Heute geht es um die Navigation in Eclipse Projekten. Über das arbeiten mit Working Sets habe ich ja schon einmal geschrieben, hier möchte ich ein paar grundlegendere Tipps geben:

h3. Resourcen öffnen

Mit Ctrl+Shift+R oder T lassen sich Resourcen (darunter versteht man alle Dateien im Projekt) oder Java-Klassen recht schnell öffnen. Das ist wahrscheinlich nichts neues. Beim öffnen von Java-Klassen gibt es aber einen Trick, und zwar das sogenannte CamelCaseSearching und das funktioniert folgendermassen: Nehmen wir an, wir wollen die Klasse RenameMethodConditionChecker öffnen. Dazu tippt man einfach die Grossbuchstaben, also RMCC, ein — fertig:

Bei unseren Refactorings haben wir meistens dasselbe Namensschema verwendet, es gibt also auch einen InlineClassConditionChecker und so weiter. Dadurch lassen sich die Klassen sehr schnell finden.

h3. Editoren

Mehrere Dateien öffnen sich in verschiedenen Tabs, und das kann mitunter ziemlich unübersichtlich werden. Wenn man häufig wechseln muss bieten sich die zwei Shortcuts Ctrl+F6 und Ctrl+E an. Ctrl+E öffnet das bekannte Menu:

und bei Ctrl+F6 erscheint ein ähnliches Fenster wie man es vom Alt+Tab des Betriebssystems kennt:

Am besten einfach mal ausprobieren!

Wow, habe soeben diese Seite über einen Shape Manipulation-Algorithmus gesehen und bin ziemlich beeindruckt.
Die zwei Autoren haben einen Algorithmus entwickelt und implementiert um Körper bewegen zu können, ohne dafür zuerst eine Art Skelett zu erstellen. Und es sieht ziemlich beeindruckend aus, besonders die Animationen mit einem Multi-Touch Eingabegerät. Unbedingt das Video ansehen oder die Demo ausprobieren, es lohnt sich

Eigentlich schäme ich mich ja fast ein bisschen, so ein Klassiker und ich hab ihn erst jetzt gelesen:

Geschrieben von Kent Beck, einem der hellsten Köpfe unserer Szene (wenn ich das mal so behaupten darf) und wie auch sein Buch über Xtreme Programming sehr kurzweilig und leicht zu lesen. Das Buch behandelt im ersten, grössten Teil das testgetriebene Entwickeln an einem Beispiel und geht zum Schluss noch auf verschiedene Patterns des TDD ein.

Auch wenn man schon test driven entwickelt kann man sich noch ein paar gute Tipps holen, und wenn man sich mit dem Thema noch nicht auskennt ist es ein sehr guter Einstieg.

*Fazit:* Unbedingt lesen!

Gestern beim Finale von You Can Dance gesehen:

Und auch Ebay ist immer mal wieder gut:

Und jetzt wünsche ich noch ein schönes Wochenende!

Heute geht es um einen Bereich von Eclipse, den man eigentlich nur ungern sieht, da man ihn meistens nur bei Problemen braucht: den Debugger. Ich kann mir vorstellen, dass dies auch der Grund ist, weshalb viele den Debugger nur rudimentär beherrschen (Breakpoint setzen, Step-Into und Step-Over) und sich die Zeit nicht nehmen, die vielen Features genauer anzusehen. Dabei würde das schlussendlich auch Zeit sparen und man kann sich besser auf den Fehler konzentrieren.

Im nachfolgenden werde ich auf die verschiedenen Views und Funktionen die ich kenne kurz eingehen und ein paar Tipps geben. Ach ja, ich hab mir mal das “Textile Plug-in”:http://www.textism.com/tools/textile/ installiert und werde in Zukunft auch etwas mehr Formatierungen in den Text bringen

h3. Navigation im Debugger

Die Grundlegenden Kommandos für Debuggen sind wohl Step-Into (die nächste Subroutine), Step-Over (das aktuelle Statement) und Step-Return (aus der Subroutine). Was aber, wenn wir in einen ganz bestimmten Aufruf in einer Reihe verschachtelter Aufrufe steppen wollen?

Nehmen wir an, wir wollen nach findTargetClass steppen. Wir könnten einfach mit einigen Step-Into und Step-Return ans Ziel kommen, einen Break-Point in findTargetClass setzen *oder* wir markieren findTargetClass und steppen mit Ctrl+F5 direkt hinein. Zeit und Nerven gespart .

Was ist, wenn wir mal zu weit gesteppt sind, aber immer noch in derselben Methode sind? Dafür gibts *Drop To Frame*:

Entweder im oberen Bereich der Debug-View oder im Kontextmenus des jeweiligen Stackframes.

h3. Breakpoints

Mit Breakpoints markieren wir die Stellen, an der der Debugger anhalten soll. Es gibt aber mehrere Arten von Breakpoints, wie Exception Breakpoints oder Conditional Breakpoints. Exception Breakpoints lassen sich über das _Run -> Add Java Exception Breakpoint…_ konfigurieren und halten dann den Debugger an sobald eine Exception des konfigurierten Typs eintritt. Sehr praktisch für Null Pointer Exception, da man dem Stacktrace nicht wirklich ansieht, was denn genau null war.

Conditional Breakpoints: Über das Kontext-Menu eines gesetzten Breakpoints lassen sich verschieden Properties setzen, zum einen den Hit-Count, welcher den Debugger nur stoppt, wenn der Breakpoint “Hit”-Mal erreicht wird, und zum anderen die genannten Conditions. Hier sehen wir ein Beispiel, bei dem der Breakpoint nur eintritt, falls der Parameter _test_ ist:

h3. Detail Formatter

Die Variables-View in Eclipse ist ziemlich praktisch um einen Blick auf den Zustand des Programms zu werfen. Im unteren Teil gibt es eine kleine Textbox, welche Informationen (toString()) zum angewählten Objekt anzeigt. Das sieht dann beispielsweise so aus:

Sehr hilfreich sieht das aber nicht aus. Aber natürlich lässt sich das auch ändern: Rechtsklick auf den Listeneintrag -> _New Detail Formatter_ und im Fenster lässt sich dann Code eingeben, der im Kontext des Objekts evaluiert wird:

h3. Display View, Resultate inspizieren

Manchmal hat man, wie im Beispiel weiter oben, verschachtelte Aufrufe und man würde gerne das Resultat eines Aufrufs sehen. Anstatt den Code zu editieren und lokale Variablen zu erstellen, kann man den Ausdruck einfach mit der Maus markieren (Achtung, alle Klammern einbeziehen) und Ctrl-Shift-D drücken. Wenn man danach die gleiche Tastenkombination nochmals drückt, wandert die Selektion in die Display View und man kann den Code noch editieren und weiter evaluieren lassen.

So, das wars soweit, ich hoffe ihr konntet was lernen! Das nächste Thema wird wohl über Plug-Ins sein, die eigentlich jeder zum JDT installieren sollte.

Auch wenn dieses Buch “Pragmatics” im Titel hat ist es ausnahmsweise mal nicht von den Pragmatic Programmers. Dementsprechend ist auch der Umfang eher mit üblichen Informatikbüchern zu vergleichen: Auf gut 800 Seiten wird so ziemlich alles über verschiedenste Programmiersprachen erklärt. Achtung, es geht nicht um die Syntax von Programmiersprachen, deren Beherrschung muss man als Leser schon selbst mitbringen, vielmehr handelt das Buch von Konzepten. Man lernt sehr viel über die Geschichte und Evolution der heutzutage modernen Sprachen und deren Vorgänger.

Angefangen wird mit Scannern und Parsern, danach geht es weiter mit Names, Scopes und Bindings. Hier fing das Buch an richtig Spass zu machen, zum Beispiel beim Thema Dynamic Scoping (ich wusste nicht mal, dass es das gibt). Die nächsten zwei Kapitel fand ich weniger interessant, sie behandelten die semantische Analyse und Mikroprozessorarchitektur. Die nächsten, relativ langen Kapitel behandeln Kontrollfluss und Datentypen. Sehr interessant fand ich die Erklärungen wie alles mit goto began und dann weiterentwickelt wurde, über verschiedene Stufen zu den bekannten Schleifen und Selektionsmöglichkeiten. Sehr schön fand ich die Erklärungen zum Case/Switch-Statement. Dieses Konstrukt dient nämlich nicht bloss zur Vermeidung von unschön aussehenden verschachtelten if..then..else Aufrufen, der Compiler kann damit ziemlich effizienten Code erstellen. Folgender Ruby Code:

case arg
  when 0 then puts "null"
  when 1..5 then puts "one to five"
  when 6, 8 then puts "six or eight"
  else
    puts "else"
  end
end

könnte man auch als Tabelle auffassen:

[0] puts "null"
[1] puts "one to five"
[2] puts "one to five"
[3] puts "one to five"
[4] puts "one to five"
[5] puts "one to five"
[6] puts "six or eight"
[7] puts "else"
[8] puts "six or eight"

arg kann dann einfach als Index in die Tabelle genommen werden. Ziemlich cool, nicht? Grundsätzlich wird das so gemacht, wobei natürlich nicht nur mit Ganzzahlen als Indizes sondern auch mit einer Hashtabelle oder ähnlichem gearbeitet werden kann.

Bei der Behandlung von Typen wird zuerst auf Grundlagen wie Polymorphismus und Type Checking eingegangen, danach verschiedene Typen erklärt (Records, Variants, Arrays, Strings, Sets, Lists, …). Weitere Themen im Buch sind Objekt Orientierung, Funktionale Programmiersprachen, Logische Sprachen und zum Schluss auch sogenannte Scriptsprachen, also Shell-Sprachen, Ruby, Python, Perl, Tcl und so weiter, wobei diese Teile eher kurz sind.

Insgesamt ein wirklich geniales Buch, das eigentlich jeder Programmierer mal gelesen haben sollte. Es kann auch gut als Nachschlagewerk benutzt werden, wenn man mal nicht mehr weiss was z.b. “true iterators” sind oder wie das Typensystem von ML funktioniert.

Ausserdem habe ich schon einige Ideen, welche Programmiersprachen ich als nächstes lernen möchte: Lisp (kann ich schon ein wenig, aber vertiefen wäre schön), Smalltalk (sehr interessante Konzepte) und Haskell (keine imperativen Sprachfeatures). Mal schauen ob ich die Zeit finde!

Kürzlich bin ich über ein interessantes Projekt gestossen: Feedalizer. Feedalizer ist eine kleine Ruby-Library, die ein paar clevere Methoden zum einfachen erstellen von RSS-Feeds von Websites erstellt.

Ich hab das ganze gleich mal angewandt, und zwar für die Website meines Lieblings-Web-Comics Order of the Stick, dessen Autor schon lange einen Feed verspricht, aber bis jetzt keinen anbietet.

Feedalizer nutzt Hpricot zum Parsen der Website, der Code für das ganze sieht folgendermassen aus:

Damit wird der Code dieser Liste geparst und nach allen p-Elementen mit der CSS-Klasse ComicList gesucht. Für jeden Paragraphen wird ein Eintrag im Feed erstellt und mit Link und Titel versehen. Ausserdem interessant ist die letzte Zeile im scrape_items-Block, hier wird die jeweilige Seite des Comics geladen und den Link zum Bild per “//td[@align='center']/img” gesucht.

Fertig ist ein Feed der alle wichtigen Informationen im Titel hat und den Comic in der Beschreibung, so dass der Feedreader es gleich anzeigen kann. Ach ja, wer will, den Feed gibt es, halbstündlich aktualisiert, unter morki.ch/oots.rss.

Hat jemand noch eine Idee, welche Seite man “verfeeden” könnte?

Update
Unterdessen gibt es schon 4 Feeds:

• Order of the Stick
• Erfworld
• Eva
• Dork Tower

So, jetzt ist endgültig fertig mit der Diplomarbeit: Heute Abend hatten wir noch die “mündliche Prüfung”, welche zum grössten Teil aus einer Präsentation und einer kurzen Fragerunde bestand. Das ganze lief ziemlich gut, die Demos haben funktioniert und wir mussten bei den Fragen nie passen.

Wer möchte kann sich die Präsentation natürlich auch anschauen, Powerpoint .ppt und PDF stehen zur Auswahl.

Ich drücke allen die Daumen, die im Laufe der Woche Ihre Präsentation noch haben!

Krass, soeben bei Symlink gelesen und auch gleich bestellt: Hispeed 10000. Das bedeutet konkret 10MBit Download und 1MBit Upload für 65 Franken pro Monat, im Gegensatz zu den jetztigen 6MBit/0.6MBit für 95 gar nicht schlecht Mal schauen wie lange es geht bis umgestellt wird.

Heute habe ich gleich zwei witzige Sachen über C/C++ erfahren, aber am besten gleich ein Beispiel:

main() ??< printf("%c??/n", 1["huhu"]);
exit(0);
??>

Ist das wirklich C-Code? Natürlich Als erstes fallen sicher die Trigraphen auf, welche man anstelle diverser Zeichen schreiben darf. Das aber nur am Rande, interessanter ist der Code: 1["huhu"]Auch das ist gültig, denn der []-Operator braucht einfach einen int und einen array als Parameter, die Reihenfolge ist egal.

Faszinierend, was man über Sprachen, die man seit Jahren kennt, immer wieder neues erfahren kann.