środa, 8 czerwca 2016

Dziwna metoda reduce

Głównym językiem tego posta będzie Java8 której pisanie zużywa klawiaturę jak mało który język.. Ale będzie też o tzw. "sztuce upadania". Był o tym jakiś czas temu artykuł w magazynie Coaching - numer listopad-grudzień 2015. Konkretnie artykuł nazywa się "Dlaczego warto ćwiczyć upadanie" i w formie wywiadu opowiada o toksycznej zdaniem autorów (i nie tylko) obecnej kulturze, gdzie każdy się musi porównywać z człowiekiem obok, zawsze ale to zawsze musi się wszystko udawać a jak się nie udaje to jest tragedyja nad tragedyje.

No i przez to ludzie się boją eksperymentować i tkwią w czymś popularnie zwanym "strefa komfortu". Później w artykule jest porównanie do sztuk walki gdzie ćwiczy się pady i oswaja z sytuacją "gleby", że ta już nie jest straszna itd itp. I właśnie w tym duchu będzie ten post gdzie nie wszystko będzie działało. A w zasadzie cały czas nie będzie działało i dopiero cos pod koniec zadziała.

Ale od poczatku...

Gdzie jest mój Fold????

W Scali i nie tylko mamy na kolekcjach kilka metod, które potrafią zamienić kolekcję w "jedną rzecz". Ta "jedna rzecz" to może być intem jak np. sumujemy cyfry w liście lub nawet i inna kolekcja jeśli chcemy elementy przekształcić i (lub) przepisać. Metody nazywają się "fold,foldRight,foldLeft" i wyglądają mniej więcej tak :

 def foldLeft[B](z: B)(op: (B, A) => B): B 

Mamy element zerowy oraz przepis na doklejanie kolejnych kawałków .Elementy to A zaś element zerowy to B także nie muszą mieć ze sobą za wiele wspólnego. Metoda jest na tyle potężna i uniwersalna, ze można przy jej pomocy zaimplementować większość możliwych operacji na kolekcjach i nawet ma swoją stronę an wikipedii : https://en.wikipedia.org/wiki/Fold_(higher-order_function)

Czy ktoś z was ma swoją stronę na wikipedii? No właśnie...

No i w Javie8 tego nima (albo ja nie mogę tego znaleźć). Za to jest coś innego. W sensie inna operacja i pomimo, że wygląda dziwnie to niesie ze sobą coś równie silnego.

Coś innego

Pierwszy wariant to reduce z tzw. BinaryOperatorem, który jest funkcją (A,A)=>A tyle, że brzmi bardziej obiektowo i zwiększa pule typów dodanych do Javy8

Optional<T> reduce(BinaryOperator<T> accumulator);
Zwraca Optional gdyż w przypadku pustego Streama nic tam nie ma (czyżby rym?).

Druga opcja dostarcza element domyślny nazwany identity i już nie potrzeba Optionala bo wiemy, ze tam coś zawsze jest.

T reduce(T identity, BinaryOperator<T> accumulator);
To co jest warte uwagi to to, że tam je ino tylko jeden typ T.

No i na pewno teraz będzie jakaś sygnatura funkcji z identity o innym typie. No ma sens by tak było.Ma to sens .. ale nima. No prawie nima bo od razu jedziemy z czymś takim.

<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);
To nie jest fold. To jest bardziej skomplikowane. Ale tam dzieje się coś ciekawego.

Nauka w szeroko pojętym znaczeniu

Wymiar ciekawości rozciąga się poza Javę 8 gdyż teraz na Courserze trwa kurs o programowaniu równoległym w Scali - tak w Scali - i tam tę sygnaturę wyprowadzili krok po kroku. Oczywiście na normalnych funkcjach bez wynalazków "BinaryOperator" czy "BiFunction". Ale to jest znowu taka uwaga aby edukację skalować też w szerz a nie tylko wzwyż - czyli zamiast maksymalnego ubijania jednej tylko technologi (albo nawet i kawałka technologi) tylko dlatego, że akurat "w tym robię an co dzień", poczytać trochę rzeczy pobocznych. Cały czas uważam, że jak kto chce lepiej zrozumieć naturę funkcji w Javie to powinien pouczyć się trochę Haskella bo tam te mechanizmy są naturalne.

Bo młodość jest po to by eksperymentować

Od dzieciństwa bardzo marzyłem by zebrać w jednej kolekcji 10 kolejnych liczb parzystych poczynając od zera. I dzisiaj to zrobimy :

        List<Integer> even = new LinkedList<>();


        List<Integer> result1 = Stream
                .iterate(0, e -> e + 1)
                .filter(e -> e % 2 == 0)
                .limit(10)
                .reduce(even,
                        (partial, elem) -> {
                            partial.add(elem);
                            return partial;
                        },
                        (partial1, partial2) -> {
                            partial1.addAll(partial2);
                            return partial1;
                        }
                );

Generalnie obliczenia równoległe tego typu nie mają żadnego sensu bo narzut samej maszynerii będzie dużo większy niż gdyby jeden procek to szybko policzył ale po raz kolejny podkreślimy role edukacyjną tego problemu (także podkreślamy). Metoda reduce przyjmuje trzy argumenty :

  • Element początkowy - tutaj przekazujemy standardową Listę z Javy, która nazywa się "mutowalna" chociaż pewnie takiego słowa w języku polskim nie ma. Programowanie równoległe i kolekcja mutowalna - no co może pójść źle?
  • przepis jak do kolekcji dokładać nowe elementy - pewnie te kawałki pójdą równolegle
  • przepis jak połączyć rezultaty cząstkowe

No i na pierwszy rzut oka działa :

System.out.println(result1);

//[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Ale działa tylko dlatego, że źle tego używam. No i pytanie jaka jest tam rola pierwszego parametru skoro i tak dostajemy rezultat z całego działania. Wszystko się wyjaśni kiedy zaczniemy tego mechanizmu używać poprawnie i dostaniemy błąd.

Równoległe

Poniższy rysunek przedstawia jak "mi się wydawało, że to działa". I nawet jeszcze dzisiaj zobaczymy jak przy pomocy pewnej listy reduce tak własnie zadziała. Ale to będzie specjalna lista a nawet nie lista tylko Wektor a w sumie Vector ale nie ten z Javy tylko inny. A ta teraz to standardowa lista - taka mutowalna - wrzucona między kilka wątków - czeka nas rzeź...

Spróbujmy niezależnie zdefiniować dwie funkcje używany w poprzednim przykładzie :

        Function<List<Integer>, Integer, List<Integer>> accumulator = (partial, elem) -> {
            System.out.println("accumulator : " + Thread.currentThread().getName());
            partial.add(elem);
            return partial;
        };

        BinaryOperator<List<Integer>> combiner = (l1, l2) -> {
            System.out.println("combiner : " + Thread.currentThread().getName());
            l1.addAll(l2);
            return l1;
        };
Dodamy informacje o wątku w którym działają oraz dokonamy obserwacji, że Lista w Javie jest dziwna bo operacje nań wykonane wcale nic nie zwracają i przez to trzeba dodawać dodatkową linię z return. Oczywiście - tutaj mały spoiler - ta obserwacja pojawiła się gdyż cały czas źle tego wszystkiego używamy. Zaraz dojdzie do nas co i jak.

I teraz taki kod:

        List<Integer> even2 = new LinkedList<>();
        List<Integer> result2 = Stream
                .iterate(0, e -> e + 1)
                .filter(e -> e % 2 == 0)
                .limit(10)
                .reduce(even2, accumulator,combiner);


        System.out.println("result2 : "+result2);
        System.out.println("even2 : "+even2);
Generuje taki rezultat :
accumulator : main
accumulator : main
accumulator : main
accumulator : main
accumulator : main
accumulator : main
accumulator : main
accumulator : main
accumulator : main
accumulator : main
result2 : [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
even2 : [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Czyli generalnie wszystko odbywa się w jednym wątku i combiner w ogóle nie jest użyty.

Można to łatwo naprawić dając "parallel" w ciąg wywołań strumienia :

 .limit(10)
 .parallel()
 .reduce(even2, accumulator,combiner);
No i naprawiliśmy problem z ilością wątków i wywołaniem "combinera" :
accumulator : ForkJoinPool.commonPool-worker-3
accumulator : ForkJoinPool.commonPool-worker-4
accumulator : ForkJoinPool.commonPool-worker-6
accumulator : ForkJoinPool.commonPool-worker-5
accumulator : main
accumulator : ForkJoinPool.commonPool-worker-1
accumulator : ForkJoinPool.commonPool-worker-6
accumulator : ForkJoinPool.commonPool-worker-2
accumulator : ForkJoinPool.commonPool-worker-4
accumulator : ForkJoinPool.commonPool-worker-3
combiner : ForkJoinPool.commonPool-worker-4
combiner : ForkJoinPool.commonPool-worker-2
combiner : ForkJoinPool.commonPool-worker-1
combiner : ForkJoinPool.commonPool-worker-2
combiner : ForkJoinPool.commonPool-worker-4
combiner : ForkJoinPool.commonPool-worker-3
combiner : ForkJoinPool.commonPool-worker-2
combiner : ForkJoinPool.commonPool-worker-3
I przy okazji popsuliśmy wszystko inne :
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at java.util.concurrent.ForkJoinTask.getThrowableException(ForkJoinTask.java:598)
    at java.util.concurrent.ForkJoinTask.reportException(ForkJoinTask.java:677)
    at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:735)
    at java.util.stream.ReduceOps$ReduceOp.evaluateParallel(ReduceOps.java:714)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:233)
    at java.util.stream.ReferencePipeline.reduce(ReferencePipeline.java:484)
(...)   
Caused by: java.lang.ArrayIndexOutOfBoundsException: 240
    at java.util.LinkedList.toArray(LinkedList.java:1053)
    at java.util.LinkedList.addAll(LinkedList.java:408)
Jest ReduceOps, AbstractPipeline i kilka innych rzeczy, których przeznaczenia można się jedynie domyślać. Tak czy inaczej nie działa.

To jest ten moment kiedy zaczynasz się zastanawiać : "A może przed włączeniem trzeba było przeczytać dokumentację?". Dokumentacja : https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html w zasadzie ma wydzieloną sekcję Mutable reduction i jasno opisuje, że reduce nie jest do tego. Do rzeczy mutowalnych jest collect a reduce do niemutowalnych. Zaraz przejdziemy do collect ale wcześniej jeszcze jeden eksperyment.

Persystentna Struktura Danych

(słowa persystentna też pewnie nie ma w słowniku)

Użyjemy Vector gdyż podobno twórca Javaslang brał inspiracje ze Scali a w Scali Vector jest zaimplementowany jako drzewo i czasem operacje działają na nim szybciej niż na liście... ale czasem wolniej... generalnie trzeba zawsze mierzyć ... dobra tutaj używamy Vectora by było bardziej kolorowo a nie tylko Lista i Lista

import javaslang.collection.Vector;
Vector<Integer> even = Vector.empty();

Od razu nasze funkcje się uproszczą gdyż operacje na "trwałych" (może to jest to słowo) strukturach danych zwracają nowy rezultat bo inaczej nie miałoby to żadnego sensu.

       BiFunction<Vector<Integer>,Integer,Vector<Integer>> accumulator= (partial, elem)->{
            System.out.println("accumulator : "+Thread.currentThread().getName());
            return partial.append(elem);
        };

        BinaryOperator<Vector<Integer>> combiner=(l1, l2)->{
            System.out.println("combiner : "+Thread.currentThread().getName());
            return l1.appendAll(l2);
        };

I teraz tak napisany kod :

       Vector<Integer> result = Stream
                .iterate(0, e -> e + 1)
                .parallel()
                .filter(e -> e % 2 == 0)
                .limit(10)
                .reduce(even, accumulator,combiner);


        System.out.println("even : "+even);
        System.out.println("result  : "+result);
Działa poprawnie - nie wiadomo czy szybko - ale poprawnie.
accumulator : ForkJoinPool.commonPool-worker-5
accumulator : ForkJoinPool.commonPool-worker-2
accumulator : ForkJoinPool.commonPool-worker-4
accumulator : ForkJoinPool.commonPool-worker-7
accumulator : ForkJoinPool.commonPool-worker-6
accumulator : main
accumulator : ForkJoinPool.commonPool-worker-3
accumulator : ForkJoinPool.commonPool-worker-1
accumulator : ForkJoinPool.commonPool-worker-4
combiner : ForkJoinPool.commonPool-worker-7
combiner : ForkJoinPool.commonPool-worker-2
accumulator : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-1
combiner : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-7
combiner : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-1
combiner : ForkJoinPool.commonPool-worker-1
even : Vector()
result  : Vector(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)

Ten przykład był po to aby czytelnik zdobył lepszą intuicję w rozumieniu różnic pomiędzy "trwałymi" i "nietrwałymi" (tak to an pewno te słowa!) strukturami danych oraz, że trwałe/niemutowalne nie musi koniecznie oznaczać inta - a można tak pomyśleć bo wiele przykładów na necie liczy sumę, zawsze sumę czegoś.

collect

Metoda collect wspomniana w dokumentacji wygląda tak :

   <R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);
Supplier i consumer to klasa tzw. "funkcji dziwnych". Pierwsza tworzy coś z niczego a druga nic z czegoś czyli po prostu połyka argument i generuje jakiś "efekt uboczny". No i w sumie to jest to czego byśmy oczekiwali przy operacji na nietrwałej strukturze danych.
        List<Integer> even=new LinkedList<>();

        BiConsumer<List<Integer>,Integer> accumulator= (partial, elem)->{
            System.out.println("accumulator : "+Thread.currentThread().getName());
            partial.add(elem);
        };

        BiConsumer<List<Integer>,List<Integer>> combiner=(l1, l2)->{
            System.out.println("combiner : "+Thread.currentThread().getName());
            l1.addAll(l2);
        };
Kod wygląda podobnie do przykładu z reduce ale już nie trzeba na siłę zwracać listy po dodaniu elementu.

No to wiooooo :

List<Integer> result = Stream
                .iterate(0, e -> e + 1)
                .parallel()
                .filter(e -> e % 2 == 0)
                .limit(10)
                .collect(() -> even, accumulator,combiner); 

System.out.println(result);
i znowu jebłoooo
combiner : ForkJoinPool.commonPool-worker-3
accumulator : ForkJoinPool.commonPool-worker-6
accumulator : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-5
combiner : ForkJoinPool.commonPool-worker-6
combiner : ForkJoinPool.commonPool-worker-2
combiner : ForkJoinPool.commonPool-worker-6
combiner : ForkJoinPool.commonPool-worker-2
combiner : ForkJoinPool.commonPool-worker-2
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    

Działająca wersja

No to w końcu coś co działa :

(...)
.collect(LinkedList::new, accumulator,combiner);

(...)
combiner : ForkJoinPool.commonPool-worker-4
combiner : ForkJoinPool.commonPool-worker-4
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Generalnie te porażki i potknięcia doskonale tłumaczą po co potrzebny jest Supplier. Każdy z niezależnych wątków musi mieć swój własny "nietrwały" półprodukt aby nie wchodzić sobie w drogę.

Collectors

Jak ktoś już Javą8 się bawił to wie, że jest 100 razy prostszy sposób na osiągnięcie tego wyniku :

.collect(Collectors.toList());

i należy go stosować i zasada DRY tutaj działa. Zapisywanie do listy to częsty i standardowy problem ze standardowym rozwiązaniem - w pracy go używaj. Tutaj słowo klucz to edukacja. Edukacja jest potrzebna aby usunąć symbolikę "abstrakcji kolektora". To trochę tak jak z Hibernate używanym przez ludzi nie znających baz danych. Czasem jak "działa ale nie wiadomo dlaczego" - to jesteśmy o krok od katastrofy. Bo jak nie wiadomo jak to działa to skąd wiadomo czy ten kawałek kodu znaleziony na necie rozwiąże akurat mój problem bez generowania pięciu innych?

Podobnie można podejść do tematu dokumentacji. Tak trzeba czytać. Ale jak sobie tak sam dla siebie eksperymentujesz - to jest to dużo lepszą formą nauki. Jeśli tylko nie pracujesz z zapalnikiem bomby atomowej - zrób sobie laboratorium. Postaraj się przewidzieć, że coś jebnie i faktycznie zweryfikuj. Na pewno w mózgu zostanie więcej niż gdy wszystko się od razu uda. Po to właśnie na Code Retreat usuwa się kod, żeby ludzie przypadkiem nie pomyśleli, że chodzi o kod a nie o czynność jego tworzenia. Jedyne co ma zostać po ćwiczeniu to nowe ścieżki pomiędzy neuronami.

środa, 1 czerwca 2016

Czytelność typów a procent prosty

"Kot rozszerza Animala" - tego typu przykłady są zazwyczaj tłem do nauki programowania. Czy to pomaga? Niedawno ktoś gdzieś podrzucił taki obrazek "Stefan mamy zlecenie na sklep ze zwierzętami - w końcu!! w końcu szkolenia na coś się przydadzą - Cat extends Animal ..."

Czasem trudno zrozumieć siłę pewnych mechanizmów programowania gdy przykłady użyte do ilustracji tychże mechanizmów są tak słabe jak polskie seriale komediowe. Ok ale co w zamian? Otóż można upiec dwie pieczenie na jednym ogniu i zarówno nauczyć się nie tylko jak ładnie programować rzeczy ale równocześnie a nawet bardziej jak ładnie programować przydatne rzeczy. A co jest bardzo przydatne? Bardzo przydatną wiedzą jest wiedza jak działa piniondz.

Nie tylko temat sam w sobie jest ciekawy ale podejście ludzi w jego kierunku jest ciekawe również : Tutaj jest Link do projektu reformy monetarnej w Islandii . O ile mi wiadomo Islandia została najbardziej wydymana na kryzysie i tam też ludzie są zdesperowani do znajdywania odpowiedzi na wiele ekonomicznych pytań - i ważne jest jak oni to robią. Dokument w linku ma 110 stron i to nie jest Lorem Ipsum, znajdują się tam wykresy, uzasadnienia, wykresy i uzasadnienia i tka dalej.

Dla odmiany co chwila na fejsbuku ktoś "udowadnia" (zazwyczaj swoje) tezy ekonomiczne demotywatorami, które zazwyczaj składają się z :
element 1) śmieszny obrazek
element 2) śmieszny komentarz do obrazka

I to w zasadzie tyle. (zazwyczaj każdy najpierw tworzy sobie tezę a później znajduje pasujące doń dowody to już inna kwestia...)

W każdym razie temat wydaje się dobry i rozwiązuje problem wymyślania ciekawych przykładów na warsztaty czy choćby do tego bloga. Na drodze pojawił się jednak pewien problem - otóż sam mam na ten temat niewiele pojęcia...

Rachunek odsetek prostych

Podświadomym zbiegiem okoliczności odkurzyłem tę oto książkę (młodsi czytelnicy mogą nie poznawać tego przedmiotu ale jest to popularna swego czasu tzw "papierowa książka") :

Która po nawet i ciekawym wstępie otwiera wzorem na liczenie odsetek prostych. I jest to już na tyle interesująca rzecz, że można przy jej okazji zbadać dosyć ciekawą technikę "ucztelniania kodu" dostępną w tzw. nowszych językach.

  • Ko - kapitał początkowy
  • r - stopa odsetek w skali jednostki czasu (dni, miesiące,lata)
  • T - liczba dni w jednostce czasu
  • t - ile dni kapitał pracował

Wzór jednocześnie jest prosty ale w kontekście jego implementacji może budzić masę kontrowersji i prowadzić do wielogodzinnych dyskusji o czytelności kodu (do wycieńczenia).

Implementacja

Zerknijmy na coś takiego :

def odsetki(kapital:Double,stopaOdsetek:Double,czas:Int,iloscDniWJednostce:Int)=
    kapital/100 * stopaOdsetek/iloscDniWJednostce * czas

Poza brakującym scaladokiem, który by tłumaczył czym dokładnie są argumenty reszta wygląda całkiem prosto i nawet można by to nazwać "prostym jednolinijkowcem". Również przez chwilę będziemy udawać, że operacje finansowe na Double to dobry pomysł aby ułatwić pokaz edukacyjny. Niebezpieczeństwo nadchodzi jednak z innej strony...

Pierwsza rzecz, która nas nie będzie interesować w tym artykule ale jest na tyle ciekawa, że warto o niej wspomnieć to ilość argumentów. Generalnie mało która zasada czytelności kodu ma pokrycie w kilkudziesięciu latach badań psychologicznych. Tutaj można sobie o tym więcej poczytać : Magiczna libcza 7 a aspekt praktyczny jest taki, że jak np. mamy 3 argumenty i każdy będzie wchodził w interakcję z innymi to mamy 2^3 kombinacji czyli "8" a według badań możemy maks 9 niezależnych elementów ogarnąć czyli 4 argumenty to już 2^4 - za dużo. To jest naprawdę ciekawe, że ta zasada ma jakiekolwiek potwierdzenie w badaniach a nie jest po prostu wygodna dla konsultanta żeby zwiększyć sumę na fakturze,

W każdym razie wywołanie :

odsetki(150.0,5.7,63,360)

Czy jesteś w stanie powiedzieć "co jest co?". Pierwszą próbą uczytelnienia kodu może być nazwanie argumentów (bo w scali można a w javie swego czasu pamiętam, że rozwiązaniem tego problemu było stworzenie buildera i konstrukcja w stylu new Domain.withParam1(...).andSomethingElse(...))

odsetki(
      kapital=150.0,
      stopaOdsetek = 5.7,
      czas=63,
      iloscDniWJednostce = 360)

Czyta się lepiej ale tylko czyta niestety. Generalnie poprawność tego wywołania zabezpiecza jedynie percepcja programisty, którą łatwo zachwiać nieprzyjemną sytuacją na drodze, kłótnią z teściową czy brakiem kawy w pracy (problemy pierwszego świata można tutaj mnożyć). Można do pomocy zaprząc kompilator zabezpieczając wywołanie odpowiednimi typami :

class Money(val value:BigDecimal) extends AnyVal
class InterestRate(val r:BigDecimal) extends AnyVal
class Days(val t:Int) extends AnyVal
class DaysInTimePeriod(val amount:Int) extends AnyVal

def interests(money:Money, rate:InterestRate, time:Days, daysinTimePeriod:DaysInTimePeriod)=
    money.value/100 * rate.r/daysinTimePeriod.amount * time.t

AnyVal i Domena

Klasa AnyVal jest tutaj bardzo istotna , ma ciekawą naturę gdyż w źródłach opisuje ją jakieś 100 razy więcej scaladoca aniżeli sama klasa ma kodu źródłowego. Generalnie jest to ukłon od kompilatora, który rozpakuje klasy rozszerzane przez AnyVal i w runtime zamieni jest w prymitywy - czyli w skrócie będzie "szybciej w runtime" ale "wolniej w kompilacji". Zawsze jest coś za coś. Jak ktoś myśli, że coś jest za darmo to jak młoda sarenka łyka wszystkie przekazy populistyczne. W każdym razie...

Wywołanie teraz wygląda jak poniżej :

interests(new Money(BigDecimal(150.0)),new InterestRate(BigDecimal(5.7)),
new Days(63),new DaysInTimePeriod(360))


Teraz jest bezpieczniej ale znowu mniej czytelnie i można by ponazywać parametry ale gdyby, gdyby gdyby możliwe było coś takiego :
interests("150.0" zloty,"5.7" ratePercent,63 days,360 daysPerYear)
Wygląda czytelniej (ocena subiektywna). (w ostatnim parametrze przekazujemy ilość dni w roku bo jest to wartość umowna - czyli tzw. część domeny. Książka twierdzi, ze bardzo często to wartość 360)

AnyVal i Opsy

Maszyneria jest do dyspozycji, wystarczy tylko zrobić odpowiednie "konwersje niejawne" :

 object InterestsImplicits{
    implicit class MoneyOps(val v:String) extends AnyVal{
      def zloty = new Money(BigDecimal(v))
    }

    implicit class InterestRateOps(val v:String) extends AnyVal {
      def ratePercent=new InterestRate(BigDecimal(v))
    }

    implicit class DaysOps(val v:Int) extends AnyVal{
      def days=new Days(v)
    }

    implicit class PeriodOps(val v:Int) extends AnyVal{
      def daysPerYear=new DaysInTimePeriod(360) //to mozna sobie gdzies zapamiętac by nie tworzyc za kazdym razem
    }
  }

I oto jeszcze raz ten kawałek zadziała :
 interests("150.0" zloty,"5.7" ratePercent,63 days,360 daysPerYear)

Jak już ktoś tykał implicitów to wie, że potrafią one budzić kontrowersje bo nie wiadomo co jest co w którym momencie. Tutaj raczej tego problemu nie ma bo wykorzystujemy ten mechanizm tylko i wyłącznie by uzyskać czytelniejsza formę "metod fabrykujących" i zamiast zloty("200.0") mamy "200.0" zloty co czyta się po ludzku i jest moim niezmiernie skromnym zdaniem również poprawną ilustracją użycia tego ficzeru, że nie trzeba kropki pisać.

No dobra a co z tymi dodatkowymi klasami? Ano nic bo ich tak naprawdę nie będzie w runtime przez to, że dziedzicza po anyval (i znowu kosztem jest czas kompilacji). Ba nawet to zastosowanie jest wymienione w oficjalnej dokumentacji http://docs.scala-lang.org/overviews/core/value-classes.html w sekcji Extension methods

Kod wydaje się i czytelny i zabezpieczony a ten ostatni temat "metody rozszerzone" jest dobrą okazją aby zbadać temat od trochę innej strony.

Extension Methods

Poniższy Kod to już język Kotlin a kod wydaje się jakby mniej skomplikowany i prostszy do ogarnięcia (ale zaraz będzie jedno ważne ale):

class Money(val value: BigDecimal)
class InterestRate(val r: BigDecimal)
class Days(val t:Int)
class DaysInTimePeriod(val amount:Int)

//extensions!
fun String.zloty(): Money = Money(BigDecimal(this))
fun String.ratePercent()= InterestRate(BigDecimal(this))
fun Int.days()= Days(this)
fun Int.daysPerYear()= DaysInTimePeriod(360)

interests2("150.0".zloty(), "5.7".ratePercent(), 63.days(), 360.daysPerYear())

Przede wszystkim ten przykład ma pokazać, że to podejście nie jest tylko "scalowe" . Druga kwestia to zrozumienie jak pewne konstrukcje językowe określają jego charakter. Extension Methods (lepiej zostać przy angielskim żeby było wiadomo co jest co) są dużo prostsze do ogarnięcia w Kotlinie aniżeli w Scali gdyż w tej drugiej wymagają znajomości potężniejszego mechanizmu Implicits. AAAALLLLEEE z drugiej strony jak już znamy Implicits możemy zaimplementować inne mechanizmy jak choćby TypeClasses a Extension Method służy... no chyba tylko do Extension Methods. Tak czy inaczej Java nie ma ani jednego ani drugiego a "project lombok" jest uważany w pewnych kręgach za szczyt ku*wa technologii kosmicznej 22 wieku

"Bo kod się częściej czyta..."

Czasem przy okazji emtikonek w sali w stylu "(_+_)" zagorzali wielbiciele nawiasów i średników lubią podkreślać, że kod się częściej czyta niż pisze. I jest to jak najbardziej prawda ale nie jest to żadnym argumentem na rzecz barokowego języka. Chociaż czytelność to rzecz subiektywna i jest wskazane aby team (pol. drużyna) sama sobie ustaliła warianty jakości kodu to jednak ten artykuł mam nadzieję pokazał, że bogatsze języki umożliwiają pisanie czytelniejszego i jednocześnie bezpieczniejszego kodu aniżeli klasyczna Java.

środa, 11 maja 2016

Typy Danych ale Algebraiczne

Często nie ma co zbyt pochopnie wydawać oceny gdyż wiele zależy od sytuacji i kontekstu :

  • Widzisz kolesia z tasakiem we krwi - krzyczysz "Policja!" - a to tylko rzeźnik wraca z fajki.
  • Widzisz jak koleś wpada do banku z kałachem - krzyczysz "Policja!" - a to tylko kręcą "Nowe przygody Porucznika Borewicza"
  • Widzisz kolesia, który w klasie abstrakcyjnej jawnie odwołuje się do typów, które ją rozszerzają - krzyczysz "Policja Obiektowa !" - a to tylko ktoś sobie implementuje Algebraiczne Typy Danych

"to zależy"

Programiści to ludzie a ludzie lubią jak są jasne zasady, posortowane ,dobro-zło, po przydzielane do danej kategorii i zaszufladkowane. "Czy to jest dobre rozwiązanie? To zależy..." - to niektórych bardzo denerwuje i frustruje bo psuje ścisłe prawa rządzące ich światem.

Ta książka :
Strona 117 (edycja polska, wydawnictwo Helion, copyrajt 2010 itd) :

Jeśli dobrze kojarz Unkel Bob prowadzi firmę "ObjectMentor" (dla młodzieży - Unkel Bob - Robert C.Martin - autor Clean Code) no i jak on sam twierdzi, że nie wszystko jest obiektem i czasem jak coś nie jest obiektem to dobrze, że nie jest obiektem - to może również na pytanie "czy dobre zasady programowania obiektowego są zawsze dobre " - może też zależy? (jak np. "czy bieganie jest zdrowe? No jak stoisz na polu minowym to nie jest- także zależy.")

"Otwarty na rozbudowę / zamknięty na polemikę"

Jest zasada Otwarty na rozbudowę / zamknięty na modyfikację i ogólnie jest to dosyć dobra zasada ale problem polega na tym, że można ją interpretować. Dokładnie tak - programiści ją interpretują i stosują swoją interpretację. Moją interpretacją przez kilka ładnych lat było to, że "trzeba tak napisać klasy i interfejsy, żeby łatwo nowe klasy implementowały te interfejsy a stare klasy były nie ruszane".

Jednak można znaleźć przykłady gdzie zabronienie powyższego procederu tylko wyszło na dobre! Np w uproszczeniu Option w Scali wygląda tak :

sealed trait Option[+A]
final case class Some[+A](get : A) extends Option[A]
case object None extends Option[Nothing]

Sealed to bardzo interesujący mechanizm, którego chyba nie ma w Javie. To takie final ale tylko dla kodu, który nie znajduje się w tym samym pliku - sprawia to, że możemy stworzyć lokalną rodzinę typów zamknięta na dalsza rozbudowę (rozbudowę w sensie dokładania nowych typów bo można o nowe operacje). Nie jestem historykiem-archeologiem ale wydaje mi się, że ten Option jest w Scali od dosyć dawna. W Javie jest Optional, które jest "public final class" i tez ogólnie na rozszerzanie jest zamknięte (i może własnie brak mechanizmu sealed w Javie spowodował, że tam Optional jest zaimplementowany jako taka wolno stojąca pojedyncza klasa ? Nie wiem, być może - to taki strzał z dupy)

Jest jeszcze inny ciekawy przykład...

Jaka cena?

To jest przykład , który z jednej strony ma szanse pokazać, że i czasem przez ponad 150 lat nie ma potrzeby na "rozbudowę typu". I pomimo, że typ nie był rozbudowywany to jest niezwykle użyteczny i praktyczny. Do tego cały czas się ciągnie to słowo Algebraiczne, które brzmi bardzo abstrakcyjnie i matematycznie.

Ów przykład to Algebra Boole'a - i pojawia się tam to słowo Algebra a generalnie może się pojawić bo typy i operacje są jasno określone bo ograniczone . Co by się stało gdyby typ Boolean był otwarty na rozbudowę w rozumieniu "dodawania nowych typów rozszerzających Boolean?"

Jak mamy :

if(costam) {
wariant1
}else{
wariant2
}

To wiadomo, że albo "costam" to albo false albo true (poza językami, gdzie pusta tablica to też false ale to inna historia). I przez to, że jest tak ubogo to jest prosto, a jak jest prosto - to jest bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo bardzo dobrze.

Jak jest prosto to jest bardzo dobrze i tworzenie abstrakcji gotowej na rozbudowę może mieć swoje uzasadnienie ale ma tez swoją cenę!. I jak np. napiszemy kod bardzo abstrakcyjny to nie jest tak, że "dobre bo solid kurde solid" tylko trzeba zadać tez sobie pytanie czy jesteśmy świadomi ceny i czy potrzeba tę cenę uzasadnia.

Czyli to że Boolean to tylko True i False to dobrze - uwaga! "To zależy" . Tak na codzień to chyba dobrze ale już w poniższych linkach wygląda tak trochę jakby nie wystarczyło

Koniec filozofowania

Dobra pisanie tekstu zamiast kodu ma tę wadę, ze muszę potem sprawdzić czy nie ma w nim błędów bo spellcheckerowi daleko do kompilatora. Także tego...

W Scali jakbyśmy chcieli takiego Booleana rezem z operacjami zaimplementować to tak :

sealed trait Bul{
  def and(other:Bul)= this match {
    case Fols => Fols
    case Tru  => other
  }
}
case object Tru extends Bul
case object Fols extends Bul

I teraz mamy rzecz niesłychaną!!! Oto w klasie (a właściwie traicie) abstrakcyjnej mamy Pattern Matching z konkretnymi typami. Ale słuchaj, słuchaj, wdech-wydech, posłuchaj. Wyłącz na chwile reakcję automatyczną ciała migdałowatego i pomyśl - i tak nie dorzucimy żadnego nowego typu, wszystko jest jasno określone tu i teraz więc czemu by tej wiedzy nie wykorzystać? Ano wykorzystujemy.

I w scali fajne jest to, co jeśli źle użyte będzie przeklęte - można czasem olać kropki i nawiasy i wtedy mamy :

println(Tru and Tru) //Tru
println(Tru and Fols) //Fols
No dla mnie wygląda to fajnie. Ale można jeszcze inaczej :
object BulAlgebra{
  def and(left:Bul,right:Bul):Bul=(left,right) match{
    case (Fols,Tru) => Fols
    case (Tru,Tru) => Tru
  }
}
I jest tutaj specjalnie zrobiony błąd bo nie wszystkie opcje są rozpatrzone :
Warning:(29, 35) match may not be exhaustive.
It would fail on the following inputs: (Fols, Fols), (Tru, Fols)
  def and(left:Bul,right:Bul):Bul=(left,right) match{
                                  ^

I zobaczcie co zyskaliśmy przez to, że nie tolerujemy open/close principle po obiektowemu - wszystkie typy są w jednym miejscu i kompilator może mi zwrócić pożyteczną uwagę "o czymś żeś zapomniał i patrz wyjebie się - nie ma za co"

To była Scala a teraz coś z zupełnie innej beczki

Idris

Idris to język - który wygląda jak Haskell plus ma bonusy - taki Super Sajan Haskellz rodziny "bardzo dobrze zaprojektowane ale mało kto umie używać" (tego typu języki napotykają dziwną barierę w organizacjach gdzie "wzrost" jest mierzony "hed kantem"). I generalnie tutaj to normalnie jest Baaaaaaaaaaajka (nie mylić z tym klubem w Mielnie).

data Bul = Tru | Fols

and : (Bul,Bul) -> Bul
and (Tru, Fols) = Fols
and (Tru,Tru) = Tru

I znowu jest specjalny błąd ale tutaj do problemu podejdziemy trochę od innej strony. W Idris możemy sprawdzić czy funkcja jest całkowita czy częściowa gdyż kompilator ma wszystkie informacje o typie - fachowo to się nazywa totality checker.

I po uzupełnieniu :

and : (Bul,Bul) -> Bul
and (_, Fols) = Fols
and (Fols, _) = Fols
and (Tru,Tru) = Tru

I bardzo dobrze. I naprawdę podoba mi się ta nazwa "Totality Checker" - jak taki cyfrowy superbohater.

Kotlin

Kotlin jest o tyle ciekawym językiem, że został stworzony przez tę samą firmę, która stworzyła jedno z lepszych (a być może najlepsze) IDE dla programistów Javy - JetBrains. I to co jest niezwykle ciekawe,to że firma z kilkunastoletnim doświadczeniem z parsowania na lewo i prawo składni Javy stworzyła dla swojego języka składnię podobną bardziej...do Scali. Dokładnie tak - Kotlin jest podobny bardzo do Scali niż Javy - a do tego JetBrains reklamuje go jako język bardzo praktyczny i ma wszelkie "kwalifikacje" aby twierdzić, że wie jak powinien wyglądać język praktyczny. Poniżej przykład ADT w Kotlinie - co moim zdaniem jest bardzo dobre to fakt, że jeśli ten ichniejszy pattern matching z "when" ma brakujące przypadki to kod zwyczajnie się nie kompiluje.

sealed class Bul{
    object Tru : Bul()
    object Fols : Bul()

    fun and(other:Bul):Bul=when(this){
        is Fols -> Fols
        is Tru -> other
    }
}

Także może należy przenieść dyskusje "składnia Javy i składnia Scali" na nowy poziom - "Składnia języków z lat 90tych i składnia nowych języków?". Generalnie kto zna Scalę powinien szybko załapać Kotlina a kto zna Javę -cóż... będzie miał okazję poznać wiele mechanizmów, o których istnieniu nie miał pojęcia.

wtorek, 3 maja 2016

For comprehension ale że w Javie

Pytanie czy w sytuacji gdy chcę napisać po prostu kilka kawałków kodu potrzebny jest jakiś rozbudowany wstęp? Sam sobie odpowiem, że nie i dlatego tylko wspomnę, że będzie tutaj o konstrukcji, która może znacznie poprawić czytelność kodu gdy w naszym kodzie Javowym (tak Javowym) pojawi się koło siebie kilka Optionów czy Futureów.

W Javie8 i są już i lamby i są już reprezentacje "Efektów". I chyba każdy język, który ma lambdy i efekty ma coś co nazywa się "[coś-tam] comprehension" - no tylko Java nie ma... ale w sumie to trochę ma... ale nie do końca. Zresztą zaraz zobaczymy.

Po co w ogóle to comprehension

Nie będziemy się bawić w tworzenie jakiejś sztucznej domeny tylko po prostu jedziemy z trzema optionami.

val option1=Some(1)
val option2=Some(2)
val option3=Some(3)

Jak mamy taki option to możemy kombinatorem/metodą map przetwarzać potencjalną wartość, która weń siedzi przy pomocy takich "czystych" normalnych funkcji.

option1.map(i=>s"result is $i").getOrElse("there is no result")
//res1: String = result is 1

To było proste ale bardziej skomplikowane konstrukcje pojawią się gdy więcej Option-ów musi ze sobą współpracować.I jeśli chce dodać dwa inty z option1 i option2 to będzie to wyglądać tak :

option1.flatMap{i1 =>
        option2.map(i2=>i1+i2)
}

I analogicznie dla trzech :
val result: Option[String] = 
 option1.flatMap { i1 =>
        option2.flatMap { i2 =>
                option3.map(i3 => s"result is  ${i1 + i2 + i3}")
        }
 }
I tak dalej...

Ponieważ im więcej tego będzie tym większy arrow code się wygeneruje dlatego też w Scali mamy do dyspozycji taką oto konstrukcję :

val forResult: Option[String] =for{
        i1 <- option1
        i2 <- option2
        i3 <- option3
} yield s"result is ${i1+i2+i3}"

result.getOrElse("there is no result")
Wynik ten sam a jak się zna ten piękny pokazywany tutaj język to czyta się o niebo łatwiej.

A co jest w Javie? A w Javie...

Mroczne widmo

Przy pomocy standardowych bibliotek w Javie to "se" można takie coś najwyżej zrobić :

Optional<Integer> optional1 = Optional.of(1);
Optional<Integer> optional2 = Optional.of(2);
Optional<Integer> optional3 = Optional.of(3);


Optional<String> result =
        optional1.flatMap(i1 ->
            optional2.flatMap(i2 ->
                optional3.map(i3 -> "result is : " + (i1 + i2 + i3))
            )
        );

System.out.println(result.orElse("there is no result"));

// result is : 6

Ale nie jest jeszcze tak źle bo ten... epizod sżósty... i tak dalej

Nowa nadzieja

Jacyś bardzo dobrzy ludzie - niech im szczęście w życiu sprzyja - stworzyli bibliotekę JAVASLANG , która po pierwsze primo daje nam typ Option, który nie jest tka upośledzony jak Optional z Javy8 (z 5 razy więcej przydatnych nań jest metod). No i bardzo wygodnie się pomiędzy tymi dwoma mapuje.

Option<Integer> dobryOption = Option.ofOptional(Optional.of(1));
Optional<Integer> dziwnyOption = dobryOption.toJavaOptional();

Ale najważniejsze jest to teraz, patrz na to , ej no skup się teraz, przypomnij sobie te flaMapy z poprzedniego punktu i patrz na to, patrz teraz na to :

 API.For(Option.of(1),Option.of(2),Option.of(3))
                .yield((i1,i2,i3)->i1+i2+i3)
                .map(sum -> "result is : "+sum)
                .forEach(System.out::println);
//result is : 6

To jest chyba nówka sztuka : http://static.javadoc.io/io.javaslang/javaslang/2.0.2/javaslang/API.html

Labola.. Rabor... Rabol ... Labolatorium

Scala - wszystkie Optiony Some

for {
      i1 <- Option(1)
      i2 <- Option(2)
      i3 <- Option(3)
    } yield i1+i2+i3

//Some(6)

Javaslang - wszystkie Optiony Some

API.For(Option.of(1), Option.of(2), Option.of(3))
                .yield((i1, i2, i3) -> i1 + i2 + i3).headOption()

//Some(6)

Scala - jeden Option None

val result: Option[Int] =for {
      i1 <- Option(1)
      i2 <- Option.empty[Int]
      i3 <- Option(3)
    } yield i1+i2+i3

//None

JavaSlang - jeden Option None

Option<Integer> result = API.For(Option.of(1), Option.<Integer>none(), Option.of(3))
                .yield((i1, i2, i3) -> i1 + i2 + i3).headOption();

//None

Scala - Interakcja pomiędzy Optionami

 val result: Option[Int] =for {
      i1 <- Option(1)
      i2 <- Option(2 + i1)
      i3 <- Option(3 + i2)
    } yield i1+i2+i3

//Some(10)

Javaslang - Interakcja pomiędzy Optionami

Tutaj trzeba zwrócić uwagę, że składnia jest ciutkę inna ale z kompilatorem Javy chyba nic lepszego się nie zdziała :(

Option<Integer> result = 
        For(Option.of(1), i1 ->
                For(Option.of(2 + i1), i2 ->
                        For(Option.of(3 + i2)).yield(i3 -> i1 + i2 + i3)
                )
        ).headOption();

//Some(10)

No to już tak średnio wygląda ale to nie największy problem...

"Ej a ten headOption?" - czyli nie ma róży bez kolców a ślimak pokaż rogi gdzie kucharek sześć

Trochę tam oszukiwaliśmy w tym Javaslang bo zawsze po wszystkim wołaliśmy "headOption". A stosowaliśmy to gdyż oryginalny typ to :

 Iterator<Integer>
Czyli dostajemy osobny typ zdefiniowany przez Javaslang
package javaslang.collection;

public interface Iterator<T> extends java.util.Iterator<T>, Traversable<T> {...}

Zaś sama deklaracja For wygląda tak :
 public static <T1, T2> For2<T1, T2> For(Iterable<T1> ts1, Iterable<T2> ts2)
Dlatego możemy zapomnieć o użyciu tutaj Optional czy CompletableFuture z Java8 (ale an szczęście są konwersje do javaslang i jest jakiś Future w Javaslang ale nie stosowałem)

Jakie to ma konsekwencje? Np w Scali gdy zrobię obliczenia na typie , który niesie ze sobą więcej informacji niż jest/nie ma to raz, że nie trace informacji o typie a dwa to, że nawet w przypadku failu wiem co się stało.

val result: Try[Int] = for {
      i1 <- Try(1)
      i2 <- Try(1 / 0)
      i3 <- Try(3)
    } yield i1 + i2 + i3

//Failure(java.lang.ArithmeticException: / by zero)
A Javie niestety w kontekście obydwu wymienionych punktów możemy rozłożyć ręce...
Iterator<Integer> result = For(
                Try.of(() -> 1),
                Try.of(() -> 1 / 0), 
                Try.of(() -> 3))
                .yield((i1, i2, i3) -> i1 + i2 + i3);

//Iterator()
Ale i tak to co możemy zrobić z biblioteką Javaslang jest o niebo lepsze niż z samą biblioteką standardową. A pod tym linkiem jest więcej ciekawych inicjatyw : 5 Essentials for a Java 8 Tech Stack

11 Maja będzie warsztat o efektach ubocznych w Javie to będzie można sobie poćwiczyć : Warsztaty Java8 - Funkcje i Efekty Uboczne