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

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (9)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Basics of Computer Science

Ähnlich wie Basics of Computer Science (20)

Mehr von Maxim Zaks

Mehr von Maxim Zaks (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Basics of Computer Science