Basics of Computer Science

Basics&of&Computer&Science
Maxim&Zaks
@iceX33
Things'I'learned'on'the'job,'a3er'my'CS'degree

Computer)Science)is:
Shoveling*Data*Around

Computer)Science)is:
Consuming)Electricity

Fast%code%produces%less%Data

How$do$we$represent$data$in$Swi/?

By#Value:
Tuple,'Struct'or'Enum
By#Reference:
Class,&Func+on

Value&Types&are&not&sharable!

Taking'a'car'for'a'drive

Value&types&are&cheaper&to&create

typealias TPerson = (name:String, age:Int, male:Bool)
+-----------------------------------------+--------------------------------------------------+
struct SPerson{ | class CPerson{
let name : String | let name : String
let age : Int | let age : Int
let male : Bool | let male : Bool
} |
| init(name : String, age : Int, male : Bool){
+-----------------------------------------+ self.name = name
enum EPerson { | self.age = age
case Male(name: String, age : Int) | self.male = male
case Female(name : String, age : Int) | }
| }
func name()->String{ |
switch self { |
case let Male(name, _): |
return name |
case let Female(name, _): |
return name |
} |
} |
} +

Benchmark*in*ms
• 000.00786781311035156*Tuple*10M
• 000.00405311584472656*Enum*10M
• 000.003814697265625*Struct*10M
• 813.668251037598*Class*10M

How$do$we$represent$a$collec/on$of$
data?

Data$Structures

Reference'or'Array'Based

Performance*Characteris0cs
• Add$(Prepand$/$Append$/$Insert)
• Get$(First$/$Last$/$ByIndex$/$ByValue)
• Find$(Biggest$/$Smallest)$
• Delete$(ByIndex$/$ByValue)
• Concatenate

Swi$%Data%Structures
Array,&Dic*onary,&Set,&String
All#deﬁned#as#Struct

Once%upon%a%*me,%(before%Swi4%2)
I"decided"to"implement"my"own"List

+-----------------------------------+-------------------------------------------------------------+
|
private protocol List{ | public struct ListNode<T> : List {
var tail : List {get} | public let value : T
} | private let _tail : List
+-----------------------------------+ private var tail : List {
| return _tail
private struct EmptyList : List{ | }
var tail : List { |
return EmptyList() | private init(value: T, tail : List){
} | self.value = value
} | self._tail = tail
| }
|
| public subscript(var index : UInt) -> ListNode<T>?{
+-----------------------------------+ var result : List = self
| while(index>0){
| result = result.tail
| index--
infix operator => { | }
associativity right | return result as? ListNode<T>
precedence 150 | }
} |
| }
+-----------------------------------+-------------------------------------------------------------+
public func => <T>(lhs: T, rhs: ListNode<T>?) -> ListNode<T> {
if let node = rhs {
return ListNode(value: lhs, tail: node)
}
return ListNode(value: lhs, tail: EmptyList())
}

Benchmark*in*ms
• 208.853006362915+List+1K
• 000.30207633972168+BoxEList+1K
• 000.0660419464111328+ClassList+1K
• 000.0400543212890625+EEList+1K
• 000.0429153442382812+Array+1K

WTF$happened?

Let's&talk&about&Pure&Func2onal&
Programming

Purely'Func+onal'Data'Structure:
No#Destruc+ve#updates
Persistent((not(ephemeral)

Why$is$it$important?

Referen&al)transparency

An#expression#always#evaluates#to#the#same#
result#in#any#context:
2"+"3
array.count

But$our$hardware$memory$is$
destruc1ve$and$ephemeral
(Physics)

Structural(Sharing

Swi$
Reference'vs.'Value'Type

Value&Type&are&not&sharable!
So#no#structural#sharing#is#posible

enum EEList<Element> {
case End
indirect case Node(Element, next: EEList<Element>)
var value: Element? {
switch self {
case let Node(x, _):
return x
case End:
return nil
}
}
}
extension EEList {
func cons(x: Element) -> EEList {
return .Node(x, next: self)
}
}

Why$are$Swi+$data$structures$
deﬁned$as$structs?

Swi$%data%structure%types%are%
facades%which%support
No#Destruc+ve#updates
Persistent((not(ephemeral)

Is#there#(me#to#talk#about#
Singletons?

Thank&you!

Singleton)is)a)globaly)shared)
instance

How$many$shared$instances$do$you$see$here?
private var fibRow = [0, 1, 2]
public func fibM(number:Int)->Int{
if number >= fibRow.count {
fibRow.append(fibM(number-2)+fibM(number-1))
}
return fibRow[number]
}

Named&func+ons&are&shared&
instances

Sharing(means(coupling

Coupling)means
• Tough'to'test
• And'tough'to'reuse
The$problem$with$object0oriented$languages$is$they've$got$all$this$
implicit$environment$that$they$carry$around$with$them.$You$wanted$
a$banana$but$what$you$got$was$a$gorilla$holding$the$banana$and$the$
en<re$jungle.
—"Joe"Armstrong

We#can#solve#the#coupling#problem#
by#abstract#type#deﬁni7ons

+----------------+ +----------------+
| | | |
| SomethingA +-------> | AbstractB |
| | | |
+----------------+ +-------+--------+
^
|
|
|
+-------+--------+
| |
| SomethingB |
| |
+----------------+

What%about%shared%state?
Isn't&share&nothing
(self&suﬃcient).architecture.be3er?

Shared'resources:
• Memory
• I/O
• Network

Not$that$bigger$problem$for
iOS/OSX&developers.

Apple%takes%cares%of%it:
• default...
• shared...
• main...

Be#aware#of#Amdahl's#law
The$speedup$of$a$program$using$mul2ple$processors$in$parallel$
compu2ng$is$limited$by$the$2me$needed$for$the$sequen2al$frac2on$
of$the$program.
—"Wikipedia

Now$I$am$done$:)

Ques%ons?

Thank&you

Links:
• PerformanceTest
• Fibonacci
• Fork2Join2illustra6on
• Linked2List2implementa6on2with2Swi=22Enum
• Pure2Func6onal2Data2Structures

Basics of Computer Science

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (9)

Destaque

Destaque (20)

Semelhante a Basics of Computer Science

Semelhante a Basics of Computer Science (20)

Mais de Maxim Zaks

Mais de Maxim Zaks (20)

Último

Último (20)

Basics of Computer Science