poniedziałek, 28 marca 2016

O Rany odwrotna kolejność Danych

A w zasadzie to chodzi o kolejność deklaracji typów w funkcji ale to się nie rymuje tak łatwo bo jak znaleźć rym do "funkcji"? Albo do słowa "Typy"? Do "Typy" można napisać "z Dypy" ale jest to naciągane i podobno niekulturalne. Także ten tego...

Prawdziwa natura metod i "obiektowa klatka"

Zacznijmy od takiego prostego (z pozoru) kawałka kodu, który ejst zwykłym wywołaniem metody na obiekcie :

List(1,2,3).map(e=>e+1)
I chociaż nie wygląda to na cos magicznego to jednak dzieje się tutaj ciekawa rzecz : wywołujemy metodę na konkretnej instancji a nie na dowolnej i to jest dosyć ważne . Wywołanie to ma jeden parametr - funkcję mapującą

Ciekawą sprawa jest to, że tak naprawdę (i w uproszczeniu) rozpatrywana metoda ma dwa argumenty bo dochodzi jeszcze niejawny argument this - referencja do instancji (Przynajmniej tak to działa na pewno w Javie to chyba w Scali też : http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-3.html#jvms-3.7)

Wobec tego powyższe można by zapisać koncepcyjnie jako :

//symboliczna równowartość wołania metody na instancji obiektu
def map[A,B](instance:List[A])(f:A=>B):List[B] = instance.map(f)

I w zasadzie można teraz tak pomajstrować w kodzie, że bez problemu zasymulujemy obiektowe wywołanie metody

val listInstance=List(1,2,3)
val function:Int=>Int = e => e+1

// można od razu wywołać z argumentem
map(listInstance)(function) // List(2,3,4)

//A można sobie zasymulować ustawienie instancji
val mapForInstance: (Int=>Int) => List[Int]=map(listInstance) _

//i później wywołanie
mapForInstance(function)

No niby taka ciekawostka ale czy coś praktycznego z tego dla nas wynika? Pierwsza rzecz to spójrzmy na ten typ :
val mapForInstance: (Int=>Int) => List[Int]

To nic innego jak metoda, która jako parametr przyjmuje funkcje Int=>Int i zwraca List[Int]. Ten typ jest dosyć dziwny i trochę nienaturalny ale z tą dziwnością żyliśmy przez lata w Javie i może dlatego dopiero po takich ćwiczeniach składniowych pojawia się tutaj "coś dyskusyjnego". Cóż, nasza nowa forma nie jest scalona z instancją co daje nam nowe pole do eksperymwntów...

A gdyby tak na odwrót - czyli opuszczenie mentalnej klatki

Odwróćmy kolejność argumentów i nazwijmy metodę fmap tak dla odróżnienia.

def fmap[A,B](f:A=>B)(l:List[A]):List[B] = l.map(f)

I powtarzamy ćwiczenie aplikując jedynie pierwszy argument :

val addOneToAll: (List[Int] => List[Int]) = fmap(function)
val allToString: (List[Int] => List[String])=fmap(i=>i.toString)

I uzyskujemy dosyć ciekawy typ List[Int] => List[Int]. Jest to spójniejszy aniżeli to co było w poprzednim punkcie bloga czyli ten typ, który funkcje zamieniał w listę. Aby zobaczyć to jeszcze lepiej przenieśmy drugi argument do sygnatury zwracanej funkcji :

def fmap[A,B](f:A=>B): List[A] => List[B] = l=>l.map(f)

I teraz widać to dokładnie! Jaka piękna kompozycja normalnie! Zamieniamy A=>B w List[A] => List[B]. No dobra ale po co i skąd ten entuzjazm? Czas na rysunek....

Czyli generalnie możemy sobie łatwo skomponować ciąg obliczeń na poziomie pewnych struktur korzystając z prostych funkcji jako bloków budulcowych. A teraz kod...

val addOneToAll: (List[Int] => List[Int]) = fmap(function)
val allToString: (List[Int] => List[String])=fmap(i=>i.toString)


//obliczenia
val computation: (List[Int]) => List[String] =
  ((l:List[Int]) => l.filter(_ > 0) ) andThen addOneToAll andThen allToString

//albo i tak
val computation2: (List[Int]) => List[String] =
  ((l:List[Int]) => l.filter(_ > 0) ) andThen fmap(function) andThen fmap(_.toString)

//i wtedy

computation(List(-1,-2,0,1,2)) // List[String] = List(2, 3)
computation2(List(-1,-2,0,1,2)) // List[String] = List(2, 3)

Dodatkowa parametryzacja

Korzystanie z prostych funkcji ma tę ogromną zaletę, że łatwo da się je parametryzować i nie musimy zaszywać na stałe wartości do której porównujemy w filtrze itd.

//podnoszenie funkcji filtrującej do poziomu list
def filter[A](f:A=>Boolean):List[A]=>List[A]= l=> l.filter(f)

//konfiguracja tego tam warunku po którym filtrujemy
val curriedPredicate: Int => Int => Boolean = toCompare => elem => elem > toCompare

// a tutaj sobie konfigurujemy dodawanie
val curriedAdd : Int=>Int=>Int = a => b =>a+b


// I HEJA!
val computation3: (List[Int]) => List[String] =
  filter(curriedPredicate(-1)) andThen fmap(curriedAdd(2)) andThen fmap(_.toString)


computation3(List(-1,-2,0,1,2)) //List(2, 3, 4)

I rysunkowo :

Marketing i edukacja

A ja się pytam dlaczego w trakcie edukacji finansowanej z podatków moich rodziców i później moich nie uczyli takich rzeczy tylko w ząbek czesane jakieś pieski i kotki dziedziczące z Animala ? I jednocześnie bombarduje się ludzi zasadami, że "tight-coupling" pomiędzy obiektami jest zły ALE (niechajże gęś to kopnie) jednocześnie wmawia się, że obiekty jako takie są dobre chociaż obiekt to nic innego jak - motyla noga - "tight-coupling" pomiędzy danymi i operacjami? (udało się udało się, zero bluzg udało się nie wierzę, że się udało kurwa udał... a niech to dunder świśnie)

"Ano dlatego bo na diagramach UML były kwadraty a w nich napisy "Klient,Faktura i Money" i to się sprzedawało!

Chyba rozumiem, czyli aby zmaterializować hajs metodę map trzeba zapisać tak :

type InternetOfThings[A]=List[A]
def zysk[Klient,Faktura](bigData: Klient=>Faktura)(microservices: InternetOfThings[Klient])
  = microservices.map(bigData)

Teraz dobrze?

Inne języki

W Haskellu w map funkcja występuje na pierwszym miejscu przez co możemy zastosować wszystkie patenty z tego artykułu :

:type map
map :: (a -> b) -> [a] -> [b]

:type map (+1)
map (+1) :: Num b => [b] -> [b]

A w Javie :

Aby w Javie przeczytać kolejność typów trzeba czytać od końca bo najpierw mamy typ zwracany z później dopiero typ przekazywany. Czyli Java to język, który czyta się od prawej do lewej i tutaj można by umieścić jakiś żart o czytaniu z prawej do lewej ale w dzisiejszych czasach to już polityka. Także udanego programowania życzę!




niedziela, 28 lutego 2016

Wstęp do FP - Scala i Java - porównanie warsztatów

Na samym początku ważne są dwa zdjęcia. Pierwsze, że warsztat się w ogóle odbył i średnia wiedzy programistycznej świata się podniosła

A drugie ważne zdjęcie to zdjęcie sponsora bo salki same się nie wynajmują i pizza sama się nie zamawia - także nieważne w jakim języku programujesz podstawy ekonomi znać musisz :) (no chyba, ze programujesz szyby naftowe w Kuwejcie to wtedy może jakoś inaczej to działa)

Obydwa zdjęcia powyżej są od CezaregoD. - ktoś może mi dać wskazówkę dlaczego 90% moich zdjęć jest zawsze rozmazanych? Łapy raczej mi się aż tak nie trzęsą. Zdjęcia robię samsungiem S5.

Poczucie bliskości wartości edukacyjnej

Ogólnie ludzie są bardziej zainteresowani Javą8 (w sumie z 80 chętnych na kilka tur?) niż scalą (około 45) i generalnie trudno się dziwić bo Java jest na co dzień w pracy - czasem nawet i ta ósemka. Scala już się tu i ówdzie pojawia ale cały czas jest to taka "inwestycja edukacyjna" gdzieś tam na przyszłość.

Mam także jednak teorie, że z każdym krokiem w kierunku opanowania Javy8 i Scala będzie stawała się bliższa bo czy taka strzałka -> czy taka => to już bez większej różnicy. W sumie jak tak patrze z perspektywy to sam zacząłem i porzuciłem naukę Haskella w połowie 2014 bo w sumie po co uczyć się kilka rzeczy jak można skoncentrować się na jednej. I znowu z subiektywnej obserwacji widzę, że po osiągnięciu pewnego poziomu trzeba "zmienić plan treningowy" i otworzyć się na inne perspektywy bo w przeciwnym przypadku zaczynamy za bardzo koncentrować się na jakiejś drobnicy.

No to zerknijmy na materiał

By nauka szła wspaniale na trzy części ją rozwalę

Mamy :

  • kod zoptymalizowany pod prędkość wykonania
  • kod zoptymalizowany pod rozszerzenie
  • kod zoptymalizowany pod ...edukację!

  • I tutaj nas interesuje ten ostatni punkt.

Generalnie jako pierwszy przykład na warsztat idzie coś co z jednej strony pokaże, że "to co tutaj robimy do czegoś w życiu się przyda" a z drugiej nie może być zbyt złożone by nikt nie odleciał. Dlatego też każdy element rozwiązania jest odwzorowany symbolicznie. I tka mamy zajebiście duża dwuelementową mapę udająca bazę danych, jest i miejsce na Optional oraz kompozycje dwóch funkcji gdzie jedna jest domenowa a druga jakaś taka niezależna i bardzo matematycznie abstrakcyjne. I jest reusedż.

Tutaj także jest założenie, że dla większości uczestników to może być pierwszy kontakt z pewnymi konstrukcjami z Javy8 i generalnie jak np. ktoś sobie zakłada, ze musi ale to MUSI zrozumieć wszystko perfekcyjnie to może niepotrzebnie pojawić się frustracja - i niepotrzebnie bo to nauce nie służy (w ogóle takie czasy są, ze musi być wszystko zajebiście i w ogóle masa lajków). Dlatego też tutaj kilka razy podkreślam, żeby się zluzować i podejść do tego jak do demonstracji - takie coś jest możliwe, tego będziemy się uczyć i za jakiś czas każdy będzie w tym wymiatał. Nauka to funkcja czasu i trzeba na ten czas poprawkę wziąć.

No i teraz mamy pierwsza istotną różnicę pomiędzy warsztatem Javowym i Scalowym - w Scali od razu jedziemy z Property Based Testing. W Javie by było 100% javowo to są zwykłe JUnity. Ale tak czy inaczej to co uczestnicy zaobserwują to, że

Poznawanie składni

Generalnie z tłumaczeniem przez kogoś kto już ma wiedzę w kierunku kogoś kto wiedzy nie ma jest ten problem jak np. z wczuwaniem się co czuje głodna osoba gdy sami jesteśmy najedzeni. Albo jak już ktoś ze 20000km przejedzie to zapomina, ze kiedyś musiał sobie ściągę do zmiany biegów rysować.

No i praktyka pokazała, że ta składnia ze strzałkami stanowi na początku problem dla osób, które znają tylko składnie Java7lubmniej. Dlatego i po to sa te krótkie ćwiczenia by sobie powtarzac i powtarzać i tworza się nowe połączenia nerwowe i kroczek po kroczku lambdy stają się naturalnym zapisem

No i trzeba zwracać uwagę na wszelakie powiązania jak np. to, że ile razy w typie wystąpi słowo Function tyle zazwyczaj strzałek musi się w ciele pojawić

W Scali tego problemu nie ma bo są aliasy ale za to w Scali jeszcze niema invoke dynamic (ale już zara ma być) także częścią warsztatów będzie badanie syntetyków.

A na sam koniec - kiedy już pojawia się jakieś zmęczenie - zostaje teoria bo praktyka bez teorii to takie działanie na czuja. na pierwszym warsztacie było (a jak!) Referential Transparency. I znowu ćwiczenia będą się troszeczkę różnić pomiędzy Java a Scalą tak by weń uwzględnić ograniczenia i ficzery każdego z języków.

Czy dwa języki mogą pomóc w nauce?

Według tego artykułu chyba tak --> https://www.washingtonpost.com/news/wonk/wp/2016/02/12/how-to-learn-new-skills-twice-as-fast/

Powtórki i kolejne odcinki

Będą. Na razie w planach powtórka pierwszego warsztatu z Java8 i pierwszy warsztat ze Scali.

Co na druga część?

Poważną zaletą dzielenia się opinią przez uczestników jest dzielenie się opinią przez uczestników. Toteż w trakcie smaltoków i ankiety po warsztatowej ludzie napisali, że fajnie by było trochę praktycznego kontekstu pokazać dla tych mechanizmów.

Pomysł na razie mam taki - że będzie sobie jakiś plik CSV z danymi (ileś tam kolumn). i stopniowo będzie my budować silnik do analizy tych danych krok po kroku tworząc funkcyjne abstrakcje, które ułatwią testowanie i ponowne wykorzystanie kodu (może od razu wykorzystamy to w drugim kontekście). A jak będzie otwieranie pliku to i zaimplementuje się loan pattern czy też w javowej nomenklaturze pykniemy sobie customowe try-with-resources tak jakby to była bułka z masłem (bo z FP jest!).

Także fidbeki są dobre bo wtedy można mówić, ze rozwiązanie jest "field tested" czyli ktoś użył i już wiadomo co i jak. Zestaw to teraz w kontrast z dyskusjami na meetingach o tym "jak robić zanim ktoś zrobi".

Czy logowanie do log4j to efekt uboczny?

Padło takie pytanko. Generalnie jakby chcieć być bardzo ścisłym to wszystko co się robi na kompie jest efektem ubocznym bo jak ze Stringa tworzysz Email to np. pamięć może się skończyć. A mimo to tak mentalnie zakładamy typ String=>Email a nie String=>Try[Email] (chociaż jak się skończy pamięć to i tak chyba wszystko jebnie)

I z logowaniem to może być też o tyle ciekawy przykład, że możemy pogłówkować gdzie to założenie ma jeszcze sens. I tak np. jak mamy taki staromodny springowy kontroler i tam używamy sobie funkcji, która ma wbudowane logowanie to można chyba założyć, ze jest ok i tagedyi nie ma.

option.map(f)

Ale co jeśli tę samą funkcje wywołamy na sparku i trzepnie nam ona 2GB logów?

rdd.map(f)

I niech teraz mamy druga funkcje f2, która tez loguje - robimy f1.andThen(f2) i nagle mamy 4GB logów. No trochę ku*wa moim skromnym zdaniem jakiś efekt uboczny to już jest. Ja wiem, że dyski tanieją ale nie aż tak szybko.

Takie rozwiązanie nasuwa mi się na myśl. Jeśli funkcja jest dosyć generyczna aż do tego stopnia, ze jest biblioteczna to zrobić ją bez logowania i łatwo można dodać funkcje dekorującą z logowaniem. Wtedy to użytkownik znający kontekst dokona właściwego (oby wyboru)

val f:Int=>Int=x=>x+1

def withLogging[A,B](f:A=>B): A=>B = a=>{
    log(s"param : $a")
    f(a)
}

withLogging(f)(5)
//INFO : param : 5
//res0: Int = 6

A jak wstawię null?

- pojawiało się pytanie "A co się stanie jak tam wstawię null".
To się stanie

Inni też robią!

  • w połowie kwietnia zapowiedział się Damian Warszawski z warsztatem o "Lazy" (i zrozumiałem, że nie ma nic przeciwko, iż wspomnę o nim z imienia :))
  • i jeszcze tam dwóch kolegów się przygotowuje aby coś o Scali porobić

Generalnie jak ktoś chce coś robić to niech śmiało daje znać. Generalnie już widziałem ten schemat n razy. Najpierw ludzie się boją, że publika zada trudne pytania a problemem jest zazwyczaj, że nikt nie zadaje pytań :) Po pierwszym udanym warsztacie zazwyczaj mózg już przestaje sobie wkręcać, że za ścianą czekają lwy i dalsze spotkania robi się dużo prościej. Jeśli chodzi o formę to tez kilka osób ma już doświadczenie także do dzieła!

niedziela, 14 lutego 2016

Plan wspólnej edukacji

Na początek miała być jakaś złota myśl o potrzebie stworzenia solidnych fundamentów wiedzy ale poniższy obrazek, który ktoś wrzucił na twittera będzie znacznie lepszy

Jeśli ktoś jeszcze nie czytał niesamowitej książki zatytułowanej Antifragile to bardzo polecam. Pośród wielu arcyciekawych konceptów jeden jest niezwykle istotny z punktu widzenia tego artykułu . Przewidywany cykl życia idei! Ów koncept może być dla czytelnika z początku mało intuicyjny bo cała mechanika działa inaczej niż z ludźmi jako takim - zoba te bulletpointy:

  • Im dłużej żyje tym mniej życia mu zostało.
  • Im Idea żyje dłużej tym więcej życia jej zostało!

Wytłumaczenie jest niezwykle proste. Idea jako Idea nie rdzewieje fizycznie, nie działają na nie wolne rodniki czy inne takie paskudztwa. Natomiast „Idea” umiera gdy "nosniki" przestają ją „przenosić” czyli konkretnie gdy ludzie przestają w daną Idea wierzyć. A wierzyć przestają gdy się z jakiegoś powodu nie sprawdza.

No i teraz mamy takie programowanie funkcyjne nie jako „język z lambdami” ale jako „Koncepcje przeprowadzenia obliczeń” - i ta koncepcja ma 100 lat prawie! To nie jest byle co ku*wa - 100 lat! I jest respawn teraz globalny! I jak ludzie do tego teraz wracają to znaczy, że ta „idea” przetrwała i coś w sobie ma. (dla porównania ludzie nie wracają do idei "woda posiada inteligencje", za którą ktoś tam kiedyś dostał IG Nobla)

No i np. pierwszy warsztat z Javy 8 za tydzień -> Java 8 warsztat meetup (Taka technika marketingowa niby, że se pisze bloga a podrzucam link). Lambda jako lambda w javie8 to prosta – interfejs z jedną metodą – ale co i gdzie można z tym zrobić to „ooo panie” i to „ooooo panie” jest dosyć uniwersalne – to się chyba mów „language agnostic”. Oczywiście kolejną istotną sprawą jest warsztat języka i jeśli jest za dużo ceremoniału by stworzyć coś „lambdopodobnego” (patrz java 7) to podejście staje się nieproduktywne i ludzie zwyczajnie go nie używają (Idea umiera nim się narodzi).

Za chwilę omówię pewien plan edukacji, który być może uda się zrealizować w tym roku na łódzkim JUGu poczynając od wiosny. Jakkolwiek wcześniej trochę Ideologii by zbudować fundamenty.

Teoria i praktyka

Co jakiś czas na różnych forach informatycznych pojawia się temat „czy tego a tego języka można nauczyć się głównie z książki?” No oczywiście, że nie można bo rzadko kiedy książka potrafi zasymulować skalę wyzwań rzeczywistego projektu. Ale jest pewne ALE. Bo tak z drugiej strony – czy języka/technologii można się nauczyć tylko z pracy w projekcie? Z tego co zauważyłem to jest szalenie niebezpieczne podejście! Dlaczego? Gdyż kiedy ludzie używają narzędzia a nie do końca rozumieją jak ono działa – to generują własne wytłumaczenia symboliczne dla zjawisk, które obserwują.

I tak np. osoba używająca mavena w tzw. „projektach komercyjnych” będzie znała wiele myków, które zaskoczą osobę ze znajomością teoretyczną ale być może ta sama osoba nie rozumie koncepcji mavena jako takiej! Zna strone na stackoverflow , z której trzeba przekleić kod by mieć wbudowane jetty ale jednocześnie nie rozumie jak ten wklejony kawałek ma się do koncepcji systemu budowania projektu.

I np. widziałem ludzi, którzy pisali w języku programowania, wiedzieli jak skompilować , jak uruchomić, jak coś wyświetlić. Ale proces tworzenia był niezwykle symboliczny „może tutaj jak wstawię ifa to zadziała, a może tam trzeba ifa, a tutaj jeszcze nie próbowałem”. Rozwińmy ten temat gdyż jest on niezwykle ciekawy w kontekście tego co dzieje się w informatyce.

Od myślenia magicznego do myślenia analitycznego

Na przykład mamy Hibernate - to dobry przykład bo popularny i sam go kaleczyłem. No i jest sobie ten Hibernate i można go użyć na dwa sposoby.

Raz, że się pozna odpowiednio relacyjne bazy danych, pozna się obiektowe mechanizmy Javy - dojdzie się do wniosku, ze trzeba jedno na drugie zmapować i poszuka czy nie ma przydatnego do tego zadania narzędzia. To będzie podejście takie nazwijmy to pragmatyczno-analityczne.
Dwa - można po prostu użyć Hibernate...no bo jak się czyta baze w Javie to przez Hibernate co nie? No tka przeca mówią na forach co nie?. To możemy nazwać myśleniem magicznym. Zastosowanie narzędzia rośnie tutaj do rangi symbolu uproszczonego poprzez sztuczną redukcję niewygodnych detali.

Albo Spring. Sam, żem kiedyś jebnął tzw. "open session in view". Działało. Psuło wiele rzeczy ale nie wiedziałem tego bo działało. Ostatnio znowu słyszałem o rozsypce przez radosne wrzucanie różnych annotacji tu i tam. Chcemy mieć transakcję - to @Transactional i hejnał!!!

Czy coś mniej oldskulowego - Apache Spark. Widziałem - ludzie używają Dataframe bez większej refleksji, że oto operują abstrakcją nad potencjalnie olbrzymim rozproszonym zbiorze danych. No przeca się wyświetla mój hello world to w czym problem? Tudzież ktoś rozpakowuje zipa ze sparkiem 1.6 gdzies w katalogu temp i ogłasza, że dokonał migracji do sparka 1.6. Cluster sruster - kompiluje się przeca!

A tak klasycznie myślenie magiczne to było np. przekonanie, że kwiaty nie rosną (skutek) bo pada deszcz (przyczyna) ale, ze istnieje siła nadprzyrodzona, która widząc kwiaty (przyczyna) sprawia, że pada deszcz (skutek). Czyli na odwyrtkę i na wysokim poziomie abstrakcji ---> więcej tutaj https://en.wikipedia.org/wiki/Magical_thinking

Także reasumując może warto spróbować podejść „teoria poparta praktyką projektową” lub „praktyka poparta zapleczem teoretycznym” ?

Cel Nauki

Na jesieni miał miejsce ciekawy kurs „programowanie funkcyjne w OCAML” i Na 90% raczej nic w życiu w OCAMLu nie napiszę (chociaż kto wie) - po co więc poświęcać czas na naukę? No bo niczego nie trzeba się w tym przypadku oduczać! Jak uczysz się programowania funkcyjnego w Javie, w której piszesz już kilka lat - to chcesz czy nie - przez swoje doświadczenie będziesz widział lambdy jako konstrukcje Javy na JVM – co samo w sobie jest dobre dla praktyki ale niekoniecznie dla edukacji.

A taki OCAML to było dla mnie wszystko nowe! No i się uczyłem. To było bardzo ciekawe gdyż konstrukcje na zmiennych „mutable”, które w Javie są codziennością (i niestety dla wielu jedynym sposobem rozwiązywania problemów) pojawiły się dopiero w tygodniu 5! Tak dopiero w tygodniu piątym! I jest miejsce na te rozwiązania i zapewne zgadujesz dobrze – zazwyczaj kiedy chodzi o wydajność.

Także to nie jest tak, że mutable jest złe i nie należy tego używać. Mutable jest za to szalenie niebezpieczne i trzeba zrozumieć cenę jaką się płaci za korzystanie z tej techniki. Tak – należy do tego podejść jak do techniki, która się używa gdy jest to potrzebne i płaci się cenę. W Ocaml jeśli dorbze pamiętam obszar minowy "mutable" jest ładnie ogrodzony klamerkami tak by było wiadomo, że zły krok i urwie nogę.

No i jeśli chodiz o optymalizację to poza wydajnością pojawia się też pojęcie zajętości. Czuli O(1) może się tyczyć zarówno szybkości jak i tego ile pamięci zajmują struktury danych. I jak masz mieć zajętość O(1) czyli stałą to nie ma siły – masz ograniczony obszar pamięci niezależny od wejściowego n i coś tam musisz w tym obszarze mutować.

Także absolutnie nie jest tak, że Functional Programming,Fanfary i świętujemy. ale może lepsze zrozumienie teorii pozwoli lepiej zrozumieć kiedy iść w stronę łatwego w zrozumieniu programowania deklaratywnego a kiedy poparte doświadczeniem programisty zanurkowanie w w podejście imperatywne przyniesie więcej pożytku niż szkody. I takie podejmowanie decyzji zdaje się nazywa „bycie inżynierem” :)

W biznesie z tego co zaobserwowałem normą dzienną są pytania „czy naprawdę potrzeba w poczekalni kanapy ze skóry aligatora za 20000 złotych czy może coś za 400 z meblowego na rogu będzie ok”. Czas może by i programiści zaczęli się zastanawiać czy mają obliczeniowy hajs na daną technikę czy nie.

Warsztaty jako edukacyjny proces społecznościowy

Dlaczego forma nauki w postaci warsztatów wydaje się według mnie najlepsza? Chociaż sam często mam potrzebę zredukowania bodźców oraz praca na ogromnych szwalniach „openspacowych” - gdzie w tle otacza nas ogromny szum – jest momentami dosyć denerwująca (i nieproduktywna - zwłaszcza jak codziennie o 16 wdzwania się "biurowy Tenor", który swoim głosem przebija nawet niemieckie techno w słuchawkach i przez 30 minut rozmawia o formatowaniu tabelek w excelu - idzie się po prostu zabić) to jednak ludzie jako ludzie żyli w gromadach od tysiącleci i ogólnie kontakty między ludzkie jak są robione dobrze to są fajne i motywujące.

No i generalnie czasem jak się siedzi tak samemu przy kompie gdzie fejsy,lajki i tweety są w odległości jednego kliknięcia by ukraść nasz cenny czas, który przeznaczmy sobie na naukę to nie idzie za wiele zrobić.A Warsztat pozwala nam uczestniczyć w wydarzeniu społecznym, które poza grupową motywacją do nauki zmniejsza tzw. „barierę wejścia w temat” bo dookoła mamy wiele osób zainteresowanych daną technologią, które mogą nam pomóc (+ do pomocy zawsze skromny prowadzący).

No i na sam koniec badania, które nie wiem czy są prawdziwe ale do pewnego stopnia potwierdzone empirycznie – że jak tylko słuchamy zapamiętamy 20-40% materiału a jak robimy to 90% (procenty pewnie wzięte z dupy). No i osobiście zawsze staram się umieścić cały materiał z ćwiczeniami praktycznymi w łatwo dostępnej formie online aby nikt się nie stresował, że jak czegoś nie zrozumie na warsztacie to już nie nadąży. Zawsze można sobie zrobić ćwiczenia na spokojnie w swoim tempie po warsztacie.

Problem systemowy - Jajko i Kura

"Szukam pracy aby zdobyć doświadczenie ale nikt nie chce dać mi pracy bo nie mam doświadczenia". Czyli standardowy problem - mamy nowy stos technologiczny - a ludzie niestety są nauczeni Javy a nie programowania. Sam to odkryłem u siebie na początku 2013 co mnie przeraziło "ja tak naprawdę umiem tylko Jave a nie Inżynierię programowania". Jakim było dla mnie szokiem gdy się okazało, że polimorfizm to nie jest dziedziczenie/interfejsy i tym podobne "odkrycia".

No i bez solidnych podstaw teoretycznych przejście od jednego paradygmatu do drugiego wymaga kolosalnej pracy. To już nie jest kwestia nauki nowego frameworka - trzeba zrozumieć koncepcje teoretyczne, które z kolei pozwolą zrozumieć pewien kontekst - co z kolei pozwoli zrozumieć np. publiczne pola to nie jest zło (a kiedy jest) oraz dlaczego izolacja operacji od danych raz jest dobra raz jest zła. I paradoksalnie widziałem, że nauka Scali na JVM idzie znacznie lepiej programistą .NET bo oni mieli te konstrukcje dużo wcześniej, te strzałki i monady nazywane u nich LINQ zdaje się.

I znowu wracamy do tego punktu "Teoria i praktyka" - jak kogoś poprostu rzucimy na projekt to może dojść do standardowego StackOverflow-Driven-Development - "Wkleję kawałek kodu z dokumentacji/stack overflow i tutaj teraz mi zadziałało. Dalsze konsekwencję? Skąd mam wiedzieć? Zobaczy się, Hejnał!!!" . Po raz kolejny uważam, że praktyka musi być uzupełniona/poprzedzona budowaniem solidnych podstaw teoretycznych.

No i to własnie będziemy to robić - wspólne budowanie fundamentów teoretycznych uzupełnione ćwiczeniami, które z jednej strony dadzą trochę praktyki małej skali ale na pewno nie zastąpią praktyki dużej skali, która można tylko zdobyć w projekcie. No ale przynajmniej skupimy się na tej cześć na którą mamy bezpośredni wpływ czyli na nas samych.

Plan Nauki

Programowanie funkcyjne

Ponieważ ludzie bardzo chcieli Javy bo na co dzień używają Javy to zaczynamy od Javy8 - Java 8 warsztat 1 (znowu przekaz podprogowy) i faktycznie chcą javy bo 60 osób się zapisało i jest mi z tego powodu naprawdę miło, że ludzie wkładają tyle zaufania w edukacje i te warsztaty.

Jednocześnie bardzo chcę równolegle prowadzić zajęcia z FP w Scali gdyż naprawdę ten język daje dużo większe możliwości jeśli chodzi o tworzenie przeróżnych konstrukcji z programowania funkcyjnego. Na początku materiał Scali i Javy będzie podobny a później w Scali zanurkujemy w bardziej zaawansowane rejony. Generalnie ludzie sobie wybiorą co im bardziej będzie pasować :)

Taka ciekawa historia. „Functional programming in Java” na początku było pisane przez tych samych autorów co „Functional programming in Scala” - później autorzy się zmienili i treść zaczęła stała się bardziej pisana „pod programistów javy”.

I do tego są zakupione dwie książki :



oraz

Pozycja do nauki scali jest znana :




Plus na bardziej zaawansowanych zajęciach wchodizmy w ScalaZ i cats

Gdyby to sobie zwizualizować na rysunku to mamy :

Po czym pojawia się kolejna ciekawa książka do nauki :

To jest o tyle ciekawe, że koleś tam już nie bawi się w rozwiązywanie problemów klasy "posortuje listę" ale próboje w duchu DDD rozwiazać problem domeny bankowej przy użyciu konstrukcji FP na poziomie scalaz czy cats.

Co daje

Czyli by jeszcze raz podkreślić – to nie nauka Scali czy Javy8 ale nauka Programowania Funkcyjnego – koncepcji mającej prawie 100 lat - przy pomocy Javy8 (bo ludzie chcieli) i NIEZALEŻNIE w Scali (bo widzę w niej niesamowity potencjał).

Programowanie Reaktywne

I podobne podejście : nauka koncepcji przy pomocy narzędzia. A tutaj mamy następującą literaturę :




I znowu to jest specjalnie tak wypisane by skoncentrować się na podejściu a w drugiej kolejności na narzędziu.

I teraz mamy

I na koniec temat, o którym mam teraz małe pojęcie czyli "reactive streams" - a że mam pojęcie małe to będziemy się uczyć razem i teraz za dużo nie napiszę

I jak do tego dołożymy typowanych aktorów z tej książki "functional and reactive modeling" to teraz

Typy i „Calculusy”

To jest dla mnie coś nowego i niezwykle fascynującego. O ile w FP pojawia się fraza „function as a first class citizen” tak dalej możemy wyjść z czymś bardziej egzotycznym – co jeśli typ zwracany też można wykorzystać jako wartość? Wtedy pojawia się „type as a first class citizen”. I oto przed nami TDD jako Type Driven Development.

Jest to o tyle ciekawe, że w tej chwili twórcy Scali pracuje nad czymś nowym zwanym „Dotty” https://github.com/lampepfl/dotty. Dotty to chyba scala 3.0 , która uwzględnia coś co nazywa się „DOT Calculus” (DOT - Dependant Object Types). Calculus to „rachunek” i mniej więcej oznacza, że ktoś coś przemyślał i jest jakaś nauka ścisła za rozwiązaniem. Inna Calculus, o którym słyszałem to lambda calculus i to to mówi np. dokładnie kiedy Funktor to Funktor (są konkretne mierzalne warunki do spełnienia) - w OOP nie spotkałem podobnego podejścia - tutaj można dyskutować godzinami czy faktura to intefejs czy klasa abstrakcyjna czy coś tam innego cytując blogi sławnych ludzi. Czasem przyjemnie to się czyta jak ludzie się kłócą ale zazwyczaj wynik jest niemeirzalny i a proces trudny do zautomatyzowania. A w takim ScalaZ w zasadzie są gotowe testy by wrzucić tam naszą customową klaskę i albo jest to Funktor albo nie jest (tak - nie wyolbrzymiam - to jest tak proste).

Haskell

Od Haskella jest Artur Czajka : https://www.gitbook.com/book/tr00per/haskell-101/details. Bardzo dobra edukacja FP.

Inne

Dlaczeo Scala a nie np. Groovy? Jak ktoś chce niech robi ale w epoce kultury masowej konsumpcji mało komu chce się cokolwiek "wytwarzać" (wklejanie cudzych demotów się nie liczy) :) 3 lata temu jak zaczynałem warsztaty ze scali w firmie to pamiętam jak taki ziom narzekał "Scali nie chce ale bym się Clojure pouczył" - Clojure nie znałem to zaproponowałem by sam zrobił warsztat i temat się uciął. Także jak ktoś chce robić Groovy niech się zgłosi i doradzimy w sprawach logistyki i takich tam. Niejaki RobertB chce robić warsztaty z Go bo podobno to tak zajebisty język, że ślina leci. Jak już się spręży to będzie okazja zobaczyć.

Podsumowanie

Zdolnych programistów podobno brakuje. I firmy chcą zatrudniać dobrych programistów i dobrzy programiści chcą pracować z dobrymi programistami. Powyżej to jest własnie taki plan by było wincyj jeszcze wincyj zdolnych programistów - na razie zainteresowanie jest. Będziemy adaptować na bieżąco - jak ktoś chce pomóc niech śmiało się zgłasza.

wtorek, 12 stycznia 2016

Bogaty w Paradygmaty

"Możesz mieć więcej!" - to radosne zdanie możemy usłyszeć w niejednej reklamie atakującej z tv czy internetu. I chociaż sama teza jest dosyć niebezpieczna w świecie programowania bo niekoniecznie chcę mieć więcej linii kodu (a już na pewno pod groźbą odcięcia jajec powinny być zabronione "targety" oparte na ilości linii kodu) to jednak być może dobrze jest mieć więcej "sposobów" pisania tego kodu?

Podobno nasze mózgi są przeładowane informacjami co może tłumaczyc dlaczego proste wyjaśnienia są tak przyjemne i popularne. Był taki moment, że nawet zazdrościłem .NETowcom, że maja tylko jeden powszechnie stosowany framework (nie wiem czy to prawda ale tak słyszałem i tego zazdrościłem) podczas gdy w Javie narzędzi i podejść było "N" co utrudniało życie jeśli chciało się uważać za pragmatycznego bo wtedy musiałeś jakoś uzasadnić dlaczego wybierasz jedno podejście a nie drugie.

W międzyczasie na zupełnie innym poziomie w .NET "wszystko przestało być obiektem" (z tego co słyszałem) podczas gdy programowanie w Javie w wygodny sposób zwalniało nas od myślenia o pewnych sprawach podsuwając "jedyny słuszny paradygmat programowania" (jak lambdy weszły do JAvy8 to ans na grupie .netowcy trolowali, ze w końcu PHP dogoniliśmy).

Jak to zrobić aby było i więcej i lepiej??

Wkrętak uniwersalny?

Powyżej rozkład paradygmatów programowania - jest ich kilka i zazwyczaj nie korzystamy ze wszystkich. Dlaczego?

Z tego co zaobserwowałem większość dyskusji IT o przewadze jednego podejścia nad drugim koncentruje się na pewnych różnicach, które w specyficznej sytuacji ukazują przewagę jednego nad drugim. I tak na przykład ktoś powie ptaki są gorsze od ryb bo średnio sobie radzą na głębokości 10 metrów na to drugi mu przytaknie "że ryby są gorsze bo nie radzą sobie łapaniem planktonu na drzewach". Z drugiej strony każdy z tych gatunków wydaje się mieć pewne zalety, które są wynikiem ewolucji trwającej ileś tam milionów lat (przy sprincie 2 tygodnie policzcie sobie ile musiało być retrospektyw).

Czy podobne zjawiska mogą zajść na gruncie "koncepcyjnym?". Dla przykładu mamy paradygmat1 z ograniczeniem "obiekt ma zmienny stan" i drugi paradygmat2 z ograniczeniem ma być zachowane "referential transparency" (nie wiem jak to łatwo przetłumaczyć ale w skrócie eliminuje to obiekty ze zmiennym stanem i ułatwia bardzo analizę kodu).

I tak co roku na code retreat ćwiczymy podobnie robiąc ograniczenia na zapędy "proceduralne" takie jak "for w forze o tej porze w jeszcze jednym forze i więcej mięsa z dodatkiem if-elsa". I przez to, że ludzie nie mogą robić proceduralnie to w bólach uczą się jak robić obiektowo (jeśli akurat jest Java).

I teraz :

  • Java - od 20 lat robi Code Retreat z ograniczeniem - "robimy programowanie imperatywne" co dla 5% osób, które znam oznacza OOP z dobrymi praktykami a dla 95% tysiące forów zamkniętych w Klasie CosTamManager
  • Haskell - Ileś tam lat rozwija się z ograniczeniem - "ma być referential transparency" - niestety za mało znam ten język i community aby wysilić się na jakiś bardzo śmieszny przykład w tym punkcie.
Czy może teraz jest tak, iż ten pierwszy język dobrze opanował ogarnianie jednego typu sytuacji a drugi ogarnianie innego typu sytuacji? Może... może... może to się przyda w projekcie gdy przyjdzie nam się zmierzyć z obydwoma rodzajami problemów?

Na podparcie tezy cytat z fajnej mądrej książki o programowaniu :

"Adding a concept to a computation model introduces new forms of expres-
sion, making some programs simpler, but it also makes reasoning about programs
harder. For example, by adding explicit state (mutable variables) to a functional
programming model we can express the full range of object-oriented programming
techniques. However, reasoning about object-oriented programs is harder than rea-
soning about functional programs"

W sumie już w Effective Java , która chyba ma z 10 lat jest rozdział który optuje za tworzeniem "niemutowalnych" struktur.

Zanim przejdziemy do dalszych rozważań - jedna ciekawa sprawa. Chociaż przy mojej obecnej wiedzy OOP rozwiązuje głównie problemy zarządzania zmiennym stanem to jednocześnie w wielu książkach o OOP czytałem, ze wszystko jest obiektem i zajebiście da się modelowac/projektować w "obiektówce". No na pewno jak możemy za użyć takich słów jak Customer czy Money to łatwiej przekonać ludzi z pieniędzmi bez wiedzy technicznej, że powinni nam trochę tych pieniędzy dać ale naprawdę OOP nie ma monopolu an rzeczowniki domenowe!

Na przykład taki Haskell - podobno czysto funkcyjny - można takie słówka stworzyć i używać.

data Customer= Customer {firstName::String, lastName::String} deriving (Show)

let c=Customer {firstName="Stefan", lastName:: "Zakupowy"}

Prelude > c
Customer {firstName = "Stefan", lastName = "Zakupowy"}

I od bidy jak jakieś rytuały tego wymagają i UMLa pewnie da się wyrysować. Powąchaj, co czujesz? Money czujesz, profit ku*wa czujesz!

Polimorfizm

Kiedyś polimorfizm wywoływał u mnie "odruch Pawłowa" - polimorfizm<--->dziedziczenie . Jakież było moje zdziwienie, gdy okazało się, że ich jest więcej!

I na przykład takie ad hoc polimorphism. Założmy, że mam pomidory i te pomidory to są takie czyste domenowo pomidory :

case class Pomidor(waga:Int)

val pomidory=Seq(Pomidor(1),Pomidor(4),Pomidor(7))

Jak szybko obliczyć wagę wszystkich pomidorów? Mogę "Ad Hoc" nadać pomidorom nature numeryczną i zwyczajnie je zsumować

implicit val numerycznaNaturaPomidora=new Numeric[Pomidor]{
  override def plus(x: Pomidor, y: Pomidor): Pomidor =  Pomidor(x.waga+y.waga)
  override def fromInt(x: Int): Pomidor = Pomidor(x)
  override def toInt(x: Pomidor): Int = x.waga
  override def toDouble(x: Pomidor): Double = ???
  override def toFloat(x: Pomidor): Float = ???
  override def negate(x: Pomidor): Pomidor = ???
  override def toLong(x: Pomidor): Long = ???
  override def times(x: Pomidor, y: Pomidor): Pomidor = ???
  override def minus(x: Pomidor, y: Pomidor): Pomidor = ???
  override def compare(x: Pomidor, y: Pomidor): Int = ???
}

pomidory.sum  
//res0: Pomidor = Pomidor(12)
//def sum[B >: A](implicit num: Numeric[B]): B

W javie trzeba by jaki interfejs numeric zaimplementować i to jest główna różnica w stosunku do dziedziczenia. No i dopóki do Javy się ograniczałem to nie za bardzo kumałem czym to się różni od "Strategii" - trzeba było mi zerknąć w Haskella.

A co do dziedziczenia to jest to realizacja mechanizmu Single Dispatch i jak się od tej strony podejdzie to łatwiej zrozumieć wady i zalety tego mechanizmu anizeli standardowy przykład, że pies i kod dziedziczą ze zwierzęcia.

Information Hiding

Zazwyczaj w parze z OOP idzie Enkapsulacja i jest to dobra praktyka - ale zastanówmy się skąd ta dobra praktyka wynika i czy obowiązuje tylko w OOP czy też może ogólnie? - a co za tym idzie czy musimy robić OOP by mieć enkapsulację czy też być może można mieć enkapsulację bez OOP?

Otóż jest znowu realizacja bardziej ogólnego konceptu : Information Hiding, który bardziej ogólnie odwołuje się pojęcia modularyzacji. I tak jak np. mamy interfejs List i specyficzną realizację LinkedList to cos sprawia, że to Linked... jest z jakiegoś powodu specyficzne (i błagam kurwa niech się niektórzy zastanowią dlaczego w Javie nie ma IList i ListImpl) analogicznie enkapsulacja OOP ma też w sobie coś specyficznego co drogi czytelniku warto zrozumieć.

Niemniej jednak jeśli chodzi o modularyzacje to Haskell ma moduły, a że to język funkcyjny więc i forma ukrywania informacji w językach funkcyjnych jest!

Jeszcze inna ciekawa sprawa to Pattern Matching. Jest to mechanizm FP (co nie było dla mnie z początku tak oczywiste) i z pozoru rozpościera wnętrzności obiektu po całym programie - ale to jest wizja dosyć błędna wynikająca być może z tego, że np. w Scali Pattern Matching często idzie w parze z "case classes", których nie można do końca utożsamiać z klasami obiektowymi ukrywającymi stan gdyż case class to zwykła forma reprezentacji danych. No a bardziej klasyczną obiektówkę można z "pattern matchingiem" ładnie pożenić.

I tak na przykład mamy taki moduł do gry w karty :

trait Gra[Karta]{
  class Talia (private val karty:List[Karta]){
    def wezZdejmKarte : (Karta,Talia) = (karty.head,Talia(karty.tail:_*))
  }

  object Talia{
    def apply(karty: Karta*)= new Talia(karty.toList)
    def unapply(talia: Talia):Option[Karta] = Some(talia.karty.head)
  }
}

Struktura, która przechowuje karty jest z zewnątrz niewidoczna i pokuszę się o nazwanie tego information hiding. Teraz dokładamy sobie implementację tego modułu gdzie karty to Stringi.

object GraNaStringach extends Gra[String]{
  def maczuj(t:Talia)= t match {
    case Talia("as") => "mam asa"
    case _ => "co innego :("
  }
}

No i jeśli dobrze zrozumiałem całą koncepcję to działa!

import GraNaStringach._
val talia1=Talia("as","walet","dycha")
val (_,talia2)=talia1.wezZdejmKarte

maczuj(talia1) //res2: String = mam asa
maczuj(talia2) //res3: String = co innego :(

Ktoś może zapytać co takiego ma w sobie as, że akurat asa sprawdzamy? Otóż As to jeden z pierwszych polskich Super-Bohaterów!

Abstrakcje

Pojęcie znaczenia abstrakcji jest samo w sobie abstrakcyjne i tutaj jest----> fajna prezentacja o abstrakcjach . Jednak aby za dużo nie odpłynąć to przypomnijmy sobie, że na przykład w Javie częsta dobrą praktyka jest programowanie do abstrakcyjnego interfejsu co daje nam nie raz więcej swobody - i dlatego np. zmienne deklaruje się z typem Collection lub List zamiast od razu obwieszczać "o to mamy LinkedList".

Czasem jednak abstrakcje nie są tak oczywiste i zauważenie ich wymaga skondensowania w nowy sposób z pozoru niezależnych faktów. Być może jest coś wspólnego pomiędzy Optional i CompletableFuture choć z pozoru są od siebie bardzo oddalone? Czy opłaca się czasem zmienić spojrzenie i przekonania na to co "dobre" i "właściwe" w danym kontekście by ujrzeć zupełnie nowe możliwości i odkryć zupełnie nowe podejścia rozwiązywania problemów?

kiedy Dobre jest Niedobre ?

Do tej pory dyskutowaliśmy o tym czy paradygmaty mogą sobie pomóc ale czy mogą sobie przeszkadzać? Czasem zapożyczenie pewnego konceptu z jednego paradygmatu i użyciu go w zupełnie innym kontekście przynosi opłakane skutki co błędnie kończy się skreśleniem konceptu jako takiego.

I tak na przykład często omawiając spierdoliny projektowe dochodzi się do momentu rodem z obiektowego Gmocha "hehe i pojawiły się hehe Utils hehe". I z jednej strony coś w tym jest bo często Utils w projekcie który miał być obiektowy jest świadectwem, ze coś jednak nie wyszło - bo oto mamy wór na luźno powiązane metody, które często jeszcze lubią zmienić sobie jakiś stan w aplikacji i już w ogóle nie wiadomo o co chodzi.

Ale jest taki cierń w oku każdego obiektowego fanatyka, który nazywa się org.apache.commons.lang.StringUtils i działa fenomenalnie? Co tutaj poszło dobrze co nam zazwyczaj nie wychodzi? Wydaje mi się, że w tym umysłowym ograniczeniu "wszystko musi być obiektem" skupiliśmy się na pojęciu spójność u ujęciu takich metryk jak LCOM4, które mierzą spójność obiektu ze względu na interakcje z jego stanem ale jednocześnie nie wiemy dobrze jak zmierzyć specjalizację bezstanowego modułu.

Ukryty Paradygmat

Istnieje jeszcze jeden paradygmat słabo opisany w literaturze nazywany "paradygmat zbiorowego nieświadomym pisaniem chujowego kodu" , który jest skomplikowanym zjawiskiem społecznym, a w którym udział biorą ludzie z całego wachlarza stanowisk korporacyjnych - od góry do dołu. Paradygmat ów stanowi swego rodzaju bramkę, wrota do innych paradygmatów i dopóki nie zostanie okiełznany to w zasadzie wszelkie dyskusje o innych paradygmatach stanowią tylko fantastykę naukową (ewentualnie ów paradygmat można porównać do świątyni na początku fallouta 2 - najpierw trzeba zajebać wszystkie skorpiony a później dopiero można myśleć w którą stronę iść.)

Dyskusje na zakończenie

Wyobraźmy sobie, że mamy dwa paradygmaty poruszania się bieganie i chodzenie. Można by dyskutować, który jest lepszy "jak biegasz to uciekniesz bandytom, - a jak cicho chodzisz to może cie nie zauważą". Ten przykład jest dla nas oczywiście głupi gdyż dotyczy bardzo intuicyjnej codziennej czynności - i dlatego wiemy, że jest głupi!

Programowanie nie jest na tyle intuicyjne dlatego warto najpierw nauczyć się i chodzić i biegać by zrozumieć, że jest bardziej abstrakcyjna forma poruszania się a jej realizacja "zelaży,zależy,zależy od" - i na tym polega bycie inżynierem by wiedzieć od czego zależy. (z drugiej można chyba robić dosyć duży hajs będąc tzw. Evangelistą jakiejś jednej konkretnej rzeczy, także znowu mamy abstrakcyjny koncept "tożsamość w IT" i chociaż bardzo nie chcieliśmy to znowu wpadliśmy w pułapkę "wiedzenia lepiej" - dop. autora)

I jeszcze taka ciekawostka : ponieważ w świecie JVM mamy pewne skrzywienie polegające na tym, że przez ponad dekadę jedynym uznawanym paradygmatem było "chodzenie" (chociaż wiele osób tka naprawdę robiło fikołki - patrz sekcja "ukryty paradygmat") to tak dla równowagi można trochę tak w zdrowych ramach pochejtować i potrolowac to jedyne słuszne "chodzenie" - wiecie tak tylko dla równowagi ale nie można za bardzo odlecieć.

A i jeszcze taki fajny cytat z książki, która jako bazę wiedzy traktuje FP i przechodzi do OOP jako czegoś dodatkowego- tak na łapanie perspektywy : "(...)A function with internal memory is usually called an object(...)"

***

niedziela, 29 listopada 2015

Warsztaty z Dataframe i wyzwania edukacji

Problem : Jak zainteresować słuchaczy czymś co z wierzchniej perspektywy przypomina zwykłą tabele SQL ale jest w sumie czymś innym i stanowi bazę do zgłębiania DataScience na Sparku?

Plan na warsztat jest gotowy i można się zapisywać----> MIGAJACE BOMBKI STRONA MEETUPA MIGAJACE BOMBKI

Zaś materiały są tutaj ---> https://pawelwlodarski.gitbooks.io/workshops/content/spark_dataframes.html

By było ciekawie można..

Nawiązać do rzeczy już poznanych. Ten motyw pojawia się w książce "Power of habit". Podobno przebój OutKast "Hey Ya" wcale nie był przebojem ale wytwornie, które mogą wywierać nacisk na radiostacje ten nacisk wymogły i HEYYA było puszczane pomiędzy przebojami PRZEBOJ<-->HEYYA<-->PRZEBOJ i ludzie się przyzwyczajali.

Dlatego tez warsztat zaczniemy od nieśmiertelnego przykładu zliczania słów z pliku LICENSE. To akurat z pełną powagą powinno ładnie pokazać porównanie pomiędzy RDD i tym co oferuje Dataframe. Ćwiczenia będziemy robić krok po kroku z dokładnym badaniem web UI.

Można dać jakieś ciekawe dane

  • polityka - zły pomysł bo ludzie się pozabijają
  • Coś z wóda bo to zawsze jest śmieszne - ale może lepiej nie bo to niezdrowe
  • Czołgi,pistolety itd - no tez dzisiaj nie da rady
  • To może jednak wóda? Ale nie mogę znaleźć CSV z danymi o wódzie na necie także nie wóda :(
  • No to będzie piłka nożna!

Będzie wczytywanie danych bezpośrednio z CSV, wykrywanie schemy oraz datascience przy obliczaniu statystyk piłkarskich. Czyli na przykład pokażemy jak łatwo znależć najbardziej i najmniej skuteczną drużynę piłkarską + możemy znaleźć co tylko dusza zapragnie.

Można pokazać Sparka w kontekście całego ekosystemu BigData

W tym celu trzeba sobie zainstalować quickstart z cloudery. Powinno to być dosyć łatwe i od razu rozwiązuje problem z tym, ze Spark 1.5 nie działa na windowsie. W trakcie ćwiczeń zaczytamy dane z Hive a Hive zrobił Facebook a Facebook używa realnie Haskella i OCamla co na razie nic nie wnosi ale jest ciekawe

Także to może być dla wielu pierwsze spotkanie z szerszym ekosystemem hadoopa.

Można trochę pokazać języka R

I pokażemy bo R jest od DataScience. Bardzo ciekawy język, z którego pożyczono Dataframes. Przykłady do samodzielnego wykonania możesz znaleźć tutaj --> http://pawelwlodarski.blogspot.com/2015/09/dataframes.html

Można nawiązać do FP

Bo FP jest zawsze ciekawe. Mamy coś takiego :

scala> val fun:Int=>Int = x=>x+1
fun: Int => Int = <function1>

scala> :t udf(fun).apply _
Seq[org.apache.spark.sql.Column] => org.apache.spark.sql.Column

No i teraz możemy zobaczyć, że udf to funkcja, która zamienia (A=>B) => UserDefinedFunction

UseDefinedFunction z powodów praktycznych ma varargsa w apply i poprzez wywołanie (chyba ETA expansion)
UserDefinedFunction.apply _ dochodzimy do (A=>B) => Seq[Column] => Column

Teraz siłą wyobraźni można napisać coś takiego

scala> val lift :(Int=>Int) => (Column=>Column) = f=> a => udf(f).apply(a)
lift: (Int => Int) => (org.apache.spark.sql.Column => org.apache.spark.sql.Column) = <function1>

scala> :t lift
(Int => Int) => (org.apache.spark.sql.Column => org.apache.spark.sql.Column)

(Int => Int) => (Column => Column) to taki naciągany Functor ale zawsze coś zabawnego z Teorii Kategorii. Także zapraszam. --> http://www.meetup.com/Java-User-Group-Lodz/events/225016091/

niedziela, 22 listopada 2015

Funkcyjne Code Retreat

Mięsień nie używany zanika ale mięsień używany ale nie ćwiczony i pozbawiony zróżnicowanych bodźców nie staje się silniejszy. Są różne "mięśnie programistyczne" które możemy ćwiczyć i jednym z nich jest mięsień funkcyjny - dosyć nowy, niedawno odkryty na lokalnych siłowniach i generujący masę hejtu tudzież frustracji u tych, którzy przy jego pomocy chcą unieść problemy cięższe od tych spotykanych do tej pory.

Co roku na CodeRetreat ćwiczymy tworzenie dobrego kodu przy pomocy.... tworzenia dobrego kodu (taka idea ćwiczenia). Klasycznie CR używa wielu technik dobrego kodu OOP i to jest bardzo wskazane bo wiele osób zanim wejdzie w ogóle na płaszczyznę "Object Oriented vs. Functional" musi zrozumieć, że na co dzień pisze szalenie złożony kod proceduralny zbudowany z zagnieżdżonych ifów i pętli.

W trakcie tegorocznego łódzkiego CodeRetreat głównym prowadzacym był Adrian Bolboaca a ja tym razem pełniłem role ciecia do pomocy co zdjęło kilka obowiązków z moich barków i pozwoliło obserwować co dokładnie robią ludzie. Ostatnia sesja na życzenie zgromadzonych była dłuższa i polegała na programowaniu funkcyjnym w języku nie funkcyjnym.

Te funkcyjne konstrukcje są już w Javie8 i w końcu trafią i do twojego korpo także można zacząć ćwiczyć i dziś. A z tego co widziałem trzeba zacząć ćwiczyć FP - oj trzeba.

Toteż poniżej plan ćwiczeń "Funkcyjnego Code Retreat"

Funkcyjny Code Retreat

Idea jest taka by ćwiczenia poza wartością edukacyjną miały zajebiste tytuły podkreślające epickość przerabianego materiału. Opisy są po angielsku z błędami bo akurat tak sobie zapisałem a nie chce mi się tłumaczyć.

  1. Session 1 – „Values are Forever” (enter world when 1 has always value of 1)
    • Theory : explain that most of people already use functional structures in GIT and that immutable data is was already one of good practices in 2006 in Effective Java (why?) Only final variables. Only immutable data structures. This is a warm up session but it’s already give some functional constraints.
  2. Session 2 – “Citizen Function” – (functions as a first class citizens)
    • Theory : Origins of OOP, why you need to encapsulate mutable state, when anemic data is good, what are benefits of separations operations from data? All existing logic can be only defined as Function (Function in Java, val fun:A=>B in scala etc. ) Data is represented by structures. No word “this” allowed (either explicitly nor implicitly)
  3. Session 3a – “Pure Stuff” – (an injection of mathematical purity)
    • Theory: Referential transparency, Unit, Void and () types. Only pure functions allowed
    Session 3b – “Fix the Billion dollar Mistake” (null,NullObjectPattern > /dev/null)
    • Theory: Referential transparency, Unit, Void and () types. How to preserve functional purity in context of value absence. Mindfuck : List as a generalization of option. Use Either Option Or Maybe Optional
  4. Session 4 – “Curry On” – (purest Dependency Injection)
    • Theory: Dependency injection out-of-the box. Only functions with one parameters allowed
  5. Session 5 – “Back to reality” – (mathematical purity is cool but you’ve just got a call from reality)
    • Theory: Functors basics, side effects in the world of functional purity. Log each operation to the console. Each function has to stay pure.

Kiedy?

Biorąc pod uwagę ilość dobrych rzeczy (jak święta) i ilość złych rzeczy (jak nie święta), które mają sie wydarzyć w najbliższym czasie to takie spotkanie powinno się udać zrobić gdzieś w pierwszej połowie stycznia.

czwartek, 12 listopada 2015

Code Retreat 2015 - nie bój się nauki

Global Day of Code Retreat już w tę sobotę ("będzie" albo "był" jeśli nie zdążyłem tego napisać i opublikować). Zapisać może się każdy a link jest tutaj --> Link na meetupie. I oczywiście jak co roku może pojawić się pytanie "ale po co?"

Niestety większość ludzi mylnie utożsamia naukę z ilością czasu jaką poświęcili na daną czynność. Czyli np. "mam 3 lata doświadczenia" jest utożsamiane z "przez trzy lata robiłem w zasadzie to samo, zebrałem ekspa i mogę przejść na super sajana 2". Jeśli się robi przez 3 lata to samo to raczej wiedza nie rośnie a pielęgnujemy te same nawyki. I nie wiadomo czy to jest dobre bo nie wiadomo czy same nawyki jako takie były dobre.

I tak np. ostatnio była dyskusja o tym jakie podejście jest lepsze , w czym i jak pisać itd - czyli dyskusja numer 13719273 o dyskusji. Pojawił się tam jednak ciekawy wątek o tym kiedy tak naprawdę - trochę duży poziom abstrakcji - można stwierdzić, że ktoś ma prawo twierdzić, ze coś jest lepsze od czegoś innego (no mówiłem, że duży poziom abstrakcji)

I pada takie sformułowanie "wypowiadam się o X bo napisałem w tym 14000 linii". I w sumie znałem kiedyś jednego takiego gościa co napisał w Javie 14000 - problem polegał na tym, że on to napisał je wszystkie w jednej klasie :D:D . W sumie to on i pewnie miał doświadczenia na 100.000 linii i na jakieś 6 klas ale znów specjalnie to jest uwypuklone by pokazać, że to wcale nie było dobre. Jak ktoś pisze przez 3 lata nieczytelny proceduralny kod to faktycznie ma 3 lata doświadczenia w pisaniu nieczytelnego proceduralnego kodu.

Cykl Kolba

Spójrz na ten rysunek :

Albo ten :

I teraz zastanów się czy tak podchodzisz do tego co robisz (ha! piszę w drugiej osobie tak jak ci smutni trenerzy rozwoju osobistego "gdy czytasz te słowa zastanów się czy jesteś tak efektywny jak mógłbyś być" ) czyli np. zastanawiasz się krytycznie (ale pod katem rozwojowym) co zrobiłeś źle i co możesz zrobić lepiej (brzmi trochę jak agile za czasów zanim korporacje go nie zjebały) czy może to taki model ala gierki RPG "robie robie robie, experience rośnie , to chyba samo się będzie się robić lepiej jak nowy level dostane co nie?"

no raczej nie

Generalnie kiedy coś robimy - powiedzmy na poziomie A1 to musimy wejść jeden poziom abstrakcji wzwyż na poziom A2, a nawet nie - musimy wejść jeszcze wyżej. Musimy wejść na poziom A3 gdyż na A2 możemy zobaczyć co robimy a na A3 - uwaga bardzo ważne - możemy zobaczyć siebie jak obserwujemy co robimy - bardzo bardzo ważne.

Przeszkoda w samokształceniu numer 1

Dla tych co mają samochody efekt jest znany - "ci co jadą wolniej ode mnie to cioty, ci co szybciej to wariaty!". Ja się spóźnię to wina znowu jebanego kierowcy autobusu, babci na przystankach, korków i kretów co mi an drodze wykopały kopce. jak ktoś inny się spóźni to oczywiście nie umie sobie planować czasu i jego "analytic skils" są słabe bo mógł wyjść wcześniej itd. Można sobie poczytać więcej o np. tutaj --> http://blog.krolartur.com/ja-chcialem-dobrze-ale-on-jest-wredny/

I teraz w czym to dokładnie przeszkadza. Ano w tym , że jak coś mi nie wychodzi to mogę mało obiektywnie stwierdzić "nie działa...no dobra...czego to może być wina... no nie moja oczywiście gdyż nazywam się principal architekt 33 i 1/3... no to chyba.... wiem... to chujowy język". Nie można też oczywiście przechodzić ze skrajności w skrajność bo są naprawdę słabe narzędzia i podejścia ale wspomnianego efektu świadomym być trzeba by mniej subiektywnie stwierdzać tę słabość.

ogólnie tematyka warta osobnego wpisu a opisane bardziej tutaj : https://pl.wikipedia.org/wiki/Teoria_atrybucji. I to tez jest fajne : https://pl.wikipedia.org/wiki/Podstawowy_b%C5%82%C4%85d_atrybucji

W trakcie code retreat między innymi po to się paruje z innymi i kasuje kod by ludzie mogli na luzie pogadać o tym co można zrobić lepiej bo i tak nie będzie dowodów :)

Przeszkoda w samokształceniu numer 2

Efekt Krugera-Dunninga - czyli w sumie dosyć logiczna dytuacja, kiedy nasza wiedza jest na tyle mała, że nie jesteśmy w stanie obiektywnie ocenić, że jest mała i wydaje nam się, że jest duża. Też to w sumie opisałem kiedyś : http://pawelwlodarski.blogspot.com/2013/02/efekt-krugera-dunninga.html bo sam to u siebie zauważyłem.

I to działa tak, że np. Mam grupę znajomych i jak się z nimi spotykam to opowiadam dowcipy i częstą się śmieją (opisuję tutaj sytuację hipotetyczną bo z moich nadal nikt się nie smieje). Myślę - "jestem niezłym kawalarzem". Problem polega na tym, że pomiar został wykonany na wąskiej i dosyć mało reprezentatywnej grupie. Teraz analogia do IT. Np. pisze sobie aplikację i tworzę taki nieczytelny zjebany kod ale dookoła mnie wszyscy tworzą Managery i Helpery a mój kod w sumie najmniej się wywala na produkcji no i do tego manager Franek zawsze mnie poklepuje po plecach za wzorowo wysprzątane biurko- no to chyba jestem jednym z "lepszych zawodników" tutaj "nie no po co mam się znowu uczyć podstaw jak jestem jednym z lepszych zawodników?"

To był chyba jeden ze słynniejszych eksperymentów gdzie wykazano, że jeśli mówisz o kimś "jaki on jest" czyli np. "inteligentny" to ten ktoś będzie wybierał sobie prostsze i łatwiejsze zadania by te ocenę potwierdzić. Masa jest przykładów na necie - można zerknąć także i tutaj --> http://www.focus.pl/czlowiek/azjatyckie-tygrysy-kontra-zachodnie-mieczaki-8208?strona=2

Moja skromna obserwacja - niekiedy przychodzą na code retreat jacyś seniorzy czy architekci i oni momentami bardziej kaleczą kod niż studenci. Sam się dzisiaj czegoś znowu nauczyłem gdy przypominałem sobie to ćwiczenie i w sumie zaraz będę kaleczył kod pastwiąc się nad kodem funkcyjnym.

Przeszkoda w samokształceniu numer 3

Tak zwana awersja do straty. Znowu temat rzeka : https://en.wikipedia.org/wiki/Loss_aversion ale generlanie co roku niektórzy naprawdę przeżywają szok w momencie gdy mają skasować kod. A Własnie o to chodzi, żeby totalnie poczuć, iż to jest nauka, wyluzować i próbować nowych rzeczy. Uważasz, ze masa małych klas to więcej szkody niż pożytku - ok ale poeksperymentuj i nie stresuj się bo kod i tak zaraz zniknie. W sumie to taki snap chat tylko, ze zamiast pokazywać cycki pokazujesz na chwile kod, którego nie jesteś pewien. Reeeeelaks - zaraz zniknie.

Kod

Starczy tego nawijania. To będzie moja 4 edycja gdy prowadzę i 5 coderetreat gdy uczestniczę i naprawdę co roku powtarza się kilka opinii, ze "ło jezu znowu to samo ćwiczenie" a co roku KAŻDEN się uczy na tym bez WYJONTKU. Znudziła ci się Java? We no popróbuj czegoś innego. Za kilka akapitów zamierzam wystawić się na pośmiewisko próbując implementacji w Haskellu. Ale jednocześnie pokaże, jak to ćwiczenie pomoże mi lepiej zrozumieć Javę 8 i Scalę (ba nawet uświadomi mi pewne obszary ze skali, których jeszcze nie opanowałem).

A tutaj rożne sposoby podejść z poprzednich lat :

Łobiektuwka

Zazwyczaj ludzie zaczynają implementacje od tablicy booleanów i arrow coda z tysiącem ifów. Później gdy TDD wkracza do gry i kilku złych nawyków się zabrania - wtedy pojawia się jakaś implementacja w postaci klas czy typów i pierwsze zarysy modularyzacji. No i teraz popróbujmy tego cyklu Kolba czyli trochę refleksji.

Np. obiektowo to może być tak, że faktycznie "zenkapsulujemy" jakiś mutowalny stan :

object RealOOPCells {
  abstract class Cell{
    def evolve(neighbours:Int):Unit
  }

  class LiveCell(private var state:Boolean) extends Cell{
    override def evolve(neighbours:Int): Unit= neighbours match {
      case 2 | 3 => state=true
      case _ => state = false
    }

    override def toString="LiveCell"
  }

  class DeadCell(private var state:Boolean) extends Cell {
    override def evolve(neighbours: Int): Unit = neighbours match {
      case 3 => state=true
      case _ => state=false
    }

    override def toString="DeadCell"
  }
}

Teoretycznie jest dobrze ale własnie teraz przeprowadźmy obserwację. W sumie stan komórki jest tylko częścią równania gdyż równie istotni są jej sasiedzi, którzy już z punktu widzenia komórki "zenkapsulowani" nie są. W toku ćwiczeń i pisania testów w TDD często "samoz siebie" wychodzi, że tak naprawdę nie tyle jest ważny stan ile sam fakt czy komórka jest żywa czy nie. I wteyd można tak (bacznie obserwujcie jak zniknął typ Unit z deklaracji metod - czy to jest łatwiejsze do testów):

 abstract class Cell{
    def evolve(neighbours:Int):Cell
  }

  object LiveCell extends Cell{
    override def evolve(neighbours:Int): Cell = neighbours match {
      case 2 | 3 => LiveCell
      case _ => DeadCell
    }

    override def toString="LiveCell"
  }

  object DeadCell extends Cell {
    override def evolve(neighbours: Int): Cell = neighbours match {
      case 3 => LiveCell
      case _ => DeadCell
    }

    override def toString="DeadCell"
  }

teraz teoretycznie mamy dwa singletony - i mimo panującej nienawiści skierowanej na to słowo - tutaj to akurat dobrze. Bo gdy ludzie dochodzą do tego lub podobnego rozwiązania to nawet nie są świadomi, ze oto wyszli z mainstreamowego nurtu wzorców i zaimplementowali coś co się zwie się Flyweight_pattern czyli waga piórkowa. To po obiektowemu bo po kolejny momencie "AHA" okazuje się, że możemy iść z wytłumaczeniem w tę stronę --> Algebraic_data_type

No i dalej jakoś separujemy informacje o budowie planszy poprzez abstrakcyjne rozumienie współrzędnych :

trait Coordinates{
    def neighbours:Seq[Coordinates]
  }
  case class FlatCoordinates(x:Int,y:Int) extends Coordinates {
    override def neighbours: Seq[Coordinates] = for {
      xe <- (x-1 to x+1) if xe>=0
      ye <- (y-1 to y+1) if (ye >=0 && (xe,ye) != (x,y))
    } yield new FlatCoordinates(xe,ye)

    override def toString=s"($x,$y)"
  }

Fajne jest też to, że mając w Scali REPLa można sobie porobić "Eksperyment Driven Development" (bo musi być jakieś driven development) i posprawdzać czy działa

import LifeLibrary._
LiveCell.evolve(1)
LiveCell.evolve(2)
LiveCell.evolve(3)
DeadCell.evolve(1)
DeadCell.evolve(2)
DeadCell.evolve(3)
/*
res0: LifeLibrary.Cell = DeadCell
res1: LifeLibrary.Cell = LiveCell
res2: LifeLibrary.Cell = LiveCell
res3: LifeLibrary.Cell = DeadCell
res4: LifeLibrary.Cell = DeadCell
res5: LifeLibrary.Cell = LiveCell
 */

new FlatCoordinates(0,0).neighbours
new FlatCoordinates(2,2).neighbours
//res6: Seq[LifeLibrary.Coordinates] = Vector((0,1), (1,0), (1,1))
//res7: Seq[LifeLibrary.Coordinates] = Vector((1,1), (1,2), (1,3), (2,1), (2,3), (3,1), (3,2), (3,3))

No to było trochę gadania o tym by się nie bać eksperymentować to zobaczmy czy można jednocześnie wprowadzić odpowiednią abstrakcje planszy i wykorzystać tak czy inaczej dziedziczoną metode "toString"

 trait Board{
    def liveNeighbourhood:Iterable[Coordinates]
    def cellAt(c:Coordinates):Cell
  }

  class FlatBoard(board:Map[Coordinates,Cell]) extends Board{
    val newLine=System.getProperty("line.separator")

    override def liveNeighbourhood: Iterable[Coordinates] =
      board.keySet ++ board.keySet.flatMap(_.neighbours)

    override def toString: String ={
      val cells=for {
        y<- (0 to 10)
        x<- (0 to 10)
      } yield (x,y,board.getOrElse(new FlatCoordinates(x,y),DeadCell))

      cells.map{
        case (10,y,LiveCell) => "O"+newLine
        case (x,y,LiveCell) => "O"
        case (10,y,DeadCell) => "X"+newLine
        case (x,y,DeadCell) => "X"
      }.mkString(",")
    }
    override def cellAt(c: Coordinates): Cell = board.getOrElse(c,DeadCell)
  }

Wygląda dziwnie, trochę strasznie i niepokojąco. No dobra to było tak w kwestii przypomnienia, a teraz...

Czas an rzeźnię

Research results from the psychology of
programming indicate that expertise in programming is far more strongly related to
the number of different programming styles understood by an individual than it is the
number of years of experience in programming

Code retreat to także szansa na naukę innego języka gdy obok ciebie usiądzie ktoś kto np. programuje w czymś czego na oczy nie widziałeś/widziałaś. Cytat powyższy (ten w szarej ramce) jest podobno autorstwa tego zioma Tim Budd, który jest jakimś tam badaczem IT. I pomimo, że nie chce mi się tego wersyfikować to cytat brzmi fajnie. A do tego np. koncept, który był w Effective Java odnośnie używania niemutowalnych obiektów w sumie lepiej można zrozumieć jak się trochę takiej niemutowalnej codzienności z FP uszczknie w bardziej funkcyjnych językach.

Teraz eksperyment będzie polegał na implementacji choćby kawałka game of life w Haskellu, który jako język czysto funkcyjny nie pozwala na oszukiwanie. I później przeniesienie tego podejścia na Jave8 i Scalę by nauczyć się programowania czysto funkcyjnego w tychże językach. Początek jest obiecujący bo typ Komórki tworzymy po prostu tak :

data Cell = LiveCell | DeadCell deriving (Show,Eq)

Pierwsza rzecz, to nie ma tutaj żadnych powiązań z pojęciem klasy jaką znamy z Javy bo Typ to Typ. A druga kwestia to to "deriving". Tutaj własnie używamy sławnych (bądź niesławnych) "Klas Typów" czyli mówimy, że nasz Typ będzie "porównywalny" i "wyświetlany".

Teraz nasze wymagania co do evolucji komórki

evolveLive 2 = LiveCell
evolveLive 3 = LiveCell
evolveLive _ = DeadCell

evolveDead 3 = LiveCell
evolveDead _ = DeadCell

Apropo tego przykładu można w koncu zczaić dlaczego Pattern Matching to "mechanizm funkcyjny". W scali to za bardzo przypominało rozbudowany "instanceof". a tutaj - przypomnijcie sobie, ze szkoły przypadki gdy definiuje się funkcje, która dla "0 ma taką wartość a dla x!=0 inną - jest to pattern matching na intach na tablicy kredą!!"

I teraz to będzie ciekawe by obadać jak wyjdzie implementacja tego samego w innych językach, najpierw scala

sealed trait Cell
object LiveCell extends Cell
object DeadCell extends Cell

val evolveLive:Int => Cell = n =>  n match{
  case 2|3 => LiveCell
  case _ => DeadCell
}

val evolveDead:Int => Cell = n =>  n match{
  case 3 => LiveCell
  case _ => DeadCell
}

Mamy mechanizm zapewniania typu zamkniętego przy pomocy słówka "sealed" oraz wbudowany pattern matching. A teraz dla porównania Java8.

enum Cell {LiveCell,DeadCell}

Function<Integer,Cell> evolveLive=n-> {
            switch (n) {
                case 2:
                case 3:
                    return LiveCell;
                default:
                    return DeadCell;
            }
        };

        Function<Integer,Cell> evolveDead=n-> {
            switch (n) {
                case 3:
                    return LiveCell;
                default:
                    return DeadCell;
            }
        };

No nie wiem, może robię coś źle że takie rozbudowane konstrukcje mi wychodzą.

Dalej jakiś currying

evolve :: Cell -> Int -> Cell
evolve LiveCell = evolveLive
evolve DeadCell = evolveDead

Takie coś powinno nam pozwolić mapować później sekwencyjnie komórki w jakiejś kolekcji. Jednocześnie znowu czas na refleksję - w obiektówce i tak pierwszym parametrem byłoby this z obiektu i jakieś dynamic dispatch. Tutaj niezależność tej funkcji sprawia, że moglibyśmy ją sobie przekazywać,dekorować, liftować i masa innych ciekawych patentów. I reszta :

Scala:
val evolve:Cell=>Int=>Cell= _ match {
  case LiveCell => evolveLive
  case DeadCell => evolveDead
}
Java:
  Function<Cell,Function<Integer,Cell>> evolve=c->{
            switch(c){
                case LiveCell: return evolveLive;
                default: return evolveDead;
            }
        };

W Javie w switchu ostatnie musi być default bo inaczej kompilator nie przepuszcza. I jeszcze trochę eksperymwntów w Replu Haskella

*GameLive> evolveLive 2
LiveCell
*GameLive> evolveLive 7
DeadCell
*GameLive> evolveDead 3
LiveCell
*GameLive> evolveDead 1
DeadCell

///evolution
*GameLive> :t evolve LiveCell 
evolve LiveCell :: Int -> Cell


*GameLive>  evolve LiveCell 2
LiveCell
*GameLive>  evolve LiveCell 4
DeadCell

Abstrakcja poprzez aliasy

Aby operować słowami domenowymi możemy zamiast tworzenia nowych klas (bo tutaj chyba jako takich klas obiektowych nie ma) stworzyć aliasy typów.

type Coordinates = (Int,Int)
type Board=Map Coordinates Cell

board :: Map Coordinates Cell
board  = Map.fromList [
  ((0,0), LiveCell),
  ((1,0), LiveCell),
  ((2,0), LiveCell)]

Co ciekawe po przeklejeniu tego kodu do Scali trzeba było tylko lekko poprawić definicje mapy i wsio się kompiluje.

type Coordinates = (Int,Int)
type Board=Map[Coordinates,Cell]

val board  = Map[Coordinates,Cell](
              ((0,0), LiveCell),
              ((1,0), LiveCell),
              ((2,0), LiveCell)
            )

Przygotowania do nowej rundy

neighbours (x,y) =[(xe,ye)|xe<-[x-1..x+1], ye<-[y-1..y+1] , ye>=0 ,xe>=0,(xe,ye)/=(x,y)]

liveCoordinates = Map.keys
coordinatesToEvolve liveCoordinates =  liveCoordinates >>= \c -> neighbours c

cellsToEvolve :: Board -> [Coordinates]
cellsToEvolve=Data.List.nub . coordinatesToEvolve . liveCoordinates

Ten kod dla javowca zapewne będzie szokiem ale generalnie nie ma tam nic odkrywczego. "neighbours (x,y)" to nic innego jak iloczyn kartezjański z wyłączeniem środka czyli wszyscy sąsiedzi 2D. Zaś następny kawałek kodu może być ciekawy "liveCoordinates >>= \c -> neighbours c" tak więc ">>=" to flat map a "\c-> neighbours c" to lambda. I w sumie jak na to teraz patrze to ta lambda jest tam nadmiarowa

coordinatesToEvolve liveCoordinates =  liveCoordinates >>= neighbours

Niestety dalej nie umiem tego uprościć a pewnie można. Teraz nauczymy się czegoś w Scali gdy nie ma do dyspozycji całej tej obiektówki

val neighbours:Coordinates=>Seq[Coordinates]= c=> {
  val (x,y)=c
  for {
    xe <- x-1 to x+1
    ye <- y-1 to y+1 if (xe>=0 && ye >=0 && (xe,ye)!=(x,y))
  } yield (xe,ye)
}

val liveCoordinates: (Board) => Seq[Coordinates] =(b:Board) => b.keys.toSeq
val coordinatesToEvolve=(liveCoordinates:Seq[Coordinates])=> liveCoordinates flatMap neighbours

I teraz zaczynają się dziać ciekawe rzeczy bo przez to, że nie widzę, żadnej "standalone" funkcji, która zostawi mi unikalne elementy w kolekcji to muszę kombinować. To jest ten moment gdzie ze względu na czysto funkcyjny charakter ćwiczenia obiektówka w scali nie pomaga bo definiuje metodę "distinct" na instancji.

I mogę to rozwiązać definiując swoją własną funkcję :

val unique=(c:Seq[Coordinates])=>c.distinct
val cellsToEvolve=
  unique compose coordinatesToEvolve compose liveCoordinates

Trochę to marnotrawstwo więc może jakaś metoda generyczna , ETA ekspansion i coś w ten deseń.

def uniqueGeneric[A](c:Seq[A])=c.distinct
val cellsToEvolve2:Board=>Seq[Coordinates]=
  (uniqueGeneric (_:Seq[Coordinates])) compose coordinatesToEvolve compose liveCoordinates

Ewentualnie można coś pokombinować z lambdami

val cellsToEvolve3:Board=>Seq[Coordinates]=
  ((_:Seq[Coordinates]).distinct) compose coordinatesToEvolve compose liveCoordinates

val cellsToEvolve4:Board=>Seq[Coordinates]=
  ((l:Seq[Coordinates])=> l.distinct) compose coordinatesToEvolve compose liveCoordinates

Jak widać rozwiązań jest kilka i każde ma w sobie coś przerażającego. Co do rzeczy przerażających pozostało nam jeszcze :

class Coordinates{
    public final Integer x;
    public final Integer y;

    Coordinates(Integer x, Integer y) {
        this.y = y;
        this.x = x;
    }

    @Override
    public String toString() {
        return "("+x+","+y+")";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Coordinates that = (Coordinates) o;

        if (x != null ? !x.equals(that.x) : that.x != null) return false;
        return !(y != null ? !y.equals(that.y) : that.y != null);

    }

    @Override
    public int hashCode() {
        int result = x != null ? x.hashCode() : 0;
        result = 31 * result + (y != null ? y.hashCode() : 0);
        return result;
    }
}

aaa pola publiczne, wszyscy zginiemy!!! I jeszcze znajdowanie sąsiadów

public static Collection<Coordinates> neighbours(Coordinates c){
        return IntStream
                .rangeClosed(c.x - 1, c.x + 1)
                .boxed()
                .flatMap(x ->
                                IntStream.rangeClosed(c.y - 1, c.y + 1)
                                        .boxed()
                                        .map(y -> new Coordinates(x, y))

                ).filter(coord -> coord.x >= 0 && coord.y >= 0 && !c.equals(coord))
                .collect(Collectors.toList());
    }

Być może na zwykłych forach po bożemu byłoby to bardziej intuicyjne ale ćwiczenie polega - przypomnijmy - na implementacji jak najbardziej czysto funkcyjnej. I dla porównania kod powyżej robi dokładnie to samo co ta linijka w Haskellu :

neighbours (x,y) =[(xe,ye)|xe<-[x-1..x+1], ye<-[y-1..y+1] , ye>=0 ,xe>=0,(xe,ye)/=(x,y)]

Na podstawie tego eksperymentu nie polecałbym Haskella do organizacji gdzie nagradza się za ilość napisanych linii kodu (oni to chyba nazywają Performance Indikator czy coś takiego, taki koncepcik zabrany z już pożółkłych książek epoki industrialnej) natomiast polecałbym do organizacji gdzie każda zbędne linia kodu kosztuje.

I obiecana rzeźnia na koniec

howManyLiveNeighbours :: Board -> Coordinates -> Int
howManyLiveNeighbours b c =
  let neighbourCells=fmap (`Map.lookup` b) (neighbours c) in
  length $ filter (/= Nothing) neighbourCells

--nextTurn :: Board -> Board
--nextTurn =  cellsToEvolve

getCells board=fmap (Data.Maybe.fromMaybe DeadCell)  $ fmap (`Map.lookup`  board)  $  cellsToEvolve board

toLiveNeighbours=fmap (howManyLiveNeighbours  board) . cellsToEvolve

finalSequence=cellsToEvolve board  `zip` (getCells board `zip` toLiveNeighbours board)

Generalnie ten kod jest mieszanką mojej nieudolności w Haskellu i podpowiedzi z pluginu "Stylish Haskell", który robił co było w jego mocy. Dodatkowo nauczyłem się pisać komentarze w Haskellu.

Nauka

Pomimo, że ostatni wklejony akapit kodu jest czystym złem to jego celem nie jest ładnie wyglądać a stanowić szczebel w nauce. Na przykład jak idziesz pierwszy raz na siłkę to raz, że używasz małych ciężarów a dwa to ćwiczysz źle - po prostu źle. Każdy kto ćwiczy kiedyś zaczynał na siłce i 90% procent ludzi to rozumie i pomaga nowym (te 10% to ludzie którzy wstrzyknęli nie w tę żyłę oraz top managerowie, którzy muszą być top performent szczególnie na tle innych). Na szczęście jeszcze nie ma kursów "zarządzanie swoim wizerunkiem na siłowni" i nie trzeba udawać idealności w każdej pozycji z ciężarem w ręku. Podobnie Ty będziesz mógł nie przejmować się bzdurami new age w trakcie ćwiczeń bo kasujesz swój kod a z tego kodu co tutaj wkleiłem w tym artykule ludzie będą się jeszcze długo śmiali (przy optymistycznym założeniu, że ktoś to wszystko przeczyta)