iOS Interfaces with Xcode Playgrounds

iOS Interfaces with Xcode Playgrounds

We all love great interfaces, right? Nice designs, great colors, some crazy effects and so on. Well, on iOS we have several ways to build those marvellous artboards sketched by our fellow designers. We can use the Interface Builder and/or we can basically code it.

Interface Builder (IB)

With Interface Builder we can easily add views, move them around, change their properties, preview directly what we are doing and most importantly… it is possible and very intuitive to define the right layout for different screens with AutoLayout. It seems to be the perfect GUI tool, right? Well, not really. The Interface Builder is great if you use a lot of standard UIKit views but if you need, e.g., a custom border or a nice shadow effect, then you need to create a custom view and implement those changes by hand.

Inside of the Interface Builder we can use Storyboards and/or XIB files. Storyboards allow us to build a complete interface and flow really fast. We can define the view layout, view relations and view transitions directly in one file. It also gives us a really nice app overview. XIB files are basically the face of a view. One Storyboard file can hold multiple view controllers but one XIB file can only hold one view controller.

Figure 1: Storyboard is a container format in Interface Builder

Storyboards have some flaws. They are difficult to reuse and they are not collaborative friendly (merge conflicts may be difficult to solve). They are great for single developers and small projects but not recommended for complex applications. On the other hand, XIB files are more reusable and less likely to have conflicts, but even so, if the app has been designed to use a unique look and feel, then writing your interface with code is the right option.

The Interface Builder is great to use as a shortcut, as a temporary simplification of the interface because it lets you move faster from the idea to product, helping you focus more on shipping and less on diversions.

Benefits of Code

With code we have a future-proof process - we can reuse each view more easily, we are aware of UIKit upgrades, have more flexibility to write good tests, it’s easier to fix merge conflicts, and we can use any compatible IDE like AppCode. On the downside, it can also be a bit frustrating: there is no preview, constraining views and layout their position on the screen isn’t as intuitive as a GUI.

What about seeing your changes directly on your simulator?

Interface with Playgrounds

Playgrounds were included in Xcode version 6.0 and with them it is possible to explore Swift syntax and functionalities, create learning environments for others and most importantly for this post: *Prototype parts of your app*.

A playground is an interactive Swift coding environment that evaluates each statement and displays results as updates are made, without the need to create a project.

Let’s see what we can do with Playgrounds - we can get started with a new Playground file, but it will be more interesting if we use a project.

Figure 2: Xcode - quick start

So, let’s create a new Single View Application project.

Figure 3: Xcode - new project

Don’t forget to select the Swift language option.

Figure 4: Xcode - project language

Go to the left bottom and select the option New playground. You can also do this with the shortcut ⌘ + N and select iOS > Source > Playground.

Figure 5: Xcode - new playground

Give it a nice name.

Figure 6: Xcode - playground name

We now have our Playground file.

Figure 7: Xcode - Playground file

Go to the Utilities > File Inspector and check if the Playground is using the iOS platform.

Figure 8: Xcode - iOS platform

Now we want to focus our environment just for our Playground. Hide the Navigator panel (⌘ + 0) and the Utilities panel (⌘ + ⌥ + 0) and write down some code. E.g.: Create a view and see the results:

var square = UIView()
square.backgroundColor = .greenColor()
square.frame = CGRectMake(0, 0, 50, 50)

Figure 9: Xcode - playground environment

Maybe you were expecting to see something more visual. You can achieve that by calling the Assistant Editor (⌘ + ⌥ + ↩︎). Then, you need to select the Timeline item from the Group Files.

Figure 10: Xcode - playground with assistant editor

You also need to import XCPlayground on your Playground and assign the current view to show on the Timeline. Now, it is possible to view your code changes in real time.

Figure 11: Xcode - playground timeline

This is a basic example but everyone knows that our apps need much more than that and most of the times we want to use some wonderful third-party library. You can use CocoaPods to include third-party code in your project.

Open your terminal, go to your project path, create the Podfile (pod init), add the pod Eureka (pod 'Eureka') and at last… install it (pod install). After that, open your .xcworkspace file and build the project (⌘ + B).

Eureka will help to create a simple table with static rows for our next example. Now you can import Eureka to you Playground and play! 😎

Gist: Eureka example

Figure 12: Xcode - Eureka example

I have something more… something especial: the Xcode 7.3 beta 3 has interactive Playgrounds 🎈🎈🎈 that allow us to click, drag, type the interface that you just coded.

Gist: Interactive example (Xcode 7.3 beta 3)

Figure 13: Xcode - interactive playground

Isn’t it awesome to code your interface and see the final result? And most of all, you can interact with it and verify if what you’re coding is what you really want to. Imagine the time that you spend animating a view. That’s it… this is also a really nice tool to animate your views because it provides you with several great tools to achieve the perfect timing for your animations. I have no doubt that I will use Playgrounds more than ever and pass it along to my dev colleagues.

#product-development #the-forge

Ricardo Pereira

More posts

Share This Post

Right Talent, Right Time

Turnkey technical teams and solo specialists
when you need them for greatest impact.

Work with us