33rd Degree 4 Charity we Wrocławiu

Keep things in memory with Cache, Mateusz Herbut

Mateusz na początku przedstawił ciekawą historię, odnośnie tego, dlaczego się zainteresował cache’m i kiedy został zdefiniowany standard JSR-107 - JCache. Fajnie się całość zbiegła z datami z filmu "Powrót do przyszłości", co prelegent dobrze wykorzystał na slajdach.

Mateusz bardzo fajnie przedstawił na diagramach sekwencji różne techniki działa cache'a:

• Cache Aside
• Read Through
• Write Through
• Write Back
• Write Behind
• Refresh Adead

Pierwsze trzy techniki z pośród wymienionych są zdefiniowane przez standard JSR-107, a pozostałe są wspierane dodatkowo przez niektóre implementacje.

Cache Aside jest najprostszy. Klient (aplikacja) sprawdza najpierw, czy wartość jest dostępna w cache’u. Gdy nie, to aplikacja sama odczytuje wartość ze źródła prawdy (dysku, bazy danych, etc.) i jeśli chce, to ją wrzuca do cache’a.

W metodzie Read Through to cache, a nie aplikacja kliencka, jest odpowiedzialna za odczyt wartości ze źródła prawdy i jej zapamiętaniu u siebie na później.

W podejściu Write Through to cache zapisuje wartość do źródła prawdy (synchronicznie) i zapamiętuje u siebie.

Write back zapisuje dane do źródła prawdy, dopiero wtedy gdy dana wartość jest usuwana z cache’a. Podejście to jest często stosowane w procesorach (L1, L2 cache) i wartości te mogą być niespójne ze źródłem prawdy (pamięć RAM). O unieważnieniu cache’a decyduje cache provider.

Przy Write behind klient zapisuje do cache’a i cache asynchronicznie rozpoczyna zapisywanie do źródła prawdy. Gdy w międzyczasie, ktoś będzie chciał odczytać wartości, to dostanie je bezpośrednio z cache’a.

W ostatniej metodzie Refresh Ahead cache decyduje podczas odczytu, czy wartość trzeba odświeżyć, czy nie.

Dalej było jeszcze o 3ch rodzajach operacji jakie mogą być wywoływane na cache’u:

• Pessimistic locking
• Lock free
• Optimistic locking

ale tu już nie będę przedstawiał, które są które.

Bardzo fajna, mięsista prezentacja. Uwagi odnośnie sposobu prezentowania  przekazałem wieczorem bezpośrednio Mateuszowi.

-XX:+UseG1GC, Jakub Kubrynski

Następnie Jakub Kurbyński ładnie omówił Garbage collector G1, który na być domyślny w Javie 9. Prelegent fajnie przeszedł przez to w jaki sposób jest zorganizowana pamięć w Javie i jakie to ma konsekwencje dla algorytmów odśmiecania. Stopniowo powoli odkrywaliśmy nowe pomysły w sposobach organizacji pamięci i algorytmów odśmiecających.

W G1 mamy wiele faz, ale dokładniej były omawiane 4:

• Young GC
• Concurrent cycle
• Mixed GC
• Full GC

Young GC to odśmiecanie młodej generacji, odpalane po zapełnieniu wszystkich regionów typu Eden. Jest ono wykonywane równolegle i zatrzymuje naszą aplikację. Concurrent Cycle bazuje na wynikach poprzedniej fazy i stara się znaleźć regiony łatwe do odśmiecenia i je oznacza. Mixed GC uwalnia te obszary z poprzedniej fazy. Czyści on pamięć zarówno z młodej generacji, jaki i starej. Najgorzej, gdy dojdziemy do Full GC (jak go zobaczymy w logach), gdyż on odśmieca całą pamięć i zajmuje sporo czasu, bo wykonuje się jednowątkowo. Powinniśmy tego unikać.

Fajne było podsumowanie, jak tuningować G1. Najlepiej ustawić:

-XX:MaxGCPauseMillis=250

lub na inną empiryczną wartość. Wtedy G1 będzie starał się nie przekroczyć zadanego czasu na odśmiecanie. Oczywiście gdy wartość będzie zbyt mała to się to nie uda. Złą stroną tuningu jest natomiast ten slajd:

czyli flagi których należy się wystrzegać ;)

Jeszcze inne dobre praktyki to:

A do przeglądania logów warto skorzystać z GCViewer, JVisualVM i Mission Control.

Nagranie z Confitury, polecam sobie obejrzeć:

Później była przerwa obiadowa, po której na prezentację Tomka Dziurko "Brzydka Pani od HR radzi…” po raz N-ty nie chciało mi się iść (widziałem na YT), a konkurencyjny temat mnie nie zachęcił. Filmik z prezentacji Tomka poniżej:

Liquibase - zarządzanie zmianami w relacyjnych bazach danych, Marcin Stachniuk

W kolejnym slocie przyszedł czas na moją prezentację. Grono zainteresowanych było niewielkie, bo w drugiej sali w tym czasie mówili o mikroserwisach po raz 144. Slajdy (trochę zaktualizowane od ostatniego razu) poniżej.

Ze zmian (po za kolorkami dopasowanymi do konferencji) to istnieje łatwiejszy sposób na wprowadzenie Liquibase'a do istniejącego projektu, niż ten który przedstawiałem na WrocJUG'u. Można skorzystać z komendy changeLogSync, która to tworzy i wypełnia danymi z changelog'a tabele potrzebne do działania biblioteki (DATABASECHANGELOG i DATABASECHANGELOGLOCK), a same zmiany nie są wykonywane. Po więcej szczegółów zapraszam na stonę Liquibase'a: Adding Liquibase on an Existing project.

Drugą wartością dodaną do prezentacji jest moje subiektywne porównanie Flyway'a i Liquibase'a, ale kot nie był niech żałuje.

Java 9, Arkadiusz Sokołowski

Prelegent pokazał parę nowości które nas czeka w kolejnej wersji Javy. Było oczywiście o REPLu i modułach, czyli projekcie Jigsaw i jak to na nas wpłynie. Prezentacja była ok, ale gdzieś już coś o nowościach słyszałem...

Java developer meets AngularJS/JavaScript: real-world projects’ experiences, Marek Matczak

Prelegent pokazywał z początku popularność różnych języków programowania, gdzie górował JavaScript i Java. Marek proponował te dwa języki do obecnych projektów, a dokładniej Spring-Boot’a i AngularJS’a.

Prelegent przedstawił, jakie są możliwości połączenia tych dwóch światów, od strony budowania aplikacji. Jedno podejście, to łączenie części frontend'owej z buildem Maven’owym. Można do tego wykorzystać maven-assembly-plugin, który buduje zzipowaną aplikację kliencką, a później za pomocą exec-maven-plugin można uruchomić node.js’a. A całość do WAR’a można wrzucić za pomocą: maven-war-plugin’a.

Drugie podejście proponowane przez Marka to wykorzystanie exec-maven-plugin’a do budowania frontendu w trakcie fazy generate-sources. Zasoby te wrzucamy do src/main/resources/static, czyli tam gdzie standardowo Spring Boot się ich spodziewa.

Całość jest dostępna na GitHubie jako Open Application Standard Platform (OASP).

Z ciekawostek, które mi utkwiły, to warto się przyjrzeć Google JavaScript Style Guide i Idiomatic JavaScript, aby wiedzieć jak dobrze pisać kod w JavaScript’cie.

Warto też na przyszłość przyjrzeć się Isomorphic JavaScript. Dzięki temu, będziemy mogli wyrenderować stronę HTML po tronie backend'u, co pozwoli nam np. na szybsze ładowanie się strony głównej naszej aplikacji.

Muszę się również przyjrzeć Gulp’owi, gdyż on ma wbudowane reverse proxy.

Dzień 2
On-heap cache vs. Off-heap cache, Radek Grębski

Drugi dzień zaczął się bardzo mięsistą prezentacją na temat pamięci off-heap, czyli pamięci po za standardowym heap’em Javowym. Jest to pamięć, która nie jest zarządzana przez Garbage Collector, można w niej zapisywać tylko tablice bajtów (korzystająć ze standardowego API) i sami musimy zajmować się jej zwalnianiem.

Generalnie bardzo polecam tą prezentację, jest dostępne nagranie z Confitury 2015 jak i kod na GitHubie: https://github.com/rgrebski/confitura2015

Trochę podsumowując prezentację:
Aby zaalokować pamięć w Javie, można skorzystać z następujących klas: HeapByteBuffer (na stercie [heap], do 2 GB), DirectByteBuffer (po za stertą, do 2 GB), MappedByteBuffer (po za stertą, do 2 GB, pamięć perzystowana), Unsafe.allocateMemory() (więcej niż 2 GB).

Pierwsze 3 klasy mogą allokować do 2 GB ponieważ jako argument przyjmują int’a, który ich ogranicza. Bardzo ciekawą klasą jest MappedByteBuffer, która tworzy buffer w pamięci, który może być zapisywany do pliku na dysku. Ma on tą przewagę nad wszystkim innym, że w przypadku całkowitego crash’u maszyny wirtualnej zapis i tak się powiedzie. Operacja ta jest zapewniana przez system operacyjny.

Chcąc allokować pamięć większą niż 2 GB to już trzeba korzystać z Unsafe’a. Korzystanie z tej klasy nie jest łatwe i wygląda jakby sam Chuck Noris ją pisał. Właściwie ta klasa z definicji miała być dostępna tylko dla „zaufanego kodu”, czyli do wewnętrznego użytku przez Javę. Ale coś poszło nie tak i obecnie masa frameworków i bibliotek z niej korzysta. Co gorsza to klasa ma być niedostępna w Javie 9, więc będzie ciekawie. Sporo kodu trzeba będzie przepisać, albo znaleść haka, aby się dostać do odpowiedniego modułu.

Dalej było o Chronicle Map. Jest to mapa, która jest zapisywana po za stertą. Jest też perzystowalna, dzielona pomiędzy osobnymi procesami JVM (również po sieci). Jedynym minusem jest fixed size, tzn. musimy wiedzieć jak duże będą nasze obiekty. I tak dla String’ów i kolekcji musimy za pomocą @MaxSize zdefiniować jak maksymalnie długie będą nasze teksty i jak wielkie kolekcje w obiektach. Gdy przekroczymy granicę to dostaniemy błąd. Obiekty zapisujemy do bloków o stałej wielkości - trochę pamięci się marnuje, ale dostęp do niej jest łatwiejszy.

Dalej było sporo porównań szybkości działania Mapy i Chronicle Mapy. Następnie prelegent opowiedział jeszcze z grubsza o Hazelcas’cie i Redisie, które również porównał z Chronicle Map.

Purely functional data structures, Tomasz Kaczmarzyk

Na początku zaczęło się o tym jak w językach funkcyjnych są zaimplementowane Listy, że składają się z głowy i ogona, że ogon wykorzystuje dokładnie tą samą strukturę co pierwotna lista itd. Kto się uczył Skali, lub innego języka funkcyjnego, to na pewno kojarzy koncept.

Póżniej było już ciekawiej, o tym jak jest zbudowana kolejka w językach funkcyjnych, w której można dodawać elementy na końcu. W standardowej liście jest to bardzo kosztowna operacja. Kolejka wprowadza pewne ciekawe pomysły, jak może ona być wewnętrznie zorganizowana, aby efektywnie przeprowadzać operacje na niej, mi.in. dodawania elementu na końcu. Ten fragment prezentacji był bardzo fajny.

Następnie było o tym jak wewnętrznie jest zorganizowany Git i jaka to jest ładna struktura danych. Temat był mi już wcześniej znany, więc mnie aż tak nie zachwycił jak poprzednia część.

Prelegent miał bardzo fajne slajdy (pisane kredą po tablicy), z ładnymi animacjami przejścia.

Sane Sharding with Akka Cluster, Michał Płachta

Tutaj było mnóstwo programowania na żywo, które działało! Prelegent się dobrze do tego przygotował.

Na początek napisał pojedynczego aktora obsługującego jakieś zapytania i zrobił test wydajności. Następnie, razem z publicznością, udoskonalał rozwiazanie… Implementowaliśmy system rozdzielający paczki na taśmociągu w jakimś magazynie.

Jako drugi krok, prelegent dorzucił drugiego aktora, który tylko podejmował decyzję o przeznaczeniu paczki. Następnie pojawili się kolejni aktorzy i to już bardzo przyspieszyło obsługę zapytań. Na koniec był jeszcze przedstawiony Akka cluster, aby można było to łatwo skalować na więcej maszyn.

Kod z prezentacji jest dostępny tutaj: https://github.com/miciek/akka-sharding-example. Warto przejść sobie po commit'ach i zobaczyć jak się aplikacja rozwijała.

Recepta na retrospekcję z finezją, Wòjcech Makùrôt

Retrospekcje są wpisane w Agile Manifesto jako dwunasty punkt:

At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

czyli:

W regularnych odstępach czasu zespół analizuje możliwości poprawy swojej wydajności, a następnie dostraja i dostosowuje swoje działania do wyciągniętych wniosków.

Prelegent podał i opowiedział na przykładach swoje 10 punktów, które trzeba spełnić, aby mieć dobrą retrospektywę. Postaram się streścić, jak ja to zrozumiałem.

• Trzeba się dobrze przygotować. Spisać sobie plan spotkania, załatwić wszystkie niezbędne pomoce materialne, poszukać inspiracji, aby nie było nudno.
• Wprowadzamy jakiegoś IceBreak’era, aby rozmawiało się na luzie. Można odwrócić krzesła w sali, aby ludzie musieli zrobić coś innego. Prowadzący spotkanie (facylitator) może być niemerytoryczny - do niego należy moderacja i czasem pacyfikacja spotkania. Najważniejsze jest zdanie innych.
• Sprawdzamy, czy z poprzedniej retrospekcji udało nam się zrealizować jakieś postanowienia. Jeśli nic się nie udało, to powinniśmy przerwać i zastanowić się dlaczego się nie udało.
• Możemy opowiedzieć historyjkę, odnośnie tego co działo się w ostatnim sprincie. Budujemy przez to naszą wspólną świadomość.
• Grupowanie i priorytetyzowanie problemów - powinniśmy zajmować się tylko tymi najważniejszymi problemami.
• Dziel i rządź, czyli z którymi problemami jesteśmy zdolni sobie poradzić, i które będą miały największy wpływ na poprawę naszej sytuacji.
• Analiza przyczyn, dlaczego coś nie działa. Tutaj możemy skorzystać z metody 5x dlaczego, ość Ishikawy
• Planowanie naprawy, czyli: co trzeba zrobić, jak, kto będzie za to odpowiedzialny i na kiedy. Nie warto brać więcej niż 4 tematy do naprawy, bo to może być niemożliwe do zrealizowania.
• Celebracja tego do czego udało się dojść, czyli warto podziękować za współpracę, nagrodzić jakoś uczestników, wyjść na piwo...
• Śledzenie postępów w kolejnej iteracji, czyli sprawdzanie wykonania zadań.

Jako źródło inspiracji, warto spojrzeć na retrospectivewiki.org i blog.accentient.com/upgrade-your-sprint-retrospective-meetings oraz do książki Agile Retrospectives.

Slajdy z wystąpienia:

Refactoring meets big money, Michal Gruca

Prelegent przedstawił 3 możliwe podejścia do refactoringu:

• Codzienny refactoring
• Pisanie całości od nowa
• Przepisywanie modułów i podmienianie

Tylko jak to wszystko wytłumaczyć i sprzedać biznesowi? Warto zdecydować się na mierzenie jakiś metryk kodu. Można wziąć jakieś Sonarowe metryki dobrych projektów open source, porównać z metrykami naszych projektów, przełożyć na kasę i strać się wytłumaczyć, że to jest ważne. Warto zrobić sobie sceeena tych metryk z naszego projektu, aby później, po serii refaktoringów, zobaczyć czy i ile się poprawiło.

Warto też, przed pójściem do biznesu, trochę się przygotować. Można stworzyć jakieś prototypowe rozwiazanie i pokazać, że ono przynosi nam jakąś wartość. Przykładowo przyspieszymy build’a albo release’a.

Prelegent polecał do przeczytania fane case study, jak to Soundcloud przechodził na mikroserwisy.

Common fallacies of micro services, Marcin Matuszak

Prelegent w ciekawy sposób podszedł do tego, w jaki sposób obecnie są wynoszone pod niebiosa mikroserwisy, kontrargumentując potencjalne zalety jakie nam daje to podejście. I tak możliwość pisania każdego mikroserwisu w innym języku jest kiepski, bo jak ktoś napisze coś w bardzo egzotycznym języku (którego mało kto zna) i później się zwolni z pracy, to trzeba będzie nauczyć się tego języka, aby utrzymywać kod.

Monolityczne aplikacje wcale nie są takie złe. Są łatwe do pisania testów, w deploymencie i utrzymaniu. Jak rozmawiamy o mikroserwisach, to się skupiamy na tym, że mają być serwisy i że mają być małe. A zapominamy że mają sie komunikować po sieci, co przysparza masę dodatkowych problemów. Jeśli zepsuliśmy aplikację monolitową, to również i zepsujemy mikroserwisy.

Podsumowując całość, była to bardzo fajna konferencja, w końcu coś ciekawego i większego zawitało do Wrocławia. Nie miałem wysokich oczekiwań co do prelekcji, a okazały się one na dobrym poziomie. Byłem więc pozytywnie zaskoczony tą konferencją. Jednocześnie sam miałem okazję wystąpić i wyświetlać swoje slajdy po raz pierwszy na kinowym ekranie.

Rusza rejestracja na tegoroczną Warsjawę oraz moje tematy

Już niedługo (21.09.2014 21:00) ruszy rejestracja dla uczestników Warsjawy - darmowej konferencji, która składa się z samych warsztatów! Liczba miejsc jest ograniczona, dlatego warto się spieszyć, zwłaszcza, że jest szansa na warsztaty, które będzie prowadził Venkat Subramaniam! Jest to założyciel Agile Developer, autor wielu książek jak i świetny prelegent, którego mieliśmy okazję wielokrotnie oglądać na polskich konferencjach. Styl jego prezentacji jest specyficzny, a o części jego wystąpień można przeczytać na moim blogu.

Dzięki wizycie Venkata w Warszawie, udało się go zaprosić także do Wrocławia i poprowadzi on wykład Programming with Lambda Expressions w ramach WrocJUG. Będzie również warsztat: Programming Concurrency - Workshop, ale na niego nie ma już miejsc, a lista oczekujących jest długa.

Jednocześnie zapraszam na warsztaty, które sam będę prowadził w ramach Warsjawy. Poniżej przedstawiam tematy, które będę prowadził, wraz z krótkim komentarzem.

Czas: Piątek, 26 września 2014 13:00
Temat: Upiększ swoje testy. Testowanie jednostkowe dla średnio zaawansowanych

Opis: Warsztat jest przeznaczony dla średniozaawansowanych programistów Java, którzy napisali już trochę testów i chcieliby je upiększyć. Podczas warsztatu będziemy ćwiczyć tworzenie ładnej sekcji given (za pomocą Builder'ów), jak i czytelniejsze zapisywanie assercji (za pomocą Hamcrest'a, FEST'a i AssertJ). Bedzie jeszcze o testowaniu wyjątków i testach parametrycznych. Warsztat będzie prowadzony po polsku, względnie może być po niemiecku;) Wymagane jest zabranie ze sobą własnego komputera ze skonfigurowanym środowiskiem programistycznym i opcjonalnie konto na GitHub'ie (do przesyłania gist'ów).

Być może, jak starczy czasu, będzie można poćwiczyć jeszcze inne rzeczy, ale to już zależy głównie od prędkości grupy, jak i zainteresowania tym, co będą chcieli usłyszeć uczestnicy.

Czas: Sobota, 27 września 2014 16:00
Temat: Poznaj lepiej swoje środowisko programistyczne i zwiększ swoją produktywność z IntelliJ Idea

Opis: Każdy programista powinien poświęcić 10 godzin na dogłębne poznanie swojego zintegrowanego środowiska pracy, aby móc z niego efektywnie (i efektownie) korzystać! A Ty ile czasu na to poświęciłeś? Warsztat jest przeznaczony dla programistów Java, korzystających z IntelliJ Idea, lub chcących się go nauczyć. Warsztat będzie miał formę Coding Dojo, podczas którego będziemy wspólnie pisać Katę i wzajemnie uczyć się korzystania z Idei bez użycia myszki. Warsztat będzie prowadzony po polsku, względnie może być po niemiecku;) Własny komputer nie jest wymagany, gdyż będziemy kodować wspólnie na jednym, podpiętym do rzutnika. Przyda się za to notatnik i długopis do zapisywania nowopoznanych kombinacji klawiszowych.

Na pomysł tego warsztatu wpadłem po tym, jak go z wielkim sukcesem przeprowadziłem w ostatnim projekcie. Po prostu, gdy udało się kupić IntelliJ Idea dla całego zespołu (o co bardzo ciężko walczyłem - skutecznie), musiałem wdrożyć kolegów w nowe środowisko. Wcześniej pokazywałem jedynie czym się różni Idea od Eclipse'a, ale to nie to samo co praktyka przy klawiaturze. Nie chciałem również słyszeć narzekań, że teraz trzeba się na nowo uczyć wszystkich kombinacji klawiszowych.

Zebrałem więc cały zespół, wyjaśniłem zasady i poszłooo! Było bardzo intensywnie, śmiesznie i co najważniejsze pouczająco. Ludzie wychodzili wówczas z sali z ugotowaną głową, ale widziałem później, że te warsztaty bardzo im pomogły. Zebrałem również bardzo pozytywne opinie na retrospektywie.

Mam nadzieję, że na Warsjawie będzie równie gorąco.

P.S. W razie jak byście chcieli się wcześniej zapisać na warsztaty, to przeczytajcie ten status.

Konfitura, marmolada, dżem, powidło i spiżarnia, czyli wrażenia po confiturze 2014

Rapid dev environments, Marcin Brański i Przemek Hejman
Prelegenci opowiadali o tym w jaki sposób tworzyć środowiska developerskie, a właściwie ich konfiguracje i obrazy, aby później można było je szybko odtworzyć np. na nowej maszynie. Chłopaki bardzo sprawnie i płynnie mówili, widać, że przećwiczyli to wystąpienie wcześniej. Ale niestety używali w swoich wypowiedziach sporo skrótów, które nie koniecznie musieli wszyscy znać. Pokazywali również sporo detalów, a zabrakło mi jakiegoś big picture, co do czego jest, oraz czym różnią się opisywane rozwiązania.

I tak oto było o następujących narzędziach: Packer.io, Puppet, Vagrant, Ansible, Chef, Salt, Fabric, Docker i Fig (nakładka na dockera). Niestety z powodu znikomej znajomości tematu nie jestem w stanie nic więcej tutaj napisać.

Git nie dla początkujących, Tomasz Borek
Tomek na początku przedstawił różnicę, pomiędzy surowym repozytorium (utworzonym z flagą --bare), a zwykłym repozytorium. Dalej już było ciekawiej. Prelegent pokazywał, co tak naprawdę jest potrzebne w katalogu .git, aby istniało repozytorium. I tak są to katalogi: objects i refs/heads oraz plik HEAD z zawartością (np.: „ref: refs/heads/master”). Ciekawa sztuczka, ale trwała trochę za długo i prelegent miał problemy z koordynacją, tj. czy klepać w klawiaturę, trzymać mikrofon, stać, siedzieć, czy mówić do mikrofonu stojącego na biurku (o którym później prelegent kompletnie zapomniał).

To było trochę jako ciekawostka, ale Tomek omówił również, po co są pozostałe katalogi i pliki. I tak w description jest opis projektu, który nie jest nigdzie pushowany i prawie nigdzie nie używany. W info/exclude można zignorować pewne pliki, których nie chcemy wersjonować. Przydaje się to w momencie, gdy mamy jakiś plik z ustawieniami lub hasłami, który tylko lokalnie powinien być dostępny, a z jakiś powodów nie chcemy go ignorować za pomocą .gitignore.

Jeszcze było o  wewnętrznej budowie commit’a. Ogółem git’a można potraktować jak acykliczny graf skierowany. Pojedyńczy commit może wskazywać na drzewo lub inne commity, drzewo wskazuje na BLOBy lub drzewa, a w BLOBach zapisywana jest zawartość plików. Co ciekawe, to nazwy plików nie są zapisywane w BLOBie, a w drzewie. Dlatego łatwo jest wykrywać zmiany położenia plików, nawet jak częściowo zmieni się zawartość.

Było jeszcze o root-commit’cie, który jest praojcem wszystkich commit’ów. Jak jakiś inny commit nie jest w stanie osiągnąć tegoż praojca, to znaczy, że jest wiszącym commit’em i można go usunąć. Swoją drogą ciekawi mnie, skąd się biorą takie wisielce? Chyba jak nie usuwamy niezmerge'owanych branchy z flagą -D, lub jakiś pojedynczych commit'ów, to nie powinno dochodzić do takich sytuacji.

Dalej było wspomniane, że nie warto wrzucać duże pliki do repozytorium. Nawet jak te pliki tam umieścimy, a następnie usuniemy, to i tak strasznie nam to spowolni pracę z git’em. A ciężko takie coś usunąć z historii tak, aby jej nie popsuć.

Oczywiście ta prezentacja nie mogłaby się odbyć z pominięciem tematu funkcji skrótu SHA1. Organizacja NIST(National Institute of Standards and Technology), która to ogłosiła ten algorytm, obecnie wycofuje się z niego i zaleca zastąpienie go SHA3. Ale w Gitcie ta funkcja skrótu nie jest wykorzystywana w celach kryptograficznych a identyfikacyjnych, więc zagrożenie jest naprawdę niewielkie. Co prawda można wygenerować plik, który będzie nam kolidował z czymś w repozytorium, ale na to pewnie też się znajdzie obejście. Po za tym zmiana funkcji hashującej wymusiłaby zmianę protokołów git’a, a ta jest dodatkowo tak zoptymalizowana, że trafia z chache CPU.

SHA1 jest wykorzystywana w Gitcie do identyfikowania commitu i innych obiektów. Dla commitów wystarczają nam zazwyczaj pierwsze 6, lub 8 znaków tegoż skrótu. Największy otwarty znany projekt hostowany na Gicie, czyli linux kernel, potrzebuje 12 znaków do identyfikacji commit’a. Wartości te są widoczne w .git/objects i są one pogrupowane w podkatalogi, aby nie osiągnąć maksymalnego limitu ilości plików w jednym katalogu i aby można było je szybko odszukać.

Było jeszcze o różnicy w sposobie przechowywania zmian w gitcie, a w SVNie. I tak SVN przechowuje różnice w plikach. Natomiast Git przechowuje całe pliki i gdy się nic w nich nie zmienia, to aktualizuje tylko wskaźnik na aktualną wersję pliku. Nie jest to do końca prawdą, gdyż gdy repozytorium nam rośnie, to git przechowuje stare rewizje również jako różnice w pliku i dodatkowo je kompresuje. Najnowsza wersja jest zawsze przechowywana jako pełen plik, gdyż najczęściej jej potrzebujemy. Dodatkowo Git został zoptymalizowany pod względem ilości zajmowanego miejsca na dysku.

Tomek wspomniał również o komendzie add w trybie interaktywnym, gdzie można wybrać, które zmiany w danym pliku wejdą do commita. Było również o takich poleceniach jak squash (pozwala złączyć commity w jeden), rebase (modyfikuje historię) i instaweb. Ta ostatnia komenda git’a pozwala przeglądać historię repozytorium przez przeglądarkę. Niestety funkcjonalność ta, póki co, nie działa w mysysgit na Windowsie(#11).

Z rzeczy poza Gitem z prezentacji dowiedziałem się o fajnej powłoce ZSH i o nakładce na nią ze zbiorem fajnych rozszerzeń: Oh My ZSH.

Prezentacja bardzo fajna. Spodziewałem się trochę więcej o komendach typu plumbing i tego co się pod spodem dzieje, gdy wywołujemy komendy typu porcelain. Ale o tym można sobie doczytać (nawet po polsku) w książce Pro Git 9. Mechanizmy wewnętrzne w Git, a prezentacja Tomka była dobrym wstępem do tego.

Po tej prelekcji niestety zmarnowałem trochę czasu na chodzeniu po stanowiskach sponsorskich, ale mówi się trudno. Ominięte wykłady oglądnę, gdy już zostaną opublikowane.

Clean architecture - jak uporządkować architekturę Twojej aplikacji. Wnioski z projektu. Andrzej Bednarz
Prelegent opowiadał, o swoim greenfield projekcie, w którym wraz z zespołem postanowili poszukać dobrej architektury. W tym celu przejrzeli to, co wielkie autorytety tego świata mówią i piszą w tym temacie i zaczęli podążać ścieżką promowaną przez Wujka Boba, a mianowicie Clean architecture.

Podejście nie jest jakoś szczególnie nowe. Mówi o odseparowaniu GUI i baz danych od naszej logiki. Każda sensowna architektura o tym mówi. Kluczowe w czystej architekturze jest odwrócenie zależności, tj. aby nasz core aplikacji NIE był zależny od bazy danych, frameworka GUI i innych komponentów. Czyli w naszych encjach powinniśmy przechowywać przykładowo datę w formacie typowym dla daty, a nie zdeterminowanym przez bazę danych, czy ORM. Innymi słowy, musimy mieć zależności DO naszej aplikacji. Więcej powinien wyjaśnić ten rysunek ze strony Wujka Boba:

Podejście takie powoduje, że nie jesteśmy uzależnieni od używanych framework'ów i możemy je łatwo wymienić. Zyskujemy również na łatwości testowania naszej logiki biznesowej. Architektura ta wymusza jednak pewien narzut na tworzenie warstw abstrakcji, wielu DTO i konwersji między różnymi obiektami.

Prezentacja była ogółem fajna. Andrzej pokazał na przykładzie kodu, jak to wygląda u niego w projekcie. Osobiście zabrakło mi trochę porównania w kodzie, z typową architekturą 3warstwową, aby móc uświadczyć różnice. Wadą wystąpienia było patrzenie prelegenta przez plecy, na kod wyświetlany na ścianie, aby pokazywać gdzie coś jest. Jak by nie można było włączyć odpowiedniego trybu pracy z rzutnikiem.

JVM and Application Bottlenecks Troubleshooting with Simple Tools Daniel Witkowski
W tym roku było sporo wykładów na Confiturze dotyczących szybkości działania tworzonych przez nas aplikacji. Prelegent pokazał kilka prostych sztuczek, jak wyłapywać problemy w naszych aplikacjach.

Na początku trzeba ustalić nasze wymagania jakościowe, czyli SLA, czas odpowiedzi, ile requestów na sekundę musimy wytrzymać itd. Następnie prelegent odpalił przygotowaną aplikację, „klikający” w nią JMeter i obserwowaliśmy, co nam pokazuje nam JVisualVM. I gdzieś tam chyba z Thread Dump’a wyczytaliśmy, że gdzieś jest ręcznie wywoływany Garbage Collector. Oczywiście wiadomo, że to jest zła praktyka, ale można zawsze ją wyłączyć, za pomocą flagi -XX:+DisableExplicitGC.

Będąc już przy temacie GC, to warto zawsze zapisywać logi z jego działania i przeglądać za pomocą GCViewer.

Inną pożyteczną wiadomością, jaką ze sobą niesie JVisualVM, jest podgląd wątków. Można tam przykładowo sprawdzić, czy liczba wątków http (przyjmujących żądania) jest taka jak się spodziewamy. Gdy będzie tylko jeden, to nie dobrze, bo requesty będą obsługiwane sekwencyjnie.

Wykres aktywności wątków, może również pokazać nam problemy z synchronizacją i blokowaniem się. Może to świadczyć o niewłaściwym użyciu słówka synchronized (np. na metodzie doGet()) lub innych mutex’ów. Jeśli widzimy, że wiele wątków nam się blokuje, to musimy znów w Thread dumpie szukać miejsc, gdzie coś może być nie tak.

Warto też spojrzeć, czy nie mamy problemów z odczytem / zapisem na dysku. W Linuxach można to sprawdzić za pomocą top’a, a na Windowsie poprzez Process Explorer. I tak jeśli dyski nie wyrabiają, może to oznaczać, ze mamy włączony za wysoki poziom logowania. Przy tej okazji w końcu zrozumiałem zasadność takich zapisów:

if(log.isDebugEnabled()) {
     log.debug(createLogMessage());
}

Jeśli ktoś napisze jakieś długotrwające operacje w metodzie createLogMessage(), to powyższy if, spowoduje, że nie będą ona wykonywane, gdy są i tak niepotrzebne. I tu bardzo fajnie widać wyższość Scali, gdzie taki argument mógłby być wyliczany w razie potrzeby.

Ponadto jakie nie wiemy w jaki sposób jest zaimplementowane isDebugEnabled(), to lepiej odczytać tą wartość raz i trzymać gdzieś w systemie.

Na koniec była jeszcze (na szczęście krótka) reklama narzędzia Zing Vision, jako że prelegent jest przedstawicielem Azul Systems. Firma ta jest również producentem maszyny wirtualnej Zing, która wg. producenta jest lepsza od implementacji Oracla.

Working with database - still shooting yourself in the foot? Piotr Turski
Prezentacja Piotrka bardzo mi się podobała, gdyż w moim projekcie doszliśmy do prawie tych samych wniosków co prelegent, a o drobnych różnicach mogliśmy sobie porozmawiać na Spoinie.

Piotrek korzysta w swoim projekcie z dwóch baz: H2 i Oracle. Jednak H2 nie do końca sprawdzała się w testach, gdyż czasem pojawiały się błędu specyficzne dla Oracla. Przykładowo w klauzurze in nie może być więcej niż 1000 elementów. Jest to dość znany problem, ale u Piotrka wyszło to dopiero na produkcji. Innym problemem było wykorzystywanie specyficznych możliwości „wyroczni” w zakresie wyszukiwania po umlautach (üöä). H2 tego nie obsługiwało, więc nie dało się testować. Innym problemem był typ Date, który na Oracle, inaczej jak na H2, po za datą zawiera również dokładną godzinę.

Z tych powodów w projekcie prelegenta testy integracyjne puszczano na Oracle, i każdy developer miał pod ręką dla siebie takową bazę. H2 nie zostało jednak wyrzucone z projektu (mimo 3 rund rozmów na ten temat), gdyż jest lżejsze, szybsze, i tylko kilka funkcjonalności na nim nie działa.

W takim wypadku, warto mieć mechanizm czyszczenia bazy na potrzeby testów. Można to załatwić DbUnit’em, ale utrzymywanie plików z danymi jest kosztowne. Po za tym narzędzie to nie zresetuje sekwencji. Można próbować również próbować przywracać dane z backup’a, ale to również może prowadzić do innego stanu bazy. Problematyczne jest tutaj usuwanie constraint’ów i powiązanych z nim index’ów. Dlatego warto wygooglać, jak można resetować bazę na Oraclu i dopasować rozwiązanie do własnych potrzeb.

Przy takich akrobacjach, warto zadbać o proces wprowadzania zmian na bazie danych. Piotrek używał w tym celu flyway, a ja u siebie korzystałem z liquibase. Nie można wtedy niestety ręcznie robić hotfix’ów. Zaletą jest to, że do testów można wtedy budować bazę tak samo jak na produkcji.

Warto również wprowadzić mechanizm testu „produkcyjnego deploymentu”. Chodzi o to, aby zgrywać stan z produkcyjnej bazy danych (schemat i dane) i wykonać deployment aplikacji (co wymusza wykonanie migracji). Zyskujemy wtedy pewność, że nic nie powinno się posypać przy roll out’cie.

Było jeszcze trochę o testowaniu integracyjnym z bazą danych, np., gdy chcemy sprawdzić HQL’a. Można do tego zaprząc wspomnianego już DbUnit’a, ale analizowanie później czemu test się wywalił, jest czasochłonne. Lepiej przygotować dane do testów w teście. Przecież i tak mamy zapewne możliwość zapisywania naszych encji w bazie, więc możemy to wykorzystywać w setupie naszych testów. Warto również przy tej okazji skorzystać z Builder’ów.

Programowanie JEE'ish bez stresu Jakub Marchwicki
Prelegent opowiadał na początku o tym, że warto czasem zbudować jakąś aplikację, wykorzystując inne technologie, niż standardowy Spring, Hibernate i JSF. Pozwala nam to przypomnieć, co te technologie załatwiają za nas, oraz jak działają pewne rzeczy na niższym poziomie. Do tego są lekkie, a przecież nie zawsze potrzebujemy tych wszystkich kombajnów, aby skosić 2m² trawnika.

I tak Jakub pokazał kilka alternatywnych rozwiązań:

• Jetty + sql2o
• Jetty + RESTEasy + MyBatis
• Spark + jOOQ
• Webbit + jdbi
• Dropwizard

Opisywane przykłady, można sobie tutaj przejrzeć: github.com/kubamarchwicki/micro-java

Zakończenie konferencji.
Na zakończenie konferencji było jeszcze losowanie nagród, wręczanie statuetek, podziękowania dla wolontariuszy itd. Szkoda, że część konkursów była wcześniej rozwiązywana, tj. w przerwach międzywykładowych. Niszczyło to szansę potencjalnych zwycięzców. Oganizatorzy od razu zapowiedzieli, że rejestracja w przyszłym roku będzie poprawiona i nie będzie tak długiej kolejki. Trzymam za słowo.

Na koniec była jeszcze impreza: Spoina, gdzie można było jeszcze trochę pogadać, zjeść pizzę, napić się piwka i pograć w kręgle. Bardzo fajne zwieńczenie tej konferencji, na którą 1400 wejściówek rozeszło się w 2 godziny od rozpoczęcia rejestracji.

Organizatorzy namawiali jeszcze do udziału w siostrzanej konferencji tj: w Warsjawie. A ja ze swojej strony dziękuję za super konferencję i zachęcam do nowej inicjatywy dBConf.

DevCrowd 2014

W tym roku udało mi się ponownie (bo po raz drugi) zawitać na konferencję DevCrowd do Szczecina. Nie jest to kolos kalibru GeeCona czy 33rd Degree, ale tworzy ona swój własny specyficzny klimat. Przygotowano nawet aplikację na androida, pomagającą w podjęciu decyzji, na którą prelekcję wybrać się aktualnie. A do wyboru były dwie równoległe ścieżki.

Rozpoczęcie konferencji przeciągnęło się mocno, przez co do obiadu wszystkie wystąpienia zostały przesunięte o kilkanaście minut. Na szczęście po obiedzie wszystko wróciło na swoje miejsce.

Na początek udałem się na prezentację Macieja Opały i Wojtka Erbetowskiego pt. Designing API for Mobile App. Jak więc projektować serwerowe API dla aplikacji mobilnych? Przede wszystkim z powodu powolnych łączy komórkowych, problemów z zasięgiem, przemieszczania się użytkownika, należy ograniczyć liczbę przesyłanych danych do minimum. Jeśli wystawiamy po stronie serwerowej RESTa, to lepiej jest przesyłać dane za pomocą JSONa niż XMLa. W przykładzie prelegentów, pozwoliło to na zmniejszenie wielkości wiadomości o 37%.

Warto również korzystać z Cache’a Http po stronie serwera, jak i Androida. W telefonie można w tym celu skorzystać z tych narzędzi: retrofit, OkHttp i HttpResponseCache. Dobrym sposobem na zmniejszenie rozmiaru paczki danych przesyłanej przez sieć, jest skorzystanie z kompresji GZIPa. Trzeba jednak uważać, gdyż dla małych plików, może ona nie opłacać się.

Przedstawiony był również problem wersjonowania naszych Interface’ów. Wynika on z opóźnionego aktualizowania aplikacji na telefonach użytkowników, czyli mogą wymagać starego API. Najlepiej, aby się ono nie zmieniało, ale najczęściej jest to niemożliwe. I tak można podawać Path parameter (np. http://api.example.com/res/v1) media type (lub custom header) (np. http://api.example.com/res+v1) albo subdomenę (np. http://v1.api.example.com/res). Wszystkie rozwiązania posiadają jednak swoje wady.

Na koniec wspomniano jeszcze o narzędziu Swagger, do tworzenia dokumentacji (coś ala javadoc) dla RESTowych aplikacji.

Zawsze bałem się prezentacji, gdzie jest dwóch prelegentów. Najczęściej oznaczało to, że prowadzący zbytnio nie znają się na temacie, lub mają opory przed wystąpieniami publicznymi. Tutaj jednak wypadło to dobrze i sprawnie.

Na drugą prezentacje wybrałem wystąpienie Mateusza Kaczmarka pt. Good design makes us happy – czyli podejmij tę decyzję za mnie. Na początku Mateusz polecał książki, od których wszystko się u niego zaczęło, czyli pozycje Dona Normana (nie pamiętam którą dokładniej) i Steva Kruga Don’t Make Me Think. Na zajawkę zamieszczam prezentację z TEDa tego pierwszego Pana.



Następnie prezentacja była wypełniona przykładami, gdzie zastosowano fajne, udane pomysły, jak i przedstawiono firmowe porażki. I tak Apple swego czasu było warte więcej niż polskie PKB, Amazon stworzył przyjemny proces zakupowy, Google uznało, że wyszukiwanie musi być proste itd. Natomiast w sektorze gier, firma EA zdobyła 2 razy z rzędu tytuł najgorszej firmy roku w USA. A zasłużyła sobie na to, dzięki wypuszczaniu niedokończonych tytułów. Inaczej było w przypadku Diablo 2 i Starcrafta, na które wydawcy kazali sobie dłuuugo czekać, co zostało sowicie nagrodzone. Również Blizzard (wydawca Diablo) pokazał, jak można naprawić swoje błędy. Przykładowo firma zamknęła sklep, za pomocą którego gracze handlowali przedmiotami w grach, gdyż to psuło rozrywkę. I ogłosili to ludzie wyglądający jak gracze, a nie panowie w garniturkach.

Co więc robić aby uzyskać UX User experience? Dla ludzi biznesu trzeba wkładać więcej wykresów do naszych aplikacji, a dla szarych Kowalskich należy upraszać nasze interfejsy graficzne. Dzięki temu użytkownicy czują się bezpieczniej i będą korzystać z naszej aplikacji. Warto też podejmować typowe decyzje za użytkownika, ograniczając mu liczbę opcji do skonfigurowania, gdyż najgorzej to stracić zaufanie użytkownika, a jeszcze gorzej jego pracę.

Prezentacja fajna, aczkolwiek był to raczej wstęp do tematu, który nie jednemu zapewne uświadomił istnienie problemu. Brakowało mi bardziej konkretnych rad i wytycznych, jak tworzyć proste i przyjemne interfejsy użytkowników. Na koniec wspomniano o innej książce Steva Kruga Rocket Surgery Made Easy, traktującej o tym, w jaki sposób tworzyć testy interfejsów na użytkownikach końcowych.

Następnie udałem się na prezentację Koziołka: Jak pracować i nie zwariować. Rozmawialiśmy o tym, co najbardziej wpływa na naszą pracę (a wiec krzesło, klawiatura, dysk SSD, RAM i 2 monitory). Każdego dnia powinniśmy lepiej poznawać nasze IDE, biblioteki i narzędzia. Warto też automatyzować jak najwięcej, gdyż jesteśmy leniwi, a jak nie będziemy musieli wielokrotnie pisać tego samego, to życie będzie przyjemniejsze.

Dalej było o introwertykach, psychopatach, dzieciach autystycznych, mądrej asertywności, drugim znaczeniu słowa SCRUM, potrzebie twardego resetu, śnie i przerywnikach w pracy. Ciekawy był pomysł Koziołka, jak odliczać sobie czas w technice pomodoro. Warto do tego użyć gier na facebooku, w których coś tam po jakimś czasie można zebrać i na nowo posiać. Wymusi to na nas regularne przerwy dla umysłu. Z praktycznych narzędzi, było wspomniane o bibliotece jFairy. która to generuje losowe dane.

Była to fajna i śmieszna prezentacja.

Następnie byłem na prezentacji Bartłomieja Nićka pt. Programista to za mało. Prelegent bardzo chaotycznie mówił i w ogóle nie zrozumiałem ani grupy docelowej, ani celu prezentacji. Było coś o wadach naszego zawodu, wadach samych programistów, jak się dawniej realizowało projekty, a jak się to robi obecnie. Prezentacja bardzo nieudana. Z prezentacji jedynie utkwiła mi różnica miedzy Computer Programer a Software Developer wg. US Bureau of Labor Statistic. A więc:

Computer programmers write code to create software programs. They turn the program designs created by software developers and engineers into instructions that a computer can follow.

Software developers are the creative minds behind computer programs. Some develop the applications that allow people to do specific tasks on a computer or other device. Others develop the underlying systems that run the devices or control networks.

Następnie był smaczny obiad i wystąpienie Pawła Szulca na temat JavaScriptu. Nie wiem czy to był celowy zamysł organizatorów, aby Pawła umieścić zaraz po obiedzie, ale jak dla mnie był to strzał w dziesiątkę! Nieprzerwany potok słów Pawła nie pozwalał ani na chwilę nudy i raczej nikomu nie chciało się spać.

Prelegent przekonywał nas, że JavaScript nie jest Mordorem, którego należy się obawiać, a wystarczy poznać i zrozumieć różnice w stosunku do Javy, to będzie dobrze. Przede wszystkim JS jest językiem funkcyjnym, a nie obiektowym. To, co początkowo przeraża, to możliwość wywołania funkcji z inną liczbą argumentów niż ją zadeklarowano! I tak niezdefiniowane argumenty będą undefined, a nadmiarowe będą zignorowane. W JS każda funkcja posiada lokalną zmienną arguments, która to przechowuje wartości argumentów przekazanych nam do funkcji.

Następnie Paweł bardzo fajnie omówił sposoby wywoływania funkcji w JS i czym się one od siebie różnią. A różnią się zazwyczaj kontekstem, na rzecz którego będzie odbywać się wywołanie, tzn. możemy otrzymać coś innego pod lokalna zmienną this. I tak mamy 4 możliwości:

1.    Wywołanie bezpośrednie powoduje, że funkcja otrzyma domyślny context, w przypadku przeglądarki jest to obiekt window

function func() {
    console.log(this)};

func();
// [object Window]

2.    Wywołanie jako metoda. Polega to na przypisaniu funkcji do pola w obiekcie. Dzięki temu dostajemy metodę, którą mozemy wywołać. W tym przypadku jako this otrzymujemy obiekt na rzecz którego funkcja została wywołana.

function func() {
    console.log(this)
}

var variable = {
    property: 'value'
};

variable.method = func;
variable.method();
// Object { property="value", meth=func()}

3.    Wywołanie jako konstruktor, a więc ze słówkiem kluczowym new powoduje utworzenie pustego obiektu (dziedziczącego z prototype). Funkcja ma w takim przypadku za zadania zainicjowanie obiektu, który zostaje zwrócony jako rezultat wywołania.

function func() {
    console.log(typeof(this))
}

var obj = new func('abc');
// object

4.    Wywołanie za pomocą applay() i call(). Przydaje się ta możliwość, gdy nie chcemy kopiować funkcji do innego obiektu, aby nie powtarzać kodu. Podmienimy jednak przez to context, czyli this. Predefiniowana funkcja applay() przyjmuje poza pierwszym argumentem tablicę z argumentami, a call() przyjmuje argumenty osobno (po prostu po przecinku)

function func() {
    console.log(this)
}

var variable = {
    property: 'value'
};

func.call(variable)
// Object { property="value"}

Było jeszcze trochę o Scop’ach, Hoistingu, domknięciach i modułach. Warto swój kod Javaskriptowy testować, np. Za pomocą narzędzi jak jasmine, czy mocha. Warto również testować swój kod statycznym analizatorem, np. JSLint. A jak musimy się na szybko nauczyć tego języka, to warto się zabrać za czytanie 2-giego i 3-ciego rozdziału Secrets of the JavaScript Ninja.

Kolejną prezentacją, na którą się udałem, było wystąpienie Tomka Borka, na temat zaawansowanego testowania. Chciałem początkowo iść na SCRUM, but, ale już miałem dość miękkich prezentacji i potrzebowałem czegoś technicznego posłuchać.

Na początku Tomek przestrzegał, aby nie używać PowerMocka, gdyż jest bardzo czasożerny, gryzie się z narzędziami do testowania pokrycia kodu, rzuca kiepskie wyjątki, a przede wszystkim pomaga początkującym pisać brzydki kod.

Dalej było trochę o adnotacji Parameterized z JUnita i ich alternatywach. Ciekawie wygląda projekt zohhak, którego wcześniej nie znałem.

Prelegent opowiedział jeszcze o paru ciekawych pomysłach, dotyczących testowania. Przykładowo, gdy wystawiamy usługi RESTowe na zewnątrz, to warto sprawdzić, czy te opublikowane interfejsy nie zmieniły się. Co do adnotacji @Ignore, to powinna być przy niej data do kiedy może ona być w teście i dlaczego.

Było jeszcze o narzędziach pomagających ogarnąć nam bazę danych, tj Liquibase, DBUnit i Databene Benerator. To ostatnie narzędzie pomaga generować testowe zbiory danych.

Z innych ciekawych (albo też egzotycznych) narzędzi był wspomniany Sureassert. Działa on tylko z Eclipse i pomaga realizować ideę design by contract i ciągłego uruchamiania testów (czyli coś jak infinitest). Niestety nie jestem fanem podejścia programowania kontraktowego i rozwiązanie działa tylko w Eclipsie.

Było jeszcze wspomniane o trzech bibliotekach, pomagających w skanowaniu naszych klas w celu poszukiwania adnotacji: Scannotation, Reflections i Classindex. Na koniec prezentacji było fajne podsumowanie, pokazujące co było omawiane na prezentacji.

Na koniec organizatorzy konferencji przygotowali niespodziankę, a mianowicie zdalne wystąpienie Adama Bienia z tematem How To Tackle Java EE 7. Live streaming był bardzo dobrze przygotowany, całość była transmitowana przez platformę ustream.tv. Prelegent zmieniał tło na którym mówił i wyglądało to bardzo profesjonalnie. Inne jego prezentacje można obejrzeć tutaj: tv.adam-bien.com.

Widać że Adam ma sporo doświadczenia w tym temacie. Było sporo kodowania na żywo, niewiele slajdów (które są dostępne tutaj), a pytania z publiczności można było zadawać za pomocą twittera. Ciekawe rozwiązanie, aczkolwiek z telefonu trochę dłużej pisze się twitnięcie, przez co było spore opóźnienie w dialogu.

Co do samej prezentacji, to Adam pokazał nam, jak można łatwo i szybko zbudować projekt z wykorzystaniem Javy EE 7. Polegało to na skorzystaniu z archetypu mavenowego i wyrzuceniu połowy domyślnego pom’a. Projekt Prelegent twierdził, że nie powinno się dodawać biblioteki do projektu „na zaś”, tylko w momencie gdy naprawdę są potrzebne. Przez to czas build’a i deploymentu powinien (przynajmniej początkowo) trwać krócej.

Generalnie kodzenia było za dużo i po jakimś czasie człowiek się wyłączał i gubił w kodzie. Dla mnie był to trochę odgrzewany kotlet, gdyż podobną prezentację widziałem na JDD 2012 z tą różnicą, że wtedy była Java EE 6 na tapecie. Jeśli ktoś chce obejrzeć tą prezentację, to jest ona dostępna poniżej:

Na zakończenie było jeszcze zbieranie ankiet i losowanie nagrody.  Konferencja wypadła bardzo fajnie. Brakowało mi jedynie typowo technicznych zagadnień, no ale trudno. Może następnym razem.

I znów Global Day Of Code Retreat

Kolejny rok mija i kolejny Global Day of Code Retreat już za nami. W tym roku planowałem początkowo uczestniczyć w tym evencie w Wolfsburgu, ale ostatecznie wybrałem Berlin, aby się trochę zorientować, jak wygląda tamtejsza sytuacja projektowa i mieszkaniowa. A CR to zawsze dobra okazja do tego. To już kolejny raz (6ty, jeśli nie licząc jakiś mniejszych, wewnętrznych inicjatyw), kiedy biorę udział w tego typie wydarzeniu, więc widzę jak się ono zmienia w czasie. Rok temu prawie 200 miast na całym świecie organizowało CR, a w tym było 165 lokalizacji. Tendencja więc spadkowa.

Jako że Berlin uchodzi za bardzo Europejskie miasto(o czym wspominałem już kiedyś w poprzedniej relacji), spotkanie było prowadzone po angielsku. Jednak w międzyczasie można było usłyszeć sporo języka niemieckiego, jaki i polskiego:) Zaczęliśmy więc od sortowania uczestników bąbelkowo, aby zorientować się kto jest mocny w TDD, pair programingu, a kto jest kompletnie świeży. No i w ten sposób najlepsi zasiedli do wspólnego stanowiska pracy z kompletnymi świeżakami. Nie ma to jak nauczanie innych:)

W pierwszej sesji dostałem więc niemieckiego studenta, który w javie pisze od święta, studiuje coś tam powiązane z medycyną, a na co dzień klepie w php. Używa do tego Vim’a. Jest on do niego tak przyzwyczajony, że korzysta z ichniejszych skrótów klawiszowych bezpośrednio w Eclipsie. Byłem pod wrażeniem, choć wątpię, aby była to optymalna droga do wykorzystania w pełni możliwości Eclipse’a.

Drugą sesję pokodowałem z przyjacielem Szymonem, z którym wspólnie przyjechałem do Berlina. Pobawiliśmy się trochę Scalą, ale nie szło nam jakoś najlepiej. Na pewno jeszcze sporo czasu trzeba zainwestować w poznawanie tego języka, aby móc z niego swobodnie korzystać. Niestety kiepska pogoda w ostatnim czasie, brak śniegu i gorączka przedświąteczna, nie jest najlepszym czasem do nauki nowych rzeczy. Dlatego kurs na Courserze sobie troszkę odpuściłem:(

Trzecią sesję miałem sposobność spędzić z pewnym Syryjczykiem, który na co dzień jest adminem, ale chciałby robić jakieś przyjemniejsze rzeczy. Ta sesja była dla mnie bardzo wymagająca pod względem komunikacji, ze względu na mój nienajlepszy angielski, ciężki w zrozumieniu angielski partnera i jego trochę słabą wiedzę w zakresie Javy. Myślę, że ziomek się sporo ode mnie nauczył.

Po trzeciej sesji była mała retrospekcja. W grupach 3 osobowych, mieliśmy napisać na kartkach, co się nauczyliśmy i co chcielibyśmy się nauczyć. Kartki przykleiliśmy na szybę i chwilę o tym dyskutowaliśmy.

Później była przerwa obiadowa. Były kanapki, a nie porządny ciepły, pyszny obiad jak to jest w formule tego wydarzenia zapisane. No ale trudno, nie to jest przecież najważniejsze.

Na 4tej sesji znów próbowałem pisać w Scali z innym nowopoznanym kolegą z Wrocławia. Tutaj trochę ciężko było nam dojść do porozumienia, gdyż zmierzaliśmy w innych kierunkach: ja kładłem nacisk na TDD, a kolega na implementację i lukier składniowy, jak to można by lepiej i ładnie zrobić w Scali.

Po czwartej sesji musieliśmy jednak opuścić warsztaty. Podziękowania dla globalnych i kontynentalnych sponsorów wydarzenia, a także dla sponsora w Berlinie: ImmobilienScout24, gdzie odbywał się event. Podziękowania również dla Martina Klose (@martinklose), który jak zwykle stanął na wysokości zadania i dobrze poprowadził kolejny raz to wydarzenie.

A co się zmienia, jeśli chodzi o Code Retreat? W Berlińskiej edycji zastosowano fajny pomysł przy rejestracji. Należało zapłacić 15 Euro, które było później zwracane, gdy uczestnik się pojawił na spotkaniu. Motywowało to ludzi do przychodzenia, gdy już byli zapisani, a gdyby naprawdę coś komuś nagłego wypadło, to strata 15 E jest do przełknięcia. Uważam to za super pomysł.

Ponadto zauważyłem, że osoby bardziej doświadczone w TDD i w formule Code Retreat już nie tak licznie w nim uczestniczą. Może to wynika z braku chęci nauczania innych, lub są już zmęczenie problemem gry w życie? Albo stwierdzają, że już nic nowego nie mogą się nauczyć i wybierają inne, ciekawsze aktywności w tym czasie. Ciężko mi to oceniać, ale wydaje mi się, jakby młodsi niedoświadczeni uczestnicy byli bardziej widoczni na tego typu wydarzeniach. To oznacza, że nadchodzą nowi, pełni zapału i żądzy wiedzy programiści, a więc tym bardziej nie można zostawać z tyłu…

Pierwszy Legacy Code Retreat

W sobotę miało miejsce niezwykle wydarzenie, mianowicie drugi Global Day of Code Retereat. Jako że niedawno było organizowane w Wolfsburgu to wydarzenie, postanowiono tym razem zrobić Legacy Code Retreat dla odmiany. Całość odbyła się z inicjatywy tych samych osób i w tym samym miejscu i sponsoringu.

Podczas Legacy Code Retreat pracuje się z już gotowym kodem, który można znaleźć na githubie: Trivia Game. Kod jest przygotowany w kilku językach i jest właściwie nie testowany. Osiągnięto to za pomocą metod zwracających void, wymieszaniu wyświetlania wyników z logiką, niejasne przeznaczenie zmiennych i boską klasę. Zadaniem uczestników jest ogarnięcie tego chaosu programując w parach.

Miałem dobre przeczucie podczas pierwszej sesji, aby początkowo stworzyć test testujący integracyjnie to co jest. Z założenia aktualny stan jest fachowo poprawny, więc nawet jak się widzi coś w kodzie co wydaje się nie prawdą, należy to zaakceptować. Taki całościowy test nazywa się Golden Master. Najlepiej stworzyć ich kilka i nie mogą one nigdy być czerwone, gdy będziemy modyfikować kod.

Jak już mamy kilka testów, możemy zacząć refaktoring. Najlepiej taki, do którego wsparcie daje nam IDE, gdyż wtedy nie powinniśmy nic zniszczyć. I tak powoli można pisać bardziej szczegółowe testy, konkretnych metod.

Podczas Legacy Code Retreat można ćwiczyć m.in. następujące rzeczy:

• tworzenie Golden Master
• pisanie testów dla nietestowanego kodu
• testowanie poprzez partial mocking (nazywane również Subclass To Test)
• refaktoring do kodu obiektów
• refkatoring do kodu czysto funkcyjnego
• refaktoring do ValueObjects

Miałem podczas warsztatów okazję przez dwie sesje pracować z kodem Scalowym. Jednak słabe wsparcie środowiska i mała przerwa w eksplorowaniu tegoż języka, sprawiły, że było bardzo ciężko przemieścić się do przodu. Inna sprawa to standardowe ułomności Eclipse’a, ale to już zasługuje na osobny post. Podczas kilku sesji korzystałem też z IntelliJ IDEA i tam już było trochę lepiej. Więcej nie opisuję, aby nie psuć wam ewentualnej zabawy z Legacy kodem, podczas warsztatów, które sami u siebie zorganizujecie.

Co do jakości i organizacji eventu nie ma się do czego przyczepić. Nie było problemów ze stołami, przedłużaczami, rzutnikami. Były naklejki z imionami, odliczanie czasu podczas każdej sesji, kanapki na śniadanie, kawa, herbata, soki, Club Mate i inne napoje. Obiad również był dobry, ciepły, wystarczył dla wszystkich i jednocześnie nie wiele się zmarnowało. Zabrakło mi jedynie videokonferencji z innymi miastami, jak to było rok temu. A to ja w sumie mogłem podsunąć pomysł organizatorom. Niestety jakoś mi to uciekło.

Osobiście wolę tworzyć nowy kod, niż grzebać w starym, tym bardziej w Legacy. Z tego powodu impreza podobała mi się trochę mniej niż typowy Code Retreat. Z drugiej strony, w naszej profesji umiejętność pracy z nieswoim kodem jest właściwie niezbędna i trzeba ją wykorzystywać od czasu do czasu. Oby taki sytuacji było jak najmniej, więc dbajmy o to, aby nie tworzyć Legacy Kodu.

Kolejny Code Retreat

Dzisiaj wziąłem po raz kolejny udział w imprezie spod znaku Code Retreat. Tym razem odbył się on w Wolfsburgu – czyli mieście największego europejskiego koncernu samochodowego. Zorganizowany został on przez znajomych z pracy, a sponsorem była firma T-Systems on site.

Podczas początkowych sesji mogłem podzielić się swoją wiedzą z zakresu programowania w parach, TDD, baby steps, pisania dobrych testów i znajomości IDE. Nie ma się tu co rozpisywać, bo ciekawsze działo się później.

Postanowiłem wykorzystać obecność fanatyków Scali i trochę się poduczyć tegoż języka. Zdobyta wiedza przyda się przy realizacji kursu: Functional Programming Principles in Scala. Kto się jeszcze nie zapisał, ma jeszcze szansę. Więcej o kursie można poczytać na scala.net.pl. Podczas mojej pierwszej scalowej sesji, udało mi się sporo samemu napisać i odświeżyć jakieś stare wiadomości na temat tego języka. Część wymagań nawet działała. Szkoda jednak, że Eclipse dalej kuleje w tym temacie. Mam nadzieję, że z Ideą będzie lepiej.

Podczas mojej drugiej sesji skalowej programowałem razem z jeszcze większym wyjadaczem (fanatykiem) tego języka. Było więc co chłonąć. Podczas tej sesji (w ogólności) ćwiczyliśmy pisanie bez pętli, co w Scali nie jest jakimś utrudnieniem. Udało nam się całą logikę zakodować wraz z testami i bez pętli, w czasie krótszym niż 45 minut i z wyjaśnieniem mi, jak działa ta cała magia! Co chwilę wlepiałem swoje ślepia w ekran, dziwiąc się, co ‘to’ lub ‘tamto’ robi, oraz próbując zrozumieć, czy to aby na pewno pokrywa wszystkie wymagania. Jestem pod bardzo dużym wrażeniem tej sesji. Teraz trzeba na spokojnie (albo pod wpływem ;) ) poznać wykorzystane mechanizmy tegoż języka, aby móc je później efektywnie stosować.

Wyniesione doświadczenie z tej sesji, pozwoliło mi jeszcze podczas ostatniego sparowania, ponownie zakodować wszystkie reguły gry. Czasem lubię się droczyć, z moimi partnerami podczas Code Retreat. Zwłaszcza przy ping pongu staram się tak odbić piłeczkę, aby się później dużo nie narobić, a jedynie obserwować, jak ktoś się męczy. Tym razem coś poszło nie tak, gdyż sam musiałem się napocić. O dziwo udało się po raz drugi dojść do końca, bez większych problemów, że coś nie działa i nie wiadomo dlaczego. Dodatkowo nie można było rozmawiać podczas tej sesji, co stanowiło dodatkowe utrudnienie. Spotkałem się z nim po raz pierwszy i przekonałem się, ile rzeczy można przekazać niewerbalnie.

Podsumowując wypadło super. Był to mój 6ty CodeRetreat (licząc te oficjalne jak i te zamknięte). Obiad był na wypasie, ciepły z dużymi możliwościami wyboru dania i z deserem. Również było sporo owoców (zamiast ciasteczek) i możliwość zjedzenia śniadania (jak ktoś nie zdążył rano). Ważnym punktem (który był strzałem w dziesiątkę) była Club Mate. Pomogła ona zebrać siły na ten jakże wyczerpujący wysiłek intelektualny, jakim jest Code Retreat. Nieźle się naYerbałem, a w ogólnym rozrachunku, to cała skrzynka poszła. Uważam, że napój ten, powinien wejść do formuły Code Retreat ;)

Teraz pozostaje już tylko czekać, na drugi Global Day of Coderetreat, który w tym roku przypada 8 grudnia. Rok temu 94 miasta wzięły w tym udział, a cel na ten rok to 200 miast. Zobaczymy czy się uda i jak spędzę ten dzień.

Code Retreat w Berlinie

W Niedzielę 3ciego czerwca wziąłem udział w warsztatach Code Retreat w Berlinie. Był to mój nie pierwszy udział w tego typu „imprezie”, ale pierwszy raz było to za granicą i w otwartej formie jednoczenie (wcześniej zorganizowaliśmy sobie CR w pracy). Co mnie bardzo zaskoczyło to wielka różnorodność kulturowa. Spodziewałem się, że event będzie prowadzony w języku niemieckim, ale jak się okazało w Berlinie mieszka sporo ludzi, którzy nie mówią w tym języku. Z drugiej strony, jak się okazało, łatwiej jest mówić o typowo technicznych sprawach w języku angielskim.

Pierwszą sesję kodowałem z Carlosem z Portugali. Przykładowo on mimo prawie rocznego już tutaj pobytu nie używał Niemieckiego, a w pracy oficjalnym językiem jest angielski, ze względu na sporą różnorodność kulturowa. Kodowaliśmy w Rubym, tzn. miałem okazję zobaczyć jak to można robić i poznać podstawy podstaw, ale ogółem nic konkretnego. Generalnie w Portugalii jest podobna sytuacja jak w Polsce, tzn. projekty są, praca jest, ale lepiej być gdzieś indziej.

Druga sesję miałem okazję po kodować z Grzegorzem Dziemidowiczem. W końcu była możliwość się poznania i sprawdzenia się przy klawiaturze. Była to moja najbardziej produktywna sesja podczas tego dnia jak i chyba podczas wszystkich Code Retreat’ów w jakich brałem udział. Obaj dobrze się poruszaliśmy po IntelliJ IDEA, była super komunikacja, zbliżone pomysły na design (czyli nie wiele konfliktów) i szybka ewolucja designu (ekstrakcja osobnych klas dla żywych i umarłych komórek, przeniesienie do nowych klas odpowiednich implementacji).

Udało mi się sprzedać fajnego hotkey’a do Idei. Mianowicie zamiast pisać assercję, można napisać warunek, jaki chcemy sprawdzić (tak jak by to był zwykły if), zaznaczyć tekst, wcisnąć Alt + Enter i wybrać opcję „Create JUnit Assertion”, aby zamienić porównanie w wywołanie odpowiedniej metody. Screen poniżej.

Podczas kolejnej sesji (tym razem z Łukaszem Balamutem) jak drugi raz pokazywałem ten skrót, to odkryliśmy, że nie zawsze on działa. Teraz jak to sprawdzałem, to doszedłem do tego, że jak zaznaczymy tekst od lewej do prawej, to popup pokazuje się bez tej (i innych opcji). Na szczęście ktoś już zgłosił ten błąd: IDEA-86707.

Z Łukaszem ćwiczyliśmy pisanie w Javie, przy czym na napisanie testu mieliśmy tylko dwie minuty. Jak stoper dochodził do końca, a my nie zdążyliśmy skończyć testu, to trzeba było usunąć kod i zacząć od nowa. Później analogicznie robiliśmy z implementacją. Ćwiczenie to miało na celu tworzenie małych prostych testów i prostej implementacji. Mi się kilka razy nie udało skończyć testu, gdyż nie była to moja klawiatura i bardzo ciężko mi się tworzyło test „na szybko”. Dla mnie pisanie testu, to czas w którym intensywnie myślę, co chcę testować, jak, jaką nazwę dobrać i czy test jest poprawny. Dwie minuty to troszkę za mało, nawet jak test jest niewielki.

Później trochę się posprzeczaliśmy na temat używania słówka should na początku nazwy każdej metody testowej. Łukasz twierdzi, że kiedyś było test (bo musiało być), a teraz ten „noise” zamieniliśmy na should i jak czytamy nazwy niedziałających testów, to i tak pomijamy ten prefiks.

Później wyskoczyliśmy całą grupą na obiad. Poszliśmy na jakieś burgery w pobliskim bistro. Panie z za lady bardzo się zaskoczyły nagłym zmasowanym atakiem żądnych mięsa programistów w Niedzielę, gdyż wcześniej nikogo w tym barze nie było. Co prawda nie była to pizza, ale taki lepszy fast food, smaczny i sponsorowany przez Nokię. Była w tym czasie możliwość pogadania z innymi uczestnikami.

Po obiedzie miałem jeszcze okazję pokodować z Janem. Tym razem rozmawialiśmy po Niemiecku.

Ostanie dwie sesje były bardzo szalone. Postanowiliśmy zrobić coś, z czym spotkałem się pierwszy raz. Mianowicie 6 par postanowiło zacząć kodować w Javie i wykonywać rotację jednej osoby co 10 minut. Do tego nie skasowaliśmy kodu pomiędzy sesjami. Bardzo smutne było, gdy trafiałem co chwila na tą samą trefną implementację jednego z uczestników, jednak ciężko było mi przeforsować jemu inny sposób spojrzenia na problem i odpuściłem. Ciężko, zwłaszcza podczas drugiej sesji, przebiegało wdrożenie w to, co się dzieje w projekcie, gdyż przez 10 minut ktoś musiał wytłumaczyć / pokazać w którym miejscu jesteśmy, jak to implementujemy i coś dopisać. W momencie gdy udało się już dopchać do klawiatury, to przychodziła już nowa osoba na sąsiednie stanowisko i role się odwracały.

O dziwo prowadzący stwierdził, że pierwszy raz widział, że ludzie podczas ostatniej sesji są tak mocno ożywieni. I rzeczywiście tak było. Te częste rotacje powodowały, ze trzeba było dawać z siebie wszystko, a stres z tym związany na pewno powodował wydzielanie się motywująco – pobudzających substancji w naszym ciele.

Na koniec oczywiście retrospekcja z całego dnia, podziękowania, wymiana kontaktami i wypad na piwko. Tam to dopiero całość spływa z człowieka i można jeszcze pogadać w luźniejszej atmosferze. No i jeszcze było sporo dzielenia się wrażeniami z Marcinem Saneckim i Rafałem w drodze powrotnej.

Podziękowania dla sponsorów @nokia, @crealytics, @klosebrothers. Miejsce odbywania się imprezy było ciekawe, gdyż znajdowało się w niezbyt uroczej dzielnicy, a blok wyglądał jak była fabryka. Za to firma crealytics udostępniła małe przytulne biuro i Club Mate, które trzymało mnie cały dzień na nogach. Powinni wprowadzić ten napój w pracy obok / zamiast kawy. Ogółem organizacja była bardzo dobra, dojście oznaczone, a na ścianach wisiały ciągle reguły gry.

Podsumowując, poznałem ciekawą technikę wymiany rotacyjnej uczestników co 10 minut, z którą nie spotkałem się wcześniej. Podpatrzyłem kilka innych konwencji nazywania metod testowych i zorientowałem się jak wygląda praca w Berlinie (miasto start-up’ów), gdzie dominującym językiem jest angielski.

Agile Development Day

W sobotę 10 grudnia odbył się w Warszawie Agile Development Day. Była to impreza zorganizowana przez firmy Sages i Pragmatis. Event polegał na wspólnym tworzeniu aplikacji, ćwiczeniu TDD, programowania w parach i innych zwinnych praktykach. Był do tego Continous Integration (build był uruchamiany co git push) i Continous Delivery (deployment co udany build).

Aby dostać się na warsztaty trzeba było się wcześniej zapisać. Z ponad 60 osób chętnych, wybrano 22 w tym mnie :) Została przygotowana startowa baza kodu i udostępniona na github’ie. Trzeba było więc wcześniej ściągnąć kod i przygotować środowisko. Technologicznie był Spring Core, Spring MVC, JSP, Casandra, Maven. Jako że nie miałem wcześniej możliwości korzystać ze Spring’a w warunkach bojowych (po za jakimiś szkoleniami / prezentacjami), to miałem z czym się bawić. Zaprzyjaźniłem się więc z książkami na ten temat i archetypami kodu, aby porozkminiać te technologie i aby było na czym bazować.

Event zaczął się o 8 rano w Millennium Plaza. Najpierw było przywitanie i omówienie zasad, co będziemy robić w ciągu dnia. Następnie było o aplikacji jaką mamy stworzyć. Mianowicie za pomocą pisanego serwisu internetowego można się chwalić czego się nauczyliśmy, ile czasu na to poświeciliśmy i ile punktów zebraliśmy. Taki jakby twitter, tyle że piszemy co poznaliśmy, jaki był stopień trudności, system nalicza jakieś tam punkty i chwalimy się tym przed znajomymi. Plus jeszcze jakieś pierdoły do tego.

Po omówieniu wymagań aplikacji było wprowadzenie do Casandry, gdyż była to najbardziej „dziwna” i nieznana technologia z używanego technology stack. Później było szybciutko o Spring MVC i zaczęło się. Uczestnicy mieli wybrać sobie couch’a i osobę do pary (najlepiej aby ktoś znał Springa MVC). Jako że znałem Piotra (jednego z prowadzących) to się z nim dogadałem i wraz z Marcinem usiedliśmy do pierwszego user story.

Wybraliśmy sobie na tapetę formatowanie czasu, ile zajęła nam nauka danej technologii. Napisaliśmy kilka testów i zaczęła się zabawa. Postanowiliśmy dodać do projektu bibliotekę JUnitParams do pisania sparametryzowanych testów w JUnit’cie. Swoją drogą jest to biblioteka napisana przez Pawła Lipińskiego, który organizował, prowadził i kodował na warsztatach. Pomogło nam to pisać ładniejsze, parametryzowane testy w JUnicie, podczas pierwszej iteracji.

Wcześniej ustalono, że iteracje będą trwały po półtorej godziny i pomiędzy nimi będą zmiany par, a co kilka iteracji będzie retrospekcja. Czyli jakby jeden dzień ze sprintu został skompresowany do 1,5h a cały Sprint do 5ciu dni (czyli pięciu iteracji). Taka organizacja pracy bardzo motywowała do jak najszybszego kończenia zadań. Nie inaczej było w naszej parze, gdyż chcieliśmy jak najszybciej zobaczyć choćby częściowy efekt naszej pracy na „live”, mimo że nie wszystkie przypadki mieliśmy obsłużone. No i tu zaczęła się prawdziwa walka z technologiami.

Gdy jeszcze wczoraj Piotrek w projekcie dodał Tiles’y zaczęła się cała aplikacja wysypywać. Doszedł on do wniosku, że Casandra z Tiles’ami nie funkcjonuje ;) i wycofał zmiany. W naszej historyjce chcieliśmy (wręcz musieliśmy) skorzystać z JSTL’owego Taga c:forEach, ale też nie chciało działać. Był ten sam błąd co w przypadku Tiles’ów. Nasza koncepcja zamknięcia wyświetlania czasu we własny Tag JSTL’owy również nie zadziałała i trzeba było to jakoś inaczej obmyślić. To wszystko pewnie przez Casandrę ;)

Akurat nadszedł koniec pierwszej iteracji i nastąpiła rotacja par. Jako, ze pracowaliśmy na moim laptopie, to Marcin odszedł, a dołączył się Michał. Porozmawialiśmy chwilę, co zrobić z naszym problemem niemożliwości użycia JSTL’a i zaproponowałem, aby stworzyć Data Transfer Object (DTO) i za jego pomocą wyświetlać już odpowiednio sformatowany tekst. Coś tam niby się udało, ale potem było trochę walki z merge’owaniem zmian. Niestety szybko się okazało, że user story bardzo nachodzą na siebie, wręcz się powtarzają. Powodowało to masę konfliktów i trudności z push’owaniem zmian, gdyż po pull’u, odpaleniu testów, i przy próbie ponownego push’a okazywało się, że ktoś w między czasie zdążył wypushować swoje zmiany i proces trzeba było powtarzać ponownie.

Po drugiej iteracji postanowiono zrobić retrospekcję. Mieliśmy na małych, przylepnych karteczkach wypisać, co nam się podobało, a co nie i przykleić to na ścianę. Później trzeba było w ciszy to pogrupować (silent sorting) i ponazywać grupy. Po „uroczystym” przeczytaniu tego co jest fajne i niefajne, każda para wraz ze swoim mentorem miała się zastanowić, co zrobić, aby było lepiej. Super pomysłem było wprowadzenie stand-up meeting’ów - w trakcie trwania iteracji - [chyba] co 20 minut, aby poprawić komunikację w zespole i wiedzieć, kto co robi i na kiedy będzie. Innym ciekawym pomysłem było wpisywanie podczas commit'a / push’a jako autor numer implementowanego user story i nazwiska autorów. I rzeczywiście, początkowo brakło konwencji wypychania zmian do repozytorium, aby były one jednolite i czytelne.

Następnie był obiad i kolejna iteracja. Tym razem osoby, które przez dwie iteracje robiły jedną opowieść, miały się przesiąść. Może to trochę nieoptymalne posunięcie z punktu widzenia ukończenia zadania, ale podczas eventu chodziło o wspólną naukę. Trafiłem więc do zadania wyświetlania podpowiedzi. Mianowicie gdy wpisujemy technologię, której się właśnie nauczyliśmy, ma nam podpowiadać czy było to łatwe, średnie czy trudne. Wiązało się to z koniecznością napisania kawałka JavaScript’a, ale na szczęście to akurat poszło gładko. Problemem się jednak okazało, gdy coś co było zależne od naszego zadania (mianowicie dodawanie nowych umiejętności) czy jest już skończone i czy dane lądują tam, skąd je odczytujemy. Niestety ciężko w Casandrze cokolwiek podejrzeć, co wylądowało w bazie danych, gdyż zapisują się tam dane binarne. Nad tym zadaniem pracowałem przez dwie iteracje i później na ostatnią iterację, znów trzeba było się przesiąść.

Dosiadłem się więc do Bartka i tam nawet początkowo było fajnie (nie znaczy to wcale, że wcześniej było źle). Dostałem szybkie wprowadzenie co robimy, że właśnie jest test z nową funkcjonalnością i mam ją zaimplementować. Chwila ogarniania / czytania kodu i z pomocą Bartka udało się. Problem niemożliwości skorzystania z JSTL’a rozwiązano użyciem Skryptletów. Coś tam nawet się udało wyświetlić, ale nie można było wypchać zmian, gdyż najpierw trzeba było powalczyć  z kwestią, co wyświetlać, jak ktoś jest niezalogowany. Inny zespół pisał back-end do tej funkcjonalności i niestety czas warsztatów nie pozwolił już na połączenie naszych zmian.

Po piątej iteracji przejrzeliśmy backlog zapisywany na tinypm.com. Okazało się, że niewiele funkcjonalności udało się w pełni zaimplementować. Paweł pokazał jednak na żywym środowisku, że coś tam działa. Patrząc na statystyki na Jenkinsie, było widać, że w ciągu zmian udało się wypchnąć do repozytorium kod 54 razy z czego tylko 9 się wywaliło. Uważam to za niezły wynik, biorąc pod uwagę to, że dla uczestników był to świeży projekt, bez wypracowanych konwencji i nie każdy musiał znać wszystkie wykorzystywane technologie. Poniżej przedstawiam trend tesów.

Podczas warsztatów budowały się build’y od 88 do 142. Wcześniejsze build’y pochodziły z przygotowań do warsztatów. Widać wyraźnie że od 95 build’a liczba testów zaczęła znacząco rosnąć, z każdą nową zmianą.

Na koniec nadszedł czas na podsumowanie. Poprzestawialiśmy trochę stoły i ułożyliśmy krzesła w dwa kółka. W środku było 5 krzeseł, a  na zewnątrz reszta. Kto siedział w środku ten mógł mówić, pod warunkiem, że cztery wewnętrzne krzesła były zajęte. Jedno było wolne, aby kogoś mógł się dosiąść i oczywiście można było spokojnie opuścić wewnętrzny krąg. Osoby siedzące w środku mówiły o swoich odczuciach dotyczących warsztatów, co się nauczyły itd. Czyli taka runda feedback’owa dla innych uczestników i organizatorów.

Jako że ja nie miałem okazji zasiąść w środku, to swoją opinię wyrażę teraz. Ogółem event wyszedł bardzo fajnie. Organizacja w porządku: były kanapki rano, napoje i ciasteczka przez caly dzień, dobry obiad w trakcie (i nie była to pizza). Lokalizacja warsztatów bardzo dobra, mianowicie blisko centralnego – ważna kwestia dla osób przyjezdnych, a tych nie brakowało. Ja sam przyjechałem z Wrocławia, ale spotkałem również ludzi z Gdyni, Gdańska, Wrocławia, a nawet z Berlina. Organizacja pod względem technicznym również dobra – były dwa rzutniki, na jednym Jenkins, a na drugim live aplikacja. Bardzo dobrym pomysłem było przygotowanie zaczynu aplikacji i jej udostępnieniu w necie. Również Continous Integration i Delivery daje bardzo fajny efekt psychologiczny. Można było szybko zobaczyć swoje zmiany na Jenkinsie jak i na na środowisku „produkcyjnym”.

Niestety, jak to sami organizatorzy przyznali, rozpoczęcie przygotowywania tej aplikacji na tydzień przed warsztatami to było trochę za późno. Wynikały później z tego problemy z technologiami (niemożliwość użycia Tiles’ów i JSTL’a). Uważam również, że dobranie stosu technologicznego było nienajszczęśliwsze. Fajnie, że było cos egzotycznego (Casandra), ale mało kto wiedział, jak z tego odpowiednio korzystać. Do tego zastosowanie Springa MVC i JSP powodowało, że czasem trzeba było się męczyć z JavaScriptem (AJAX i jQuery). Te problemy technologiczne powodowały, ze ciężko było się skupić na czystym pisaniu kodu (nie wspominając już o TDD), a trzeba było się męczyć ze zgraniem technologii i merge’owaniem zmian.

Wcześniej wydawało mi się że w miarę ogarnąłem już Git’a, ale dopiero tutaj w warunkach bojowych zweryfikowałem swoje poglądy na ten temat. Problem scalania zmian występuje (pushowaliśmy do jednej gałęzi, aby Continous Server już dalej robił swoje), jak w każdym innym systemie kontroli wersji. Jakub Nabrdalik mówił, że jednym z możliwych sposobów jest zrobienie miecza z dwóch zwiniętych kartek papieru i ten kto aktualnie posiada miecz może push’ować. Jak ktoś innyc chce to robić, to musi uzyskać ten miecz. Wydaje mi się, że skorzystanie z Mercuriala mogło by trochę ułatwić sprawę z łączeniem zmian w kodzie, ale nie jestem ekspertem w tym temacie.

Innym poważnym minusem co do warsztatów, było przygotowanie user story’s. Bardzo często były one do siebie podobne, zachodziły na siebie i od siebie zależały. Jednak podczas wyboru user story nie posiadaliśmy tej wiedzy. Na przyszłość trzeba lepiej przygotować historyjki do zaimplementowania, wraz z grafem, co od czego zależy, co trzeba zrobić najpierw i z lepszym opisem. Większość opowiastek dotyczyła strony głównej, przez co wzajemnie sobie modyfikowaliśmy zawartość tych samych plików, co prowadziło do problematycznych konfliktów. Na przyszłość można kilka opowiastek udostępnić np. tydzień wcześniej, aby można było w domu coś na rozgrzewkę napisać. Zachęciło by to bardziej do zajrzenia w kod i do lepszego przygotowania do warsztatów. I najlepiej aby były one możliwie jak najbardziej rozłączne.

Również wybór Casandry na bazę danych nie było chyba najlepsze, gdyż z rozmów pomiędzy ludźmi słyszałem, że niektóre zespoły sporo się z nią męczyły. Fajnie poznać przy takiej okazji coś nowego, ale wybór chyba nie był najszęśliwszy. Jak bym proponował na następny raz jakąś bazę działającą w pamięci, inną NoSQL’ową (obiektową, key-value) lub jakąś lekką SQLową, którą wszyscy znają. Jako technologię widoku proponowałbym GWT (lub coś o podobnej koncepcji), gdyż tam nie trzeba się bawić z JavaScriptem, ani z JSP, a maksymalnie z niewielkimi kawałkami HTML’a.

Nie oznacza to, ze nic nie wyniosłem z warsztatów. Miałem w końcu motywację do lepszego poznania Springa, Git’a, JUnitParams… Zrozumiałem, że nie tylko testy jednostkowe są najważniejsze, ale obok nich musi się znajdować kilka integracyjnych i akceptacyjnych (już w początkowym stadium projektu). Przykładowo prosty test end-to-end uruchamiający przeglądarkę na stronie głównej i sprawdzający czy jakiś tam przycisk istnieje, pozwolił nam szybko wykryć, że Tagi w JSP nie chcą działać. Inna sprawa ze testy nie były podzielone na jednostokowe i inne (trwające dłużej), przez co ich uruchamianie było trochę przydługie.

Dowiedziałem się też o fajnej technice, podkreślającej współwłasność kod. Mianowicie po za wywaleniem z szablonów plików / klas i metod informacji o autorze, można dać wszystkim pracownikom z danego projektu, jedno konto i hasło do repozytorium. Dopiero wtedy powstaje wspólny kod i nikt się nie boi modyfikować nieswoich części. Poznałem również trochę bardziej w praktyce procesy zachodzące w procesie Agile'owym, jak i mogłem się dowiedzieć jak wygląda IT w innych miastach.

Zawsze z takich wydarzeń można wynieść ciekawe skróty klawiaturowe. I tak dla IDEI: Crtl + Shift + Enter - Statement Comlete, czyli dodanie średnika na końcu linii. Z analogicznych skrotów korzystałem w NetBeans’ie, ale tam to było to Ctrl + ; i Ctrl + Shift + ;. Innymi interesującymi skrótami w Idei są: Ctrl + Shift + T czyli przejście do klasy, która testuję aktualną klasę, w której jesteśmy i Ctrl + Shift + N (odpowiednik Eclipsowego Ctrl + Shift + R), czyli wyszukiwanie po nazwie pliku z projektu.

Ciekawe, nowopoznane skróty dla Eclipse’a to Ctrl + Shift + M - zaimportowanie statyczne danej metody na której znajduje się aktualnie focus. Przydatne zwłaszcza jak mockujemy z Mockito i chcemy samo when() zamiast Mockito.when(). Ponadto Ctrl + Shift + O czyli organizacja importów (w Idei można zrobić, aby automatycznie narzędzie przed commitem zmian, odpowiednio organizowało importy). I na koniec syso + Ctrl + Spacja, czyli skrót od System.out.println();. W Idei jest to sout + Tab co jest według mojego gustu fajniejsze.

Dobra to chyba tyle z podsumowania wydarzenia. W tym roku już się żadna konferencja / warsztaty nie szykują, więc trzeba będzie z tym poczekać do przyszłego roku. Mam nadzieję na kolejną edycję Agile Development Day lub podobny tego typu event.