Thanks to this you’re able to commit always “refering to” some specific task. Using GitHub and Kanbanery such commits are linked back to the task on the board, which makes code reviews very pleasant :-)

As we’re using Kanbanery in our team, I’ll hopefully have some time and ideas to make this plugin even more useful over time :-) So in case you’re interested just download the plugin from your IntelliJ or head to github to look at the source code or vote for this plugin on it’s site.

Oh… Seems like I forgot to announce that I’ve also released a Android client for Kanbanery :-) Yup, that’s true, so got ahead and check it out if you’d like to. This one still needs some polishing, but the idea is to keep it in one codebase but develop for both, tablets and normal phones, so some things are a little bit tricky :-) I love to use it on my XOOM, but I’ll work hard to make the phone versions as awesome as the tablet one.

Now, we all remember how painful it it to write good equals and hashCode methods, yet we really should implement them to make our collections work the way they should work (HashAnythings, Lists, Sets). So we sometimes use Apache Commons to implement these, or just leave the coding to IntelliJ or NetBeans. The problem with the second, code generating, solution is that it’s a hell of a mess. Don’t believe me…? Just a quick reminder then…

Now that we’ve remembered how painful it looks, let’s dive into JDK7: The full code would look like this (this time equals is also accepting subclasses of Test, the above example didn’t):

Note the Objects.hash() method, wich is really a lifesaver and also the Objects.equals() method which makes our code NullPointerException safe, which the previous version had to tackle by using ?:… And it read’s much nicer, Of course, you could skip the result variable, but I decided to do it like this for the sake of easy reading.

And here is it’s test:

Now that was nice wasn’t it? :-) Objects probably isn’t “the” killer feature that JDK7 has, but it’s a really nice addition, so let’s get to using it :-) The other utility methods in this class are:

• static <T> int compare(T a, T b, Comparator < ? super T> c)
  Returns 0 if the arguments are identical and c.compare(a, b) otherwise.
• static boolean deepEquals(Object a, Object b)
  Returns true if the arguments are deeply equal to each other and false otherwise.
• static boolean equals(Object a, Object b)
  Returns true if the arguments are equal to each other and false otherwise.
• static int hash(Object… values)
  Generates a hash code for a sequence of input values.
• static int hashCode(Object o)
  Returns the hash code of a non-null argument and 0 for a null argument.
• static <T> T requireNonNull(T obj)
  Checks that the specified object reference is not null.
• static <T> T requireNonNull(T obj, String message)
  Checks that the specified object reference is not null and throws a customized NullPointerException if it is.
• static String toString(Object o)
  Returns the result of calling toString for a non-null argument and “null” for a null argument.
• static String toString(Object o, String nullDefault)
  Returns the result of calling toString on the first argument if the first argument is not null and returns the second argument otherwise.

Hooray for small litle improvements :-) This class officialy get’s Duke’s thumbs up image:

As I’m coding quite a lot GWT and JS has also become quite powerfull in the last years I enlisted the training to learn more about JS optimalization and add some more tricks to my toolbox. Also some real life use scenarios would be very welcome. Turns out Tanadu (a polish “heroes-like” browser game) was implemented 100% in plain JS. Which is quite shocking and as we later agreed on developing such code can really be a pain in the neck. “Use GWT” would be my anwser to such an use case I guess – you wouldn’t loose the refactoring tooling Java gives you and could still fallback to JSNI if really needed. Did the “training” meet my expectations? Yup. Want more details? Read on… :-)

It was really fun and I’ve even (and unexpectedly) met a friend of mine with whom (and one other developer) we’ve paired up and were coding a JS Mortal Kombat in JavaScript for those two days. We’ve learnt how to use CSS3 *-animation, *- transition and other cool new features (well, most of them “webkit only” but very cool nevertheless). Then we’ve coded a little and went on to dinner ate Jeff’s where I’ve lead the group to :-) Sadly dinner took a little too much time and we had less time to code than Poznań during their meeting a few weeks ago.

By the way… MVC in JavaScript is quite weird (hey, most of the teams ended up with GodObjects anyways! ;-)), as is any acting “hey, let’s just say we can have classess and inherit them blabla…”. We’ve seen quite a few examples on how to emulate OOP in JavaScript which was both: really weird and interesting at the same time. In the end, the thought “if you have no type system, in the end you develop your own” seems really true here. I believe this was said by someone from twitter about their Ruby code, which had a hell lot of assertions in it just to be sure “abc is really of type AbcType”. That’s why I’m more for Scalas apparoach than Groovy’s or Javascript/Ruby/Php, but I’m not that advanced in Scala yet to judge it as “super perfect”… ;-)

MK in Javascript using Node.js

On the next day we implemented the serverside stuff, using node.js and socket.io for the clientside wich worked really well I have to addmit. Although I’m still wondering how I’d handle auth/security to be _really_ secure using such server instances (“nodes” ;-))… Finally our game had a very nice and developed state machine for all basic mortal kombat moves (including high/low punch etc, how much such state is blocking and which sprite to use for it, jumping etc.). As this state manipulation took most of our time, our server didn’t support an infinite number of players as some other implementations did but as a trade off they didn’t have any combo/move logic in their games :-) Of course the game was playable (well, “almost playable” – both players think they’re “on the left”, but we’d fix that very quick if needed… ;-)). A quick finishing talk touched some performance tweaks – quite some we should have used in mSejf etc – so I feel a little smarter than before :-) Sadly we didn’t talk too much about TDD using JavaScript which may be really a good idea (ugh this loose typing can make you mad sometimes… ;-)).

Our mortal kombat game ;-)

What could be definitely improved is the internet connection (well, “organization” as a whole I guess) as we had quite a lot problems with it (choose a hotel which is no noob in terms of IT meetings :-)) and the lead’s knowlage about git. Since it’s quite an deep tool, and we’re not here to focus on it but on JavaScript some quick info about how to use it and more developers who aren’t using it the first time in their lifes would have been really helpful. But fear not, I’ve helped out all the teams with learning git and all merges, push/pull flows and other weird problems :-) So it became quite an hybrid training where some of the participants learnt quite a lot about git :-) Some may actually like it in spite of the difficulties we encountered in our very chaotic flow during our hack sessions… :-) On the other hand, any way of introducing git to new people is a good thing, but I fear some may expierience some discomfort/distrust to a tool they’ve just “learnt” on a “fly by basis”, from… well, me – another participant. ;-)

From my perspective it was a great and fun meeting and I’d like to attend more such meetings, sharing the same  formula, or slightly improved. What I loved was of course the hacking and fun of working in a team + teaching people git… :-) If you’re hungry for some team coding you may want to checkout one of the upcomming meetings or wait for SCKRKs + PolishJUGs “Code Retreat” that we’ll be announcing really soon… :-)

PS: I’ve pushed our game implementation (less than 8h of real coding (rest of the time was talking/presentations/eating etc ;-)) to github, here: https://github.com/ktoso/mk-javascript so you may want to take a look. Event out of pure curiosity :-)

UPDATE
The plugin is now available from Sonatype Nexus!

    
        sonatype-releases
        Sonatype Releases
        https://oss.sonatype.org/content/repositories/releases/
    

END OF UPDATE

Now I’ll be a bit lazy and just paste the README I’ve prepared for maven-git-commit-id-plugin on github.

  git clone git://github.com/ktoso/maven-git-commit-id-plugin.git maven-git-commit-id-plugin
  cd maven-git-commit-id-plugin
  mvn install

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
       <modelVersion>4.0.0</modelVersion>

       <groupId>pl.project13.maven</groupId>
       <artifactId>my-git-plugin-sample-app</artifactId>
       <packaging>war</packaging>
       <version>0.1</version>
       <name>my-git-plugin-sample-app</name>
       <url>http://www.blog.project13.pl</url>

       <parent/>

       <dependencies />

       <build>
           <!-- GIT COMMIT ID PLUGIN CONFIGURATION -->
           <resources>
               <resource>
                   <directory>src/main/resources</directory>
                   <filtering>true</filtering>
                   <includes>
                       <include>**/*.properties</include>
                       <include>**/*.xml</include>
                   </includes>
               </resource>
           </resources>

           <plugins>
               <plugin>
                   <groupId>pl.project13.maven</groupId>
                   <artifactId>git-commit-id-plugin</artifactId>
                   <version>1.0-SNAPSHOT</version>
                   <executions>
                       <execution>
                           <goals>
                               <goal>revision</goal>
                           </goals>
                       </execution>
                   </executions>
                   <configuration>
                       <prefix>git</prefix> <!-- that's the default value -->
                       <dateFormat>dd.MM.yyyy '@' HH:mm:ss z</dateFormat> <!-- that's the default value -->
                       <verbose>true</verbose> <!-- false is default for this -->
                       <dotGitDirectory>${project.basedir}/../.git</dotGitDirectory> <!-- required, you have to specify this path -->
                   </configuration>
               </plugin>
               <!-- END OF GIT COMMIT ID PLUGIN CONFIGURATION -->

               <!-- other plugins -->
           </plugins>
       </build>
   </project>

 git.branch=${git.branch}

 git.build.user.name=${git.build.user.name}
 git.build.user.email=${git.build.user.email}
 git.build.time=${git.build.time}

 git.commit.id=${git.commit.id}
 git.commit.user.name=${git.commit.user.name}
 git.commit.user.email=${git.commit.user.email}
 git.commit.message.full=${git.commit.message.full}
 git.commit.message.short=${git.commit.message.short}
 git.commit.time=${git.commit.time}

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean name="gitRepositoryInformation">
        <property name="branch" value="${git.branch}"/>
        <property name="commitId" value="${git.commit.id}"/>
        <property name="commitTime" value="${git.commit.time}"/>
        <property name="buildUserName" value="${git.build.user.name}"/>
        <property name="buildUserEmail" value="${git.build.user.email}"/>
        <property name="commitMessageFull" value="${git.commit.message.full}"/>
        <property name="commitMessageShort" value="${git.commit.message.short}"/>
        <property name="commitUserName" value="${git.commit.user.name}"/>
        <property name="commitUserEmail" value="${git.commit.user.email}"/>
    </bean>

</beans>

package pl.project13.maven.example.git;

import org.codehaus.jackson.annotate.JsonWriteNullProperties;

/**
 * A spring controlled bean that will be injected
 * with properties about the repository state at build time.
 * This information is supplied by my plugin - <b>pl.project13.maven.git-commit-id-plugin</b>
 *
 * @author Konrad Malawski
 */
@JsonWriteNullProperties(true)
public class GitRepositoryState {
  String branch;                  // =${git.branch}
  String commitId;                // =${git.commit.id}
  String buildUserName;           // =${git.build.user.name}
  String buildUserEmail;          // =${git.build.user.email}
  String buildTime;               // =${git.build.time}
  String commitUserName;          // =${git.commit.user.name}
  String commitUserEmail;         // =${git.commit.user.email}
  String commitMessageFull;       // =${git.commit.message.full}
  String commitMessageShort;      // =${git.commit.message.short}
  String commitTime;              // =${git.commit.time}

  public GitRepositoryState() {
  }

  /* Generate setters and getters here */
}

<context:property-placeholder location="classpath:*.properties" />
<import resource="classpath:/git-bean.xml"/>

 @Controller
 @RequestMapping("/git")
 public class GitService extends BaseWebService {

     @Autowired
     GitRepositoryState gitRepoState;

     @RequestMapping("/status")
     public ModelAndView checkGitRevision() throws WebServiceAuthenticationException {
       ServerResponse<GitRepositoryState> response = new ServerResponse<GitRepositoryState>(gitRepoState);
       return createMAV(response);
     }
 }

 {
     "branch" : "testing-maven-git-plugin",
     "commitTime" : "06.01.1970 @ 16:16:26 CET",
     "commitId" : "787e39f61f99110e74deed68ab9093088d64b969",
     "commitUserName" : "Konrad Malawski",
     "commitUserEmail" : "konrad.malawski@java.pl",
     "commitMessageFull" : "releasing my fun plugin :-)
                            + fixed some typos
                            + cleaned up directory structure
                            + added license etc",
     "commitMessageShort" : "releasing my fun plugin :-)",
     "buildTime" : "06.01.1970 @ 16:17:53 CET",
     "buildUserName" : "Konrad Malawski",
     "buildUserEmail" : "konrad.malawski@java.pl"
 }

Dzisiejszy wpis będzie o znanej i generalnie dość znanej i mającej wiele zalet metodyce Design By Contract. Temat “wypłynął” ponownie dla wielu javovców tym razem dzięki wydaniu biblioteki  CoFoJa (o którym właśnie będzie ten post) przez dwóch pracowników Google przy ścisłej współpracy z autorem pierwowzoru tego projektu. Dlaczego jednak nietypowy tytuł posta – “trzeźwe spojrzenie”? Ponieważ w odróżnieniu od niektórych nie oceniam technologii na podstawie “wow factor” a realnej używalności. Gotowi mini review tego toola? No to lecimy… :-)

Contracts For Java

Na początek warto rzucić okiem na googlowy blog gdzie ogłoszono premierę tego narzędzia oraz oczywiście samą stronę domową projektu CoFoJa. Oczywiście na samym przekierowaniu nie poprzestanę więc zaczniemy od mini definicji od strony użytkownika metodyki design by contract. Jak możemy przeczytać chociażby w pragmatycznym programiście metodyka ta ma dość spory potencjał i ciekawe możliwości – generalnie chodzi o określanie “kontraktów” na naszych metodach. Zakładanie kontraktów ma pewną wyższość nad pisanie testów jednostkowych ponieważ możemy kontrakt założyć na interfejsie a wszystkie implementujące go klasy będą z nim związane

Kontrakt może na przykład zapewnić:

• wykonanie danej metody tylko i wyłącznie wtedy gdy przekazane jej argumenty spełniają pewne kryteria (w kontekście CoFoJa byłoby to @Requires)
• zagwarantowanie spełnienia pewnych warunków po opuszczeniu metody (w kontekście CoFoJa byłoby to @Ensures ewentualnie @ThrowEnsures jeśli chcemy mieć kontrakt na rzucenie wyjątku)
• zagwarantowanie ogólnych warunków na konkretnej np. klasie (@Invariant)

Ok, skoro znamy podstawowe building blocks (zaczerpnięte skądżeby inąd niż z Eiffla oczywiście) zobaczmy jakieś przykładowe poadnotowane nimi API:

A teraz praktycznie

Najlepiej jest chwilkę się w niego wgryźć, powinien być stosunkowo zrozumiały. Nie chcemy nigdy mieć ujemnej ilości bananów – spowodowałoby to złamanie kontraktu. Podobne przykładowe kontrakty wejściowe/wyjściowe widzimy na metodach oraz jeden mały tip: metoda old() jest dostarczana automagicznie i oznacza “starą wartość tego wywołania” czyli przed wykonaniem metody na którą zakładamy ten kontrakt. Poza tym mamy tutaj do czynienia w sumie z zwyczajnym kodem Java który niestety jest wewnątrz stringa… Świadomy programista zapewne już ma zapaloną lampkę alarmową, że to będzie nie refaktorowalne i bez sensu… Na pocieszenie dodam iż kod Java zawarty w tych stringach faktycznie jest “kompilowany”i jak coś popsujemy składniowo, kontrakty się nie skompilują i dostaniemy normalne informacje jakby to się nam nie kompilował normalny “nasz kod”. Co do wygody refaktoringu… Na szczęscie korzystam z porządnego IDE (IntelliJ IDEA) i takie “problemy” mnie nie dotyczą ;-). Wybrałem inject języka Groovy do tych stringów aby parser składniowy nie dziwił się pojawienia się metody old() “z nikąd”: Problem z “nie podpowiadaniem metod” jak i “nie da się refaktorować” jak widać został od razu wyeliminowany :-) Hooray for JetBrains. Poszukajmy jednak kolejnego problemu z tym API… Tak jest, @ThrowEnsures jest trochę brzydki a nie koniecznie musi być cały w stringu. Jak działa obecnie? Przekazujemy mu listę stringów gdzie parami występują “wyjątek” + “warunek kiedy ma zostać rzucony”. Chętniej zobaczył bym to w formie podobnej do poniższej (tylko szybki szkic taki), a wy?

Ok czas na uruchomienie kodu z “włączonymi kontraktami”… I… niestety nie okazało się to takie trywialne na obecnym etapie projektu. Niestety trzeba sobie ręcznie poustawiać processowanie adnotacji (norma, tutaj się niewiele zmieni) jednak trochę problemów nastarcza mi obecnie widoczność klas/pól dla CoFoJa w intellij. Classpath (dla procesora) zdaje się być ustawiony poprawny oraz jego klasa jak i inne opcje też jednak nie dochodzi do poprawnego przeparsowania wszystkich reguł. No cóż, może jutro się uda – tymczasem odsyłam do poradnika dla użytkowników Eclipse gdzie to członek społeczności sprawnie poradził sobie z tym problemem :-)

Trzeźwe spojrzenie: “Czy obecnie warto?”

Pozostaje pytanie… Czy warto się zainteresować CoFoJa jak i samym DBC? Pytanie jest chyba równie ogólne jak “czy warto meta-programować?” także wprost odpowiedzi nie udzielę. Miejmy jednak na uwadze że jak na razie używanie CoFoJa nie jest zbyt wygodne a adnotacje można by jeszcze trochę poszlifować. Trzeba by jeszcze rzucić okiem jak stoimy z integracją tego z Maven – aby normalnie testując bądź klikając sobie po projekcie te kontrakty mogły się przydawać. Sama idea jest ciekawa i jakby integracja z narzędziami była wygodniejsza – a może od razu pluginy do IDE – można by się nad tym porządniej zastanawiać. Jak na razie projekcik odkładamy ten projekt spokojnie na półkę “worth watching” i liczymy na rychłe wydanie 2.0. :-)

PS: Jeżeli interesują Cię takie jak i inne ciekawe metodyki i sposoby tworzenia pięknego, czystego kodu, zapraszam serdecznie na co 2 tygodniowe spotkania SCKRK gdzie obecnie dyskutujemy w formie “reading club” nad Domain Driven Design :-)

So… Since I’ve started using git-svn at work, I do have an possibility to make things better now! The answer lies in client-side-hooks and git aliases (“custom commands”). First let’s write this as an simple bash script, that we’ll locate in the .git/hooks/ folder:
It’s a fairly simple script, so I wont bore you explaining it in detail – if in doubt, feel free to ask. We only need to place this script as “.git/hooks/pre-commit” and make it executable and git will take care of the rest for us. Oh and in case you’re wondering where that org.eclipse.jdt.core.prefs came from. It’s created by eclipse into the .settings folder when you check some option to “use formatter per project” – that’s the only time I had to fire up and click around in eclipse to get it’s formatter running “headless”. Ok, let’s check if it works…

Yup, you can agree or not with the formatting rules – but what matters is that the whole team decided on it and that we keep it consistent throughout the whole project. This hook will definitely help with this. :-) Step two for me was changing this into a git command, so that I wouldn’t launch eclipse each time I just do some quick local commiting. The solution is to drop the hook idea (although it’s quite nice) and create an custom git command. We do this by doing an alias like that:

git config --global alias.eclipse-formatter '!~/git-hook-eclipse-formatter'

The !command alias support is with us in git since 1.5.0 and it enables us to launch any program/script as an git command. Great, just what I wanted! Let’s now see what this command really did:

As you can see, adding an alias is as simple as adding it to your ~/.gitconfig or, if you want to setup the alias “per project”, to .git/config – pretty cool, ay? Also, this command will be included in bash-autocompletition suggestions! :-)

That’s it for today… happy hacking!

Łukasz Lenart – “Nie samym kodem programista żyje”

Łukasz’s presentation was not a technical one this time. He talked about how to be/become an effective programmer. A nice tip he noted was to carry a notebook and note your ideas in it – i sometimes try to but did find myself forgetting some “amazing idea” due to the lack of discipline in carring such notebook (yeah, an paper-notebook… :-)) so it’s definitely something worth reminding. He also talked a little about Kaizen, ZenToDone and the Pomodoro Technique which all kinda share the same idea but explain it a little bit differently. I also was quite happy to find out that I’m not the only one that gets slown down in development when actually being in the company – with lots of stuff happening around me. Admit it – we all work more productive when there’s noone bugging us ;-)

The most notable tips where the “alone-zone” (as explained in REWORK (good book, I recommend it)) which is really great and I love it, but sometimes it’s hard to enforce – coding is usualy team work, ain’t it..? Using multiple desktops – and monitors at best, to seperate your work space from fun space. Cutting oneself off from the internet is, while extreme, very effective by the way. I noticed it quite a few times – there’s simply nothing distracting you – same goes for anything that might take your attention. By the way, I’m not really convinced about Pomodoro – what if you get into an v. nice flow and then the pomodoro snaps you out of it? I guess it may be more targeted at people working at bigger companies – not as myself in an small nice team and nowadays, mostly from home.

All in all he warmed up the audience perfectly and let’s hope some of theese tips help us become better programmers… :-)

• //TODO: watch on parleys.com
• //TODO: download slides
• download video

Konrad Malawski – “Git (tak. po prostu.)”

The PJUG guys asked me to tell a little about git and I happily agreed to do it – thus, my first “public presentation”. Firstly I’d like to explain why the slides where so “weird”. It’s because I wanted them to be something like an “break”, and most of the session was live terminal typing. They were all hand drawn by me and my girlfriend, then scanned and recoloured in GIMP. Took a few evenings to prepare them, but I hope they where quite memorable, fun, and did point out the important aspects of what the next topic would be about – an 3 headed dragon as symbol for lots of HEADs in an git repo etc… ;-)

Click to show presentation

I’ve been preparing the flow of all examples before but during the presentation I missed out a few steps and made a some stupid mistakes (see my previous git post on this blog ;-). Well, it wasn’t anything world breaking I guess and I’d really like to thank the audience for such great support. We strayed a little of the path I’ve prepared sometimes, but that’s ok as it was interesting to interact with the audience during an presentation – not just stand there and “praise git to zee heavnz” ;-) Such interaction is something I (personally) really like in presentations, even if they break a little due to this :-)

All in all, we managed to go through all of git’s basic features and in the end even mentioned rebase – which can be used to change the history of ones commits (there’s also the very useful git commit –amend), detached-HEADs and git-svn, which I didn’t use before as I feared a little to make a mess in the company svn-repo (and in all “my” projects I’m using git, so I never felt the need to use git-svn). Some guys sucessfully used it and really recommended it, thus… here I am, doing git svn dcommits on an daily basis… :-) I’m glad to have also learned something from this presentation, not just “showed what I had to show” :-) Now just a few links to very good resources about git:

• A Successful Git Branching Model
• Very good video tutorial on git
• https://git.wiki.kernel.org/index.php/GitFaq
• http://git-plumbing-preso.heroku.com – internals
• https://github.com/ – free opensource project hosting
• and of course: http://git-scm.com/documentation

After the presentation I made an small sms-contest where you could win an PJUG tshirt for guessing what github’s mascot is called like. I hope it was an nice positive accent to finish the session. Next up was the pizza and then 2 more Łukasz’s… :-)

• //TODO: watch on parleys.com
• download slides
• download video

Łukasz Żmudziński – “Project Lombok – Cause We Hate Boilerplate!”

Lombok, if you didn’t see it before is this -> http://projectlombok.org/ It’s a “total hack”, as the author describes it (and he’s right ;-)) but it allows some funny compile time hacks while writing Plain Old Java Code. Łukasz showed us around all the annotations which Lombok provides and how they work, what code exactly would be generated by them etc. The most “let’s you write less code” annotation would be @Data, which at compile time would cause Lombok (…here comes the important part:) to write the source for all setters, getters and toString hashcodes etc – so javac in the end, thinks it’s just compiling plain odl java… Here’s a link on how it works: Data.html The funny part about it is that it’s an compile time tool – much similar to Spring Roo in that aspect if you ask me -  and what it actually modifies is the AST (AbstractSourceTree) that javac then uses to generate it’s bytecode… So no bytecode magic – just how I’d call it… source code injection during compile time? Yeah, weird stuff.

And if you ask me not really something I’d be using all over the place. Sure it’d spare me the writing of some getters and setters and some more tricks but in the end, it’s a problem for not supported IDEs. (How do you explain IDEA that this class really *will have* an setBla() method…?) While NetBeans and Eclipse do have plugins to enable them to unserstand lomboks annotations. It’s not really enough – what about static code analisis tools? They’d go nuts with code that calls methods which dont exist in the source etc :-) Nevertheless if was a fun topic and it definitely is an quite funny javac hack, but if I’d be desperate for such features… I’d go polyglot coding with groovy or scala etc… :-)

• //TODO: watch on parleys.com
• download slides
• download video

Łukasz Czerpak – “Testy jednostkowe i integracyjne w przykładach”

By now you probably noticed it… There where almost only Łukasz’s presenting on this Camp…! :-) Łukasz Czerpak’s topic was about, generally speaking, TDD. He focused (as the title suggests, if you can read polish ;-)) on unit and integration tests. The border between them is sometimes a little blury, but the definitions he have were nice and clear – 1 class = unit, long setup involved = integration. It’s as easy as that, yet sometimes during discussions with other coders these sometimes get confised. Next he went on to some examples of how TDD is useful and finally to a lot of code examples. As he’s using EJBs at his day job, this part was mostly covered – and very interesting (for me, who’d usually just use spring and be done with it).

The mocking framework he used in his examples was of course our Polish Mockito… :-) It’s really great and lot’s of fun to work with, unlike some other mocking frameworks out there. Although easymock would take the 2nd place if I’d were to make an ranking. I’ve also seen a little JMock but it doesn’t “feel good” – but if youre interested in pure “what X can do”, they all do offer the same things, so why bother with some cluttery syntax? :-)

Next, Łukasz showcased using glassfish as an embeded container which definitely is on my “good to know” list and then continued on to an very awesome JBoss library: Arquillian [arquillian homepage] (see? It’s so cool I even had to mark it bold ;-)) It’s an lib which enables you to deploy (yes, “deploy” – perfect word choice) EJBs or even whole archives to an testing enviroment – which would then be started using an embeded container, although as seen on their homepage, they also support remote containers… interesting! Here’s another nice usecase of it: http://ocpsoft.com/seam/cdi-powered-unit-testing-using-arquillian/ The presentation was really well prepared and most probably the high

• //TODO: watch on parleys.com
• //TODO: download slides
• download video

That’s all folks!

We’ll be doing another JavaCamp in the near future (January perhaps…?). But for theese few weeks now we’ll be focusing on the upcomming GeeCON 2011 (Cracow) and kickstarting it’s call for papers (yay, I’m it’s author ;p). And if you’re interested in seeing all recordings on parleys.com and not just as videos – stay on your toes, because after Devoxx we’ll upload them there – I’ll update my blog then and we’ll write an quick news about it on java.pl In the mean time, you can go take a look at these and the previous (javacamp #4) recordings on camp.java.pl – which I just quickly set up to allow you guys quick access to the movies…

Yup, that’s all I think… see you on GeeCON || JavaCamp #6! :-)

If you code in Java, you most probably use (you really should use) some dependecy injection mechanisms. They’re really great and take care about all the setup that need’s to be done before you can move on to your coding. The same thigh applies to testing, you’d rather write:

Than use the new operator, or worse, perform some super weird setup to build this object. If you use spring, you’d write an test like this to make it support Spring’s DI:

That’s all you need to make your tests properly autowire all components they’re using. So far so good – probably nothing new here, and nothing complicated. So let’s move on to some “super big data set” that needs to be tested, over the same flow over and over again. We’ll use an super conplicated example to showcase what I mean:

Ok, that’s obviously stupid… :-) So, how do we deal with repetitive tests, that need some bigger dataset than just this email example (given here because it’s short and good enough for our example test)…? We’d use @RunWith(Parameterized.class), the class would then look something like this:

Ok, that’s a nice way to make your code in the tests smaller yet have an nice overview through all of your tested data. Each array will be inserted in the constructor, and then ran as an seperate test – with each dataset. Nice, isn’t it?

Ok, but what if we want to have both Spring’s DI and an @Parameters “test data provider”…? Can you spot the problem? Yup, JUnit4 can only have ONE @RunWith annotation, and it doesn’t accept multiple runners. Which totaly makes sense when you think about it, but then there is our special case of DI, which really doesn’t change the way an test wotks, it just makes setup easier… All that said, here’s how to use both spring and parameters in your Junit4 tests:

That’s it :-) We do what the spring Runner would do for us, instanciate an application context and prepare it – that’s when the DI happens. Note that we cant use another runner annotation, but we can as usual specify where to find the appContext.xml’s.

That’s all, hope this will prove useful to some of you :-) Keep your tests clean!

PS: Warning, most of this code was written in wordpress, it may contain minor spelling errors ;-)

git mv oldname newname
        =
mv oldname newname
git add newname
git rm oldname

Note that last line, git rm oldname is what we fotgot to do in our example, thus git was seeing an just the “new file” version of our operation. One line wrong, yet very important :-) Let’s check if it works this way:

[ktoso@homunculus test]$ ls
jeden  typescript
[ktoso@homunculus test]$ git init .
Reinitialized existing Git repository in /home/ktoso/test/.git/
[ktoso@homunculus test]$ cat jeden
drugi pliczek
[ktoso@homunculus test]$ echo 'dwadwa' > dwa
[ktoso@homunculus test]$ cat dwa
dwadwa
[ktoso@homunculus test]$ git add .
[ktoso@homunculus test]$ git commit -m 'dodanie ich'
[master (root-commit) a430782] dodanie ich
2 files changed, 2 insertions(+), 0 deletions(-)
create mode 100644 dwa
create mode 100644 jeden
create mode 100644 typescript
[ktoso@homunculus test]$ git mv
dwa         .git/       jeden       typescript
[ktoso@homunculus test]$ git mv jeden nowy-jeden
[ktoso@homunculus test]$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       renamed:    jeden -> nowy-jeden
#
[ktoso@homunculus test]$ mv
dwa         .git/       nowy-jeden  typescript
[ktoso@homunculus test]$ mv dwa nowe-dwa
[ktoso@homunculus test]$ git add nowe-dwa
[ktoso@homunculus test]$ git rm dwa
rm 'dwa'
[ktoso@homunculus test]$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       renamed:    dwa -> nowe-dwa
#       renamed:    jeden -> nowy-jeden
#
[ktoso@homunculus test]$ echo "problem Solved... :-)"
problem Solved… :-)

Yup, it actually detects the renames proppery. Even more, it would detect an “copy” action (this works even easier):

[ktoso@homunculus test]$ cp nowy-jeden nowy-jeden-jeden
[ktoso@homunculus test]$ git add .
[ktoso@homunculus test]$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       renamed:    dwa -> nowe-dwa
#       copied:     jeden -> nowy-jeden
#       renamed:    jeden -> nowy-jeden-jeden
#       modified:   typescript
#

I’m already converting all the presentations to MP4 files and they’ll be online soon I hope :-) Then I’ll also write an usual “review” as I always do with any confernce/meering. For now just a quick summary: An amazing attandee count, nice presentations and an very very nice crowd :-) Thanks a lot for all the talks, but let’s wair for my “review” with more informations about JC5… :-) (Oh, yes we’re allready planing JC6… ;-))

As this years WARSJawa looked very interesting since it’s been annouced. I immediatly decided to go there – and tried to convince some friends to go with me. In the end, 2 friends came with me: Andrzej Grzesik (from PolishJUG) and Temporal – a LISP/Erlang hacker from my university ;-) We had to ride out at 5:00 to on time (driving so soon in the night really sux), but it was definitely worth it! Now let’s go on with a quick review as always after any conference:

Wojciech Erbetowski z PlayFramework

Wojtek started out the conference with an quick prezi.com presentation but then dived deep into the code and showed us an basic demo of the Play framework in action… I’m not really getting “turned on” by “yet another framework” so I wasn’t all too enthusiastic about it. Some things are really horrible in Play – all views are generated by static methods for example – oh God… Please dont force me to test such an application – you know, with multiple threads… ;-)

All in all: “I won’t be using this one.”

Dariusz [LocK] Łuksza z EGit i przyjaciele

As Darek has taken part in this years Google Summer of Code in the EGit project, he’s the perfect person to give a speech about this plugin. Sadly we encountered an bug in EGit during his presentation and it “broke his flow” a little – which I fully understand. Doing live coding/demos is really hard and I’ve seen a lot of experienced developers/presenters having problems with ther demos. It’s the so called “Weird, this did work last night!” or “Demo-” syndrome… Nothing you can do about it. As LocK’s presentation was mostly about clicking, I wasn’t so happy with it as I’m more of an terminal hero, and like to do all my git commands from the command line. Nevertheless, the EGit plugin seems to have improved quite a lot!

Btw the way… My friends from the PolishJUG have asked me to present about Git during the next JavaCamp (#5), but my presentation (while also being an live demo (oh please don’t allow it to fail… ;-))) will be purely terminal and git command focused. I hope you’ll like that approach…

Paweł Lipiński z “niespodzianką” – w ostatniej chwili za Sławka Sobótkę

This talk was one of the “fun” ones. No hardcore coding action, but lots and lots of fun and comparing everything to Agile. And Software Craftsmanship to a boy that won’t clean up his room etc etc. A very fun talk, but there’s not too much to comment on here, so let’s move on to the meat of this conference:

Marcin Rzewucki z Clojure – podstawowo i praktycznie

“This is the meat.” This is the one presentation that convinced Jacek (Temporal) to go with us to this conference. And I really have to say, it’s also what really tickled my hacker sense looking at the agenda. So, were we let down with just some basic intro..? NO, absolutely no. This presentation was very invofmative, easy to grasp and it turned out to be two presentations in one! The first part by Marcin was an intro to the language and how it functions, along with calling Plain Old Java from it. (Btw, kudos to Marcin for speaking so clearly even though he had some health (throat) problems  at that time)

The second part, which was taken over by Jan Rychter was entirely focused on the practical aspect of coding in Clojure in an commertial application. It was VERY, VERY interesting to see how and why one would use an functional (“very functional”, not just Scala) language to implement some application.

And don’t forget to add Marcin’s blog – http://www.clojureblog.pl/ to your RSS feeds!
Yet another link for starters: http://clojure.org/

Adam Michalik z Co w bajtkodzie piszczy?

You may remember my blog post where I’ve been decompiling string concatenations inside an for loop just to see how much more dump it produces. Adam’s presentation was just about that, decompiling and analyzing the ByteCode. It’s an very fun topic to look into and may lead someone into implementing some language on top of the JVM… :-)

But Adam didn’t stop at just analyzing the ByteCode, in the end he actually coded some fun stuff that the ByteCode allows us to do but the javac compiler doesnt – such as multimethods and calling methods of an interface (invokeinterface) on an Object object… ;-) There were some fun tricks included in his presentation and he seemed really compenent about this matter. “Bit fat 10 points for the man over here ;-)”

Rafał Rusin z Tworzenie zadań przy użyciu komponentów Open Source (Apache HISE, Apache Camel)

While being a little accustomed to (“I know what it is”) with Apache Camel, and seeing some sense in it. I really can’t seem to find any particuilar use case for my for Apache HISE. It’s an WS-Human-Task Spec implementation and aims to… wel… And that’s the problem I had during this presentation, I didn’t quite grasp why I would use it. The general concept of Human Tasks is quite easy to understand, but why I’d need Hise for it is not… One of the reasons I didn’t grasp it may be that we were dead tired after riding +4hours to Warsaw. Having that said, you may want to take a look at their homesite.

Summary

We all really enjoyed everything there in Warsaw, the great people (hooray for networking), food and last but not least the great presentations. During the few presentations we didn’t enjoy we were hacking some of emacs sources (using emacs of course… ;-)), and what a suprise – they’re mostly LISPs (the plugins). That was also a very interesting thing I took from this conference… I’d recommend you go to the next edition ot WarsJawa if you still haven’t been there… It’s even worth +8hours in a car on one day! :-)

Photos and more reviews can be found here:

• http://picasaweb.google.com/bartek.zdanowski/Warsjawa2010#5531326004503230818
• http://blog.japila.pl/2010/10/warsjawa-2010-za-nami-o-javarsovii-2011.html
• http://picasaweb.google.pl/Anna.Mazinska/Warsjawa?authkey=Gv1sRgCNm7mvryj7LcsQE#

PS: Yeah sorry for less links to projects and homepages than I usually include, but I’m kinda very busy right now… :-)