Dienstag, 29. Mai 2012

Web Development mit Java in 2012

Teilen
Wir schreiben das Jahr 2012. HTML5 ist längst keine Spezifikation mehr und wird von vielen Frameworks gepushed. Aber wann begann der Hype um HTML5? Wann hieß es, man kann damit Enterprise Applications bauen?

Ok. Back to 2012. Eine Ist-Aufnahme. Bei dem OpenWMS.org Framework hatte ich zu Anfang auf "Standard-Technologien" gesetzt, um natürlich eine lange Wartbarkeit und Langlebigkeit vorhandener Projekte zu garantieren. Damals war JavaServer Faces in der Version 1.1 der de-facto Standard (2005). Dieses Projekt fand leider niemals seinen Weg aus einem Developer-Branch heraus. Trotzallem wollte ich an dem Standard festhalten und entwickelte mit JSF1.2 sowie der RichFaces Library eine zweite Version. Diese kam mit Ajax Features daher und machte das Ganze etwas mehr "Rich" als es mit plain JSF einher kam. Das Problem was sich damals und bis heute noch nicht gelöst hat ist, dass es schier einen enormen Zeitaufwand bedeutet "custom"-Screens zu entwickeln. Das sind genau die Dialoge die nicht in irgendein Template passen. Im Falle eines WMS (Warehouse Management System /logistics) Projektes ist dies eben keine Seltenheit. Wir entwickeln kein breit-bekanntes Softwareprodukt, nachdem sich der Kunde ausrichten muss. Vieles ist weit weg von Standardsoftware mit Standard-Dialogen.

Das Problem bis zu dem damaligen Zeitpunkt war einfach, dass Browser-Inkompatibilitäten einen enormen Aufwand an Screen-Design benötigten. Sprich, ein Entwickler musste (und muss immer noch) die Technologien CSS, JavaScript indeep beherrschen! Was an sich eine Lachnummer ist. Ein WMS Projekt Engineer möchte eigentlich nur seine Geschäftslogik einfach und verständlich umsetzen - ohne ein Webdesigner sein zu müssen.

Nachdem ich selbst einen grossen Teil des eigentlichen OpenWMS.org Frameworks mit JavaServer Faces 1.2 und RichFaces implementiert hatte, musste ich wieder einmal feststellen, dass der hochgelobte Standard nicht die richtige Technologie für meine Domäne ist.
Mir wurde klar, dass zum einen eine vernünftige Tool-Unterstützung fehlt, und zum anderen die Inkompatibilitäten der "Sandboxes" (Browser) ein erhebliches Problem darstellt.

Zum Glück gab es Adobe Flex!
Adobe Flex bietet den Vorteil, dass auch eine Sandbox von Adobe geliefert wird (Adobe Flash Player). Zudem bietet Adobe eine ordentliche IDE (Adobe FlexBuilder 3 dazumals) die es erlaubt UI vernünftig in angemessener Zeit zu implementieren. Rapid Screen Development!

Flex heisst ActionScript mit MXML, und wo ist Java?
Die Businesslogik eines WMS Projektes sollte über mehr als 10 Jahre wartbar sein. Das UI darf in dieser Zeit öfters als einmal wechseln. Also stellen sich zwei Fragen:

1) Wie stabil sind die Interfaces des Backends (not a topic here)?
2) und wie gut ist die Anbindung an Backend-Technologien vorhanden?

Im Falle von Adobe Flex kann man auf die zweite Frage antworten: Die Anbindung an die Java Welt funktioniert mit Frameworks wie GraniteDS perfekt und mit Adobe BlazeDS und Adobe Cairngorm auch sehr gut.

Trotzallem 2012.
Adobe hat sich leider dazu entschieden, sicherlich aus Gründen der kommenden HTML5 Bewegung, das Flex Framework an die OO Community zu übergeben und nicht mehr selbst voran zu treiben. Was für mich persönlich den Ende, bzw. die nicht mehr aktive Weiterentwicklung, des Frameworks bedeutet.

Also habe ich mich erneut dazu entschieden, eine Vorab-Evaluation über gewisse, bekannte Web-Frameworks zu betreiben. Meine Anforderungen hatten sich eigentlich nicht verändert: Die Entwicklung der Screens sollte ein Software Engineer, der halbwegs die laufenden Technologien beherrscht, in angemessener Zeit umsetzen können.

Ein weiterer Versuch mit JSF2
No way. Um diesen Blog abzukürzen möchte ich mich kurz fassen. Nach Flex (und FlexBuilder) hatte ich mit Eclipse und dem XML-Editor (mit XML-Tag completition) das Framework nachgebaut. Sprich: Basis-Framework (Web Projekt) und pro Modul (CORE, COMMON, TMS, WMS) das entsprechende Web-Projekt. Verwendet hatte ich diesesmal die PrimeFaces Komponenten-Bibliothek in Version 3.2. Ergebnis: Es ist immer noch sehr sehr zeitaufwändig, Dialoge mit JSF umzusetzen. Ich kann einem Software Engineer (nicht zu vergessen: der eigentlich projekt-spezifische Business-Screens implementieren möchte) diese Technologie in Version 2.1 nicht in die Hand geben - das Budget würde bei Weitem überzogen werden.

Hin und wieder hatte ich auch mal das sehr vielversprechende Vaadin Framework angeschaut. Leider ist hier die Integration in Applikations-Frameworks weniger gut gegeben. Dependency Injection funktioniert eben nur unter Krämpfen und Umwegen. Ebenso ist die Integration eines Security Mechanismus sehr aussenstehend. Wer eine einfache Seite nachbauen möchte, die einen Image-Button beliebiger Grösse beinhalten soll und dieser Button zudem noch einen Mouseover-Effect bietet dem sei dieses CSS von der Original Vaadin Page angetan (bitte unten weiterlesen):

.toolbar .v-button {
      display: block;
      height: 55px;
      background: transparent;
      border: none;
      text-align: center;
}
 
.toolbar .v-button img {
      display: block;
      margin-left: auto;
      margin-right: auto;
      margin-bottom: 5px;
}

.toolbar .v-button span {
      font-size: x-small;
      text-shadow: #fafafa 1px 1px 0;
}

.toolbar .v-button .v-button-wrap, 
.toolbar .v-disabled.v-button .v-button-wrap {
   background: transparent;
   border: none;
   -webkit-border-radius: 0;
   -moz-border-radius: 0;
   border-radius: 0;
   -webkit-box-shadow: none;
   -moz-box-shadow: none;
   box-shadow: none;
}

.toolbar .v-button:active .v-button-wrap,
.toolbar .v-button.v-pressed .v-button-wrap {
   background: transparent;
   -webkit-box-shadow: none;
   -moz-box-shadow: none;
   box-shadow: none;
}

CodeLympics 2012
Zu diesem Projekt hatten wir uns zu Viert arrangiert. In 4 Wochen, innerhalb 3 Sprints und 3 Demos vor einer Jury eine Web-Anwendung zu entwickeln die:
- sexy, intuitiv und rich sein soll,
- reliable und robust sein soll
- ohne Browser Plugin auskommt
- und im IE8 laufen soll
aber weder
- wartbar
- noch langlebig
sein soll
Also Rapid Application Development. Die Wahl auf PrimeFaces 3.2 stellte sich als Blamage heraus, da wegen Problemen mit JavaScript, jQuery und & Co. das alles nicht lief.

Technologien wie JavaFX nehme ich hier bewusst nicht in Betracht, da zum Ersten widerum eine "Sandbox" verwendet wird, zum Zweiten keine ordentliche Toolunterstützung vorhanden ist und zum Dritten keine besondere Stabilität bzgl. der Wartbarkeit in Betracht auf vorgängige Versionen vorhangen ist (man vergleiche v1.1, v1.2 und v2.0).

Dienstag, 15. Februar 2011

Technische Dokumentation

Teilen
Ein weiteres Leid...
Zu Anfang begann ich Spezifikationen/Systementwürfe in Word95/97 zu schreiben, die viele Entwickler nicht kümmerten und keiner las. Heute sind wir im Jahre 2011 und ich schreibe immer noch technische Dokumentation in Word 2003/2010. Diese Art der Niederschrift technisch, fachlicher Inhalte hat meist ein Problem, dass sie mit sinkendem Abstraktionsgrad sehr stark der eigentlichen Umsetzung hinterherhinkt.

In openwms.org begann ich zu Anfang meine Doku mit OpenOffice Document Format zu schreiben, was sicherlich Word gleichberechtigt ist, allerdings war das eigentliche Problem damit nicht gelöst, da diese Doku immer noch zu weit weg vom eigentlichen Code.

Daher hab ich mir angesehen wie die Spring/JBoss Community ihre Doku schreibt und war davon direkt überzeugt.

Die Dokumentation von openwms.org wird ausschliesslich in DocBook Format geschrieben, passend zum aktuellem Release der Software und generiert durch die Zuhilfenahme von Apache Maven. Als nettes Feature wird sie natürlich in den gewohnten Formaten HTML/HTML-SINGLE und PDF generiert und ist stets für jede Release Version verfügbar.

Das Ganze mit Maven und DocBook zu bauen war etwas tricky, aber machbar :-)

Wer sich also hinsichtlich technischer Dokumentation frei bewegen kann sollte sich einmal DocBook (aktuell in Version 5) und den super Editor XMLMind ansehen. Und wer dann noch mehr wissen möchte wie man mit Maven das alles zu "Papier" bringt sollte nicht zögern und mich anschreiben...

Montag, 14. Februar 2011

Immer diese Qual mit der IDE

Teilen
Was ich seit Jahren immer wieder mit Bedauern feststellen muss ist, dass viele Entwickler sich mit der IDE und deren Konfiguration rumschlagen bevor eine Zeile Code geschrieben werden kann. Aus meiner Erfahrung spreche ich über meine Lieblings Java IDE, die Eclipse Umgebung (die wirklich sehr gut ist).

Es beginnt, wenn Plugins installiert werden müssen und dies nicht in der Standardinstallation sondern in einer partiellen Installation der Plugins erfolgt, danach natürlich auch das Konfigurieren der Plugins usw.

Als ich einst den Task hatte, für diesen Prozess eine "Installationsanweisung in Word" zu schreiben, so in der Form ... Download File from here ... Click "Windows->Preferences" habe ich mich wehement dagegen gewehrt. Zudem habe ich bei openwms.org gesehen, dass es für viele Leute einen echten Aufwand bedeutet Eclipse mit speziellen Plugins zu installieren und zu konfigurieren. Nicht umsonst gibt es die sogenannte "Eclipse Distros" die eben eins zum Ziel haben, ein zielgerichtetes Eclipse auszuliefern, für Spring, php oder andere.

Aber das war ja nur der Anfang :-)

Was mich bei Eclipse immer noch störte, ist die Abhängigkeit des Eclipse Workspace zu der lokalen Installation. Manche Einstellungen (Formatter, Templates) lassen sich problemlos ex-und importieren aber eben nicht alle Workspace Einstellungen, somit bleibt der Workspace immer spezifisch zur Installation.

Nicht so mit der OpenWMS.org IDE. Hierbei handelt es sich um einen IzPack Installer der für die gängigsten Umgebungen verfügbar ist und die Installation eines angepassten Eclipse und dessen Workspace vereinheitlicht vornimmt. Dabei werden beide Produkte für den Entwickler und dessen Environment angepasst.

Der Installer führt durch einige wenige Menüs. Neben den Standard Dialogen gibt es auch ein Formular welches zur Eingabe von Benutzerinformation zwingt, diese wird lediglich in den Code Templates des Workspace verwendet. Die Schritte des Installers sowie die Anpassungen möchte ich nun kurz erklären.

Diese angepassten Code Templates haben zur Folge, dass z.B. das Erstellen einer neuen Klasse immer den File Header hat:

/*
* openwms.org, the Open Warehouse Management System.
*
* This file is part of openwms.org.
*
* openwms.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* openwms.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software. If not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/

/**
* A MyClass.
*
* @author Heiko Scherrer
* @version $Revision: $
* @since 0.1
*/
public class MyClass {


Welcome Screen:

Initial Screen mir einigen Infos über die Version des Installers.

License Screen: Listet alle Lizenzen die akzeptiert werden müssen. Ist nichts anders als bei der manuellen Installation ...User Input: In diesem Screen wird (SVN-) Benutzername, sowie Vor und Nachname und die Email abgefragt. Diese Informationen werden ausschliesslich dazu verwendet um den Header von neuen Java Typen mit den Author Infos zu füllen (Beispiel siehe oben):


Und zu guter letzt die Auswahl der zu installierenden Packs, sprich Eclipse und/oder Workspace:


Und warum das alles? a) Um den Aufwand der manuellen Installation zu sparen, b) um ein einheitliche Entwicklungsumgebung zu haben, welche nicht nur die Formatter und Codetemplates integriert sondern auch noch anderes:

Umfang:
----------
+ Eclipse Helios SR1, JEE Version
+ für Win32, Win64, Linux32, Linux64, Mac64 (weil ich auf allen entwickele ;-)

Plugins:
----------
Checkstyle, Spring IDE, M2Eclipse, Subclipse/Subversive (je nach Platform), Flex Formatter, AIR Gear Plugin

+ Checkstyle auf Remote Rules: http://openwms2005.sourceforge.net/rules/checkstyle/checkstyle.xml, integrated into develop & built lifecycle
+ Customized view layout (Java, Console, Servers, Tasks, ... )

General/Startup and Shutdown
--------------------------------------
+ Disable Usage Data Collector
+ Disable Subclipse Usage Reporting
+ Disable Spring IDE User Agent Analysis Integration
+ Uncheck "Confirm exit when closing the last window"

Usage Data Collector
-------------------------
+ Disable

General/Editors/Text Editors
------------------------------------
+ Insert (4) Space for tabs
+ Show Line Numbers
+ Spelling: User dictionary: "${workspace_loc}/.metadata/user_dictionary" (own dictionary from glossary!!)

General/Editors/File Associations
-----------------------------------------
+ Change default for .mxml to XML Editor

General/Content Types
----------------------------
+ Choose Text->XML and add "*.mxml"

Team/SVN/Label Decorations
------------------------------------
/Text Decorations:
- Remove Outgoing and Added flag
/Icon Decoration:
- Mark all

XML/XML Files/Editor
-----------------------------
- Line Length: 120
- Ident using spaces: 4

XML/XML Catalog
-----------------------
+ Click Add... and add the Flex3.xsd file to user catalog (for better MXML hacking ;-)

Web/HTML Files/Editor
------------------------------
- Line Length: 120
- Ident using spaces: 4

Web/CSS Files/Editor
---------------------------
- Line Length: 120
- Ident using spaces: 4

Validation
-------------
For Manual and Build only activate:
Classpath, DTD, JPA, WAR, XML Schema, XML

FlexFormatting
-------------------
Main page: Use Spaces
Load flexformatter.properties
Auto Format AS Files on Save

Java/Code Style
-------------------
Import custom Codetemplates
+ Mark "Automatically add comments for new methods and types"
Import custom Code Formatter settings

Java/Editor/Templates
----------------------------
Import custom templates
like:
"ulog" (use logger) is...
if (logger.isDebugEnabled()) {
logger.debug("");
}
fix:
// FIXME [your name] :
todo:
// TODO [your name] :
chk (for code reviews):
// CHECK [your name] :

Developers have to check their own tags only instead of having >100 tags with no author!

... and many more code templates

Java/Editor/Save Action
------------------------------
+ Enable Format source code/Format all lines
+ Organize Imports
Additional Settings:
+ Remove unused imports
+ Add missing @Override annotations
+ Add missing @Deprecated annotations
+ Remove trailing whitespaces in all lines
+ Correct indentation

Add Java/Compiler/Task Tag
------------------------------------
Tag: CHECK (Normal)

Maven
--------
+ Mark download sources and javadoc
+ Open always XML editor
+ Show advanced tabs

AIR GEAR
-------------
+ Set FLEX SDK to : ${FLEX_SDK}
/Format:
+ Choose Tab Policy : Space only, intention 4


Da Maven in Verbindung mit IzPack eingesetzt wird und die verschiedenen Artefakte über Classifiers gebaut werden empfiehlt es sich einige Workspace spezifische Files nach der Installation von IzPack/Maven anpassen zu lassen:

/workspace-targetplatform/.metadata/.plugins/org.eclipse.wst.xml.core/system_catalog.xml:
/workspace-targetplatform/.metadata/.plugins/org.eclipse.wst.xml.core/user_catalog.xml:
/workspace/.metadata/.plugins/org.eclipse.jdt.launching/libraryInfos.xml:

Dadurch werden hardcodierte JAVA_HOME Pfade ersetzt und andere benutzerspezifische Dinge aufgelöst.

Wer also Lust auf einen Download der IDE hat sollte sich nicht scheuen und schnell unter openwms.org als Developer registrieren.....

Wer wissen möchte wie man sowas mit Maven & IzPack automatisiert baut darf mich gerne anschreiben.

openwms.org - TAKE THE LEAD

Dienstag, 18. Januar 2011

Introduction on Apache Maven2

Teilen
Check out this SlideShare Presentation:

Mittwoch, 4. August 2010

Adobe Cairngorm vs. GraniteDS Tide MVC

Teilen
Wer eine etwas umfangreiche Flex Applikation entwickelt wird früher oder später nicht um ein vernünftiges MVC Framework herumkommen. Man kann sich noch soviel Mühe geben und mittels Code-Behind Pattern Layout von Logik trennen, aber der Einsatz eines MVC Frameworks bringt deutliche Vorteile die man nach kurzer Zeit nicht mehr missen möchte.

Nun gut. Am Anfang der Entwicklung nutzte ich das Adobe Cairngorm MVC Framework welches sehr stark an die alt hergebrachten J2EE Patterns angelehnt ist. Zur Anbindung an das Spring Backend verglich ich BlazeDS mit GraniteDS und habe mich für Letzteres entschieden, was ich bis heute nicht bereut habe.

Tide ist Teil von GraniteDS und als MVC Framework zu gebrauchen. Zusätzlich bringt es noch sehr viel andere nützliche Features (ServerPush/Security etc.) mit. All dies kommt sozusagen mit GraniteDS als nette Beigabe mit.

Kürzlich habe ich entschieden Cairngorm durch Tide zu ersetzen (ein Framework weniger). Die ersten Schritte wurden bereits umgesetzt und es haben sich viele Vorteile als auch einige unschöne Dinge (mit denen man leben kann) gezeigt.

Cairngorm:
Das Prinzip bei Cairngorm ist wie folgt: Teile dem Controller mit, welcher Command bei welchem Event auszuführen ist. Im Command nutze das Business Delegate Pattern und handle den Result in der Command Klasse. Der Delegater nutzt wiederum das ServiceLocator Pattern um das Backend aufzurufen.

Nachteil: Folgt man dieser Vorgehensweise, spürt man recht schnell wie man das DRY Prinzip verletzt. Immer wieder Event and Command binden, usw. Die Anzahl der Command Klassen wächst somit pro Eventtyp. Irgendwie schlecht. Viel zu viel Code für einen einzigen Button Click.

Vorteil: Die IDE als auch der Compiler decken Fehler in der Implementierung auf, da alles typisiert ist.

Tide:
Hier wird Loose Coupling gross geschrieben. Meiner Ansicht nach etwas zu GROSS.
Vorteil: Sehr viel weniger und redundanter Code, schickes MVC Framework, integriert sich gut und nicht zu aufdringlich, d.h. der Code bleibt relativ sauber, wenige Tide Dependencies.

Nachteil:
Observermethoden werden über AS Annotationen markiert. Der EventType ist dabei ein String:
[Observer("ADD_USER")]
public function addUser():void

Das Event wird gemäss Standard geworfen:
dispatchEvent(new UserEvent(UserEvent.ADD_USER));
-> Fehler werden zur Laufzeit sichtbar und sind nicht trivial zu finden. In der IDE ist es nicht möglich Referenzen ausfindig zu machen (nur mit einem file search).

Ähnlich wie bei Spring wird ein Tide Context aufgebaut der die markierten(!) Klassen verwaltet. Eventhandling und Auffindung der Services läuft über diesen Context. Einen Service findet man über eine dynamische Klasse:
tideContext.userService.findAll(onUsersLoaded);
Vertippt man sich stattdessen und schreibt:
tideContext.userervice.findAll(onUsersLoaded);
meckert der Compiler nicht und auch zur Laufzeit tritt kein Fehler auf (dynamische Proxy Klasse)!
Das Java Pendant sieht folgendermaßen aus:
class UserService, Methode: List findAll().

Der Parameter onUsersLoaded ist eine Eventhandler Methode.

Thema Security: Grosse Probleme ergaben sich bei der Nutzung der Spring Security (die von GraniteDS eingerichtet ist) und dem Cairngorm Framework. Cairngorm wrapped auftretende Exceptions und es ist nicht ohne weiteres möglich an die SecurityExceptions von GraniteDS ranzukommen. Mühseelig die Fehlercodes und Texte auszuwerten um an den Cause zu gelangen. Diese Probleme hat man nicht wenn man Tide benutzt!

Alles in allem muss ich aber sagen, dass ich Tide dem Cairngorm bevorzuge zumal ich sowieso GraniteDS benutze. Wer BlazeDS nutzt sollte sich möglicherweise noch andere MVC Frameworks ansehen bevor er sich für Cairngorm oder Tide entscheidet.




Dienstag, 6. Juli 2010

Aber bitte nicht die Katze im Sack

Teilen
Vor einiger Zeit habe ich einen Eintrag geschrieben der ein Komponentenmodell einer OSGi Anwendung darstellt.

Dies war die Theorie - heute die Praxis um zu zeigen, dass hinter einer schönen Fassade auch eine saubere Architektur steckt. Hin und wieder sollte man zu einem Dependency Analyse Tool greifen und die gewünschte Architektur dahingehend überprüfen.

Natürlich fällt die Einhaltung der sauberen Schichtentrennung und einem gerichteten Dependeny Graph in einem OSGi Umfeld mit Maven Build einfacher, als dies bei proprietären Enterprise Applikationen der Fall ist, wo oft nur auf Package Ebene unterschieden wird.
Dann wird die Sache sehr viel schwieriger und sollte dauerhaft (möglichst im CI Build) einem Dependency Check unterzogen werden (JDepend).

Wenige Klicks in der IDE (stan4j) waren nötig um sich aus 15 OSGi Bundles ein klares Bild über die Abhängigkeiten zu verschaffen (Die Packages liegen z.T in unterschiedlichen Bundles):

Donnerstag, 17. Juni 2010

Apropos Bücher

Teilen
Den dollsten Clue habe ich mit dem Kauf eines Buchs von Apress bzgl. JEE6 und GlassFish v3 gemacht. Das war im vergangenen Jahr (als die Spez noch draft war und der Embedded Container noch unbrauchbar).

Das Buch ist sowas von schrecklich! Komplett für Rookies, voller Fehler und selbst die Code-Beispiele zum Download waren unbrauchbar,

Mich hatte interessiert ob ich die Instanziierung des Embedded EJBContainers korrekt gemacht hatte. Damals hatte ich unheimliche Hacks zu verrichten um das Ding mit Maven/Cobertura/Surefire gescheit zum Laufen zu bringen. Auf der Suche nach Hilfe fand ich einen brandaktuellen Eintrag im Forum von Sun. Dieser Eintrag kam von dem Autor des Buches, der ebenso um Hilfe schrie....

Mittlerweile ist der Autor in die Liga der Java Champions aufgestiegen. Ich vermute, dass ein Buch über Java Technologien die letzte Hürde war die es zu meistern galt :-)

Nun denn, dann fangen wir doch mal an Buuuuch zu schreiben ....

Google Books macht mich traurig

Teilen
Sehr sehr schade ...

Ich mag Bücher. Und noch mehr mag ich Fachbücher! Angefangen 1987 mit den Ausgaben des Amiga Magazins (die übrigens immer noch in Umzugskisten verweilen) bis zum heutigen Tag mit ganz tollen Büchern von Apress, Manning oder O'Reilly.

Gute Fachbücher muss man einfach kaufen, da man sie immer und immer wieder liest und stets Neues darin entdeckt. Deswegen sollte auch ein jeder die Arbeit des Autors schätzen und für den Druck das nötige Kleingeld hinlegen.

Nach der Welle der eBooks auf eDonkey, rapidshare & Co. findet man nun auch so manch tolles Werk auf books.google.com. Dieser Trendbewegung stehe ich momentan noch mit einem weinenden Auge gegenüber und weiss nicht Recht ob dies dem KnowHow der Menschheit dienlich ist oder nicht.

Der Erscheinungstermin von DocBook5 ist laut des Verlags O'Reilly schon wieder verschoben. Mittlerweile von Ende Mai auf Juli; wurde mir per Mail bestätigt. Schade, schade, dabei warte ich schon seit Anfang des Jahres (!) auf genau dieses Stück Papier.

Weder ebook, iPad, books.google können in meinem Bücherregal das Papier ersetzen ...

Mittwoch, 16. Juni 2010

OSGi die µSOA!

Teilen
Der Begriff SOA ist sehr geläufig. Dabei handelt es sich lax ausgedrückt um eine verteilte, lose gekoppelte heterogene Struktur von Applikationen die oftmals mittels einer Middleware (z.B. eines ESB) zusammenhängen. Jede dieser Applikationen bieten dabei der SOA ihre Services an.

Nimmt man eine Lupe zur Hand und schaut sich eine Applikation dieser SOA genauer an könnte man möglicherweise eine Applikation ausfindig machen, die auf OSGi aufgebaut ist und dedizierte Services der SOA anbietet.

Die Architektur einer solchen OSGi Anwendung hat gewisse Ähnlichkeit mit einer echten SOA. Alle OSGi Bundles sind autarke Softwarekomponenten die Services veräußern und der OSGi Runtime und damit anderen Bundles anbieten. Alle Komponenten sind dabei ebenso lose gekoppelt und können während des Betriebs aktiviert bzw. deaktiviert werden ohne größeren Schaden auf andere Komponenten auszuüben.

Die oben erwähnte Middleware ist zu vergleichen mit der OSGi Runtime. Ein vernünftiger OSGi Server wie der SpringSource dmServer bietet eine solide OSGi Laufzeitumgebung die keine Wünsche offen lässt.

Zum Thema Verteilung (wenn dies wirklich ein Thema sein sollte): "1st law of istribution is, don't distribute, if you don't and won't have to" (Martin Fowler).

Sollte man dennoch in die Verlegenheit kommen OSGi Services verteilen zu müssen, wäre vielleicht das Projekt R-OSGi der ETH Zürich ganz interessant.

µSOA!

Alles in allem könnte man also eine OSGi Applikation inkl. OSGi Runtime als eine µSOA bezeichnen.

Dienstag, 15. Juni 2010

Business Domain Modelling

Teilen
Ein paar Gedanken zum Entwurf einen Domain Models...

Ich frage mich, wie viele Designer und Architekten den Weg zu einem stabilen Domain Model finden welches losgelöst jeglicher Technologie ist und auf eine lange Zeit Bestand hat?

Nehmen wir einmal den Entwickler als erstes Beispiel: Der Entwickler arbeitet am Liebsten in der IDE seiner Wahl und findet sich am besten in der Sprache seiner Wahl zurecht, welche sich letztendlich in Code ausdrückt. Da er glaubt mit den neuesten Standards und Hypes bewandert zu sein, entwirft er ein super-duper Domain Model in Sourcecode (am Besten OO mit POJOs). Metadaten dürfen im Code natürlich auch nicht fehlen, zumal es die Frameworks ja sogar anbieten (Bsp. JPA Annotationen).

Recht schnell wird ihm klar, dass das Ganze doch recht komplex wird aber es stört nicht weiter, da sich immer noch alles abbilden lässt bzw. er der Macher ist und (mittlerweile als Einzigster) den Überblick behält.

Anforderungen wie Langlebigkeit und Wartbarkeit sind erstmal zweitrangig, auch wenn der JCP bereits einen Draft der Folgeversion vorgelegt hat. Neuen Teammembers dieses monolithische Geflecht einzelner Klassen zu erklären und auch die Notwendigkeit der Beziehungen untereinander aufzuzeigen ist ein Genuss, da er sein Modell kennt und Javadoc sein bester Freund. Nur versteht dies jeder? Versteht dies auch der Business Analyst der die Anforderungen definiert hat? Fraglich...

Phase 2:
Sei es ein Technologiewechsel oder ein Upgrade, es ist Zeit, dass der Macher sein Modell upgraded (denn er versteht es am Besten). Reine Fleissarbeit...

Phase 3:
Neue Anforderungen landen im Jira. Denkbar wäre, dass das Modell (oder Teile davon) in eine WSDL gepackt werden, oder generell in ein Schema, um einem Legacy System anbieten zu können. Also basteln wir kurzer Hand ein XMLSchema und natürlich auch die Parser/Writer dazu. Allerdings sind somit unsere eigentlichen Informationen des Business Models redundant und voneinander unabhängig geworden. Noch schlimmer wird es wenn jemand verlangt abhängig von unserem Modell DAO Code (sei es SQL oder Java) zu erzeugen, also bauen wir uns ein Freemarker Template und die nächste Redundanz ist da.

Das Problem was ich aufzeigen möchte ist folgendes: Ist das Business Model nicht das zentrale Herzstück der Anwendung bzw. des gesamten Unternehmens? Und sollte dieses Modell nicht auch von Stakeholders begriffen werden, die sich nicht in den Tiefen unserer Kodierungssprache bewegen? Sollten wir uns nicht einen Schritt von dem Code wegbewegen und nochmals über die Methodologie nachdenken?

Mögliche Lösungsansätze ohne an Code zu denken:

1) UML: Sicherlich interessant nur Overkill. Ich möchte nicht jedes kleinste Detail mit UML modellieren und immer wieder den One-Way-Generator laufen lassen um zu sehen, dass ich ein perfekter Designer bin und mit dem grünen Knopf mein Modell in Code giessen kann. Dies ist einfach nicht effizient genug und wie erwähnt in den allermeisten Fällen eine Einbahnstrasse.

2) Einfache Modellierungssprachen (wie Ecore/EMF) bieten genug um ein Modell anschaulich darzustellen und begreiflich zu machen. Hat man sein Ecore Modell auf dem Desktop ist es lediglich eine Frage des Generators (bzw. des Templates) um jegliche Anforderungen zu erschlagen. Selbst der Business Analyst wagt sich das Modell zu öffnen und findet sich damit zuerecht. Der Vorteil gegenüber vielen kommerziellen UML Tools liegt in den M2T und M2M Transformationen die ich nach Belieben entwerfen kann um zum Ziel zu gelangen.

Wer also die Problemstellung kennt sollte sich die Geschwister Ecore/EMF/Xpand/Xtext und oAW anschauen. Vielleicht hilft dies weiter...

Montag, 14. Juni 2010

Dienstag, 25. Mai 2010

JSR-303 Bean Validation API

Teilen
Check out this SlideShare Presentation:

Donnerstag, 10. Dezember 2009

DB adé, welcome to the Cloud!

Teilen
Ein Gedanke der mich schon seit Wochen plagt und den ich nun mal aus meinem Kopf haben möchte, daher hier ein Post dazu.

Mit dem neusten Schrei Cloud Computing, Amazon EC2 usw. habe ich mich noch nicht sonderlich befasst, allerdings kam mir direkt eine Idee sowas ähnliches gebrauchen zu können....

Was wäre wenn...ich meine Applikation nicht komplett virtualisieren möchte, da sie ja keine reine Internet Applikation ist, sondern vielmehr eine Intranet Applikation, oder auch aus dem Grunde, dass ich nicht wirklich diesen großen Schritt auf einmal gehen möchte :-)

Zum Problem: Wie oft macht man sich schon beim Entwurf des Domain Modells Gedanken um Performanz. Ist dies in dieser Phase wirklich so berechtigt? Oder sollte man das Geschäftsmodell nicht einfach nach den wirklichen Business Requirements entwerfen und die Performance Leaks im Zuge der Iterationen aufdecken?!

Egal wie, aber im Endeffekt zielt vieles darauf ab, den DB Zugriff zu optimieren, d.h. auch das Domain Model zu verändern (was nicht immer im Sinne des Erfinders ist).

Also wie wäre es, wenn ich mir um die Persistenz (in Form einer DB) keine Gedanken machen müsste?

Wie wäre es wenn ein Freak mit viel Zeit daher käme und mir einen JPA Provider für eine Cloud anbieten würde?

Machen wir uns nicht zuviel Gedanken um Ausfallsicherheit und vollkommenes Data Recovery?

Also nehmen wir mal an, es gäbe da was, was mir eine saubere transaktionale Implementierung der JPA bietet, somit könnte ich diese ohne irgendwelche groben strukturellen Änderungen in meiner Applikation benutzen.

Engpässe wären lediglich im Netzwerk I/O zu sehen - da die Cloud ein SuperB Computer darstellt, der für mich als Anwender kein Nadelöhr in Sachen File I/O ist.

Was ich doch bis dato immer noch nicht verstehen kann, dass ich als Designer des Domain Models Rücksicht nehmen muss, auf irgendwelche alt hergebrachten Misstände der Datenbanken.

Vielleicht muss ich mich auch mit dem Thema Cloud Computing noch etwas mehr auseinander setzen. Als nächstes werde ich mir mal ansehen was das CloudTools Projekt (google hosted) zu diesem Thema beitragen kann und wie sich der Spring dm Server in dieses Environment integriert. So, stay tuned...

OSGI Bundles - The Big Picture

Teilen
Nachdem ich nun lange genug gebastelt habe und einige Umstrukturierungen vornahm, möchte ich mal so zwischendurch ein Overview der verschiedenen OSGi Bundles aufzeigen. OSGi Service Referenzen sind rot markiert und OSGi Package Imports grün. Lediglich der Flex Client nimmt ein zweites Flex Modul während des Kompilierens hinzu (akzeptabel)



Der Flex Client nutzt also die OSGi Service Registry um Services zu finden, die direkte Implementierung übernimmt hier ein anderes Bundle (...spring). Diese Trennung rührt daher, da es in früherer Zeit eine zweite Service Implementierung auf Basis von EJB gab.

Die Service Implementierung nutzt ein Bundle der Integrationsschicht (war dies nicht was mit DAO!?), dies wird ebenfalls über die OSGi Service Registry aufgelöst.

Implementiert wird dieses "DAO" Interface Bundle durch ein Bundle welches JPA nutzt (...integration.jpa). Die DAO Implementierung muss natürlich die JPA Entity Klassen kennen (in common.domain und tms.domain). Der Übersicht wegen sei hier auf die Referenzierung von Services und Client auf diese Bundles verzichtet.

Das Bundle ...integration.jpa ist in sofern interessant, da hier der PersistenceContext (sprich:EntityManagerFactory) erzeugt wird. Es müssen also die Bundles mit den Entity Klassen bekannt sein. Ausserdem braucht die Initialisierung des EM auch eine DataSource (Bundle:infrastructure.postgres) und einen JPA Provider (integration.eclipselink). Diese sind in zwei separate Bundles ausgelagert um sie austauschbar zu halten, JPA kann EclipseLink, Hibernate... sein wobei die DataSource die dahinterliegende DB verstecken sollte.

Was auf diesem Bild nicht eingezeichnet ist, das es nicht in diesem Scope liegt, ist ein Modul der Domain Objekte in ActionScript. Diese Klassen werden aus den Java Domain Objekten generiert und dienen dem Flex Client, haben also keinen direkten Bezug zu OSGi (daher Modul und nicht Bundle).

Montag, 7. Dezember 2009

Signup to EC2 Amazon WS

Teilen
Da ich mir die Sache mit Cloud Computing mal näher ansehen wollte, zog ich in Erwägung mich bei Amazon EC2 anzumelden, allerdings haben mich die Terms of Use etwas verunsichert, wobei ich dies nun erst mal sein lasse, bis ich einen greifbaren Nutzen von dem Ganzen sehe.
Ich werde mal researchen was man so mit CentOS und CloudFoundry anstellen kann und ob ich den AWS Account wirklich brauche...

Dienstag, 2. Juni 2009

RAD mit RIA und "throwaway screens"?

Teilen
Hallo zusammen,

heute möchte ich einmal ein Thema zum Nachdenken geben, was sicherlich den ein oder anderen plagt wenn er an seine schönen Webfrontends vergangener(!) Tage denkt. Ich möchte in diesen Zeit beginnen, als sich noch alles um Servlets drehte und alles voll und ganz aus HTML Rendering bestand. Was kam danach? JSP? Weil man das Problem der Servlets erkannte. Danach? Struts, JSF, ettliche JSF Komponentenbibliotheken inklusive Ajax Support. Irgendwann sollte man sich einmal fragen, tut es Not soviel Energie und Zeit in Screens mit
lästigem CSS Layout und JavaScript zu investieren? Diese womöglich noch mit Firebug zu tracen? Wie oft wird sich die Technologie im Frontend Bereich noch ändern?

Von daher pflege ich den Begriff der "Thowaway Screens", welchen ich eigentlich so genial im Zusammenhang mit Web Controllern fand ("Spring Recipes" von Mak/Apress).

Meiner Meinung nach müsste die Zeit nun vorbei sein, in der man unnötige Zeit mit dem Layout und dem Studieren von Komponenten verbacht hat. Als neuestes Baby habe ich AdobeFlex ausprobiert und bin von diesem Rapid Screen Development völlig begeistert. Die ersten Gehversuche unternahm ich mit BlazeDS zusammen mit dem gleichnamigen Spring Subprojekt. Recht früh bin ich dann zu GraniteDS und Cairngorm umgesiedelt was zusätzliche Vorteile bringt.

Wer also recht fix Webclients erstellen möchte sollte sich dies mal ankucken, wobei für den Anfang Spring BlazeDS sicherlich eine gute Unterstützung darstellt.

Grüßle,

Sonntag, 24. Mai 2009

JPA Entity Klassen in mehreren JAR Filex

Teilen
Also zum Problem, an dem ich nun wieder seit Tagen rumgebissen habe:
Ich habe Entity Klassen in mehreren JAR Files und möchte diese innerhalb einer Webanwendung (WAR) deployen. Das Projektchen ist bzgl. Dependencies ungefähr wie folgt aufgesetzt: entity1.jar, entity2.jar werden von einer Service Layer Implementation service.jar benutzt. Alle drei zusammen werden in einer Flex Webanwendung (könnte auch sonst ein Client sein) benutzt, liegen somit im WEB-INF/lib folder.

Nun ja, soweit eigentlich noch kein Problem, aber wohin mit der persistence.xml? Diese darf natürlich nicht ein einer der beiden entity.jars liegen da sie sonst nur für dieses JAR zählt. Dann die logische Frage: Wer braucht eigentlich alle Entities? Das ist der Service (oder auch Integration) Layer, also dort ins META-INF. Somit funktionierts. Oder auch in WEB-INF/classes/META-INF, allerdings ist dies keine Angelegenheit der Webanwendung itself.

Kleiner Seiteneffekt während der Entwicklung in Eclipse: Man muss natürlich die persistence.xml aus den Domain Object Projekten entfernen, das kann allerdings zu Problemen mit dem Eclipse Dali JPA Validator führen, da der nicht mehr weiss gegen wen oder was er validieren muss.

Dienstag, 21. April 2009

Flex coden mit Eclipse aber ohne Plugin

Teilen
Mühseelig ist es schon auf die Features von FlexBuilder zu verzichten, da ich aber unter Ubuntu Linux arbeite und es kein deb Package gibt und ich mir auch nicht stundenlang die Mühe machen wollte das ganze Teil zu kompileren, habe ich kurzentschlossen das Flex Plugin von Amateras installiert und für die Codevervollständigung im XML Editor von Eclipse das Flex3 XML Schema eingebunden.
Das Schema wird eben leider nicht mit dem SDK geliefert, kann aber natürlich generiert werden. Für die Komponenten des SDK zu haben hier. Und falls jemand für eigene MXML Komponenten ein Schema generieren möchte hier gleich das Eclipse Plugin mit dem dies möglich sein sollte :-).

Geht auch ohne FlexBuilder (zumindest bis noch bis heute ... )

Ach ja, da gibts noch ein ganz ganz leckeres kleines Framework GraniteDS um sich von vorhandenen Domainobjekten die passenden ViewObjekte in AS3 generieren zulassen. Ein Must!

Donnerstag, 22. Januar 2009

Installation svn/javasvn/rapidsvn 1.4.6 auf Ubuntu 8.04/8.10

Teilen
Möchte man eine ältere Version von Subversion auf Ubuntu Hardy Herion oder Intrepid installieren empfiehlt sich folgendes:
  • Die Packages downloaden, nicht mit Synaptic installieren
  • Download und Install der Binaries von libsvn1
  • Download und Install der Binaries von subversion
  • Download und Install der Binaries von libsvn-java
  • Download und Install der Binaries von libsvncpp0c2a
  • Download und Install der Binaries von rapidsvn_0.9.4-3
Danach sollte man mit Synaptic prüfen ob die richtige Version (z.B. 1.4.6) aller Packages installiert ist und diese dann gegen Upgrades sprerren (Lock Version)

Das Paket libsvn-java ersetzt das ältere libsvn-javahl! JavaHL wird bekanntlich für Java SVNClient wie Subclipse benötigt.

Auf keinen Fall sollte man in Versuchung kommen libsvn-javahl installieren. Dies ist ein Dummy Package und upgraded die betroffenen svn Packages auf die neuste Version!

Damit Eclipse die JavaHL Libraries beim Start findet, fügt man
-Djava.library.path=/usr/lib/jni
als vmargs hinzu.

(Getestet auf Intrepid mit SVN 1.4.6 und Eclipse 3.3,3.4)

Relationship Annotations in @Embeddable unzulässig (JPA1.0)

Teilen
Laut JPA 1.0 Specification ist der Gebrauch von Relationships in @Embeddable annotierten Klassen unzulässig, somit ist die Idee von embedded Valueobjects in Entities nur halbherzig durchgezogen worden (... ein fine-grained Domainmodel sollte doch guter Stil sein!?)

Es bleibt also abzuwarten was JPA2.0 in diesem Sinne bringt.

Beispiel:

@Embeddable
public class UserDetails implements Serializable {

@OneToMany(mappedBy ="id") // unzulaessig!!
private Set emails = new HashSet();

...
}

... wäre schön, ist aber nicht. Die @Embeddable annotierte Klasse darf lediglich einfach annotierte Properties (Basic, Column, Lob, Temporal, Enumerated) enthalten (siehe Kap. 9.1.34/JPA1.0 Spec)