5 Podcasts für Software-Entwickler

Podcasts sind für mich ein sehr angenehmes Format um mich auf dem Laufenden zu halten. Alles was es braucht ist eine Mobiltelefon und eine vernünftige App die Podcasts verwalten kann. Und natürlich die passenden Podcasts. Heute möchte ich 5 Podcasts vorstellen die ich regelmässig höre und ich für Software-Entwickler empfehlen kann.

Mir gefällt an diesen Podcasts vor allem der regelmässige Blick über den Tellerrand. Sich nicht nur auf ein spezifisches Thema oder eine Technologie zu limitieren macht angesichts der kurzen Halbwertszeit von Frameworks und Toolkits Sinn. So bleiben viele der besprochenen Themen auch dann noch relevant wenn wir schon den nächsten Hype vor uns haben.

 

Ruby Rogues

Ruby Rogues ist eine wöchentliche Diskussionsrunde die sich vorwiegend um Ruby dreht. Hat man sich einmal an das wilde Durcheinander gewöhnt schätzt man sehr bald den grossen Themenmix und das fundierte Wissen der Moderatoren.

Neben dem Book Club gefallen mir besonders die Episoden bei denen es um allgemeine Themen wie dem Lernen oder Software-Qualität geht. Hier kommen aus meiner Sicht die unterschiedlichen Erfahrungen der Rogues besonders gut hervor und ermöglichen sehr spannende Diskussionen.

Ein grosses Plus für diesen Podcast sind die Abschriften die es für jede Folge gibt. Damit kann man auch später einzelne Themen oder Links einfach finden ohne sich die genaue Folge merken zu müssen.

 

Hanselminutes

Scott Hanselman dürfte den meisten .Net Entwicklern durch seine Präsentationen rund um ASP.net bekannt sein. Sein Podcast Hanselminutes ist glücklicherweise keine Microsoft-Werbeveranstaltung sondern behandelt die Themen die ihn persönlich interessieren.

Jede Woche bespricht Scott mit einem Gast in rund 30 Minuten ein Thema aus dem IT-Bereich. Dabei ist es immer wieder erstaunlich mit wie viel Hintergrundwissen seine Gäste aufwarten können.

Besonders lustig wird es wenn Richard Campbell ein bis zwei Mal pro Jahr für eine Hanselminutiae Folge zu besuch kommt. Diese Gespräche über alles was die beiden gerade so machen sind sehr spannend und die Liste von Gadgets meist endlos.

 

This Developer’s Life

Leider nur sehr unregelmässig und mit grossen Pausen erscheint This Developer’s Life. Die Gemeinschaftsproduktion von Scott Hanselman und Rob Conery nimmt sich in rund einer Stunde grösseren Themen an, die einem meist sehr lange im Gedächtnis haften bleiben. Space, Typo, Cancer und Getting Fired sind nur eine kleine Auswahl der Themenvielfalt.

 

.Net Rocks!

Carl Franklin und Richard Campbell machen zusammen seit einer gefühlten Ewigkeit .Net Rocks. Thematisch sind die beiden in der .Net Welt beheimatet und kennen dort alles was Rang und Namen hat.

Mit 2 Folgen a 60 Minuten pro Woche ist es kaum möglich alle Folgen zu hören. Bei der Menge kann man aber problemlos einen „eigenen“ Kanal mit ausgewählten Episoden zusammenstellen und hat immer noch genug Material.

 

Herding Code

Herding Code erscheint rund alle zwei Wochen und wird von K. Scott Allen, Kevin Dente, Scott Koon und Jon Galloway moderiert. Thematisch ist dieser Podcast noch mehr auf .Net fokussiert als .Net Rocks, was einem durch die unterschiedlichen Meinungen ein recht genaues Bild über das .Net Ökosystem liefert.

 
Soweit meine Liste mit Podcasts. Da auch ich gerne neue Podcasts kennen lernen sind weitere Empfehlungen sehr willkommen.

Advertisements

5 Bücher die jeder Software-Entwickler kennen sollte (Ausgabe 2014)

Vor gut 1.5 Jahren habe ich bereits einmal eine Top 5 Liste mit Büchern veröffentlicht. Seither habe ich viel gelesen und es ist daher höchste Zeit die Leseempfehlungen zu aktualisieren.

Ich versuchte wiederum eine möglichst technologieneutrale Liste zusammenzustellen. Frameworks kommen und gehen und sind stellenweise in erschreckend kurzer Zeit wieder obsolet. Die hier vorgestellten Bücher behandeln Themen die schon länger aktuell sind und es allem Anschein nach noch einige Jahre bleiben werden.

 

Practical Object-Oriented Design in Ruby

POODR Obwohl sehr viel über OO-Design geschrieben wird ist es sehr schwer ein gutes Buch für den Einstieg zu finden. Sandi Metz hat einen guten Mittelweg zwischen Theorie und Praxis gefunden und es gelingt ihr dieses Thema in verständlichen Schritten zu erklären. Auch wer sich mit Ruby nicht auskennt kann hier viel über OO-Design lernen.

Da die Beispiele recht kurz sind kann man sich auf genau den behandelten Teilaspekt konzentrieren. Dies hilft nicht nur Einsteigern sondern ist auch sehr gut als Auffrischung für erfahrene Programmierer geeignet.
(ISBN: 978-0-3217-2133-4 | detaillierte Rezension)

 

Refactoring

Trotz seines Alters ist Refactoring nach wie vor das Standardwerk zur Restrukturierung von Code. Der ausführliche Katalog mit Strategien zur Verbesserung der Codebasis ist aus meinem täglichen Entwicklerleben nicht wegzudenken.

Dies bedeutet keinesfalls dass ich alle darin vorgestellten Methoden auswendig kenne. Aber Refactorings wie das Umbenennen von Variablen oder das Extrahieren von Methoden sind Dinge die jeder beherrschen sollte. Diese sind sehr einfachen und verbessern den Code doch enorm.
(ISBN: 978-0-201-48567-7 | detaillierte Rezension)

 
 

The Art of Unit Testing (Second Edition)

The Art of UnitTesting 2nd editionRoy Osherove liefert das aus meiner Sicht bisher beste Buch über Unit Testing. Es gibt viele Bücher die gut sind, seine Erklärung von komplexeren Themen wie dem Mocken von Abhängigkeiten ist aber immer noch unerreicht. Und mit der 2. Ausgabe wurden die Praxisbeispiele und Tipps nochmals besser.

Gerade diese Praxisbeispiele helfen einem dabei auch die komplexeren Bereiche mittels Unit Tests abzudecken. Nur wenn man diese Herausforderungen meistern kann wird man Unit Tests in die eigenen Projekte integrieren.
(ISBN: 978-1-6172-9089-3 | detaillierte Rezension)

 
 

Clean Code

Unit Tests und Refactoring sind Techniken die den Code sauberer machen. Wenn einem diese Richtung gefällt ist Clean Code von Robert C. Martin der nächste Schritt.

Sein Buch geht den Weg weiter und verbindet verschiedenste Erkenntnisse in der Software-Entwicklung der letzten Jahre zu einem Ganzen.
Bei Clean Code ist es aus meiner Sicht aber besonders wichtig das man das Ziel bei all den Regeln nicht aus den Augen verliert. Verständlicher Code sollte immer vor einer in Stein gemeisselten maximalen Anzahl Zeilen für eine Methode gehen.
(ISBN: 978-0-13-235088-4 | detaillierte Rezension)

 
 

Patterns of Enterprise Application Architecture

Patterns of Enterprise Application ArchitectureDas 2. Buch von Martin Fowler in meiner Liste behandelt die Patterns rund um Geschäftsanwendungen. Die Problemstellungen in diesem Bereich sind so grundlegend dass die meisten Entwickler in ihren Projekten damit zu tun haben – ganz egal ob ihre Projekte den Stempel „Enterprise“ tragen oder nicht.

Fowler beschränkt sich nicht nur darauf die einzelnen Patterns aufzulisten, sondern erklärt auch die jeweiligen Vor- und Nachteile. Diese Gegenüberstellung macht für mich den Wert dieses Buches aus, da man nur so eine fundierte Entscheidung treffen kann.
(ISBN: 978-0-3211-2742-6 | detaillierte Rezension)

 
 

Soweit meine aktualisierte Liste von Büchern die ich als „Must-Read“ bezeichne. Ich würde mich freuen zu erfahren was andere Entwickler als unverzichtbare Bücher auflisten.

 

Was man von der Baruco 2013 gesehen haben muss

Die Baruco (Barcelona Ruby Conference) ist zwar schon fast 2 Monate her, allerdings sind die Videos erst seit letzter Woche alle online. Die Idee pro Tag ein Video zu veröffentlichen ist recht praktisch um fortlaufen die Präsentationen anzuschauen. Wartet man allerdings vor allem auf die zuletzt gehaltene Präsentation ist dies nicht gerade ideal.

Den Organisatoren gelang es eine Top-Liste an Referenten einzuladen die mit viel Freude und Enthusiasmus ihre Präsentationen hielten oder Workshops durchführten. Da aber nicht jeder 2 Tage Zeit hat um alle Videos anzuschauen habe ich die 5 ausgewählt die man unbedingt sehen sollte:
 

Here Be Dragons“ von Katrina Owen (@kytrinyx) handelt nur vordergründig von schlechtem Code. In einer an ein Computerspiel erinnernden Präsentation zeigt Katrina das man nicht ein schlechter Mensch sein muss um schlechten Code zu schreiben. Vielleicht hatte der entsprechende Programmierer ja auch nur einen schlechten Tag oder die Anforderungen änderten sich fortlaufend. Wie man dennoch als Team zusammenarbeiten kann wird ebenso gezeigt wie die dazu passenden Erkenntnisse aus der Spieletheorie.

 

Der 2. Tage wurde von Paolo Perrotta (@nusco) mit der Keynote „Hunters and Gatherers“ eröffnet. Dass Evolution nicht linear verläuft dürfte den meisten wohl bekannt sein. Was für Umwege dabei in Kauf genommen müssen zeigt Paolo anhand des Längenproblems. Die Bestimmung der geografischen Länge beschäftigte die Seefahrt für über 2000 Jahre und war das Problem schlechthin. Dies ist nicht nur eine interessante Geschichtslektion, sondern zeigt auch worauf wir uns in der IT einstellen müssen.

 

Wen man von Regeln spricht denken die meisten an Einschränkungen. Wie daraus auch neue Möglichkeiten entstehen können zeigt Sandi Metz (@sandimetz) in „Rules„. Um Ruby Code zu schreiben empfiehlt uns Sandi diese 5 Regeln:

  • Maximal 100 Zeilen pro Klasse
  • Maximal 5 Zeilen pro Methode
  • Maximal 4 Parameter pro Methodenaufruf (keine Hashes als Umgehungslösung)
  • Nur 1 Instanzvariable pro Rails-View
  • Maximal 2 Klassen pro Rails-Controller Action

Wer sein eigenes Projekt gegen diese Regeln prüfen will findet mit sandi_meter das passende Gem.

 

Matt Wynne (@mattwynne) sprach in „Treating objects like people“ nicht nur über den Stellenwert der Zusammenarbeit aller im Projekt beteiligten Personen sondern auch über Cucumber. Dieses Projekt ist keinesfalls tot. Obwohl es länger recht still war wird nun wieder aktiv entwickelt und für die nächste Version gibt es zahlreiche interne Verbesserungen. Die Hauptentwickler haben die Firma Cucumber.pro gegründet und bieten nun auch Support und Unterstützung für Unternehmen an.

 

Wie man mit Ruby Spiele für iOS entwickelt zeigte Brian Sam-Bodden (@bsbodden) in „iOS Games with RubyMotion„. Dies geht ganz ohne Objective-C und auf einer unglaublich hohen Abstraktionsebene. Die dafür notwendigen Bibliotheken zeigt Brian ebenso wie weitere hilfreiche Werkzeuge um die Levels zu erstellen. RubyMotion ist definitiv ein Projekt das ich mir einmal genauer anschauen werde.

 

Fazit

Die Baruco 2013 war eine sehr spannende Konferenz die mein Interesse an Ruby deutlich gesteigert hat. Die vorgestellten 5 Videos zeigen einen guten Querschnitt der Präsentationen und wer Zeit hat soll ruhig auch ein Blick auf die Präsentationen von Avdi oder Matz werfen.
 

Bootstrap auf Version 3 aktualisieren

So praktisch Bootstrap für optisch ansprechende Webseiten auch ist, so gibt es doch etwas was man bedenken muss: Wie jede andere Abhängigkeit in einem Software-Projekt muss auch Bootstrap aktualisiert werden. Was harmlos tönt kann schnell recht aufwendig werden, vor allem wenn so viel geändert wurde wie beim Wechsel von 2.x auf 3.0.

 

Zahlreiche Veränderungen

Zwischen Version 2 und 3 gab es bei Bootstrap zahlreiche Veränderungen. Unzählige CSS-Klassen wurden umbenannt, JQuery wird nun direkt verwendet und Responsive Webdesign ist ab sofort zwingend. Wenn diese Veränderungen auch allesamt in die richtige Richtung gehen, so bedeutet dies vor allem Arbeit.

Bevor man sich an die Arbeit macht auf Version 3 zu aktualisieren sollte man sich unbedingt den Migrationsleitfaden anschauen. Darin werden alle Klassen aufgeführt die verändert, entfernt oder neu hinzugekommen sind. Da alles was in dieser Liste enthalten ist angepasst werden muss sollte man sich die nötige Zeit nehmen und die Liste in Ruhe durchlesen.

Beim Grid-System gibt es ebenfalls Änderungen. Neu gibt es 4 Grid-Grössen die über die col-XX- Klasse definiert werden. Wenn man vor hat das Grid zu verändern sollte man dies gleich von Anfang an machen. Ansonsten darf man ein zweites Mal die CSS-Klassen umbenennen.

 

Suchen und Ersetzen

Der Wechsel von den alten auf die neuen Klassen lässt sich am einfachsten mittels Suchen und Ersetzen bewerkstelligen. Wer sich an die Standardvorlage gehalten hat dürfte mit dieser Tabelle schon weit kommen:

2.x 3.0
btn-danger btn btn-danger
btn-success btn btn-success
alert alert-error alert alert-danger
row-fluid row
span2 col-md-2
span3 col-md-3
span4 col-md-4

 

Die Vorlage plündern

Wer noch den Internet Explorer 8 unterstützen muss schaut sich am besten gleich das Starter-Template an und kopiert dort die entsprechenden Header-Zeilen heraus:

    <!-- Bootstrap core CSS -->
    <link href="../../dist/css/bootstrap.css" rel="stylesheet">

    <!-- Custom styles for this template -->
    <link href="starter-template.css" rel="stylesheet">

    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
      <script src="../../assets/js/html5shiv.js"></script>
      <script src="../../assets/js/respond.min.js"></script>
    <![endif]-->
  </head>

JQuery und die JavaScript-Teile von Bootstrap können ebenfalls dort entnommen werden und gehören ans Ende der Seite direkt vor den Body-Tag:

    <!-- Bootstrap core JavaScript
    ================================================== -->
    <!-- Placed at the end of the document so the pages load faster -->
    <script src="../../assets/js/jquery.js"></script>
    <script src="../../dist/js/bootstrap.min.js"></script>
  </body>

 

Wo es komplizierter wird

Die Probleme beginnen meist bei den eigenen Anpassungen. Durch Veränderungen in der Vererbungshierarchie stimmen plötzlich die Abstände zwischen den Rändern nicht mehr ganz genau überein. Bis dies wieder stimmt kann man in den CSS Dateien hin und her experimentieren. Allerdings kann es so vorkommen dass der eine CSS-Fehler den man in der Liste jagt seine Ursprung an einer ganz anderen Stelle hat.

Statt sich diesen Problemen auszusetzen sollte man besser eine Seite wie Bootply.com benutzen. Dort kann man im Browser eine Bootstrap-Vorlage nach seinen Wünschen verändern und sich die Auswirkungen gleich anzeigen lassen.

Bootply

Wenn es dort geht und bei der eigenen Datei nicht liegt es wohl doch eher am eigenen Code und nicht an Bootstrap…

 

Fazit

Ich bin nach wie vor von Bootstrap überzeugt. Man muss sich allerdings bewusst sein das man sich den Zeitgewinn bei der Erstellung der Seite mit einem zusätzlichen Wartungsaufwand erkauft. Dies gilt nicht nur für Bootstrap, sondern für jede Abhängigkeit. Ob sich dieser Zusatzaufwand lohnt muss jeder für sich selber entscheiden.

AngularJS testen

Auch Anwendungen die auf JavaScript-MVC-Frameworks wie AngularJS aufbauen können mittels TDD entwickelt werden. Wie einfach dies ist hängt davon ab ob das jeweilige Framework dafür ausgelegt ist. Bei AngularJS wurde nicht nur an TDD gedacht sondern es gibt sogar eine (ausführliche) offizielle Dokumentation die zeigt wie man vorgehen soll.

 

Dependency Injection macht’s möglich

AngularJS setzt sehr stark auf Dependency Injection. Wenn alle Abhängigkeiten wie Services, Libraries und sogar der DOM an die eigenen Methoden übergeben wird braucht man selber keine fixen Abhängigkeiten mit new zu erzeugen. Fürs testen genügt es so die Abhängigkeiten zu simulieren ohne das man auf den konkreten Service oder den ganzen DOM angewiesen ist.

Bei AngularJS empfiehlt nicht nur die Dokumentation diese Vorgehensweise, sondern es ist auch der einfachste Weg um mit dem Framework zu arbeiten. Dadurch sind die meisten Anwendungen in einer guten Ausgangsposition um automatisch getestet zu werden.

 

Angular-seed als Startpunkt

Wie in meinem früheren Beitrag gezeigt kann man sehr einfach die passenden Bibliotheken einbinden um die eigene Anwendung mit AngularJS zu ergänzen. Will man AngularJS voll ausnützen gibt es aber eine praktische Abkürzung: angular-seed

Angular-seed ist ein Anwendungsskelett für AngularJS das bereits alles nötige enthält um mit TDD loslegen zu können. So sind neben einer minimalen Projektstruktur sowohl Jasmine wie auch der Testrunner Karma bereits konfiguriert und einsatzbereit. Nach einer Installation von Node.js genügt es das Script scripts\test.bat für die Unit- und script/e2e-test.bat für die Integrationstests zu starten.

 

Szenarien mit Jasmine beschreiben

Jasmin ist ein BDD Framework (Behaviour-driven Development) für JavaScript und lässt einem Szenarien (Testfälle) sehr ähnlich wie RSpec oder MSpec beschreiben. Ein einfacher Test ob die Addition wie erwartet funktioniert kann so beschreiben werden:

'use strict';

describe('jasmine demo', function() {

  describe('calculator', function() {
    it('should return the sum of two values', function() {
      expect(1 + 2).toEqual(3);
    });
  });
});

Die Testdurchführung geschieht entweder im Webbrowser oder alternativ mit den Testrunner Karma. Dieser überwacht die JavaScript-Dateien im Projekt und führt die Tests aus sobald sich etwas ändert. Das Resultat wird einem in der Konsole angezeigt und sieht im Erfolgsfall so aus:

karma_green

Im Fehlerfall (hier mit einem – statt einem +) zeigt einem Karma was nicht stimmt:

karma_red

 

Asynchrone Operationen testen

Das Testen von asynchronen Methoden in Jasmine hat seine eigenen Herausforderungen. Jonathan Paul hat sehr gut beschrieben wo diese liegen und wie man seine Testfälle schreiben muss um die gewünschten Resultate zu erhalten.

Allerdings ist dies recht mühsam diesen Code zu lesen. Die Erweiterung Jasmine.Async von Derick Bailey liefert einem eine kleine Verbesserung. So braucht man nicht immer wieder die gleichen Codeblöcke zu schreiben und kann sich stattdessen auf ein async.beforeEach oder async.it beschränken.

 

End-to-End Tests

Oft möchte man aber wissen ob die ganze Anwendung funktioniert und nicht nur die einzelnen Teile. Dazu sind die ebenfalls mit angular-seed mitgelieferten End-to-End Tests gedacht.

Als Anwendung nutze ich für dieses Beispiel wiederum den JSON-Service aus „Erste Schritte mit AngularJS„. Diese Spezifikation beschreibt was für einen MD5-Hash ich für den Text „Hello“ erwarte:

'use strict';

describe('md5 Service', function() {

  beforeEach(function() {
    browser().navigateTo('../../app/md5service.html');
  });


  it('should have a button to click', function() {
    expect(element('button').text()).toEqual('Click');
  });

  it('should ask service for md5-hash of "Hello"', function() {
    input('input').enter("Hello");
    element('button').click();
    expect(element('.result').text())
      .toEqual('8b1a9953c4611296a827abf8c47804d7');
  });
});

Diese Tests lassen sich entweder durch Karma oder direkt über den Webbrowser starten:

angular_end2end_runner

 

Mehr zum Thema

Die hier gezeigten Beispiele vermitteln einen ersten Eindruck der Möglichkeiten. Wer mehr dazu wissen will sollte sich diese Webseiten und Videos anschauen:

 

Fazit

AngularJS wurde so geschrieben das man damit testgetriebene Anwendungen entwickeln kann. Durch Erweiterungen wie angular-seed und Jasmine.Async hat man die nötigen Werkzeuge zur Hand um sehr einfach mit dem Testen beginnen zu können. Alles was es nun noch braucht ist die Bereitschaft dies auch wirklich zu machen. Und das notwendige Training um auch schnell vorwärts zu kommen.

Buch-Rezension zu „Patterns of Enterprise Application Architecture“

Patterns of Enterprise Application ArchitectureEgal mit was für einer Technologie oder Framework man sich beschäftigt, das Buch „Patterns of Enterprise Application Architecture“ von Martin Fowler wird wohl ein Kapitel dazu beinhalten.

MVC? OR-Mapper? Lazy-Loading? Unit of Work? Layering? Session State? Oder braucht man Tipps zur Strukturierung von Geschäftslogik? Fast jedes Thema das man beim Schreiben von Geschäftsanwendungen antrifft wird in diesem Buch behandelt und dessen Platz im grossen Puzzle erklärt.

 

Teil 1: Eine Übersicht zu Geschäftsanwendungen und deren Problemstellungen

Auf rund 100 Seiten erhält man eine Übersicht über die einzelnen Teile die eine Geschäftsanwendung ausmachen. Die Problemstellung wird so erklärt das man auch als Einsteiger in dieses Thema problemlos folgen kann.

Neben einer Definition der Begriffe erfährt man wo die Herausforderungen liegen und wie man durch eine geschickte Wahl der passenden Entwurfsmuster den eigenen Code von den häufigsten Problemen fernhält.

Wer sich schon länger mit Geschäftsanwendungen beschäftigt kann diesen Teil getrost überspringen. Man wird die besprochenen Probleme schon selber oft genug erlebt haben und möchte wohl gleich zu den passenden Lösungen im 2. Teil.

 

Teil 2: Die Patterns

Die Muster sind thematisch geordnet und nehmen die Reihenfolge aus dem 1. Teil auf. Dies macht das Buch sehr angenehm zu lesen da man so auf ein wildes hin und her springen verzichten kann.

Jedes dieser Muster wird nach dieser Schablone erklärt:

  1. Welche Probleme lassen sich damit lösen
  2. Ein UML-Diagramm
  3. Detaillierte Erklärung wie das Pattern funktioniert
  4. Eine Empfehlung wann man dies einsetzen soll (und wann nicht)
  5. Weiterführende Unterlagen
  6. Ein Beispiel mit Code in C# oder Java

Der grösste Nutzen liegt aus meiner Sicht nicht bei der Vorstellung der Patterns an sich, sondern beim Auflisten der Vor- und Nachteile. Stösst man im Projekt an Grenzen kann man entweder alles umbauen oder hier nachschauen was Fowler für Anpassungen empfiehlt. Dabei aber unbedingt überprüfen ob die von Fowler erwähnten Einschränkungen nicht zu noch grösseren Problemen führen. Sonst steht man nach viel Arbeit wieder an der gleichen Stelle.

 

Katalog der Enterprise Application Patterns

Wie für die Refactoring-Patterns gibt es von Martin Fowler auch einen Katalog zu den Enterprise Application Patterns. Darin werden die Patterns mit einer kurzen Beschreibung und dem UML-Diagramm vorgestellt. Dies genügt um sich über die Patterns zu unterhalten, wer allerdings eine Anwendung bauen will wird nicht um das Buch herum kommen.

 

Fazit

Mit Ausnahme von REST erklärt dieses Buch alles was heute bei den meisten Geschäftsanwendungen zum Einsatz kommt. Dabei handelt es sich nicht um irgendwelche an den Haaren herbeigezogenen Spezialfälle, sondern um konkrete Lösungen zu konkreten Problemen.

Wenn man auch intuitiv auf zahlreiche Lösungen selber kommen kann ist dieses Buch doch eine sehr hilfreiche Sammlung. Dies vor allem da auch Alternativen gezeigt und Einschränkungen offen angesprochen werden.

 

Zum Buch

Patterns of Enterprise Application Architecture“ von Martin Fowler, 2002 Addison-Wesley, ISBN 978-0-3211-2742-6, 560 Seiten, Englisch

Buch-Rezension zu „Smalltalk Best Practice Patterns“

Smalltalk Best Practice PatternsSmalltalk Best Practice Patterns“ von Kent Beck erschien bereits 1996, doch stosse ich in letzter Zeit immer wieder auf dieses Buch. Überall wird erzählt wie wegweisend dieses Buch sei und wie viel man damit über objektorientierte Programmierung lernen könne. Die Besprechung bei Ruby Rogues in den Folgen 23 und 24 überzeugte mich schliesslich dieses Buch zu lesen – obwohl ich nie in Smalltalk programmiert habe.

Um es vorweg zu nehmen: Es gibt nur wenige Teile in diesem Buch die einzig für Smalltalk eine Bedeutung haben. Der grösste Teil ist so geschrieben das dieser auch für Sprachen wie C#, Ruby oder Java nützlich ist.

 

Viele gute Ideen

Die Tipps zur objektorientierten Programmierung fand ich nicht schlecht. Allerdings waren mir viele Konzepte bereits bekannt und als Einstieg in die objektorientierter Programmierung finde ich POODR besser geeignet.

Was aber in diesem Buch gut dargelegt wird ist das „Wieso?“. Als die Objektorientierung noch nicht so verbreitet war wie heute musste man noch argumentieren. Es brauchte Überzeugungsarbeit und konkrete Beispiele wie damit die Arbeit leichter wird. In heutigen Büchern findet man so etwas leider meist nicht mehr.

Kent Beck verkauft einem seine Empfehlungen nicht als den einzig selig machenden Weg. Jede Entscheidung hat Vor- und Nachteile die man entsprechend Abwegen muss. Mir hat dabei besonders gefallen dass die Nachteile gleich an Ort und Stelle dargelegt werden. So muss man nicht lange Suchen und kann gleich abschätzen ob das Pattern für einen in Frage kommt.

Die Kurzreferenz am Ende des Buches bringt jedes vorgestellte Pattern mit wenigen Sätzen auf den Punkt. Durch das Plus an Informationen gegenüber dem Index findet man auch dann das passende Pattern wenn einem der Name entfallen ist. Diese Zusammenfassung ist zudem als Gedankenstütze äusserst hilfreich.

 

Wie nützlich ist das Buch heute?

Wenn man mit Ruby entwickelt hat das Buch auch heute noch seine Berechtigung. Man erfährt hier den Ursprung von so manchem Sprachkonstrukt und worauf man auch in Ruby achten sollte. Blöcke, Inject() und das Konzept mit dem senden von Meldungen gehen so sehr auf Smalltalk zurück das man die Patterns von Kent Beck 1:1 weiter verwenden kann.

Arbeitet man mit .Net ist der Nutzen nicht so offensichtlich. Obwohl zahlreiche Konzepte von Ruby nach .Net geflossen sind ist die Distanz zu Smalltalk doch deutlich grösser. „Clean Code“ und „The Art of Readable Code“ greifen zudem viele Ideen aus diesem Buch auf und erklären diese mittels C# (oder Java) – ein Umweg über Smalltalk ist dadurch unnötig.

Seit anfangs 2013 gibt es dieses Buch auch als E-Book. Wäre die Nachfrage danach gering hätte sich der Verlag fast 17 Jahre nach der Erstveröffentlichung diese Mühe sicher nicht gemacht. Mit dem wiedergefundenen Interesse werden vielleicht auch einige der handwerklichen Eigenheiten (wie der Zusammenfassung oder dem Abwägen von Vor- und Nachteilen) in aktuelle Bücher einfliessen – wünschenswert wäre dies allemal.

 

Fazit

Ich finde es immer wieder erstaunlich seit wie vielen Jahren die gleichen Herausforderungen und Probleme gelöst werden müssen. Smalltalk Best Practice Patterns zeigt Lösungen die auch heute noch Code verbessern können. Je nach Programmiersprache braucht es aber einiges an (mentaler) Arbeit bevor man die hier gezeigten Lösungen verwenden kann.

 

Zum Buch

Smalltalk Best Practice Patterns“ von Kent Beck, 1996 Prentice Hall, ISBN 978-0134-7690-2, 240 Seiten, Englisch