PARADYGMATY PROGRAMOWANIA

CZY ISTNIEJE NAJLEPSZY?

@akashivskyy

PARADYGMATY PROGRAMOWANIA

SPOSÓB PATRZENIA NA PRZEPŁYW STEROWANIA I

WYKONYWANIE PROGRAMU

1. PROGRAMOWANIE OBIEKTOWE

PROGRAM DEFINIUJĄ OBIEKTY ŁĄCZĄCE STAN I ZACHOWANIE

3 ZAŁOŻENIA

1. ABSTRAKCJA 2. ENKAPSULACJA 3. DZIEDZICZNOŚĆ

1. ABSTRAKCJA 2. ENKAPSULACJA 3. DZIEDZICZNOŚĆ

protoco! Shape { var area: Doub!e }

func pr"ntShapeArea(shape: Shape) { pr"nt!n("area = \(shape.area)") }

struct Square: Shape { !et s"de: Doub!e !et area: Doub!e { return s"de # s"de } }

pr"ntShapeArea(Square(s"de: 4)) // 16.$

struct C"rc!e: Shape { var rad"us: Doub!e var area: Doub!e { return M_PI # rad"us # rad"us } }

pr"ntShapeArea(C"rc!e(rad"us: 2)) // 12.56

struct P!ane: Shape { var area: Doub!e { return Doub!e."nf"n"ty } }

pr"ntShapeArea(P!ane()) // "nf"n"ty

1. ABSTRAKCJA 2. ENKAPSULACJA 3. DZIEDZICZNOŚĆ

c!ass Encrypt"onAss"stant { pr"vate var key = "42$m!g$crub" pub!"c func encrypt(pass: Str"ng) -> Str"ng { return rsaEncrypt(pass, key) } }

!et ass"stant = Encrypt"onAss"stant() ass"stant.encrypt("secret") // 1L!$$Myn4RtY ass"stant.key // comp"!e error!

1. ABSTRAKCJA 2. ENKAPSULACJA 3. DZIEDZICZNOŚĆ

POJAZD

SZYNOWY DROGOWY

TRAMWAJ POCIĄG ROWER KOMBAJN

c!ass Car { var co!or: Str"ng = "red" var name: Str"ng { return "\(co!or) car" } }

c!ass B!ueCar: Car { overr"de var co!or = "b!ue" }

Car().name // red car B!ueCar().name // b!ue car

2. PROGRAMOWANIE IMPERATYWNE

ZDANIA ROZKAZUJĄCE, ZMIENIAJĄCE GLOBALNY STAN

PROGRAMU

!et numbers = [1, 2, 3, 4, 5, 6] var sum = $ var odds: [Int] = [] for number "n numbers { sum += number "f number % 2 == 1 { odds.append(number) } }

getRemoteData("ur!", { data, error "n "f error == n"! { parseData(data, { parsed, error "n "f error == n"! { hand!eParsedData(parsed) } e!se { d"sp!ayError(error) } }) } e!se { d"sp!ayError(error) } })

PROGRAMOWANIE IMPERATYWNE JEST

NAJPOPULARNIEJSZE

PROGRAMOWANIE IMPERATYWNE JEST

NAJŁATWIEJSZE

PROGRAMOWANIE IMPERATYWNE JEST

NAJGORSZE

1. PODATNE NA BŁĘDY 2. NIE SKALUJE SIĘ

3. ZBYT SKOMPLIKOWANE

getRemoteData("examp!e.com", { data, error "n "f error == n"! { parseData(data, { parsed, error "n "f error == n"! { hand!eParsedData(parsed) } e!se { d"sp!ayError(error) } }) } e!se { d"sp!ayError(error) } })

getRemoteData("examp!e.com", { data, error "n "f error == n"! { parseData(data, { parsed, error "n "f error == n"! { "f parsedDataVa!"d(parsed) { hand!eParsedData(parsed) } } e!se { d"sp!ayError(error) } }) } e!se { d"sp!ayError(error) } })

getRemoteData("examp!e.com", { data, error "n "f error == n"! { parseData(data, { parsed, error "n "f error == n"! { "f parsedDataVa!"d(parsed) { saveParsedDataInCache(parsed, { error "n "f error == n"! { hand!eParsedData(parsed) } e!se { d"sp!ayError(error) } }) } } e!se { d"sp!ayError(error) }

getRemoteData("examp!e.com", { data, error "n "f error == n"! { parseData(data, { parsed, error "n "f error == n"! { "f parsedDataVa!"d(parsed) { saveParsedDataInCache(parsed, { error "n "f error == n"! { hand!eParsedData(parsed, { error "n "f error == n"! { d"sp!aySuccess() } e!se { d"sp!ayError(error) } }) } e!se { d"sp!ayError(error)

3. PROGRAMOWANIE DEKLARATYWNE

DEKLARUJEMY CO CHCEMY OSIĄGNĄĆ, A NIE JAK TO

ZROBIĆ

!et numbers = [1, 2, 3, 4, 5, 6] var sum = $ var odds: [Int] = [] for number "n numbers { sum += number "f number % 2 == 1 { odds.append(number) } }

var sum = $ var odds: [Int] = [] !et numbers = [1, 2, 3, 4, 5, 6] for number "n numbers { sum += number // redukcja "f number % 2 == 1 { // f"!tracja odds.append(number) } }

!et numbers = [1, 2, 3, 4, 5, 6] !et sum = reduce(numbers, $, { memo, number "n return memo + number }) !et odds = f"!ter(numbers, { number "n return number % 2 == 1 })

!et numbers = [1, 2, 3, 4, 5, 6] !et sum = reduce(numbers, $, +) !et odds = f"!ter(numbers, { $$ % 2 == 1 })

getR

emot

eDat

a("e

xamp!

e.co

m",

{ d

ata,

err

or "

n "f

err

or =

= n"!

{ pa

rseD

ata(

data

, {

pars

ed,

erro

r "n

"f

err

or =

= n"!

{ "f

par

sedD

ataV

a!"d

(par

sed)

{

sa

vePa

rsed

Data

InCa

che(

pars

ed,

{ er

ror "n

"f

err

or =

= n"!

{ ha

nd!e

Pars

edDa

ta(p

arse

d, {

err

or "

n "f

err

or =

= n"!

{ d"

sp!a

ySuc

cess

()

}

e!se

{

d"

sp!a

yErr

or(e

rror

) }

})

}

e!se

{

d"

sp!a

yErr

or(e

rror

) }

})

}

}

e!se

{

d"

sp!a

yErr

or(e

rror

) }

})

}

e!se

{

d"

sp!a

yErr

or(e

rror

) }

})

RURY

POBIERZ PRZETWÓRZ ZAPISZ WYŚWIETL

BŁĘDY

POBIERZ PRZETWÓRZ ZAPISZ WYŚWIETL

BŁĘDY

getRemoteData("examp!e.com") .then({ data "n parseData(data) }) .f"!ter({ parsed "n parsedDataVa!"d(parsed) }) .then({ parsed "n saveInCache(parsed) }) .then({ parsed "n hand!eParsedData(parsed) }) .error({ error "n d"sp!ayError(error) })

getRemoteData("examp!e.com") .then({ data "n parseData(data) }) .f"!ter({ parsed "n parsedDataVa!"d(parsed) }) .f"!ter({ parsed "n !a!readyInCache(parsed) }) .then({ parsed "n saveInCache(parsed) }) .then({ parsed "n hand!eParsedData(parsed) }) .error({ error "n d"sp!ayError(error) })

getRemoteData("examp!e.com") .then({ data "n parseData(data) }) .f"!ter({ parsed "n parsedDataVa!"d(parsed) }) .f"!ter({ parsed "n !a!readyInCache(parsed) }) .then({ parsed "n saveInCache(parsed) }) .then({ parsed "n hand!eParsedData(parsed) }) .error({ error "n d"sp!ayError(error) })

PROGRAMOWANIE DEKLARATYWNE JEST

PROSTSZE

PROGRAMOWANIE DEKLARATYWNE JEST

BEZPIECZNIEJSZE

PROGRAMOWANIE DEKLARATYWNE JEST

BARDZIEJ SKALOWALNE

CZY ISTNIEJE NAJLEPSZY PARADYGMAT?

1. OBIEKTOWY 2. IMPERATYWNY

3. DEKLARATYWNY

1. OBIEKTOWY 2. IMPERATYWNY

3. DEKLARATYWNY

1. OBIEKTOWY 2. IMPERATYWNY

3. DEKLARATYWNY

RAZEM

DZIĘKUJĘADRIAN KASHIVSKYY

@akashivskyy github.com/akashivskyy/talks