This document provides an introduction to the Swift programming language. It discusses key Swift concepts like variables and constants, comments, flow control, strings, typing, optionals, arrays, dictionaries, enums, sets, functions, closures, and object-oriented programming support. The document demonstrates syntax for these concepts and notes advantages of Swift like strong typing and readability of its syntax compared to earlier Apple languages like Objective-C. It directs readers to Apple's developer site for more information on Swift.

1. A Modest
Introduction
To Swift
pdx.pm
10 Mar 2016
John SJ Anderson
@genehack

2. Sorry!

3. Swift?

4. Introduced in 2014

5. Went Open Source
at version 2.2

6. Originally MacOS only

7. Now on Linux too.

9. Android in the works!

11. (Windows coming soon too)

12. Originally targeted
MacOS, iOS,
watchOS, and tvOS

13. With expanded platform
support, offers obvious
"single-language stack"
advantages a la Node

14. So what's it like, man?

15. First, a brief digression…

16. How many MacOS / iOS
users do we have here?

17. How many MacOS / iOS
developers do we have?

18. The dirty little secret of
developing for Apple

19. From In The Beginning
Was The Command Line
by Neal Stephenson

20. Weird Pascal-based
naming and calling
conventions

21. HANDLES?!?

22. ObjectiveC's "syntax"

23. Swift is the Mac of Apple
programming languages

24. Swift Syntax

25. Comments
// this is a comment

26. Comments
/* this is a
multi-line
comment */

27. Comments
/* this is a
_nested_
multi-line comment, */
which is cool! */

28. Variables
var foo = 1
var bar: Int
var baz = "whee!"

29. Variables
let bar = 1
bar += 1 // compile time error!

30. Variables
let bar // also a compile time error
/*
You canNOT have an uninitialized and
untyped variable. You also can't use
an initialized variable _at all_
*/

31. How friggin' awesome is that?

32. Operators

33. Flow Control
let n = 1
if n > 1 {
print("we got a big N here")
}

34. Flow Control
let arr = [ 1, 2, 3, 4]
var sum = 0
for elem in arr {
sum += elem
}
// sum now is 10

35. Flow Control
for index in 1 ... 10 {
# do something 10 times
}

36. Flow Control
for index in 1 ..< 10 {
# do something 9 times
}

37. Flow Control
var countDown = 5
while countDown > 0 {
countDown--
}

38. Flow Control
var countUp = 0
repeat {
countUp++
} while countUp < 5

39. Flow Control
let sample = 2
switch sample {
case 0:
print("Is 0")
case 2:
print("Is 2")
default: // mandatory when cases not exclusive
print("Not 0 or 2, is it.")
}

40. Flow Control
let sample = "foo"
switch sample {
case "foo":
print("Is foo")
case "bar":
print("Is bar")
default: // mandatory when cases not exclusive
print("Not foo or bar, is it.")
}

41. Flow Control
let sample = ("foo", 2)
switch sample {
case ("foo", 2):
print("Is foo, 2")
case ("bar", _):
print("Is bar")
default: // mandatory when cases not exclusive
print(" ¯_( )_/¯ ")
}

42. Flow Control
let sample = ("foo", 2)
switch sample {
case ("foo", "bar"):
print("Is foo, bar")
case (let one, let two):
print("Is (one) and (two)")
default: // mandatory when cases not exclusive
print(" ¯_( )_/¯ ")
}

43. Strings
var myString = "this is a string"
if myString.isEmpty {
// do something
}
myString += "and this is a longer string"

44. Swift is very strongly typed.

45. Typing
var foo = 1 // foo is an Int
var bar: Int // bar is an uninit'd Int
var baz = Int()
if baz is Int {
print("Nice Int you got there")
}

46. Casts
var foo = 1 // foo is an Int
var bar = String(foo) // "1"
var maybeBaz = stringishThing as? String
// maybeBaz is an optionally typed String
var forceBaz = stringishThing as! String

47. Optional Types
// When a variable may not have a value
var bar: Int?
// test
if bar != nil {
// has a value
}

48. Optional Types
// unwrap the value to use
if bar != nil {
bar! += 2
}
// unwrapping nil --> runtime exception!

49. if-let
var bar: Int?
if let foo = bar {
// bar had a value & foo now does too
}
else {
// bar was nil
}

50. if-var
var bar: Int?
if var foo = bar {
// bar had a value & foo now does too
// foo is mutable
foo++
}
else {
// bar was nil
}

51. Tuples
let tuple = ("foo", 42)
let first = tuple.0 // "foo"
let labeledTuple = (one: "foo", two: 42)
let second = labeledTuple.two // 42

52. Arrays
let nums = [1, 2, 3]
var strs : [String]
// _can_ mix & match
let mixed = [1, "foo"]
// but you probably shouldn't

53. Dictionary
let orCityCounties = [
"Salem": "Marion",
"West Salem": "Polk",
]
// orCityCounties has type
// [String:String]

54. Dictionary
// again can mix & match
let orCityCounties = [
"Salem": "Marion",
"West Salem": 2,
]
// orCityCounties has type
// [String:NSObject]

55. Enumerations
enum SalemMeetups {
case HackSalem
case PortlandPerlMongers
}
var thisMeetup = SalemMeetups.HackSalem
// thisMeetup is type SalemMeetups

56. Sets
var petSet :Set = [ "cat", "dog",
"fish", "dog"]
petSet.count // returns 3

57. Functions
func obExample () {
print("Hello, Salem!")
}

58. Functions
func obExample (who :String) {
print("Hello, (who)!")
}

59. Functions
func obExample (who :String) -> String {
return "Hello, (who)!"
}

60. Functions
func obExample (who :String = "Salem")
-> String {
return "Hello, (who)!"
}
obExample("Oregon") // "Hello, Oregon!"
obExample() // "Hello, Salem!"

61. Functions
func obExample (what :String = "Hello",
who :String = "Salem")
-> String {
return "(what), (who)!"
}
obExample() // "Hello, Salem!"
obExample("bye") // "bye, Salem!"
obExample("bye",who:"felicia") // "bye, felicia"
obExample("bye", "salem") // COMPILE ERROR

62. Functions
func obExample (what :String = "Hello",
_ who :String = "Salem")
-> String {
return "(what), (who)!"
}
obExample("bye") // "bye, Salem!"
obExample("bye",who:"felicia") // COMPILE ERROR
obExample("bye", "salem") // "bye, salem!"

63. Functions
func variadiacExample (nums: Int...) {
// do something with nums
}

64. Functions are first-class citizens

65. Closures
let numbers = [2,1,56,32,120,13]
var sorted = numbers.sort({
(n1: Int, n2: Int) -> Bool in return n2 > n1
})
// sorted = [1, 2, 13, 32, 56, 120]

66. Closures
let numbers = [2,1,56,32,120,13]
var sorted = numbers.sort({
(n1: Int, n2: Int) -> Bool in return n2 > n1
})
// sorted = [1, 2, 13, 32, 56, 120]

67. Closures
let numbers = [2,1,56,32,120,13]
var sorted = numbers.sort({
(n1: Int, n2: Int) -> Bool in return n2 > n1
})
// sorted = [1, 2, 13, 32, 56, 120]

68. Closures
let numbers = [2,1,56,32,120,13]
var sorted = numbers.sort({
(n1: Int, n2: Int) -> Bool in return n2 > n1
})
// sorted = [1, 2, 13, 32, 56, 120]

69. Closures
let numbers = [2,1,56,32,120,13]
// inferred param & return types
var sorted = numbers.sort({n1, n2 in return n2 > n1})
// sorted = [1, 2, 13, 32, 56, 120]

70. Closures
let numbers = [2,1,56,32,120,13]
// positionally named parameters
var sorted = numbers.sort({return $0 > $1})
// sorted = [1, 2, 13, 32, 56, 120]

71. Closures
let numbers = [2,1,56,32,120,13]
// when closure is last param, parens optional
var sorted = numbers.sort { $0 > $1 }
// sorted = [1, 2, 13, 32, 56, 120]

72. OOP is
also
well
supported
I'm just
well out
of time…

73. Workspaces

74. https://developer.apple.com/swift

77. THANKS!