Technische Schulden verfolgen mit NDepend 2017.2

NDepend nutzte ich mittlerweile häufig zur Analyse meiner Anwendungen. Die statische Codeanalyse liefert zwar kein vollständiges Bild zum Zustand einer Anwendung, aber man erhält genügend Informationen um Probleme frühzeitig zu erkennen. Die früheren Versionen hatte ich bereits hier und hier beschrieben.
Technische Schulden verfolgen mit NDepend 2017.2 weiterlesen

Advertisements

Github Gist: Code-Schnipsel einfach veröffentlichen

Mir fehlte es für lange Zeit an einer guten und einfachen Möglichkeit um Code-Schnipsel öffentlich zu machen. Für ganze Projekte finde ich die Kombination von Mercurial und Bitbucket sehr gut. Aber um eine einzelne Datei oder gar nur eine Methode publizieren zu können ist diese Lösung zu aufwändig.

Vor kurzem bin ich beim durchstöbern von Github auf Gist gestossen. Über eine sehr einfache Weboberfläche kann man die Schnipsel mit einem Namen versehen und veröffentlichen. Wenn man will kann man noch die Sprache wählen, womit dann auch die Syntaxhervorhebung stimmt.

Um Gist zu nutzen braucht man nur einen Account bei Github. Man muss weder Git installiert haben noch gross darüber Bescheid wissen. Wenn man später einmal ein „richtiges“ Projekt daraus machen möchte steht dem nichts im Weg: Ein Gist ist ein vollwertiges Git-Repository und verfügt damit von Anfang an über eine Historisierung.

Ich finde Gist eine sehr gute Idee und bin gespannt was sich dadurch alles für Möglichkeiten eröffnen.

Buch-Rezension zu „Ruby in Practice“

Ruby in Practice“ von Jeremy McAnally und Assaf Arkin erschien im Mai 2009 bei Manning. Das selbstdefinierte Ziel des Buches ist es aus dem Leser einen produktiveren (Ruby-) Programmierer zu machen. In wie weit die Autoren dieses Ziel erreichen können hängt wohl primär vom Leser ab. Unbestritten ist aber die grosse Anzahl verschiedenster Tipps und Tricks die die Arbeit mit Ruby deutlich vereinfachen.

 
 

 

Teil 1: Ruby Techniken

Der erste Teil geht auf die grundlegenden Spracheigenschaften von Ruby ein. Diese kleine Repetition soll einem in Erinnerung rufen was Ruby eigentlich ausmacht. Es geht dabei aber nicht um eine Erklärung für Einsteiger. Es ist vielmehr ein Aufzeigen was man für Möglichkeiten bekommt weil Ruby so funktioniert wie es funktioniert.

Auch das Kapitel übers Testen beinhaltet nichts Revolutionäres. Es wird in einem kurzen Rundgang die einzelnen Ansätze gezeigt die einem zur Verfügung stehen. Dazu gehören neben Unit Tests auch Test Driven Development und Behavior Driven Development so wie eine ganze Packung an Werkzeugen (wie RSpec, Mocha oder rcov). Auch hier liegt der Schwerpunkt beim Aufzeigen der Möglichkeiten und nicht bei einem tiefgehenden Einführungskurs.

Im Kapitel „Scripting with Ruby“ beginnt das Buch auf die praktischen Anwendungsfälle detailliert einzugehen. Als erstes Problem gilt es eine aus diesen Teilen bestehende Aufgabe zu lösen:

  1. Verkleinern der hochauflösenden Ferienfotos
  2. Fotos mit einem Polaroid Effekt versehen
  3. Fotos in die Cloud von Amazon hochladen
  4. jede Stunde auf Twitter ein Foto veröffentlichen

Die einzelnen Teile sind einfach genug um sie zu erklären und zusammen komplex genug um viele Tipps und Tricks aufzeigen zu können. Das Auslagern von Benutzernamen und Passwort in eine eigene Konfigurationsdatei ist einer dieser simplen aber äusserst hilfreichen Tricks.

 

Teil 2: Integration und Kommunikation

Im 2. Teil drehen sich die Beispiele um die Integration von Drittsystemen. Sei dies in dem man Ruby on Rails Anwendungen erweitert, Webservices konsumiert oder E-Mails nutzt um Systeme neu zu starten.

Die Beispiele sind immer nach dem gleichen Muster aufgebaut:

  • Beschreibung der Situation und was genau das Problem ist
  • Erarbeiten einer einfachen und pragmatischen Lösung
  • Diskutieren von alternative Lösungen und Ansätzen

Die Diskussion von Alternativen fand ich persönlich sehr gut. Nicht nur zu wissen wie man es auf eine Art machen kann sondern auch zu erfahren was sonst noch möglich ist finde ich äusserst hilfreich.

 

Teil 3: Daten und Dokumente

Der letzte Teil zeigt wie man Daten speichern und Dokumente verarbeiten kann. Als Datenquelle kann dabei von einer Datenbank bis zu XML- oder YAML-Dateien alles dienen. Zahlreiche Beispiele zeigen die verschiedenen Ansätze auf und in der Diskussion werden wiederum die Vor- und Nachteile eingehend betrachtet.

In diesem Teil wird ebenfalls die Identifizierung und Autorisierung von Benutzern behandelt. Dabei wird besonders Wert darauf gelegt das man Passwörter nicht im Klartext speichert. Es braucht nur wenigen Zeilen zusätzlichen Code und Rails speichert nur noch den Passwort-Hash (jeder mit individuellem Salt) ab. Dies ist ein ganz einfacher Tipp mit dem man die Passwörter effektiv schützen kann.

 

Aktualisierung willkommen

Die Programmiersprache Ruby entwickelt sich sehr schnell, gleiches gilt für die Werkzeuge und Bibliotheken rund herum. Einige der Beispiele funktionieren mit der aktuellen Ruby Version nicht mehr und andere sind nur mit grossem Aufwand zum Laufen zu bekommen. Eine Aktualisierung des Buches könnte diese Probleme beheben und auch auf die aktuellen Tools eingehen.

 

Fazit

„Ruby in Practice“ ist ein Buch mit sehr vielen praktischen Beispielen. Die behandelten Themen werden so erklärt dass man das dort gewonnene Wissen auch bei anderen Problemstellungen wiederverwenden kann. Gerade die Diskussion der gewählten Lösung und möglicher Alternativen macht aus dem Buch weit mehr als eine Rezeptsammlung. Wenn es auch nicht mehr ganz aktuell ist so gibt das Buch doch sehr viele Ideen um Probleme aus einer anderen Richtung anzugehen.

 

Zum Buch

Ruby in Practice“ Jeremy McAnally and Assaf Arkin, 2009 Manning, ISBN 978-1-93398-847-4, 360 Seiten, Englisch

Prolog: Kleine Unterschiede, grosse Wirkung

Beim Durcharbeiten der „Hausaufgaben“ von „Sieben Wochen, sieben Sprachen“ hatte ich beim Kapitel zu Prolog einige Schwierigkeiten zu lösen. Da ich mich sonst nicht mit Prolog beschäftige dauerte es recht lange bis ich meinen Fehler finden konnte. Auch wenn ich diesen Blog-Eintrag primär als Gedankenstütze für mich selber schreibe, so würde es mich freuen wenn andere Prolog-Neulinge auch davon profitieren könnten.

 

Die Aufgabe


An sich war die Hausaufgabe recht einfach: Die vorgegebene Lösung für ein 4×4 Sudoku muss so erweitert werden damit man ein reguläres 9×9 Sudoku lösen kann. Neben dem grösseren gültigen Zahlenbereich mussten vor allem mehr Spalten, mehr Zeilen und mehr Blöcke eingefügt werden.

Mein (fehlerhaftes) Resultat sah so aus:

valid([]).
valid([Head|Tail]) :-
        fd_all_different(Head),
        valid(Tail).

sudoku(Puzzle, Solution) :-
        Solution = Puzzle,


        Puzzle = [S11, S12, S13, S14, S15, S16, S17, S18, S19,
                  S21, S22, S23, S24, S25, S26, S27, S28, S29,
                  S31, S32, S33, S34, S35, S36, S37, S38, S39,
                  S41, S42, S43, S44, S45, S46, S47, S48, S49,
                  S51, S52, S53, S54, S55, S56, S57, S58, S59,
                  S61, S62, S63, S64, S65, S66, S67, S68, S69,
                  S71, S72, S73, S74, S75, S76, S77, S78, S79,
                  S81, S82, S83, S84, S85, S86, S87, S88, S89,
                  S91, S92, S93, S94, S95, S96, S97, S98, S99],

        fd_domain(Solution, 1, 9),

        Row1 = [S11, S12, S13, S14, S15, S16, S17, S18, S19],
        Row2 = [S21, S22, S23, S24, S25, S26, S27, S28, S29].
        Row3 = [S31, S32, S33, S34, S35, S36, S37, S38, S39],
        Row4 = [S41, S42, S43, S44, S45, S46, S47, S48, S49],
        Row5 = [S51, S52, S53, S54, S55, S56, S57, S58, S59],
        Row6 = [S61, S62, S63, S64, S65, S66, S67, S68, S69],
        Row7 = [S71, S72, S73, S74, S75, S76, S77, S78, S79],
        Row8 = [S81, S82, S83, S84, S85, S86, S87, S88, S89],
        Row9 = [S91, S92, S93, S94, S95, S96, S97, S98, S99],

        Col1 = [S11, S21, S31, S41, S51, S61, S71, S81, S91],
        Col2 = [S12, S22, S32, S42, S52, S62, S72, S82, S92],
        Col3 = [S13, S23, S33, S43, S53, S63, S73, S83, S93],
        Col4 = [S14, S24, S34, S44, S54, S64, S74, S84, S94],
        Col5 = [S15, S25, S35, S45, S55, S65, S75, S85, S95],
        Col6 = [S16, S26, S36, S46, S56, S66, S76, S86, S96],
        Col7 = [S17, S27, S37, S47, S57, S67, S77, S87, S97],
        Col8 = [S18, S28, S38, S48, S58, S68, S78, S88, S98],
        Col9 = [S19, S29, S39, S49, S59, S69, S79, S89, S99],

        Square1 = [S11, S21, S31, S12, S22, S32, S13, S23, S33],
        Square2 = [S41, S51, S61, S42, S52, S62, S43, S53, S63],
        Square3 = [S71, S81, S91, S72, S82, S92, S73, S83, S93],
        Square4 = [S14, S24, S34, S15, S25, S35, S16, S26, S36],
        Square5 = [S44, S54, S64, S45, S55, S65, S46, S56, S66],
        Square6 = [S74, S84, S94, S75, S85, S95, S76, S86, S96],
        Square7 = [S17, S27, S37, S18, S28, S38, S19, S29, S39],
        Square8 = [S47, S57, S67, S48, S58, S68, S49, S59, S69],
        Square9 = [S77, S87, S97, S78, S88, S98, S79, S89, S99],

        valid([Row1, Row2, Row3, Row4, Row5, Row6, Row7, Row8, Row9,
                Col1, Col2, Col3, Col4, Col5, Col6, Col7, Col8, Col9,
                Square1, Square2, Square3, Square4, Square5, Square6, 
                Square7, Square8, Square9]),

        write( '\n' ), write( Row1 ),
        write( '\n' ), write( Row2 ),
        write( '\n' ), write( Row3 ),
        write( '\n' ), write( Row4 ),
        write( '\n' ), write( Row5 ),
        write( '\n' ), write( Row6 ),
        write( '\n' ), write( Row7 ),
        write( '\n' ), write( Row8 ),
        write( '\n' ), write( Row9 ).

 

Kompilierfehler


Als Arbeitsumgebung nutze ich meinen Linux-PC mit Ubuntu 11.4 und GNU Prolog 1.3.0. Nach dem Start von gprolog gab es beim Laden der Datei diese Fehlermeldung:

jgr@R:~/BLOG/$ gprolog
GNU Prolog 1.3.0
By Daniel Diaz
Copyright (C) 1999-2007 Daniel Diaz
| ?- ['sudoku.pl'].
compiling /home/jgr/BLOG/sudoku.pl for byte code...
/home/jgr/BLOG/sudoku.pl:6-23: warning: singleton variables [S31,S32,S33,S34,S35,S36,S37,S38,S39,S41,S42,S43,S44,S45,S46,S47,S48, S49,S51,S52,S53,S54,S55,S56,S57,S58,S59,S61,S62,S63,S64,S65,S66,S67, S68,S69,S71,S72,S73,S74,S75,S76,S77,S78,S79,S81,S82,S83,S84,S85,S86, S87,S88,S89,S91,S92,S93,S94,S95,S96,S97,S98,S99,Row1,Row2] for sudoku/2
/home/jgr/BLOG/sudoku.pl:24-64: warning: suspicious predicate (',')/2
/home/jgr/BLOG/sudoku.pl compiled, 64 lines read - 22767 bytes written, 187 ms

yes
| ?- 

Wer wie ich vor allem in C# entwickelt wird beim ersten Zusammentreffen mit so einer Fehlermeldung wenig anfangen können. Es stehen aber alle nötigen Informationen drin – nur muss man diese erst einmal „entschlüsseln“.

 

sudoku.pl:6-23: warning: singleton variables [S31,S32,S33,…] for sudoku/2

 
Laut dieser Fehlermeldung verwendet die Regel sudoku (mit 2 Parametern) die Variablen S31, S32, usw. nur 1 einziges Mal. Schaue ich den Inhalt meiner sudoku-Regel an, sollten diese Variablen aber alle mehrmals verwendet werden.

Auch die Zeilennummern erscheinen auf den ersten Blick nutzlos. Weder in Zeile 6 noch in Zeile 23 sehe ich etwas was nach einem Fehler aussieht. Meldet Visual Studio „; expected Line 97 Column 76“ weis ich das ein „;“ in Zeile 97 fehlt. Prolog ist ein wenig anders.

Die Fehlermeldung kann man aber auch so übersetzen:
„In der Regel sudoku mit 2 Parametern, die zwischen Zeile 6 und 23 definiert ist, werden die Variablen S32, … nur 1 Mal verwendet.“

Für den Interpreter ist meine Regel zwischen den Zeilen 6 und 23 definiert. Für mich müsste diese aber bis zu Zeile 64 gehen – und hier liegt die Ursache der Fehlermeldung. Prolog nutzt einen Punkt um einzelne Fakten und Regeln zu trennen. Schaut man meinen Regelsatz noch einmal genau an findet man auf Zeile 22 am Ende der Definition von Row2 auch ein Punkt statt einem Komma.
Dieser „kleine“ Unterschied hat aber grosse Wirkung. Sind die Regelsätze unvollständig wird Prolog damit kein Sudoku lösen können. Macht man trotzdem weiter sind die Folgefehler kaum mehr zu durchschauen.

Nachdem ich den Punkt durch ein Komma ersetzt hatte liessen sich meine Regeln fehlerfrei laden:

| ?- ['sudoku.pl'].
compiling /home/jgr/BLOG/sudoku.pl for byte code...
/home/jgr/BLOG/sudoku.pl compiled, 64 lines read - 19963 bytes written, 13 ms

yes
| ?- 

Um ein Sudoku zu lösen genügt es nun die bekannten Zahlen sowie ein _ für alle offenen Felder einzugeben. Prolog löst das Rätsel im Handumdrehen – oder noch schneller:

| ?- sudoku([_, _, _, 2, 4, _, 8, _, _,
             _, _, 2, 3, _, _, _, 6, _,
             _, _, _, 7, _, _, 9, 3, _,
             _, _, _, _, 9, _, _, _, 1,
             _, 9, _, 1, 2, 4, _, _, 3,
             _, _, 1, _, _, _, _, _, _,
             3, _, _, _, _, 8, _, 1, _,
             _, 8, 6, 4, 1, _, _, 5, _, 
             _, 7, 4, _, _, 5, _, _, _], Solution).

[6,3,9,2,4,1,8,7,5]
[7,5,2,3,8,9,1,6,4]
[4,1,8,7,5,6,9,3,2]
[2,6,3,8,9,7,5,4,1]
[5,9,7,1,2,4,6,8,3]
[8,4,1,5,6,3,7,2,9]
[3,2,5,9,7,8,4,1,6]
[9,8,6,4,1,2,3,5,7]
[1,7,4,6,3,5,2,9,8]

 

Tipps für die Problemlösung


Zum Abschluss möchte ich 2 Punkte herauspicken die ich im Nachhinein als besonders wichtig erachte:

  1. Im Fehlerfall immer erst den 1. Fehler beheben. Viele Folgefehler werden damit auch gleich beseitigt.
  2. Für Sprachen wie Prolog muss der Texteditor oder die Konsole unbedingt eine Schrift verwenden die Punkte und Kommas deutlich differenziert. (Monospace ist dafür nicht geeignet)

 

Fazit


So richtig spannend wird es erst wenn man vor Probleme gestellt wird. Eine ganz einfache uns simple Aufgabe (eine Lösung von 4×4 auf 9×9 erweitern) verwandelte sich in eine veritable Herausforderung. Wenn man die Antwort kennt ist es banal. Muss man sich aber durch die Fehlermeldungen und unzählige falsche Ansätze kämpfen beginnt erst das eigentliche lernen.

Auch kleine Aufgaben können einem viel beibringen.

Buch-Rezension zu “Programming Entity Framework“

Programming Entity Framework“ von Julia Lerman erschien im August 2010 in der 2. Ausgabe bei O’Reilly. Diese Ausgabe wurde für Entity Framework 4 komplett überarbeitet. Will man mit EF 4 arbeiten sollte man also unbedingt schauen das man diese Ausgabe kauft.

 

Ich bin jeweils ein wenig skeptisch wenn ich ein Buch mit über 700 Seiten sehe. Zu oft reicht das Wissen der Autoren nur für rund 500 Seiten und der Rest ist dann eine mehr oder weniger gekonnte Wiederholung. Dies ist hier aber definitiv nicht der Fall!

Julia Lerman gilt zu Recht als DIE Expertin zu Entity Framework ausserhalb von Microsoft. Die Teile zu EF sind sehr fundiert und liefern auch einen sehr guten Einblick in die Entstehungsgeschichte des neusten OR-Mappers von Microsoft.

 
Mehr als nur Entity Framework
Das Buch behandelt alle Teile die man zum Verstehen von Entity Framework braucht. Es beginnt mit dem Entity Data Model und den Abfragemöglichkeiten mit LINQ to Entities oder Entity SQL. Es folgen Tipps und Trick wie man mit dem EDM Designer arbeitet und wo man ihn umgehen muss. Ob man Self-Tracking Entities oder POCOs nutzen will, man findet für beide Ansätze ausführliche Anleitungen. Kapitel zu Transaktionen oder dem Mappen von Stored Procedures fehlen ebenso wenig wie die Einbindung von realitätsnahen (und damit komplexen) DB-Schemas in Entity Framework. Das Buch lässt diesbezüglich keine Wünsche offen.

Am meisten beeindruckte mich aber wie der konkrete Einsatz von EF erklärt wird. Ob man Windows Forms, WPF, WCF oder ASP.Net nutzt – für alle diese Technologien gibt es mindestens ein Kapitel das einem zeigt worauf man achten muss. Man ist so in der Lage EF in seinem eigenen Projekt zu nutzen ohne noch viele zusätzliche Informationen suchen zu müssen.

Mit seinem Umfang an Informationen ist „Programming Entity Framework“ auch sehr gut als Nachschlagewerk geeignet. Ein ausführlicher und gut gepflegter Index hilft beim Finden der passenden Stelle.

 
Kleine Kritikpunkte
Es gibt aber auch bei dem Buch noch einige wenige Verbesserungsmöglichkeiten. Die meisten Bilder im Kapitel 14 sind um 1-2 Nummern verschoben. Dies stört beim Lesen doch recht stark, da man vergeblich versucht das gerade erklärte auf dem Bild zu finden. Auch die Strukturierung könnte man bei einer 3. Ausgabe wohl noch ein wenig optimieren. Etliche der Verweise auf eine spätere Erklärung des Themas würden so entfallen.

 
Fazit
Wer sich mit Entity Framework beschäftigen will sollte sich dieses Buch unbedingt kaufen. Vor allem die Kapitel die auf die Nutzung von EF mit den einzelnen Microsoft Technologien (wie WPF, WCF, Windows Forms oder ASP.Net) eingehen sind eine sehr grosse Hilfe bei der täglichen Arbeit.

 
Zum Buch
Programming Entity Framework“ von Julia Lerman, 2010 O’Reilly, ISBN 978-0-596-80726-9, 912 Seiten, Englisch

Buch-Rezension zu „Professional WCF 4“

Professional WCF 4: Windows Communication Foundation with .NET 4“ von Pablo Cibraro, Kurt Claeys, Fabio Cozzolino und Johann Grabner erschien im Juni 2010 bei Wrox. Die Autoren sind Experten in WCF und lieferten ein Buch mit dem man den Einstieg in WCF wagen kann.

 

Um dem Buch folgen zu können sollte man sich mit C# auskennen. Man muss kein Experte sein, aber man sollte die Grundlagen kennen. Für WCF braucht man kein Vorwissen, da das Buch einem mit allen notwendigen Informationen versorgt.

Neben den Standard-Themen wie Data- und ServiceContracts, Bindings und Security geht das Buch auch auf spezielleres wie Workflows und Windows Azure ein. Zahlreiche Bilder helfen beim Verstehen der einzelnen Schritte und Konzepte. Die einzelnen Kapitel bauen aufeinander auf und sind gut strukturiert.

 
Detaillierte und praxisrelevante Beispiele
Neben den über das ganze Buch verteilten kleinen Beispielen widmen sich 3 ganze Kapitel ausführlichen Szenarien. Diese Anwendungen sind äusserst hilfreich um das Zusammenspiel der einzelnen Teile zu verstehen. Man hat damit eine funktionierende Grundlage die man für die eigenen Experimente problemlos ausbauen kann.

Man sollte sich aber davor hüten produktiven Code nach dem im Buch vorgegebenen Muster zu strukturieren. In eine Datei ICarManagement.cs gehört nur das Interface, nicht noch die DataContracts zur Klasse Car und alle von Car abgeleiteten Klassen. Sobald die Anwendung komplexer wird findet man sich so nicht mehr zurecht. Wie immer gilt auch hier: Nicht blind alles nachmachen.

Trotz dieser Einschränkung finde ich die Beispiele äusserst gelungen.

 
Grammatik: grosses Verbesserungspotential
Bei Amazon gibt es etliche Reviews mit teils haarsträubenden Beispielen für missglückte Formulierungen. Diese lassen sich zum Teil damit erklären, das Englisch nicht die Muttersprache der Autoren ist. Man muss aber leider auch Wrox kritisieren. Beim Editieren hätten nicht so viele Fehler durchschlüpfen dürfen. Es scheint als ob es einen gewaltigen Druck zur Veröffentlichung gegeben hat. Für eine 2. Auflage müsste deutlich mehr in die Qualität investiert werden. Erstaunlicherweise ist das Errata aber bisher leer. Kommt man nicht nach oder haben die Leser erst gar nicht versucht die Fehler zu melden?

 
Fazit
Wer über die grammatikalischen Verfehlungen hinweg sehen kann bekommt mit diesem Buch eine gute Einführung in WCF. Die Autoren kennen sich zweifelsfrei mit dem Thema aus und können dieses Wissen auch weitergeben.

Ich empfehle aber jedem vor dem Kauf einen Blick ins Buch zu werfen und für sich selber zu entscheiden, ob er mit der Sprache zurechtkommt.

 
Zum Buch
Professional WCF 4: Windows Communication Foundation with .NET 4“ von Pablo Cibraro, Kurt Claeys, Fabio Cozzolino und Johann Grabner, 2010 Wrox, ISBN 978-0-470-56314-4, 480 Seiten, Englisch

Buch-Rezension zu „Building Enterprise Applications with WPF and the MVVM Pattern“

Building Enterprise Applications with Windows Presentation Foundation and the Model View ViewModel Pattern“ von Raffaele Garofolo erschien im März 2011 bei Microsoft Press. Das MVVM Pattern ist für Silverlight und WPF Anwendungen schon fast ein Muss. Für den geringen Betrag von 15$ bekommt man ein gutes Buch zu MVVM.

 

Das Buch startet wie zu erwarten mit einer Einführung ins Model View ViewModel Pattern und dessen Abgrenzung gegenüber den sonstigen UI Patterns wie MVC oder MVP. Mit diesen Grundlagen ist man gerüstet um die einzelnen Schichten einer Anwendung anzuschauen. Vom Domänenmodell geht es über den Data Access Layer durch die Geschäftslogik zur Oberfläche der Anwendung.

Als Abschluss bietet das Buch eine kurze Übersicht zu MVVM Frameworks und Toolkits wie Caliburn, Prism, MVVM Light Toolkit oder Cinch.

Am Ende jedes Kapitels findet man ein grösseres Beispiel in dem die gerade beschriebenen Punkte zu einem realistischen Szenario verbunden werden. Dies sollte man unbedingt anschauen, da der Text im Kapitel selber wohl nicht jedem genügen wird.

 
Klein, aber fein?
Das Buch ist mit nur 224 Seiten recht dünn, behandelt aber dennoch eine grosse Anzahl von Themen. So kann vieles nur angeschnitten werden, für eine Vertiefung fehlt es an Platz. Wer hier eine detaillierte Einführung in Caliburn erwartet muss zwangsläufig enttäuscht werden.

Es gibt aber Themen wie das Repository- oder das Unit of Work Pattern, die mit ausreichendem Tiefgang beschreiben werden. Der Mehrwert dieses Buches liegt für mich beim kombinieren der einzelnen Themen und Ansätze zu einem Gesamtbild.

Im Grossen und Ganzen hätte der Verzicht aufs eine oder andere Toolkit oder Framework dem Buch wohl mehr Profil gegeben. Jetzt wird zwar jeder angesprochen, doch wer eine Empfehlung für ein spezifisches Produkt sucht wird enttäuscht.

 
Test-Driven
Garofolo legt sehr viel Wert auf die Testbarkeit der vorgestellten Ansätze. So findet man neben einer minimalen Einführung in Test Driven Development über das ganze Buch verteilt immer wiederkehrende Beispiele wie man in dieser Situation nun genau den Code testen kann. Diese Hilfestellung fand ich sehr gut und ich wünschte mir, dass mehr Autoren so viel Wert auf die Testbarkeit legen würden.

 
Downloads
Beim Link zu den Code-Beispielen gab es scheinbar einige Probleme. Der Source Code finden sich auf http://examples.oreilly.com/9780735650923-files/9780735650923_files.zip. Man könnte für die Zukunft noch die ReSharper-Dateien und Binaries weglassen, wodurch das Zip deutlich kleiner würde.

 
Fazit
Wer eine kurze und günstige Einführung ins MVVM Pattern sucht wird in diesem Buch das gewünschte finden. Man muss sich aber mit WPF oder Silverlight auskennen, denn dies ist keine Einführung in diese Technologien.

 
Zum Buch
Building Enterprise Applications with Windows Presentation Foundation and the Model View ViewModel Pattern“ von Raffaele Garofolo, 2011 Microsoft Press, ISBN Print 978-0-7356-5092-3, ISBN E-Book 978-0-7356-4982-8, 224 Seiten, Englisch