OlliN's » software

It’s never to late for git.

ollin — Sun, 18 Dec 2011 11:32:57 +0000

If not already done, every software developer must try GIT - the fast, distributed version control system. It’s such a nice and useful tool. Once every week I find a new little nice feature.

The last month I used the git-client together with a svn-remote repository and I will never use the svn client again. It is so handy to have the full history of the repository on my notebook. I can commit my changes every time to my local repository and merging/branching is just fun. I’m so much faster …

Here my path to git

Effectively Using Git With Subversion
Dominik (a colleague which answered my first questions)
Pragmatic Guide to Git by Travis Swicegood
The Git Community Book
the git man pages
… and using it every day

Here my favorite git client in action (the command line client :

git command line

There are plugins for eclise, idea, windows, mac… So give it a try and have fun!

And if you want to have the little nice prompt add the following lines to your .bashrc:

...
#-----------------------------------
# git in prompt
#-----------------------------------
        RED="\[\033[0;31m\]"
     YELLOW="\[\033[0;33m\]"
      GREEN="\[\033[0;32m\]"
       BLUE="\[\033[0;34m\]"
  LIGHT_RED="\[\033[1;31m\]"
LIGHT_GREEN="\[\033[1;32m\]"
      WHITE="\[\033[1;37m\]"
 LIGHT_GRAY="\[\033[0;37m\]"
 COLOR_NONE="\[\e[0m\]"
 
function parse_git_branch {
        git rev-parse --git-dir &amp;&gt; /dev/null
        git_status="$(git status 2> /dev/null)"
        branch_pattern="^# On branch ([^${IFS}]*)"
        remote_pattern="# Your branch is (.*) of"
        diverge_pattern="# Your branch and (.*) have diverged"
 
        if [[ ! ${git_status} =~ "working directory clean" ]]; then
                state="${RED}?"
        else
                state="${GREEN}?"
        fi
 
        # add an else if or two here if you want to get more specific
        if [[ ${git_status} =~ ${remote_pattern} ]]; then
                if [[ ${BASH_REMATCH[1]} == "ahead" ]]; then
                        remote="${YELLOW}?"
                else
                        remote="${YELLOW}?"
                fi
        fi
 
        if [[ ${git_status} =~ ${diverge_pattern} ]]; then
                remote="${YELLOW}?"
        fi
 
        if [[ ${git_status} =~ ${branch_pattern} ]]; then
                branch=${BASH_REMATCH[1]}
                echo " (${branch})${remote}${state}"
        fi
}
function prompt_func() {
        previous_return_value=$?;
        prompt="${GREEN}${USER:-$(type whoami >/dev/null && whoami)}@$(type uname >/dev/null && uname -n) ${BLUE}[\w${GREEN}$(parse_git_branch)${BLUE}]${COLOR_NONE} "
        if test $previous_return_value -eq 0
        then
                # PS1="${prompt}? "
                PS1="${prompt} \\$ "
        else
                #PS1="${prompt}${RED}?${COLOR_NONE}"
                PS1="${prompt}${RED}\\$ ${COLOR_NONE}"
        fi
}
 
PROMPT_COMMAND=prompt_func

I found this script at github and changed it a little bit. Thx to trapni.

The Clean Coder

ollin — Tue, 08 Nov 2011 07:56:49 +0000

Habe gestern Abend “The Clean Coder” von Robert C. Martin (Uncle Bob) fertig gelesen. Ich wäre so froh gewesen, wenn ich dieses Buch als Berufseinsteiger gelesen hätte. Es hätte mich so manche Fettnäpfchen vermeiden lassen.

Spannend zu lesen war seine Meinung über den “Flow”. Dieser Zustand beim Programmieren, oder Arbeiten allgemein, wo man die Zeit vergisst und einem schier alles gelingt. Uncle Bob findet diesen Zustand eher hinderlich, weil man den Blick für das Grosse verliert. Ich denke es hängt ein wenig vom Arbeitsstil ab. Ich habe immer zu Beginn mein Notizbuch vor mir liegen, wo ich den grossen Kontext aufzeichne. Manchmal komme ich dann schon in Flow während ich beim dem Design bin – also einem relativ hohen Abstraktionsniveau. Trotzdem hat mich das Buch etwas kritischer gegenüber dem Flow werden lassen.

Einen völlig anderen Blickwinkel auf den Flow hat z.B. Joel Spolsky (bekannt von dem Blog “Joel on Software“). Er erzählt in einem Interview, wie wichtig er den Flow findet und das er die Büros sogar so gestaltet, das man sich richtig gut in die Arbeit vertiefen kann.

Es gibt aber in dem Buch noch sehr viele andere Perlen und Denkanstösse zu finden. Lesen!

netbeans 7 update and the license agreement dialog

ollin — Tue, 09 Aug 2011 12:19:56 +0000

I’ve just updated NetBeans. The following dialog appeared:

License Agreement Dialog

How many people read those 85 263 lines of text carefully?

I’m going to FOSDEM 2011

ollin — Wed, 02 Feb 2011 09:05:59 +0000

Funny Emerging Threats

ollin — Tue, 02 Nov 2010 20:19:03 +0000

I hope I did not land on the black list.

Gesetz von Demeter, Unit Tests und der zweite Programmierer

ollin — Sat, 21 Nov 2009 10:43:33 +0000

In meinem letzten Post habe ich beschrieben, das Delegation für den Benutzer einer Klasse angenehm ist und das wir dies auch im realen Leben schätzen. Heute möchte ich kurz beschreiben wie sich das Einhalten des Gesetzes von Demeter auf das Schreiben von Unit-Tests und das Benutzen meiner Implementierungen auswirkt. Dazu habe ich das Modell um Implementierungen erweitert:

Am Beispiel von CityBike möchte ich erklären, dass die Implementierung der Unit-Test’s jetzt ganz einfach geht. Wir haben also die leere Implementierung der Klasse:

public class CityBike implements WithBasket {
 
    private Basket basket;
 
    public CityBike(Basket basket) {
    }
 
    public void addElement (Element e) {
    }
 
    public Basket getBasket () {
        return null;
    }
}

Alle Implementierungen sind leer, da wir ja im Sinne von Test-Driven Development (TDD) zuerst unsere Tests schreiben und erst danach die Implementierung. Hier also die JUnit4-Testklasse:

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
 
public class CityBikeTest {
 
    private Basket basket;
    private CityBike cityBike;
 
    @Before
    public void setUp() {
        basket = mock(Basket.class);
        cityBike = new CityBike(basket);
    }
 
    @Test(expected=IllegalArgumentException.class)
    public void shouldNotCreateWithNullAsBasket() {
        new CityBike(null);
    }
 
    @Test
    public void shouldDelegateAddElementToBasket() {
        Element e1 = mock(Element.class);
        //
        cityBike.addElement(e1);
        //
        verify(basket).add(e1);
    }
 
    @Test
    public void shouldReturnBasket() {
        assertEquals(basket, cityBike.getBasket());
    }
}

Alle 3 Tests melden einen Fehler. Also ändern wir die Implementierung so, dass die Tests funktionieren:

public class CityBike implements WithBasket {
 
    private Basket basket;
 
    public CityBike(Basket basket) {
        if (null == basket){
            throw new IllegalArgumentException("null as basket not allowed");
        }
        this.basket = basket;
    }
 
    public void addElement (Element e) {
        this.basket.add(e);
    }
 
    public Basket getBasket () {
        return this.basket;
    }
}

Alle Tests funktionieren. (Die Implementierung und Tests für SimpleBasket und SimpleElement lasse ich hier im Text mal weg, damit es nicht zu unübersichtlich wird.) Damit haben wir als Programmierer von CityBike mal alles gemacht

Jetzt kommt ein zweiter Programmierer und möchte unsere Klassen benutzen. Es wird eine Person implementiert, die mit dem Fahrrad fahren soll. Allerdings muss dieser Fahrer seine Umhängetasche in den Korb (Basket) legen, bevor er losfahren darf. Natürlich sollte auch der zweite Programmierer seine Klassen “Fahrer” und “Tasche” testen. Hier die fertigen Implementierungen:

public class Fahrer {
 
    private Tasche tasche;
 
    private CityBike cityBike;
 
    public Fahrer(Tasche tasche, CityBike cityBike) {
        if (null == tasche){
            throw new IllegalArgumentException("null as tasche not allowed");
        }
        this.tasche = tasche;
 
        if (null == cityBike){
            throw new IllegalArgumentException("null as cityBike not allowed");
        }
        this.cityBike = cityBike;
    }
 
    void losfahren(){
        this.cityBike.addElement(tasche);
 
        // aufsteigen
        // nach rechts und links schauen
        // anfangen in die Pedalen zu treten
    }
}
 
public class Tasche implements Element {
 
    public int getWeight() {
        return 12;
    }
}
 
import org.junit.Before;
import org.junit.Test;
import static org.mockito.Mockito.*;
 
public class FahrerTest {
 
    private Tasche tasche;
 
    private CityBike cityBike;
 
    private Fahrer fahrer;
 
    @Before
    public void setUp() {
        this.tasche = mock(Tasche.class);
        this.cityBike = mock(CityBike.class);
 
        this.fahrer = new Fahrer(tasche, cityBike);
    }
 
    @Test
    public void shouldAddTascheInKorb() {
        //
        fahrer.losfahren();
        //
        verify(cityBike).addElement(tasche);
    }
}

Was passiert, wenn wir die Methode addElement(Element e) aus WithBasket und CityBike rausnehmen. Jeder der dann WithBasket, CityBike oder andere Subklassen von WithBasket benutzt muss dann den Wege über getBasket().add(Element e) gehen. Die Methode losfahren in Fahrer sieht dann so aus:

    void losfahren(){
        this.cityBike.getBasket().add(tasche);
 
        // aufsteigen
        // nach rechts und links schauen
        // anfangen in die Pedalen zu treten
    }

Aber nicht nur das wir jetzt in X Klassen dieses getBasket().add(tasche) stehen haben. Wir machen den Benutzern unserer Klasse auch noch das Testen schwieriger:

import org.junit.Before;
 
import org.junit.Test;
 
import static org.mockito.Mockito.*;
 
public class FahrerTest {
 
    private Tasche tasche;
 
    private CityBike cityBike;
 
    private Basket basket;
 
    private Fahrer fahrer;
 
    @Before
 
    public void setUp() {
 
        this.tasche = mock(Tasche.class);
 
        this.cityBike = mock(CityBike.class);
 
        this.basket = mock(Basket.class);
 
        this.fahrer = new Fahrer(tasche, cityBike);
 
    }
 
    @Test
 
    public void shouldAddTascheInKorb() {
 
        when(cityBike.getBasket()).thenReturn(basket);
 
        //
 
        fahrer.losfahren();
 
        //
 
        verify(basket).add(tasche);
 
    }
 
}

Wir haben eine zusätzliche Membervariable basket im Test und der Test muss noch Vorbereiten das auf cityBike auch wirklich ein Basket geliefert wird. Und hier haben wir nur eine Verschachtelungstiefe. Man denke sich mal aus wie es aussieht wenn wir folgende Situation haben: A.getB().getC().getD().add(E e). Und jetzt stelle sich der Leser noch vor, dass das ganze Konsequent in der ganzen Applikation so gemacht wird. Irgendwann sind die Tests so aufwendig und kompliziert, dass kein Entwickler mehr Tests schreibt, weil einfach keine Zeit ist. Wenn dagegen immer das Law of Demeter eingehalten wird, dann sind die Tests kurz und einfach.

Schlusswort:

Ich habe hier Mockito verwendet um die Mock-Objekte zu schreiben. Eine wirkliche Empfehlung von meiner Seite. Diese Bibo ist der Hammer. Wirklich schnell zu lernen und eine wunderschöne API. Gratulation an die Entwickler zu diesem tollen Stück Software.

Schönes Wochenende!

Netbeans, Ivy und Spring 3.0.0M4

ollin — Tue, 11 Aug 2009 20:35:52 +0000

Ich programmiere gerade eine kleine Web-Applikation und möchte dazu die neuen REST-Features vom Spring-Framework benutzen. Bis gestern habe ich mir dazu in Netbeans ein Webprojekt gebaut und dann ganz artig alle notwendigen Bibos von Hand dem Projekt hinzugefügt. Gestern wurde nun der Milestone 4 von Spring 3.0.0 veröffentlicht und ich wollte mir nicht noch einmal die Arbeit machen.

Also musste ein Tool her, welches mir alle notwendigen Jar’s auflösen kann und in mein Projekt einhängt. Da ich nicht so ein rechter Fan von Maven bin, habe ich wieder einmal die Gelegenheit genutzt und Ivy ausprobiert. Als IDE verwende ich Netbeans – also muss ein Plugin für Netbeans her, welches mir die Arbeit mit Ivy innerhalb der IDE vereinfacht. Also schnell mal bei ivybeans vorbeigeschaut. Version 1.1 unterstützt jetzt auch Webprojekte – Schick! Also schnell das Plugin installiert und ein Repository gesucht in welchem die 3.0.0M4 Version von Spring liegt. Nach ein wenig Suchen habe ich dann herausgefunden, dass es ein Spring-eigenes Repository in Amazon S3 gibt (S3Browse ist übrigens ein guter Browser für S3).

Dann habe ich mir noch die folgenden zwei Dateien für die Konfiguration von Ivy im Projektverzeichnis meines Webprojektes angelegt:

Hier der Inhalt der Dateien:

 version="1.0" encoding="UTF-8"?>
 version="2.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation=
                   "http://ant.apache.org/ivy/schemas/ivy.xsd">
     module="WebApplication2" organisation="WebApplication2" revision="1.0"/>
    >
         name="compile"/>
         name="runtime"/>
         name="compile-test"/>
         name="runtime-test"/>
    >
    >
         org="org.springframework" name="spring-webmvc" rev="3.0.0.M4" conf="" />
    >
>

 version="1.0" encoding="UTF-8"?>
>
     defaultResolver="chained"/>
    >
         name="chained">
             name="maven2" m2compatible="true"/>
             name="s3.maven.springframework.org" m2compatible="true" root="http://s3.amazonaws.com/maven.springframework.org/milestone/"/>
        >
    >
>

Dann im Projekt Ivy aktivieren. Dazu mit der rechten Maustaste auf das Projekt und in den Ivy-Einstellungen das Häkchen machen und die zwei Dateien auswählen:

Dann noch das Projekt zwingen sich die Jars zu holen:

Und siehe da… alle Jar’s und Sourcen (wenn im Repository) sind da:

Mit der rechten Maustaste kann man nun ganz einfach die Abhängigkeiten entfernen, die man nicht braucht.

Upgrade Debian Etch zu Debian Lenny mit Virtualmin

ollin — Mon, 04 May 2009 19:54:47 +0000

Letztes Wochenende habe ich nun endlich meinen Hetzner-Server von Debian 4 auf Debian 5 umgestellt. Zur Administration der Domains benutze ich Virtualmin und dies sollte natürlich dann auch noch laufen. Eine Anleitung war bei www.virtualmin.com zu finden. Allerdings stimmte da die Reihenfolge in welcher man die Pakete installieren sollte noch nicht ganz. Nachdem ich einen Bug bei virtualmin.com aufgemacht hatte, war das Problem aber zusammen mit den Jungs von virtualmin.com (Jamie Cameron und Joe Cooper) schnell gelöst. Wirklich schneller und kompetenter Support – Spitzenklasse!

Nach dem Upgrade konnte ich mich dann aber nicht via POP3 auf dem Mail-Server einloggen. Ich musste dazu noch die Konfigurationsdatei (/etc/default/saslauthd) von saslauthd anpassen:

Die Zeile

START=no

auf

START=yes

ändern und den richten Pfad eintragen. Von:

OPTIONS="-c -m /var/run/saslauthd"

auf:

OPTIONS="-c -m /var/spool/postfix/var/run/saslauthd"

Dann die Services nochmal neu starten
# /etc/init.d/saslauthd restart
# /etc/init.d/postfix restart

Und schon funktionierte die Anmeldung auf dem POP3 wieder.

Künstler und Softwareentwicklung – Teil 2

ollin — Wed, 18 Mar 2009 20:12:34 +0000

Nun, Künstler und Auftragsarbeiten ist so eine Sache… Aber nicht nur der Punkt war an meinem letzten Blog-Eintrag ein wenig “schräg”.

Unter der Annahme das der Auftraggeber weiss was er möchte, geht es eigentlich bei der Anforderungsanalyse darum, dass der Auftragnehmer versteht was der Kunde eigentlich möchte. D.h. der Künstler – um beim Beispiel zu bleiben – muss die grobe Beschreibung lesen und die richtigen Fragen stellen. Er muss dem Bildliebhaber z.B. fragen: “Ist es okay, wenn das Bild kubistisch ist?”. Wenn das nicht klar ist, dann muss man sich darüber unterhalten…

Künstler und Softwareentwicklung

ollin — Thu, 12 Mar 2009 14:42:01 +0000

Was hat die Anforderungsanalyse oder besser Anforderungserhebung in der Softwareentwicklung mit einem Künstler zu tun?

Will man ein Softwaresystem bauen, so muss man wissen was man da eigentlich bauen möchte. Logisch, oder? Also notiert man sich die Anforderungen. Doch die Frage ist: Wie genau muss dies gemacht werden?

Genau wie man Aufwand in die Erstellung eines Systems steckt, so bekommt auch eine detailierte Anforderungsspezfikation nicht umsonst erstellt. Es macht auch wenig Sinn 3 Jahre zu spezifizieren und dann festzustellen, dass man es in 3 Monaten implementieren kann. Die Verhältnismässigkeit ist nicht mehr gegeben. Als Auftraggeber kann man nun trotzdem der Meinung sein, dass, wenn man nur genau genug sein Anliegen spezifiziert, diesen Anforderungskatalog jedem Softwareentwickler geben kann und dann das System erhält, welches man haben möchte.

Dazu folgendes Gedankenspiel:

Herangehensweise 1:

Ich möchte ein Bild für mein Wohnzimmer. Es sollen Pferde auf einer Wiese dargestellt werden. Nun beschreibe ich das Bild so gut wie ich kann und gehe zum ersten Künstler um die Ecke.

Herangehensweise 2:

Als erstes suche ich mir einen Künstler aus, dessen Werke ich kenne und die mir gefallen. Eventuell hat er schon ähnliche Bilder gemalt und ich beschreibe mein Wunschbild in groben Zügen.

Was funktioniert besser?

Man bedenke allein die vielen Stilrichtungen … Der Künstler an der Ecke war ein Kubist und ich habe alles spezifiziert nur nicht die Stilrichtung. Wo ich doch Caspar David Friedrich so mag.

Fortsetzung folgt…