Now that the dust has settled somewhat on Swift, the new language on the block for developing iOS and OSX applications, we take a look at its impact and improvements over its predecessor, Objective-C. Apple claims Swift to be a modern, safe, and powerful language for developing for iOS and OSX. Just how powerful is Swift compared to the venerable Objective-C? And how does it make developing applications easier and safer? In this article, I will walk you through some of the important features in Swift and how it improves on Objective-C. In a follow up article, I will show you how you can use Swift and Objective within the same project.
Why is Swift Important?
While Apple intended to use Swift as the de facto language for writing iOS and OSX apps, its birth definitely has an impact on the computing world and the long-term future of programming languages.
With Swift, Apple aims to address the number one complaint of iOS and OSX developers: that Objective-C is showing its age and is a difficult-to-learn language, especially with its arcane syntax, and memory-management pitfalls. Developers coming from modern languages like C# and Java often struggled with learning Objective-C, and this is something that Apple desperately needed to address in the long term if it want to maintain iOS as an enticing platform for developers.
As you will see in this article, Swift addresses a lot of the shortcomings in Objective-C, making it far simpler, even for beginners, to come up with a simple app in a short amount of time. With the new, interactive Playgroundtool in Xcode 6, learning Swift has never been easier. And this is where Apple is spot on – by making it easy to learn and test the code, Apple hopes to make the language more approachable, and hence encourage a new group of self-taught programmers to develop the next generations of apps. Playground allows you to type in the code and see the result instantly. Make a change to your code and your program will immediately change: instant gratification!
Instant gratification with the interactive Playground tool (source: Apple)
Developer’s Love it!
Languages come and go, and with Swift, there is a huge motivation for developers to learn the language. With many languages, one might spend some time to learn the new syntax, and often the next thing that happens is that interest is lost as the developer moves on to other more interesting projects. With Swift, more so than most other languages, there is a huge enticement to get onboard: the lure of the AppStore and the 800 million iOS devices that are waiting to run your latest creation.
Not only must a language be able to address all the key computing challenges, it must be easy to learn, and there must be an inherent appeal to pique developers’ interest. In addition, there needs to be an abundance of innovative tools to ensure that the language is accessible and fun.
Apple is ticking all the right boxes with Swift, and developers loved it right from the start. With the first Swift app publicly released on 2nd June 2014, it didn’t take long for developers to line up. Within hours, Flappy Swift, a Flappy Bird clone, was written in Swift and released into the wild. Underscoring the simplicity of the language, the developer, Nate Murray, said “It took me about four hours to read the e-book on programming Swift and put it together“.
Flappy Swift in action, with an excerpt of its Swift code behind (source: Flappy Swift github)
Wider impact of Swift
With the release of Swift, all eyes are now on Google, who’s Android platform, in contrast to iOS, is still reliant on a language that it does not own: Java. Since 2010, Google has been embroiled with Oracle in a legal battle over the use of the Java APIs in Android, the ultimate outcome of which will have a big impact on both Android and software development in general. It could indeed be hugely expensive for Google, and at the same time stymie the evolution of Android. Having its own Swift might not be a bad thing for Android.
And while Java is not really comparable with Objective-C in terms of developer-unfriendliness, Swift has elicited many a green-eyed side-glance from Android developers. Proponents of Dart (Google’s own Web programming language) have been suggesting Google adopt its own language for Android, where doing so will give it more control over the progression of the language and platform. Indeed, Google may be forced to do so very soon, as they have already witnessed throngs of mobile developers moving to other toolsets (such as Xamarin, PhoneGap, and Titanium) that do not use native languages such as Objective-C and Java.
As pointed out by Christian Grobmeier, Swift “looks pretty similar to Dart actually”. If iOS developers can benefit from more modern programming concepts, then why not Android developers too?
Swift: Objective-C without the C
So exactly how has Apple achieved these improvements? During its announcement at WWDC 2014, Swift was described as Objective-C without the C. In the following sections we take a look at some specifics of exactly how Swift makes iOS app development easier. And what better way to do it than by looking at some of the differences between Objective-C and Swift.
Type Inference
In Objective-C, you have to explicitly specify the data type of variables when you declare them:
|
1 2 |
int num = 5; float degrees = 3.25; |
In Swift, the compiler will automatically infer the type of variables/constants that you are declaring:
|
1 2 3 4 |
let columns = 3 // columns is inferred to be Int var num = 5 // num is inferred to be Int var degrees = 3.25 // degrees is inferred to be Double var str = "Wei-Meng Lee" // str is inferred to be String |
In Swift, you use the let keyword to declare a constant and the var keyword to declare a variable.
Of course, you can also explicitly declare the type of a variable/constant. This is especially useful if you:
- Are not assigning an initial value to a variable during declaration time, or
- Do not like the default data type inferred by the compiler
For example, the following example declares score to be of type Float and then assigns it a value:
|
1 2 |
var score: Float score = 78.9 |
You can also rewrite the above by combining the two statements:
|
1 |
var score: Float = 78.9 |
The above example is also useful because you explicitly declare score to be of type Float. If you simply let the compiler infer the type, score would be inferred to be of type Double, rather than Float:
|
1 |
var score = 78.9 // the compiler will infer score to be Double |
Tuples – Compound Variables
In Objective-C, a method can return at most one value. If you want to return multiple values, you can resort to a number of ways:
- using inout parameters to return values after a method call
- returning objects or structures containing the values you want to return
In Swift, there is a neater way – tuples. A tuple is an order collection of values. The values inside a tuple can be of any type and need not be of the same type. The following shows an example of a tuple:
|
1 |
var pt = (7,8) |
To access the individual elements inside a tuple, you can use its index, starting from 0, like this:
|
1 2 |
println(pt.0) // 7 println(pt.1) // 8 |
The following function returns a tuple:
|
1 2 3 |
func doSomething() -> (Int, Int) { return (5,6) } |
When you call the function it returns a tuple, which you can then access, its individual elements:
|
1 2 3 |
pt = doSomething() println(pt.0) // 5 println(pt.1) // 6 |
Improved String Handling
One of the key complaints by programmers learning Objective-C for the first time is that of string handling. The class dealing with strings in Objective-C is the notorious NSString class. To relive the horror, consider the case that you want to create a string containing the value of a number. You have to do the following:
|
1 2 3 |
int num = 5; NSString *str1 = [NSString stringWithFormat:@"The value of num is %d.", num]; |
You have to use the stringWithFormat: method of the NSString class to create a string that combines some text with a number. The nightmare continues if you try to concatenate two strings:
|
1 2 |
NSString *str2 = @"Objc-C string is awful!"; str1 = [NSString stringWithFormat:@"%@ %@", str1, str2]; |
With Swift, strings handling is now much more straightforward and easy. The above could be rewritten using the String type in Swift, like this:
|
1 2 3 4 |
var num = 5 var str1 = "The value of num is (num)" var str2 = "Objc-C string is awful!" str1 = str1 + ". " + str2 |
The () syntax is know as string interpolation. Put any variable within the parentheses and it will return a string.
One added bonus is that all the APIs in the NSString class that you have painstakingly taken years to learn and master are available in Swift – by type casting a String instance to an NSString object:
|
1 2 3 4 5 6 7 |
println((str1 as NSString).containsString("Objective-C")) println((str1 as NSString).length) println((str1 as NSString).hasPrefix("The")) println((str1 as NSString).hasSuffix("!")) println((str1 as NSString).uppercaseString) println((str1 as NSString).lowercaseString) println((str1 as NSString).capitalizedString) |
New Types – Optionals
Swift introduces the new optional types. An optional type means that a variable can either have a value, or nil if it does not have one. To understand the rationale for optionals, consider the following example in Objective-C:
|
1 2 3 |
NSString *strNum = @"2,500"; int num = strNum.integerValue; int result = num + 1500; |
In the above you are trying to convert the strNum variable to an integer value. Because the strNum variable contains a comma in it, the conversion incorrectly returns 2 instead of the expected 2500. This will cause the statements after it to incorrectly perform its calculation. Ideally, the integerValue property of the NSString class should return a nil to indicate that the number cannot be converted to an integer value correctly.
In Swift, the above statements would look like this:
|
1 2 |
let strNum = "2,500" var num = strNum.toInt() |
However, note that since the conversion from 2,500 fails, the toInt() method does not return a 2. Instead it returns a nil. And because num can now either contain a valid integer value, or nil, the type of num is now inferred to be Int?. The ? indicates that num is of type Integer optional.
To access the value of num, you need to first of all check if it is a nil. Only if it is not a nil can you access it by appending the ! character to the end of num, like this:
|
1 2 3 |
if num != nil { var result = num! + 1500 } |
Besides using type inference, you can explicitly declare a variable to be an optional type. For example, the following statement declares description to be a String optional:
|
1 |
var description: String? |
You can assign a value to an optional type:
|
1 |
description = "Some description here..." |
Or set it to nil:
|
1 |
description = nil |
When dealing with optional types, you should check that it is not nil before accessing it value or methods/properties. For example, you need to ensure that description is not nil before calling its properties, such as uppercaseString:
|
1 2 3 |
if description != nil { description!.uppercaseString } |
Because checking an optional for non-nil is so common, you can actually use the following shortcut:
|
1 |
description?.uppercaseString |
The above statement reads: “If description is not nil, then call its uppercaseString property”.
Improved Enumerations
In Swift, enumerations are much improved. Consider the following enumeration definition in Objective-C:
|
1 2 3 |
typedef enum { Black, White, Red, Green, Yellow } BagColor; |
To use the BagColor enum, you declare a variable of BagColor, and then assign it a value within the enum:
|
1 2 |
BagColor colorOfBag; colorOfBag = Black; |
The first problem is that you often have a lot of difficulty knowing the members in an enumeration. Code completion in Xcode could not help without needing you to read the definition of the enumeration. Second, often you need to save the value/print the value of an enumeration type so that you can persist the data. For example, you might want to print out the color of the bag as “B” if it is Black, “W” if it is White, and so on. In Objective-C, you often have to implement your own method to do this, like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
-(NSString *) colorToString:(BagColor) bagColor { switch (bagColor) { case Black: return @"B"; break; case White: return @"W"; break; case Yellow: return @"Y"; break; case Green: return @"G"; break; case Red: return @"R"; break; } } |
You then have to pass in the enumeration type into this method in order to get its string equivalent:
|
1 2 3 |
BagColor colorOfBag; colorOfBag = Yellow; NSLog(@"%@", [self colorToString:colorOfBag]); // Y |
In Swift, you could simply declare the enumeration as follows:
|
1 2 3 4 5 6 7 |
enum BagColor: String { case Black = "B" case White = "W" case Red = "R" case Green = "G" case Yellow = "Y" } |
To print out its string equivalent, use the rawValue property:
|
1 2 3 |
var colorOfBag:BagColor colorOfBag = BagColor.Yellow println(colorOfBag.rawValue) // Y |
To convert a string back to its equivalent enumeration value, use the rawValue: method:
|
1 2 |
var colorOfSecondBag:BagColor? = BagColor(rawValue:"G") |
Note that colorOfSecondBag is declared to be of type BagColor optional. This is because there is a possibility of passing in a string (such as “P”) that does not match any of the colors in the enumeration.
Switch on Steroids
The Switch statement in Swift in now on steroids. To understand why I said so, read on.
First, there is no more implicit fallthroughs – after each case is matched, it automatically exits the switch statement.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
var day = 6 var dayOfWeek: String switch day { case 1: dayOfWeek = "Monday" case 2: dayOfWeek = "Tuesday" case 3: dayOfWeek = "Wednesday" case 4: dayOfWeek = "Thursday" case 5: dayOfWeek = "Friday" case 6: dayOfWeek = "Saturday" case 7: dayOfWeek = "Sunday" default: break; } println(dayOfWeek) //---prints Saturday--- |
With this enhancement, it eliminates a lot of bugs that we inadvertently introduced into our Objective-C code, and indeed many other languages, simply by forgetting to insert the break keyword into the end of each case.
You can also match characters in a Switch statement:
|
1 2 3 4 5 6 7 8 9 10 |
var grade: Character grade = "A" switch grade { case "A", "B", "C", "D": println("Passed") case "F": println("Failed") default: println("Undefined") } |
In certain conditions, fallthroughs are still useful. Swift supports explicit fallthroughs using the fallthrough keyword:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
var grade: Character grade = "A" switch grade { case "A": fallthrough case "B": fallthrough case "C": fallthrough case "D": println("Passed") case "F": println("Failed") default: println("Undefined") } |
You can also match ranges in a Switch statement:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
var percentage = 85 switch percentage { case 0...20: println("Group 1") case 21...40: println("Group 2") case 41...60: println("Group 3") case 61...80: println("Group 4") case 81...100: println("Group 5") default: println("Invalid percentage") } |
Matching ranges also applies to tuples:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//---(math, science)--- var scores = (70,40) switch scores { case (0,0): println("This is not good!") case (100,100): println("Perfect scores!") case (50...100, _): println("Math passed!") case (_, 50...100): println("Science passed!") default: println("Both failed!") } |
You can perform conditional checking within a case by performing value bindings in a Switch statement:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//---(math, science)--- var scores = (40,60) switch scores { case (0,0): println("This is not good!") case (100,100): println("Perfect score!") case (50...100, let science): println("Math passed!") if science<50 { println("But Science failed!") } else { println("And Science passed too!") } case (let math, 50...100): println("Science passed!") if math<50 { println("But Math failed!") } else { println("And Math passed too!") } default: println("Both failed!") } |
You can even specify a where clause within a case!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//---(math, science)--- var scores = (90,90) switch scores { case (0,0): println("This is not good!") case (100,100): println("Perfect score!") case let (math, science) where math > 80 && science > 80: println("Well done!") case (50...100, let science): println("Math pass!") if science<50 { println("But Science fail!") } else { println("And Science also pass!") } case (let math, 50...100): println("Science pass!") if math<50 { println("But Math fail!") } else { println("And Math also pass!") } case let (math, science): println("Math is (math) and Science is (science)") } |
Summary
In this article, we’ve looked at a variety of features in Swift that makes it a modern and safe language. It is clear that Swift is a much more developer-friendly language than Objective-C, and has lowered the barrier-to-entry for iOS development.
We’ve also tried to take a look at Swift in the broader context of app development in general, and to put it in perspective with other platforms. Traditionally, Android has had a somewhat lower barrier-to-entry for developers, with more development tools and platforms available to use. The introduction of Swift has leveled the playing field to a certain extent, and has arguably tipped the balance a little too. However, while serious Android developers are unlikely to abandon the platform altogether simply because another platform has better development tools, the draw of well thought-out and easy-to-use tools should not be underestimated.
It also begs the question of whether Google has plans to launch new Android tools. As many developers have suggested, Google’s Dart programming language might make a good fit for Android, and shares at least some of the beneficial simplicity of Swift.
Leave a Reply