ExtJS Theming: Eine Anwendung, 100 Gesichter

In der Frontendentwicklung ist es nicht unüblich, eine Anwendung in verschiedener Art in Erscheinung treten zu lassen. Ob für die Abgrenzung mehrerer Brands voneinander, den Verkauf einer Software mit spezifischen Designanpassungen für den Käufer (etwa für einen Online-Shop), oder zur Durchführung von A/B-Tests mit unterschiedlich gestylten Frontendkomponenten – es gibt eine Vielzahl von Gelegenheiten, bei denen es Sinn macht, eine Anwendung mit unterschiedlichen Gestaltungen in anderen Gewändern zu zeigen.

Hier möchte man selbstverständlich in den wenigsten Fällen das komplette Frontend neu schreiben. Dabei können bereits kleinere Änderungen, etwa eine Anpassung der verwendeten Farben, das Aussehen der Anwendung grundlegend ändern.

Im Folgenden möchte ich zeigen, wie man durch den Einsatz von Themes die eigene Anwendung mit relativ geringem Aufwand in neuem Glanz präsentieren kann. Weiterlesen

Die Reise mit der Mayflower – ein Ausbildungsbericht

Seit nunmehr 2 1/2 Jahren habe ich das Privileg, teil der Mayflower-Crew zu sein. Nun ist der Zeitpunkt für mich gekommen, mich von meinem Leichtmatrosen-Dasein zu verabschieden und meine Ausbildung Revue passieren zu lassen – und auf diesem Weg anderen Landratten einen Einblick zu geben, was es bedeutet, als Auszubildender auf der Mayflower zu segeln.

Für mich begann diese Reise völlig unerwartet Anfang 2010, als ich mich mit dem Zend Framework beschäftigte und zu diesem Zweck das Zend-Framework-Poster der Mayflower GmbH bestellte. Weiterlesen

Alternative Bedienkonzepte für Webanwendungen

Die typische Webanwendung wird seit jeher über das Klicken auf Links gesteuert. Und vermutlich hat gerade das zur Popularität des Internets beigetragen, schließlich kann somit jeder ohne große Vorkenntnisse eine Website bedienen. Anders sähe es aus, wenn man Webanwendungen nur mit kryptischen Befehlen steuern könnte, wie beim Arbeiten mit einer Shell. Hier wäre dann wieder Expertenwissen gefragt.

Jedoch ist das Steuern einer Webanwendung mit der Maus auch noch nicht die schnellste Art, um zum Ziel zu gelangen. Je nach Zweck der Seite kann es durchaus Sinn machen sich alternative Möglichkeiten zu überlegen, um die Bedienbarkeit der Anwendung zu erhöhen und diese zu beschleunigen. Einige diese Möglichkeiten möchte ich im folgenden kurz vorstellen. Weiterlesen

Production != Staging und trotzdem alles unter einem Hut

In einer idealen Welt der Entwicklung sehen natürlich Staging- und Produktivsystem völlig identisch aus, da Probleme, die im Produktivsystem auftreten würden, bereits auf dem Stagingsystem absehbar sind.

In der realen Welt ist dies jedoch längst nicht immer der Fall, sei es nun historisch bedingt, aus Kostengründen, wenn beispielsweise eine teuere kommerzielle Linuxdistribution für das Produktivsystem genutzt wird, oder weil das Produktivsystem so gar nicht abbildbar ist – Gründe gibt es genug, warum Staging- und Produktivsystem nicht so identisch sind, wie sie es seien sollten.
Weiterlesen

16.12. Eine Einführung in Behavior Driven Development

Testdriven Development, also das Schreiben eines oder mehrerer Tests bevor der eigentliche Code entsteht, ist inzwischen ein alter Hut.
Ein großer Nachteil dieses Verfahrens ist, dass im agilen Umfeld die User Stories erst verstanden werden müssen.
Wenn die Story aber falsch verstanden wurde, dann wird auch der Test falsch implementiert.
Knackpunkt ist also immer noch der Abgrund zwischen Analyse und Verdeutlichung der Geschäftsprozesse sowie dem korrekten Erfassen und testen eben jener.
Eine Lösung hierfür soll Behavior Driven Development – kurz BDD – bieten.

Weiterlesen

08.12. Agilere Datenbankentwicklung

Agile Entwicklung ist gescheitert.
Jedenfalls auf Datenbankseite.

Agile Entwicklung ist mehr als nur Scrum, hierzu kommen in den meisten Projekten noch weitere Tools und Vorgehensweisen zum Einsatz, um schnell auf neue Anforderungen zu reagieren.
Hierzu zählen in der eigentlichen Entwicklung Continuous Improvements, also das stetige Verbessern des Quellcode innerhalb eines Projektes, welche zum Beispiel durch Code Reviews und Refactorings unterstützt werden können.

Bedingt durch die sich schnell ändernden Anforderungen ändert sich auch der Code schneller und häufiger.
Um sich dennoch abzusichern, kommen hier Tools wie automatisierte Unittests, ausgeführt Beispielsweise in einer Continuous Integration Umgebung zum Einsatz.

Inzwischen haben viele Projekte zudem erkannt, dass die kurzen Entwicklungszyklen, die mithilfe, eben genannter Techniken möglich werden, entsprechend kurze Releasezyklen erfordern.
Im Idealfall führt dies zu einem Continuous Deployment, also der Fähigkeit ein Feature sofort nach der Fertigstellung zu releasen.

Ein Prozess ist jedoch immer nur so gut, wie seine Teilprozesse.
An dieser Stelle sollten wir unseren Blick auf die Datenbank lenken.

  • Wie läuft hier die Entwicklung?
  • Wie automatisieren wir Datenbankupdates?
  • Was für einen Stand hat unsere Datenbank auf Produktiv? Auf Staging? Auf dem Previewsystem?
  • Wie sichern wir Datenverluste bei nachträglichen Änderungen ab?

Bei uns lief es im Projekt bis vor kurzem so, dass vor einem Update der Datenbank händisch geprüft werden musste welche Änderungen noch nicht in der Datenbank existieren um dann entsprechende SQL Dateien zusammenfügen zu können, die die neuen Änderungen enthielten.
So ein Vorgehen ist nicht nur Fehleranfällig sondern auch Aufwendig.
Am stärksten Bemerkbar machte sich dies, beim migrieren von Daten, was bedeutete, dass die Reihenfolge von SQL Dateien und Migrationsskripten strikt beachtet werden musste.

Refactorings hingegen liefen so ab, dass die neue Datenstruktur in Form von neuen Tabellen angelegt wurde, die Daten mithilfe von Migrationsskripten überführt wurden und die ursprünglichen Tabellen erst beim nächsten Release vollständig gelöscht wurden, sofern dies nicht vergessen wurde.

Dieses Vorgehen kostete viel Zeit und Nerven, weshalb eine Alternative gesucht wurde.

Vor kurzem haben wir als Team ein neues Tool gefunden welches uns viel Arbeit abnimmt und vor allem zusätzliche Sicherheit auf Datenbankseite gibt.

Dies ist Liquibase, ein in Java geschriebenes Tool zum Refactoring und automatischen Update der Datenbank, welches unter der Apache 2.0 Lizenz zur freien Nutzung zur Verfügung steht.

Liquibase bringt eine eigene Beschreibungssprache für Datenbankänderungen mit, die auf XML basiert.
Durch diese abstrakte Beschreibung der Änderungen in XML wird Datenbankunabhängigkeit ermöglicht.
So kann Liquibase mit jeder Datenbank umgehen für die ein JDBC Treiber verfügbar ist, so zum Beispiel MySQL, Microsoft SQL Server, Oracle, PostgreSQL, SQLite, Apache Derby und vielen weiteren.

Definiert werden die Änderungen als sogenannte Changesets, die in beliebiger Anzahl innerhalb eines DatabaseChangelogs vorkommen können.
Jedes Changeset setzt die Angabe eines Autors und einer Id voraus, wobei die Id nur innerhalb des DatabaseChangelogs eindeutig sein muss.

Ein einfaches Changelog, der eine einzelne Tabelle mit 2 Spalten, id und name, anlegt sieht wie folgt aus:


Ausgeführt werden kann dieses Changelog entweder innerhalb eines vorhandenen Buildsystems, hierfür gibt es Tasks in ANT, Maven, Grails, Spring und in Phing als Erweiterung unter https://github.com/bitExpert/liquibase-phing, oder über die Kommandozeile:


Bei diesem Aufruf wird der Treibertyp, in unserem Fall JDBC MySQL, das Verzeichnis des Treibers, der Pfad zum auszuführenden Changelog, sowie URL der Datenbank, Nutzername und Passwort angegeben und der Befehl update, um Liquibase zu veranlassen, dass alle Änderungen eingespielt werden, die noch nicht in der Datenbank sind.
Am Rande sei hier bemerkt, dass der JDBC Treiber für die jeweilige Datenbank nicht Teil von Liquibase ist, ergo separat heruntergeladen werden muss.

Wer sich jetzt fragt, woher Liquibase wissen kann, was bereits in der Datenbank vorhanden ist und was geupdatet werden muss, dem möge folgende kurze Erklärung dienen:
Liquibase speichert in der Tabelle DATABASECHANGELOG Metainformationen zu jedem erfolgtem Update ab.
Hierzu gehört für jedes ausgeführte Changeset der Autor, die Id, das Ausführungsdatum und eine Hashsumme des Changesets.
Die Hashsumme wird bei jedem neuen Update für alle bereits vorhandenen Changesets geprüft, so dass nachträgliche Änderungen an einem bereits ausgeführten Changeset nicht mehr möglich sind.
Es gibt zwar die Möglichkeit mit dem Kommandozeilenbefehl clearChecksums alle Hashsummen zu löschen, jedoch ist die saubere Vorgehensweise bei einem Fehler ein neues Changeset anzulegen, welches den Fehler behebt.

Der größte Vorteil, den man mit echten Changesets gewinnt, sind die Rollbacks.
Für alle Änderungen die neue Tabellen, Spalten oder ähnliches anlegen, oder bestehende Verändern, bietet Liquibase automatische Rollbacks.
Diese werden wichtig, sobald beim updaten etwas schief geht, denn dann wird der Rollback ausgeführt, so dass eine inkonsistente Datenbank verhindert wird.
Jedoch sind die Rollbacks auch in der Entwicklung sehr nützlich, da jederzeit zu einem bestimmten Stand der Datenbank zurück gekehrt werden kann.
Dies ist Changesetabhängig möglich, mit rollbackCount n, welches die letzten n Changesets zurück nimmt, Datumsabhängig mit rollbackDate <date>, welches alle Changesets die neuer als das angegebene Datum sind zurück nimmt und Tag abhängig.
Letzteres kehrt dabei zu einem in Liquibase gesicherten Stand der Datenbank zurück, einem sogenanntem Tag.

Für alle Rollbacks, die nicht mit einem Automatismus abgedeckt werden, kann auch manuell ein Rollback definiert werden.
Dies ist zum Beispiel der Fall wenn das Löschen einer Tabelle fehlschlägt und darauf entsprechend reagiert werden soll.
Das Definieren geschieht innerhalb des entsprechenden Changesets, indem nach der eigentlichen Anweisung eine oder mehrere Rollbackanweisungen geschrieben werden, die alle innerhalb des Tags <rollback> stehen müssen.

In den meisten Teams ist Dokumentation nicht gerade beliebt, jedoch ein notwendiges Übel um neuen Teammitgliedern den Einstieg zu erleichtern und nachvollziehbar zu machen, welche Änderungen wann gemacht wurden.
Auch hier Unterstützt uns Liquibase.
Mit dem Befehl dbDoc und einer nachfolgenden Pfadangabe ist es möglich, eine Dokumentation aller Änderungen zu generieren, die mit dem angegebenen DatabaseChangeLog durchgeführt werden würden.
Die dabei entstehende Änderungsdokumentation ist dabei stark an Java-Doc angelehnt.

Am meisten Zeit bei der Datenbankentwicklung mit Liquibase verschlingt das Schreiben der Changesets.
Zum Glück stellt auch hier Liquibase ein Tool bereit.
Die Methode diffChangeLog generiert anhand der Unterschiede zwischen zwei Datenbanken die entsprechenden Changesets.
Der Kommandozeilenaufruf dazu sieht ähnlich aus, wie beim updaten der Datenbank, jedoch werden zusätzlich die Daten der zweiten Datenbank angegeben, gegen welche geprüft wird:


Die neuen Changesets werden im angegebenen changeLogFile gespeichert.
Dabei werden sowohl Stored Procedures und Functions, als auch Trigger und Check Constraints ignoriert.

Die Unterschiede können mit Liquibase auch zwischen verschiedenen Datenbanksystemen ermittelt werde, beispielsweise einer MySQL und einer SQLite Datenbank.

Auch wenn die Einarbeitung in Liquibase einige Zeit erfordert und vor allem eine Umstellung in der Arbeitsweise, so möchte ich dieses geniale Tool im täglichen Arbeiten nicht mehr missen, da uns als Team damit viele Sorgen und Mehraufwände abgenommen werden.

IPC 2011 – ein kurzer Bericht

Die International PHP Konferenz im schönen Mainz liegt wenige Tage zurück, Grund genug für mich ein Fazit zu ziehen und einige besondere Perlen unter den zahlreichen Vorträgen zu erwähnen.
Mit der Rheingoldhalle in Mainz hat der Veranstalter meiner Meinung nach eine sehr schöne Location gefunden, die flexible Vortragsräume bot um sowohl großen Vorträgen mit mehreren hundert Zuhörern, als auch kleineren Präsentationen entsprechenden Platz zu bieten.
Einzig der Bereich für Aussteller, Garderobe und Eingang zu den jeweiligen Räumen hätte gerne größer ausfallen dürfen.
Jedoch ließen sich die wenigsten von dieser Tatsache stören und so kamen auch auf diesem engerem Raum viele gute Gespräche zustande.

Weiterlesen

Agiles CSS

Bei Mayflower wird agil entwickelt. In erster Linie bedeutet dies für den Kunden, dass wir auf geänderte Anforderungen schnell reagieren können.
Schnell reagieren zu können heißt auch, neue oder geänderte Anforderungen so schnell wie möglich umzusetzen.
Dafür muss der Code so aufgebaut sein, dass man mit minimalen Aufwand Änderungen durchführen kann.
In PHP nutzen wir dafür entsprechende Abstraktionen und Kappselungen.

Aber wie schaut das Ganze im Frontend aus, insbesondere in CSS Dateien?
Was, wenn der Kunde das Blau aus dem vorgegebenen Farbschema eine Nuance dunkler haben möchte?
Weiterlesen

Buildscripts mit PHING – Teil 3

Im zweiten Teil wurde die Hauptaufgabe, das Zusammenführen aller SQL-Files, durch einen eigenen Task gelöst.
Nun fehlen noch die letzten Schritte, das Bereinigen und Zusammenpacken der Projektdateien und das anschließende Bilden einer Prüfsumme.
Anschließend müssen alle Ausgaben nur noch zusammengefasst ausgeführt werden, um einen Deployfähigen Zustand zu erhalten.
Damit am Schluss alle Aufgaben nur noch zusammengefasst ausgeführt werden müssen, um ein Deployfähigen Zustand zu erhalten.

Weiterlesen