Upgrade to Pro
— share decks privately, control downloads, hide ads and more …
Speaker Deck
Features
Speaker Deck
PRO
Sign in
Sign up for free
Search
Search
Solving Problems the Swift Way
Search
Ash Furrow
July 05, 2014
Technology
23
8.5k
Solving Problems the Swift Way
A presentation on solving problems in idiomatic Swift.
Ash Furrow
July 05, 2014
Tweet
Share
More Decks by Ash Furrow
See All by Ash Furrow
Migrating to React Native: A Long-Term Retrospective
ashfurrow
0
190
How Artsy Automates Team Culture
ashfurrow
0
2.9k
Building Custom TSLint Rules
ashfurrow
0
380
Circumventing Fear of the Unknown
ashfurrow
1
480
Building Better Software by Building Better Teams
ashfurrow
1
520
Building Open Source Communities
ashfurrow
0
790
Comparative Asynchronous Programming
ashfurrow
2
9.2k
Building Compassionate Software
ashfurrow
0
380
Swift, Briskly
ashfurrow
0
110
Other Decks in Technology
See All in Technology
『AWS Distinguished Engineerに学ぶ リトライの技術』 #ARC403/Marc Brooker on Try again: The tools and techniques behind resilient systems
quiver
0
130
5分で紹介する生成AIエージェントとAmazon Bedrock Agents / 5-minutes introduction to generative AI agents and Amazon Bedrock Agents
hideakiaoyagi
0
220
技術負債の「予兆検知」と「状況異変」のススメ / Technology Dept
i35_267
1
1k
管理者しか知らないOutlookの裏側のAIを覗く#AzureTravelers
hirotomotaguchi
2
240
AndroidデバイスにFTPサーバを建立する
e10dokup
0
240
Googleマップ/Earthが一般化した 地図タイルのイマ
mapconcierge4agu
1
200
エンジニアの育成を支える爆速フィードバック文化
sansantech
PRO
3
670
滅・サービスクラス🔥 / Destruction Service Class
sinsoku
6
1.5k
第13回 Data-Centric AI勉強会, 画像認識におけるData-centric AI
ksaito_osx
0
360
君はPostScriptなウィンドウシステム 「NeWS」をご存知か?/sunnews
koyhoge
0
720
『衛星データ利用の方々にとって近いようで触れる機会のなさそうな小話 ~ 衛星搭載ソフトウェアと衛星運用ソフトウェア (実物) を動かしながらわいわいする編 ~』 @日本衛星データコミニティ勉強会
meltingrabbit
0
120
データ資産をシームレスに伝達するためのイベント駆動型アーキテクチャ
kakehashi
PRO
2
230
Featured
See All Featured
The Language of Interfaces
destraynor
156
24k
Building Adaptive Systems
keathley
40
2.4k
Building Better People: How to give real-time feedback that sticks.
wjessup
366
19k
Chrome DevTools: State of the Union 2024 - Debugging React & Beyond
addyosmani
3
310
Design and Strategy: How to Deal with People Who Don’t "Get" Design
morganepeng
129
19k
The Psychology of Web Performance [Beyond Tellerrand 2023]
tammyeverts
45
2.3k
StorybookのUI Testing Handbookを読んだ
zakiyama
28
5.5k
Fontdeck: Realign not Redesign
paulrobertlloyd
82
5.4k
Documentation Writing (for coders)
carmenintech
67
4.6k
Reflections from 52 weeks, 52 projects
jeffersonlam
348
20k
The Invisible Side of Design
smashingmag
299
50k
The Power of CSS Pseudo Elements
geoffreycrofte
75
5.5k
Transcript
Idiomatic Swift Ash Furrow @ashfurrow
None
1.Better ways to solve familiar problems using Swift 2.Everyone is
a beginner again 3.We should share what we learn
Problem-Solving
You are here You wanna be here “Problem Solving”
• It would be a shame not to take advantage
of these new tools and techniques • Let’s take a look at some examples
• Completely new concept of nil • Indicates “missing” value
• Replaces nil, Nil, NULL, CGRectNull, -1, NSNotFound, NSNull, etc • Haskell’s “Maybe” type • C#’s “Nullable Types” Optionals
• Works well with Swift’s compile-time type safety • Which
is awesome • No, seriously, awesome • Eliminates several classes of bugs • Don’t over-use optional types Optionals
let a = someFunction() //returns Int? if a != nil
{ // use a! } Optionals
let a = someFunction() //returns Int? if let b =
a { // do something with b } if let a = a { // do something with a } Optionals
• Tuples are compound values • They are lightweight, temporary
containers for multiple values • Those values can be named • Useful for functions with multiple return types Tuples
func calculate() -> (Bool, Int?) { // ... return (result,
errorCode) } Tuples
func calculate() -> (Bool, Int?) { // ... return (result,
errorCode) } ! let calculation = calculate() ! if (calculation.0) { // … } Tuples
func calculate() -> (Bool, Int?) { // ... return (result,
errorCode) } ! let calculation = calculate() let (result, _) = calculation ! if (result) { // … } Tuples
func calculate() -> (result: Bool, errorCode: Int?) { // ...
return (result: result, errorCode: errorCode) } ! let calculation = calculate() if (calculation.errorCode) { // ... } Tuples
for (key, value) in dictionary { // ... } Tuples
• New APIs shouldn’t use out parameters • eg: NSError
pointers • Really great for use in pattern-matching Tuples
• Borrowed from functional programming • Really useful in tail-recursive
functions • Like “switch” statements on steroids Pattern-Matching
-(void)tableView:(UITableView *)tableView didSelectRowAtIndexPath: (NSIndexPath *)indexPath { switch (indexPath.section) { case
0: { switch (indexPath.row) { case 0: ... } } break; } } Pattern-Matching
-(void)tableView:(UITableView *)tableView didSelectRowAtIndexPath: (NSIndexPath *)indexPath { switch (indexPath.section) { case
ASHLoginSection: { switch (indexPath.row) { case ASHLoginSectionUserNameRow: ... } } break; } } Pattern-Matching
override func tableView(tableView: UITableView!, didSelectRowAtIndexPath indexPath: NSIndexPath!) { switch (indexPath.section,
indexPath.row) { case (0, _): ... default: ... } } Pattern-Matching
override func tableView(tableView: UITableView!, didSelectRowAtIndexPath indexPath: NSIndexPath!) { switch (indexPath.section,
indexPath.row) { case (0, let row): ... default: ... } } Pattern-Matching
override func tableView(tableView: UITableView!, didSelectRowAtIndexPath indexPath: NSIndexPath!) { switch (indexPath.section,
indexPath.row) { case (0, let row) where row > 5: ... default: ... } } Pattern-Matching
struct IntList { var head: Int = 0 var tail:
IntList? } ! ... ! switch (list.head, list.tail) { case (let head, nil): //... case (let head, let tail): //... } Pattern-Matching
• Generics are common in other languages, like C# and
C++ • Using a generic type as a placeholder, we can infer the type of variables at compile- time • A part of Swift’s “safe by default” behaviour Generics
struct Stack<T> { var items = [T]() mutating func push(item:
T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } } Generics
var stack = Stack<Int>() ! var stack = Stack<String>() !
var stack = Stack<Recipe>() Generics
struct Stack<T: Equatable> : Equatable { var items = [T]()
mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } } ! func ==<T>(lhs: Stack<T>, rhs: Stack<T>) -> Bool { return lhs.items == rhs.items } Generics
• Use stacks whenever you want to define an abstract
data type structure • Whenever possible, don’t bind new data structures to existing ones • Use protocols for loose coupling Generics
• Optionals • Pattern-matching • Tuples • Generics
Everyone is a Beginner
• No one is an expert in Swift • This
can be kind of stressful • Relax Everyone is a Beginner
• The benefits outweighs the cost of learning • Depending
on your circumstance • Have your say Everyone is a Beginner
• The hardest thing is the most important thing •
Start Everyone is a Beginner
• Don’t be embarrassed to ask questions! • Try to
ask in public so others can benefit from the answer Everyone is a Beginner
• Let’s borrow ideas Everyone is a Beginner
• Community-based conventions and guidelines are still being established Everyone
is a Beginner
We Should Share What We Learn
• Conventions and guidelines are still in flux • There’s
an opportunity to significantly alter the future of iOS and OS X programming We Should Share What We Learn
• The demand for material on Swift is HUGE •
Great opportunity to get known We Should Share What We Learn
• When you teach, you learn We Should Share What
We Learn
• If we all share what we learn, we all
get smarter • Rising tides lift all boats We Should Share What We Learn
• Stack Overflow • Blogs • Tweets • Gists •
Open source • Radars We Should Share What We Learn
http://github.com/artsy/eidolon
1.Better ways to solve familiar problems using Swift 2.Everyone is
a beginner again 3.We should share what we learn
Let’s Make Better Mistakes Tomorrow
Thank you" @ashfurrow