Krzysztof Kędziorski - Notatnik programisty

Nawet nie wyobrażacie sobie mojego zdziwienia gdy rano zaraz po przebudzeniu sprawdziłem maile na telefonie a tam informacja z Toruńskiej Grupy Developerów .NET , że Sławek Sobótka wystąpi w Toruniu.

Fajnie rozkręca się TGD .Net, niedawno byłem na ogranizowanej przez nich konferencji, teraz zaprosili Sławka - gratuluje.

Szkoda, że w Toruniu żaden JUG nie działa.

Wykłady:

• Domain Driven Design - Wszystko ma swoje miejsce i wszystko jest na miejscu

“Czy zastanawialiście się co jest przyczyną rozkładu średnich i dużych systemów? Czy jest on nieunikniony i jest jedynie kwestią czasu? A może jednak istnieje jakiś sposób na utrzymanie entropii w ryzach? Podczas prezentacji zobaczymy w jaki sposób Domain Driven Design pomaga w okiełznaniu chaosu. W prezentacji znajdą się główne techniki modelowania takie jak Ubiquitous Language, Bounded Context, Strategic Design. Zostaną przedstawione również podstawowe techniki implementacji DDD: przykłady Building Blocks, Command-query Responsibility Segregation, system zdarzeń, przypadki racjonalnego wykorzystania zarówno ORM jak i czystego i SQL. ”

• Command-query Responsibility Segregation - ewolucja architektury warstwowej w stronę modularyzacji i skalowania

“Z biegiem kariery, tworząc kolejny system lub aplikację, stajemy przed problemami innej klasy. Inna klasa problemu to inne wymagania odnośnie technologii, metodyki i architektury. Popularne architektury warstwowe mogą być nieodpowiednie do pewnych klas problemów - mogą np. narzucać nieracjonalne wykorzystanie ORM lub promować naiwne modelowanie domeny biznesowej. Podczas prezentacji przedstawię nowe ujęcie warstw - architekturę Command-query Responsibility Segregation, która wspiera aplikacje średniej i dużej skali. Architektura CqRS promuje zdobycze nowoczesnej inżynierii oprogramowania takie jak: Domain Driven Design i noSQL, otwiera system na skalowanie oraz w naturalny sposób rozwiązuje typowe problemy z mapowaniem relacyjno-obiektowym. Główne składowe nowej architektury to: dwa stosy warstw, rozwarstwienie logiki, komunikacja zdarzeniowa oraz opcjonalnie event sourcing (składowanie danych w modelu behawioralnym - w przeciwieństwie do klasycznego modelu strukturalnego) “

Miejsce: Wydział Matematyki i Informatyki (ul. Chopina)

Data: 13.05.2011

Godzina: 17.00 - 20.00

Rejestracja: WSS , CodeGuru

Do zobaczenia w piątek 13.  ;-)

Mam chwile to opisze jak wystartować z Google Web Toolkit. Jakoś po prezentacjach z Programowania Zespołowego ktoś mnie poprosił żebym przybliżył troche GWT w wolnym czasie. Wtedy pisałem jeszcze w GWT 1.5 i porzadnego “Hello World” z uwzględnieniem komunikacji przez RPC nie dało się zrobić tak jak teraz w kilka sekund. No dobra to co bedzie nam potrzebne ? Nie wiele ; ] Odpalamy eclipse’a i doinstalowujemy plugin podając eclipsowi ten url: http://dl.google.com/eclipse/plugin/3.4 . OK gdy już mamy zainstalowany plugin i zresetujemy eclipse’a pojawią nam się m.in 3 nowe ikonki:

• New Web Aplication Project
• GWT Compile Project
• Deploy App Engine Project

Aby stworzyć przykładowy projekt klikamy na New Web Aplication Project lub tradycyjnie tworzymy projekt poprzez New -> Other… -> Google -> Web Application Project. Wpisujemy nazwę i pakiet- zwróćmy uwage by pozostawić zaznaczone checkboxy przy Use Google Web Toolkit i Use Google App Engine gdyż bez nich nie stworzy nam się przykład korzystający z GWT a jedynie przykładowy servlet. No dobra po kliknięciu na Finish mamy już gotową aplikacje w GWT która korzysta z RPC do komunikacji z serwerem. Szkoda że nie było tak fajnie gdy zaczynałem zabawe z GWT - żeby takie coś uzyskać to dosyć długo się naszukałem : ) No ale ok przyjrzyjmy się temu co nam sie wygenerowało. Po pierwsze wygenerowały nam się 3 pakiety w moim przypadku są to:

• pl.kedziorski.examples.GWT (w tym pakiecie znajduje się plik xml opisujący moduł GWT)
• pl.kedziorski.examples.GWT.client (klasy klienckie - kompilowane do JavaScript’u)
• pl.kedziorski.examples.GWT.server (klasy serwerowe - serwlety i to co obliczane po stronie serwera)

[xml]

<module rename-to=’gwt_hello’>
<inherits name=’com.google.gwt.user.User’/>
<inherits name=’com.google.gwt.user.theme.standard.Standard’/>
<entry-point class=’pl.kedziorski.examples.GWT.client.GWT_Hello’/>
</module>

[/xml]

Tag inherits definiuje z z jakich modułów ma dziedziczyć nasz moduł, tag entry-point natomiast definiuje strone startową / punkt wejścia. To ta klasa będzie wywoływana po odwołaniu do modułu.W pakiecie serwera wygenerowała nam się klasa GreetingServiceImpl.java :

[java]

public class GreetingServiceImpl extends RemoteServiceServlet implements
GreetingService {

public String greetServer(String input) {
String serverInfo = getServletContext().getServerInfo();
String userAgent = getThreadLocalRequest().getHeader("User-Agent");
return "Hello, " + input + "!<br><br>I am running " + serverInfo
+ ".<br><br>It looks like you are using:<br>" + userAgent;
}
}

[/java]

Servlet dziedziczący po RemoteServiceServlet z jedna metodą. Od normalnych (nie w GWT) servletów odróznia go jeszcze to, że implementuje interface GreetingService znajdujący się w pakiecie klienckim. W tej klasie bedą wszystkie metody do komunikacji z serwerem. W pakiecie klienckim znajdują się 3 pliki.

Wspomniany wcześniej interface GreetingServic.java

[java]

public interface GreetingService extends RemoteService {
String greetServer(String name);
}

[/java]

Jego asynchroniczna wersja GreetingServiceAsyn.java

[java]

public interface GreetingServiceAsync {
void greetServer(String input, AsyncCallback<String> callback);
}

[/java]

Oba interfejsy musze deklarować te same metody z tym że w wersji asynchronicznej zamiast typu zwracanego dorzucamy jeden argument typu AsyncCallback<typ_tego_co_zwraca_metoda>.

Jest tu jeszcze nasza klasa wejścia GWT_Hello.java z której powybieram tylko ważniejsze części.

[java]

public class GWT_Hello implements EntryPoint {

////////////////////////////////////////////////////

private final GreetingServiceAsync greetingService = GWT
.create(GreetingService.class);

////////////////////////////////////////////////////

public void onModuleLoad() {/*wyciety kod*/}

////////////////////////////////////////////////////

greetingService.greetServer(textToServer,
new AsyncCallback<String>() {
public void onFailure(Throwable caught) {

}

public void onSuccess(String result) {

}
});

}

[/java]

Klasa jest punktem wejścia więc implementuje EntryPoint stąd też metoda onModuleLoad() - która jest jakby odpowiednikiem main’a. AsyncCallback wymaga zaimplementowania 2 funkcji onFailure() i onSuccess() które zostaną wywołane w zależności od tego czy uda nam się przesłać dane z serwera czy też nie (bo akurat nam się router zrestartował np).  To by było chyba tyle jeśli chodzi o sturtup w GWT. Teraz możemy odpalić nasz projekt klikając na zwykły eclipsowy Run ; ] Projekt włączy nam się w tzw. Hosted mode, czyli mówiąc w duuuużym skrócie uruchamiamy go z klas Javy bez kompilacji do JavaScript co m.in umożliwia bardzo wygodne debugowanie np z eclipse’a. Aby umieścić aplikacje na serwerze trzeba by ją skompilować (np klikając wspomniany na początku nowy przycisk) albo bezpośrednio wrzucić na serwer Google App Engine (3. z nowych przycisków).

W sumie stratą czasu byłoby jeżdżenie na konferencje jeśli kończyłoby się jedynie na wysłuchaniu tego co miał do powiedzenia prelegent. Postaram się powoli po testować narzędzia i praktyki, o których miałem przyjemność usłyszeć na JAVArsovia 2009. Na pierwszy ogień pójdzie wtyczka do eclipse (do InteliJ też jest dostępna) Infinitest. Co to takiego? Jest to wtyczka do IDE, która w tle przeprowadza testy jUnit i informuje nas o ich powodzeniu. Co to nam daje? Ano to, że już w chwili pisania testu wiemy czy on przechodzi czy też nie. Jakie ja z tego widzę korzyści?

• eliminacja prostych pomyłek przy pisaniu samych testów
• Oszczędność czasu (nie uruchamiamy testów czekając aż się skończą tylko kodujemy dalej bo wiemy że przeszły)

Żeby zainstalować Infinitest wrzucamy link http://eclipse.infinitest.org jako update site w eclipse i instalujemy : ) Po restarcie eclipse plugin już działa. No dobra to co teraz ? Napiszmy trywialny przykład:

[java]
import junit.framework.Assert;
import org.junit.Test;

public class NaszTest {
   @Test
   public void shouldDoSth() throws Exception {
      //given
      Integer liczba = new Integer(10000);
      //then
      Assert.assertEquals(10000, liczba.intValue());
   }
}
[/java]

Ten test jest poprawnie napisany bo faktycznie wartością liczby jest 10000. Ale załóżmy że nam się jedno 0 za dużo wpisało:

[java]
import junit.framework.Assert;
import org.junit.Test;

public class NaszTest {
@Test
public void shouldDoSth() throws Exception {
//given
Integer liczba = new Integer(10000);
//then
Assert.assertEquals(100000, liczba.intValue());
}
}
[/java]

Dodałem “niechcący” jedno zero więcej i kod teraz już by nie przeszedł. Co robi Infinitest ? Informuje, że oczekujemy 100000 podczas gdy liczba ma wartość 10000. I tą informacje dostajemy praktycznie zaraz po zapisaniu pliku. I to w formie do której jesteśmy przyzwyczajeni - przypominającej błąd w składni. No to by było na tyle jeśli chodzi o Infinitest.

W tym roku na uczelni jako przedmiot do wyboru wybrałem jezyk D. Powoli zaczynam programować w tym języku. Jako że eclipse to moje ulubione IDE chciałbym pisać w nim również w D. Potrzebna nam będzie wtyczka do eclipse o nazwie Descent.

Pierwszą rzeczą jaką musimy zrobić jest zainstalowanie Descent w naszym eclipse. A więc odpalamy eclipse i wchodzimy w menu:

Help -> Software updates…

Przechodzimy na zakładkę Available Software i klikamy na Add Site… , wyskoczy okienko, w które wpisujemy adres:

http://downloads.dsource.org/projects/descent/update-site

Zaznaczamy checkbox przy adresie i klikamy Install… Musimy teraz poczekać kilka chwil po czym ukaże się nam okienko z rzeczami do zainstalowania - powinien być tam tylko Descent. Klikamy Next , akceptujemy licencje i klikamy Finish. Po chwili eclipse prosi o restart IDE, po restarcie mamy już zainstalowanego Descent’a i możemy utworzyć projekt w D:

New -> Other ->D -> D Project

Wybieramy nazwe i klikamy Finish - eclipse zaproponuje przejście do perspektywy D - godzimy się na to. OK - projekt już mamy teraz klikamy prawym na nazwę projektu po czym na:

New -> Module

Wpisujemy nazwę np Main  i klikamy Finish. Mamy już utworzoną naszą klasę Main. Wpiszmy tam prosty kod:

[cpp]
module Main;
import std.stdio;

void main(char[][] args){
writefln("Hello World!");
}
[/cpp]

Aby uruchomić nasz Hello World musmy kliknąć na ikonkę (która znajduje się po prawej stronie Run As…):

External Tools -> External Tools Configurations…

Klikamy 2 razy na Program. Na początek nadajmy nazwę naszej konfiguracji np D Compile. W pole Location wpisujemy/wybieramy ścieżkę do kompilatora dmd. W Working Directory wpisujemy :

${project_loc}

Następnie w pole Arguments wpisujemy nazwę naszej klasy main wraz z .d oraz -g - w moim przypadku jest to po prostu main.d -g. Przechodzimy na zakladke Refresh i zaznaczamy checkbox przy Refresh resources upon comletion i wybieramy The Project cointaining the selected resource. Zapisujemy konfigurację klikając Apply i zamykamy okienko.Klikamy raz na naszą klasę / moduł Main.d tak aby się zaznaczyła. Teraz po naciśnieciu ikonki Run D Compile (obok Run As ) nasz projekt zostanie skompilowany. Pojawią się 2 nowe pliki jeden to main.exe. Klikamy na  main.exe tak by zostalo zaznaczone po czym klikamy na ikonkę Run As… i wybieramy D Aplication. W okienku konsoli powinno pojawić się nasze Hello World.


OK teraz zajmijmy się debugerem. Sciągamy i rozpakowujemy debuger DDbg. Klikamy Window -> Preferences. Wybieramy D -> Debug i wpisujemy w pole Debugger executable ścieżkę do debugera DDbg po czym klikamy OK.

Teraz możemy również debugować nasze aplikacje pisane w D.