Display JavaDoc tooltips in Eclipse

Sometimes after installing the JDK and Eclipse, JavaDoc tooltips do not show the Java documentation:

Eclipse not showing JavaDoc in its tooltips

I have experienced this problem quite often, especially with programming students who installed the JDK additionally to an already present JRE. The simple solution is to switch the JRE Eclipse uses in the preferences (you may have to “Add” the JRE included in your JDK first):

Eclipse preferences for changing the current JRE

Now Eclipse should display JavaDoc in the tooltips:

Eclipse showing JavaDoc in its tooltips

Verweis auf mein PowerShell-Script in der aktuellen Ausgabe der hakin9

10. August 2011 um 10:12:01 - Beitrag Nr. 1095
Schlagwörter:

In der aktuellen Ausgabe der hakin9 verweist Hannes Schurig im Rahmen seines Artikels “Manuelle und automatisierte Administration einer Active Directory Domäne und Grundlagen der Gruppenrichtlinien” auf mein kleines PowerShell-Script zum Auslesen von Computern aus einem Active Directory. Danke für die Referenz! :-)

Aber unabhängig von der kleinen Referenz hat Hannes einen interessanten Einführungsartikel in die automatische Administration von AD-Infrastrukturen geschrieben. Von der Installation der Tools, über Vorschläge zur Benennung von Benutzergruppen, der Extraktion der Informationen mit CSVDE und der PowerShell und sogar einer kurzen Einführung in Gruppenrichtlinien sind einige zentrale Aufgabengebiete eines Windows-Administrators abgedeckt. Also durchaus ein lesenswerter Artikel!

Robert C. Martin – The Clean Coder

16. Juli 2011 um 23:04:43 - Beitrag Nr. 1089
Schlagwörter: ,

Uncle Bobs “Clean Code” steht auf meiner Empfehlungsliste sowohl für Programmiereinsteiger als auch für gestandene Softwareentwickler, die ihren Code optimieren wollen, seit dem Tag, an dem ich die ersten Kapitel gelesen habe. Sein Nachfolger, wenn man “The Clean Coder” so nennen will, gesellt sich nun direkt dazu.

Anders als in “Clean Code” geht Robert Martin in “The Clean Coder” nicht auf das Ergebnis der Programmierarbeit – den Code – ein, sondern widmet sich ausgiebig dem Prozess des Programmierens und dem professionellen Verhalten von Softwareentwicklern im betrieblichen Umfeld. Wer also Tipps zur Programmierung oder zur weiteren Optimierung seines Codes sucht, wird definitiv enttäuscht. Wer jedoch auf der Suche nach Lösungen oder Handlungsempfehlungen für häufige Probleme im zwischenmenschlichen Bereich der Softwareentwicklung (“Soft Skills”) ist, dem sei “The Clean Coder” wärmstens empfohlen. Zwar geht Martin in eigenen Kapiteln auch (oberflächlich) auf eher technische Themen wie TDD, Code Katas und Teststrategien ein und listet im Anhang noch ein paar wichtige von ihm verwendete Werkzeuge zur Programmierung auf, aber der Großteil des Buches behandelt die effektive Kommunikation mit Kollegen (insb. Managern) und die “Programmiererehre”.

Robert Martin vermittelt seine “Lessons Learned” insbesondere anhand praktischer Beispiele aus seiner eigenen Karriere. Diese teils mehrere Jahrzehnte zurückliegenden Erfahrungsberichte sind sehr unterhaltsam und zeigen, dass sich das Feld der Softwareentwicklung in den vielen Jahren doch weniger stark verändert hat, als man annehmen könnte. Vieles ist auch heute noch genauso gültig wie damals, etwa die häufigen Missverständnisse zwischen Managern und Entwicklern beim Schätzen von Projektdauern oder die Annahme, dass man mit ein paar Überstunden die Deadline schon irgendwie halten kann. Martin macht sich auf Basis der von ihm gemachten Fehler für ein professionelles Verhalten als Entwickler stark, z.B. für das Nein-Sagen zu unmöglichen Anforderungen oder die Verantwortung, sich ständig fortzubilden, und schließt daher das Buch auch mit seiner Definition des “Software Craftsmanship” ab, dessen Verfechter er ist.

Letztlich waren mir viele Forderungen in “The Clean Coder” bereits aus anderen Büchern bekannt oder könnten mit ein wenig gesundem Menschenverstand selbst aufgestellt werden, aber niemand bringt sie so gut und absolut unterhaltsam auf den Punkt wie Robert Martin. Da man die Kernaussagen des Buches auf wenigen Seiten zusammenfassen könnte und Martin an einigen Stellen sogar teilweise komplette Anekdoten wiederholt, um seine Aussagen noch einmal zu unterstreichen, gibt es von mir in der Bewertung einen Punkt Abzug. Aber durch die meiner Meinung nach gut geschriebenen Geschichten und den relativ geringen Umfang des Buches ist es insgesamt leicht und flüssig in ein paar Stunden gelesen und jedem Einsteiger in das Thema “Software Craftsmanship” daher absolut zu empfehlen: Punkte 4/5.

web2bibtex.ps1: BibTeX-Einträge für Onlineartikel aus Fachzeitschriften generieren

Ich pflege mit Zotero eine Liste aller von mir gelesenen Fachartikel. Dazu ist es notwendig, die Metadaten dieser Artikel zu erfassen. Da ich jedoch wenig Spaß daran habe, das für mehrere Artikel pro Woche manuell zu tun, habe ich mir ein kleines PowerShell-Script geschrieben, das aus den Beschreibungen der Artikel auf den Websites der Zeitschriften die verfügbaren Metadaten extrahiert und als BibTeX-Datei ablegt. Diese kann ich dann einfach in Zotero importieren.

Das Script verarbeitet aktuell die Websites folgender Zeitschriften, kann aber sehr einfach durch ein paar zusätzliche reguläre Ausdrücke um weitere Zeitschriften ergänzt werden.

Hier ein Beispiel: Um den Artikel Designing Web Usability 2011: Zur Aktualität des Buch-Klassikers von Jakob Nielsen von Michael Köster zu erfassen, übergebe ich einfach die Adresse des entsprechenden Online-Beitrags an das Script. Es erstellt dann aus den dortigen Angaben die folgende BibTeX-Datei.

Screenshot eines Artikels der objektSPEKTRUM
  1. @article{Köster2011,
  2.  title = {„Designing Web Usability” 2011: Zur Aktualität des Buch-Klassikers von Jakob Nielsen},
  3.  shorttitle = {Köster2011},
  4.  url = {http://www.sigs-datacom.de/fachzeitschriften/objektspektrum/archiv/artikelansicht.html?tx_mwjournals_pi1[pointer]=0&tx_mwjournals_pi1[mode]=1&tx_mwjournals_pi1[showUid]=6905},
  5.  abstract = {Im Jahr 1999, in Zeiten von Netscape und Internet Explorer 4, veröffentlichte Jakob Nielsen seinen Klassiker „Designing Web Usability”. Nielsens klare Sprache haben seinen Namen zu einer Marke werden lassen und die Inhalte seiner Bücher zum einem Element der universitären Curricula. Aber welche Relevanz haben seine Regeln angesichts schneller Browser, neuer Standards, kompilierender Skript-Engines und hoch-verfügbarer Netzverbindungen heute noch? Im Jahr 2011 gibt es eine weit größere Anzahl an konkurrierenden Buchtiteln als damals. Ein erneuter Blick ins Buch erzeugt ein nur in Teilen revisionistisches Gesamtbild.},
  6.  number = {04/2011},
  7.  journal = {objektSPEKTRUM},
  8.  author = {Köster, Michael},
  9.  month = {aug},
  10.  year = {2011},
  11.  pages = {0}
  12. }

Download

web2bibtex.ps1

Excel 2007/2010: Menü Daten (und weitere) komplett ausgegraut

Heute hatte ich das seltsame Problem, dass bei einer Excel-Datei das komplette Menü “Daten” und weitere Funktionen (insb. auch AutoFilter) ausgegraut waren:

Excel 2010: Menü Daten ausgegraut

Die Lösung war so einfach wie seltsam: Es waren zwei Tabellenblätter gleichzeitig ausgewählt (durch Klicken mit gedrückter STRG-Taste):

Excel 2010: 2 Tabellenblätter gleichzeitig ausgewählt

Diese Auswahl wurde auch beim Speichern der Datei mitgespeichert, sodass beim Neuöffnen das Problem immer noch bestand. Sobald man die Doppelauswahl durch Klicken mit gedrückter STRG-Taste auf eines der Blätter wieder aufhebt, geht wieder alles.

Excel 2010: 1 Tabellenblatt gleichzeitig ausgewählt

Oracle: How to call a function from the SQL*Plus command line

23. Mai 2011 um 21:33:32 - Beitrag Nr. 1061
Schlagwörter: , ,

If you would like to verify the result of a function call in Oracle SQL*Plus you could simply include it in a SQL select statement like this:

  1. CREATE OR REPLACE FUNCTION testfunction(testparm IN NUMBER)
  2.   RETURN(testparm);
  3. END testfunction;
SQL> select testfunction(123) from dual;
 
TESTFUNCTION(123)
-----------------
              123
 
SQL> 

Kurz/Rieger: Die Datenfresser

Wer sich (wie ich) schon immer gefragt mal hat, was eigentlich genau das Problem mit dem freigiebigen Umgang mit persönlichen Daten ist, dem empfehle ich aktuell das Buch “Die Datenfresser” von Constanze Kurz und Frank Rieger:

Das Buch hat mir persönlich vor allem die Monetarisierung unserer Benutzerdaten (nicht nur im Internet) sehr anschaulich und gut verständlich erklärt. Womit/wie verdienen Google und Facebook eigentlich ihr Geld? Und was sind die Folgen für die Benutzer, die so freigiebig mit ihren persönlichen Daten umgehen?

Alle wichtigen Bereiche, in denen wir alltäglich unsere Daten preisgeben, werden abgedeckt: allen voran natürlich die ubiquitären soziale Netzwerke, Online-Buchhändler, aber auch (Offline-)Kundenkarten im Supermarkt u.a. Und auch die Daten, die wir preisgeben, ohne es zu merken, sind Thema: z.B. die Bewegungsdaten des eigenen Handys. Außerdem behandelt ein einzelnes Kapitel das (aktuelle) Thema Biometrie und die damit einhergehenden Sicherheitsprobleme.

Kurzum: das Buch bietet einen sehr guten und umfassenden Überblick über die Problematik des Datenschutzes und liefert auch Argumente gegen den alten Spruch: “Ich habe doch nichts zu verbergen”. Und nicht zuletzt die beiden fiktiven Geschichten über ein soziales Netzwerk für Haustiere und unseren (möglichen) komplett digitalisierten Alltag in nicht allzu ferner Zukunft lassen sich flüssig runterlesen.

Was meiner Meinung nach allerdings zu kurz kommt, ist das auch im Untertitel erwähnte “Zurückgewinnen der Kontrolle”. Bis auf wenige (recht offensichtliche) Tipps wie “einfach mal keine Daten angeben” enthält das im Verhältnis zu kurz geratene Kapitel zu diesem Thema wenig Nützliches.

PowerShell: Read user’s groups from Active Directory

Here’s a short PowerShell function to retrieve a list of a user’s groups from Active Directory:

  1. function getADGroups($username)
  2. {
  3.   $root = ([adsi]"").distinguishedName;
  4.   $searcher = new-object System.DirectoryServices.DirectorySearcher($root);
  5.   $searcher.filter = "(&(objectClass=user)(sAMAccountName=$username))";
  6.   $user = $searcher.findall();
  7.  
  8.   $groupNames = @();
  9.   if ($user.count -eq 1)
  10.   {
  11.     $groups = $user[0].Properties.memberof;
  12.     [regex]$regex = "^CN=(.*?),";
  13.     $groups | % {
  14.       $groupNames += $regex.matches($_) | % { $_.groups[1].value }
  15.       };
  16.   }
  17.   else
  18.   {
  19.       write-host "invalid username, result count:" $user.count -foregroundcolor "red";
  20.   }
  21.   $groupNames;
  22. }
  23.  
  24. getADGroups "macke" | % { $_ }

LINQ rules!

6. Mai 2011 um 21:48:37 - Beitrag Nr. 1033
Schlagwörter: , ,

Here’s an example of a small refactoring I did today using LINQ’s features in C#. I had this method that simply constructs a WHERE clause for a SQL statement using an IList of table prefixes:

  1. private string getWhereClauseForTablePrefixes(IList<String> tablePrefixes)
  2. {
  3.     var where = "";
  4.     if (tablePrefixes.Count > 0)
  5.     {
  6.         where += " where ";
  7.         var enumerator = tablePrefixes.GetEnumerator();
  8.         enumerator.MoveNext();
  9.         while (true)
  10.         {
  11.             where += "table_name like ‘" + enumerator.Current + "%’";
  12.             if (enumerator.MoveNext())
  13.             {
  14.                 where += " or ";
  15.             }
  16.             else
  17.             {
  18.                 break;
  19.             }
  20.         }
  21.     }
  22.     return where;
  23. }

So, e.g. for a list containing A and B the method returned where table_name like 'A%' or table_name like 'B%'. Using the Select extension method on IList, the method now looks like this:

  1. private string getWhereClauseForTablePrefixes(IList<String> tablePrefixes)
  2. {
  3.     var where = "";
  4.     if (tablePrefixes.Count > 0)
  5.     {
  6.         where += " where ";
  7.         where += String.Join(" OR ", tablePrefixes.Select(prefix => "table_name like ‘" + prefix + "%’"));
  8.     }
  9.     return where;
  10. }

Simple and concise! :-)

Seven Languages in Seven Weeks (Bruce Tate)

5. Mai 2011 um 17:26:05 - Beitrag Nr. 1045
Schlagwörter: ,

Heute habe ich meine erste Buchrezension bei Amazon geschrieben. Das war schon längst mal überfällig, aber das Buch, um das es geht, war es jetzt auch wirklich wert:

Die Kurzrezension könnte lauten: absolute Leseempfehlung für jeden (objektorientierten) Softwareentwickler :-D

Im Buch beschreibt Autor Bruce Tate sieben (völlig) unterschiedliche Programmiersprachen, die jeweils ein mehr oder weniger eigenes Konzept oder Programmierparadigma verwenden: von Ruby als OO-Sprache mit funktionalen Aspekten, über logische Programmierung mit Prolog bis hin zur reinen funktionalen Sprache Haskell ist alles dabei (wobei der Fokus auf den funktionalen Aspekten liegt). Hier kommt der Langtext meiner Rezension:

Ich habe das Buch, anders als der Autor vorschlägt, nicht gelesen und währenddessen die Programmierbeispiele praktisch ausprobiert (außer bei der ersten beschriebenen Sprache Ruby), sondern direkt runtergelesen, weil ich lediglich einen tieferen Einstieg in (aktuelle) Entwicklungen der verschiedenen Programmierparadigmen (Objektorientierung, funktional, logisch, Prototype) bekommen wollte, ohne diese praktisch anzuwenden. Und dafür ist das Buch wirklich super! Bruce Tate zeigt anhand von sinnvollen Praxisbeispielen mit sehr vielen Quelltextauszügen die Vor- und Nachteile der einzelnen Sprachen (Ruby, Io, Prolog, Scala, Erlang, Clojure und Haskell) auf und geht insbesondere auf die jeweiligen Vorzüge ein, die das Programmieren einfacher machen (syntactic sugar). Für alle, die die Sprachen auch in der Praxis ausprobieren wollen, liefert Tate nach jedem Kapitel Online-Quellen und Tipps für interessante Miniprojekte.

Dabei folgt er einem sehr sinnvollen Aufbau. Bei den ersten behandelten Sprachen werden allgemeingültige Konzepte von Programmiersprachen eingeführt und anhand von Beispielen erklärt (z.B. Pattern Matching, Rekursion, Closures, Futures) und bei den Sprachen im hinteren Teil des Buches wieder aufgegriffen und vertieft. Dabei streift Tate wirklich viele aktuelle Entwicklungen insbesondere aus dem Bereich der funktionalen Sprachen: 5 der 7 Sprachen sind entweder komplett oder in Teilen funktional. Ich kannte bislang von den vorgestellten Sprachen lediglich Prolog, sodass mir das Kapitel hierzu als kleine Auffrischung meiner Kenntnisse diente. Ich war überrascht, wie viele (hilfreiche) Konzepte es aus Prolog inzwischen in andere Programmiersprachen geschafft haben.

Für Anfänger ist das Buch wohl eher schwierig zu verstehen, da nicht lange gefackelt wird und viele grundlegende Kenntnisse vorausgesetzt werden. Für fortgeschrittene Programmierer, insbesondere aus dem Bereich der Objektorientierung, ist es jedoch ein super Buch, um einmal über den Tellerrand zu schauen. Gerade heutzutage, wo die funktionalen Sprachen immer wichtiger werden (aufgrund der guten Parallelisierbarkeit), sollte jeder Entwickler einen Blick riskieren und schauen, welche Konzepte er für seine eigene Arbeit übernehmen kann. Durch die Vielzahl an unterschiedlichen Sprachen wird das Buch definitiv nicht langweilig und man kann es richtig verschlingen.