Es wird niemals eine Software geben, die sich eine andere Software anschaut und entscheidet, ob sie etwas bestimmtes macht.
In der theoretischen Informatik gibt es das Halteproblem.
Man kann kein Programm schreiben, das sich ein anderes beliebiges Programm anschaut und nach endlich vielen Schritten erkennt, ob es hält.
(Es kann auch interpretiert werden, aber man hat nicht beliebig Zeit. Wenn ein Programm exakt 10 Jahre läuft, kann man das nicht „testen“, da der Test ja auch 10 Jahren dauert.)
Nehmen wir an es gibt ein Programm
bollean willStop( char[] program )
das entscheidet, ob ein anderes Programm endet.
So sollte folgendes true ergeben:
willStop(„return“);
willStop(„for(int i=0;i<100000000;i++)print(i);“);
und folgendes false:
willStop(„while(true);“);
Eine zweites Methode:
void reverser( char[] program ) {
while ( willStop( program ) )
out.println( „willStop will stop“ );
}
Umgangssprachlich:
– Wenn willStop() true liefert, endet reverser() nicht.
– Wenn willStop() false liefert, endet reserver().
Frage: Was passiert bei folgendem Aufruf?
void reverser( „void reverser(char[]…“ );
Ausgefaltet:
void reverser( char[] program ) {
while ( willStop( „void reverser(char[]…“ ) )
out.println( „willStop will stop“ );
}
Stoppt reserver(), hat willStop(„void reserver…“) aber false gegeben. Aber warum ergibt willStop() dann false? Die Funktion stoppt doch? (Umgekehrtes gilt auch.)
Durch diesen Widerspruch muss die Annahme falsch sein, dass es willStop() überhaupt gibt.
Aus dem Seminar: Codeanalyse mit FindBugs, PMD, Checkstyle und JDepend
Buchkritik “Google Web Toolkit . GWT Java AJAX Programming. A practical guide to Google Web Toolkit for creating AJAX applications with Java”
Prabhakar Chaganti. Packt Publishing. ISBN 1847191002. 15. Februar 2007. 248 Seiten
Didaktisch ist das Buch deutlich besser aufgebaut als GWT in Action, allerdings geht es deutlich weniger in die Tiefe. Während die Autoren ein einfaches Beispiel zur Internationalisierung angeben und dann schreiben „The I18N support in GWT is quite extensive and can be used to support either simple or complicated internationalization scenarios.“ geht hier das Hanson-Tacy-Gespann deutlicher in die Tiefe. Sehr gut gefallen haben mir den praktischen Beispiele, die Ajax so bekannt gemacht hatten, etwa die Listen mit Kandidaten bei eingegebenen Suchbegriffen oder weiteres. Allerdings gibt es auch ein paar Schwachpunkte. Zunächst betrifft es die GWT-Version: das Buch basiert auf GWT RC1 von Ende 2006. So kommen Neuigkeiten aus GWT 1.4 (aktuell ist GWT 2) nicht zur Sprache. Zudem ist die Formatierung oft ungenügend. Es beginnt schon früh mit dem Satz:
When we wish to draw your attention to a particular part of a code block, the relevant lines or items will be made bold:
calendarPanel.add(calendarGrid);
calendarPanel.add(todayButton);
Und dann steht das noch nicht mal in der Einleitung in bold.
Einrückung und Formatierung sind im ganzen Buch sehr merkwürdig. Die Listings besitzen oft am Anfang eine sehr hohe Einrückung, um dann die verbleibenden Zeilen an den unmöglichsten Stellen umbrechen zu müssen. Einige Fehler sind sicherlich nur Unachtsamkeiten. Wie die folgende:
Primitive types—character, byte, short, integer, long, Boolean, float, and double
Primitive type wrapper classes—character, byte, short, integer, long, Boolean, float, and double
Oder dann zeigt ein Screenshot bei den Primzahlenbeispielen eine Zahl in Anführungszeichen, doch im Quellocode steht:
Window.alert("Yes, "+ primeNumber.getText() ...
Es fehlt hier, genauso wie bei der Fallunterscheidung beim No, das einleitende Hochkomma. Bei Konstruktoren ist ein einfaches super();
sicherlich nicht als explizite Anweisung nötig. Einige Kritikpunkte betreffen die Namensgebung. Da heißt dann eine Methode großgeschrieben ShowText()
oder onEventpreview()
. Stilistisch lässt sich vielleicht noch for (; rs.next();)
mit einem einfachen while( rs.next() )
schreiben. Und warum sehe ich das bei so vielen Autoren Felddeklarationen der Art
private String[] items = new String[]{"apple", "peach", "orange", "banana", "plum", "avocado", ...
Wenn es auch einfach nur
private String[] items = {"apple", "peach", "orange", "banana", "plum", "avocado", ...
heißen könnte? Viele Beispiele tragen im Quellcode für die GWT-Komponenten CSS-Zuweisungen wie
searchText.setStyleName(„liveSearch-TextBox“);
Doch die CSS-Datei ist nicht angegeben! Für die Listings hätte das eigentlich auch wegfallen können—hier muss man die Beispiele von CD oder aus dem Internet nehmen. Mit den Styling ist auch eine andere Sache krumm. Statt <img border=’0′ src=’images/blank.gif’/> für eine Tabelle zu schreiben, wäre hier wohl CSS besser, also etwa <img class="border:0" src='images/blank.gif'/>
. Bei den Schaltflächen müssen HTML-Zeichen nicht ausmaskiert werden: new Button("<", this); new Button(">", this);
ist schlicht falsch. In der Abbildung auf Seite 41 taucht plötzlich eine Schnittstelle RemoteServiceAsync
auf. Die angeblich selbst geschriebene Schnittstelle gibt es nicht, das sollte PrimesServiceAsync
heißen. Beim Beispiel mit Auto Form Fill überträgt der GWT-RPC-Service eine HashMap
mit den Daten. Eine interessante Alternative wäre, eine serialisierbare Bean zu deklarieren und diese zu versenden. Da kommt in den Beispielen nirgendwo vor. Platz nehmen recht viel Codeduplikate ein, da der Autor bei den Beschreibungen einen Aufbau gewählt hat, in dem erst der Quellcode als Tue-Dies-Anweisungen aufgeführt wird und später die zentralen Stellen beim Was-haben-wir-eigentlich-gemacht-Teil wiederholt. Das kostet natürlich Platz beim Druck und hätte kompakter ausfallen können. Einige Beispiele geben Beispiele für eine Ajax-Bibliotehk an, die sonst aber nicht so weit verbreitet ist. Eine Sache gibt es sogar, die im Action-Buch nicht steht – und die ich auch dort vermisste habe: wie man Dokumente lädt. Hier ist es: HTTPRequest.asyncGet("customers.csv", new ResponseTextHandler() )
. Eine Auflistung der unterstützten APIs fehlt jedoch auch hier. In der Summe bleibt ein nettes gut lesbares Buch, welches schnell gelesen ist und auch nicht schwer ist.
Buchkritik “GWT in Action. Easy Ajax with the Google Web Toolkit”
Robert Hanson, Adam Tacy. Manning. ISBN 1-933988-23-1. Juni 2007. 632 Seiten
Die Autoren kennen sich mit GWT gut aus und sind selbst an einigen GWT-Komponenten beteiligt (die allerdings nicht sonderlich spektakulär sind). So hat auch Robert Hanson einen Blog unter http://roberthanson.blogspot.com/ und aktualisiert in hin und wieder mit Neuerungen des GWT. Dieses Detailwissen in GWT scheint dem Autor aber an einigen Stellen im Wege zu sein, wenn etwa das CSS-Styling der Komponenten oder der Aufbau eigener Widgets sowie der native Zugriff auf JavaScript (das sogenannte JSNI) noch vor dem GWT-RPC vorgestellt wird, was dann unter Advanced zählt – da gehört für mich eher JSNI hinein, aber viel weniger GWT-RPC. Da das Buch zu einem der ersten GWT-Büchern gehört, gibt es noch einige Bezüge zu GWT 1.3, die stören aber nicht. Offensichtliche Fehler oder Ungenauigkeiten sind mir bis auf eine fehlende Implementierung bei
public static ServerService getInstance();
und der verrückten StringBuffer-„Optimierung“ nicht aufgefallen.
StringBuffer query = new StringBuffer();
query.append(„param1=“ + URL.encodeComponent(value1));
query.append(„&“);
query.append(„param2=“ + URL.encodeComponent(value2));
query.append(„&“);
query.append(„param3=“ + URL.encodeComponent(value3));
String url = „/search?“ + query.toString();
Und so gibt es bis auf die etwas verwirrenden Kapitelreihenfolgen nichts zu bemängeln.
Kapitel 2 und 10 sind online unter http://www.manning.com/hanson/ als PDF verfügbar. Wollen wir hoffen, dass das Buch bald auf GWT 2 gebracht wird. Ich würde wir auch wünschen, dass es ein Kapitel mit einer Vorstellung von Zusatzkomponenten gib, denn die eingebauten GWT-Komponenten sind genauso gammelig wie die AWT-Komponenten. Smart GWT, bzw. Ext GWT sollten auf jeden Fall genannt und beschrieben werden. In der Summe ein gutes Buch, wenn man sich schon mit einfachen Beispielen aus dem Netz mit dem GWT warmgemacht hat und noch mehr Interna lernen möchte.
Java Decompiler: JD, Jad
Der Java-Compilers erzeugt aus der Quellcodedatei eine Klassendatei und der Decompiler dreht die Arbeitsweise um. Decompiler gibt es für die verschiedenen Programmiersprachen und Java gehört zu den Sprachen, bei der die Zurückübersetzung einfacher ist als bei optimierten Maschinenprogrammen, die zum Beispiel ein C++-Compiler erzeugt. Der Grund ist, dass im Bytecode viele wertvolle Informationen enthalten sind, die in herkömmlichen Maschinencode nicht auftauchen. Darunter sind etwa Typinformationen oder Hinweise, ob ein Methodenaufruf virtuell ist oder nicht. Sie sind für die Java-Laufzeitumgebung wichtig und eine große Hilfe, wenn es darum geht, mit einem Decompiler verlorenen Quellcode wiederzubeleben oder an fehlende Informationen aus Paketen von Fremdherstellern zu gelangen.
Ein Decompiler liest die Klassendatei als Bytefeld ein und beginnt mit der Analyse. Da der Bytecode gut dokumentiert ist, ist das Extrahieren von Variablen- oder Methodennamen einfach. Schwierig sind die Anweisungen. Aus dem Java-Bytecode für eine Methode baut ein Decompiler einen Kontrollfluss-Graphen auf und versucht, Anweisungen und Ausdrücke zu erkennen, die bei der Übersetzung bestimmter Sprachkonstrukte entstanden sein müssten. Das ist eine nicht-triviale Aufgabe und immer noch Gegenstand einiger Diplomarbeiten. Und da Variablennamen durch einen Obfuscator eventuell ungültig gemacht worden sind, muss ein guter Decompiler diese illegalen Bezeichnernamen korrigieren und weitere Tricksereien vom Obfuscator rückgängig machen. Diese Umbenennung ändert den Algorithmus nicht, und ein Decompiler hat es bei dieser Art von Verschleierung einfach.
Ist das legal? Lassen wir einen Decompiler auf den eigenen Programmcode los, weil etwa der Quellcode verschwunden ist, dann ist die Anwendung kein rechtliches Problem. Das Reverse Engineering von vollständigen Anwendungen, die unter Urheberschutz stehen, muss nicht unbedingt ein Problem darstellen. Vielmehr beginnt die Straftat, wenn dieser Quelltext verändert und als Eigenleistung verkauft wird.
Da mittlerweile auch andere Compiler auf dem Markt sind, die Java-Bytecode erzeugen – etwa aus EIFFEL-Programmen oder aus diversen LISP-Dialekten –, ist über den Umweg Compiler/Klassendatei/Decompiler ein Crosscompiling denkbar. Hier sind jedoch einige Einschränkungen bezüglich der auf dem Markt befindlichen Decompiler erkennbar. Denn fremde Compiler, die Java-Bytecode erstellen, haben andere Techniken, die der Decompiler dann nicht immer passend übersetzen kann.
Java Decompiler project (JD) und Alternativen
Der Markt an leistungsstarken Decompilatoren ist sehr übersichtlich. Das beste Tool (aber auch nicht ganz fehlerfrei) ist zurzeit JD (http://java.decompiler.free.fr/). Das frei verfügbare – aber nicht quelloffene – Programm ist als Bibliothek JD-Core, als alleinstehende grafische Anwendung JD-GUI und Eclipse-Plugin JD-Eclipse verfügbar. JD selbst ist in C++ geschrieben und benötigt daher keine JVM. JD verarbeitet den Bytecode verschiedener Compiler, wobei das JDK 1.1 bis JDK 6 selbstverständlich mit in der Liste ist, genauso wie der Eclipse-Compiler. (Die Unterscheidung ist nicht ganz uninteressant, da die Compiler sich in machen Details in der Bytecode-Abbildung doch unterscheiden.) JD-GUI ist für die Plattformen Windows, Linux und Mac unter dem Punkt http://java.decompiler.free.fr/?q=jdgui#downloads verfügbar und bietet neben dem Decompileren einzelner Java-Klassen und ganzen Java-Archiven eine angenehme Quellcodedarstellung mit farblicher Unterlegung und Drag & Drop.
Sehr lange war der Decompiler Jad die Referenz. Doch nur von 1997 bis 2001 hat Pavel Kouznetsov das Kommandozeilenprogramm in C++ entwickelt und dann auch 2009 seine Webseite vom Netz genommen. Eine Privatperson hat jedoch die Webseite gespiegelt und unter http://www.varaneckas.com/jad lebt das Projekt (auf unbestimmte Zeit) weiter. Wer Projekte bis Java 1.4 decompilieren möchte, ist mit dem Tool sehr gut bedient. Für Java 5 Projekte hilft JadRetro (http://jadretro.sourceforge.net/) noch ein wenig nach, in dem es Java 5 Bytecode auf Java 1.4 anpasst und kleine Änderungen im Bytecode durchführt. FrontEnd Plus ist eine grafische Oberfläche für Jad, doch auch sie ist vom Internet verschwunden, seit dem es Jad nicht mehr offiziell gibt. Unter http://jadclipse.sourceforge.net/ ist auch ein Plugin für Eclipse erhältlich, dessen Ende aber ebenfalls eingeläutet ist.
Eclipse 3.5SR2 ist raus. Und immer noch diese dumme Fehler drin,…
… nämlich das trotz Bestätigung der Lizenzbedingungen der Next und Finish Button deaktiviert bleibt. Hier bleibt nichts anderes übrig, als es mehrfach zu versuchen bis es klappt. Der Fehler scheint erst in Eclipse 3.6 behoben zu sein.
Links:
Thema der Woche: Java Sicherheit und Angriffe
Zur Vorbereitung
- Suche über die Nutzung von Escape Sequences \uxxxx im Internet und wo sie im Java-Programmcode überall genutzt werden können.
- Lies über die Methode exec() von Runtime und den ProcessBuilder.
- Lies über den Klassenlader und Klassenladehierarchien.
- Mit der Java Compiler API lässt sich ein Java-Programm aus einem anderen Java-Programm heraus übersetzen. Wie sieht die API aus? Seit wann gibt es sie?
http://www.blackhat.com/presentations/bh-usa-09/WILLIAMS/BHUSA09-Williams-EnterpriseJavaRootkits-PAPER.pdf ist ein schöner Artikel, wie Entwickler den Quellcode kompromittieren können, um “böse” Sachen anzustellen. Zwar ist die Information über den Java-Compiler, den der Tomcat nutzt, nicht korrekt, aber Jeff Williams fasst wunderbar verschiedene Angriffsfälle zusammen.
Lies den Text und beantworte folgende Fragen:
- Welcher Annahme im Programm bei “Abusing the JSP Compiler” wird gemacht? Ist das Beispiel realistisch?
- Wie lässt es sich verhindern, dass man private Attribute auslesen kann? Lässt sich das in der Praxis realisieren?
- Was ist BCEL? Seit wann und warum integriert das JDK BCEL?
- Gibt es Unternehmen (in Deutschland), die Code Audits durchführen? Auch von bekannten Open-Source Libraries?
Wer weiter Interesse an dem Thema hast, kann sich http://www.blackhat.com/presentations/bh-usa-09/WEBER/BHUSA09-Weber-UnicodeSecurityPreview-SLIDES.pdf anschauen.
Version 1.3.1 von Google App Engine
- Datastore Query Cursors
- Transactional Tasks
- Support for Custom Admin Console pages
- Java Precompilation is now on by default
- Developers can opt-out of precompilation by setting the flag in appengine-web.xml: <precompilation-enabled>false</precompilation-enabled>
- New built-in support for unit testing (see appengine-testing.jar)
- http://code.google.com/appengine/docs/java/tools/localunittesting.html
- http://code.google.com/p/googleappengine/issues/detail?id=326
- net.sf.jsr107 package included as an alternative to the low-level Memcache API
- javax.annotation.Resource/Resources added to the package whitelist
- New „month“ and „synchronized“ syntax for Cron configuration
- URLFetch supports asynchronous requests
- appcfg.sh uses HTTPS for application deployment
- appcfg.sh adds request_logs –append
- Changes to the order queries without a specified sort order are returned
- Only queries that use IN will see different results.
- Added support for multiple != filters on the same property
- Improved support for keys-only queries when using IN and != filters
- Support for ETags, If-matches, If-not-matches HTTP Headers, as well as 304 status codes now available on static files (not yet available on the dev_appserver or Blobstore blobs)
- Fixed issue where the maximum transform count was enforced for composite operations
- Fixed issue with whitespace on the end of strings in web.xml
- Fixed web.xml <error-page> entries for 404 error codes
- Added validation prevent welcome-files with absolute paths
- Fixed issue where cancelling a deployment in progress could unintentionally corrupt the SDK
- Fixed issue with QuotaService.getCpuTimeInMegaCycles() returning 0
- Fixed issue where JSP exceptions will be incorrectly cast causing a ClassCastException
JDO/JPA Changes
- Child object with custom pk column can’t be saved
- Queries with multiple contains() where one filter is on pk don’t work
- Throw exception when filtering or sorting by pk-id or pk-name fields
- Throw exception when filtering or sorting by pk-id or pk-name fields
- Store child keys in a multi-value property on the parent
- Incorrect exception for multiple fields of same type
- Non-persistent base classes do not work
- Relationships in abstract base classes don’t work
- Explicitly disallow multiple relationships of the same type
- Occasional ArrayOutOfBoundsIndexException
- Support inheritance
- Support != queries
- Support IN queries
- Support datastore cursors
- Inheritance is working for simple fields and embedded fields. Relationships in base classes are completely untested and probably do not work.
- Cannot add child to existing one-to-many if parent has Long or unencoded String pk
- Can’t query by embedded fields at depth > 1
- Positional parameters don’t work (JPQL)
- Throw JDOCanRetryException when ConcurrentMod hit during txn commit
- Respect JDOQL/JPQL case sensitivity for keywords, in particular „count“
- Put all native datastore types in the default fetch group
- Empty Set gets loaded from datastore as null
- Cannot remove element of one to many when parent has pk of type Long or unencoded String
- Severe problem when deleting a child object from an owned relationship (JDO)
- NPE resulting from corrupt JDOQL query
- Embedded, multi-value fields don’t work
Die Unterstützung eines Cursors gehört mit den größten Neuerungen. Zudem listet der Blog-Eintrag http://googleappengine.blogspot.com/2010/02/app-engine-sdk-131-including-major.html auf:
- Datastore Query Cursors – Cursors allow applications to save and ‚bookmark‘ their progress through a query, so that it can be resumed later. This works great in combination with paging URLs, as well as processing in the Task Queue API, but there are many other uses. Watch for an upcoming blog post that explores Cursors in the near future. They’re also really handy in the context of the next change…
- No more 1000 result limit – That’s right: with addition of Cursors and the culmination of many smaller Datastore stability and performance improvements over the last few months, we’re now confident enough to remove the maximum result limit altogether. Whether you’re doing a fetch, iterating, or using a Cursor, there’s no limits on the number of results.
- Reduced error rate with Automatic Datastore Retries – We’ve heard a lot of feedback that you don’t want to deal with the Datastore’s sporadic errors. In response, App Engine now automatically retries all datastore calls (with the exception of transaction commits) when your applications encounters a datastore error caused by being unable to reach Bigtable. Datastore retries automatically builds in what many of you have been doing in your code already, and our tests have shown it drastically reduces the number of errors your application experiences (by up to 3-4x error reduction for puts, 10-30x for gets).

GWT 2.0.1 und GWT 2.0.2
Release Notes for 2.0.2
This 2.0.2 release contains a couple of fixes that were not included in the 2.0.1 release.
Noteworthy Fixed Issues
- Standard.css missing new layout styles (#4429)
- Using a PopupPanel in Internet Explorer without a history IFrame throws a NullPointerException (#4584)
Release Notes for 2.0.1
This 2.0.1 release contains fixes for bugs found in the 2.0.0 release.
Potentially breaking changes and fixes
- Fixed a bug in how code generators collect method arguments from generated source, which impacted the Messages interfaces generated for UiBinder template files. In GWT 2.0, such argument names were incorrectly changed to ARGn. Most GWT applications will be unaffected, but external systems relying on these names will need to be updated.
- The development mode server will, by default, only bind to localhost which will break cross-machine debugging. You can get the old behavior by specifying
-bindAddress 0.0.0.0
. Please see issue (#4322) for more details. For webAppCreator-generated ant files, you can pass this with ant -Dgwt.args="-bindAddress 0.0.0.0" devmode.- The CurrencyList/CurrencyData APIs are now public – if you were relying upon these classes in their non-public location, you should only need to update your imports.
Noteworthy Fixed Issues
- UiBinder Image class with resource attribute, removes styles on that image (#4415)
- Widgets lose focus if its placed on FocusPanel (Opera, Safari) (#1471)
- Remove method in SplitLayoutPanel is broken (#4217)
- Splitter constructor hard codes the background color of the splitter to white (#4335)
- Image should provide method to set alternative text (#4335)
- CssResource cannot parse unescaped ‚-‚, ‚_‘ in class selectors and unknown at-rules (#3946)
- Focusable implementation breaks ScrollPanels in Safari (#1313)
- RequestBuilder restricted to GET and POST (#3388)
- HTMLTable.Cell.getElement() calls getCellFormatter().getElement() with row and column swapped RequestBuilder restricted to GET and POST (#3757)
- MenuBar steals focus when hovered (#3884)
- TabLayoutPanel tabs don’t line up properly on IE (#4447)
- webAppCreator produces ant build files which support the gwt.args property for passing additional flags to the gwtc and devmode rules, such as ant -Dgwt.args="-style PRETTY" gwtc.
See the GWT issue tracker for the complete list of bug fixes and enhancements in this release.
Genau wie andere auch, hatte ich den Bug #3946 gemeldet und freue mich, dass der CSS-Parser nun auch das „-“ für proprietäre CSS-Stile parst.

Einrücken von mit XMLStreamWriter geschriebenen XML-Dokumenten
- http://www.koders.com/java/fidF88DABC620B5E39687C12D2D8DC430C647EB8A74.aspx und
- http://www.koders.com/java/fidCF4610BDDF4735D0241551D1955CF8F238C2FB0D.aspx
auf und dekoriert dann seinen eigenen Stream-Writer:
StringWriter stringWriter = new StringWriter(1024);
XMLOutputFactory factory = XMLOutputFactory.newInstance();
XMLStreamWriter writer = new IndentingXMLStreamWriter( factory.createXMLStreamWriter( stringWriter ) );
writer.writeStartDocument( „utf-8“, „1.0“ );
…

GWT Drag and Drop
Das Projekt unter http://code.google.com/p/gwt-dnd/ gehört mit den zu den bekanntesten Drag & Drop Bibliotheken für GWT. Die von Fred Allen-Sauer geschriebene Bibliothek ist ordentlich mit Beispielen hinterlegt, sodass der Einstieg einfach ist. Ein kleines Beispiel soll die Bibliothek demonstrieren.
a) Nach dem Einbinden der Jar-Datei ist in der XML-Datei für GWT folgendes einzutragen:
<inherits name='com.allen_sauer.gwt.dnd.gwt-dnd'/>
b) Von http://code.google.com/p/gwt-dnd/source/browse/trunk/DragDrop/#DragDrop/war/images nimmt man die Grafik row-dragger-8.gif passend etwa in das WEB-INF/images mit auf und schaut auf den URL-Eintrag in der CSS, dass der Pfad passt.
c) Von http://code.google.com/p/gwt-dnd/source/browse/trunk/DragDrop/#DragDrop/demo/com/allen_sauer/gwt/dnd/demo/client/example/flextable kopiert man die Dateien
- FlexTableRowDragController
- FlexTableRowDropController
- FlexTableUtil
in das eigene GWT-Projekt.
In onModuleLoad() kann es dann so aussehen:
AbsolutePanel panel = new AbsolutePanel();
panel.setPixelSize(450, 300);
panel.addStyleName(„demo-FlexTableRowExample“);
FlexTableRowDragController dragController = new FlexTableRowDragController( panel );
FlexTable table = new FlexTable();
table.addStyleName( „demo-flextable“ );
HTML handle1 = new HTML( „<b>Heinzelmann</b> (100 €)“ );
handle1.addStyleName( „demo-drag-handle“ );
table.setWidget( 0, 0, handle1 );
dragController.makeDraggable( handle1 );
HTML handle2 = new HTML( „<b>Wumme</b> (200 €)“ );
handle2.addStyleName( „demo-drag-handle“ );
table.setWidget( 1, 0, handle2 );
dragController.makeDraggable( handle2 );
HTML handle3 = new HTML( „<b>Fred</b> (90 €)“ );
handle3.addStyleName( „demo-drag-handle“ );
table.setWidget( 2, 0, handle3 );
dragController.makeDraggable( handle3 );
panel.add(table, 10, 20);
FlexTableRowDropController dropController = new FlexTableRowDropController(table);
dragController.registerDropController(dropController);
RootPanel.get().add( panel );
Anschließend haben wir eine Webseite mit
Heinzelmann (100 €)
Wumme (200 €)
Fred (90 €)
wobei wir die 3 Einträge in der Reihenfolge verschieben können.
Dokumentation zur standardisierten Dependency Injection (CDI)
Beschreibt die zweiteilige Dokumentation unter http://www.theserverside.com/tt/articles/article.tss?l=DependencyInjectioninJavaEE6. Die Referenzimplementierung von Contexts and Dependency Injection for Java EE (CDI) ist Weld und auch dort gibt es eine sehr gute Dokumentation. DZone hat auch schon gleich eine Reference Card.
“This is still an issue.” – Bug-Fixes bei Eclipse
2006 habe ich einen https://bugs.eclipse.org/bugs/show_bug.cgi?id=149380 bei Eclipse eingetragen. Heute purzelt mal wieder eine Nachricht rein “This is still an issue.” Wie wahr nach 4 Jahren. Aber vielleicht bin ich einfach zu ungeduldig…
Denormalisierung für schnelle Key/Value Speichersysteme
RDBMS kommen im distributed Cloud-Computing selten vor. Daher muss man auch die Datenhaltung überdenken. Ein Blog-Eintrag diskutiert die Änderungen sehr gut: http://highscalability.com/how-i-learned-stop-worrying-and-love-using-lot-disk-space-scale. Im Prinzip geht es darum, aus Joins zu verzichten, und Daten in den verschiedenen Entities zu duplizieren. Die Erfahrung habe ich bei meinen GWT und GAE/J Projekt ebenfalls gemacht. Es führt zu weniger Lesezugriffen insgesamt, wenn man die Daten lokal in der Entity hält und nicht erst aus verschiedenen Entities zusammensucht, wie man bei normalisierten relationalen Modellen tut. (Außerdem ist es bei vielen lese-Zugriffen auch billiger, die Daten an einer Stelle zu haben, anstatt sie von verschiedenen Stellen über Lesezugriffe, die jeweils Kosten nach sich ziehen, einzusammeln.)
In meinen GWT-GAE/J-Projekt habe ich noch einen anderen Ansatz, die Zugriffe auf die Big-Table zu minimieren. Grundsätzlich: Alle GWT-RPC Implementierungen sind Fassaden, die auf Services zurückgreifen (Googe Guice injiziert diese in die RPC-Fassaden). Für diese Endpoints gibt es dann noch einmal einen Caching-Dekorator als eine Art Caching-Aspekt, der sich wie ein Proxy um die eigentlichen RPC-Implementierungen legt. Diese speichert relevante Daten im MemCache zwischen und minimiert so (langsame) Zugriffe auf die Big-Table. Bei Schreibzugriffen löscht der Caching-Proxy die relevanten Daten aus dem Cache, sodass sie neu geladen werden müssen. Das ist einfach und fix.
Groovy 1.7 und Groovy Eclipse 2.0
Ein paar Tage ist es schon her, da wurde Groovy 1.7 veröffentlicht. Die Neuerungen gibt es unter http://docs.codehaus.org/display/GROOVY/Groovy+1.7+release+notes. Im Wesentlichen sind es die Unterstützung von geschachtelten und anonymen inneren Klassen, ein paar AST-Sachen.
Ganz frisch ist nun das Update der Groovy IDE auf Eclipse Basis. Die Version 2.0 ist fertig und ist nahezu ein vollständiger rewrite. Die News listet http://docs.codehaus.org/display/GROOVY/Groovy-Eclipse+2.0.0+New+and+Noteworthy auf. Weiterhin mit bunten Bildern:
Java 6 Update 18
Die Änderungen http://java.sun.com/javase/6/webnotes/6u18.html sind vielfältig. Zum einen für die Systemkonfigurationen:
- Ubuntu 8.04 LTS Desktop Edition for both JFB and Java SE (x86) in 32-bit
- SLES 11
- Windows 7 support is now available
- Red Hat Enterprise Linux 5.3
Dann:
Im JDK gibt es ein Update der Datenbank
Aus dem Bereich XML:
- JSR-173 StAX 1.2 API Upgrade. In erster Linie JavaDoc Korrekturen aber auch Änderungen, da der richtige Klassenlader nun genutzt wird. http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6861589
Und vieles mehr im Bereich Tuning und Fehlerbehebung.
Thema der Woche: “Sicheres” Programmieren
Studiere im Artikel http://java.sun.com/security/seccodeguide.html die Guidelines 0 bis 5.
Gib für alle einzelnen Tipps ein alternatives Beispiel. (Aufgabe für 2 Wochen.)
Ant 1.8.0RC1 ist auf dem Weg
Ant 1.7 gibt’s ja schon gefühlte ewige Zeit und bei Ant, dem make des 2.0 Zeitalters, steht ein Update ein. Nichts großes, sondern eher Detailverbesserungen:
Apache Ant 1.8.0RC1 is now available for download .
- a new top level element extension-point allows build files to be extended with custom targets more easily
- if and unless attributes will be evaluated according to the values of the properties entered if these properties evaluate to true, false, on, off
- Ant now requires Java 1.4 or later
- new task include provides an alternative to <import> that should be preferred when you don’t want to override any targets
- numerous bug fixes and improvements as documented in Bugzilla and in WHATSNEW
While in open source projects a final release date strongly depends on the free time of the volunteers/committers, the final release is expected one to two months maximum after this RC. So Ant 1.8.0 is expected between mid February and mid March 2010.
Googles erstes Smartphone mit Android 2.1 verfügbar
Mit dem MVP-Modell GWT-Anwendungen entwickeln
Im Quellcode auf der Seite gibt es einige Fehler durch ein falsch verarbeitet <. So steht etwa
public interface Display extends HasValue> {
HasClickHandlers getAddButton();
HasClickHandlers getDeleteButton();
HasClickHandlers getList();
void setData(List data);
int getClickedRow(ClickEvent event);
List getSelectedRows();
Widget asWidget();
}
statt
public interface Display {
HasClickHandlers getAddButton();
HasClickHandlers getDeleteButton();
HasClickHandlers getList();
void setData(List<String> data);
int getClickedRow(ClickEvent event);
List<Integer> getSelectedRows();
Widget asWidget();
}

NetBeans 6.8
Von http://www.netbeans.com/ gibt es eine neue Version, die insbesondere im Bereich des neuen Java EE 6 punktet. Die Neuigkeiten führt http://wiki.netbeans.org/NewAndNoteworthyNB68 auf.