Saucony White Shoes
Xcode doesn't have a great reputation for stability, it's true. However, the time lost to re launching Xcode after a crash is miniscule compared to the amount of additional time you'll take designing, testing and debugging your layout code.
Using the Interface Builder doesn't mean that you have to use the Interface Builder for everything. You're still free to embed a custom view, set its class, and then provide a loadView method for that class to manually Saucony White Shoes create the view hierarchy for that class.
example, if you've got a view controller that needs to use a custom selector view of some kind, embedding a view that you've designed in a XIB can be a pain.
"Dealing with lingering outlets leads to crashes."
getting better and better at detecting merge conflicts. When a merge results in structurally valid XML but an invalid storyboard, Xcode will attempt to repair what it can: for example, if merging two versions results in an object connecting to an outlet that was removed, Xcode will notice it, and correct it.
"Using storyboards means designing your interfaces in Xcode, which is slow and crashy."
However, starting with Xcode 5, the Interface Builder is Saucony Grid 8000 On Feet
Embedding view controllers using container objects is straightforward. If you need to embed a collection of views elsewhere, or if you want to break out the logic of a screen into multiple sub units, use the Container View object to break out a collection of views into a separate view controller.
This was a fair criticism in Xcode 4, constraints were a huge mess, and it was very difficult to understand how re repositioning a view in the Interface Builder would affect the constraints.
Unless you care about the contents of your custom view, seeing a preview of your view isn't a requirement for constructing the rest of the screen. Positioning and sizing the view on the screen is the most useful feature, and that's what you get.
However, Xcode 5 and iOS 7 has simplified this considerably. You no longer receive a soup of vertical and horizontal blue lines, and controlling the position and size of views using constraints that you design in the Interface Builder is simple and straightforward.
Another common argument against using storyboards is that using custom views is harder. For Reebok Ventilator Supreme Grey
A related argument that we see is that custom views just look like empty white boxes in your view controller's designs. Reebok Originals
Storyboards and NIBs
(Xcode's still the worst IDE ever built, but that makes it no different to every other IDE.)
Apple vigorously promotes the Interface Builder and the use of Storyboards, but there's a surprisingly large number of developers who insist on not using them.
Technically, that's true if you drag in a generic UIView, and set the view's class to your own, it'll still appear as a generic white box. However, this argument against storyboards ignores some important facts:
Beneath the relatively placid surface, a battle is raging among iOS developers.
Google aren't the only ones insisting that storyboards aren't a good idea. There are dozens of examples of developers promoting this viewpoint, and here are the most common arguments we see.
"Programmers should code, and not do visual design. You should know how views work from the ground up, and being able to code your interface is more extensible."
A number of important, Apple provided views also appear as empty boxes. The point isn't that you get to see the content, but rather that positioning and arranging the view in the screen is significantly more straightforward.
A good programmer knows more than just than their specialty. The argument that programmers should only focus on the written component of their apps implies a separation of skills that simply isn't workable in mobile apps: if you're making an application that relies on the user holding a screen in their hand, deliberately not thinking visually means that you'll be more likely to not catch small visual problems in your app's design.
Auto Layout has received a significant amount of criticism since it was introduced, and many developers argue that the older method of struts and springs (as well as defining frame rectangles for each view) is easier to understand.
It's a common situation: you link a view to a class using an outlet; later, you decide you don't need the outlet, so you delete it from your code. You run the app, but the view still wants to connect to the now deleted outlet. Your code crashes. You scream with rage.
"Creating re usable views is harder. Also, custom views are hard to see in IB, they're just white boxes."
This is a reasonable criticism Xcode should at least provide a more visible warning that the property is missing. However, it's nowhere near enough of a reason to forswear ever using it.
"Auto Layout sucks, and doing the layout yourself is easier to understand."
There's a lot to be said for understanding views and view controllers from the ground up, for the same reasons as understanding any other topic in programming: knowing as much as possible about what's going on behind the scenes makes it easier for developers to make more advanced use of the technology. However, this isn't an argument for avoiding the Interface Builder understanding how views work doesn't require that you manually create them in your code.
On one side, we have developers who use the built in visual interface development tools for constructing their screens. On the other, we have the code purists, who insist on entirely generating their interfaces from code.
Saucony White Shoes
Reebok Pump Basketball Shoes