The current version 3.1 has come a long way from the Yet-Another-C-Based-Syntax of the 1.0 version of Swift.
One of the best features of Swift is how functional programming idioms are integrated into the core of the language. Like JavaScript, you can code in Swift in several methodologies, including procedural, declarative, object-oriented, and functional. I find it’s best to use all of them all simultaneously! It’s easy to become a victim of the law of diminishing returns if you try to stick to one programming idiom. Swift is a very expressive coding language and it’s economical to use different styles for different tasks in your program.
This might be hard for non-coders to understand but coding style is critical for creating software that functions well because a good coding style makes the source easy to read and easy to work with. Sometimes you have to write obscure code for optimization purposes but most of the time you should err of the side of clarity.
Apple has made a few changes to Swift that help with readability in the long term but remove traditional C-based programming language syntax that old-time developers like me have become very attached to.
The most famous example was the increment operator:
x++ // add one to the value of x
In modern Swift you have to write:
x += 1 // add one to the value x in Swift
As much as I loved to type ++ to increment the value of a variable there was a big problem with x++! Most coders, including me, were using it the wrong way! The correct way for most use cases is:
++x // add one to the value of x before using x
Most of the time the difference in side effects between ++x and x++ were immaterial, except when it wasn’t and it created hard to track down bugs in code that looked perfectly ok.
So now I’m used to typing += to increment values even in programming languages where ++ is legal. (Also, C++ should rebrand itself as C+=1.)
Another big change for me was giving up for-loops for functional expressions like map, reduce, and filter. As a young man when I wanted to find a particular object in an array of objects I would loop through the array and test for a key I was interested in:
for o in objects {
if o.id == 12345 {
// do something
break;
}
}
Nothing is wrong with this code-it works. Well, actually there is a lot wrong with it:
- It’s not very concise
- I should probably have used a dictionary and not an array
- What if I accidentally try to change o or objects inside this loop?
- If objects is a lengthy array it might take some time to get to 12345
- What if there is more than one o with the id of 12345?
- This for-loop works but like x++: it can be the source of subtle, hard to kill bugs while looking so innocent.
But I’ve learned a new trick! In Swift I let the filter expression do all this work for me!
let o = objects.filter { $0.id == 12345 }.first!
In that single line of code o will be the first object that satisfies the test id == 12345. Pretty short and sweet!
At first, I found the functional idiom of Swift to be a little weird looking. By weird I mean it looks a lot like the Perl programming language to me! But I learned to stop being too idiomatic and to allow myself to express functional syntax as needed.
For you JavaScript or C programmers out there here is a cheat sheet to understanding how this functional filtering works:
- let means o is a constant, not a mutable variable. Functional programing prefers constants because you can’t change them accidentally!
- The { } represents a closure that contains a function and Swift has special syntactic sugar that allows you to omit a whole bunch of typing if the function in the closure is the last or only parameter of the calling function. (Remember in functional programming functions are first class citizen and can be pass around like variables!)
- $0 is a shortcut for the first parameter passed to your closure. So you don’t have to bother with throw away names like temp or i,j,k,x, or y.
- .first! is a neat way to get [0], the first element of an array. The ! means you know it can’t fail to find at least one element. (Don’t use the ! after .first unless you are 100% sure your array contains what you are looking for!)
I’m working on a new project, a game that I hope to share with you soon. The game itself won’t be very interesting. I find that I enjoy creating games more than I enjoy playing them so I’m not going to put too much effort in creating the next Candy Crush or Minecraft. But I will blog about it as I work thought the problems I’ve set for my self.