basics of computer science

Basics&of&Computer&ScienceMaxim&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%StructuresArray,&Dic*onary,&Set,&String

All#defined#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


Purely'Func+onal'Data'Structure:No#Destruc+ve#updates



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


Benchmark*in*ms• 208.853006362915+List+1K

• 000.30207633972168+BoxEList+1K

• 000.0660419464111328+ClassList+1K

• 000.0400543212890625+EEList+1K

• 000.0429153442382812+Array+1K


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$defined$as$structs?


Swi$%data%structure%types%are%facades%which%supportNo#Destruc+ve#updates



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#defini7ons


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


What%about%shared%state?

Isn't&share&nothing

(self&sufficient).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


https://gist.github.com/mzaks/0d219bcb52da9604aeb5

https://gist.github.com/mzaks/6e248558f30e480503fc

https://www.typesafe.com/blog/7-ways-washing-dishes-and-message-driven-reactive-systems

http://airspeedvelocity.net/2015/07/26/linked-lists-enums-value-types-and-identity/

http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf

basics of computer science

Education