Ein paar einführende Worte zu Ruby und Rails

Ruby on Rails ist eine Kombination aus Sprachen (Ruby) und Frameworks (Rails), die in den letzten Jahren eine sehr hohe Aufmerksamkeit bekommen hat.

Ruby vereint bewährte Konzepte unterschiedlicher Sprachen in einer Skriptsprache: vollständige, reine Objektorientierung von Smalltalk, prototyp-basierte Objektorientierung a là JavaScript, Mixins aus Python. Über DuckTyping wird eine dynamische Typisierung bereitgestellt und da jedes Programm in einem globalen Main-Objekt läuft, fallen explizite Klassendefinition wie aus Java, C++, C#, etc. bekannt, weg und vereinfachen die Syntax; so kann Ruby auch vollständig prozedural programmiert werden und da jeder Ausdruck zu einem Wert ausgewertet wird, ist auch funktionale Programmierung möglich.

Schnell folgte ein Framework für Webapplikationen. In Ruby-Manier (Principle of Least Surprise + Keep It Short and Simple) versucht Ruby on Rails trotz komplizierter Technologien wie Model View Controller, Representational State Transfer oder Object-relational Mapping, den Programmieraufwand so gering wie möglich zu halten. Das scheint anzukommen, typische Rails-Projekte umfassen Basecamp, Twitter, Scribd, Pitchfork, Shopify oder GitHub.

Die Zauberformel nennt sich „Convention over Configuration“ und das Werkzeug, mit dem man auch ohne Ruby-Kenntnisse Webapplikationen erstellen kann, heißt „Scaffolding“: Eine Vorstellung der Modellbeziehungen reicht um mit den Scaffolding-Befehlen Datenbanken, Model-, View und Controller-Klassen, Routes, etc. automatisiert zu erzeugen.

Meine bisherigen Bucherfahrungen

Leider, das ist meine Erfahrung, wird dieses Prototyping-Werkzeug von vielen Buchautoren missverstanden. So gibt es viele Bücher und Tutorials, die einem mit Scaffolding aufzeigen wie leicht sich ein Blog, ein Twitter-Clone oder eine Filme-Datenbank bauen lässt; wenn dann der Leser ein eigenes Projekt realisiert und auf Probleme stößt, steht er oft verloren da. Denn warum Scaffolding wo welche Dateien wie anlegt, wird einem in der Regel nicht erklärt. Falls doch (Michael Hartls „Learn Web Development with Rails“ ist eine solche Ausnahme), wächst das Buch schnell an Umfang, sodass für fortgeschrittene Themen kaum Raum bleibt.

In diese Lücke tritt das von O’Reilly vertriebene Buch „Crafting Rails Applications“ aus der Reihe „The Facets of Ruby“, welches sich in der vorliegenden zweiten Auflage vom Verlag Pragmatic Bookshelf explizit auf Rails 4 bezieht. Der Autor José Valim verspricht auf den 180 Seiten dem Leser ein Verständnis von „Rails‘ inner workings“ zu verschaffen, welches helfen soll zukünftig robustere Projekte zu erstellen.

Acht Kapitel mit jeweils etwa 20 Seiten gibt es zu lesen, jedes Kapitel ist ein in sich geschlossenes Hands-on-Tutorial, welches ein eigenes Thema umfasst, und die Theorie an einem Beispiel demonstriert. Dennoch lohnt sich das „chronologische“ Lesen, denn auf die Theorie der ersten Kapitel wird in den folgenden Kapiteln zurückgegriffen.

Inhalt

Das erste Kapitel erweckt zunächst den Eindruck, dass das Buch auch für Einsteiger geeignet sei, da bekannte Begriffe wie Gemfile, Rakefile, application.rb, erklärt werden. Schnell geht es dann aber in die tiefere Materie; zunächst wird das Plug-In-System vorgestellt, dass auch für viele fortgeschrittene Webapplikationsentwickler noch unbekannt sein dürfte. Praktisch wird gleich im ersten Kapitel ein Renderer geschrieben, der das Erzeugen von PDF-Dateien unterstützt. Prawn, welches aus einfachem Text PDF-Dateien erzeugt, soll als Plug-In ins Rendering-System von Rails eingebunden werden. Um die Funktionalität sicher zu stellen, wird in bewährter „Test-Driven Development“-Manier das erwartete Verhalten in Integrationstests beschrieben, bevor der eigentliche Programmcode geschrieben wird. Dann folgt Theorie, die Anhand von Beispielen erklärt wie der Render-Stack in Rails implementiert ist. Abgeschlossen wird das erste Kapitel mit Erweiterungsmöglichkeiten: HTML-to-PDF und XML-to-PDF wären schön, Softwarepakete, die einem hierbei helfen, werden benannt und verlinkt.

Im zweiten Kapitel geht es darum ein Plug-In namens „Mail form“ zu programmieren, welches auf POST-Requests lauscht, die Daten validiert und dann per E-Mail versendet. Aufbauend auf den Erörterungen zum ActionController im vorherigen Kapitel nimmt sich José Valim nun das ActionModel vor und zeigt, wie wir dank des Modularen Aufbaus nur die Funktionalitäten in unser Objekt aufnehmen, die uns interessieren. Es wird gezeigt, wie auf elegante Weise zu generierende Methoden für noch unbekannte Attribute geschrieben werden können und wie der Code auch ActiveModel API-Konform bleibt. Nebenbei wird für das Testen das Capybara-Framework vorgestellt.

Das Kapitel 3 befasst sich neben Vertiefen des Rendering-Stacks auch mit der Datenbank. Ziel ist es, Templates, die sich in einer Datenbank befinden, abzurufen und beim Rendern einzusetzen. Wir brechen also mit Rails „Convention over Configuration“, welche ein Template unter app/views erwartet, und müssen uns gleichzeitig einen SQL-Resolver schreiben. Die Crux bietet ein Ausflug in das Thema Caching sowie das Integrieren des bisherigen Codes in einen CMS-Controller, wobei auch das ActionController-Modul aus dem ersten Kapitel wieder besucht und insbesondere die ActionController::Metal-Klasse näher untersucht wird.

Mit Kapitel 4 befasst sich das Buch noch ein weiteres Mal mit dem Rendering. Während im ersten Kapitel das Einbinden von zusätzlichen Renderern und der Render-Stack untersucht wurde und im dritten Kapitel Templates für den Renderer untersucht wurden, geht es nun um die Klärung der Frage, wie Rails aus einem Template Code compiliert. Dazu wird der Template Handler über das Beispiel eines Multipart E-Mailers unter die Lupe genommen; Markdown-formatierter Text soll über einen Template Handler mithilfe eines einzigen Templates sowohl in HTML als auch in Plain-Text umgesetzt werden und als Multipart E-Mail versendet werden, sodass im Abhängigkeit vom Mail-Client des Empfängers die Mail entweder als HTML- oder als Plain-Text-E-Mail angezeigt wird. Ein eigener Rails Generator sowie ein Einblick in die Hook-Architektur von Rails-Frameworks über Railties runden dieses Kapitel ab.

Im Kapitel 5 wird das Rendering verlassen und Streaming beleuchtet. Als Beispiel-Programm wird ein Plug-In geschrieben, welches bei Änderung eines Assets diese Information direkt an den Browser sendet, sodass ein manuelles Neuladen der angezeigten Seiten hinfällig wird. Um neben der dargestellten Technik auch weiterführende Techniken aus der Rails-Welt darzustellen, wird das Plug-In nach Erzeugung als Gem verpackt und kann so dann in andere Projekte integriert werden. Dazu werden Rails Engines vorgestellt, mit denen ein Plug-In auch eigenständig wie eine vollständige Rails-Applikation verwendet werden kann.

Das sechste Kapitel setzt sich mit einer der wichtigsten Philosophien hinter Ruby on Rails auseinander, nämlich DRY Code, d.h. Code, der darauf optimiert ist, dass sich nichts wiederholt. Dazu werden die Responders-Methoden von Rails verwendet und mit deren Hilfe werden Generatoren erzeugt, die vom Scaffolding verwendet werden, um Dateien anzulegen, die eine höhere „DRYness“ haben als es der standardmäßig erzeugte Code der Scaffolding-Generatoren tut.

Kapitel 7 baut auf die zuvor vorgestellten Rails Engines auf. Gezeigt wird, wie man eine komplett isolierte Engine baut, die in Rails gemounted werden kann. Als Beispiel-Applikation dient ein Programm, welches aufzeichnet, wie viele Datenbank-Anfragen zu einem Request von einer Rails Applikation abgesendet werden und wie lange die Beantwortung der Anfragen benötigen. Dazu wird die ActiveSupport::Notifications-API von Rails vorgestellt. Die Informationen werden in eine eigene Datenbank (MongoDB) geschrieben und die Engine stellt eigene Routes, Controller und Views bereit, um die gespeicherten Daten anzuzeigen. Dazu wird auch der Rails-interne Webserver Rack genauer untersucht.

Im letzten Kapitel wird auf das Internationalization Framework (I18n) von Rails eingegangen. Statt, wie von Rails standardmäßig angeboten, eine YAML-Datei mit den benötigten Übersetzungen zu füllen, welche schnell groß und unübersichtlich wird, werden die Daten mithilfe eines Key-Value-Stores (Redis) abgelegt, sodass die Übersetzungen weiterhin von der Performanz einer YAML-Datei profitieren, aber gleichzeitig wartbar bleiben. Parallel werden Sinatra, eine DSL für das schnelle Erzeugen von Web-Applikationen, sowie Devise, ein Authentifizierungssystem das auf Rack basiert, vorgestellt.

Fazit

Zunächst möchte ich betonen, dass „Expert Practices“ als Untertitel wirklich Programm ist. Wer noch nie mit Rails gearbeitet hat oder bisher hauptsächlich auf Scaffolding gesetzt hat, wird mit diesem Buch keine Freude haben. Ich selbst habe 2011 das erste Mal beruflich mit Rails zu tun bekommen und hatte dank eingangs erwähnten schlechten Einführungsbüchern auch lange Zeit zu kämpfen. Mittlerweile bin ich begeistert von Rails und entwickele nun auch im privaten ein kleines eigenes Projekt. Dennoch empfand auch ich das Buch nach 3 Jahren Rails-Erfahrung nicht gerade als einfache Kost.

Der Aufbau des Buchs gefällt mir sehr. Jedes Kapitel startet mit einem Szenario, mit dessen Hilfe in die zu untersuchende Technik von Rails eingeführt wird. Die Szenarien sind praxisnah gewählt und werden anhand von Code-Snipplets und Testcases erläutert, ehe programmiert wird. Beim Programmieren wird dann auch auf die Hintergründe eingegangen. Am Ende eines jeden Kapitels kommen die Unterkapitel „Taking it to the next level“, bei dem auch auf mögliche Erweiterungen eingegangen wird, sowie „Wrapping it up“, welches das Kapitel noch mal zusammenfasst, auf zusätzliche Erweiterungen eingeht und Quellen nennt, die man sich zur Vertiefung angucken sollte. Somit bildet jedes Kapitel eine abgeschlossene Einheit, es entsteht eine klare Struktur und man bekommt gute Hinweise darauf, wie man die Technik weiter erforschen kann.

Das Buch ist nichts, dass sich nebenher lesen lässt. Insbesondere ist es sinnvoll, die Programme am eigenen Rechner nachzuvollziehen. Das Buch hebt sich dadurch heraus, dass alles von Hand programmiert wird – auf Code-Generatoren wird verzichtet. Dafür zeigt José Valim Best-Practice-Methoden, etwa indem neben der Rails-Eigenen Testumgebung auch auf Capybara eingegangen wird, welches im Railsumfeld oft anzutreffen ist. Dabei ist das Tempo sportlich, auf 180 Seiten ist das Buch so gehaltvoll, dass man langsamer voran kommt, als bei manch einem umfangreicheren Buch. Oft musste ich im Internet zusätzliche Quellen hinzuziehen um bestimmte Themen zu durchdringen. Das würde ich aber nicht als Nachteil des Buchs betrachten – es handelt sich hierbei tatsächlich um ein „Arbeitsbuch“, das einen durch den tieferen Einstieg in Rails führt.

Empfehlen würde ich dieses Buch jedem, der schon einige Projekte in Rails realisiert hat; insbesondere auch mal eines von Grund auf selbst entwickelt hat, und jetzt auf der Suche nach weiterführenden Techniken ist. Am Ende des Buches ist José Valim sich sicher, dass man nun das nötige Grundverständnis besitzt, um auch den Rails-Code nachvollziehen zu können und eventuell bald sogar selbst zum Rails-Projekt beitragen kann. Das möchte ich mir nach der Lektüre nun nicht direkt zutrauen – die ein oder andere Technik müsste ich wirklich noch mal im Detail durcharbeiten. Dennoch verstehe ich jetzt einige Hintergründe besser als zuvor. Und wer weiß, vielleicht macht mich dies ja tatsächlich zu einem besseren Rails-Programmierer? Die zukünftigen Projekte werden es zeigen.