Profil für Klaus M. > Rezensionen

Persönliches Profil

Beiträge von Klaus M.
Top-Rezensenten Rang: 1.449.057
Hilfreiche Bewertungen: 152

Richtlinien: Erfahren Sie mehr über die Regeln für "Meine Seite@Amazon.de".

Rezensionen verfasst von
Klaus M. "java-coder" (Trier)

Anzeigen:  
Seite: 1 | 2
pixel
Implementation Patterns
Implementation Patterns
von Kent Beck
  Taschenbuch
Preis: EUR 30,95

15 von 17 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Neue Verpackung für alten Inhalt, 30. Dezember 2007
Rezension bezieht sich auf: Implementation Patterns (Taschenbuch)
Das vorliegende Werk von Kent Beck ist ein Katalog von Implementation Patterns, d.h. ein Katalog von häufigen Entscheidungen, die Programmierer mehr oder weniger tagtäglich treffen müssen (siehe auch Implementation Patterns - deutscher Sondereinband 978-3827326447).
Das Buch basiert indes im Wesentlichen auf einer (alt-bekannten) Annahme: In der SW-Entwicklung gibt es nur eine Konstante, nämlich sich ändernde Anforderungen. An dieser Stelle setzen die Implementation Patterns an. Da sich die Anforderungen häufig ändern, muss der Code problemlos modifizierbar sein. Eine Modifikation des Codes ist insbesondere dann (einfach) möglich, wenn der Code leicht verständlich und "kommunikativ" ist.

Die Grundidee hinter den Implementation Patterns hört sich also sehr gut an. Die "Patterns" werden dabei meist auf ca. 1-2 Seiten beschrieben und sind thematisch gegliedert in die Bereiche (Kapitel): Class, State, Behaviour, Methods, Collections und Evolving Frameworks.
Allerdings musste ich beim Lesen des Buchs leider feststellen, dass es sich bei den Patterns größtenteils lediglich um altbekannte Vorschläge/Praktiken handelt oder in manchen Fällen sogar nichtmals um Vorschläge, sondern lediglich um Abhandlungen zu bestimmten Konstrukten der Programmiersprache Java (an dieser Stelle sei darauf hingewiesen, dass zur Demonstration einiger Patterns die Programmiersprache Java verwendet wird. Einige Patterns sind aber auch allgemeingültig und unabhängig auf andere Sprachen anwendbar).
Ein Pattern handelt beispielsweise von der variablen Parameterübergabe. Allerdings wird durch das Pattern lediglich vermittelt, dass es die variable Parameterübergabe gibt. Weiterhin wird auch beschrieben, dass es möglich ist innere und anonyme innere Klassen zu verwenden. Dies sind nur einige wenige Beispiele.
Da es sich bei dem Buch allerdings um kein "Lehrbuch für Java" handelt, in dem einem die Grundlagen der Programmiersprache vermittelt werden, habe ich diese Patterns als unnötig und überflüssig empfunden. Insbesondere wurde dort nicht näher betrachtet inwiefern diese Konstrukte die Lesbarkeit beeinflussen oder welche Vorteile/Nachteile der Einsatz dieser Konstrukte hat.

Ferner beinhalten einige andere Patterns bekannte Empfehlungen wie:
- Programmiere gegen eine Schnittstelle, nicht gegen eine Implementierung
- Achte bei der Wahl eines Variablen/Methoden/Klassennamens auf einen aussagekräftigen Namen
- Setze Vererbung nur dort ein wo es sinnvoll ist
- Achte auf Code-Duplikate und kapsele entsprechend mehrfach vorkommende Logik in einer separaten Methode
- etc. pp.

Alles wichtige und brauchbare Empfehlungen, aber leider auch "kalter Kaffee".
An manchen Stellen des Buchs hat Kent Beck auf seine Erfahrungen aus JUnit etc. verwiesen und versucht entsprechend die Relevanz eines Patterns zu veranschaulichen. Von diesen Beispielen hätte ich mir im Buch mehr gewünscht. Gerade jemand wie Kent Beck hätte aus diesem Buch mit Sicherheit mehr machen können. Zudem wären an manchen Stellen größere Beispiele sicher angebracht gewesen.

Ich möchte das Buch aber nicht einfach nur "schlecht machen". Einige vorgestellte Patterns sind durchaus brauchbar. Insbesondere regt das Buch zum Nachdenken über bestimmte Themen an, stets mit der Frage im Hinterkopf: Wie kann ich den Code verständlich machen.
Zudem ließ sich das Buch sehr gut lesen. Dies lag unter anderem an dem gewohnten Schreibstil von Kent Beck und an den jeweils kurzen Kapiteln bzw. Pattern-Beschreibungen.

Alles in allem konnte ich aus diesem Buch leider keine neuen Erkenntnisse ziehen. Einige Patterns erschienen mir überflüssig und die restlichen haben lediglich bekanntes wiederholt. Für einen Programmieranfänger der mit den Themen noch nicht so vertraut ist kann es vielleicht brauchbar sein, für erfahrenere Programmierer nicht. Letztlich erhält das Buch deswegen auch nur 2 Sterne. Der Programmieranfänger der gerade erst mit einer Sprache anfängt gehört eig. nicht zu der typischen Zielgruppe für dieses Buch.


Java EE 5 - Aktuell zur neuen Version, mit Lernkontrolle auf CD: Einstieg für Anspruchsvolle (Master Class)
Java EE 5 - Aktuell zur neuen Version, mit Lernkontrolle auf CD: Einstieg für Anspruchsvolle (Master Class)
von Thomas Stark
  Taschenbuch

1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Einstieg in Java EE, 23. August 2007
Ich habe mir dieses Buch damals u.a. als Vorbereitung auf die Vorlesung "Entwicklung verteilter Anwendungen" gekauft. Darüber hinaus wollte ich einen Einstieg in Java EE finden.

Zunächst einmal muss ich dazu sagen, dass ich nicht das komplette Buch gelesen habe (es aber noch nachholen werde). Das Buch beinhaltet unter anderem Kapitel zu JSP, Servlets, Tag-Bibliotheken, Struts, JSF, JNDI, EJB, JMS, JavaBeans, XML, XSL - XPath & Co. und etwas zu WebServices.

Aus diesem breiten Spektrum folgt natürlich auch direkt, dass die Beschreibungen nicht so tiefgehend sind und lediglich ein Grundverständnis vermittelt wird. Für jeden der mit den oben genannten Begriffen nicht viel anfangen kann und sich einen Überblick über verschiedene Technologien verschaffen möchte, ist dieses Buch auf jeden Fall geeignet. Für genauere und ausführlichere Informationen sollte man dann aber andere Bücher zu Rate ziehen.

Insbesondere die Aufmachung des Buches überzeugt doch sehr und wirkt sehr professionell. Dazu gehören farblich hervorgehobene Kästen mit Tipps etc, zahlreiche gute Grafiken, anders formatierter Quelltext etc. pp. Für manche sind diese Aspekte vllt nicht wichtig, aber es macht einfach deutlich mehr Spaß ein solches Buch zu lesen, als einfach nur alles trist heruntergeschrieben zu sehen.

Mir persönlich hat es geholfen einen Einstieg in die Thematik zu finden. Ich werde sicherlich auch die restlichen Kapitel noch lesen, da der Schreibstil zudem auch verständlich ist.
Jemand der bereits mit den oben genannten Themen vertraut ist und nähere Informationen sucht, wird mit diesem Buch wahr. eher nicht glücklich werden. Jemand der über Grundkenntnisse in Java verfügt und einen Überblick über die Thematik möchte und eine Einführung, der wird mit dem Buch gut beraten sein.
Letztlich auch ein gutes Preis/Leistungsverhältnis!


Ship it!: Softwareprojekte erfolgreich zum Abschluss bringen
Ship it!: Softwareprojekte erfolgreich zum Abschluss bringen
von Jared R. Richardson
  Taschenbuch

4.0 von 5 Sternen Guter Überblick über verschiedene Werkzeuge, Vorgehensweisen etc., 2. April 2007
In diesem Buch versuchen die Autoren die typischen Gründe für das Scheitern von IT-Projekten zu beschreiben und Tipps zu geben, damit man nicht dieselben Fehler macht.

Es gliedert sich im Wesentlichen in drei Hauptbereiche: Infrastruktur, Technik und Prozess. Die Infrastruktur gibt einen Überblick über die wichtigsten Softwarewerkzeuge, allerdings meist nicht ganz konkret (z.B. setzen Sie unbedingt das Produkt X ein oder für den Fall das Produkt Y), sondern auf einer allgemeineren Ebene. Dort empfehlen die Autoren u.a. den Einsatz eines Versionsverwaltungssystems, die Verwendung von skriptbasierten Build-Prozessen, automatischen Build-Prozessen, Bug-Tracking-Systemen etc.

Im Abschnitt Technik beschreiben sie die Aufgaben eines Technischen Projektleiters, die Verwendung einer Liste, die Bedeutung von Reviews, den Sinn von Täglichen Besprechungen, sowie die Verwendung von Änderungsnachrichten. Insbesondere auf die Bedeutung von Täglichen Besprechungen und Reviews wird im gesamten Buch immer wieder verwiesen.

Der Prozess beinhaltet Erklärungen zu einem, von den Autoren verwendeten Vorgehensmodell, welches sich durch hohe Flexibilität auszeichnet: Leuchtspurentwicklung (TBD - Tracer Bullet Development).

Abgeschlossen wird das ganze durch ein Kapitel über häufige Probleme, wie man diese lokalisiert/erkennt und schließlich behebt.

Im Anhang befinden sich nochmals alle Tipps auf einen Blick, sowie Verweise auf konkrete Produkte (die im Text teils nur kurz angesprochen wurden - wenn überhaupt).

Wie man daran erkennt, wird ein recht großes Themen-Spektrum abgedeckt, welches allerdings auf eine - für die Bücher aus der Reihe "Pragmatische Programmierer" typisch - sehr verständliche Art und Weise vermittelt wird.

In den jeweiligen Abschnitten versuchen die Autoren auch den Sinn der jeweiligen Techniken/Werkzeuge zu beschreiben (bspw. warum macht es Sinn ein Versionsverwaltungssystem zu verwenden oder Tests zu automatisieren etc.) Dies gelingt ihnen in der Regel auch.

Darüber hinaus sind die einzelnen Kapitel und Abschnitte gleich gegliedert, d.h. am Ende eines Kapitels "Wie fange ich an?", "Mache ich es richtig?" und "Warnzeichen" - so dass jeder zum Schluss hin das Gelernte noch einmal kontrollieren kann.

Alles in allem hat mir das Buch gut gefallen, allerdings ist es nichts für Software-Entwickler die ganz konkrete Tipps suchen und mit speziellen Problemen konfrontriert sind (da die Aspekte sehr allgemein gehalten sind). Jemand der bereits JUnit, Ant, Maven etc. kennt, wird dem Buch nicht viel Neues entnehmen können. Es eignet sich aber durchaus als Einsteigerwerk, um ein Gefühl für die Materie zu entwickeln.

Bei dem Buch kommt es inhaltlich auch zu einigen Überschneidungen mit anderen "Pragmatische Programmierer"-Werken, z.B. mit "Versionsverwaltung mit CVS", "Projektautomatisierung" etc. Dies ist prinzipiell aber kein Kritikpunkt - das Buch eignet sich neben "Der Pragmatische Programmierer" als guter Einstieg in die Reihe.

Für jeden der bereits CVS/Subversion einsetzt, mit Ant vertraut ist und für den Reviews/Refactoring keine Fremdwörter sind, ist das Buch eher nichts. Für alle anderen, die sich immer gefragt haben warum man Reviews durchführen sollte, warum Versionsverwaltung Sinn macht etc...wird das Buch eine lohnende Investition darstellen.

Da das Buch auch nicht vorgibt für Experten der Software Entwicklung geschrieben zu sein, erhält es von mir 4 Sterne.


Programmieren in Java 1.5: Ein kompaktes, interaktives Tutorial (Xpert.press)
Programmieren in Java 1.5: Ein kompaktes, interaktives Tutorial (Xpert.press)
von Gregor Fischer
  Gebundene Ausgabe
Preis: EUR 9,95

4 von 4 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Kompakte Einführung in die OOP mit Java (5) - Mit einigen Schwächen!, 4. März 2007
Mit diesem Werk geben die Autoren eine kompakte Einführung in die (objektorientierte) Programmierung mit Java. Insbesondere werden nicht alleine die Spracherweiterungen durch das Release 5.0 vorgestellt, diese werden im Text bei passendem Zusammenhang mit eingeführt.

Allerdings betonen die Autoren den objektorientierten Ansatz auf eine etwas gewöhnungsbedürftige Art und Weise. Zum Verständnis der Eigenschaften von OOP sollte zunächst einmal grundsätzliches Wissen (das Fundament) vermittelt werden. Auf diesem aufbauend lassen sich dann auch Klassen, Methoden etc. leicht einführen. Dieses Buch startet allerdings direkt mit "String" und "StringBuffer", zeigt wie Objekte von diesen Typen erzeugt und wie Methoden auf die Objekte aufgerufen werden können. Im Anschluss daran folgen elementare Erläuterungen zur Eingabe/Ausgabe.

Erst danach führen die Autoren überhaupt einmal primitive Datentypen ein.

Das fundamentale Wissen wird zwar vermittelt, allerdings ist der gesamte Aufbau des Buchs zum Erlernen der Sprache nicht gut geeignet, da teilweise Konstrukte verwendet werden, die erst deutlich später erklärt werden, bzw. die man erst deutlich später verstehen kann.

Syntaxdiagramme und UML-Diagramme sollen den Leser visuell unterstützen. Allerdings wird eine deutlich vereinfachte Art von UML Klassendiagrammen verwendet (dies macht allerdings in einem Einsteigerwerk, v.a. am Anfang, auch Sinn). Die Verwendung von Syntaxdiagrammen empfand ich als durchaus gut geeignet, allerdings werden diese bei großen Zusammenhängen schnell unübersichtlich.

Störend war allerdings der "Hang zur konsequenten Übersetzung von Begriffen" der Autoren. Typische Begriffe wie "Call by value" oder "call by reference" wurden nicht verwendet. Stattdessen findet man "Wertsemantik" und "Referenzsemantik". Ähnliche Beispiele sind über das gesamte Buch verteilt.

Was das Thema "Beispiele" betrifft, so muss man dem Buch zugute halten, dass es sehr praxisorientiert ist. Im Text sind immer wieder kleine Programmieraufgaben enthalten, die überprüfen sollen ob der Leser den Stoff auch verstanden hat. Die Lösungen zu den Aufgaben sind ebenso mit enthalten.

Die beiliegende CD enthält nicht nur die Beispiele/Aufgaben, sondern auch eine HTML Version des Buchs, sowie u.a. die Entwicklungsumgebung Eclipse etc.

Bei einem Werk wie diesem, mit einem solchen Titel, betrachte ich als Leser insbesondere ob der Titel des Buchs zum Inhalt passt. In diesem Fall handelt es sich, wie bereits geschrieben, nicht um eine reine Beschreibung der Spracherweiterungen durch Java 5.0. Den Ansatz, die Spracherweiterungen mit den anderen Konstrukten im Text einzuführen, halte ich grundsätzlich für brauchbar.

Im vorliegenden Fall werden die Erweiterungen zwar teilweise eingeführt, aber nicht ausführlich beschrieben. Enthalten sind u.a. static-imports, enums, for-each Schleife und Generics.

Die Erläuterungen zu den genannten Erweiterungen sind größtenteils sehr dürftig und gehen selten über ein Beispiel hinaus.

Insbesondere finde ich es verwunderlich das in einem Buch über Java 5.0 in keinster Art und Weise Annotations erwähnt werden. Auch die variable Parameterübergabe wird nicht beschrieben.

Anstatt die Sprachmittel etwas genauer zu beschreiben, haben sich die Autoren dazu entschieden, u.a. Kapitel über Grafische Benutzeroberflächen (GBO), Applets und Threads in das Buch zu integrieren. Diese drei Themen werden auf insgesamt circa 25 Seiten (!) beschrieben. Danach weiss man als Leser zwar das man GBO's mit Java programmieren kann, bzw. das es Threads gibt, aber mehr auch nicht.

Verbesserungswürdig ist ebenso der Index des Buchs. Dort fehlen u.a. "enum", "for-each" etc. An manchen Stellen entspricht der Index auch nicht dem Buch, bzw. die im Index verwendeten Begriffe sind andere, wie die im Text verwendeten (Beispiel: Default-Konstruktor und Standard-Konstruktor etc.)

Abschließend die positiven Punkte im Überblick:

+ Viele Beispiele

+ CD mit HTML-Version des Buchs

Negativ:

- Unstrukturierter Aufbau

- Erläuterungen zu Annotations, variabler Parameterübergabe etc. fehlen komplett

- Erläuterungen zu anderen Spracherweiterungen in Java 5.0 sind zu kurz

- Im Index fehlen wichtige Begriffe

- "Überflüssige" Kapitel zu Threads, GBO und Applets (betrachtet man den Umfang der jeweiligen Kapitel)

Die genannten Schwachstellen führen zu der Gesamtbewertung von 2 Sternen.


Java 5.0. Konzepte, Grundlagen und Erweiterungen in 5.0
Java 5.0. Konzepte, Grundlagen und Erweiterungen in 5.0
von Vasu Chandrasekhara
  Gebundene Ausgabe

3.0 von 5 Sternen Falscher Titel - Inhalt teils ganz brauchbar, 29. Januar 2007
Als ich mir dieses Buch angeschafft habe, ging ich ursprünglich davon aus, es würde hauptsächlich die Erweiterungen durch Java 5.0 beschreiben.

Leider handelt gerade mal etwas mehr als ein Drittel des Buchs von Java 5.0. Der restliche Teil beinhaltet eine Einführung in Java (z.B. die Sprachkonstrukte bis Version 1.4) , sowie weiterführende Informationen zu beispielsweise XML, RMI, JDBC etc.

Der erste Teil der Rezension bezieht sich auf diesen Teil, mit Informationen zu Java bis Version 1.4.

Prinzipiell spricht sicher nichts dagegen den unerfahrenen Leser in die Java-Programmierung allgemein einzuführen, mit Betrachtung der Erweiterungen durch Java 5.0. Allerdings bezweifle ich den Nutzen für einen absoluten Anfänger, denn für eine brauchbare Einführung wird die notwendige Thematik nicht ausreichend behandelt (ein Blick ins Inhaltsverzeichnis zeigt: gerade mal circa ein Drittel führen den Leser in die Programmierung ein, die restlichen Seiten sind etwas fortgeschritteneren Themen gewidmet).

Ehrlich gesagt habe ich diesen Teil nicht besonders intensiv betrachtet, allerdings fiel bereits da auf das die Autoren nicht viele weiterführende Informationen geben. Dies erklärt den kleinen Umfang dieses Teils.

Darüber hinaus haben die Programmbeispiele nicht alle besonders viel mit objektorientier Programmierung zu tun (Attribute sind beispielsweise teilweise public etc.).

Aus Interesse an dem Thema habe ich dann doch den Teil zu XML komplett gelesen. Dabei wird durchaus ein Verständnis für die grundsätzliche Thematik vermittelt, aber mehr auch nicht. SAX wird beispielsweise auf gerade einmal 1 1/2 Seiten beschrieben. Ähnliches gilt für DOM.

Der Leser kann danach sicher mit einigen Akronymen etwas mehr anfangen, das war es dann aber auch schon.

Umso unverständlicher ist es dann für mich, dass andere Kapitel teilweise "überflüssige" Informationen beinhalten. Im Kapitel zu Collections sind teilweise Sources (zu Bspw. Collection, Set etc.) abgebildet, die man sowieso einsehen kann. Des Weiteren ließen sich andere Informationen ebenso der Java Doku entnehmen (Auflistung der Methoden einer Klasse + kurze Beschreibung was diese machen).

Alles in allem kann ich, was den Teil zu Java bis zur Version 1.4 betrifft, das Konzept und den Aufbau nicht ganz nachvollziehen.

Für Einsteiger ist es unbrauchbar, aufgrund von fehlender Tiefe und fehlenden Erläuterungen zu einigen Bereichen (man betrachte nur mal den geringen Umfang des Teils).

Für Fortgeschrittene ist es ebenso unbrauchbar, da diese keine Informationen zu Schleifen etc. nachlesen wollen. Die durchaus interessanten Bereiche XML, JDBC, RMI etc. werden ebenso dafür zu oberflächlich thematisiert.

Was den Teil des Buchs zur Java Version 5.0 betrifft, so werden die wesentlichen Erweiterungen gut beschrieben: Generics, foreach-Schleife, Autoboxing/Unboxing, enum, variable Parameterübergabe, static imports, metadaten (annotations), sowie ein kurzer Überblick über das Concurrent Package (für Parallele Programmierung), sowie einige Hinweise zu Neuerungen in den Bereichen XML, JDBC, RMI etc.

Die Erklärungen sind verständlich, so dass jeder Java Programmierer mit geringen Vorkenntnissen, die Erweiterungen in Java 5.0 gut erlernen kann.

Abschließend einige allgemeine Dinge zu dem Buch. Man merkt an einigen Stellen das es sich um die erste Auflage handelt. Buchstabendreher, fehlende Buchstaben, teilweise fehlende Teilsätze etc...diese Sachen kann man zwar übersehen, stören aber dennoch. Zudem ist die Formatierung der Quelltexte an einigen Stellen äußerst unschön, da manchmal komplett auf Einrückung verzichtet wurde. Des Weiteren frage ich mich, ob die Autoren schon einmal etwas von Konventionen gehört haben (z.B. werden Methoden-Namen klein geschrieben etc.).

Was Quelltexte betrifft, gibt es bei diesem Buch allerdings auch etwas posiitives: Davon sind viele enthalten. An praktischen Beispielen zu den Themen mangelt es also nicht - das erleichtert das Verständnis der Thematik.

Prinzipiell handelt es sich also durchaus um ein brauchbares Buch, wenn man bereits Java programmieren kann und sich lediglich die Erweiterungen durch die Version 5.0 aneignen möchte.

Darüber hinaus eignet es sich ebenso als Nachschlagewerk (was Java 5.0 betrifft).

Zum Erlernen von Java, bzw. zum Vertiefen der Java-Kenntnisse (für Fortgeschrittene) ist es allerdings nicht geeignet, da diese Bereiche jeweils zu oberflächlich beschrieben werden.

Insgesamt bekommt das Buch deswegen von mir 3 Sterne. Nur der Java 5.0 Teil hätte durchaus mehr verdient, für denjenigen den es interessiert.


My Job Went to India: And All I Got Was This Lousy Book: 52 Ways to Save Your Job (Pragmatic Programmers)
My Job Went to India: And All I Got Was This Lousy Book: 52 Ways to Save Your Job (Pragmatic Programmers)
von Chad Fowler
  Taschenbuch

8 von 8 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Unterhaltsam und lehrreich zugleich, 25. Januar 2007
Chad Fowler beschreibt in diesem Buch die "neue" Situation von Software-Entwicklern, angesichts von dem Begriff "Offshoring". Viele SW-Entwickler sehen sich mit der Gefahr konfrontiert, ihren Job an einen Entwickler aus einem "Billig-Lohn-Land" zu verlieren.

Die Intention des Autors besteht allerdings in keinster Weise darin, eine bestimmte Sicht auf diese Situation besonders positiv oder negativ darzustellen, z.B. die Programmierer aus Indien oder China zu kritisieren. Vielmehr illustriert er die neuen Problematiken anhand von zahlreichen Beispielen und versucht eine Sensibilität für die Probleme zu schaffen.

Insgesamt enthält dieses Buch 52 Ratschläge, jeweils in sehr kurze Kapitel gefasst. Darüberhinaus gefällt mir auch der Schreibstil des Autors sehr gut,

so dass sich das Buch alles in allem sehr gut lesen lässt. Am Ende eines Kapitels sind meistens sog. "Act On It"-Anregungen. Dort

gibt der Autor Aufgaben an den Leser, die aus dem besprochenen Bereich stammen.

Die Tipps sind meist keine ganz konkreten Vorschläge, z.B. "Sie sollten die Programmiersprache XYZ lernen und sich anschließend mit der Technologie ABC befassen".

Es geht vor allem um die Weiterentwicklung eines jeden in verschiedenen Bereichen. Primär sollte jeder Entwickler natürlich über das technische Know-How

verfügen. Doch bereits bei diesem Know-How macht der Autor eins klar: Man sollte sich nicht auf eine bestimmte Technologie verlassen, sondern stets

die Anforderungen des Markts im Auge behalten und gegebenfalls auch neue Technologien erlernen.

Im Generellen sollte das Wissen etwas breiter gefächert sein, so dass man als Mitarbeiter nicht auf einen ganz bestimmten Bereich beschränkt ist.

Ein flexibler Mitarbeiter ist in der Regel für das Unternehmen wertvoller, und darum geht es schließlich.

Das größte Know-How bringt nichts wenn ich damit für mein Unternehmen nicht wertvoll bin, bzw. wenn ich es nicht richtig umsetzen kann.

Jeder sollte also in der Lage sein sich selbst zu "vermarkten". Das technische Know-How ist dabei in gewisser Weise das Fundament für erfolgreiches Marketing.

Der Autor arbeitet auch schön den Unterschied zwischen den tatsächlichen Fähigkeiten einer Person und dem wie

das Unternehmen, bzw. Aussenstehende diese Fähigkeiten wahrnehmen, heraus.

Es geht allerdings nicht lediglich um die "Steigerung des eigenen Marktwerts", denn es gibt Grenzen, die man nicht überschreiten sollte.

Der Autor hebt des Weiteren hervor, dass man darüberhinaus auch in anderen Bereichen seine Persönlichkeit weiterentwickeln sollte. Anstatt jeden Auftrag anzunehmen, um dem Chef zu gefallen, tut ein Mitarbeiter auch gut daran mal Nein zu sagen. Fowler macht klar das dies ein integraler Bestandteil eines Berufs ist. Lernen Nein zu sagen und auch

mit Fehlern richtig umgehen zu können.

Die Reflektion über eigenes Handeln und die Kritik an der eigenen Person, gehört genauso dazu wie seine Stärken nach Aussen zu vermarkten.

Alles in allem ein wirklich interessantes Buch. Die "Weisheiten" sind größtenteils sicherlich keine neuen, aber im Gesamtzusammenhang macht jeder

Tipp Sinn. Manchmal muss man auch auf Banalitäten hingewiesen werden, denn oft sind es diese Banalitäten die wir übersehen oder vergessen.

Das Buch ist sicherlich nichts für jemanden der eine "konkrete Anleitung" sucht, wie er vorgehen muss um sich aus einer misslichen Lage zu befreien.

Aufgelockert wird das Buch zusätzlich durch zahlreiche Anektoden aus seiner Jugendzeit als Jazz-Musiker, bzw. durch Geschichten aus Indien.

Nichtzuletzt hat es meine Sichtweise auf die Situation dort, bzw. auf Offshoring allgemein erweitert.


Pragmatisch Programmieren - Unit-Tests mit JUnit
Pragmatisch Programmieren - Unit-Tests mit JUnit
von Andrew Hunt
  Gebundene Ausgabe

6 von 6 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Gutes Einsteigerwerk - wenig Tiefgang, 18. Januar 2007
Bei diesem Buch handelt es sich um die deutsche Übersetzung des Buchs "Pragmatic Unit Testing In Java With Junit". Das Buch lässt sich gut und flüssig lesen. Ein häufiges Problem bei Übersetzungen besteht ja darin das einfach alles übersetzt wird, auch etablierte Fachbegriffe etc. Dieses Problem besteht im Großen und Ganzen bei diesem Buch nicht,da bei den meisten Begriffen das englische Original verwendet wurde (wobei die deutsche Übersetzung manchmal auch noch mit angegeben wurde).

Nun zum eigentlichen Inhalt. Der Großteil des Buchs handelt allgemein von Unit-Tests, es sollte aber nicht als JUnit-Handbuch betrachtet werden. Die wichtigsten Informationen zu JUnit befinden sich in einem extra Kapitel, wo u.a. die assert-Methoden , setUp(), tearDown() und suite() vorgestellt werden. Genauere , bzw. tiefergehende Kenntnissezu JUnit werden allerdings nicht vermittelt.Anhand von einem sehr einfachen Beispiel versuchen die Autoren anfangs zu zeigen das hinter Unit-Tests keine "Zauberei" steckt,sondern das sie dem Programmierer selbst helfen können Fehler zu entdecken etc.In einem späteren Kapitel demonstrieren Sie ebenfalls anhand von einem Beispiel wie Unit-Tests zur Verbesserung des Designs eines Programms beitragen können.

Der Sinn und Zweck von Unit-Tests wird auch klar, da die Autoren Schritt für Schritt zeigen worauf man achten sollte, was man testen sollte und was eben nicht (ein durchaus wichtiger Aspekt bei Unit-Tests).

Ich hätte mir allerdings noch mehr Beispiele gewünscht.

Alles in allem ein gutes Buch für einen Einsteiger in die Thematik, der erst einmal mit Unit-Tests vertraut werden will und dafür JUnit einsetzen möchte. Wer bereits Erfahrung mit Unit-Tests hat, sollte allerdings wohl zu einem anderen Buch greifen.


Effective Java Programming Language Guide
Effective Java Programming Language Guide
von Joshua Bloch
  Taschenbuch

2 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Pflichtlektüre für jeden Java Programmierer, 9. Januar 2007
Bei diesem Buch handelt es sich definitiv um eine Pflichtlektüre für jeden (angehenden) Java Programmierer.

Es besteht aus verschiedenen Kapiteln, die jeweils einen bestimmten Bereich behandeln. Innerhalb dieser Kapitel existieren verschiedene "Items". (In diesem Fall wäre allerdings eine Übersetzung in "Tipp" bzw. "Empfehlung" etwas besser als die wörtliche Übersetzung in "Gegenstand").

Das Buch umfasst folgende Kapitel: Creating and Destroying Objects, Methods Common to All Objects, Classes and Interfaces, Substitutes for C Constructs, Methods, General Programming, Exceptions, Threads, Serialization.

Die meisten Items betreffen Punkte, die wahrscheinlich jeder halbwegs erfahrene Programmierer bereits schon kennt oder von denen er schon einmal gehört hat. Dazu gehört: Überschreibe hashCode immer wenn du equals überschreibst, bevorzuge komposition, verwende statische factory methoden an den stellen wo es sinn macht etc. pp.

Überdies stellt es für mich auch nicht nur eine Sammlung von Design Patterns da, wie einer der Rezensionen zuvor suggerierte. Zu einem guten Design gehören nun mal auch Design Patterns.

Die meisten Tipps sind allgemein auf die Sprache Java bezogen und beschäftigen sich nicht zu speziell mit einzelnen Teilgebieten. Es sollte also für jeden angehenden Programmierer gut lesbar sein.

Der Aufbau der Items gefällt mir auch gut. Zu beginn wird das Problem geschildert. Übliche Lösungen dazu werden vorgestellt, gleichzeitig damit auch typische Fehler. Zur "schöneren" Lösung eines Problems werden im weiteren Kapitel dann Möglichkeiten vorgeschlagen.

Dies umfasst auch zahlreiche Code-Beispiele.

An manchen Stellen ist das Alter des Buchs erkennbar, bspw. am Kapitel: Substitutes for C Constructs, bzw. insbesondere am Kapitel zu enums. Diese sind, wie wohl jeder weiss, mittlerweile integraler bestandteil von java. (Ein Grund der für das Buch spricht ist zudem der Autor: Joshua Bloch, nicht zuletzt ihm ist es zu verdanken das die enums in der Art aufgenommen wurden).

Alles in allem ein wirklich gelungenes Buch, das sich primär an Java Programmierer mit fundamentalen Programmierkenntnissen richtet.


The Elements of Java- Style (SIGS Reference Library, Band 15)
The Elements of Java- Style (SIGS Reference Library, Band 15)
von Allan Vermeulen
  Taschenbuch
Preis: EUR 13,40

3 von 3 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Gute Idee - Die Umsetzung ist allerdings verbesserungswürdig, 21. September 2006
Die Idee die diesem Buch zugrunde liegt ist durchaus sehr gut. Es geht im Wesentlichen darum, wie der Titel suggeriert, die Elemente zu beschreiben die "guten" Programmierstil ausmachen.

In den ersten Kapitel geht es v.a. um die korrekte Formatierung des Quelltextes, eine einheitliche Namenskonvention u. die Dokumentation des Quelltextes (obwohl ich an dieser Stelle sagen muss das einige Empfehlungen bzgl. dieser Konventionen denen widersprechen denen ich bisher begegnet bin. Bspw. empfehlen die Autoren eine Einrückung von 2 Zeichen etc.)

Die Autoren versuchen dabei in der Regel nicht einfach nur Vorgaben zu machen, sondern sind durchaus bemüht ihre Entscheidungen zu begründen. Das misslingt allerdings an einigen wenigen Stellen wiederum, da manche Tipps etwas willkürlich erscheinen.

Das vorletzte Kapitel beschreibt zudem allgemeinere Programmierhinweise, u.a. bzgl. Synchronisation, Effizienz, Assertions etc. In diesem Kapitel ist dann auch das Alter erkennbar, da u.a. beschrieben wird wie man selbst dafür sorgen kann das Assertions (de)aktivierbar sind, obwohl dies mit Java Mitteln ja bereits (mittlerweile schon länger) machbar ist. Zudem wird bspw. das Double Checked Locking empfohlen.

Alles in allem sollte das Buch für jeden, der bereits einige Zeit programmiert oder sich etwas mit der Materie beschäftigt hat, keine neuen Informationen beinhalten. An manchen Stellen widersprechen die Autoren sogar sich selbst, da sie etwas empfehlen und einige Zeilen weiter drunter gegen ihre eigene vorherige Empfehlung verstoßen.

Überdies beinhaltet es einige unnötige Wiederholungen von Tipps etc.

Im Großen und Ganzen wiederholt das Buch nur das, was bereits in den Java Code Conventions gut beschrieben steht. Es verweist auch auf diese Code Conventions an einigen Stellen.

Alternativ zu diesem Buch empfehle ich (neben den Java Code Conventions) das Buch "Refactoring" von Martin Fowler. Dieses ist natürlich etwas teurer, lässt sich aber ebenso gut lesen, bei deutlich besserer qualität. Zudem beinhaltet es nicht wie dieses Buch nur einige wenige Ansätze, sondern ausformuliert viele hilfreiche Tipps.

Für (absolute) Einsteiger in die Thematik, die aus dem deutschen Sprachraum kommen, kann ich zudem "Der Pragmatische Programmierer" empfehlen.


Der Pragmatische Programmierer
Der Pragmatische Programmierer
von David Thomas
  Taschenbuch
Preis: EUR 39,90

7 von 8 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Schöner Überblick - Teils etwas oberflächlich, 19. Juli 2006
Rezension bezieht sich auf: Der Pragmatische Programmierer (Taschenbuch)
Ich war bereits mit den anderen Büchern aus der "Bibliothek für Pragmatische Programmierer" (Versionsverwaltung mit CVS,Unit-Tests mit JUnit etc.) vertraut und habe auch dieses Buch mit viel Freude gelesen.

Es beinhaltet insgesamt 70 Tipps, die sich auf unterschiedlichste Bereiche der SW-Entwicklung beziehen, sei es nun die Betrachtung der O-Notation zur Abschätzung der Komplexität, die korrekte Dokumentation von Code, die Verwendung von (automatisierten) Tests oder aber die Koordinierung durch Blackboards etc.

Die meisten Tipps behandeln dabei größtenteils bekannte Prinzpien, z.B. DRY (Don't Repeat Yourself), MVC (Model View Controller) oder aber DBC (Design By Contract) etc. pp. Nichtsdestotrotz sind einige Tipps doch ganz hilfreich, v.a. da das behandelte Themenspektrum breit gefächert ist.

Der Nutzen sollte v.a. darin liegen das es sich nicht auf eine spezielle Sprache bezieht und z.B. nur Java oder C++ spezifische Tipps enthält, stattdessen werden verschiedenste kleine Beispiel-Codes mal in Java, mal in C etc. vorgestellt.

Der ein oder andere Tipp ist in der Praxis mit Sicherheit nur bedingt anwendbar, bspw. schlagen die Autoren vor für alles einen einzigen Editor zu benutzen, also für Programmierung, Dokumentation etc. pp. Ein Vorschlag war da z.B. der bekannte Editor "vi". In Zeiten von Eclipse & Co. halte ich diesen Vorschlag allerdings für etwas praxisfern. Hinzu kommt was bereits ein anderer zuvor geschrieben hat: Man ist oft an best. Programme gebunden und kann gar nicht alles mit einem Programm machen.

Auch wenn ich den Nutzen für Fortgeschrittene/Erfahrene SW-Entwickler bezweifle (wie einige Passagen in dem Buch suggerieren), kann ich dieses Buch dennoch jedem angehenden SW-Entwickler empfehlen.

Alles in allem würde das Buch 4 1/2 Sterne bekommen, in diesem Fall runde ich aber mal auf 5 Sterne auf.


Seite: 1 | 2