Posts filed under ‘1’

Lernen im 4. Quartal 2009

Damit habe ich mich im 4. Quartal 2009 beschäftigt und das habe ich dabei gelernt:

  • Ich habe mir Cruise-Control Ruby angesehen und damit die Testausführung in einem Rails-Projekt automatisiert. Ich bin nicht überzeugt von dem Tool. Zu umständlich für das bisschen, was es leistet.
  • Hudson kann mehr und ist auch nicht komplizierter.
  • Ich habe weiter Rails programmiert und insbesondere mein Verständnis der DB-Migration verbessert.
  • In diesem Zusammenhang habe ich mit auch jQuery und jQuery-UI angesehen und bin davon ganz angetan.
  • Ich habe mehrere Präsentationen mit Prezi erstellt und gehalten. Das war lustig. Meiner Erfahrungen dazu hatte ich bereits in einem anderen Blog-Eintrag beschrieben.
  • Im Rahmen einer Artikelvorbereitung habe ich mich näher mit BDD beschäftigt und etwas mit easyB programmiert. Ich finde easyB echt nett, um Tests äh Spezifikationen für Groovy-Code zu schreiben.
  • Für ein Projekt habe ich Python-Skripte programmiert. Das war lustig. Nette Sprache.
  • Ich habe bei einem Kunden mehr Kanban in der Praxis erlebt und dabei ein paar interessante Einsichten gewonnen. Mehr dazu auf der OOP und in späteren Blog-Einträgen.
  • Ich habe gelernt, dass man in einer Linux-Shell Strg+R drücken kann, um in der Shell-History zu suchen. Das ist echt nützlich.
  • Ich habe das Buch “Sexy Webdesign” gelesen. Meine Einschätzung dazu hatte ich bereits in einem anderen Blog-Eintrag beschrieben.
  • Durch das Buch bin ich auf die Layouthilfe 960.gs gestoßen. Das sieht auch echt nützlich aus.
  • Ich habe etwas mit der A3-Analysetechnik aus dem Toyota-Production-System experimentiert und dabei festgestellt, dass das gar nicht so einfach ist. Aber hilfreich war es dann doch.
  • Ich habe in einem Java-Projekt etwas Jersey programmiert, um ein REST-API zu erstellen. Schön einfach. Ist man von Java ja gar nicht gewohnt :-)
  • Für die XP-Days Germany musste ich mehrere Code-Katas vorbereiten. Dabei habe ich gemerkt, wie überraschend viel man lernen kann, wenn man mehrfach hintereinander dasselbe Beispiel programmiert. Diese Erfahrung habe ich in einem anderen Blog-Eintrag beschrieben.
  • Ich habe das Buch X-Teams gelesen. Meine Einschätzung habe ich hier beschrieben.
  • Nachdem ich mir von meinem Bruder im 3. Quartal die richtige Brustschwimm-Technik habe zeigen lassen, habe ich das Brustschwimmen geübt und kann das jetzt einigermaßen (letzter Wert: 1.000 Meter am Stück). Das war am Anfang wirklich ein komisches Gefühl: Ich paddel unbeholfen zwischen den ganzen Halbprofi-Schwimmern rum und mache mich dabei mehr oder weniger lächerlich. Das hat mir ein Gefühl dafür vermittelt, wie schwer es mitunter für Schulungsteilnehmer sein muss. Man macht in einem Bereich mehr oder weniger öffentlich, dass man in diesem Bereich von Tuten und Blasen keine Ahnung hat. Das kann schon eine ganz schöbe Überwindung bedeuten.

    • Januar 14, 2010 at 9:02 nachmittags Hinterlasse einen Kommentar

Katacast: Screencast zu Code-Kata – Primfaktorzerlegung

Ich habe zusammen mit Bernd Schiffer in mehreren Iterationen an der Code-Kata zur Primfaktorzerlegung gearbeitet. Jetzt hat Bernd den dazugehörigen Screencast veröffentlicht. Die Kata selbst führt Bernd vor.

Dezember 26, 2009 at 7:04 nachmittags Hinterlasse einen Kommentar

XP-Days-Pecha-Kucha: Stop the Line in der Softwareentwicklung

Die Folien zu meinem Pecha-Kucha-Vortrag “Stop the Line in der Softwareentwicklung”, den ich auf den XP-Days Germany in Karlsruhe gehalten habe, sind jetzt online auf Slideshare.

Dezember 3, 2009 at 8:07 vormittags Hinterlasse einen Kommentar

iPhone und Ubuntu

Seit kurzem besitze ich ein iPhone und habe damit als Ubuntu-Benutzer gleich das erste Problem: Man braucht iTunes für das Aktivieren des iPhone und zur Synchronisation von Musik etc.

Zuerst habe ich versucht, iTunes unter Wine zu installieren. Die aktuelle iTunes-Version bricht aber schon bei der Installation ab. Hier steht, dass iTunes 7.X funktioniert und wo man die alte iTunes-Version herkriegt. Tatsächlich lässt sich iTunes 7.X unter Wine installieren und ausführen. Allerdings lief es bei mir so instabil, dass ich nie zum Synchronisieren gekommen bin.

Also habe ich iTunes unter Windows über Virtual-Box verwendet. Das Aktivieren funktionierte problemlos. Die erste Synchronisation schlug allerdings fehl und hinterließ das iPhone im unbenutzbaren Recovery-Zustand. Das Wiederherstellen über iTunes unter Virtual-Box hat nicht funktioniert (Fehler 1601, 1604 und 1611).

Das iPhone ließ sich aber am Mac eines Kollegen wiederherstellen und danach auch über Virtual-Box synchronisieren.

Aus meinen eigenen Beobachtungen und Hinweisen im Internet habe ich mir dazu folgenden Theorie zusammengereimt: Bei der ersten Synchronisation hat iTunes festgestellt, dass das iPhone ein Firmware-Update vertragen kann. iTunes hat das Firmware-Update auf des iPhone übertragen und dann das iPhone neu gestartet. Ich vermute, dass nach dem Neustart die Verbindung iPhone zu iTunes nicht wiederhergestellt werden konnte – und das hat wahrscheinlich irgendwas mit der Durchleitung des USB-Ports durch Ubuntu zur Virtual-Box zu tun.

Beim Wiederherstellen aus dem Recovery-Mode wird das iPhone auch neu gestartet und dasselbe Problem tritt auf.

Daraus folgt:

  1. iTunes unter Virtual-Box nicht automatisch synchronisieren lassen, so dass man jederzeit weiß, was passiert.
  2. Keine Firmware-Updates durch iTunes synchronisieren lassen.
  3. Wenn man feststellt, dass ein Firmware-Update notwendig ist, dies über einen Windows- oder Mac-Rechner erledigen. Dasselbe gilt für den Fall, dass das iPhone aus dem Recovery-Mode wiederhergestellt werden muss.
  4. Feature-Request an Apple schreiben, auch Linux zu unterstützen. Wenn es stimmt, dass Apple im Grunde Unix als Betriebssystem ist, kann das doch kein so großes Drama sein.

P.S.: Liebe Leser dieses Blogs: Ihr braucht mir nicht empfehlen einen Mac zu kaufen oder ein Android-Phone zu benutzen. Das haben inzwischen ausreichend viele Leute getan :-)

November 29, 2009 at 8:20 nachmittags Hinterlasse einen Kommentar

Ubuntu 9.10 und Flash mal wieder kaputt

Ich habe gerade von Ubuntu 9.04 auf Ubuntu 9.10 aufgedated. Das war soweit problemlos. Einige Dinge sehen etwas schicker aus. Das Starten aus dem Sleepmode ist nochmal schneller geworden.

Einziges Problem bisher: Flash läuft (mal wieder) nicht mehr. Aber mit dieser Anleitung konnte ich es dann doch schnell wieder reparieren.

November 4, 2009 at 8:33 vormittags Hinterlasse einen Kommentar

[OOP 2010] Agil auf der OOP

Die OOP Konferenz im Januar 2010 hat einiges an agilen Themen zu bieten:

Das sind insgesamt 21 Sessions zu agilen Themen – von unsgesamt knapp 130 Sessions. Das ist schon nicht schlecht, zumal es mir damit das am stärksten vertretene Einzelthema zu sein scheint. SOA hingegen scheint vollkommen tot zu sein.

Oktober 12, 2009 at 6:24 nachmittags Hinterlasse einen Kommentar

XP-Days Germany 2009

Das Programm der XP-Days Germany 2009 ist jetzt online: http://xpdays.de/2009/programm.html

Ich selbst bin am Freitag mit einem Vortrag über “Inkrementelles Design” vertreten. Da ich ein Verfechter kurzer Vorträge bin, habe ich das Thema als 30-Minuten-Vortrag eingereicht. Einige der Reviewer hatten Zweifel, ob das Thema in 30 Minuten untergebracht werden kann. Das ist gut. Ich mag Herausforderungen.

Am Donnerstag halte ich eine Pecha-Kucha-Session zum Thema “Stop the Line in der Softwareentwicklung”. Pecha-Kucha ist ein modernes Vortragsformat, in dem genau 20 Folien für jeweils genau 20 Sekunden gezeigt werden. Der ganze Vortrag dauert dann exakt 6:40 Minuten. Bei der JAX 2009 haben wir das bereits einmal ausprobiert. Naja, ok: Ich habe ausprobieren lassen und mich auf die Organisation beschränkt. Auf den XP-Days muss ich jetzt selbst zeigen, ob ich das Format gut ausgefüllt bekomme.

Auf der JAX 2009 hatte mein Kollege Bernd Schiffer einen Pecha-Kucha-Vortrag über “Inkrementelles Design” gehalten, der jetzt auch als Video verfügbar ist. Für alle, die bei den XP-Days (oder der W-JAX oder sonstwo) einen Pecha-Kucha-Vortrag halten, ist das Video sicher eine ganz gute Inspiration und es zeigt auch, dass 20 Sekunden je Folie manchmal ziemlich lang sein kann :-)

August 21, 2009 at 7:46 vormittags Hinterlasse einen Kommentar

Verantwortung in der Praxis

Bernd Schiffer hat ein interessantes Foto geschossen:

http://twitpic.com/bmajr

Da ist also eine Fahrtreppe der Deutschen Bahn außer Betrieb. Als Grund wird angegeben, dass der namentlich genannte Lieferant nicht rechtzeitig geliefert habe.

Diese Aktion der Deutschen Bahn finde ich seltsam. Ich habe den Eindruck, die Bahn will damit die Verantwortung für die nicht-funktionierende Fahrtreppe auf den Lieferanten abwälzen. Allerdings kaufe ich mein Ticket ja bei der Deutschen Bahn und nicht bei deren Lieferanten. Und wenn die Lieferanten nicht funktionieren, liegt die Verantwortung letztlich auch bei der Deutschen Bahn. Diese hat ja schließlich die Lieferanten ausgewählt.

Die ganze Geschichte ist aber keineswegs einmalig, sondern sehr häufig anzutreffen. Wenn Teams mit Scrum beginnen, zeigen sie im ersten Sprint-Review häufig ähnliche Verhaltensweisen: “Ja, wir haben unser Commitment nicht gehalten. Das ist aber nicht unsere Verantwortung. Das liegt nur daran, dass der Datenbank-Administrator unsere Tabellen nicht reichtzeitig angelegt hat.” Und dann sprechen wir über Verantwortung und Commitment. Auch wenn ich von jemand anderem abhängig bin, ändert das nichts an meiner Verantwortung, die ich mit dem Commitment eingegangen bin. Entweder muss ich herausfinden, wie ich mein Commitment trotzdem halten kann oder ich darf kein Commitment abgeben.

Juli 26, 2009 at 6:26 nachmittags 3 Kommentare

BDD for Prolog

During my experiments with Prolog I needed a test framework. I startet with the unit test framework written by Ken Egozi. Over time I tried to migrate it to a more BDD like style. I named the result “ProSpec”. Here is the code (Open-Source-License):

it(Spec_Desc/Spec):-
    current_fixture(Fixture),
    retractall(spec_def(Fixture/Spec_Desc/Spec)),
    assert(spec_def(Fixture/Spec_Desc/Spec)). 
 
describe(Fixture) :-
    retractall(spec_def(Fixture/_/_)),
    assert(current_fixture(Fixture)). 
 
end_describe:-
    retractall(current_fixture(_)). 
 
run_one_spec(Pred/Name) :-
	spec_def(Pred/Name/Spec),
	setup_spec,
	call(Spec).

run_specs :-
    dynamic(setup_spec/0),
    dynamic(specs_stats/2),
    write('Run Specs '), nl,
    bagof(Fixture/Specs, bagof((Spec_Desc/Spec), spec_def(Fixture/Spec_Desc/Spec), Specs), SpecsPerPredicate),
    run_specs(SpecsPerPredicate, Passed/Failed),
    write_specs_summary(Passed/Failed). 
 
run_specs(SpecsSpecsPerPredicate, TotalPassed/TotalFailed) :-
    run_specs(SpecsSpecsPerPredicate, 0/0, TotalPassed/TotalFailed). 
 
run_specs([], Passed/Failed, Passed/Failed):-!. 

run_specs([Fixture/Specs|Rest], Passed/Failed, TotalPassed/TotalFailed):-
    nl, write(Fixture), write('...'), nl,
    foreach_spec(Specs, PassedInPredicate/FailedInPredicate),
    write('Passed:'), write(PassedInPredicate),
    (FailedInPredicate > 0, write(' Failed:'), write(FailedInPredicate) ; true),
    nl,
    Passed1 is Passed + PassedInPredicate,
    Failed1 is Failed + FailedInPredicate,
    run_specs(Rest, Passed1/Failed1, TotalPassed/TotalFailed). 
 
foreach_spec(Specs, Passed/Failed):-
    foreach_spec(Specs, 0/0, Passed/Failed). 
 
foreach_spec([], Passed/Failed, Passed/Failed):-!. 
foreach_spec([Spec_Desc/Spec|Rest], Passed/Failed, NewPassed/NewFailed):-
    (
	setup_spec, call(Spec), !,
        NextPassed is Passed + 1,
        NextFailed is Failed,
        write('...'), write(Spec_Desc), write(' (passed)'), nl
    ;
        NextFailed is Failed + 1,
        NextPassed is Passed,
        write('...'), write(Spec_Desc), write(' (FAILED)'), nl
    ),
    foreach_spec(Rest, NextPassed/NextFailed, NewPassed/NewFailed). 
 
write_specs_summary(Passed/0) :- !,
    nl,
    write(Passed), write(' specs passed'),
    nl. 
write_specs_summary(Passed/Failed) :-
    nl,
    write(Passed), write(' specs passed,'), nl,
    write(Failed), write(' specs failed'),
    nl. 
 
reset_all_specs:-
    retractall(spec_def(_/_/_)).

run_spec(Spec) :-
    call(Spec),!,
    specs_passed(X),
    retract(specs_passed(X)),
    NewX is X + 1,
    assert(specs_passed(NewX)).
run_spec(Spec) :-
    failing_specs(X),
    retract(failing_specs(X)),
    NewX = [Spec|X],
    assert(failing_specs(NewX)).

% Asserts
assert_that(Actual, equals:Expected) :-
	Actual \= Expected, nl, write('Expected '), write(Expected), write(' equal to '), write(Actual), nl, fail;
	Actual == Expected.

assert_that(Actual, not_equals:Expected) :-
	Actual == Expected, nl, write('Expected '), write(Expected), write(' not equal to '), write(Actual), nl, fail;
	Actual \= Expected.
	
assert_that(Actual, is_true) :-
	Actual;
	nl, write('Expected '), write(Actual), write(' to be true '), nl, fail.
	
assert_that(Actual, is_false) :-
	Actual, !, nl, write('Expected '), write(Actual), write(' to be false '), nl, fail;
	true.
	
assert_that(Actual, fails) :- 
	assert_that(Actual, is_false).
	
assert_that(Actual, is_empty) :-
	Actual \= [], nl, write('Expected '), write(Actual), write(' to be empty '), nl, fail;
	Actual == [].

assert_that(Actual, has_member:Member) :-
	not(member(Member, Actual)), nl, write('Expected '), write(Actual), write(' to has member '), write(Member), nl, fail;
	member(Member, Actual).

assert_that(Actual, has_no_member:Member) :-
	member(Member, Actual), nl, write('Expected '), write(Actual), write(' to has no member '), write(Member), nl, fail;
	not(member(Member, Actual)).

assert_that(Actual, contains_all:Sublist) :-
	not(contains_all(Actual, Sublist)), nl, write('Expected '), write(Actual), write(' to contain all members of '), write(Sublist), nl, fail;
	contains_all(Actual, Sublist).

contains_all(_, []) :- true.
contains_all(List, [Member]) :- member(Member, List).
contains_all(List, [Member|Rest]) :- member(Member, List), contains_all(List, Rest).

The whole ProSpec can be downloaded from github.

Juli 21, 2009 at 7:38 nachmittags 1 Kommentar

Prolog-Grundzüge 8: Datenbasis

In den vorigen Blogposts haben wir Fakten, Regeln, das Prolog-System, Pattern-Matching, Rekursion, Fail und den Cut-Operator betrachtet. Damit haben wir die grundlegenden Dinge beisammen, um Prolog-Programme zu schreiben. Jedenfalls fast. Wir müssen noch ein paar Dinge über die Prolog-Datenbank für Fakten und Regeln lernen. Wir können die Datenbasis nämlich zur Programmlaufzeit dynamisch verändern!

Mit assert können wir Fakten und Regeln zur Laufzeit hinzufügen.

assert(benutzer(levi)).

fügt den neuen Fakt “Levi ist ein Benutzer” zur Datenbasis hinzu.

Mit “asserta” wird an den Anfang und mit “assertz” ans Ende der Datenbasis hinzugefügt.

Den Effekt kann man mit “listing” überprüfen:

listing.

listet alle Fakten und Regeln der Datenbasis auf.

Mit “retractall” werden alle Fakten/Regeln aus der Datenbasis entfernt, die zum angegebenen Fakt/Regel passt.

retractall(benutzer(_)).

Anmerkung: Der Unterstrich ist übrigens eine anonyme Variable, die man immer dann einsetzt, wenn man an dem konkreten Wert der Variablen nicht interessiert ist.

Und nicht zuletzt kann man mit “findall” Regeln und Fakten in der Datenbasis suchen:

findall(Benutzer, benutzer(_), BenutzerListe).

liefert alle Regeln namens “benutzer” mit einem Parameter.

Juli 21, 2009 at 6:12 nachmittags Hinterlasse einen Kommentar

Ältere Artikel


Blog abonnieren
Follow

Bekomme jeden neuen Artikel in deinen Posteingang.

Schließe dich 172 Followern an