swift projects on github

Click the image to see Swift language projects on GitHub.

swift kickApple’s documentation, The Swift Programming Language, is a pretty decent read, but its examples are geared around showing individual language features and not around building full-blown apps. With Swift having been released to registered Apple developers a mere three days ago and the NDA preventing the posting of screenshots of iOS 8 and Xcode 6 until their general release, we’re going to be short on books and detailed tutorials for the next few months. So how’s a developer to learn about Swift and still play within the rules of their developer agreement with Apple?

The answer: Github. More accurately, Swift projects on Github. And there are more of them than you might think.

As I write this (10:00 a.m. EDT, June 5, 2014), even though it’s been less than 72 hours since the beta of Xcode 6 (and therefore Swift) was made available for download, there are already about 350 repos on Github marked as being done in Swift. There may be more by the time you read this.

Update: As of 1:45 p.m. EDT, June 5, 2014, there are 370 Swift repos in Github.

Some of these repos are simple experiments with Swift and its syntax, some are tests of interacting with various API using Swift, some are the sort of mini-apps you build when learning a new language, and then there’s this:


That’s right: it’s an implementation of Flappy Bird in Swift. If you’ve always wanted to learn SpriteKit and now want to learn Swift, go to the FlappySwift repo on GitHub and kill two — ahem — birds with one stone.

Keep an eye on Swift projects in Github; I’m sure that their numbers will keep growing. And don’t forget to make your own contribution!


{ 1 comment }

swift kickLet’s dive into Swift! For the next several articles, I’m going to share my observations as I noodle around with Swift on the Xcode 6 beta and try to get a feel for the language.

Keep in mind that Swift is in beta, and given the loose way “beta” is defined in these agile, pivot-happy days, it could be subject to all sorts of changes that may invalidate some of what I cover here.

Example 1: No semicolons, implicitly-typed variables, basic variable types, output, and string interpolation

We’ll start off with a couple of variable declarations, and then we’ll print them out on the console. Here’s the code:

var name = "Dëathtöngüë"
var radius = 4.0
println("Hey, \(name), we're working with a radius of \(radius).\n")

And here’s its output:

Hey, Dëathtöngüë, we're working with a radius of 4.0.

No semicolons

Note that unlike Objective-C (or C, or most other languages that borrow its syntax), the lines of code above don’t end in semicolons. Swift is like JavaScript in that a line break is enough to mark the end of a statement, and ending them with semicolons is optional (much to the chagrin of the pro-mandatory-semicolon people in the Great JavaScript Semicolon Debate). You do need to use a semicolon to separate statements if you want to put them on the same line. For example, the following code compiles:

var name = "Dëathtöngüë"; var radius = 4.0;
println("Hey, \(name), we're working with a radius of \(radius).\n");

My recommendation: follow the style in Apple’s example code, be like our friends in the Lua, Python, and Ruby worlds, and don’t use semicolons to separate statements.

Implicitly-typed variables

Note that we didn’t have to specify the types of the name and radius variables. All we did was declare them with the var keyword, and then we assigned values to them:

var name = "Dëathtöngüë"
var radius = 4.0

This code is legal JavaScript, but it’s rather different underneath. JavaScript associates types with values, while Swift associates types with variables. The compiler infers the variables’ types from the values assigned to them:

  • name was assigned a string literal, which means that it should be of type String, and
  • radius was assigned a numeric literal with a decimal point, so the compiler assigned it the type Double.

This feature goes by names like type inference and implicit typing. We’ve had this in C# since late 2007, and it’s nice to see it in Swift.

Swift’s basic types

The basic types that I’ve encountered in the documentation so far are:

  • Int
  • Float
  • Double
  • Bool (whose values are true and false as opposed to Objective-C’s YES and NO)
  • String


The println() function sends output to the console. It’s capable of outputting all of Swift’s basic types without your having to convert them to String first. All of the following lines work in Swift:

println(5 * 5)
println("Five by five, chief.")

String interpolation

\() is used for string interpolation, in a manner similar to Ruby’s and CoffeeScript’s #{}.

Example 2: Defining functions, defining constants, and Unicode names

Let’s take our initial code and add a function that calculates the area of a circle, given its radius:

var name = "Dëathtöngüë"
var radius = 4.0
println("Hey, \(name), we're working with a radius of \(radius).\n")

func circleArea(circleRadius: Double) -> Double
  let π = 3.14
  return π * circleRadius * circleRadius
println("The circle's area is \(circleArea(radius)).")

Here’s its output:

Hey, Dëathtöngüë, we're working with a radius of 4.0.

The circle's area is 50.24.

Defining functions

Function headers in Swift have the following format… function headers in swift …and they’re bounded by braces — { and } — just like in Objective-C and every other C-like language. The return keyword works as you’d expect it to: it specifies the function’s return value and returns program control to whatever called the function in the first place.

There’s a lot more to function definitions, and I’ll cover than in a later article.

Defining constants

Take a closer look at the definition inside the circleArea function:

let π = 3.14

Just as var is used to declare variables, let is used to declare constants. As with variables, if there’s enough information in the value you’re assigning to the constant, the compiler will infer its type.

As you might expect, any attempt to redefine a constant results in an error. After all, a redefinable constant is a variable.

Unicode names

In our constant declaration, we used the greek letter π (which you get by typing option-p) instead of pi.Swift’s source files are Unicode, which means that you’re not limited to the Roman character set for naming things. This feature is meant to let people whose native languages with non-Roman alphabets give more meaningful names to their variables, constants, functions, classes, and so on.

As I wrote in an earlier post, it also lets you use emoji, which may be useful for amusing demos or in the event someone declares an Obfuscated Swift programming contest.

Explicitly declaring variable types

There are times when the compiler just doesn’t have enough information to infer the type of a variable. For instance, if you make the following declaration…

var someValue = 3.0

…the compiler will assume that someValue‘s type is Double. What if you need someValue to be a Float instead? You’ll need to specify its type, as shown below:

var someValue:Float = 3.0

If you need to declare a variable but don’t want to assign a value to it immediately, you’ll also have to specify its type, as the compiler won’t have enough information to infer it:

var finalScore:Int
var playerToBeNamedLater:String
var iDontFeelLikeTypingADecimalPoint:Double = 3

Example 3: Remember, Swift is a strongly-typed language

Try the following code, but take note: it won’t work!

// This code won't work!
func circleArea(circleRadius: Double) -> Double
  let π = 3.14
  return π * circleRadius * circleRadius
var floatRadius:Float = 3.0
// Here's where the error occurs:
println("The other circle's area is \(circleArea(floatRadius)).")

The problem is that you’re passing a Float to a function that expects a Double parameter. You need to convert floatRadius into a Double first. Luckily that’s pretty simple — all the basic types have conversion functions:

  • Int() takes a numeric or Bool argument and returns its Int equivalent, with the fraction removed (not rounded). The Bool value true is converted to 1, false is converted to 0.
  • Float() takes a numeric argument and returns its Float equivalent. You lose decimal precision if you use Float() on a Double, and gain some if you use it on an Int. The Bool value true is converted to 1.0, false is converted to 0.0.
  • Double() takes a numeric argument and returns its Double equivalent. You gain decimal precision if you use Double() on an Int or Float. The Bool value true is converted to 1.0, false is converted to 0.0.
  • Bool() takes a numeric or String argument and returns its Bool equivalent. As far as I can tell, only 0 equates to false; everything else — even the empty string "" — equates to true. I tried Bool(nil) and got an error.
  • String() takes a numeric argument and returns its String equivalent.

This code works, because we use Float() to convert floatRadius into a Double before passing it to circleArea():

func circleArea(circleRadius: Double) -> Double
  let π = 3.14
  return π * circleRadius * circleRadius
var floatRadius:Float = 3.0
// We have to convert floatRadius to a Double before
// passing it to circleArea().
println("The other circle's area is \(circleArea(Double(floatRadius))).")

Why all the type fussiness?

swift speed

Craig Federighi talks about Swift’s swiftness.

The payoff for all this fussiness about type is speed. As Matt Galloway writes in his Swift Language Highlights article on RayWenderlich.com:

In Swift, the compiler knows much more [than Objective-C] about the types in play in any method call. It knows exactly where [any given function or method] is defined. Because of this, it can optimise certain call sites by jumping directly to the implementation rather than having to go through dynamic dispatch. In other cases, it can use vtable style dispatch, which is far less overhead than dynamic dispatch in Objective-C. This is the kind of dispatch that C++ uses for virtual functions.


swift kickIf you’re a regular reader of this blog, chances are that you’re itching to take Apple’s new programming language, Swift, out for a spin. Global Nerdy’s largely about mobile technology these days, and since I’m looking to make it more about mobile development as well, I thought “Hey, here’s a great opportunity to write about programming and cover something new and exciting. I’ve already got my hands on the Xcode 6 beta and iOS 8, as well as Apple’s Swift programming book, and will be noodling with the language for the next little while. I’ll post my observations here, under the category “Swift Kick”.

(If you think that name is silly, my friend David Janes came up with a worse one: “Tailored Swift”. I may still use that name for a presentation.)

Swift stuff that’s available to the general public

swift site

The Swift site, located at developer.apple.com/swift/, is open to the general public and the first place you should head. Its landing page gives you a quick overview of the language and provides a number of useful links, including the online edition of the ebook The Swift Programming Language.

swift cheat sheet

There’s a reason RayWenderlich.com is one of the go-to sites for iOS developers: they’ve got great articles, and they’re quick to put out tutorials on how to use the latest iDevelopment tools. They’ve done it again by putting out a cheat sheet and reference card for Swift.

swift stack overflow

And finally, there’s a Swift tag — swift-language — in Stack Overflow, and as of this writing (2:00 pm on Tuesday, June 3, 2014), there are 155 questions with this tag.

Swift stuff that’s available to people with Apple devices

swift ibook

If you have a Mac (necessary if you want to developer for iOS) or an iPhone/iPad/iPod Touch, you can get your hands on the iBook The Swift Programming Language, which is available for free.

Swift stuff that’s available to registered developers

swift xcode

If you’re a registered iOS or OS X developer, you’ll be able to download the betas for Xcode 6 and iOS 8. Remember that this is beta code: don’t build anything that you’re putting on the market with the Xcode beta, and don’t install the iOS beta on a device that’s critical to your work!

What can we talk about? Where does the NDA apply?

Ole Bergmann points out that Apple has eased up on their NDA (non-disclosure agreement) for the iOS 8 / OS X Yosemite releases. He points to this sentence in the agreement from section 10.1, titled Information Deemed Apple Confidential:

Further, Apple agrees that You will not be bound by the foregoing confidentiality terms with regard to technical information about pre-release Apple Software and services disclosed by Apple at WWDC (Apple’s Worldwide Developers Conference), except that You may not post screen shots, write public reviews or redistribute any pre-release Apple Software or services.

It appears to mean that we can talk about material that’s covered in the Swift book, at the very least. Can anyone enlighten us and tell us what else we can talk about?



{ 1 comment }

swift kickBy allowing Unicode characters in constant and variable names, Apple’s new Swift programming language will allow programmers whose native languages don’t use the Roman alphabet to write code that makes more sense to them. Since emoji are part of the Unicode set, expect to see amusing code demos and search-and-replace pranks that look like this:

poopy swift code example

(And yes, this code compiles and runs on Swift using the XCode 6 beta.)


samsung copier

…the Samsung copier.


what software patches would look like in the physical world

I captioned this picture after finding it and being reminded of Weinberg’s Second Law: 

If builders built buildings the way programmers wrote programs, then the first woodpecker that came along would destroy civilization.

And then I thought: Didn’t he have some clever quips about consulting? A little searching found these gems I’d read about and forgotten:

weinberg's laws of consulting

Ah, Weinberg’s Laws of Consulting, from his 1985 book, The Secrets of Consulting:

  • There’s always a problem, with the corollary “Never promise more than 10% improvement”
  • It’s always a people problem, with the corollary “Whatever they’re doing, advise them to do something else”
  • They’re paying you by the hour, not the solution, with the corollary “You’ll never accomplish anything if you care who gets credit”

For more of Jerry Weinberg’s wisdom on consulting (and writing, too!), check out his Secrets of Writing and Consulting blog.


Orders of magnitude

Click the chart to see it at full size.
Feel free to use it in your articles and presentations; just credit us!

We’ve already hit the point where there are about as many mobile subscriptions as there are people. In Internet Trends 2014, Mary Meeker’s presentation for the venture capital firm Kleiner Perkins Caufield Byers, each new generation of computing carries ten times the installed base of the previous one. With desktop internet having reached one billion users and the current growth of mobile, the pattern looks like it will hold true, giving mobile 10 billion units/users.

Meeker’s presentation is a 164-slide gold mine of information and insight into the present and future of mobility. If you have anything at all to do with mobile tech, you’ll want to at least give it a quick read. We’re going to be consulting it regularly for the next little while, and doing things like taking this chart…

original kpcb orders of magnitude chart

Click the graphic to read the report.

…and sprucing it up into the one at the top of this article.

See more of our infographics on Pinterest!

gsg pinterest

Want to see more of our infographics? Keep an eye on our Pinterest page, which we’re using as a library for them. And yes, because we want to spread the knowledge, you can use our infographics in your own articles and presentations — just credit us.

this article also appears in the GSG blog