1. PARADYGMATY
PROGRAMOWANIA
CZY ISTNIEJE NAJLEPSZY?
@akashivskyy

2. PARADYGMATY
PROGRAMOWANIA

3. SPOSÓB PATRZENIA NA
PRZEPŁYW STEROWANIA I
WYKONYWANIE PROGRAMU

4. 1. PROGRAMOWANIE
OBIEKTOWE

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

6. 3 ZAŁOŻENIA

7. 1. ABSTRAKCJA
2. ENKAPSULACJA
3. DZIEDZICZNOŚĆ

8. 1. ABSTRAKCJA
2. ENKAPSULACJA
3. DZIEDZICZNOŚĆ

10. protoco! Shape {
var area: Doub!e
}
func pr"ntShapeArea(shape: Shape) {
pr"nt!n("area = (shape.area)")
}

11. struct Square: Shape {
!et s"de: Doub!e
!et area: Doub!e {
return s"de # s"de
}
}
pr"ntShapeArea(Square(s"de: 4)) // 16.$

12. 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

13. struct P!ane: Shape {
var area: Doub!e {
return Doub!e."nf"n"ty
}
}
pr"ntShapeArea(P!ane()) // "nf"n"ty

14. 1. ABSTRAKCJA
2. ENKAPSULACJA
3. DZIEDZICZNOŚĆ

15. 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)
}
}

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

17. 1. ABSTRAKCJA
2. ENKAPSULACJA
3. DZIEDZICZNOŚĆ

18. POJAZD
SZYNOWY DROGOWY
TRAMWAJ POCIĄG ROWER KOMBAJN

19. 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"
}

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

21. 2. PROGRAMOWANIE
IMPERATYWNE

22. ZDANIA ROZKAZUJĄCE,
ZMIENIAJĄCE GLOBALNY STAN
PROGRAMU

23. !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)
}
}

24. 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)
}
})

25. PROGRAMOWANIE
IMPERATYWNE JEST
NAJPOPULARNIEJSZE

26. PROGRAMOWANIE
IMPERATYWNE JEST
NAJŁATWIEJSZE

27. PROGRAMOWANIE
IMPERATYWNE JEST
NAJGORSZE

28. 1. PODATNE NA BŁĘDY
2. NIE SKALUJE SIĘ
3. ZBYT SKOMPLIKOWANE

29. 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)
}
})

30. 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)
}

31. 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 {

32. 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)
}
})

35. 3. PROGRAMOWANIE
DEKLARATYWNE

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

37. !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)
}
}

38. 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)
}
}

39. !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
})

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

41. getRemoteData("examp!e.com"
"ferror==n"!{
parseData(data,{parsed,
"ferror==n"!{
"fparsedDataVa!"d(par
saveParsedDataInCach
"ferror==n"!{
hand!eParsedData
"ferror==n"!
d"sp!aySucces
}e!se{
d"sp!ayError(e
}
})
}e!se{
d"sp!ayError(error
}
})
}
}e!se{
d"sp!ayError(error)
}
})
}e!se{
d"sp!ayError(error)
}
})

43. RURY

44. POBIERZ PRZETWÓRZ ZAPISZ WYŚWIETL
BŁĘDY

45. POBIERZ PRZETWÓRZ ZAPISZ WYŚWIETL
BŁĘDY

46. 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) })

47. 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) })

48. 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) })

49. PROGRAMOWANIE
DEKLARATYWNE JEST
PROSTSZE

50. PROGRAMOWANIE
DEKLARATYWNE JEST
BEZPIECZNIEJSZE

51. PROGRAMOWANIE
DEKLARATYWNE JEST
BARDZIEJ SKALOWALNE

52. CZY ISTNIEJE
NAJLEPSZY PARADYGMAT?

53. 1. OBIEKTOWY
2. IMPERATYWNY
3. DEKLARATYWNY

54. 1. OBIEKTOWY
2. IMPERATYWNY
3. DEKLARATYWNY

56. 1. OBIEKTOWY
2. IMPERATYWNY
3. DEKLARATYWNY

57. RAZEM

58. DZIĘKUJĘ
ADRIAN KASHIVSKYY
@akashivskyy
github.com/akashivskyy/talks