Apple's New Programming Language Swift Highlights

Swift
Apple’s New Programming Language
Sasha Goldshtein
CTO, Sela Group
blog.sashag.net @goldshtn
Join the conversation on Twitter: @SoftArchConf #SA2014
This presentation: http://s.sashag.net/sa-swift

Apple WWDC Announcements
• iOS 8 and OS X Yosemite
• Xcode 6
• Swift

Minus Bazillion Points
“Every feature starts out in the hole by 100
points, which means that it has to have a
significant net positive effect on the overall
package for it to make it into the language.”
– Eric Gunnerson, C# compiler team
If a language feature starts at -100 points,
where does a new language start?!

Objective-C Popularity
• Objective-C owes all its popularity to the
meteoric rise of the iPhone
App Store introduced

What’s Wrong with Objective-C
Exhibit One
// Ignore the horrible syntax for a second.
// But here's the charmer:
// 1) if 'str' is null, we return NSNotFound (232-1)
// 2) if 'arr' is null, we return 0
+ (NSUInteger)indexOfString:(NSString *)str
inArray:(NSArray *)arr
{
return [arr indexOfObject:str];
}

Exhibit Two
// This compiles and crashes at runtime with:
// "-[__NSArrayI addObject:]: unrecognized selector
// sent to instance 0x7a3141c0"
NSMutableArray *array = [NSArray array];
[array addObject:@"hello"];

Exhibit Three
NSMutableArray *array = [NSMutableArray array];
[array addObject:@"hello"];
[array addObject:@17];
// This compiles just fine
NSString *string = array[1]; // Yes, the "17"
// This works and prints 17
NSLog(@"%@", string);
// But this crashes
NSLog(@"%@",
[string stringByAppendingString:@"hmm"]);

Swift Language Principles
• Clean and modern
• Type-safe and generic
• Extensible
• Functional
• Productive
• Compiled to native
• Seamlessly interops with Objective-C

Why Not an Existing Language?
• Good philosophical question
• If you want some more philosophy:
http://s.sashag.net/why-swift
We will now review some of the interesting
language decisions, which make Swift
different from mainstream languages

Variables and Constants
let size = 42
let name = "Dave"
var address = "14 Franklin Way"
address = "16 Calgary Drive"
var city: String
city = "London"
var pi: Double = 3.14

Strings and Arrays
var fullAddress = city + " " + address
println("(name)'s at (city.capitalizedString)")
var customers = ["Dave", "Kate", "Jack"]
var addresses = [String]()
addresses += fullAddress
if customers[2].hasPrefix("Ja") {
customers.removeAtIndex(2)
}

Dictionaries
var orderSummary = [
"Dave": 11000,
"Kate": 14000,
"Jack": 13500
]
orderSummary["Kate"] = 17500
for (customer, orders) in orderSummary {
println("(customer) -> (orders)")
}

Null
“I call it my billion-dollar mistake. It was the
invention of the null reference in 1965. […] I
couldn't resist the temptation to put in a null
reference, simply because it was so easy to
implement. This has led to innumerable
errors, vulnerabilities, and system crashes,
which have probably caused a billion dollars
of pain and damage in the last forty years.”
– Sir Charles Antony Richard Hoare,
2009

Optional Types
var myName: String
myName = nil // Does not compile!
var jeffsOrders: Int?
jeffsOrders = orderSummary["Jeff”]
if jeffsOrders {
let orders: Int = jeffsOrders!
}
var customerName: String? = getCustomer()
println("name: (customerName?.uppercaseString)")

Pattern Matching
switch milesFlown["Jeff"]! {
case 0..<25000:
println("Jeff is a Premier member")
case 25000..<50000:
println("Jeff is a Silver member")
case 50000..<75000:
println("Jeff is a Gold member")
case 75000..<100000:
println("Jeff is a Platinum member")
default:
println("Jeff is an Elite member")
}

Pattern Matching
switch reservation.fareClass {
case "F", "A", "J", "C":
milesBonus = 2.5 // business/first
case "Y", "B":
milesBonus = 2.0 // full-fare economy
case "M", "H":
milesBonus = 1.5 // top-tier discount economy
case let fc where fc.hasPrefix("Z"):
milesBonus = 0 // upgrades don't earn miles
default:
milesBonus = 1.0
}

Functions and Tuples
func square(x: Int) -> Int { return x * x }
func powers(x: Int) -> (Int, Int, Int) {
return (x, x*x, x*x*x)
}
// The first tuple element is ignored
let (_, square, cube) = powers(42)

Closures
func countIf(arr: [Int], pred: (Int) -> Bool) {
var count = 0
for n in arr { if pred(n) { ++count } }
return count
}
countIf([1, 2, 3, 4], { n in n % 2 == 0 })
var squares = [17, 3, 11, 5, 7].map({ x in x * x })
sort(&squares, { a, b in a > b })
sort(&squares) { a, b in a > b }
sort(&squares) { $0 > $1 }

Swift REPL
DEMO

Classes
class FrequentFlier {
let name: String
var miles: Double = 0
init(name: String) {
self.name = name
}
func addMileage(fareClass: String, dist: Int) {
miles += bonus(fareClass) * Double(dist)
}
}

Custom Properties and
Observers
class MileageStatus {
var miles: Double = 0.0 {
willSet {
assert(newValue >= miles)
// can't decrease one's mileage
}
}
var status: String {
get { switch miles { /* ... */ } }
}
}

Smart Enums
enum MemberLevel {
case Silver
case Gold
case Platinum
func milesRequired() -> Int {
switch self {
case .Silver: return 25000
case .Gold: return 50000
case .Platinum: return 75000
}
}
}

Stateful Enums
enum HttpResponse {
case Success(body: String)
case Error(description: String, statusCode: Int)
}
switch fakeHttpRequest("example.org") {
case let .Error(desc, status) where status >= 500:
println("internal server error: (desc)")
case let .Error(desc, status):
println("error (status) = (desc)")
case .Success(let body):
println("success, body = (body)")
}

Extensions
extension Int {
var absoluteValue: Int {
get { return abs(self) }
}
func times(action: () -> Void) {
for _ in 1...self {
action()
}
}
}
5.times { println("hello") }
println((-5).absoluteValue)

Generics
class Queue<T> {
var items = [T]()
var depth: Int {
get { return items.count }
}
func enqueue(item: T) {
items.append(item)
}
func dequeue() -> T {
return items.removeAtIndex(0)
}
}

Operators
struct Complex {
var r: Double, i: Double
func add(z: Complex) -> Complex {
return Complex(r: r+z.r, i: i+z.i)
}
}
@infix func +(z1: Complex, z2: Complex) -> Complex {
return z1.add(z2)
}

Custom Operators (Oh My!)
operator prefix &*^%!~ {}
@prefix func &*^%!~(s: String) -> String {
return s.uppercaseString
}
operator infix ^^ { associativity left }
@infix func ^^(a: Double, b: Double) -> Double {
return pow(a, b)
}
println(&*^%!~"hello") // prints "HELLO"
println(2.0^^4.0) // prints 8.0

Swift and Objective-C

Building an iOS app with Swift
DEMO

Wrapping Up
• Most iOS developers are extremely
excited about Swift
• Swift has a much smoother learning curve
and fixes many Objective-C mistakes
• For the foreseeable future though, we will
still use both languages

Sasha Goldshtein
blog.sashag.net
@goldshtn
s.sashag.net/sa-swift
Thank You!

Apple's New Programming Language Swift Highlights

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Apple's New Programming Language Swift Highlights

Similar to Apple's New Programming Language Swift Highlights (20)

More from Sasha Goldshtein

More from Sasha Goldshtein (20)

Recently uploaded

Recently uploaded (20)

Apple's New Programming Language Swift Highlights

Editor's Notes