paper - Business Informatics Group

Transcrição

TU Wien
Business Informatics Group
Institut für Softwaretechnik und Interaktive Systeme
Moderne Softwareentwicklungsumgebungen
Evaluierung Java-basierter Ansätze
Magisterarbeit zur Erlangung des akademischen Grades eines
Magisters der Sozial- und Wirtschaftswissenschaften
eingereicht bei o. Univ.-Prof. Mag. Dipl.-Ing. Dr. Gerti Kappel
mitbetreuender Assistent: Mag. Manuel Wimmer
Michael Wihsböck
Wien, 1. März 2007
Eidesstattliche Erklärung
Ich erkläre an Eides statt, dass ich die vorliegende Arbeit selbständig und ohne fremde Hilfe verfasst, andere als die angegebenen Quellen nicht benützt und die den benutzten Quellen wörtlich oder inhaltlich entnommenen Stellen als solche kenntlich
gemacht habe.
Wien, 1.3.2007
Michael Wihsböck
Danksagung
Ich möchte mich bei o. Univ.-Prof. Mag. Dipl.-Ing. Dr. Gerti Kappel für die Möglichkeit bedanken, dass ich diese Arbeit am Institut für Softwaretechnik und Interaktive Systeme durchführen durfte. Besonderer Dank gilt ebenfalls Mag. Manuel
Wimmer sowie Mag. Michael Strommer für die umfassende Betreuung. Weiters
möchte ich mich bei meinen Eltern für die moralische und finanzielle Unterstützung
während meines Studiums bedanken.
Kurzfassung
In den letzten Jahrzehnten durchlief die Softwareentwicklung eine eindrucksvolle
Evolution. Anfang der 1960er Jahre begann die kommerzielle Softwareentwicklung
mit primitiven Assemblerinstruktionen, kurz darauf folgten bereits die ersten Hochsprachen. In den 1990er Jahren setzte sich schließlich die objektorientierte Softwareentwicklung durch. Nun scheint diese Evolution ihre Fortsetzung durch modellgetriebene Ansätze zu finden. Diese Ansätze versuchen die objektorientierte Programmierung durch grafische Modelle zu ergänzen, und so auch die Software allgemeiner
zu gestalten, um gegebenenfalls auch die eigentliche Programmiersprache ersetzen
zu können. Durch die Arbeit mit diesen neuen Techniken müssen die entsprechenden
Entwicklungsumgebungen zwangsläufig komplexer werden. Reichten zur Entwicklung mit Assembler bzw. frühen Hochsprachen noch ein einfacher Texteditor in
Kombination mit einem Compiler oder Linker, so wurden bei objektorientierten
Sprachen großteils bereits umfangreiche integrierte Entwicklungsumgebungen eingesetzt.
In dieser Arbeit sollen die Möglichkeiten gängiger integrierter Entwicklungsumgebungen anhand eines erstellten Kriterienkatalogs bewertet werden. Die Produkte
werden hinsichtlich ihrer Möglichkeiten in den Bereichen Programmierung, Modellierung, Softwarequalitätssicherung, Erweiterbarkeit und Bedienung evaluiert.
Es wurden bei den Produkten sowohl Vertreter aus dem kommerziellen, als auch
dem freien (Open Source) Umfeld für die Entwicklung mit der Programmiersprache
Java gewählt. Diese Arbeit konzentriert sich bei den Untersuchungen auf die Entwicklungsumgebungen Eclipse 3.2, Netbeans 5.5, JBuilder 2006 und IntelliJ IDEA
6.0. Eine Partnerarbeit, die zeitgleich am Institut von Florian Skopik [Sko07] durchgeführt wurde, beschäftigt sich mit C++/C# Entwicklungsumgebungen. Da der Kriterienkatalog unabhängig von den untersuchten Entwicklungsumgebungen ist, wurde
dieser Teil gemeinsam erstellt und ist in beiden Arbeiten vorhanden.
Abstract
Software development went through an impressive evolution in the last decades. In
the 1960ies the commercial software development started with primitive assembler
instructions, shortly followed by the first high-level programming languages. In the
last decade the object-orientated software development became generally accepted.
Now this evolution seems to find their continuation by model-driven approaches.
These new methods try to do object-orientated programming more general by
graphic models and allow a replacement of the specific programming language.
When working with these new techniques the appropriate development environments
must become inevitable more complex. For the development process with assembler
and early high-level programming languages a simple text editor in combination
with a command line based compiler or link ewer mostly adequate. However, the use
of object-orientated programming languages has lead to quite complex development
environments.
In this work the possibilities of usual integrated development environments are
evaluated on the basis of a provided catalogue of criteria. The products are evaluated
regarding their possibilities within the ranges programming, modelling, software
quality control, extensibility and usability.
Both, product representatives from the commercial and also from the open source
sector, for the development with the programming language Java, were selected.
This work concentrates in its analysis on the development environments Eclipse 3.2,
NetBeans 5.5, JBuilder 2006 and IntelliJ IDEA 6.0. A partner thesis, which was accomplished at the same time at the department by Florian Skopik [Flo06], is occupied with C++/C# development environments. Since the catalogue of criteria is independent of the examined environments, this part was provided together and is present in both works.
Inhaltsverzeichnis
1 Einleitung ........................................................................................................... 1
1.1 Motivation für diese Arbeit .................................................................. 1
1.2 Behandelte Fragestellungen.................................................................. 3
1.3 Gliederung der Arbeit........................................................................... 3
2 Kriterienkatalog.................................................................................................. 5
2.1 Editor .................................................................................................... 5
2.1.1 Codeeditor ................................................................................ 5
2.1.2 User Interface Designer............................................................ 7
2.1.3 Refactoring............................................................................... 9
2.1.4 Sprachunterstützung............................................................... 10
2.1.5 Entwurfsmuster ...................................................................... 11
2.1.6 Aufbau der Arbeitsumgebung ................................................ 11
2.2 Modellierung ...................................................................................... 12
2.2.1 Unified Modeling Language .................................................. 12
2.2.2 Model Driven Architecture .................................................... 14
2.2.3 Forward Engineering.............................................................. 14
2.2.4 Reverse Engineering .............................................................. 15
2.2.5 Roundtrip Engineering ........................................................... 15
2.3 Programmierung ................................................................................. 15
2.3.1 Compiler und Programmiersprachen ..................................... 15
2.3.2 Mitgelieferte Klassenbibliotheken und Frameworks ............. 16
2.3.3 Middleware und Komponentenstandards............................... 16
2.3.4 Klassenbibliotheken und Komponenten von Drittanbietern .. 17
2.3.5 Internationalisierung von Anwendungen ............................... 17
2.3.6 Datenbankprojekte ................................................................. 17
2.3.7 Webentwicklung .................................................................... 18
2.3.8 Entwicklung für mobile Endgeräte ........................................ 18
2.4 Softwarequalitätssicherung................................................................. 19
2.4.1 Debugger ................................................................................ 19
2.4.2 Remote Debugger................................................................... 19
2.4.3 Profiler.................................................................................... 20
Inhaltsverzeichnis
2.4.4 Unit Tests ............................................................................... 20
2.4.5 Quality Audits ........................................................................ 20
2.4.6 Quality Metrics....................................................................... 21
2.5 Erweiterbarkeit der Entwicklungsumgebung ..................................... 21
2.5.1 Einbindung in ein Application Lifecycle Management ......... 22
2.5.2 Zusatzkomponenten von Drittanbietern................................. 22
2.6 Hilfe und Support ............................................................................... 22
2.6.1 Dokumentation des Produkts ................................................. 22
2.6.2 Größe der Community............................................................ 23
2.6.3 Kundenbetreuung durch den Hersteller ................................. 23
2.7 Sonstiges............................................................................................. 24
3 Evaluierung ...................................................................................................... 25
3.1 Eclipse 3.2 .......................................................................................... 26
3.1.1 Allgemeines............................................................................ 26
3.1.2 Bewertung nach Kriterienkatalog .......................................... 30
3.2 NetBeans 5.5....................................................................................... 57
3.2.1 Allgemeines............................................................................ 57
3.3 JBuilder 2006...................................................................................... 84
3.3.1 Allgemeines............................................................................ 84
3.4 IntelliJ IDEA 6.0 .............................................................................. 107
3.4.1 Allgemeines.......................................................................... 107
3.4.2 Bewertung nach Kriterienkatalog ........................................ 108
4 Gegenüberstellung der Produkte .................................................................... 123
4.1 Allgemeine Gegenüberstellung ........................................................ 123
4.2 Gegenüberstellung nach Kriterienkatalog ........................................ 125
4.2.1 Editor.................................................................................... 125
4.2.2 Modellierung ........................................................................ 126
4.2.3 Programmierung................................................................... 127
4.2.4 Softwarequalitätssicherung .................................................. 128
4.2.5 Erweiterbarkeit der Entwicklungsumgebung....................... 129
4.2.6 Hilfe und Support................................................................. 130
4.2.7 Sonstiges .............................................................................. 130
4.3 Übersichtstabelle .............................................................................. 132
5 Zusammenfassung und Ausblick.................................................................... 133
Abkürzungsverzeichnis ....................................................................................... 136
Literaturverzeichnis ............................................................................................ 141
2
Abbildungsverzeichnis
Abbildung 1.1:
Abbildung 3.1:
Abbildung 3.2:
Abbildung 3.3:
Abbildung 3.4:
Abbildung 3.5:
Abbildung 3.6:
Abbildung 3.7:
Abbildung 3.8:
Abbildung 3.9:
Abbildung 3.10:
Abbildung 3.11:
Abbildung 3.12:
Abbildung 3.13:
Abbildung 3.14:
Abbildung 3.15:
Abbildung 3.16:
Abbildung 3.17:
Abbildung 3.18:
Abbildung 3.19:
Abbildung 3.20:
Abbildung 3.21:
Abbildung 3.22:
Abbildung 3.23:
Abbildung 3.24:
Abbildung 3.25:
Abbildung 3.26:
Abbildung 3.27:
Abbildung 3.28:
Abbildung 3.29:
Abbildung 3.30:
Überblick der Java Plattform
Eclipse - Hauptkomponenten der Eclipse Architektur
Eclipse - Codeeditor
Eclipse - Visual Editor Ansicht
Eclipse - WindowBuilder Ansicht, Formular mit Grouplayout
Eclipse - Refactoringmethoden, Voransicht eines Refactorings
Eclipse - EclipseUML, Klassendiagramm
Eclipse - openArchitectureWare Funktionsüberblick
Eclipse - Klassenbibliothek eines Drittanbieters einbinden
Eclipse - Assistent zum Auslagern sprachspezifischer Texte
Eclipse - WTP Funktionsumfang
Eclipse - EclipseME in Java Perspektive
Eclipse - Debugger Perspektive
Eclipse - JUnit Ansicht
Eclipse - Profiler mit Montitor und Sequenzdiagramm
Eclipse - Konfiguration des Audit Plugins Checkstyle
Eclipse - Plugin Metrics
Eclipse - ALF Architektur
NetBeans - Übersicht über die NetBeans-Familie
NetBeans - Codeeditor
NetBeans - GUI-Designer Matisse
NetBeans - Refactoringmethoden, Jackpot Refactoring Manager
NetBeans - UML Design Center mit Pattern-Katalog
NetBeans - Sequenzdiagramm mittels Reverse Engineering
NetBeans - Library Manager
NetBeans - Tabellenbasiertes Editieren von Sprachdateien
NetBeans - Verbundene Datenquelle und SQL-Abfrageeditor
NetBeans - HTTP-Monitor
NetBeans - WYSIWYG Editor für JSF basierte Webseiten
NetBeans - Screen Designer für mobile CLDC Geräte
NetBeans - Mobility Pack Flow Designer
Abbildungsverzeichnis
Abbildung 3.31:
Abbildung 3.32:
Abbildung 3.33:
Abbildung 3.34:
Abbildung 3.35:
Abbildung 3.36:
Abbildung 3.37:
Abbildung 3.38:
Abbildung 3.39:
Abbildung 3.40:
Abbildung 3.41:
Abbildung 3.42:
Abbildung 3.42:
NetBeans - Debugger Ansicht
NetBeans - Profiler Ansicht
NetBeans - JUnit Ansicht
NetBeans - Dynamisches Hilfesystem
NetBeans - Refactoring einer XML-Schema Datei
JBuilder - Codeeditor
JBuilder - GUI-Designer Ansicht
JBuilder - Refactoringmenü, Refactoring-Historie
JBuilder - UML Ansicht
JBuilder - EJB-Designer
JBuilder - Dialog zum Verwalten der Klassenbibliotheken
JBuilder - Mit dbSwing-Komponenten erstelltes DB-Frontend
JBuilder - JavaServer Faces Flow-Designer
Abbildung 3.43:
Abbildung 3.44:
Abbildung 3.45:
Abbildung 3.46:
Abbildung 3.47:
Abbildung 3.48:
Abbildung 3.49:
Abbildung 3.50:
Abbildung 3.51:
Abbildung 3.52:
Abbildung 3.53:
Abbildung 3.54:
Abbildung 3.55:
Abbildung 3.56:
Abbildung 3.57:
Abbildung 3.58:
Abbildung 3.59:
Abbildung 3.60:
Abbildung 3.61:
Abbildung 3.62:
Abbildung 3.63:
Abbildung 5.1:
JBuilder - Entwicklung für mobile Endgeräte
JBuilder - Debuggeransicht
JBuilder - Unit Test Unterstützung
JBuilder - Code Audits
JBuilder - Borland ALM
JBuilder - Unterstützte VCS-Systeme
JBuilder - Peer-to-Peer Modus
IntelliJ IDEA - Codeeditor
IntelliJ IDEA - GUI Designer
IntelliJ IDEA - Refactoring
IntelliJ IDEA - Verwaltung der Klassenbibliotheken
IntelliJ IDEA - Internationalisierungs-Funktionalitäten
IntelliJ IDEA - EJB Persistenz Diagramm
IntelliJ IDEA – Erweiterung IntelliME
IntelliJ IDEA - Debugger
IntelliJ IDEA - Durchführung von Unit Tests
IntelliJ IDEA - Definition von Code Audit-Regeln
IntelliJ IDEA - Plugin MetricsReloaded
IntelliJ IDEA - Pluginverwaltung
IntelliJ IDEA - Hilfe während zeitaufwendigen Prozessen
IntelliJ IDEA - Integrierter Instant Messenger
Entwicklungsumgebung Borland C++ 3.1 (1991)
2
Tabellenverzeichnis
Tabelle 2.1:
Tabelle 2.2:
Tabelle 2.3:
Tabelle 2.4:
Tabelle 3.1:
Tabelle 3.2:
Tabelle 3.3:
Tabelle 3.4:
Tabelle 3.5:
Tabelle 3.6:
Tabelle 3.7:
Tabelle 3.8:
Tabelle 3.9:
Tabelle 3.10:
Tabelle 3.11:
Tabelle 3.12:
Tabelle 4.1:
Tabelle 4.2:
Tabelle 4.3:
Tabelle 4.4:
Tabelle 4.5:
Tabelle 4.6:
Tabelle 4.7:
Tabelle 4.8:
Tabelle 4.9:
Features eines Codeeditors
Refactoring Prozesse
Strukturdiagramme der UML und deren Bedeutung
Verhaltensdiagramme der UML und deren Bedeutung
Eclipse - Überblick über die einzelnen Callisto Projekte
Eclipse - Mitgelieferte Klassenbibliotheken der Callisto Distribution
Eclipse - Vom Teilprojekt JST von WTP unterstützte J2EE Artefakte
Eclipse - Aktivitäten der Community
NetBeans - Sun-Erweiterungsmodule für die IDE
NetBeans - Einige mitgelieferte Klassenbibliotheken
NetBeans - Aktivitäten der Community
JBuilder - Einige mit der IDE ausgelieferte Klassenbiblotheken
JBuilder - Unterstützte Technologien für Webapplikationen
JBuilder - Optimizeit Werkzeuge
JBuilder - Borland Communityaktivitäten
IntelliJ IDEA – Webentwicklung
Allgemeine Gegenüberstellung
Bewertung: Editor
Bewertung: Modellierung
Bewertung: Programmierung
Bewertung: Softwarequalitätssicherung
Bewertung: Erweiterbarkeit der Entwicklungsumgebung
Bewertung: Hilfe und Support
Bewertung: Sonstiges
Bewertung: Gesamtübersicht
Kapitel 1
Einleitung
1.1
Motivation für diese Arbeit
Die Programmiersprache Java wurde, nach [Sun06o], im Zuge eines internen Projekts bei Sun Microsystems entwickelt. Anfang 1996 wurden von der Firma die ersten Entwicklungswerkzeuge mit dem Java Development Kit 1.0 bereitgestellt. Die
derzeit aktuelle Version 6.0 des JDKs erschien im Dezember 2006 und steht unter
anderem für die Plattformen Win32, Linux und Mac OS X zur Verfügung.
Eine Besonderheit der Java-Technologie ist, dass der Java Compiler im Gegensatz
zu Übersetzern anderer Programmiersprachen, wie etwa C++, aus dem Quelltext
nicht Maschinencode für eine spezifische Plattform, sondern sogenannten Bytecode,
generiert. Dieser Zwischencode kann anschließend auf jeder Plattform ausgeführt
werden, für die eine entsprechende Java Virtual Machine bereitsteht, welche diesen
Zwischencode interpretieren kann. Diese Fähigkeit wird von Sun oft mit dem Ausspruch „Write once, run everywhere“ zusammengefasst.
Abhängig vom Einsatzgebiet der Java Programme werden von Sun drei verschiedene
Java Editionen unterschieden.
Die Java Standard Edition ist die klassische Umgebung, um Java basierte Anwendungen oder Applets auszuführen. Für die Entwicklung bietet die J2SE das Java Development Kit, kurz JDK.
Die Java Enterprise Edition basiert auf der Standard Edition und erweitert diese um
zusätzliche Klassenbibliotheken und Frameworks für den Einsatz im Enterprise- und
Webbereich.
Einleitung
2
Mit der Java Micro Edition steht eine Laufzeitumgebung zur Verfügung, die eine
Ausführung von Java Programmen auch auf Systemen mit limitierten Ressourcen,
wie beispielsweise Handys oder PDAs, ermöglicht.
Selbst für die Ausführung von Programmen auf Smartcards stellt Sun Microsystems
inzwischen eine eigene Variante von Java zur Verfügung. Abbildung 1.1 zeigt die
Java Editionen im Überblick.
Abbildung 1.1: Überblick der Java Plattform (Grafik nach [Sun06m])
Unter [Sun06n] wird angegeben, dass bereits mehr als 2 Milliarden elektronische
Geräte mit Java Unterstützung existieren:
•
Eine Milliarde Smartcards
•
708 Millionen Mobiltelefone (600 verschiedene Modelle von 30 Herstellern)
•
700 Millionen Computer mit installierter Java Laufzeitumgebung
Die Entwicklung von Programmen, die auf derart unterschiedlichen Endgeräten verwendet werden können, stellt auch eine große Herausforderung für die eingesetzten
Entwicklungswerkzeuge dar.
Einleitung
1.2
1.3
3
Behandelte Fragestellungen
•
Ist modellgetriebene Entwicklung bei den derzeit erhältlichen Produkten überhaupt ein Thema und wenn ja, wie weit geht die Unterstützung?
•
Inwieweit unterstützen die Produkte Modellierungstechniken?
•
Auf welche Art und Weise beschleunigt die Verwendung einer modernen
IDE den Entwicklungsprozess gegenüber einem Texteditor und Commandline-Compiler?
•
Wie wird die Qualität der resultierenden Software sichergestellt?
•
Wie sieht es mit der Erweiterbarkeit und Interoperabilität der Produkte aus?
•
Welche Phasen eines Entwicklungsprozesses (Anforderungsanalyse, Entwurf, Design, Implementierung, Test) werden von den untersuchten Produkten abgedeckt?
•
Wie wird das Arbeiten im Team unterstützt? Wie funktioniert dabei das Rollenmanagement?
•
Wie weit geht die Unterstützung für Anwendungen abseits des Desktopbereichs, wie z.B. Webanwendungen oder Applikationen für mobile Endgeräte?
Welche Techniken kommen dabei zum Einsatz?
•
Welche Standards haben sich im Bereich Softwaredesign und Softwareentwicklung etabliert?
Gliederung der Arbeit
In dieser Arbeit werden weit verbreitete Java Entwicklungsumgebungen anhand eines Kriterienkatalogs evaluiert und abschließend gegenübergestellt.
Kapitel 2 enthält den, zur Evaluierung der Produkte notwendigen, Kriterienkatalog.
Dieser wurde gemeinsam mit Florian Skopik, der zeitgleich eine Partnerarbeit
[Sko07] am Institut zum Thema C++/C# Entwicklungsumgebungen durchführte,
erarbeitet. Der Katalog ermöglicht eine Bewertung der IDEs in den Bereichen Editor, Modellierung, Programmierung, Softwarequalitätssicherung, Erweiterbarkeit der
Entwicklungsumgebung, Hilfe und Support sowie Sonstiges.
Einleitung
4
In Kapitel 3 liegt der Schwerpunkt dieser Arbeit: Die Evaluierung der ausgewählten
Produkte. Aus dem Open Source Bereich wurden Eclipse 3.2 und NetBeans 5.5 und
aus dem kommerziellen Umfeld die Umgebungen JBuilder 2006 und IntelliJ IDEA
gewählt. Jedem Produkt ist in diesem Kapitel ein Abschnitt gewidmet, in dem dieses,
gemäß den Kriterien aus dem Katalog, untersucht wird.
Kapitel 4 stellt die evaluierten Produkte direkt gegenüber. Dadurch werden die jeweiligen Stärken und Schwächen der einzelnen Entwicklungsumgebungen im Vergleich zu den Konkurrenzprodukten aufgezeigt.
Im letzten Kapitel werden Erfahrungen und Erkenntnisse aus den Produktevaluierungen zur Sprache gebracht.
Kapitel 2
Kriterienkatalog
Der folgende Katalog umfasst die Kriterien nach der die ausgewählten Entwicklungsumgebungen evaluiert werden.
Dieser Kriterienkatalog wird sowohl für die Evaluierung in Kapitel 3, als auch in
unveränderter Form in [Sko07] verwendet. Damit ist eine direkte Vergleichbarkeit
zu den in [Sko07] untersuchten Produkten gewährleistet.
2.1 Editor
Der Editor umfasst alle sichtbaren Bereiche des Produktes, welche zur Anwendungsentwicklung genutzt werden, wie z.B. den Codeeditor zur Eingabe des Programmcodes in Textform oder den User Interface Designer zur Erstellung einer Programmoberfläche. Weitere Kriterien zur Bewertung der Oberfläche sind auch eine vorhanden Sprachunterstützung abseits der englischen Standardversion oder der Gesamtaufbau der Arbeitsumgebung.
2.1.1 Codeeditor
Ein leistungsfähiger Eingabeeditor hilft den Überblick in langen Dateien zu bewahren. Ein einfacher Texteditor mit Syntax Highlighting, also dem farblichen Hervorheben von Schlüsselwörtern einer Programmiersprache, ist schon lange nicht mehr
genug. Moderne Codeeditoren besitzen noch viele weitere Features.
Tabelle 2.1 zeigt einen Überblick über Features moderner Codeeditoren.
Kriterienkatalog
6
Change Bars
Darunter versteht man das Markieren von, seit dem
letzten Speichern, geänderter Codebereiche mit
einem vertikalen farbigen Balken.
Quellcodeformatierung
Der Quellcode wird automatisch nach bestimmten
Regeln, wie z. B. konsistentes Einrücken bei Blöcken oder Schleifen, formatiert.
Code Parameter-Hilfe
Die Code Parameter-Hilfe gibt Hinweise, welche
Parametertypen für den an der Cursorposition stehenden Methodenaufruf, möglich sind.
Code-Hilfe
Diese gibt weitere Informationen über das Symbol
an der aktuellen Cursorposition, wie z.B. Typ, Datei und Zeilennummer der Deklaration.
Code Completion
Dieses Feature ermöglicht das Bereitstellen einer
Liste über alle an der aktuellen Cursorposition
möglichen Ausdrücke, wie z.B. eine Liste über alle
im aktuellen Kontext verfügbaren Methoden nach
Eingabe eines Objektnamens.
Class Completion
Unter Class Completion versteht man das automatische Generieren eines leeren Klassengerüsts, im
richtigen Namespace bzw. Package und leeren
Konstruktor.
Block Completion
Die Block Completion schließt einen Block am
Ende selbständig mit einer geschweiften Klammer.
Code Browsing
Code Browsing ermöglicht das Finden jedes Auftreten eines Symbols oder nur seiner Deklaration in
allen geöffneten Dateien bzw. in allen zum Projekt
gehörenden Dateien.
Method Hopping
Mit diesem Feature ist ein Wechseln zwischen Methoden durch einfaches Anklicken des Methodennamens im Sourcecode möglich.
RegEx-Suche
Das Durchsuchen der Projektdateien mittels regulä-
Kriterienkatalog
7
ren Ausdrücken wird heute von den meisten IDEs
unterstützt
Code Templates
Code Templates sind bereits vordefinierte, oft wiederkehrende Codestellen, z.B. eine Zählschleife.
Um diese nicht jedes Mal von neuem schreiben zu
müssen, kann diese nach einem Parametrisieren aus
einem Template-Archiv eingefügt werden. Die
meisten Produkte erlauben auch ein Hinzufügen
eigener Templates.
Code Folding
Code Folding ist das „Einklappen“, ähnlich einer
Baumstruktur, von ganzen Codebereichen z.B. Methoden die derzeit nicht bearbeitet werden. Dies
hilft die Codelänge künstlich zu verkürzen, ohne
tatsächlich Codeteile in andere Dateien auslagern
zu müssen. Dadurch wird die Übersicht selbst in
langen Codeteilen gewahrt.
ToDo List-Verwaltung
Die Verwaltung von „Merkzetteln“ und Verknüpfung mit Codeteilen regelt die ToDo ListVerwaltung.
Tastaturmakros
Bestimmte Funktionen mit Tastaturmakros zu belegen sollte heute zur Standardausstattung gehören.
Bookmarks
Bookmarks ermöglichen es, schnell zwischen wichtigen Codeteilen, auch über mehrere Dateien hinweg, zu wechseln.
Blockkommentare
Diese werden benutzt um ganze Codesektionen
einzelzeilenweise auf einmal auszukommentieren.
Tabelle 2.1: Features eines Codeeditors
2.1.2 User Interface Designer
Eine grafische Benutzeroberfläche (GUI) hat nach [Wes02] die Aufgabe, Anwendungssoftware auf einem Rechner mittels grafischer Elemente bedienbar zu machen.
Da bei heutigen Computersystemen zur Bedienung durch den Endanwender nahezu
Kriterienkatalog
8
ausschließlich GUIs verwendet werden, ist ein leistungsfähiger User Interface Designer Grundbestandteil einer jeden Entwicklungsumgebung.
Bei der Evaluierung des User Interface Design Editors werden folgende Fragestellungen untersucht:
•
Ist eine komfortable Platzierung der grafischen Komponenten mittels Drag &
Drop möglich?
•
Lassen sich die Eigenschaften (Beschriftung, Größe, Farbe, etc) einer Komponenten komfortabel in tabellarisch aufbereiteter Form ändern, oder ist dies
nur im Code möglich?
•
Wird der darunter liegende Code, also die Verbindung zwischen dem User
Interface und dem Controller, dem eigentlich arbeitenden Code der Applikation nach dem MVC-Modell wie z. B. in [ZBGK01] beschrieben, automatisch erzeugt, oder ist dies manuell erforderlich?
•
Wie wird die Verbindung zwischen durch User Interface-Komponenten ausgelösten Ereignissen und dem Programmcode realisiert (z.B. Eventhandler,
Action Listener, CallBack-Funktionen)?
•
Werden Designrichtlinien, wie z. B. unter [MS06a] beschrieben eingehalten
bzw. besteht die Möglichkeit den Editor nach eigenen Designrichtlinien zu
konfigurieren?
•
Ist die Bedienung intuitiv genug und eine schnelle Einarbeitung zu Beginn,
als auch eine rasche Abwicklung immer wiederkehrender Aktionen gewährleistet?
Dieses Bewertungskriterium befasst sich nicht mit dem eigentlichen Framework,
welches zur Darstellung der Benutzeroberfläche und der grafischen Komponenten
verwendet wird d.h. welche Komponenten zur Verfügung stehen, welche Möglichkeiten diese besitzen, deren Look & Feel oder Verwendung im Code. Diese Kriterien
werden im Teilkatalog Programmierung unter Mitgelieferte Klassen und Frameworks behandelt.
Kriterienkatalog
9
2.1.3 Refactoring
Refactoring ist nach [Fow05] eine Bezeichnung für eine Vorgehensweise in der
Informatik, spezieller der Softwareentwicklung, bei der die Lesbarkeit, Verständlichkeit, Wartbarkeit, Erweiterbarkeit und Struktur (der Funktionen und Klassen)
eines Computerprogramms verbessert wird, ohne dabei die Funktionalität der Software zu verändern.
Viele Refactoringprozesse ermöglichen das Hinzufügen, Ändern oder Löschen von
Symbolen. Der Vorteil in der Benutzung solcher Refactorings gegenüber der manuellen Manipulation des Sourcecodes liegt in der Aufrechterhaltung der Konsistenz
des Sourcecodes, da eine Refactoringfunktion ein Symbol nicht nur an einer Stelle
manipuliert, sondern an allen Stellen im Projekt in dem dieses auftritt.
Einige der häufigsten Refactoring-Prozesse werden in Tabelle 2.2 erläutert.
Symbol umbenennen
Dieser Prozess gibt einem Symbol, z. B. einer Variablen oder Klasse einen neuen Namen. Dabei wird
jedes Auftreten dieses Symbols im gesamten Projekt berücksichtigt.
Methode extrahieren
Methode extrahieren erlaubt es für ein Stück Sourcecode eine eigene Methode zu generieren. Dies
erhöht die Wiederverwendbarkeit, insbesondere
dann, wenn dieses Stück Sourcecode im gleichen
Projekt mehrmals Verwendung findet.
Interface extrahieren
Erzeugt aus einer implementierten Klassen ein Interface, sofern die Programmiersprache, z.B. C#
oder Java, das Konzept eines Interfaces vorsieht. In
C++ ist ein Interface unter gewissen Umständen mit
einer abstrakten Basisklasse vergleichbar.
Parameter umsortieren
Die Reihenfolge der Parameter in der Parameterliste einer Methode oder Funktion wird zwecks besserer Lesbarkeit verändert.
Parameter entfernen
Entfernt einen Parameter aus der Deklaration und
allen Methodenaufrufen.
Verschiebe lokale Variable in
Diese Funktion zieht eine lokale Variable einer
Kriterienkatalog
10
die Parameterliste
Methode in deren Parameterliste, um sie auch von
extern verändern zu können.
Variable in Methode einschließen
Falls eine Klassenvariable nur in einer einzigen
Methode der Klasse benutzt wird, sollte sie zwecks
Übersichtlichkeit zu einer lokalen Variable dieser
Methode gemacht werden.
Methode verschieben
Verschiebt eine Methode in eine über- oder untergeordnete Klasse.
Inline Membervariable
Eine lokale Variable, welche mit einem fixen Wert
initialisiert wurde und auf die im Weiteren nur
mehr lesend zugegriffen wird, wird bei ihrer Verwendung durch den vorinitialisierten Wert ersetzt.
Sicheres Löschen
Vor dem Löschen von Variablen, Methoden oder
Klassen wird überprüft, ob diese im Projekt verwendet werden.
get()- und set()-Methoden
generieren
Automatisches Erzeugen von get()- und set()Methoden für private Membervariablen
Tabelle 2.2: Refactoring Prozesse
2.1.4 Sprachunterstützung
Das Kriterium Sprachenunterstützung behandelt, wie gut ein Produkt für den nichtenglischsprachigen Markt gerüstet ist, also ob die Bedienungsmenüs vollständig und
weitgehend fehlerfrei übersetzt wurden und auch das Hilfesystem vollständig in anderen Sprachen verfügbar ist.
Dieses Kriterium beschäftigt sich nicht mit der Unterstützung andere Programmiersprachen oder mit der Entwicklung verschiedensprachiger Anwendungen. Dafür sind
die Kriterien Compiler und Programmiersprachen und Internationalisierung von
Anwendungen im Katalog Programmierung gedacht.
Kriterienkatalog
11
2.1.5 Entwurfsmuster
Ein Entwurfsmuster (engl. design pattern) beschreibt eine bewährte Schablone für
ein Entwurfsproblem. Es stellt damit eine wiederverwendbare Vorlage zur Problemlösung dar. Die bekanntesten und heute weit verbreiteten Entwurfsmuster sind jene
von E. Gamma, R. Helm, R. Johnson und J. Vlissides, der sogenannten Gang of Four
(GoF) [Wiki06b]. Eine genaue Abhandlung dieser Entwurfsmuster findet sich in
[GoF96] und dessen Nachfolgewerk [GoF99].
Diese Entwurfsmuster werden nach ihrem Zweck in die Kategorien
•
Erzeugungsmuster (creational patterns), welche Objekterzeugungsprozesse
abstrahieren,
•
Strukturmuster (structural patterns), welche Klassen und Objekte zu größeren
Strukturen zusammenfassen und
•
Verhaltensmuster (behavioral patterns), welche die Interaktion zwischen Objekten und komplexen Kontrollflüssen beschreiben,
eingeteilt. Darüber hinaus gibt es auch noch viele weitere nützliche Muster anderer
Autoren und Entwickler.
Dieses Bewertungskriterium befasst sich damit, ob das Thema Entwurfsmuster in der
Entwicklungsumgebung eine Rolle spielt, ob diese zumindest als Codeteile in der
Hilfe verfügbar sind bzw. optimalerweise über ein entsprechendes Menü dem Projekt hinzugefügt werden können. Weiters wird der Umfang der bereits implementierten Vorlagen untersucht.
2.1.6 Aufbau der Arbeitsumgebung
Diese Kriterium befasst sich mit der Benutzerfreundlichkeit (engl. usability) der Gesamtumgebung.
Beispielsweise werden folgende Fragestellungen erläutert:
•
Wie wird ein neues Projekt angelegt, wie die zugehörigen Dateien und Ressourcen verwaltet?
Kriterienkatalog
2.2
12
•
Wie brauchbar ist die Standardkonfiguration der Oberfläche (Darstellung der
Informationen in verschiedenen Fenstern und deren Anordnung) und in wie
weit kann diese verändert werden?
•
Sind die Menüs überladen? Sind diese individuell anpassbar, d.h. können
nicht benötigte Funktionen ausgeblendet werden?
•
Ist die Bedienung intuitiv und hält sich diese an etablierte Standards?
•
Wie sind die für den Entwicklungsprozess wichtigen Informationen aufbereitet, wie z. B. die Darstellung der Klassenhierarchie (Class Browser) und wie
wird die Übersicht über das Projekt gewahrt?
Modellierung
Dieser Teilkatalog befasst sich mit der Unterstützung der Softwaremodellierung
durch die untersuchten Produkte. Dabei wird unterschieden, ob das Produkt die Unified Modeling Language unterstützt und wenn ja, welche Diagrammarten; weiters
auch ob UML dann auch tatsächlich zu MDA-Zwecken eingesetzt werden kann, also
ob aus einem abstrahierten Modell Code erzeugt werden kann, und wenn nein, ob
wenigstens ein Forward Engineering möglich ist.
2.2.1 Unified Modeling Language
Dieses Kriterium behandelt, ob und in welcher Form die Verwendung der UML
möglich ist. Die meisten größeren Produkte erlauben zumindest das Generieren und
Darstellen eines Klassendiagramms in einer graphischen Ansicht. Bei anderen Produkten geht die Unterstützung von UML aber weit darüber hinaus. Es wird untersucht, ob die nach [Kapp03a] und [ZBGK01] wichtigsten Diagrammarten zur Modellierung oder Dokumentation verwendet werden können.
Der aktuelle Standard UML 2.0 kennt dreizehn verschiedene Diagrammtypen, welche sich in Strukturdiagramme und Verhaltensdiagramme gliedern.
Klassendiagramm
In Klassendiagrammen werden die Attribute und
Methoden von Klassen gezeigt, sowie die Beziehungen der Klassen untereinander dargestellt. Bei der
Kriterienkatalog
13
Darstellung der Klassen sollten unterschiedliche
Detailgrade gewählt werden können.
Kompositionsstrukturdiagramm
Das Kompositionsstrukturdiagramm zeigt einheitlich das Innere eines Classifiers und dessen Zusammenarbeit mit seiner Umgebung.
Komponentendiagramm
In einem Komponentendiagramm, typischerweise in
der Komponentenbasierten Softwareentwicklung
eingesetzt werden Komponenten und deren „Andockstellen“, Schnittstellen sowie Ports, dargestellt.
Objektdiagramm
In einem Objektdiagramm werden Ausprägungsspezifikationen von Klassen und Assoziationen dargestellt.
Paketdiagramm
In einem Paketdiagramm werden Pakete, Paketimports, Paketverschmelzungen und Abhängigkeitsbeziehungen dargestellt.
Verteilungsdiagramm
In einem Verteilungsdiagramm werden Knoten, Artefakte, Ausprägungsspezifikationen und Verteilungsbeziehungen dargestellt.
Tabelle 2.3: Strukturdiagramme der UML und deren Bedeutung
Anwendungsfalldiagramm
Das Anwendungsfalldiagramm zeigt die Benutzer
und die Anforderungen eines Systems im Überblick.
Aktivitätsdiagramm
Ein Aktivitätsdiagramm ist eine graphische Darstellung eines Netzes von elementaren Aktionen, die mit
Kontroll- und Datenflüssen verbunden sind. Häufig
wird es zur Beschreibung von Abläufen eines Anwendungsfalls verwendet.
Sequenzdiagramm
Im Sequenzdiagramm wird der dynamische Ablauf
zwischen Objekten unter Berücksichtigung der zeitlichen Abfolge dargestellt.
Kriterienkatalog
14
Kommunikationsdiagramm
Ein Kommunikationsdiagramm ist eine graphische
Darstellung einer Interaktion und spezifiziert den
Austausch von Nachrichten zwischen Ausprägungen, die im Diagramm als Lebenslinien dargestellt
sind.
Interaktionsübersichtdiagramm
Das Interaktionsübersichtsdiagramm ist eine Kombination aus einem Aktivitätsdiagramm und weiteren Interaktionsdiagrammen. Damit ist es möglich,
komplexe Interaktionen Top/Down oder Bottom/Up
zu modellieren.
Zeitverlaufsdiagramm
Zeitverlaufsdiagramme sind zweidimensionale Diagramme, bei denen die X-Achse die Zeit, und die YAchse Objekte (im weitesten Sinne) und deren Zustände darstellen.
Zustandsdiagramm
Ein Zustandsdiagramm dient zur Beschreibung eines
endlichen Automaten in UML-Notation.
Tabelle 2.4: Verhaltensdiagramme der UML und deren Bedeutung
2.2.2 Model Driven Architecture
Dieses Kriterium untersucht, ob die Entwicklungsumgebung einen Modellgetriebenen Entwicklungsprozess unterstützt, also ob wie in [StVö05] und [And04] beschrieben, tatsächlich das Generieren von Sourcecode aus einem abstrahierten Modell, evtl. über Zwischenschritten, möglich ist. Weiters wird untersucht inwiefern die
in heutigen MDA-Tools eingesetzten Techniken, wie z.B. die Object Constraint Language (OCL) zur textuellen Spezifikation von Bedingungen oder XML Metadata
Interchange (XMI) zum Dokumentenaustausch Unterstützung finden. Letzteres gibt
zum Teil auch Aufschluss darüber inwieweit das Produkt mit anderen Tools zusammen verwendet werden kann.
2.2.3 Forward Engineering
Unter Forward Engineering versteht man nach [StVö05] das einfache Generieren
von Code aus einem Modell, wobei Code und Modell auf der gleichen Abstraktionsstufe liegen, das Modell also nur eine andere Darstellungsform des Codes ist.
Kriterienkatalog
15
Ein typisches Beispiel hiefür wäre, das Generieren von Klassenskeletten aus einem
selbst gezeichneten UML-Klassendiagramm.
2.2.4 Reverse Engineering
Reverse Engineering ist die Umkehrung von Forward Engineering, also das Erzeugen eines Klassendiagramms aufgrund selbst geschriebenen Codes.
Auf diesem Weg erzeugte Klassendiagramme werden häufig zur Dokumentation
eingesetzt, obwohl sie nach [StVö05] dafür nur bedingt geeignet sind. Dies resultiert
aus der Tatsache, dass Code und Klassendiagramm den gleichen Detailgrad aufweisen, das erzeugte Klassendiagramm daher meist durch Hilfsklassen und für die Funktionalität weniger wichtigen Code (z.B. vom User Interface) überladen und unübersichtlich ist.
2.2.5 Roundtrip Engineering
Im Gegensatz zur Model Driven Architecture versteht man nach [StVö05] unter
Roundtrip Engineering die Möglichkeit, sowohl in einem Modell als auch in dem
daraus generierten Code nach Belieben Änderungen vornehmen zu können, wobei
die Änderungen in beide Richtungen propagiert werden und beide Artefakte immer
konsistent sind.
2.3
Programmierung
Dieser Teilkatalog enthält alle Kriterien, die aus programmiertechnischer Sicht interessant sind, also welche Compiler und Programmiersprachen eigentlich unterstützt,
welche Klassenbibliotheken und Frameworks mitgeliefert oder welche Zielplattformen abgedeckt werden.
2.3.1 Compiler und Programmiersprachen
Viele der untersuchten Entwicklungsumgebungen unterstützen nicht nur die Entwicklung unter einer Programmiersprache, sondern unter vielen. Obwohl das Hauptaugenmerk auf den Sprachen C++ und C# bzw. Java liegt, soll dieses Kriterium kurz
beleuchten, welche alternativen Compiler und andere Programmiersprachen noch
unterstützt werden.
Kriterienkatalog
16
Eine Abhandlung über alle durch das jeweilige Produkte unterstützte Sprachen würde den Rahmen dieser Arbeit sprengen, da es sich bei den ausgewählten Produkten
entweder um Entwicklungsstudios handelt, welche, wie der Name schon sagt, die
Unterstützung vieler Technologien vereinen, oder die Systeme völlig modular aufgebaut sind und daher je nach installierter Plugins für die Entwicklung unter nahezu
jeder Programmiersprache verwendet werden können.
2.3.2 Mitgelieferte Klassenbibliotheken und Frameworks
Zur schnellen und sinnvollen Applikationsentwicklung ist man im Allgemeinen auf
die Unterstützung bereits erstellter Klassenbibliotheken angewiesen. In Java z. B.
gibt es verschiedene Editionen für unterschiedliche Zwecke. So gibt es für Desktopanwendungen die Java 2 Standard Edition (J2SE) bzw. das .NET Framework und für
mobile Endgeräte die Java 2 Micro Edition (J2ME) bzw. das .NET Compact Framework.
Bei diesem Kriterium soll vor allem das Spektrum der bereits mitgelieferten Bibliotheken und Frameworks untersucht werden und für welche Aufgabengebiete, z. B.
Datenbankapplikationen, Web-Anwendungen, diese ausgelegt sind.
2.3.3 Middleware und Komponentenstandards
Nach [And04] sind Komponentenstandards Standards in Bezug auf die Darstellung,
die Bezeichnung, das Verhalten, die Implementierung, die Interoperabilität, das
Customizing, die Komposition und die Verteilung von Komponenten. Sie definieren
anhand einer Spezifikation, welche Anforderungen Komponenten aus syntaktischer
und semantischer Sicht erfüllen müssen. Komponentenstandards liefern eine Infrastruktur, die es ermöglicht, Komponenten flexibel auf verschiedenen Standorten auszuführen.
Ein Komponentenstandard spezifiziert nach [And04]:
•
Syntax und Semantik der Komponenten,
•
eine Laufzeitumgebung,
•
spezifische Basisdienste (Erzeugung, Aktivierung, Deaktivierung von Komponenten),
Kriterienkatalog
17
•
horizontale Dienste, die verschiedenen Bereichen zur Verfügung stehen (Persistenzmanagement, Transaktionsverhalten, Sicherheit, Verzeichnisdienste
etc.), und
•
vertikale Dienste, die einem spezifischen Bereich zur Verfügung stehen (Businessprozesse, -entitäten, -services etc.).
Ein Komponentenstandard nutzt sowohl spezifische Applikationsserver und Container als auch spezifische Middleware.
Zu den heute verwendeten Komponentenstandards zählen EJB (Enterprise JavaBeans), CCM (CORBA Component Model), COM+ (Component Object Model) und
.NET.
2.3.4 Klassenbibliotheken und Komponenten von Drittanbietern
Oft greift man bei der Entwicklung von komplexen Anwendungen auf Komponenten
von Drittanbietern für spezielle Funktionalitäten zurück, da es aus Zeit- und Kostengründen nicht möglich ist diese immer selbst zu entwickeln und ausreichend zu testen.
Eine Entwicklungsumgebung sollte solche Komponenten einfach integrieren und
verwalten können.
2.3.5 Internationalisierung von Anwendungen
Unter Internationalisierung in der Softwareentwicklung versteht man den Übersetzungsprozess sodass die Software in verschiedenen Sprachen und Regionen verwendet werden kann, ohne Änderungen am Programmquellcode vornehmen zu müssen.
Die Internationalisierung betrifft länder- bzw. sprachspezifische Komponenten wie
Texte, Datumsformate und Eingabemethoden.
Übersetzte Texte werden üblicherweise in Textdateien ausgelagert um diese einfach
auch von Nicht-Programmierern erstellen lassen zu können.
2.3.6 Datenbankprojekte
Viele Anwendungen verwenden heutzutage eine Datenbank als Speicher-Backend.
Um die Entwicklung von datenbankabhängigen Applikationen zu vereinfachen, sollte eine Entwicklungsumgebung eine entsprechende Datenbankunterstützung bereit-
Kriterienkatalog
18
stellen. Diese ist optimalerweise möglichst flexibel und unabhängig von einem Hersteller gestaltet.
In der Entwicklungsumgebung sollte zumindest ein Editor integriert sein, welcher es
erlaubt Abfragen abzusetzen und Strukturänderungen am Datenmodell vorzunehmen. Da Anwendungen bei der Entwicklung oft mit unterschiedlichen Datenbanksystemen getestet werden müssen, wäre weiters eine übersichtliche Möglichkeit zur
Verwaltung der Datenquellen wünschenswert.
2.3.7 Webentwicklung
Nach [Kapp06b] ist eine Web-Anwendung ein Softwaresystem, das auf Spezifikationen des World Wide Web Consortium (W3C) beruht und Web-spezifische Ressourcen wie Inhalte und Dienste bereitstellt, die über eine Benutzerschnittstelle, den
Web-Browser, verwendet werden.
Hierzu sind der Computer des Benutzer (Client) sowie der Server über ein Netzwerk
miteinander verbunden, sodass die räumliche Entfernung zwischen Client und Server
unerheblich ist.
Bei der Entwicklung einer solchen Webanwendung gibt es verschiedene Arten der
Implementierung je nach verwendeter Technologie und Hersteller.
Im Java-Bereich stehen z. B. Webkomponenten für die Webentwicklung mit den
JavaServerPages sowie mit Servlets zur Verfügung, unter .NET übernimmt
ASP.NET ähnliche Funktionalitäten.
2.3.8 Entwicklung für mobile Endgeräte
Im Unterschied zur Entwicklung von Standardanwendungen für den Desktop- sowie
Serverbetrieb stellt die Anwendungsentwicklung für mobile Endgeräte, wie etwa
Handys oder PocketPCs, eine besondere Herausforderung dar. Die Rechenleistung,
als auch die Darstellungsmöglichkeiten eines solchen Endgerätes sind üblicherweise
sehr beschränkt.
Es ist daher gerade für mobile Endgeräte sehr wichtig, dass leistungsfähige Entwicklungswerkzeuge vorhanden sind mit denen es auch möglich ist aus derart minimalistischen Umgebungen die größtmögliche Leistung herauszuholen. Da das Testen von
Anwendungen direkt auf dem Endgerät oft sehr umständlich ist, müssen auch entsprechende Emulatoren in der Entwicklungsumgebung zur Verfügung stehen.
Kriterienkatalog
2.4
19
Softwarequalitätssicherung
Nach dem ISO Standard 9126 versteht man unter Softwarequalität die Gesamtheit
der Merkmale und Merkmalswerte eines Softwareprodukts, die sich auf dessen Eignung beziehen, festgelegte oder vorausgesetzte Erfordernisse zu erfüllen.
Da Softwareprogramme oft sehr komplexe technische Artefakte sind, die oft auch
Komponenten von Drittanbietern verwenden, ist es praktisch unmöglich alle Fehler
zu finden und zu beheben. Um das Finden bzw. Vermeiden von Fehlern zu erleichtern, sollte eine moderne Entwicklungsumgebung entsprechende Tools zur Verfügung stellen.
2.4.1 Debugger
Die meisten untersuchten IDEs stellen einen sogenannten Debugger zur Verfügung
der als eigenständiges Programm oder Bestandteil eines Compilers die Suche und
Beseitigung von syntaktischen Fehlern und Fehlern im Programm oder Quellcode
dient. Ein Debugger bietet normalerweise mindestens folgende Funktionen:
•
Watches (Überwachungen) um Variableninhalte zu überprüfen
•
Breakpoints (Haltepunkte) um Ausgaben zu überwachen
•
Tracingfunktionalität, um durch schrittweise Abarbeitung eine bessere Überprüfung des Programmablaufs zu ermöglichen
Debugger sind ein unverzichtbares Werkzeug in der Programmentwicklung und erleichtern die Suche und Beseitigung von Fehlern.
2.4.2 Remote Debugger
Eine Sonderform des Software Debuggers ist der Remote Debugger. Dieser ermöglicht das debuggen eines Programms welches auf einem anderen Computer ausgeführt wird. Normalerweise öffnet das zu untersuchende Programm einen TCP/IP
Listenport zu dem sich der Debugger verbindet und entsprechende Befehle über diese Socketverbindung mit dem Programm austauscht.
Kriterienkatalog
20
2.4.3 Profiler
Mit einem Profiler ist es möglich, Programme auf ihr Laufzeitverhalten sowie auf
ihre Speichernutzung hin zu untersuchen. Es wird beispielsweise ermittelt, welche
Programmteile wie oft ausgeführt werden und wie viel Zeit dafür benötigt wird.
Bei Desktopanwendungen wird aufgrund der inzwischen sehr leistungsfähigen PCs
oft auf eine genaue Lauftzeitanalyse verzichtet. Im Bereich der mobilen Endgeräte,
wie etwa Mobiltelefone, wo auf einen möglichst geringen Energieverbrauch geachtet
werden muss, ist eine genaue Betrachtung des Laufzeitverhaltens der Anwendung
jedoch unbedingt notwendig.
2.4.4 Unit Tests
Unit Tests werden verwendet um einzelne Teile des Sourcecodes auf korrekte Funktion zu testen. Die Tests werden implementiert, indem Testfälle für jede Methode
geschrieben werden. Auf diese Weise ist es einfach und reproduzierbar möglich Fehler zu finden. Unit Tests zählen aufgrund dieser Vorgangsweise zu der Gruppe der
White Box Tests.
Für die Programmiersprachen Java und C#, die in dieser Arbeit hauptsächlich behandelt werden gibt es jeweils bereits ein Unit Test Tool welches sich als quasi Standard durchgesetzt hat: JUnit (Java) [JUnit06] und NUnit (C#) [NUnit06]. Daher wird
bei diesem Kriterium vor allem beurteilt wie gut die untersuchte Entwicklungsumgebung JUnit bzw. NUnit integriert.
2.4.5 Quality Audits
Quality Audits ermöglichen die Umsetzung geltender Standards und Konventionen
und die Optimierung der Programmiertätigkeit. Beim Ausführen von Audits werden
bestimmte Regeln ausgewählt, mit denen der erstellte Quelltext konform sein muss.
Die Ergebnisse zeigen an, wo gegen diese Regeln verstoßen wird, sodass dem Problem auf den Grund gegangen werden kann. Viele Programmiersprachen bieten Standard-Code-Konventionen, wie z. B. die Sun-Code-Konventionen für Java. Solche
oder eigene Konventionen sollten in der Entwicklungsumgebung eingestellt und ausgetauscht werden können.
Kriterienkatalog
21
Audits überprüfen also automatisch die Einhaltung von Standard- oder benutzerdefinierten Stilrichtlinien sowie die Einhaltung von Richtlinien bezüglich Wartung und
Stabilität von Code.
Die Einhaltung von Konventionen erleichtert die Wartbarkeit und Qualitätssicherung
gerade bei der Entwicklung im Team.
2.4.6 Quality Metrics
Eine weitere Möglichkeit eine Aussage über Qualität der entwickelten Software zu
erhalten, ist der Einsatz von Qualitäts- bzw. Software Metriken. Typische Metriken
für objektorientierte Software sind beispielsweise:
•
Anzahl der Zeilen pro Methode
•
Komplexität der Methoden (messbar durch Gewichtung einzelner Strukturen)
•
Prozentueller Anteil von Kommentaren pro Klasse
•
Anzahl der Methoden pro Klassen
•
Anzahl der Klassenvariablen
•
Verhältnis öffentlicher zu privaten Methoden
•
Typische Vererbungstiefe in der Anwendung
•
Verhältnis von abstrakten Klassen zu nicht abstrakten Klassen
Die Untersuchung der Ergebnisse der unterschiedlichen Metriken erlaubt eine gezielte Verbesserung der Softwarequalität. Enthält z. B. eine Klasse überdurchschnittlich viele Variablen und Methoden, so liegt möglicherweise zu viel Verantwortung
in dieser Klasse.
2.5
Erweiterbarkeit der Entwicklungsumgebung
Dieser Teilkatalog befasst sich einerseits damit, wie gut sich das Produkt in den gesamten Softwarentwicklungsprozess einfügt und welche Phasen eines Entwicklungsprozesses es abdeckt und andererseits mit der Erweiterung der Entwicklungsumgebung selbst, d.h. ob Schnittstellen nach außen verfügbar sind, um das Produkt mit
Komponenten von Drittanbietern erweitern zu können.
Kriterienkatalog
22
Die Erweiterung mittels Klassenbibliotheken, Frameworks und Komponenten von
Drittanbietern wird hingegen im Teilkatalog Programmierung behandelt.
2.5.1 Einbindung in ein Application Lifecycle Management
Unter einem Application Lifecycle Management (ALM) versteht man nach [Bor06b]
eine Kette von Softwareprodukten, welche den gesamten Entwicklungsprozess vom
ersten Entwurf, über die Modellierung und darauf folgende Implementierung bis
zum Testen und Ausliefern des fertigen Produkts vollelektronisch abdecken.
Dieses Kriterium bewertet, wie gut die untersuchte Entwicklungsumgebung mit anderen Produkten, welche die durch die IDE nicht abgedeckten Aufgabenbereiche
übernehmen, zusammenarbeiten kann. Dies umfasst neben den zuvor genannten
Aufgabenbereichen auch eine Integration in eine teamfähige Umgebung.
2.5.2 Zusatzkomponenten von Drittanbietern
Dieses Bewertungskriterium beurteilt die Erweiterbarkeit der Entwicklungsumgebung durch Komponenten von Drittanbietern, d.h. ob überhaupt Schnittstellen dafür
vorgesehen sind, und gibt eine Übersicht über häufig verwendete Module. Beispiele
für solche Erweiterungskomponenten einer IDE sind z.B. Plugins für Unit Tests oder
VCS-Clients.
Die Erweiterung der Entwicklungstechnik, d.h. Erweiterung mit Frameworks oder
Komponenten die in einer entwickelten Applikation genutzt werden, wird hierbei
nicht berücksichtigt. Dafür ist das Kriterium Klassenbibliotheken und Komponenten
von Drittanbietern im Teilkatalog Programmierung zuständig.
2.6
Hilfe und Support
Dieses Kriterium behandelt die verfügbaren Ressourcen in den Bereichen Produktdokumentation, Benutzer-Community und Kundenbetreuung durch den Hersteller.
Dieses Kriterium bewertet zwar nicht direkt das Produkt, ist aber in der Regel für die
Akzeptanz beim Benutzer ausschlaggebend.
2.6.1 Dokumentation des Produkts
„Ein Produkt ist nur so gut wie dessen Dokumentation.“ Dieser berühmte Satz über
ein Produkt gilt natürlich auch für Softwareentwicklungsumgebungen. Moderne I-
Kriterienkatalog
23
DEs bieten im Vergleich zu vielen anderen Softwareprodukten meist eine überdurchschnittlich hohe Funktionsvielfalt. Um die Möglichkeiten effektiv nutzen zu
können, ist ein umfangreiches und flexibles Hilfesystem notwendig. Eine Dokumentation für eine IDE sollte neben einer brauchbaren Online Hilfe auch ein interaktives
Hilfesystem anbieten, welches es dem Anwender erlaubt die Funktionalitäten des
Produkts aktiv zu erarbeiten. Da bei Entwicklungsumgebungen üblicherweise der
Funktionsumfang mittels Erweiterungen ausgebaut werden kann, sollte eine geeignete Dokumentationsschnittstelle zur Verfügung stehen, welche es Plugin-Herstellern
ermöglicht, ihre Dokumentation in das bestehende Hilfesystem zu integrieren.
2.6.2 Größe der Community
Treten bei der Verwendung eines Softwareprodukts Fragen bzw. Probleme auf, ist
der erste Weg bei der Suche nach Hilfe oft das Internet. Die Wahrscheinlichkeit,
dass man bei der Suche nach einer entsprechenden Hilfestellung fündig wird, steigt
je größer die Community des Produktherstellers ist.
Von Seiten des Herstellers sollte eine zentrale Plattform bereitgestellt werden, welche als Anlaufstelle für Anwender genutzt werden kann um sich untereinander austauschen zu können.
Eine große und aktive Community schafft oft eine umfangreiche Wissensbasis, welche die Leistungsfähigkeit eines Produkts indirekt steigern kann. Bietet die Entwicklungsumgebung beispielsweise eine flexible Schnittstelle für Erweiterungen, sorgt
eine große Community meist für viele und leistungsfähige Plugins um eventuell vorhandene Schwächen der IDE auszumerzen.
2.6.3 Kundenbetreuung durch den Hersteller
Fällt bei der Wahl einer Entwicklungsumgebung die Entscheidung auf ein kommerzielles Produkt, erhofft sich der Anwender meist eine entsprechende Betreuung direkt vom Hersteller.
Bei diesem Kriterium soll untersucht werden, welche Supportmöglichkeiten der Hersteller anbietet, ob diese kostenpflichtig sind und ob bei spezifischen Problemen ein
entsprechend kompetenter Ansprechpartner zur Verfügung steht. Auch die Erreichbarkeit des Supports ist ein Punkt, der hier nicht außer Acht gelassen werden sollte.
Kriterienkatalog
2.7
24
Sonstiges
Abhängig von der Philosophie ihres Herstellers hat jede IDE meist einen Schwerpunkt und zeigt dort oft viele Stärken und Funktionalitäten. Ein direkter Vergleich
dieser Möglichkeiten ist daher meist nicht möglich.
Eine IDE könnte beispielsweise das Hauptaugenmerk auf Teamfähigkeit legen und
daher eine sehr gute Unterstützung für Konfigurations- und Versionsmanagementsysteme bieten oder eine integrierte Kommunikationsmöglichkeit für Projektbeteiligte, z. B. ein Instant-Messaging System, zur Verfügung stellen.
Kapitel 3
Evaluierung
Dieses Kapitel behandelt die konkrete Bewertung der ausgewählten Produkte nach
den in Kapitel 2 beschriebenen Kriterien. Wichtige Funktionalitäten, die ein Produkt
zusätzlich bietet, werden ebenfalls im Zuge der Evaluierung erwähnt. Zu jedem Produkt wird darüber hinaus eine Gesamtübersicht über seine Positionierung am Markt
und seiner Entwicklung geboten.
Evaluierung
3.1
26
Eclipse 3.2
Hersteller
Eclipse Foundation
Produktversionen
Standard, Callisto-Suite
Testversion
Eclipse 3.2 mit Erweiterungen
Anschaffungskosten
Kostenlose Basisplattform, kommerzielle Erweiterungen:
EclipseUML [Omo06a] (1990 EUR1) sowie WindowBuilder [Ins06] (245 EUR2)
Plattform
Windows, Linux, Solaris, AIX, HP-UX, Mac OS X
Homepage
www.eclipse.org
3.1.1 Allgemeines
Die Geschichte von Eclipse beginnt im Grunde mit der Übernahme der Firma Object
Technologies International durch IBM. Denn OTI entwickelte Programmierwerkzeuge und war auch für die Entwicklung der IBM-Visual Age-Produktpalette verantwortlich. Im Rahmen der Arbeiten zu IBM Websphere wurde eine JavaEntwicklungsumgebung namens Eclipse geschaffen, die ihrerseits auf vielen Konzepten von Visual Age for Java basiert. Entwickler dieser Anwendung war ebenfalls
wieder OTI. Im Jahr 2001 gab IBM Eclipse in der Version 1.0 frei und stellte es unter eine Open-Source-Lizenz. [Cub05]
Die Führung des Eclipse Projekts wurde der neu gegründeten Eclipse-Foundation,
die 2003 unabhängig von IBM wurde, übertragen. Die Firma IBM ist derzeit noch
immer sehr stark an der Eclipse-Entwicklung beteiligt, die Kontrolle des Projekts hat
jedoch ausschließlich die Eclipse Foundation, deren Vorstand mit Mike Milinkovich
kein IBM Mitarbeiter ist.
Die Eclipse Plattform wurde nach [Ecl06a] so gestaltet, dass diese als flexible Basis
für die Entwicklung von integrierten Entwicklungsumgebungen (IDEs) verwendet
werden kann. Seit Version 3.0 ist es auch möglich, auf Wunsch der Community
1 Preis nach http://www.omondo.de/default.asp?subsite=pricing (12.11.2006)
2 Preis nach http://www.instantiations.com/windowbuilderpro/order.html (12.11.2006)
Evaluierung
27
[Ecl06b], Eclipse nicht nur als Basis für Entwicklungsumgebungen, sondern auch
als Rich Client Platform (RCP) für beliebige Applikationen zu verwenden.
Die Eclipse Plugin Architektur ist, nicht zuletzt durch den Vorgänger IBMs Visual
Age for Java, sehr flexibel erweiterbar. Abbildung 3.1 zeigt die Hauptkomponenten
der Eclipse Architektur. Der Kern der Eclipse Rich Client Platform besteht aus dem
Eclipse Workbench, dem Standard Widget Toolkit SWT [Ecl06c], der JFace
[Ecl06c] Bibliothek, sowie der Hilfe Komponente.
Abbildung 3.1: Eclipse - Hauptkomponenten der Eclipse Architektur (Grafik: [IBM06a])
Mit Ausnahme der Kernkomponenten von Eclipse (in Abbildung 3.1 der Block „Eclipse Platform“) werden alle Funktionen von Eclipse durch Plugins realisiert. In der
Eclipse Distribution sind standardmäßig Plugins für die Entwicklung von Java Applikationen enthalten, die Eclipse Java Development Tools (JDT). Eine optionale
Erweiterung für die Programmiersprachen C bzw. C++ steht z. B. mit den Eclipse
C/C++ Development Tools zur Verfügung [Sko07].
Eclipse wurde komplett in der Programmiersprache Java realisiert und steht für alle
gängigen Betriebssysteme zur Verfügung. Ein Kritikpunkt an Entwicklungsumgebungen, die in Java programmiert wurden, war oft das träge Verhalten der Benutzeroberfläche sowie die Usability, welche sich manchmal vom nativen Verhalten unterscheidet. Der Grund für dieses Verhalten ist das bei vielen Java GUI Programmen
verwendete Widgetset Swing [Sun06h]. Bei Swing werden die GUI Komponenten
direkt von Java gezeichnet und sind daher nicht von nativen Betriebssystemenelementen abhängig. Der Vorteil ist, dass Swing-Komponenten auf allen Plattformen
Evaluierung
28
gleich aussehen, unabhängig davon, ob die Plattform eine entsprechende eigene
Komponente zur Verfügung stellt oder nicht. Die Eclipse Plattform stellt ein eigenes
Widgetset zur Verfügung, das Standard Widget Toolkit SWT [Ecl06c], welches im
Gegensatz zu Swing, ähnlich zu Sun´s Abstract Windowing Toolkit AWT [Sun06a],
die nativen grafischen Elemende des Betriebssystems nutzt und es somit ermöglicht
performantere Oberflächen zu erzeugen. Im Unterschied zu AWT, welches nur grafische Komponenten bereitstellt, die unter praktisch allen Betriebssystemen nativ vorhanden sind, versucht SWT hier einen Mittelweg zwischen Performance und Funktionsumfang zu beschreiten. Wenn das Betriebssystem ein entsprechendes natives
Gegenstück besitzt, wird dieses verwendet, ansonsten wird es von SWT emuliert.
SWT ist inzwischen bei Java Entwicklern auch außerhalb von EclipseEntwicklungen sehr beliebt und wird immer häufiger als Widgetset für grafische
Java Anwendungen verwendet. Mit JFace stellt die Eclipse Foundation inzwischen
ein Toolkit zur Verfügung welches auf SWT aufsetzt und dieses um einen MVC Ansatz erweitert. Es ist dadurch möglich, komplexere GUI Komponenten zu erzeugen.
Mit der Veröffentlichung von Eclipse 3.2 wurde ebenfalls die Callisto-Suite [Ecl06d]
bereitgestellt. Callisto, benannt nach einem der zehn Jupiter Monde, ist eine Initiative der Eclipse Foundation mit dem Ziel, mehrere Projekte zu einem gemeinsamen
Release-Termin für neue Versionen zu verpflichten. Nach Installation der Eclipse
Kerndistribution, bestehend aus Java Development Tools (JDT), Eclipse Plattform
und Plugin Development Environment (PDE), können über eine Update Funktion bei
Bedarf Projekte aus Callisto nachgerüstet werden.
Die Callisto-Suite besteht aus den folgenden Projekten:
Business Intelligence and
Reporting Tools (BIRT) 2.1
[Ecl06j]
Infrastruktur und Anwendungen für die Entwicklung, Verteilung, Generierung und Betrachtung von
Berichten in einer Organisation. Zusätzliche Subprojekte behandeln beispielsweise die statistische Analyse.
C/C++ Development Tooling
(CDT) 3.1 [Ecl06e]
Das CDT Projekt stellt eine komplette C/C++ Entwicklungsumgebung für die Eclipse Plattform bereit.
Eine Evaluierung dazu wurde in der Partnerarbeit
von Florian Skopik in [Sko07] zeitgleich mit dieser
Arbeit durchgeführt.
Data Tools Platform (DTP)
DTP hat sich zum Ziel gesetzt, Entwicklungswerk-
Evaluierung
29
1.0 [Ecl06h]
zeuge für datenbasierte Applikationen bereitzustellen. Es versucht Konzepte anzubieten, die einen einheitlichen Zugriff auf diverse Datenquellen (nicht
nur Datenbanken) ermöglichen. (siehe Kapitel Bewertung nach Kriterienkatalog – Programmierung)
Eclipse Modelling Frame- Ein Modellierungsframework und Codegeneriework (EMF) 2.2 [Ecl06p]
rungswerkzeug, welches es ermöglicht, Anwendungen basierend auf einem strukturierten Datenmodell
zu entwickeln.
Graphical Editor Framework
(GEF) 3.2 [Ecl06i]
GEF ermöglicht die Entwicklung grafischer Editoren auf Basis eines existierenden Applikationsmodells. Aus Entwicklersicht hat diese Vorgangsweise
den Vorteil, dass auf allgemeine, von GEF zur Verfügung gestellte, Operationen zurückgegriffen werden kann und die Möglichkeit besteht, diese bei Bedarf für domänenspezifische Applikationen zu erweitern.
Graphical Modeling Framework (GMF) 1.0 [Ecl06q]
Dieses Framework versucht die Projekte EMF und
GEF zu verbinden und so die Möglichkeit einer grafischen Modellierung zu schaffen. Basierend auf
modellgetriebenen Entwicklungstechniken ermöglicht GMF die Generierung von grafischen Modellierungseditoren.
Eclipse SDK 3.2
Kernplattform mit Unterstützung für Java und Eclipse RCP basierte Anwendungsentwicklung
Test and Performance Tools
Platform (TPTP) 4.2 [Ecl06r]
TPTP enthält Werkzeuge für die Durchführung von
Tests und Performanceanalysen, um die Qualität der
erstellten Anwendung während des gesamten Entwicklungsprozesses zu überprüfen und gegebenenfalls verbessern zu können. (siehe Kapitel Bewertung nach Kriterienkatalog – Softwarequalitätssicherung)
Web Tools Platform (WTP)
WTP enthält Entwicklungswerkzeuge für J2EE
Webapplikationen. (siehe Kapitel Bewertung nach
Evaluierung
30
1.5 [Ecl06f]
Kriterienkatalog – Programmierung)
Visual Editor (VE) 1.2
[Ecl06g]
Framework zur Entwicklung von GUI Designern
(siehe Kapitel Bewertung nach Kriterienkatalog –
Editor)
Tabelle 3.1: Eclipse - Überblick über die einzelnen Callisto Projekte
Der Marktanteil von Eclipse steigt, vor allem im Bereich der Java IDEs, seit Veröffentlichung von 1.0 im Jahr 2001 stetig an. So bescheinigten Umfragen, welche im
Jahr 2004 bzw. 2005 durchgeführt wurden, Eclipse einen Markanteil von 56,2%
bzw. 65,1% unter Java IDEs [BZ05].
3.1.2 Bewertung nach Kriterienkatalog
Editor
Eclipse verfügt über einen leistungsfähigen und vollständigen Editor, der dennoch
nicht überladen wirkt, siehe Abbildung 3.2. Die entsprechenden Editorkriterien aus
dem Kriterienkatalog werden alle unterstützt.
Abbildung 3.2: Eclipse - Codeeditor
Der Codeeditor verfügt über die Fähigkeit, den Quelltext in Echtzeit bereits bei der
Eingabe auf korrekte Syntax zu überprüfen. Falls eine Syntaxverletzung vorliegt,
Evaluierung
31
wird diese durch eine rote Unterwellung des betroffenen Bereichs gekennzeichnet.
Hierbei wäre es möglicherweise sinnvoll, die aktuell editierte Zeile von der Überprüfung auszunehmen, da jedes Codestück während der Eingabe temporär syntaktisch
fehlerhaft ist. Mittels Code Folding können einzelne Abschnitte (Methoden, Kommentare, Import-Statements) geklappt werden (siehe Abbildung 3.2: Zeile 19 bis 22).
Gefaltete Elemente können, mit am linken Editorrand platzierten kleinen
Plus/Minus-Grafiken, manuell auf- bzw. zusammengeklappt werden. Wird der
Mauszeiger über eine Plus-Grafik bewegt, erscheint der gefaltete Bereich als Tooltip-Text. Die „Marker Bar“ am linken Editorrand wird verwendet um z. B. Compilerfehler bzw. Warnungen (Abbildung 3.2: Zeile 8) anzuzeigen, Debugger Breakpoints (Abbildung 3.2: Zeile 13) sowie Lesezeichen zu setzen. Am rechten Editorrand befindet sich ein schmaler Streifen bei dem, mittels kleiner Rechtecke, die Anzahl und Position von Fehlern und Warnungen relativ zur Gesamtlänge der Quelltextdatei angezeigt werden. Durch einen Mausklick auf ein solches Rechteck ist es
rasch möglich zu den jeweiligen Problemen zu navigieren.
Fast in jeder Situation bietet der Editor durch Drücken einer bestimmten Tastenkombination eine Hilfestellung. Man kann package oder import-Deklarationen komplettieren. Innerhalb von Klassendefinitionen kann man sich Methodensignaturen für aus
Oberklassen vorhandenen Methoden einfügen lassen. Zudem kann man mit Hilfe
eines Template-Generators generische Methoden-Templates einfügen. So reicht etwa
ein „main“, um die übliche Startmethode einer Java-Anwendung im Quelltext zu
erstellen. Auch innerhalb von Methoden können Templates bei der Eingabe helfen.
Ein „for“ reicht, um etwa über ein Array oder eine Liste zu iterieren. Die Namen der
Laufvariable oder des Arrays können dabei eingestellt werden, müssen jedoch nur
einmal angegeben werden, da innerhalb des Templates automatisch alle Vorkommen
passend benannt werden. Eclipse versucht dabei, sinnvolle Variablennamen zu verwenden. Steht vor einem „for“ eine Array-Definition, so wird dieser Name benutzt.
Außerdem können alle Templates angepasst oder nach eigenen Wünschen erweitert
werden.
Die Code Completion öffnet nach kurzer Wartezeit oder durch Drücken einer entsprechenden Tastenkombination einen Assistenten, der alle, an der jeweiligen Stelle
syntaktisch möglichen, Alternativen präsentiert. Kurze Zeit später wird auch der
JavaDoc-Text [JaD06] zum ausgewählten Kandidaten angezeigt. Entscheidet man
sich für eine bestimmte Methode, bietet Eclipse schließlich noch eine Ausfüllhilfe
für die Parameter. Besonders praktisch ist die Code Completion auch bei inneren
Klassen. Um etwa einen ActionListener zu implementieren, reicht es, nach dem Text
„new ActionListener(“ die Completion auszulösen, und Eclipse fügt automatisch die
Evaluierung
32
notwendige Methode hinzu. Gibt es mehr als eine Methode, öffnet sich ein Auswahldialog. Sehr häufig bietet Eclipse auch eine Auswahl von Vorschlägen, wie ein
bestimmer Fehler korrigiert werden kann, den sogenannten QuickFix. Dazu kann ein
Popup-Menü geöffnet werden, welches anbietet, falsch geschriebene Methoden zu
korrigieren, neue Methoden zu implementieren, Imports oder Casts hinzuzufügen
und einiges mehr. [AR04]
Die meisten Editorfunktionalitäten können bei Bedarf angepasst oder komplett deaktiviert werden.
Mit dem Visual Editor (VE) [Ecl06g], aus der Callisto-Suite, stellt die Eclipse Foundation einen GUI-Designer zur Verfügung. Er kann bequem über die Eclipse Aktualisierungsfunktion installiert werden. VE ist nach [Ecl06g] eigentlich kein GUIDesigner sondern vielmehr ein Framework für die Entwicklung von User-InterfaceDesignern, kommt jedoch mit Referenzimplementierungen zur Gestaltung von Benutzeroberflächen mit den Java WidgetSets Swing und SWT. Es ist beabsichtigt,
den Visual Editor auch als Basis für GUI Designer anderer Programmiersprachen,
wie etwa C/C++, und alternativen WidgetSets, welche nicht von Java direkt unterstützt werden, zu verwenden.
Abbildung 3.3: Eclipse - Visual Editor Ansicht
Evaluierung
33
Die Oberflächeninformation wird beim Visual Editor nicht wie bei einigen anderen
GUI Designern in einer zusätzlichen Datei abgelegt, sondern die Komponenten- und
Layoutinformationen werden direkt aus dem Java Quelltext geparst. Es ist damit
prinzipiell möglich eine beliebige Java Datei mit dem Visual Editor zu öffnen. Es
steht eine Zwei-Wege Ansicht zur Verfügung: Einerseits wird die grafische Oberfläche in einer WYSIWYG Ansicht angezeigt, andererseits wird auch der Java Code
dargestellt. Änderungen in einer der beiden Ansichten rufen automatisch eine Änderung in der jeweils anderen Darstellung hervor. Der Editor unterstützt sämtliche LayoutManager der Java Standard Distribution, die Bedienung ist jedoch unterschiedlich
bequem. So werden absolute Positionierung [Sun06b] oder einfache LayoutManager
wie etwa das BorderLayout [Sun06c] sehr komfortabel unterstützt, komplexe Layouts, die etwa mit dem GridBagLayout [Sun06d] erstellt werden, erfordern jedoch
Hintergrundwissen über die genaue Funktionsweise des Managers und nehmen dem
WYSIWYG Editor seine Vorteile gegenüber der manuellen Konstruktion des grafischen Interfaces im Quelltext. Wünschenswert wäre die Unterstützung von LayoutManagern, welche explizit für Java GUI Designer entwickelt wurden wie etwa dem
GroupLayout [Sun06f].
Abbildung 3.4: Eclipse - WindowBuilder Ansicht, Formular mit Grouplayout
Evaluierung
34
Obwohl der Visual Editor sehr leistungsfähig ist, reicht er von der Bedienbarkeit und
Performance nicht an die GUI-Designer von Netbeans und IntelliJ IDEA, siehe deren Evaluierung, heran. Es stehen jedoch eine Reihe weiterer, großteils kommerzieller, Interface Designer als Eclipse Erweiterungen zur Verfügung.
Mit dem WindowBuilder [Ins06] der Firma Instantiations steht ein kommerzieller
GUI Designer für Eclipse zur Verfügung, der ebenfalls direkt mit dem Quelltext arbeitet, mit dem sich jedoch durch die Unterstützung von LayoutManagern wie
GroupLayout oder FormLayout [Jgo06] auch komplexe grafische Strukturen einfach
erstellen lassen. Der WindowBuilder unterstützt wie der Visual Editor sämtliche
gebräuchlichen Java WidgetSets: AWT, Swing und SWT.
Alle untersuchten GUI Designer ermöglichen das Platzieren von Komponenten per
Drag And Drop von der sogenannten Palette, die auch um eigene Komponenten (JavaBeans [Sun06g]) erweitert werden kann, in die grafische Ansicht.
Eclipse stellt einen umfangreichen Refactoringsupport zur Verfügung und deckt damit alle im Kriterienkatalog beschriebenen Refactoring-Prozesse ab (siehe Abbildung 3.5). Vor der Durchführung eines Refactorings bietet Eclipse die Möglichkeit
einer Voransicht, um alle Änderungen prüfen zu können.
Abbildung 3.5: Eclipse - Refactoringmethoden, Voransicht eines Refactoringprozesses
Refactorings, die lokal an einem Projekt durchgeführt werden, können in einem Refactoring-Skript gespeichert werden und so automatisiert in beliebigen Projekten
angewendet werden. Beispielsweise ist es denkbar, dass der Hersteller einer Soft-
Evaluierung
35
warebibliothek während seiner Refactorings diese in einer Datei mitprotokolliert.
Den Kunden wird bei einer neuen Version der Komponente auch die Skriptdatei mitgeliefert, um ihnen die Möglichkeit zu bieten, alle Änderungen, welche durch die
aktualisierte Hersteller-Komponente notwendig werden, automatisch durch das
Skript durchführen zu lassen.
Die Eclipse Distribution steht neben der hier evaluierten englischen Version durch
die Unterstützung sogenannter Language Packs [Ecl06k] auch in vielen anderen
Sprachen zur Verfügung. Da es viele Plugins oft nur auf Englisch gibt, sollte man
jedoch nach Möglichkeit die englische Fassung von Eclipse beibehalten, um etwaige
sprachliche Inkonsistenzen zu vermeiden.
Der Aufbau der Arbeitsumgebung wird unter Eclipse mit sogenannten Perspektiven
realisiert. Eine Perspektive definiert eine Reihe von Fenstern (im Eclipse-Kontext als
Views bezeichnet) welche so angeordnet sind, dass sie für den gewählten Zweck
eine produktive und bequeme Anwendung ermöglichen. Es ist möglich, bestehende
Perspektiven zu kopieren oder abzuändern, um es den eigenen Bedürfnissen anpassen zu können. Zu den wichtigsten Views, neben der Editoransicht, für die Java
Entwicklung zählen:
•
Package Explorer: Dieser gibt einen Überblick über die Projekte mit dessen
Elementen, wie Packages, Klassen, Methoden und Variablen.
•
Outline View: Diese dient zur Anzeige von Strukturdaten einer Ressource. In
der Java Entwicklung werden die Klassen, Methoden und Variablen, der aktuell geöffneten Java Datei, angezeigt. Im Unterschied zum Package Explorer, welcher ebenfalls in der Lage ist diese Informationen anzuzeigen, ermöglicht die Outline View eine individuelle Anzeige der Strukturen.
•
Problems View: Diese Komponente zeigt gefundene Probleme an, beispielsweise Kompilierfehler und Warnungen.
•
Tasks View: Diese enthält eine Liste von Aufgaben mit einer Referenz zur
betroffenen Datei mit Liniennummer. Einträge in diese Liste können beispielsweise direkt im Sourcecode, durch „ToDo“ Inline-Kommentare, hinzugefügt werden.
Entwurfsmuster (Design Patterns) werden von Eclipse standardmäßig nicht unterstützt. Erweiterungen für ältere Eclipse Versionen, welche zum Zeitpunkt des Verfassens dieser Arbeit mit der aktuellen Eclipseversion nicht kompatibel waren, ste-
Evaluierung
36
hen mit den Erweiterungen PatternBox [Pat06], Pattern Support for Eclipse (PSE)
[PSE06] und WebOfPatterns [WOP06] zur Verfügung.
Modellierung
Die Firma Omondo [Omo06a] bietet mit EclipseUML ein umfangreiches UML Modellierungswerkzeug als Eclipse Erweiterung an. EclipseUML bietet eine umfangreiche UML2 Unterstützung und erlaubt die Erstellung folgender Diagramme: Aktivitätsdiagramm, Anwendungsfalldiagramm, Klassendiagramm, Kollabrationsdiagramm, Kompontendiagramm, Objektdiagramm, Sequenzdiagramm, Verteilungsdiagramm und Zustandsdiagramm. Die Modellierungssoftware setzt auf die Eclipse
Projekte Graphical Editor Framework (GEF) und Eclipse Modeling Framework
(EMF) auf und erlaubt so eine native Integration in die Plattform.
Abbildung 3.6: Eclipse - EclipseUML, Klassendiagramm während Roundtrip Engineerings
EclipseUML unterstützt Forward Engineering, Reverse Engineering und Roundtrip
Engineering. In Abbildung 3.6 wird exemplarisch gezeigt, wie in einem einfachen
Projekt parallel mit Klassendiagramm und Quelltext gearbeitet werden kann. Änderungen im Quelltext sollten direkt in das Diagramm übernommen werden und umgekehrt. Diese Vorgangsweise würde einem Roundtrip Engineering enstprechen.
Quellcode- und UML-Ansicht können übersichtlich nebeneinander platziert werden.
EclipseUML leistet sich beim Editieren jedoch einige Synchronisierungsfehler, so-
Evaluierung
37
dass nicht alle Änderungen übernommen werden. Erst ein komplettes Schließen der
UML Ansicht, gefolgt von einem erneuten Öffnen, kann das Problem beheben. Es
stellt sich die Frage, ob durch dieses Problem ein sinnvolles Arbeiten mit komplexen
Projekten möglich ist, da es schon bei relativ einfachen Klassenstrukturen zu derartigen Problemen kommen kann.
Zur Dokumentation bietet EclipseUML die Möglichkeit eine erweiterte JavaDoc
API-Dokumentation zu erstellen, welche auch auswählbare UML Diagramme enthalten kann.
Laut Omondo wird EclipseUML gegen Ende 2006 um Funktionen für die Modellgetriebene Entwicklung erweitert.
Für die modellgetriebene Entwicklung existiert die Erweiterung openArchitectureWare (oAW), welche seit Anfang 2006, als Teil des Technology Project für modellgetriebene Entwicklung Eclipse GMT, ein offizielles Eclipse Projekt ist. Mit oAW
ist es prinzipiell möglich, beliebige Modelle zu verarbeiten. Standardmäßig bietet es
Unterstützung für EMF, verschiedenste UML Werkzeuge, wie beispielsweise MagicDraw [MD06], Poseidon for UML [Pos06], Enterprise Architect [EA06], Rational
Rose [Rose06], Eclipse UML2, textbasierte Modelle, XML und Visio. Aus diesen
Modellen kann openArchitectureWare beliebige textuelle Ausgaben generieren.
Die Integration von oAW in Eclipse unterstützt den Entwickler, sowohl bei der Generatorenentwicklung, als auch bei der Erstellung einer domänenspezifischen Entwicklungsumgebung auf Basis der entwickelten Generatoren. Für die erstellte IDE
können beispielsweise GEF-basierte Editoren entwickelt werden.
Die Entwicklung eines Generators basierend auf oAW umfasst nach [Vö06b] drei
Haupttätigkeiten: Die Definition/Implementierung des Metamodells der betreffenden
Domäne, das Schreiben von Templates sowie die Verifikation, welche das korrekte
Laden und Verarbeiten von Modellen ermöglicht. Die Implementierung des Metamodells geschieht mittels Javaklassen, bei deren Entwicklung JDT zum Einsatz
kommt oder Klassen, welche aus einer existierenden UML-Modelldefinition automatisch generiert werden. Bei der Erstellung der Templates mit der oAWTemplatesprache unterstützt der Editor den Entwickler mit bereits bekannten Funktionalitäten wie Code Completion und Syntax Highlighting. Die Generierung und
Modellverifikation erfolgt normalerweise mit Hilfe eines Ant-Skriptes [Ant06]. Treten bei diesem Vorgang Probleme auf, hilft die IDE mit nützlichen Warnungen und
Tipps.
Evaluierung
38
Abbildung 3.7: Eclipse - openArchitectureWare Funktionsüberblick (nach [Völ06a])
Ein wichtiger Aspekt bei modellgetriebener Entwicklung ist die Definition der domänenspzifischen Sprache DSL. Diese kann sowohl textbasiert als auch grafisch
sein. Bei der grafischen Variante benötigt man einen entsprechend leistungsfähigen
Editor, der jedoch meist nicht zur Verfügung steht. Alternativ wird oft auf UML und
Profile ausgewichen. OpenArchitectureWare stellt für diese Tätigkeit einen Generator zur Verfügung, mit dem es möglich ist, einen grafischen Editor für die DSL zu
erzeugen.
Ein weiteres UML/MDA Modellierungswerkzeug steht mit dem Borland Produkt
Together als Eclipse Plugin zur Verfügung. Together gibt es nätürlich auch für die
Borland eigene IDE JBuilder und wurde in dieser Arbeit im entsprechenden Abschnitt bereits behandelt.
Evaluierung
39
Programmierung
Eclipse stellt in der Standarddistribution zunächst eine umfangreiche Umgebung zur
Entwicklung von Javaanwendungen zur Verfügung. Die Eclipse Foundation stellt
mit der CDT Erweiterung, welche Teil der Callisto Distribution ist, eine Möglichkeit
bereit, auch C bzw. C++ Code mit der Eclipse Plattform zu entwickeln [Sko07].
Von Seiten der Community wird intensiv an der Unterstützung anderer Programmiersprachen gearbeitet. So stehen inzwischen beispielsweise Eclipse basierte Entwicklungsumgebungen für die Programmiersprachen PHP [PhE06], Perl [PeE06]
und Phyton [PyE06] zur Verfügung. Der Entwicklungsstand dieser Erweiterungen ist
derzeit noch sehr unterschiedlich und liegt meist deutlich unter der Java Unterstützung durch JDT.
Die Eclipse 3.2 Kerndistribution stellt mit der Plugin Entwicklungsumgebung PDE
notwendige Klassenbibliotheken und entsprechende IDE Funktionalitäten bereit, um
sowohl Eclipse Erweiterungen, als auch eigenständige Rich-Client-Plattform Anwendungen auf Basis des Eclipse Frameworks entwickeln zu können.
Für viele Klassenbibliotheken, welche Teil des Java Development Kits sind, existiert
eine entsprechende Unterstützung durch Eclipse. Die Entwicklung mit den grafischen Frameworks AWT und Swing wird beispielsweise durch den GUI-Designer
Visual Editor wesentlich vereinfacht.
Callisto bietet über die automatische Update- und Erweiterungsfunktion eine Reihe
von häufig benötigten Klassenbibliotheken und Frameworks. Tabelle 3.2 zeigt eine
Aufstellung der mitgelieferten Bibliotheken. In den meisten Fällen ist es nicht notwendig diese Komponenten explizit zu installieren, da sie meist als Abhängigkeiten
von den einzelnen Callisto Projekten benötigt und daher automatisch bei der Installation eines dieser Projekte bezogen werden.
Apache Batik 1.6.0 [Apa06i]
Diese Bibliothek ermöglicht die Darstellung, das
Erzeugen und die Manipulation von Scaleable Vector Graphics (SVG) [SVG06]. Batik kann darüber
hinaus auch SVGs in Rastergrafiken konvertieren.
Apache Commons Codec
1.3.0 [Apa06a]
Implementierungen für häufig verwendete Ver- und
Entschlüsselungsverfahren wie beispielsweise Base64, Hex und URLs
Apache commons logging
Diese Bibliothek stellt eine allgemeine Schnittstelle
Evaluierung
40
1.0.4 [Apa06b]
für verbreitete Logging-Bibliotheken, wie Log4J
[L4J06] oder das Sun Java Logging Framework
[JAPI06a] bereit.
Apache Derby Core 10.1.2
[Apa06j]
Derby ist ein Java-basiertes relationales DatenbankManagement-System. Aufgrund seiner geringen
Größe kann es sehr einfach mit Java Applikationen
gebündelt werden. Derby ist ab Version 1.6 in das
Java Development Kit integriert.
Apache Jakarta log4j 1.2.8
[L4J06]
Log4J ist ein Framework zum Loggen von Java
Anwendungsmeldungen. Die Meldungen können
wahlweise auf die Standardausgabe, in eine Datei
oder in beliebige andere Ziele geschrieben werden.
Apache Xerces 2.8.0
[Xerces06]
Xerces ermöglicht das Parsen und Generieren von
XML-Daten. Das Unterprojekt Xerces-J stellt validierende Parser für Java bereit.
Lowagie iText 1.3.0
[iText06]
iText erlaubt die Erstellung und Manipulation von
PDF, RTF und HTML Dateien. Das Hauptaugenmerk liegt jedoch auf das PDF-Format, für welches
iText auch die meisten Operationen zur Verfügung
stellt.
Mozilla Rhino 1.6.0
[Rhino06]
Rhino ist eine Implementierung der Skriptsprache
JavaScript. Es ermöglicht das Kompilieren von JavaScript-Quelltext in Java-Bytecode aber auch eine
JavaScript Interpretation zur Laufzeit.
Tabelle 3.2: Eclipse - Mitgelieferte Klassenbibliotheken der Callisto Distribution
Eine typische Middleware-Art ist laut [And04] die Message Oriented Middleware
(MOM). Diese ermöglicht die Kommunikation zwischen lose gekoppelter Komponenten und Systemen. Message Oriented Middleware dient der asynchronen Kommunikation von Komponenten und Systemen anhand von Botschaften (Messages).
Eine solche Message Oriented Middleware ist im Java Message Service [JMS06]
(JMS) von Sun Microsystems beschrieben. JMS wird von dem Teilprojekt JST der
Web Tools Platform (WTP) unterstützt.
Evaluierung
41
Die von der Object Management Group (OMG) standardisierte MiddlewareArchitektur CORBA [COR06] wird von keinem Produkt der Eclipse Foundation
direkt untersützt, es stehen jedoch mit ORB Studio [OSt06] und EclipseCorba [ECo06] entsprechende Erweiterungen zur Verfügung, um CORBA Funktionalitäten
nachzurüsten.
Komponenten-Standards sind im Java Bereich vor allem in der Java 2 Platform, Enterprise Edition, J2EE anzutreffen. J2EE ist ein laut [And04] ein von Sun Microsystems entwickeltes Rahmenwerk für Design, Entwicklung, Zusammenbau und
Verteilung von Unternehmens-Anwendungen auf Basis von Komponenten. Die Unterstützung von J2EE in Eclipse wird durch das Callisto-Projekt Web Tools Platform
bereitgestellt, welche in diesem Abschnitt noch beschrieben wird.
Wird Eclipse als IDE zur Entwicklung von Javaanwendungen verwendet, ist es, wie
jede andere Java Entwicklungsumgebung, im Grunde „nur“ ein Frontend zur Programmierung mit einem entsprechenden Java Development Kit, beispielsweise der
Firma Sun Microsystems. Durch diese Tatsache und durch die große Verbreitung der
Programmiersprache Java stehen Klassenbibliotheken und Komponenten von Drittanbietern in sehr großem Umfang zur Verfügung. Java Klassenbibliotheken werden
normalerweise als JAR-Archive bereitgestellt. Zusätzlich gibt es meist eine JavaDoc
API-Dokumentation. Das jeweilige Archiv und die Dokumentation lassen sich bequem zu einem Projekt hinzufügen. Die JavaDoc-Dokumentation ist nützlich, um
zusätzlich zur Code Completion des Editors auch eine kurze Hilfestellung aus der
API-Dokumentation einblenden zu können.
Abbildung 3.8: Eclipse - Klassenbibliothek eines Drittanbieters einbinden
Evaluierung
42
Optional ist es auch möglich, neben der API-Dokumentation, den Quelltext der Klassenbiblothek einzubinden. Das hat den Vorteil, dass jederzeit spezielle Implementierungsdetails untersucht werden können, und die Dokumentation direkt aus Quelltextkommentaren geparst werden kann.
Bei der Internationalisierung von Anwendungen stehen in der Standard Java Klassenbibliothek bereits eine Reihe von Klassen zur Verfügung, die diesen Vorgang
erheblich vereinfachen. Mit der Klasse java.util.Locale beispielsweise kann
die gewünschte Sprache und geographische Region gesetzt werden. Basierend auf
diesen Informationen werden sprachabhängige Informationen, z. B. Datumsdarstellung, entsprechend spezifisch angezeigt. Wenn Java-Programme sprachunabhängig
gestaltet werden sollen, besteht die Möglichkeit, alle Zeichenketten einer Sprache
durch symbolische Namen, wie Variablen zu ersetzen. In Java wird die Verbindung
zwischen den Variablen und den sprachspezifischen Texten mithilfe der Klasse java.util.ResourceBundle hergestellt. Diese Klasse ermöglicht es, alle Texte und
Informationen einer Lokalisierung in einer Datei abzulegen. In dieser Datei wird für
jeden Text ein Schlüssel-Text Paar abgelegt. Um keine Probleme mit unterschiedlichen Zeichenkodierungen zu bekommen, werden die Dateien konsequent Unicode
codiert.
Zum Auslagern der länderspezifischen Texte bietet Eclipse einen komfortablen Assistenten an, siehe dazu Abbildung 3.9.
Abbildung 3.9: Eclipse - Assistent zum Auslagern sprachspezifischer Texte
Evaluierung
43
Zum Verwalten und Übersetzen der einzelnen Sprachdateien bietet sich das kostenlose Eclipse Plugin JInto [JInto06] an. In JInto werden die Texte in einer konfigurierbaren Sprachspalte zum Editieren angezeigt. Änderungen werden automatisch in
der entsprechenden Sprachdatei gespeichert.
Eclipse 3.2 ist die erste Eclipse Version, welche eine umfangreiche Datenbankunterstützung direkt von der Eclipse Foundation enthält. Die Data Tools Platform (DTP)
ist Teil der Callisto Suite und stellt eine Reihe datenbankspezifischer Funktionalitäten bereit.
DTP ermöglicht die Verwaltung von mehreren Datenbankverbindungen. Für einige
Datenbanksysteme, wie beispielsweise MySQL, Oracle oder Sybase, werden die
notwendigen Treiber bereits mitgeliefert. Für andere Datenbanksysteme können die
JDBC Treiber des jeweiligen Herstellers einfach nachgerüstet werden. DTP Datenquellen sind nicht auf relationale Datenbanken beschränkt. Die sogenannten ODA
(Open Data Access) Quellen bieten auch Unterstützung für Formate wie CSV oder
XML.
Um eine Datenbankverbindung einzurichten, steht ein komfortabler Assistent zur
Verfügung. Die Data Tools Platform enthält eine spezielle Datenbankperspektive,
welche zunächst eine Ansicht zur Verwaltung der einzelnen Verbindungen bietet,
den Data Source Explorer. Dieser bietet eine Übersicht über die Strukturen der verbundenen Datenbank, wie Tabellen, Spalten, gespeicherte Prozeduren und Trigger.
Die Hauptansicht der Datenbankperspektive ist ein SQL-Abfrageeditor. Er unterstützt das Öffnen und Speichern von Dateien, Syntax Highlighting, Code Completion
und eine Möglichkeit, Abfragen durchzuführen. Die Abfrageergebnisse werden in
einer weiteren Ansicht in tabellarischer Form angezeigt und können auch spaltenweise sortiert werden. Ältere Abfragen und deren Ergebnisse werden in einer Liste
verwaltet und können jederzeit bequem untersucht werden. Die Resultate können
auch in verschiedenste Formate exportiert werden.
Einige interessante Features sind laut [Ecl06h] geplant, darunter ein grafischer SQLEditor und eine detaillierte Abfrageanalyse.
Zur Webentwicklung stellt die Eclipse Foundation die Web Tools Platform (WTP)
zur Verfügung, welche auch Teil der Callisto Familie ist. Das Ziel der WTP ist es,
nach [Car05], eine allgemeine, erweiterbare und auf anerkannte Standards aufbauende Plattform bereitzustellen, welche auf Eclipse Kernmodule aufsetzt. Das WTPPlugin besteht aus den Teilprojekten Web Standard Tools (WST) und Java Standard
Evaluierung
44
Tools (JST). Die Web Standard Tools stellen die grundlegende Infrastruktur für das
Erstellen von Webapplikationen bereit und halten sich an festgelegte Standards von
W3C, OASIS und ANSI. Zu diesen Standards gehören beispielsweise HTML, XML,
XML Schema, XPath, SQL aber auch WebServices wie UDDI und WSDL. Die für
das Teilprojekt JST relevanten Standards werden durch den sogenannten Java Community Process [JCP06] definiert. JST erlaubt die Entwicklung von Webanwendungen gemäß der J2EE Spezifikation [J2EE06]. Durch diese beiden Teilprojekte werden Werkzeuge für nicht-programmiersprachenabhängige Teile einer Webapplikation durch WST abgedeckt und der JST Teil ermöglicht die Realisierungen mittels
J2EE Technologie. WTP deckt damit nur einen Teil der vorhandenen Technologien
für Webanwendungen ab, Quasi-Standards wie Struts [Struts06] und Hibernate
[Hib06] werden nicht direkt unterstützt. Das Web Tools Projekt hat jedoch nicht das
Ziel, Lösungen für alle denkbaren Anwendungsfälle bereitzustellen, sondern bietet
eine erweiterbare Plattform, die als Basis für zusätzliche Technologien gut geeignet
ist.
Abbildung 3.10: Eclipse - WTP Funktionsumfang (Grafik nach [EM05])
Das Web Standard Tools Teilprojekt bietet eine umfassende Editorunterstützung für
Standardsprachen wie HTML/XHTML, SQL und XML. So stehen die für Eclipse
typischen Features wie Refactoring, Code Completion, spezielle Outline Views für
Evaluierung
45
die Struktur des jeweiligen Dokuments und die Möglichkeit, eigene Code-Templates
zu definieren, zur Verfügung. Die XML Unterstützung ist umfangreich und ermöglicht auch die Validierung der Strukturen gegen entsprechende Schemadefinitionen.
Das Plugin bietet auch die Möglichkeit einer Anbindung der marküblichen Applikationsserver, wie JBoss oder Tomcat, mittels Serveradapter. Spezielle Server können
gegebenenfalls auch über eine generische Anbindung mittels XMLKonfigurationsdatei eingebunden werden. Die eingebundenen Zielserver können aus
der Plattform heraus gestartet, gestoppt und die entwickelte Anwendung darauf ausgeführt werden. Das JST Teilprojekt beherrscht typische J2EE Artefakte, siehe dazu
Tabelle 3.3. Weiters stellt es einen komfortables Java Server Pages Editor zur Verfügung welcher sowohl HTML als auch JSP Code inklusive Refactoring beherrscht.
Enterprise Java Beans (EJB)
[EJB06]
Unter Enterprise Java Beans versteht man nach
[And04] eine von Sun Microsystems ausgearbeitete
Standard-Architektur zur Entwicklung verteilter
komponentenbasierter Unternehmensanwendungen
auf Basis der Programmiersprache Java.
Servlets [Serv06]
Servlets sind nach [And04] Java-Klassen, die eine
Anfrage (Request) dynamisch verarbeiten und eine
Antwort erzeugen.
Java Server Pages (JSP)
[JSP06]
Java Server Pages sind nach [And04] textbasierte
Dokumente, die als Servlets ausgeführt werden.
Java Database Connectivity
(JDBC) [JDBC06]
JDBC ist eine Java-API, die eine einheitliche und
standardisierte Schnittstelle zu verschiedensten Datenbanken bereitstellt. Der Schwerpunkt der Schnittstelle liegt bei der Unterstützung von relationalen
Datenbanken. JDBC-Implementierungen werden
meist direkt von den Datenbankherstellern bereitgestellt.
Java Transaction API (JTA)
[JTA06]
Die Java Transaction API erlaubt einer Anwendung
die Steuerung der Transaktionsverwaltung.
Java Message Service (JMS)
[JMS06]
Laut [BWB+06] versteht man unter JMS eine JavaAPI, die Interfaces bereitstellt, um Nachrichten zu
erzeugen, versenden, empfangen und lesen zu kön-
Evaluierung
46
nen. Die Nachrichten werden asynchron zwischen
Anwendungen und Komponenten ausgetauscht.
Java Naming and Directory
Interface (JNDI) [JNDI06]
JNDI ist eine Java-API für Verzeichnis- und Namensdienste. Die Schnittstelle erlaubt einen namensbasierten Zugriff auf Daten- oder Objektreferenzen. Im J2EE Umfeld wird JNDI vor allem verwendet, um verteilte Objekte in einem Netzwerk zu
registrieren und diese durch Remote-Aufrufe anderen Komponenten zur Verfügung zu stellen.
Java Webdienste [JWS06]
Webdienste sind nach [BWB+06] Komponenten,
deren Funktionalitäten und Daten von Clients oder
anderen Anwendungen über Protokolle der Internettechnologie angesprochen werden. Java Webdienste
werden in der Programmiersprache Java entwickelt.
Tabelle 3.3: Eclipse - Vom Teilprojekt JST von WTP unterstützte J2EE Artefakte
Für die Entwicklung von Java Anwendungen für mobile Endgeräte steht die Erweiterung EclipseME [EME06] zur Verfügung. Das Sun J2ME Wireless Toolkit (WTK)
[JWTK06] ist die Referenzimplementierung von J2ME [J2ME06] und MIDP
[MIDP06]. Es stellt notwendige Klassenbibliotheken sowie einen Geräteemulator
zur Verfügung. Neben Suns J2ME WTK stehen noch einige alternative Frameworks
von Herstellern Mobiler Endgeräte bereit, wie beispielsweise das Motorola SDK for
J2ME [MSDK06] bzw. die Nokia Developer Suite for J2ME [NSDK06]. EclipseME
integriert das gewählte Framework in die IDE, um so auch für diese spezielle Applikationsentwicklung die Vorzüge einer leistungsfähigen Entwicklungsumgebung mit
ihren Vorteilen, vor allem im Editor- und Softwarequalitätssicherungsbereich, nutzen zu können.
Evaluierung
47
Abbildung 3.11: Eclipse - EclipseME in Java Perspektive mit Sun J2ME WTK Simulator
EclipseME stellt eigene Projektassistenten für die Erzeugung der Grundstruktur der
mobilen Anwendung als auch für die Erstellung der MIDlet-Klassen [J2ME06] zur
Verfügung. Weiters steht ein komfortabler Editor für die Bearbeitung der sogenannten Java Application Descriptor (JAD) Datei bereit, welcher es erlaubt, die MIDlets
zu konfigurieren, ohne direkt in der entsprechenden Textdatei arbeiten zu müssen.
Damit kann die Fehleranfälligkeit reduziert werden. EclipseME erlaubt die Verteilung der Applikationen sowohl als Standard JAR/JAD Paket, als auch eine verschlüsselte Version, falls ein entsprechender Obfuscator installiert ist. Passende Obfuscatoren wären beispielsweise ProGuard [ProG06] oder RetroGuard [RetG06]. Die
Entwicklungsmöglichkeiten mobiler Java Applikationen mit EclipseME sind gegenüber den Möglichkeiten in anderen evaluierten Entwicklungsumgebungen etwas
eingeschränkt. So bietet EclipseME beispielsweise keinen Interface- bzw. Workflow
Designer.
Evaluierung
48
Eclipse stellt einen komfortablen und leistungsfähigen Debugger zur Verfügung. Die
Debug-Perspektive (siehe Abbildung 3.12) bietet verschiedene spezielle Views für
die diversen Debugging Aktivitäten: Die Debug View zeigt alle laufenden Threads
mit ihren Stacks, wenn der Debugger z. B. durch einen Breakpoint unterbrochen
wurde. Variables-, Expressions- und Display View werden verwendet, um den derzeitigen Programmzustand untersuchen zu können. Mittels Variables View ist es
möglich, Felder, lokale Variablen und Methodenparameter anzuzeigen. Beispielsweise ist es möglich, den genauen Inhalt einer Liste anzuzeigen und falls gewünscht,
einzelne Elemente zu ändern (siehe Variables View in Abbildung 3.12). Breakpoints
View bietet eine Liste aller gesetzten Haltepunkte im Code.
Abbildung 3.12: Eclipse - Debugger Perspektive
Der Debugger ermöglicht es, sogenannte „Code Snippets“, also Quelltext, der nicht
Teil des untersuchten Projektes ist, in der Display View auszuführen. Die Untersuchung dieses Quelltexts geschieht im Kontext der derzeit gewählten Klasse. Es ist
beispielsweise möglich ein zusätzliches Listenelement hinzuzufügen oder selten aufgerufene Methoden im Betrieb zu testen. Der Eclipse Debugger unterstützt darüber
Evaluierung
49
hinaus „Hot Code Replace“, d. h. der Quelltext kann während einer Debugging Session geändert werden, ohne die Virtuelle Maschine neu starten zu müssen. Durch
Einschränkungen seitens der VM ist festgelegt, welche Teile des Codes geändert
werden dürfen.
Der Eclipse Debugger folgt dem Client-Server Designprinzip, d. h. das untersuchte
Programm kann von einem beliebigen Computer im Netzwerk gestartet werden und
von einem anderen Rechner mit Eclipse Installation debuggt werden. Diese Remote
Debugging Funktionalität ist besonders sinnvoll, wenn das Java Programm auf einer
Plattform läuft, auf der es nicht möglich ist Eclipse zu installieren, beispielsweise auf
einem PocketPC oder einem Handy. Auch zum Debuggen von Applikationen, die
auf bestimmten Serverplattformen laufen müssen, wie etwa eine Anwendung eines
J2EE Applikationsservers, ist dieses Debuggerdesign vorteilhaft zu nutzen.
Für Unit Tests wird in Eclipse das JUnit Testframework verwendet. Beim Durchführen von JUnit Testfällen wird automatisch in der aktuellen Perspektive eine entsprechende Ansicht eingeblendet, die in Funktion und Ansicht an die Orginal JUnit
Swingoberfläche angelehnt ist, siehe Abbildung 3.13. Eclipse unterstützt sowohl
JUnit Version 3 als auch JUnit 4. Dieses macht jedoch intensiven Gebrauch von Annotationen (mit Java 1.5 eingeführtes Sprachfeature) und setzt deshalb eine entsprechend aktuelle Java Version voraus.
Abbildung 3.13: Eclipse - JUnit Ansicht
Wünschenswert wäre eine integrierte Code-Coverage Analyse. Diese kann jedoch
durch Erweiterungen wie Coverlipse [Cov06] oder Clover [Clov06] nachgerüstet
werden.
Evaluierung
50
Mit dem Callisto Projekt TPTP (Test and Performance Tools Platform) steht Eclipse
eine Sammlung von Frameworks und Komponenten zur Verfügung, die Themen wie
Testen, Profiling und Monitoring adressieren. Der TPTP Profiler bietet eine Speicheranlyse, eine Laufzeitanalyse sowie eine Methoden-Code-Abdeckung. Es wird sowohl Lokal- als auch Remoteprofiling unterstützt. TPTP stellt für den Profiler eine
entsprechende Perspektive zur Verfügung. Die wichtigste View dieser Perspektive
ist der Profiling Monitor, eine Art Zusammenfassung über den aktuellen Profilingprozess darstellt (siehe Abbildung 3.14).
Bevor mit dem Profiling begonnen werden kann, muss zunächst gewählt werden,
welche Analysen durchgeführt werden sollen, sowie welche Informationen während
des Vorgangs gesammelt und aufbereitet werden müssen.
Die gesammelten Informationen können in den verschiedenen tabellarischen (z. B.
Speicherstatistik, Ausführungsstatistik, Objektreferenztabelle) und grafischen (z. B.
UML2 Sequenzdiagramm, Ausführungsflussdiagramm) Views aufbereitet werden.
Besonders interessant ist die Aufbereitung als Sequenzdiagramm. Die im Diagramm
aufgeführten Klassennamen sind direkt mit dem Quelltext verlinkt. Im linken Fensterbereich symbolisiert die Stärke der roten Farbe wie kritisch die Performance im
korrespondierenden Bereich des Sequenzdiagramms ist (siehe Abbildung 3.14).
Abbildung 3.14: Eclipse - Profiler mit Montitor und Sequenzdiagramm (Bildschirmfoto: [Ecl06s])
Quality Audits können beispielsweise mit der Eclipse Plugin Version des kostenlosen Programmes Checkstyle [CkS06] durchgeführt werden. Die Integration in die
Evaluierung
51
IDE erfolgt wie gewohnt durch eine entsprechende Installations-URL3 über die Eclipse Update Funktion. Checkstyle bettet sich in den Einstellungsdialog von Eclipse
ein, in dem Audit Konfigurationen definiert werden können, siehe dazu auch Abbildung 3.15.
Abbildung 3.15: Eclipse - Konfiguration des Audit Plugins Checkstyle
Es können mehrere Konfigurationen gleichzeitig angelegt und konfiguriert werden.
Standardmäßig enthält die Checkstyle Distribution die im Java Bereich häufig verwendeten Sun Code Conventions [SCC06]. Es lassen sich jedoch bequem weitere
Konfigurationen anlegen bzw. bestehende modifizieren. Alle erfassten Konventionen
können im XML-Format im- und exportiert werden und so z. B. anderen Projektmitgliedern zur Verfügung gestellt werden.
Checkstyle bindet sich in den Kompilierprozess von Eclipse ein, welcher bei vielen
aktivierten Regeln deutlich mehr Zeit benötigt. Nach dem Übersetzungsprozess werden die Ergebnisse sowohl im Meldungsfenster als auch direkt im Editor angezeigt.
Für Auditanalysen stehen für die Tools FindBugs [FB06] sowie PMD [PMD06] ebenfalls leistungsfähige Eclipse Erweiterungen zur Verfügung. Diese Programme
untersuchen den Quelltext jedoch weniger auf Code-Konventionen sondern mehr
nach potentiellen Fehlern und Schwachstellen, wie beispielsweise fehlende Excepti-
3 Checkstyle Installations URL: http://eclipse-cs.sourceforge.net/update
Evaluierung
52
onbehandlung im catch Block, unbenutzte Variablen und mehrfach vorhandener Code.
Das kostenlose Plugin Metrics [EMe06] erlaubt eine Analyse des Quelltexts nach
den üblichen Qualitätsmetriken. Nach der Eingabe der entsprechenden URL4 lässt
sich Metrics komfortabel über die Eclipse Update Funktion installieren. Die zu berücksichtigenden Metriken können im Eclipse Einstellungsdialog konfiguriert werden. Auf Projektebene muss das Plugin einmalig aktiviert werden, anschließend wird
der Code bei jedem Kompiliervorgang des Projekts, entsprechend der eingestellten
Metriken, analysiert.
Abbildung 3.16: Eclipse - Plugin Metrics
Metrics bietet eine tabellarische Ansicht, um zutreffende Metriken, des aktuell im
Projektnavigator selektierten Java Elements, beispielsweise eine Klasse oder ein
Paket, darzustellen. Zusätzlich existiert eine View mit einem Graphen, um die Abhängigkeiten der einzelnen Pakete ansprechend visualisieren zu können. Zur weiteren Verarbeitung, z. B. für Refactoringprozesse, können die erzeugten Daten als
XML-Datei exportiert werden.
Im Bereich des Application Lifecycle Managements war man bei Eclipse bisher auf
externe Lösungen angewiesen. Mit dem relativ jungen Application Lifecycle Framework (ALF) Projekt [Ecl06m] der Eclipse Foundation wird derzeit daran gearbeitet die typischen Phasen der Anwendungsentwicklung, vom ersten Entwurf, über die
4 Metrics Installations URL: http://metrics.sourceforge.net/update
Evaluierung
53
Modellierung und darauf folgende Implementierung bis zum Testen und Ausliefern
des Produkts, abdecken zu können.
Derzeit wird nach [Ecl06n] bei einem typischen ALM-System auf eine Reihe verschiedenster Produkte zurückgegriffen, welche untereinander in einer Punkt-zuPunkt Kommunikation stehen. Diese Integrationsform ist adäquat für eine geringe
Anzahl beteiligter Anwendungen. Bei vielen Anwendungen steigt der Kommunikationsaufwand extrem an. Der Administrations- und Wartungsaufwand bei einer derartigen Konfiguration ist schwierig und die Fehleranfälligkeit nimmt zu.
Die ALF Lösung für dieses Problem ist nach [Ecl06n] die Einführung eines zentralen
Navigators welcher die Interaktionen zwischen den Anwendungen steuert. Ein standardisiertes Kommunikationsformat ermöglicht die einfache Integration einer neuen
Anwendung. Abbildung 3.17 zeigt einen Überblick über die ALF Architektur.
Abbildung 3.17: Eclipse - ALF Architektur (Grafik: [Ecl06n])
ALF strebt primär nicht die Neuentwicklung einzelner ALM Anwendungen an, sondern versucht vorhandene zu vereinen. Als ALF Anwendungen können entweder
Eclipse Plugins oder externe Anwendungen verwendet werden.
Die Firma Borland, welche mit ihren Produkten einen kompletten Application Lifecycle abdecken kann (siehe dazu auch [Sko07]), hat damit begonnen ihre ALM Produkte auch für die Eclipse Plattform bereitzustellen. So ist beispielsweise die Modellierungsanwendung Together bereits als Eclipse Plugin verfügbar.
Evaluierung
54
Wie eingangs, im Allgemeinen Teil (Kapitel 4.2.1), erwähnt, ist das wichtigste Element der Eclipse-Plattform das Plugin. Eclipse besteht, abgesehen von einem klein
gehaltenen Plattform-Kern, ausschließlich aus Plugins, getreu nach dem Motto „Everything is a plugin“. In [BWB+06] wird Eclipse daher sehr treffend als „Ablaufumgebung für Plugins“ bezeichnet. Durch diese, konsequent auf Erweiterungen basierende, Architektur existieren mächtige und sehr gut dokumentierte Schnittstellen.
Entsprechend groß ist inzwischen die Verfügbarkeit von Eclipse Plugins. Die Webseite von EclipsePluginCentral [EPC06] listet derzeit an die 700 Eclipse Erweiterungen in den verschiedensten Kategorien auf.
Hilfe und Support
Eclipse verfügt über eine umfangreiche Online-Hilfe, in welche auch Erweiterungen
deren Dokumente integrieren können. Neben dieser Standard-Hilfe unterstützt Eclipse zusätzlich einen interaktiven Hilfe-Mechanismus, der sich Cheat Sheets nennt
und den Anwender durch eine Sequenz von definierten Schritten führt. Jeder Schritt
kann entweder automatisch oder manuell durch den Benutzer durchgeführt werden.
Viele Anleitungen in Eclipse stehen als Cheat Sheets zur Verfügung und versuchen
den Anwender beim Erlernen verschiedenster Funktionalitäten zu unterstützen.
Cheat Sheet-Anleitungen werden in einem entsprechenden XML-Dialekt verfasst
und können daher auch von Anwendern und Plugin Autoren einfach erstellt werden.
Die Eclipse-Plattform verfügt trotz ihrer kurzen Vergangenheit (die erste Version
kam im Jahr 2001) über eine große und aktive Community. Auf der offiziellen Homepage ist unter [Ecl06o] ein Überblick zu den Aktivitäten der Gemeinschaft zu
finden.
Veranstaltungen
Ein Kalender gibt einen Überblick über kommende
Veranstaltungen mit Eclipse-Bezug. Es werden beispielsweise Konferenzen, Seminare und Messen
angekündigt. Im Normalfall finden sich hier mindestens 3 Einträge pro Monat.
Portalseiten
Mit der Community wuchs auch die Anzahl der internationalen und nationalen Seiten die sich ausschließlich mit der Eclipse Plattform beschäftigen.
Derzeit gibt es an die 30 derartige Portale.
Schulungen
Es gibt inzwischen viele Organisationen und Fir-
Evaluierung
55
men, die sowohl kostenlose als auch kommerzielle
Schulungen für Eclipse anbieten. Hier werden jedoch auch Bücher und WebSeminare vorgestellt.
Plugin und RCP Katalog
Mit [EPC06] betreibt die Community eine umfangreiche Webseite mit allen bekannten EclipseErweiterungen bzw. Eclipse basierten Rich Client
Anwendungen.
Tabelle 3.4: Eclipse - Aktivitäten der Community
Kommerzieller Support für die Eclipse Plattform wird von verschiedenen Mitgliedern der Eclipse Foundation, wie beispielsweise [INNO06], angeboten.
Sonstiges
Die saubere Integration von Quasi-Standard-Technologien in die Plattform ist sicher
einer der Stärken von Eclipse bei der Java Entwicklung. Die Unterstützung solcher
Technologien ist vor allem wichtig im Hinblick darauf, dass im Normalfall auch
innerhalb kleiner Projektteams, je nach persönlichen Vorlieben, unterschiedliche
Entwicklungsumgebungen Verwendung finden. Werden entsprechende Standards
von allen IDEs ausreichend unterstützt, ist eine konfliktfreie Zusammenarbeit problemlos möglich.
Das Build-Tool Ant [Ant06] hat sich bei der Entwicklung mit Java weitgehend
durchgesetzt. Ant ist von der Funktionsweise mit dem klassischen „make“ für die
C/C++ Entwicklung vergleichbar. Es wurde jedoch selbst in Java geschrieben und
gewährleistet so die Plattformunabhängigkeit. Um ein Build mit Ant durchführen zu
können, muss eine XML Konfigurationsdatei erstellt werden, welche alle notwendigen Prozessschritte enthält und sogenannte Targets definiert. Ein Target ist üblicherweise eine bestimmte Aufgabe des Übersetzungsprozesses, wie beispielsweise
das Kompilieren oder das Erstellen der Code-Dokumentation. Ein Target besteht aus
Tasks, welche spezielle Teilaufgaben übernehmen, z. B. den Aufruf des Java Übersetzers javac. Ant stellt standardmäßig bereits sehr viele Tasks zur Verfügung. Weitere Tasks können jedoch einfach als Erweiterung nachgerüstet werden. Eclipse unterstützt Ant sehr komfortabel. So ist es z. B. möglich, ein Target als sogenannten
„externen Build“ einzubinden. Weiters bietet Eclipse für Ant eine spezielle Outline
View sowie eine Code Completion für die Konfigurationsdatei.
Evaluierung
56
Mit der Integration der Versionsverwaltung CVS [CVS06] ist ein weiterer QuasiStandard in die Eclipse Plattform standardmäßig integriert. Der CVS-Client ist nahtlos in die Oberfläche integriert und ermöglicht das einfache Übertragen der Dateien
von und zum CVS-Repository. Darüber hinaus wird eine spezielle SynchronizePerspektive zur Verfügung gestellt, welche einen komfortablen Vergleich zwischen
den unterschiedlichen Versionen erlaubt.
Die Firma Innoopract bietet mit ihrem kostenlosen Service Yoxos [YOX06] die
Möglichkeit, sich seine persönliche Eclipse Distribution mit auswählbaren Erweiterungen online zusammenzustellen. Die resultierende Plattform kann anschließend als
ZIP-Archiv herunterladen werden. Dieses Service ist z. B. für ein Projekt sinnvoll, in
welchem eine Eclipse Installation mit diversen speziellen Erweiterungen eingesetzt
werden soll, um allen Teammitgliedern exakt dieselbe Entwicklungsumgebung bereitstellen zu können.
Evaluierung
3.2
57
NetBeans 5.5
Hersteller
Sun Microsystems
Produktversionen
Standard, diverse Erweiterungsmodule
Testversion
NetBeans 5.5 mit den Erweiterungspaketen „Enterprise
Pack”, „Visual Web Pack“, „Mobility Pack” und „Profiler“
Anschaffungskosten
kostenlos
Plattform
Windows, Linux, Solaris, Mac OS X
Homepage
www.netbeans.org
3.2.1 Allgemeines
Netbeans wurde nach [NB06a] 1996 als Studentenprojekt gestartet. Ziel war es, eine
Delphi ähnliche IDE für Java zu schaffen. Die erste Version erschien unter dem Namen Xelfi im Jahr 1997 und war die erste Java-IDE, welche gänzlich in Java implementiert wurde. Das Projekt erhielt viel Zuspruch und so entschieden sich die Studenten eine Firma zu gründen. Die Firma wurde schließlich im Jahr 1999 von Sun
Microsystems, also dem Erfinder der Programmiersprache Java, übernommen. Im
Jahr 2000 entschied Sun Netbeans als OpenSource Software weiterzuentwickeln.
Netbeans hat weitgehend den Ruf einer vollständigen Entwicklungsumgebung. So
wird bereits in der Grundausstattung ein großer Funktionsumfang geboten. Trotzdem
ist die Entwicklungsumgebung modular gestaltet und die Basisplattform schlank
gehalten. Für Spezialgebiete stellt Sun Microsystems einige Erweiterungsmodule,
siehe Tabelle 3.5, zur Verfügung. Da diese Module vom IDE-Hersteller kostenlos
bereitgestellt und normalerweise mit den Release-Terminen der Kernplattform abgestimmt sind, werden die Modulfunktionalitäten zum Funktionsumfang der IDE gezählt.
Evaluierung
58
Enterprise Pack [NB06c]
Erweitert NetBeans um die Möglichkeit SOA (service-oriented architecture) Applikationen zu schreiben. Darüber hinaus bietet es, derzeit jedoch noch
im
Beta-Stadium,
umfangreiche
UMLModellierungstechniken. (siehe Kapitel Bewertung
nach Kriterienkatalog – Modellierung)
Mobility Pack [NB06d]
Dieses Erweiterungsmodul stellt Werkzeuge für die
Entwicklung mobiler Applikationen zur Verfügung.
(siehe Kapitel Bewertung nach Kriterienkatalog –
Programmierung)
Profiler [NB06e]
Das Profiler Pack dient der Performance-Analyse
von Java-Applikationen. (siehe Kapitel Bewertung
nach Kriterienkatalog – Softwarequalitätssicherung)
Visual Web Pack [NB06f]
Das Visual Web Pack ermöglicht eine komfortable
Vorgehensweise bei der Gestaltung von JavaServerFaces.
C/C++ Pack [NB06g]
Dieses Modul dient der Entwicklung von nativen
Applikationen mit den Programmiersprachen C und
C++.
Tabelle 3.5: NetBeans - Sun-Erweiterungsmodule für die IDE
NetBeans ist laut Jan Chalupa, Director von NetBeans Engineering bei Sun
Microsystems, nach [BC06] seit Version 3.0 als generelle Applikationsplattform
entworfen worden. Die Unterstützung für die Entwicklung von Anwendungen auf
Basis der NetBeans-Plattform war jedoch ziemlich reduziert und zu der Zeit nur als
experimentelles Add-on erhältlich. Das hat sich mit NetBeans 5.0 geändert. Unterstützung für die Entwicklung von Applikationen, die auf der NetBeans-Plattform
basieren, steht in der Standard-IDE zur Verfügung.
In [BC06] erklärt Tim Boudreau, Mitglied des NetBeans Core Team, dass es
inzwischen eine große Anzahl von Firmen gibt, die mit ihren Produkten auf die NetBeans Plattform aufsetzen. Als Beispiel nennt er die Firma Nokia, die zur Verwaltung ihres Mobilfunk-Netzwerks eine NetBeans-RCP-Applikation verwendet.
Abbildung 3.18 gibt einen Überblick über die NetBeans-Familie.
Evaluierung
59
Abbildung 3.18: NetBeans - Übersicht über die NetBeans-Familie (Grafik nach [Trap06])
Da NetBeans in Java realisiert wurde, kann es auf allen Betriebssystemen eingesetzt
werden, für die eine entsprechende Java Virtual Machine verfügbar ist. Bei der aktuellen Version stehen komfortable Installationen für die Betriebsysteme Windows,
Solaris, MAC OS X und Linux bereit. Für andere UNIX basierte Systeme kann die
Installation manuell mit einem allgemein gehaltenen Archiv durchgeführt werden.
NetBeans war nicht nur die erste IDE mit vollständiger Unterstützung von Java 5, es
bietet bereits auch Unterstützung für die nächste Version Java 6. Generell wird Wert
darauf gelegt, dass neben den aktuellen Standards auch frühzeitig neue Versionen
und Technologien unterstützt werden. Auf diese Weise können kommende Versionen schon in der Entwicklung neuer Projekte Berücksichtigung finden. [Trap06]
Editor
Der NetBeans Codeeditor ist leistungsfähig und komfortabel zu bedienen. Er deckt
fast alle im entsprechenden Abschnitt des Kriterienkatalogs aufgelisteten Features
ab. Lediglich die Change Bar, eine vertikale Markierungsleiste, welche geänderte
Codebereiche farbig heraushebt, ist nicht vorhanden.
Evaluierung
60
Abbildung 3.19: NetBeans - Codeeditor
Abbildung 3.19 zeigt den Codeeditor in Aktion. Man sieht hier deutlich die Code
Completion sowie die Code Hilfe, die direkt aus dem Sourcecode geparst oder aus
der JavaDoc Hilfe geladen wird. Die Completion Features reagieren durchwegs angenehm schnell, sodass es zu keinen größeren Verzögerungen beim Tippen kommt.
Weiters sind ein gefalteter Codeabschnitt (Zeile 10-13), ein gesetzter DebuggerBreakpoint (Zeile 19) sowie ein Lesezeichen (Zeile 27) zu sehen. Der aktuell syntaktisch fehlerhafte Code wird, wie auch bei manchen Textverarbeitungsprogrammen,
rot unterwellt sowie durch ein auffallendes Icon am linken Editorrand hervorgehoben.
Eine Besonderheit des NetBeans Quelltexteditors ist die eigene Symbolleiste, welche
für jede geöffnete Datei angezeigt wird. Sie stellt abhängig vom geladenen Dateityp
entsprechend passende Funktionalitäten bereit. In diesem Fall wird beispielsweise
eine Navigationsmöglichkeit zu den zuletzt bearbeiteten Stellen in der Datei und den
gesetzten Lesezeichen, eine Suchfunktion, verschiedene Formatierungs- und Kommentierungsmöglichkeiten sowie eine Makrofunktionalität, um häufig benutzte Abfolgen automatisieren zu können, angezeigt. Die Symbolleiste stellt eine elegante
Alternative zu Tastaturkürzel für diese Funktionen dar und ist effizient zu bedienen.
Evaluierung
61
Die Code Folding Funktionen des Codeeditors bieten sowohl die Möglichkeit, Standardstrukturen als auch Teile des Quelltexts, deren Aufbau normalerweise zu keiner
Faltungsoption führt, einzuklappen. Durch das Umschließen mit den XML-ähnlichen
Kommentaren „// <editor-fold>“ am Anfang sowie „// </editor-fold>“ am Ende eines
beliebigen Abschnitts kann auch dieser gefaltet werden. Diese Funktionalität ist beispielswiese nützlich, wenn man einen relativ flach gehaltenen Algorithmus dennoch
übersichtlich gestalten möchte.
Obwohl eine Studie der Evans Data Corporation im Jahr 2005 nach [Trap06] ermittelt hat, dass das Java WidgetSet Swing, das am meisten verwendete noch vor den
WinForms [WinF06] ist, gab es lange Zeit keinen besonders komfortablen User Interface Designer für Java. Um komplexe grafische Oberflächen zu gestalten, war es
oft notwendig, verschiedene Panels mit unterschiedlichen LayoutManagern ineinander zu verschachteln. Die Programmierung war dementsprechend kompliziert und
führte zu unübersichtlichem Code.
In NetBeans 5.0 wurde das Java GUI-Design mit der Einführung des WYSIWYG
Designers Matisse, benannt nach dem berühmten Maler Henri Matisse [HM06], wesentlich verbessert.
Abbildung 3.20: NetBeans - GUI-Designer Matisse
Matisse ist eine Kombination des LayoutManagers GroupLayout sowie eines grafischen Interfaces um die Oberfläche mit diesem Layout zu gestalten. Dieser GUI-
Evaluierung
62
Designer erlaubt es auch komplexe Oberflächen, ohne die erwähnten Verschachtelungen, zu konstruieren. Die einzelnen Komponenten lassen sich per Drag and Drop
von der Palette auf die Arbeitsfläche ziehen und können entweder an den Rändern
des Grafikcontainers oder an bereits platzierten Beans ausgerichtet werden. Dadurch,
dass das Layout auf Beziehungen zwischen den Komponenten anstatt auf z. B. absoluten Koordinatenangaben basiert, sind die einzelnen Abstände immer korrekt, auch
wenn die Fenstergröße verändert wird oder sich einzelne Texte durch eine Übersetzung ändern. GroupLayout bietet weiters die Möglichkeit, Textkomponenten anhand
ihrer Grundlinie auszurichten, um zu verhindern, dass die Texte versetzt dargestellt
werden.
Die wichtigsten Werkzeuge von Matisse sind (siehe dazu auch Abbildung 3.20):
•
Form Editor: Dieser bietet sowohl eine Design- als auch eine Quelltextansicht zwischen denen in der, im Abschnitt Codeeditor erwähnten, spezifischen Symbolleiste umgeschaltet werden kann. Die Designansicht erlaubt die
beschriebene Platzierung der Komponenten. Die Quelltextansicht enthält den
generierten GUI-Code. Der von Matisse generierte Code besteht lediglich
auch einer „initComponents()“ Methode sowie einigen Variablendefinitionen
für Komponenten, welche innerhalb der Klasse global verfügbar sind.
•
Palette: Diese Ansicht enthält eine Liste von Komponenten, die, wie bereits
beschrieben, per Drag and Drop auf der Arbeitsfläche platziert werden können. Die Liste kann bei Bedarf um eigene JavaBeans erweitert werden.
•
Properties window: Die selektierten Komponenten können in dieser Ansicht
komfortabel konfiguriert werden.
•
Navigator: Dieses Fenster bietet eine hierarchische Ansicht aller Komponenten des Formulars.
Matisse arbeitet zwar standardmäßig mit dem GroupLayout, es kommt jedoch auch
mit klassischen LayoutManagern wie z. B. FlowLayout, BorderLayout oder GridBagLayout gut zurecht.
Ab Java 6, derzeit Release Candidate, wird das GroupLayout laut der entsprechenden API Dokumentation [Sun06f] Teil der Java Standard Klassenbibliothek sein. Um
den LayoutManager mit der aktuellen Java Version 1.5 bzw. der älteren 1.4.2 nutzen
zu können, muss eine ca. 140 kB große Zusatzbiblothek mit der Anwendung gebündelt werden.
Evaluierung
63
NetBeans beherrscht praktisch alle, im Kriterienkatalog vorgestellten Refactoringmöglichkeiten. (siehe dazu auch das Refactoring-Menü, welches einen Großteil der
Funktionalitäten auflistet, in Abbildung 3.21)
Abbildung 3.21: NetBeans - Refactoringmethoden, Jackpot Refactoring Manager
Mit NetBeans 6.0 wird nach [Trap06] ein umfangreiches Refactoring Modul, das
derzeit unter dem Codenamen Jackpot entwickelt wird, zusätzlich zu den bestehenden Möglichkeiten eingeführt. Jackpot führt die Transformationen nicht auf Quellcode-Basis, sondern auf dem nach dem Kompilieren entstandenen abstrakten Syntaxbaum aus. Hierfür gibt es eine eigene kleine Sprache, mit der sich auch komplexe
Operationen definieren lassen. Diese können weit über den bisherigen Umfang von
Refactorings hinausgehen. Jackpot kann auch als Qualitätssicherungswerkzeug eingesetzt werden, um schlechten Programmierstil oder potentielle Fehler, wie etwa in
[Blo06] beschrieben, zu erkennen und eventuell automatisch zu korrigieren. Als Beispiel können auf diese Weise komplexe If-Then-Strukturen vereinfacht oder überflüssige Casts und Ähnliches erkannt werden. [Trap06]
Jackpot steht als Beta-Version bereits für NetBeans 5.5 zur Verfügung und kann
einfach über das sogenannte Update-Center installiert werden. Die Regeln werden
im Refactoring-Manager, siehe Abbildung 3.21, aktiviert, konfiguriert und können
anschließend einfach auf das aktuelle Projekt angewendet werden. Das Modul erwies
sich bei den Tests als stabile, sehr leistungsfähige Refactoringmöglichkeit.
Zum Zeitpunkt des Schreibens dieser Evaluierung stand nur die englische Version
von NetBeans 5.5 bzw. den Erweiterungspacks zur Verfügung. Für die Vorgängerversion 5.0 standen neben der Standardsprache Englisch auch Übersetzungen in den
Sprachen Chinesisch (vereinfacht), Japanisch, Koreanisch und Russisch zur Verfü-
Evaluierung
64
gung. Mit einer deutschen Variante ist demnach auch für die aktuelle Version 5.5
nicht zu rechnen.
Mit Hilfe des Enterprise Pack ist es möglich, aus drei Kategorien Entwurfsmuster
auszuwählen und diese zu modellieren: EJB 1.1 und EJB 2.0 ermöglichen die Generierung entsprechender Patterns gemäß der jeweiligen Enterprise JavaBean Spezifikation. Die von der Gang of Four [GoF96] vorgeschlagenen Entwurfsmuster können
ebenfalls angewendet und modelliert werden. Abbildung 3.22 zeigt das UML Design
Center mit einem generierten GoF Iterator Pattern als Klassendiagramm.
Abbildung 3.22: NetBeans - UML Design Center mit Pattern-Katalog
Der Aufbau der Arbeitsumgebung ist in der Standardkonfiguration sehr übersichtlich
und funktionell gestaltet. Zentrales Element ist eine Editorkomponente, beispielsweise der Codeeditor oder User Interface Designer. Im linken Bereich befinden sich
eine Projektübersicht, ein einfacher Dateimanager für das aktuell geöffnete Projekt
und eine Ansicht für Strukturdaten. Weitere dockbare Ansichten können bei Bedarf
eingeblendet werden, z. B. Palette für GUI Design oder Modellierung, Suchergebnisse, Konsole, Taskfenster uvm. Die Inhalte der Menü- bzw. Symbolleisten lassen
sich flexibel an den persönlichen Geschmack anpassen.
Evaluierung
65
Modellierung
Das NetBeans UML Modellierungswerkzeug war laut [NM06a] ursprünglich Teil
des Enterprise Erweiterungspakets. Es ist nun jedoch eine eigenständige Erweiterung
und lässt sich bequem über das NetBeans Update-Center installieren. Die Implementierung entspricht dem UML 2.0 Standard und unterstützt neun Diagrammtypen:
Aktivitäts-, Anwendungsfall-, Klassen-, Kommunikations-, Komponenten-, Objekt-,
Sequenz-, Verteilungs- und ein Zustandsdiagramm. Das Objektdiagramm wird zwar
nicht direkt von einem speziellen Assistenten unterstützt, kann jedoch mit einem
Klassendiagramm modelliert werden. In Abbildung 3.22 wurde bereits ein Klassendiagramm gezeigt.
Das UML Modul bietet drei verschiedene Assistenten an, um ein neues Modellierungsprojekt anzulegen:
•
Platform-Independent Model: Diese Projektform kann für Modellierungsprojekte ohne Code-Generierung genutzt werden.
•
Java-Platform Model: Bei der Auswahl dieses Projekttyps können nach
[AT06] optional UML-Modellierungsprojekte mit separaten NetBeans-JavaProjekten assoziiert werden. Damit kann dann eine bidirektionale Synchronisierung zwischen UML-Modell und Java-Sourceode erfolgen.
•
Java-Platform Model by Reverse Engineering: Soll für ein bestehendes Projekt eine UML-Modellierungsmöglichkeit nachgerüstet werden, kann dieser
Assistent genutzt werden.
Bei allen Assistenten wird zunächst ein eigenständiges Projekt angelegt, welches
gegebenenfalls mit einem oder mehreren Quelltextprojekten verknüpft ist. Wird reines Forward Engineering betrieben, arbeitet man praktisch ausschließlich im UML
Projekt und generiert den Quelltext im entsprechend verknüpften Projekt. Umgekehrt wird beim Reverse Engineering nur im Quellcodeprojekt gearbeitet und bei
Bedarf werden die Modelle des assozierten UML Projekts manuell aktualisiert.
Round-Trip Engineering, also das Arbeiten sowohl im Modell als auch Quelltext
wird prinzipiell unterstützt. Bei dieser Technik ist jedoch etwas Handarbeit notwendig. Es kann sowohl mit der Modellierung, als auch mit der manuellen Programmierung begonnen werden. Wird z. B. zunächst ein Klassendiagramm entworfen, so
kann durch einfaches Forward Engineering passender Code generiert werden. Werden nun Änderungen im erzeugten Quelltext vorgenommen, werden mittels Reverse
Engineering zunächst Modellstruktur und damit auch die bereits erstellten Diagram-
Evaluierung
66
me aktualisiert. Wird nun wieder in den Diagrammen etwas verändert und Quelltext
generiert, bleiben noch passende Teile des zuvor manuell erweiterten Codes, z. B.
Kommentare und Implementierungen der Methodenrümpfe erhalten. Die Durchführung der Forward- bzw. Reverse Engineering-Aktion muss jeweils manuell ausgelöst
werden. Diese Vorgehensweise ist, auch der Online Hilfe nach, empfohlen und funktionierte bei der Evaluierung problemlos, sonderlich komfortabel ist es jedoch nicht.
Abbildung 3.23: NetBeans - Sequenzdiagramm mittels Reverse Engineering
Um Abläufe übersichtlich dokumentieren zu können, eignet sich eine Sequenzdiagrammdarstellung sehr gut. Abbildung 3.23 zeigt ein Sequenzdiagramm, das mit
Reverse Engineering automatisch erzeugt werden kann. Für die Ablaufdokumentation kann alternativ auch ein Kommunikationsdiagramm erzeugt werden. Alle erzeugten Diagramme können manuell um zusätzliche Elemente, wie beispielsweise Kommentarblöcke, aus der Palette ergänzt werden.
Die Editorfunktionalitäten bei der Arbeit mit einem UML-Diagramm sind umfangreich und so stehen beispielsweise typische Navigations- und Skalierungsfunktionen
sowie automatische Layoutmöglichkeiten zur Verfügung. Die Modelle können in
diverse Grafikformate (JPEG, PNG, SVG) exportieren. Eine XMIExportmöglichkeit der UML-Modelle steht nicht zur Verfügung.
Evaluierung
67
Die NetBeans IDE bietet standardmäßig keine speziellen Funktionalitäten für die
modellgetriebene Softwareentwicklung. Die kommerziellen NetBeans Erweiterungen Applied Models [AM06] und MagicDraw UML [MD06], welche MDSD- bzw.
MDA-Techniken unterstützen, stehen jedoch zur Verfügung.
Programmierung
Sun Microsystem stellt für die Entwicklung von C bzw. C++ Anwendungen eine
Erweiterung zur Verfügung, welche sich beim Verfassen dieser Arbeit jedoch noch
im Beta-Stadium befand. Die Erweiterung liegt als Setup auf der NetBeans Homepage vor, lässt sich einfach installieren und unterstützt laut [AT06] die Sun Compiler,
den GCC und unter Windows den C++ Compiler des Microsoft Visual Studios. Als
Debugger kommt der GDB [GDB06] zum Einsatz. Die Editorkomponente ist nicht
so leistungsfähig wie die Java Variante, unterstützt jedoch Syntax-Highlighting und
einfache Code-Completion. Die Verwaltung von Makefiles ist ebenfalls möglich.
Der sogenannte Library Manager, siehe Abbildung 3.24, dient in NetBeans zur Verwaltung, sowohl von mitgelieferten als auch von eigenen Klassenbibliotheken. Standardmäßig liefert NetBeans, inklusive der erwähnten Erweiterungspakete, bereits
viele Bibliotheken und Frameworks mit. Tabelle 3.6 zeigt einige der mitgelieferten
Bibliotheken.
Java ME CDC AGUI Swing
Layout
Eine Variante des Swing Layouts [SL06] um den
NetBeans GUI-Designer Matisse mit GroupLayout
[Sun06f] auch für mobile Applikationen nutzen zu
könnnen.
JavaServer Faces 1.1 [JSF06]
JavaServer Faces vereinfachen die Gestaltung grafischer Web-Benutzeroberflächen. Die Entwicklung
mit JSF erfolgt auf einem hohen Abstraktionsniveau
und folgt dem MVC Konzept. In NetBeans wird die
Entwicklung komfortabel mit der Erweiterung Visual Web Pack, siehe dazu WebEntwicklung im Kriterienkatalog, unterstützt.
JavaServer Pages Standard
Tag Library 1.1 [JSTL06]
JSTL ist eine Sammlung von Tag-Bibliotheken, die
für Entwicklung mit JavaServer Pages hilfreich sind.
NetBeans SVG MIDP Com-
Klassenbibliothek, um Scaleable Vector Graphics
[SVG06] auch auf leistungsfähigen mobilen Geräten
Evaluierung
68
ponents
nutzen zu könnnen.
ProGuard Obfuscator 3.5
[ProG06]
ProGuard obfuskiert und verkleinert Java-Bytecode.
Es wird dadurch unerwünschter Zugriff auf den
Sourcecode erheblich erschwert und die Größe der
Applikation verringert.
Apache Struts 1.2.9 [Apa06c]
Bei Struts handelt es sich um Framework um Java
Webapplikationen nach der MVC Architektur zu
entwickeln.
Swing Layout Extensions
1.0.1 [SL06]
Das Ziel der Swing Layout Extensions ist die Vereinfachung der Gestaltung professioneller GUI Layouts mit Swing. Aus diesem Projekt ging das
GroupLayout [Sun06f] hervor, dass Teil von Java
1.6 sein wird und direkt vom NetBeans GUIDesigner unterstützt wird.
Tabelle 3.6: NetBeans - Einige mitgelieferte Klassenbibliotheken
Einen wichtigen Komponentenstandard im Bereich der Java Entwicklung stellen die
Enterprise JavaBeans [EJB06] dar. Folgende Vorteile ergeben sich nach [KCC+06]
wenn man Applikationslogik in EJBs verpackt:
•
Enterprise Beans unterstützen Transaktionen, d. h. man muss das verteilte
Objekt nicht manuell vor gleichzeitigem Zugriff schützen. Die Transaktionseinstellungen sind bequem über sogenannte Deployment Descriptor-Dateien
möglich.
•
Enterprise Beans können einfach von mehreren Clients genutzt werden, unabhängig davon, ob der Zugriff lokal oder entfernt erfolgt.
•
Die Geschäftslogik des Beans kann geschützt werden, ohne direkt Änderungen im Quelltext vornehmen zu müssen.
•
EJBs können auf externe Ressourcen wie beispielsweise Datenbanken, Nachrichtenwarteschlangen und Webdienste über das Java Naming und Directory
Interface (JNDI) zugreifen. Der JNDI Namensdienst vereinfacht das Lokalisieren verschiedenster Komponenten und Ressourcen. Um z. B. eine JDBCDatenquelle zu finden, kann eine JNDI lookup-Methode verwendet werden,
Evaluierung
69
welche durch Übergabe entsprechender Parameter das gesuchte Objekt zurückliefert.
NetBeans bietet umfangreiche Möglichkeiten bei Design und Arbeit mit EJBs. Zum
Erstellen eines neuen EJB-Moduls existiert ein komfortabler Assistent und zu bereits
bestehenden Modulen können bequem zusätzliche Beans, Dateien oder Bibliotheken
hinzugefügt werden. Die für die Geschäftslogik notwendigen Methoden des Beans
können mit einer Standardimplementierung über entsprechende Popup-Menüs des
Projekt-Managers oder direkt in der Editoransicht hinzugefügt werden. Die IDE generiert automatisch den zusätzlich notwendigen Quelltext z. B. um die lokale oder
entfernte Methodensignatur zu aktualisieren.
Zum Bearbeiten des sogenannten EJB-Deploymentdeskriptors existiert eine leistungsfähige Editorkomponente die sowohl graphisches als auch manuelles Editieren
der XML-Datei ermöglicht.
Das im Abschnitt Evaluierung bereits beschriebene UML Design Center unterstützt
neben der bekannten Patterns der Gang of Four auch EJB Entwurfsmuster.
Neben EJBs erleichtert NetBeans die Arbeit im Bereich der Middleware und Kompontenstandards auch mit den Frameworks Java API for XML-Based Remote Procedurce Calls (JAX-RPC) [JRPC06] sowie Java Message Service [JMS06] durch die
Bereitstellungen verschiedenster Assistenten.
Klassenbibliotheken und Komponenten von Drittanbietern stehen, wie auch schon
bei der Eclipse IDE Evaluierung beschrieben, in sehr großem Umfang zur Verfügung. Im NetBeans Library Manager können sowohl von NetBeans bereitgestellte
Bibliotheken verwaltet, als auch eigene hinzugefügt und geändert werden. Nach Angabe eines Namens und dem Hinzufügen der eigentlichen Komponente können optional noch Pfade zum Quelltext und zur API-Dokumentation im JavaDoc Format,
falls vorhanden, spezifiziert werden. Diese Details sind vor allem für dynamische
Hilfefunktionalitäten, z. B. bei der Code Completion und um Implementierungsdetails untersuchen zu können, hilfreich.
Evaluierung
70
Abbildung 3.24: NetBeans - Library Manager zur Verwaltung der Klassenbibliotheken
Um die Suche nach Bibliotheken zu vereinfachen, bietet der Verwaltungsdialog eine
einfache Einteilung der Komponenten in verschiedene Gruppen. Standardmäßig existieren die Kategorien Class Libraries, Mobile Libraries, Component Libraries und
Theme Libraries.
Wie bereits in der Eclipse-Evaluierung beschrieben, bietet die Standard Java Klassenbibliothek bereits umfangreiche Mechanismen um Anwendungen internationalisieren zu können. Eine dieser Techniken ist das Auslagern sprachspezifischer Inhalte
in einzelne Dateien. Die Dateien beinhalten idente Schlüssel und sprachspezifische
Werte, in den meisten Fällen Texte. Für das Editieren stellt NetBeans neben der manuellen Variante auch einen tabellenbasierten Editor zur Verfügung.
Abbildung 3.25 zeigt exemplarisch die relevanten Teile von NetBeans beim Übersetzen der einzelnen Sprachdateien. In der Projektansicht werden die Sprachdateien
übersichtlich gruppiert. Es ist möglich, die Dateien einzeln zu bearbeiten, siehe dazu
die geöffneten Sprachdateien rechts unten. Die komfortablere und weniger fehleranfällige Variante ist das Editieren der Dateien in Tabellenform. Für jede vorhandene
Sprache wird eine eigene Spalte mit den jeweiligen Übersetzungen angezeigt.
Evaluierung
71
Abbildung 3.25: NetBeans - Tabellenbasiertes Editieren von Sprachdateien
Neben dem Spracheditor stehen noch weitere Assistenten zur Internationalisierung
zur Verfügung, die beispielsweise das Auslagern bereits fix kodierter Texte in Dateien erlauben. Der bereits beschriebene GUI-Designer bietet ebenfalls die Möglichkeit
die Texte direkt aus den einzelnen Sprachressourcen zu beziehen und darüber hinaus
noch die Sprache in der Voransicht zu definieren.
NetBeans bringt auch Unterstützung für Datenbanken mit. In der Runtime-Ansicht
werden auch die Datenbankverbindungen verwaltet. Die Apache Datenbank Derby,
welche Teil von Java 1.6 sein wird, ist schon jetzt in der NetBeans Distribution gut
integriert und ist für das rasche Testen der Datenbankfunktionalität einer Applikation
ideal geeignet. Es können natürlich beliebige Datenbanksysteme verwendet werden,
sofern ein geeigneter JDBC-Treiber zur Verfügung steht.
Für das Anlegen einer neuen Datenbankverbindung steht ein entsprechender Assistent zur Verfügung, um Verbindungsdaten und Treiberinformationen eingeben zu
können. Die Verbindung wird anschließend in die Baumstruktur der RuntimeAnsicht eingeordnet. Verbindet man sich mit der Datenquelle, werden die üblichen
Strukturen der Verbindung angezeigt: Tabellen, Ansichten und Prozeduren. In der
Editoransicht können typische SQL-Statements abgesetzt werden. Die Abfrageergebnisse werden in einer Tabelle angezeigt und können bei Bedarf mittels CopyPaste Funktionalität kopiert werden. Eine Exportfunktion, um die Daten in eine
Spreadsheet-Applikation zu übernehmen, wird nicht zur Verfügung gestellt.
Evaluierung
72
Abbildung 3.26: NetBeans - Verbundene Datenquelle und SQL-Abfrageeditor
Darüber hinaus gibt es eine sogenannte Persistenz-Funktionaliät, die es ermöglicht,
aus existierenden Datenbank-Schemen Klassen zu generieren. Umgekehrt kann eine
Datenbankstruktur aus bereits entwickelten Klassen erzeugt werden.
NetBeans kommt mit einer umfassenden Unterstützung bei der Entwicklung von
Webapplikationen:
•
Mit der IDE wird ein Tomcat-Server [Apa06d] ausgeliefert, auf dem die entwickelten Applikationen deployt, getestet und debuggt werden könnnen.
•
Die Datei- und Verzeichnisstruktur der Webapplikation wird von der IDE automatisch umgesetzt.
•
Der Editor bietet Syntax Highlighting, Code Completion und einige weitere
Editorhilfen, wie z. B. Refactoringmöglichkeiten, bei der Bearbeitung von
Servlet-, JSP-, HTML- und Tagbibliotheks- Dateien.
•
Es gibt eine umfangreiche Unterstützung der Webframeworks JSF [JSF06]
und Struts [Apa06c]. Die beiden Frameworks können nach [DA06] optional
für Webapplikationen integriert werden. Die erforderlichen JAR Dateien
werden automatisch mit in das erstellte Archiv aufgenommen. Darüber hinaus existieren Codevorlagen und Assistenten für die Erstellung von JSF Managed Beans, Struts Actions und ActionForm Beans.
Evaluierung
•
73
Aus der Komponentenpalette können Codefragmente per Drag-and-Drop in
die entsprechenden Quelldateien, z. B. JSP- oder HTML-Dateien, gezogen
werden.
Ein sehr nützliches Feature beim Testen von Webapplikationen ist der integrierte
HTTP-Monitor, siehe dazu Abbildung 3.27, der laufend die Kommunikation zwischen Browser und Server visualisiert.
Abbildung 3.27: NetBeans - HTTP-Monitor
Die Anfragen und Antworten können damit genau analysiert werden. Weiters ist es
auch möglich, den Verkehr aufzuzeichnen um ihn später wieder abspielen zu können. Auch ein Ändern der einzelnen Anfragen ist möglich, um z. B. verschiedene
Umgebungen zu simulieren.
Neben der textbasierten Entwicklung von Webapplikationen direkt mit dem Codeeditor im JSP- oder Servlet-Quelltext, steht mit dem Visual Web Pack eine Erweiterung zur Verfügung, die es erlaubt, JSF-basierte Seiten in einer WYSIWYG Umgebung zu entwickeln, siehe dazu Abbildung 3.28.
Die JavaServer Faces Komponenten können via Drag-and-Drop aus der Palette auf
die Seite gezogen und frei platziert werden. Die Ausrichtung der Komponenten ist
einfach über eine Gittereinteilung der Arbeitsfläche möglich. Es gibt eine schnelle
Voransicht im Browser, ohne dazu einen Webserver starten zu müssen. Für die
AJAX basierten JSF Komponenten können JavaScript Abläufe innerhalb der Komponente, sowie eine komplexe Kommunikation zum Server realisiert werden.
Evaluierung
74
Abbildung 3.28: NetBeans - WYSIWYG Editor für JSF basierte Webseiten
Die Arbeit mit den AJAX basierten Komponenten gestaltet sich ähnlich einfach, wie
die Gestaltung von Benutzeroberflächen mit JavaBeans im Desktopbereich: Die
Komponenten werden platziert, individuell konfiguriert und es können serverseitige
Ereignisbehandlungsroutinen implementiert werden.
Die Applikationsentwicklung für mobile Endgeräte wird unter NetBeans mit der
Mobility Pack Erweiterung ermöglicht. Mit diesem Paket können Anwendungen,
sogenannte Midlets, auf Basis der CLDC (Connection Limited Device Configuration) Klasse entwickelt werden. In diese Gruppe fallen die meisten Mobiltelefone,
welche standardmäßig mit einer Java VM ausgestattet sind. Zusätzlich steht eine
Erweiterung für das Mobility Pack bereit, die für die Unterstützung leistungsfähiger
Geräte, auf Basis der CDC (Connection Device Configuration), optimiert ist. Zum
Zeitpunkt des Verfassens dieser Arbeit fielen in diese Klasse beispielsweise die Nokia-80 sowie Sony-Ericsson-CDC Serie sowie die Savaje Mobile-Plattform. Für die
Entwicklung CLDC basierter Applikationen wird das Sun’s J2ME Wireless Toolkit
(WTK) [JWTK06] mit optionalen, herstellerspezifischen Erweiterungen verwendet.
CDC Anwendungen stehen bei der Entwicklung ebenfalls entsprechende Basisplattformen, wie beispielsweise das UIQ 3 SDK [UIQ06] und herstellerabhängige Erweiterungen wie Sony Ericssons CDC Platform 1 Extension Package [SE06] zur Verfügung.
Die Entwicklung einer mobilen Anwendung gestaltet sich mit NetBeans sehr komfortabel. Zunächst wird mit einem intuitiven Assistenten eine grobe Anwendungsstruktur erzeugt. Das Bearbeiten des generierten Midlets kann direkt im Quelltext, in
einem GUI-Designer und im sogenannten Flow Designer erfolgen.
Evaluierung
75
Abbildung 3.29: NetBeans - Screen Designer für mobile CLDC Geräte
Abbildung 3.29 zeigt die Arbeit mit dem Oberflächendesigner des Mobility Packs.
Bei der Entwicklung von CLDC basierten Anwendungen können mit dem Screen
Designer einfach gehaltene Benutzeroberflächen bequem erstellt werden. Es steht
wie bei GUI-Designern üblich eine Komponentenpalette zur Verfügung, von der für
die verwendetete Plattform geeignete Elemente per Drag-and-Drop auf die Arbeitsfläche gezogen werden können. Neben der grafischen Gestaltung können den Komponenten auch Aktionen zugeordnet werden, siehe dazu „Assigned Commands“ in
Abbildung 3.29.
Für CDC Applikationen steht ein visueller Editor auf Basis des leistungsfähigen
Standard GUI-Designer Matisse, siehe dazu den Abschnitt „Editor“ dieser Evaluierung, zur Verfügung. Damit können auch im mobilen Bereich komplexe Oberflächen
intuitiv und bequem erzeugt werden.
In Abbildung 3.30 wird exemplarisch die Arbeit im Flow Designer gezeigt. In diesem Bearbeitungsmodus können die einzelnen Oberflächengestaltungen zu einem
Flussdiagramm modelliert werden.
Evaluierung
76
Abbildung 3.30: NetBeans - Mobility Pack Flow Designer
Um denselben Quelltext für unterschiedliche Plattformen nutzen zu können, bietet
NetBeans einen Präprozessor, der bei der Übersetzung des Programms von einem
speziellen Ant-Task behandelt wird, an. Die Direktiven sind dem C-Präprozessor
sehr ähnlich, werden jedoch mit „//“ eingeleitet, wodurch sie von normalen JavaEditoren als Kommentar wahrgenommen und dadurch ignoriert werden. Typische
Präpozessoranweisungen bei der mobilen Entwicklung mit NetBeans wären beispielsweise:
//#if manufacturer == „Nokia“ && type == „6230“
…
//#elif manufacturer == „Siemens“
…
//#endif
Das Mobility Pack bietet weiters noch die Integration typischer Obfuskatoren, wie
auch bei der Eclipse Evaluierung beschrieben, sowie eine Unterstützung von Whitebox-Tests auf Basis der J2MEUnit-Frameworks [JMEU06].
NetBeans bietet einen leistungsfähigen integrierten Debugger, der angenehm und
intuitiv bedienbar ist. Er beherrscht alle Funktionen, die man von einem Debugger
erwartet, wie beispielsweise schrittweise Ausführung, Untersuchung spezifischer
Abschnitte durch das Setzen eines Breakpoints und die Anzeige von Variableninhalten. Darüber hinaus verfügt der NetBeans Debugger über eine Reihe zusätzlicher,
nützlicher Funktionen.
Evaluierung
77
Abbildung 3.31: NetBeans - Debugger Ansicht
Abbildung 3.31 zeigt exemplarisch den Debugger in Aktion beim Untersuchen einer,
durch einen Breakpoint gestoppten, Applikation. Im Editorbereich werden die Inhalte einzelner Variablen durch Bewegen des Mauszeigers über das, zu untersuchende,
Feld mit einem Tooltip angezeigt. Bei komplexen Datentypen wird die Stringrepräsentation, welche durch die toString() Methode erzeugt wird, für den Tooltiptext
herangezogen. Die Variablenansicht, in Abbildung 3.31 rechts unten eingeblendet,
werden alle Variablen im aktuellen Ausführungskontext mit entsprechenden Typen
und Werten angezeigt. Zusätzliche Variablenansichten können in der WatchesAnsicht, siehe Abbildung 3.31 links unten, hinzugefügt werden. Die Besonderheit
bei dieser Ansicht ist, dass beliebige lokale und statische Felder sowie Metodenaufrufe entsprechend der Java-Syntax miteinander kombiniert werden können und
so sehr spezifische Evaluierungsausdrücke untersucht werden können. Bei der Eingabe derartiger Ausdrücke stehen einige Editorfunktionalitäten wie Code Completion und Code Hilfe zur Verfügung.
Der Debugger kann sich zu entfernten Anwendungen verbinden und so ein Remote
Debugging durchführen. Dazu muss die JVM der untersuchten Anwendung in einem
Debugmodus gestartet werden (weitere Informationen dazu finden sich in [NB06b]).
Mit dem Profiler Erweiterungspaket stellt NetBeans eine leistungsfähige Möglichkeit bereit, um die erstellten Applikationen bezüglich ihres Laufzeitverhaltens zu
Evaluierung
78
analysieren. Nach [KCC+06] können alle Applikationen, welche das sogenannte
JVM Tool Interface [JVMTI06] unterstützen, untersucht werden. Ab Sun JDK 1.5
Update 4 ist das Interface standardmäßig integriert.
Der Profiler bietet Standardprofile für typische Analysen wie laufende Anwendungsüberwachung, Performance- und Speicherbedarfanalyse. Für spezielle Analyseschwerpunkte ist es auch möglich, eigene Profile zu definieren.
Abbildung 3.32: NetBeans - Profiler Ansicht
Abbildung 3.32 zeigt einen typischen Profiling-Vorgang. Im Hauptbereich wird der
Zeitbedarf der einzelnen Methoden angezeigt. Die Darstellung kann flexibel konfiguriert werden, um z. B. nur im Zuge der untersuchten Anwendung entwickelten
Methoden zu visualisieren, und Standard JDK Aufrufe auszublenden. Am rechten
Rand wird das Profiler Control Panel angezeigt, in dem die Analyse gesteuert und
die Ansicht angepasst werden kann. Die VM Telemetry Overview Ansicht, im unteren Bereich der Abbildung, gibt einen Überblick über die Heapauslastung, die Arbeit
des Garbage Collectors sowie die Anzahl der laufenden Threads.
Mit dem Profiler können auch entfernte Prozesse analysiert werden. Diese Art der
Untersuchung hat den Vorteil, dass durch die zu analysierende Anwendung und Profiler auf unterschiedlichen Maschinen ausgeführt werden können und so mehr Ressourcen für die Applikation zur Verfügung stehen. Wird der Profiler zur Untersu-
Evaluierung
79
chung von Anwendungen im Produktivbetrieb herangezogen, ist es aufgrund des
Overheads sinnvoll, die Profilingvorgänge möglichst kurz zu halten. Um trotzdem
eine genaue Analyse durchzuführen, können die gesammelten Daten in sogenannten
Snapshots gespeichert und offline untersucht werden.
Für Unit Tests wird in NetBeans das JUnit Testframework verwendet. Es stehen Assistenten zur Verfügung, die es erlauben, Rümpfe von Testklassen zu generieren. Es
wird in diesem Fall für jede Methode der zu testenden Klasse eine korrespondierende Testmethode erzeugt, in der lediglich die Implementierung angepasst werden
muss. Die Testfälle werden standardmäßig in einem anderen Verzeichnis abgelegt,
sodass Produktiv- von Testcode sauber getrennt ist. Zum Ausführen der Testfälle
wird eine spezielle JUnit Ansicht eingeblendet, die in Ansicht und Funktion an die
Orginal JUnit Swingoberfläche angelehnt ist, siehe dazu Abbildung 3.33.
Abbildung 3.33: NetBeans - JUnit Ansicht
NetBeans unterstützt derzeit JUnit Version 3. An einer Unterstützung von Version 4
wird nach [NB06h] derzeit gearbeitet. Standardmäßig bietet NetBeans keine Code
Coverage-Analyse. Diese kann jedoch z. B. durch die Erweiterung Clover [Clov06]
nachgerüstet werden.
NetBeans bietet derzeit standardmäßig keine spezielle Unterstützung für die Durchführung von Quality Audits. Es stehen jedoch einige externe Programme bereit, die
sich in die IDE integrieren lassen. Für CheckStyle [CkS06] steht beispielsweise eine
Integration unter [NBCS06] zur Verfügung. Diese ist jedoch veraltet und unterstützt
keine aktuellen Versionen von CheckStyle. Um eine aktuelle Version des Programms unter NetBeans nutzen zu können, ist es jedoch möglich den der CheckStyle-Distribution beiliegenden Ant-Task zu verwenden. Für Auditanalysen stehen für
die Tools [FB06] sowie PMD [PMD06] weitere leistungsfähige NetBeans Module
Evaluierung
80
zur Verfügung. Die Funktionsweise von CheckStyle, FindBugs und PMD wurde in
der Eclipse Evaluierung bereits erläutert.
Derzeit bietet NetBeans keine integrierte Möglichkeit eine Analyse nach üblichen
Qualitätsmetriken durchzuführen. Das derzeit in Entwicklung befindliche NetBeans
Projekt Metrics [NB06i] verspricht jedoch eine Verbesserung dieser Situation für
zukünftige NetBeans Versionen.
Im Bereich des ALM werden die Phasen Modellierung, Implementierung und Testen
direkt von der Entwicklungsumgebung abgedeckt. Spezielle Bestrebungen, einen
kompletten Application Lifecycle, entweder außschließlich durch die IDE oder auch
durch teilweiser Zusammenarbeit mit Fremdkomponenten, abzudecken, sind derzeit
nicht zu erkennen.
Nachdem, wie eingangs im Allgemeinen Teil (Kapitel 4.3.1) bereits erwähnt, NetBeans eine modulare Erweiterungsstruktur bietet und die Entwicklung von Modulen
mit Version 5.0 erheblich vereinfacht und dokumentiert wurde, gibt es inzwischen
viele Plugins für die IDE. Der NetBeans Plugin Catalogue [NB06j] listet inzwischen
über 80, teils kommerzielle, Erweiterungen für die Entwicklungsumgebung auf.
Hilfe und Support
NetBeans verfügt über eine umfangreiche und gut aufbereitete Online-Hilfe. Alle
untersuchten Erweiterungen integrierten ihre Dokumentation in das Hilfesystems
und sind konsistent gestaltet.
Abbildung 3.34: NetBeans - Dynamisches Hilfesystem
Evaluierung
81
Neben der Standard-Hilfe gibt es eine dynamische Hilfe. Bei diesem Hilfesystem
wird eine Ansicht eingeblendet, in der passende Themen in einer Baumstruktur zum
aktuell fokussierten Element eingeblendet werden, siehe dazu Abbildung 3.34.
Für die Entwicklung von J2EE Applikationen steht der sogenannte BluePrints Solutions Catalog zur Verfügung. Bei diesem Hilfesystem wird zu verschiedensten J2EE
Fragestellungen zunächst ein Artikel bereitgestellt, der die Problemstellung erläutert
und anschließend zur Lösung führt. Um das Thema anschließend auch praktisch
nachvollziehen zu können, gibt es die Möglichkeit, ein passendes Beispielprojekt
generieren zu lassen.
NetBeans verfügt über eine stetig größer werdende Community die nach [BC06] in
den letzten eineinhalb Jahren von ca. 40.000 auf ungefähr 300.000 Anwender angewachsen ist. Obwohl die Popularität von NetBeans hinter der von Eclipse liegt, gibt
es auf der offiziellen Community Hompage unter [NB06k] umfangreiche Aktivitäten, siehe dazu auch Tabelle 3.7.
Veranstaltungen
Ein Kalender gibt einen Überblick über kommende
Veranstaltungen mit NetBeans-Bezug. Es werden
beispielsweise Konferenzen, Seminare und Messen
angekündigt. Im Normalfall finden sich hier mindestens 4 Einträge pro Monat.
Video Demonstrationen
Neue und andere interessante NetBeans Funktionalitäten werden oft von Mitgliedern des Entwicklungsteam oder routinierten Anwendern in Form einer
Flash Demonstration zur Verfügung gestellt. Diese
Videos erlauben einen praxisnahen Einblick in die
Arbeit mit NetBeans.
Mailinglisten
Zum Informationsaustausch stehen diverse Mailinglisten für Anwender und Entwickler bereit.
Tabelle 3.7: NetBeans - Aktivitäten der Community
Für Anwender, die auf kommerziellen Support Wert legen, bietet die Firma Sun
Microsystems entsprechende Pakete an. Unter [NB06l] wird beispielsweise eine 24/7
Telefonunterstützung für die NetBeans IDE angeboten.
Evaluierung
82
Sonstiges
Das bereits bei der Eclipse Evaluierung beschriebene Ant-Buildsystem kommt in der
NetBeans IDE intensiv zum Einsatz. Bei diversen anderen JavaEntwicklungsumgebungen, wie z. B. Eclipse oder JBuilder, ist Ant als alternatives
Buildsystem integriert. NetBeans geht nach [KCC+06] hier einen Schritt weiter und
verwendet es als alleiniges System für alle projektbezogenen Aktionen wie beispielsweise Kompilier- oder Debugprozesse. Wenn ein neues Projekt angelegt oder
ein bestehendes abgeändert wird, generiert die IDE die entsprechenden XML-Tags
im Ant-Skript automatisch. Der größte Vorteil dieses Ansatzes ist, dass das Projekt
auch ohne spezielle Anpassungen in einer anderen IDE oder direkt in der Konsole
übersetzt oder ausgeführt werden kann.
NetBeans unterstützt die VCS-Systeme CVS [CVS06] und Subversion [SubV06].
Während CVS bereits in der Standarddistribution enthalten ist, muss Subversion
über das Update-Center nachinstalliert werden. Laut der NetBeans SubversionIntegrations-Homepage [NB06m] wird es in der, voraussichtlich Mitte 2007 erscheinenden, Version 6.0 standardmäßig integriert sein. Die Systeme binden sich direkt in
die Projektverwaltung ein und erlauben das einfache Absetzen der entsprechenden
VCS Befehle. Die Arbeit mit den VCS Systemen wird durch eine Reihe integrierter
Hilfsprogramme, die beispielsweise das Vereinen, das Suchen oder den Vergleich
unterschiedlicher Versionen ermöglichen, sehr komfortabel gestaltet.
Für moderne Entwicklungsumgebungen ist eine adäquate Unterstützung von XML
sehr wichtig. So bietet auch NetBeans in der IDE als Standard-Plugins bereits einige
Möglichkeiten, XML-Dokumente, DTDs oder Schemas zu erstellen bzw. zu verarbeiten. Oft wird hier ein textbasierter Ansatz gewählt. Mit dem XML-Plugin im Enterprise Erweiterungspack geht man hier neue Wege. Man hat erkannt, dass die rein
textbasierte Erstellung und Darstellung von z. B. großen Schema-Dateien nicht sonderlich intuitiv ist. Das XML-Plugin bietet deshalb verschiedene Varianten, um
Schemas grafisch aufzubereiten sowie zu editieren. Neben der einfachen SourceAnsicht existiert eine Baumansicht, eine mehrspaltige Ansicht der SchemaBestandteile sowie eine grafische Designansicht. Ein weiteres innovatives Feature
des Plugins ist die Analyse von Abhängigkeiten in der Schema-Datei. Wenn man
herausfinden möchte, an welchen Stellen im Schema Elemente referenziert werden,
kann bequem eine entsprechende Option im Kontextmenü genutzt werden. Dies öffnet zum einen eine XML-Refactoring-Ansicht für die Darstellung der Abhängigkeiten, zum anderen wird auch ein grafisches Modell, welches an UMLKlassendiagramme angelehnt ist, angezeigt. (nach [AT06])
Evaluierung
83
Abbildung 3.35: NetBeans - Refactoring einer XML-Schema Datei
Evaluierung
3.3
84
JBuilder 2006
Hersteller
Borland Software Corporation
Produktversionen
Foundation, Developer, Enterprise
Testversion
JBuilder 2006 Enterprise, Deutsche Trialversion
Anschaffungskosten
Kostenlos (Foundation) – 4000 EUR5 (Enterprise)
Plattform
Windows, Linux, Solaris
Homepage
www.borland.com
3.3.1 Allgemeines
Borland JBuilder war eine der ersten Entwicklungsumgebungen für die Programmiersprache Java. Nach [RGN03] war Borland’s erste Idee, Java-Unterstützung in
ihr Produkt C++ 4.5.1, ein früher Vorgänger des C++ Builders [Bor06e], bereitzustellen. Diese Erweiterung erlaubte das Erstellen von Java-Quelltexten und bot die
Möglichkeit, den Compiler aus der IDE zu starten. Unterstützung bei der Fehlersuche oder gar Debuggingfunktionalitäten wurden nicht geboten.
Die ersten JBuilder Versionen waren nach [RGN03] teilweise in C++ und Delphi,
sowie ein kleiner Teil der Implementierung, ungefähr 20 Prozent, in Java implementiert. Der im Jahr 2000 erschienene JBuilder 3.5 war schließlich die erste Version,
die komplett in Java realisiert wurde. Der aktuelle JBuilder 2006 ist, nach einer Änderung der Versionskennzeichnung im Jahr 2005 von laufender Nummer auf Erscheinungsjahr, bereits das 12. Major-Release.
Anfang 2006 sah es so aus, als wäre JBuilder 2006 die letzte Version unter der Leitung der Firma Borland. In einer Pressemitteilung [Bor06d] teilte die Firmenleitung
mit, ihre IDE-Produke, mit denen Borland einst Markführer gewesen ist, verkaufen
zu wollen, um sich verstärkt auf Application-Lifecyle-Mangement Produkte konzentrieren zu können. Zum angekündigten Verkauf kam es schließlich nicht. Stattdessen gründete Borland die Tochterfirma CodeGear (Pressemitteilung: [Bor06c]),
die sich um die IDE-Produkte kümmern sollte.
5 Borland Vertrieb durch http://www.edv-buchversand.de/borland/ (16.09.2006)
Evaluierung
85
Trotzdem wird JBuilder 2006 die letzte Version in seiner heutigen Form sein. Borland bzw. CodeGear kündigte an [Bor06f], dass JBuilder 2007 auf die Eclipse Plattform aufsetzen wird und diese um Borland’s ALM Produkte, wie Together, CaliberRM und StarTeam ergänzen wird. Borland ist zwar langjähriges Mitglied der
Eclipse Foundation, trotzdem kam dieser Schritt für viele überraschend.
Editor
JBuilder verfügt über einen modernen Codeeditor, der fast alle im entsprechenden
Abschnitt des Kriterienkatalogs aufgelisteten Features abdeckt. Die Change Bar, eine
vertikale Markierungsleiste, welche geänderte Codebereiche farbig hervorhebt, fehlt
jedoch.
Abbildung 3.36: JBuilder - Codeeditor
Abbildung 3.36 zeigt exemplarisch die Arbeit mit dem JBuilder Quelltexteditor. Die
diversen Vervollständigungsfunktionalitäten, wie z. B. die Code Completion in Abbildung 3.36, sind komfortabel bedienbar und individuell konfigurierbar. So kann
beispielsweise die Zeitdauer zwischen dem letzten Tastendruck durch den Benutzer
Evaluierung
86
und dem Erscheinen des Popup-Fensters eingestellt werden. Wird die Vervollständigung bei einer Wertzuweisung verwendet, können unpassende Vorschläge ausgeblendet werden. Diese Funktion ist besonders bei umfangreichen Strukturen hilfreich. Die Abbildung zeigt weiters einen eingeklappten Abschnitt (Zeilen 126-129),
einen Debugger-Haltepunkt (Zeile 141) sowie ein Lesezeichen (Zeile 138). Aktuell
fehlerhafter Quelltext wird rot unterwellt dargestellt.
Der Codeeditor bietet einige weitere hilfreiche Funktionen. Die sogenannte ScopeInsight Funktion beispielsweise ist ein Bereichswerkzeug für den Quelltext, das die
Verschachtelungsebenen oberhalb des aktuell im Editor sichbaren Code-Elements
identifiziert und den Kontext angibt, indem es die verknüpften Klassen, Methoden
oder Ausdrücke im Quelltext anzeigt. ScopeInsight zeigt die Position in der geöffneten Datei an, indem es den Klassen- und Methodennamen der aktuellen Struktur in
einem schattierten Popup-Feld am obigen Editorrand einblendet. Mit dem sogenannten SyncEdit-Werkzeug können mehrfach vorkommende Bezeichner innerhalb eines
markierten Bereichs schnell und einfach abgeändert werden.
Bei jeder geöffneten Java Quelltext-Datei kann in die sogenannte „Doku“-Ansicht
umgeschaltet werden. In dieser einfach gehaltenen JavaDoc-Ansicht kann jederzeit
der aktuelle Zustand der Klassendokumentation, ohne manuelles Erstellen der APIDokumentation, untersucht werden.
Bei Klassen, die grafische Oberflächenstrukturen enthalten, ist es möglich in die
sogenannte Designer-Ansicht zu wechseln. Diese enthält mehrere Entwurfswerkzeuge. Zu diesen gehören ein UI- und Menü-Designer sowie ein Werkzeug für den Datenzugriff. Der UI-Designer ermöglicht das übliche Zusammenstellen der Benutzeroberfläche mit JavaBeans aus einer Komponentenpalette. Das Arbeiten mit den
komplexeren Layout-Managern wie beispielsweise dem GridBagLayout ist relativ
umständlich und bietet keine besonderen Vorteile gegenüber dem Arbeiten direkt im
Quelltext. Der Designer eignet sich gut für einfache Designs z. B. auf Basis des BorderLayouts und Null-Layouts. Mit dem Borland Layout-Manager XYLayout steht
ein erweitertes Null-Layout zur Verfügung, das die bevorzugte Größe (preferredSize) der Komponente berücksichtigt. XYLayout passt die Komponentengröße an das
Erscheinungsbild, z. B. spezielle Schriftarten, des Systems an. Bei Verwendung des
Null-Layouts würden durch die absoluten Pixelangaben Probleme, wie beispielsweise abgeschnittene Texte und überlappende Komponenten, auftreten.
Evaluierung
87
Abbildung 3.37: JBuilder - GUI-Designer Ansicht
Der Designer verwendet keine speziellen Ressourcen um die Oberflächeninformationen zu speichern, sondern bezieht und legt die Information direkt im Java Quelltext
ab. Diese von Borland als Two-Way-Tool-Technologie bezeichnete Technik erlaubt
sowohl Änderungen im Designer als auch direkt im Quelltext.
Beim visuellen Designer handelt es sich um eine Komponente mit gut dokumentierten Schnittstellen. Diese erlauben es Entwicklern ihn gegebenfalls anzupassen. Beispielsweise wäre eine Unterstützung zusätzlicher Layout-Manager denkbar.
JBuilder unterstützt die typischen, im Kriterienkatalog vorgestellten, Refactoringmöglichkeiten (siehe dazu das in Abbildung 3.38 dargestellte Refactoring-Menü).
Abbildung 3.38: JBuilder - Refactoringmenü, Refactoring-Historie
Evaluierung
88
Die durchgeführten Änderungen werden in der sogenannten Refactoring-Historie
abgelegt. Diese kann zu Projekt- und Bibliotheksarchiven hinzugefügt werden, sodass beispielsweise andere Projekt-Mitglieder sehen können, welche RefactoringVorgänge ausgeführt wurden. Im Dialogfeld „Verteilte Refactorings“ können die
Teammitglieder ihren Quelltext entsprechend anpassen. Refactoring-Vorgänge müssen nicht unbedingt im Quelltexteditor durchgeführt werden, einige Mechanismen
stehen auch in der UML-Ansicht zur Verfügung (siehe dazu Modellierung in diesem
Abschnitt).
JBuilder 2006 ist neben der englischen Orginalversion in den Sprachen Deutsch,
Französisch und Japanisch erhältlich. Im Zuge dieser Evaluierung wurde großteils
mit der deutschen Version gearbeitet. Die deutsche Übersetzung ist durchwegs in
Ordnung, in der Onlinehilfe gibt es jedoch einige Übersetzungsfehler und einige
Spezialkapitel, wie beispielsweise die OpenTool-Dokumentation, sind nur auf Englisch verfügbar. Die Oberfläche wurde gut übersetzt, auf unbedingtes Übersetzen
jedes Spezialbegriffes wurde jedoch verzichtet.
JBuilder 2006 verfügt über keine spezielle Unterstützung für Entwurfsmuster, da bei
Borland IDEs üblicherweise die Erweiterung Together [Bor06g] diese Aufgabe übernimmt. Borland Together wurde für JBuilder 2006, im Gegensatz zur Vorversion
2005, nicht zur Verfügung gestellt. Da es sich bei der kommenden JBuilder Version
2007 um einen Eclipse-basierten Ansatz handelt und für Eclipse bereits eine Together Portierung bereit steht, ist anzunehmen, dass für JBuilder 2006 kein entsprechendes Modul nachgereicht wird.
Der Aufbau der Arbeitsumgebung bietet in der Standardkonfiguration eine für Entwicklungsumgebungen typische Anordnung der Komponenten. Zentrales Element ist
der Eingabeteil, z. B. Code- oder visueller Editor, am rechten Rand eine Übersicht
der Dateien des Projekts und eine Strukturansicht der aktuell geöffneten Klasse mit
ihren einzelnen Elementen wie Methoden und Variablen. Die Anordnung dieser
Komponenten kann per Drag-and-Drop einfach geändert werden und bei Bedarf als
sogenannter Arbeitsbereich gespeichert werden. Ein Arbeitsbereich ist vergleichbar
mit einer Perspektive unter der Eclipse IDE. Zwischen den abgelegten Arbeitsbereichkonfigurationen kann einfach gewechselt und diese für jeweils unterschiedliche
Aspekte der Entwicklung verwendet werden.
Evaluierung
89
Modellierung
JBuilder 2006 bietet minimale Unterstützung für UML, indem es die Möglichkeit
bereitstellt begrenzte Paket-Abhängigkeitsdiagramme und kombinierte Klassendiagramme aus dem Quelltext zu generieren (Reverse Engineering). Zur Visualisierung
von Code mit Hilfe von UML-Diagrammen gibt es den UML-Browser. Dieser ist
über das Register UML in der Editoransicht erreichbar und jede aktuell aktive JavaDatei kann in diese Ansicht umgeschaltet werden (siehe dazu auch Abbildung 3.39).
UML-Sichtbarkeitssymbole können wahlweise gemäß der UML-Standard-Notation
oder eigenen JBuilder Grafiken ausgeführt sein, wie etwa in Abbildung 3.39 ersichtlich. Durch Klicken auf einzelne Elemente wie Klassen und Abhängigkeiten kann zu
anderen Diagrammen navigiert werden. In der UML-Ansicht steht ein Kontextmenü
zur Verfügung, welches schnellen Zugriff auf gängige Aktionen, wie passende Refactoring-Befehle (Referenzen suchen, Umbenennen, Verschieben, Parameter ändern, …), Diagramm als PNG-Grafik abspeichern und JavaDoc-Anzeige bietet.
Abbildung 3.39: JBuilder - UML Ansicht
Neben der eigentlichen UML-Ansicht gibt es noch ein Strukturfenster, in Abbildung
3.39 rechts unten eingeblendet, welches eine Baumansicht der Beziehungen anzeigt.
Diese Ansicht kann für die Auswahl und Navigation zu einer Klasse oder einem Paket verwendet werden. Darüber hinaus werden auch Informationen angezeigt, die im
Diagramm nicht enthalten sind, weil sie beispielsweise durch den Benutzer herausgefiltert wurden oder aus Gründen der Übersichtlichkeit entfernt wurden.
Evaluierung
90
Für erweiterte UML-Fähigkeiten sowie Unterstützung für modellgetriebene Entwicklung ist bei Borland IDE-Produkten das Produkt Borland Together [Bor06g]
zuständig. Dieses ist jedoch, wie bereits erwähnt, nicht für den JBuilder 2006 erhältlich. Durch diesen Umstand stehen im UML-Bereich standardmäßig nur wenige und
für modellgetriebene Entwicklung keine Funktionen zur Verfügung.
Programmierung
JBuilder 2006 ist eine reine Java-Entwicklungsumgebung und unterstützt keine weiteren Programmiersprachen. Eine Integration alternativer Java Compiler, wie beispielsweise Jikes [IBM06b] ist jedoch mit OpenTool-Erweiterungen möglich.
JBuilder 2006 liefert standardmäßig bereits viele Klassenbibliotheken und Frameworks mit. Tabelle 3.8 zeigt einige der mitgelieferten Bibliotheken.
Apache Axis 1.2.1 [Apa06f]
Bei Apache Axis handelt es sich um eine Implementierung des Simple Object Access Protocol (SOAP),
ein XML-basiertes Protokoll für den Austausch von
Informationen.
Apache Cocoon 2.1.5
[Apa06g]
Bei Cocoon handelt es sich um ein Servlet-basiertes
Java-Publishing-Framework zur Veröffentlichung
von XML. Dabei wird Inhalt, Stil und Logik getrennt und mittels XSL-Transformation in das Zielformat übergeführt.
Apache Cactus 1.7 [Apa06e]
Cactus erweitert JUnit um Komponententests für
serverseitigen Java-Code. Cactus leitet dazu den
Testfall an einen serverseitigen Proxy weiter.
Apache Xalan 2.2 [Apa06h]
Xalan ist ein XSLT-Prozessor. Zu den Features von
Xalan zählt beispielsweise eine umfangreiche
Schnittstellenunterstützung für die Java API for
XML Processing (JAXP).
BorlandXML
BorlandXML bietet laut der JBuilder Onlinehilfe
einen Datenbindungsmechanismus, der die Details
von XML ausblendet und somit die CodeKomplexität zur leichteren Handhabung verringert.
Evaluierung
91
HttpUnit 1.5.4 [HttpU06]
HttpUnit ermöglicht Komponententests für Webseiten und wird dazu in das JUnit-Testframework integriert. Es ermöglicht die Emulierung typischer
Browserfunktionalitäten inklusive Formularbehandlung, JavaScript, HTTP-Authentifizierung, Cookies
und automatische Weiterleitungen.
Sun JavaMail 1.3.2 [Sun06i]
JavaMail stellt ein plattform- und protokollunabhängies Framework für das Entwickeln von Mailapplikationen zur Verfügung.
Tabelle 3.8: JBuilder - Einige mit der IDE ausgelieferte Klassenbiblotheken
JBuilder bietet umfangreiche Unterstützung bei der Arbeit mit Komponentenstandards und Middlewaresysteme. Für Enterprise JavaBeans steht beispielsweise ein
komfortabler Deployment-Deskriptor-Editor zur Verfügung. Weiters steht ein leistungsfähiger EJB-Designer bereit, mit dem man visuell ein Enterprise-Bean erstellen
kann. Abbildung 3.40 zeigt die Arbeit mit diesem EJB-Werkzeug.
Abbildung 3.40: JBuilder - EJB-Designer (Bildschirmfoto: JBuilder-OnlineHilfe)
Evaluierung
92
Der Designer ist ein vollständiges Zwei-Wege-Tool: Änderungen können sowohl
direkt im grafischen, als auch im Code-Editor durchgeführt werden. Der Quelltext
und das Modell werden dabei synchronisiert.
Auch für den Middleware-Standard CORBA (Common Object Request Broker Architecture) bietet JBuilder eine umfassende Unterstützung. JBuilder hat standardmäßig die CORBA-Entwicklungswerkzeuge VisiBroker ORB [Bor06h] sowie OrbixWeb ORB [OW06] integriert und bietet auch Werkzeuge zur Konfiguration anderer
ORBs von Drittherstellern an.
Das Borland eigene Produkt VisiBroker bietet eine CORBA ORB-Laufzeit- und Entwicklungsumgebung, zur Verteilung und Verwaltung verteilter Java-Anwendungen.
Erstellte Objekte können auf webbasierte Anwendungen zugreifen, die den Übertragungsstandard IIOP (Internet Inter-ORB Protocol) zur Kommunikation zwischen
verteilten Objekten verwenden.
Die, für Methodenaufrufe von externen Java-Objekten entwickelte, Technologie
RMI (Remote Method Invocation) wird durch einige Assistenten sowie einer integrierten RMI-Registrierung ebenfalls unterstützt.
Klassenbibliotheken und Komponenten von Drittanbietern stehen, wie bei jeder anderen Entwicklungsumgebung für Java, in großem Umfang zur Verfügung. Zur Verwaltung gibt es einen komfortablen Dialog, in dem die Bibliotheken übersichtlich
kategorisiert werden können, siehe dazu auch Abbildung 3.41.
Abbildung 3.41: JBuilder - Dialog zum Verwalten der Klassenbibliotheken
Evaluierung
93
Die von JBuilder standardmäßig mitgelieferten Komponenten werden ebenfalls direkt mit diesem System verwaltet. Zu den einzelnen Einträgen können optional neben der eigentlichen Klassenbibliothek zusätzlich noch Pfade zu Quellcodedateien
sowie API-Dokumentation definiert werden. Es ist auch möglich, Abhängigkeiten zu
anderen Bibliotheken anzugeben.
Zum Internationalisieren von Anwendungen bietet JBuilder verschiedene Funktionen. Für Anwendungen, die nachträglich übersetzt werden sollen, gibt es einen sogenannten Ressourcen-Experten. Dieser durchsucht den Quelltext und ermöglicht die
Verschiebung von fixkodierten Texten, sowie bereits definierten Tastaturkürzeln in
Ressourcebündel-Dateien. Beim Platzieren übersetzbarer Textkomponenten im UIDesigner gibt es die Möglichkeit, die entsprechenden Strings umgehend in Ressourcebündeln abzulegen. Länderspezifische Zeichen, wie beispielsweise die Umlaute im
deutschsprachigen Bereich, werden automatisch mit entsprechenden Unicode Escape-Sequenzen kodiert, um eine korrekte Darstellung auf allen Systemen zu gewährleisten.
Für das Entwickeln von Projekten, die eine Datenbank benötigen, bietet JBuilder
einige Funktionen. Die integrierte Borland Datenbank JDataStore ist eine reine JavaDatenbank folgende Komponenten beinhaltet:
•
Eine eingebettete relationale Datenbank mit JDBC- und DataExpressSchnittstellen, die einen Mehrbenutzerzugriff unter Transaktionsbedingungen
unterstützt.
•
Eine Objektspeicherlösung für das Speichern von serialisierten Objekten und
Dateiströmen.
•
Eine JavaBean-Komponente, die mit visuellen Tools zum Erstellen von JavaBeans bearbeitet werden kann.
Zur Verwaltung der JDataStore-Datenbanken steht der sogenannte JDataStoreExplorer, der in die IDE integriert ist, zur Verfügung.
Für Datenbanken mit JDBC-Treiber steht der Datenbank-Pilot bereit, der einen Dankenbank-Browser sowie einen SQL-Abfrageeditor bietet. Mit Hilfe des JDBCMonitors kann der laufende Datenbankverkehr beobachtet werden. Dabei werden,
laut OnlineHilfe, alle JDBC-Treiber während ihrer Verwendung in JBuilder überwacht.
Evaluierung
94
Für den grundlegenden Datenzugriff stellt JBuilder die DataExpress-Komponenten
zur Verfügung. Diese decken mit den Phasen Daten bereitstellen, Daten manipulieren und Daten Speichern alle wichtigen Funktionalitäten einer typischen Datenbankanwendung ab. Die dbSwing-Klassenbibliothek stellt grafische Komponenten für ein
Datenbankfrontend auf Basis des Swing-Widgetsets zur Verfügung. Die gebotenen
Tabellen- und Navigationskomponenten werden standardmäßig im GUI-Designer
angeboten und können einfach konfiguriert werden.
Abbildung 3.42: JBuilder - Mit dbSwing-Komponenten erstelltes Datenbank-Frontend
JBuilder bietet umfangreiche Unterstützung bei der Erstellung von Webapplikationen. Folgende Technologien werden beispielsweise durch Assistenten und teilweise
durch unterschiedliche Modellierungswerkzeuge unterstützt:
Struts
Für die Entwicklung von Anwendungen auf Basis
des Struts-Frameworks bietet JBuilder verschiedenste Werkzeuge und Assistenten. Mit dem StrutsDesigner können Elemente des Webmoduls visuell
gestaltet werden. Die XML-basierten Konfigurationsdateien können über komfortable Editoren bearbeitet werden.
Applets
Um ein Applet zu entwickeln, steht ein Assistent
bereit, der die Appletgrundstruktur sowie eine pas-
Evaluierung
95
sende HTML-Datei generiert. Das User Interface
kann mit dem Designer gestaltet werden. Zum Testen der Anwendung kann der AppletViewer oder ein
Browser direkt aus der IDE gestartet werden.
Web Start
Um aus einem Applet oder einer Applikation eine
Web Start Anwendung zu entwickeln steht ein passender Assistent zur Verfügung. Weiters hilft JBuilder bei der Erstellung einer geeigneten JNLPStartdatei und bietet einen passenden Webserver,
z. B. TomCat 5.0, um die Anwendung testen zu
können.
JavaServer Faces/Pages
Die Entwicklung von JSF bzw. JSP wird von zahlreichen Assistenten und Designer unterstützt. So
steht beispielsweise ein JSF-Editor zur Verfügung
mit dem auf Quelltext-Basis die Seite bearbeitet
werden kann. Von einer Komponentenpalette können Textvorlagen per Drag-and-Drop in den Quelltext eingefügt werden. Mit dem visuellen JSFDesigner, siehe Abbildung 3.42, kann der Nachrichtenfluss der einzelnen Seiten modelliert und Attribute der einzelnen Elemente definiert werden.
Web Services
Für Web Services steht eine Konsole zum Anzeigen
von WSDLs und SOAP-Nachrichten, ein AxisFlow-Designer, ein TCP-Monitor sowie ein WebLogic-Flow-Designer zur Verfügung.
InternetBeans Express
Dabei handelt es sich, laut JBuilder Onlinehilfe, um
Komponenten und Tag-Bibliotheken von Borland,
die die Darstellung und Bearbeitung von Daten aus
einer Datenbank erleichtern. Diese Technologie
wird in Verbindung mit Servlets oder JSP verwendet.
Servlets
Wird direkt mit Servlets gearbeitet, können diese auf
den integrierten Servern, z. B. TomCat, ausgeführt
und getestet werden.
Tabelle 3.9: JBuilder - Unterstützte Technologien bei der Entwicklung von Webapplikationen
Evaluierung
96
Bei J2EE werden die Versionen 1.3 und 1.4 unterstützt. Die aktuelle Version 1.5
wird derzeit noch nicht unterstützt. Die Server TomCat 4.1 sowie TomCat 5.5 sind in
der JBuilder 2006 Distribution enthalten. Für folgende Applikationsserver sind passende Konfigurationen vorhanden: Borland Enterprise Server 5.2 und 6.0, JBoss 3.2
und 4.1, BEA Weblogic Server 7.0 und BEA Weblogic Platform 8.1, IBM Webshere
4 und 5, Sybase EAServer 4.x und 5.x.
Abbildung 3.42: JBuilder - JavaServer Faces Flow-Designer
Die Anwendungsentwicklung für mobile Endgeräte ermöglicht das integrierte und
konfigurierte J2ME Wireless Toolkit 2.1 (WTK) von Sun Microsystems. Alternative
J2ME-WTKs, beispielsweise die Nokia Developer Suite for J2ME [NSDK06], können ebenfalls verwendet werden.
Evaluierung
97
Abbildung 3.43: JBuilder - Entwicklung für mobile Endgeräte
Abbildung 3.43 zeigt exemplarisch die Anwendungsentwicklung für mobile Endgeräte mit dem JBuilder 2006. Der gestartete Emulator stammt aus Sun’s WTK 2.1. Im
Hintergrund ist die MIDP Designeransicht geöffnet. Der Designer ähnelt dem JBuilder-Standarddesigner für Swing und AWT Oberflächen, bietet jedoch durch die fehlende Unterstützung komplexer LayoutManager des Wireless Toolkits nicht den
gleichen Komfort.
Die Applikationsentwicklung für mobile Endgeräte ist unter JBuilder einfach gehalten. Erweiterte Fähigkeiten wie beispielsweise ein Flow-Designer, um die Abfolge
der einzelnen Oberflächen übersichtlich gestalten zu können, wären wünschenswert.
Der JBuilder verfügt über einen gut integrierten und leistungsfähigen Debugger. Für
das Starten der zu untersuchenden Anwendung im Debug-Modus steht ein eigenes
Menü in der JBuilder-Symbolleiste zur Verfügung. In diesem sind alle LaufzeitKonfigurationen, die für das Ausführen der Anwendung erstellt wurden, bereits vorhanden. Der Debugger unterstützt alle Funktionalitäten, die man sich erwartet, wie
beispielsweise eine schrittweise Ausführung, Untersuchung spezifischer Abschnitte
Evaluierung
98
durch das Setzen eines Breakpoints und die Darstellung von Variableninhalten. Darüber hinaus stehen noch einige weitere interessante Funktionalitäten bereit. So existiert eine sogenannte Monitorsynchronisierung, die bei der Suche möglicher Verklemmungen (Deadlocks) sehr hilfreich sein kann.
Abbildung 3.44: JBuilder - Debuggeransicht
Abbildung 3.44 zeigt exemplarisch eine Debug-Sitzung. Während der Arbeit mit
dem Debugger wird ein Fenster (Abbildung 3.44, unterer Bildschirmrand) eingeblendet, welches Zugriff auf derzeit mögliche Aktionen des Debuggers erlaubt. Die
Inhalte dieser Ansicht sind durch Register gruppiert und bieten folgende Funktionalitäten: Eine Konsole mit Programmausgaben durch System.out bzw. System.err, eine
Ansicht der laufenden Threads mit Stack-Ansicht, die bereits erwähnte Monitoransicht, eine Datenausdruck-Ansicht, einen Überblick aktuell geladener Klassen sowie
statischer Daten und eine Übersicht über die gesetzten Haltepunkte im Quelltext.
Abbildung 3.44 zeigt eine durch einen Haltepunkt in Zeile 27 gestoppte Anwendung
mit geöffneter Threadansicht. Wird der Mauszeiger über Variablen bewegt, wird der
Inhalt dieser, falls vorhanden, visualisiert. Der Debugger bietet die Möglichkeit, sich
zu entfernten Applikationen zu verbinden, um diese untersuchen zu können.
Um Performance-Probleme auf Quelltextebene über den gesamten Entwicklungszyklus einer Anwendung verfolgen und protokollieren zu können, stellt Borland im JBuilder die Optimizeit Enterprise Suite zur Verfügung. Nach der Onlinehilfe ist es damit möglich, Performance-Engpässe auf JDBC-, JMS-, JNDI-, JSP-, EJB-, CCI- und
Evaluierung
99
auf Webservices-Ebene zu ermitteln. Tabelle 3.10 gibt einen Überblick über die einzelnen Werkzeuge der Optimizeit-Suite.
Profiler
Mit dem eigentlichen Profiler kann die Performance
auf den beschriebenen Ebenen untersucht und verbessert werden. Er enthält eine Speicher- und CPUProfiling-Funktion. Mit dem sogenannten Application Quality Analyzer werden auftretende Fehlermeldungen und Exceptions erfasst und protokolliert.
Zusätzlich gibt es noch eine Berichtfunktion, mit der
Snapshots generiert und erfasste Daten in Berichtform, beispielsweise im PDF-Format, exportiert
werden können.
Code Coverage
Dieses Optimizeit Werkzeug erlaubt die Feststellung, welche Zeilen des Quellcodes tatsächlich ausgeführt werden. Code Coverage kann verwendet
werden, um nicht benötigten Quelltext zu erkennen,
gegebenenfalls zu entfernen und so den Speicherbedarf der Anwendung zu verringern.
Thread Debugger
Der Thread Debugger ermöglicht es Threadkonflikte, verhungerte Threads und Verklemmungen zu
erkennen.
Request Analyzer
Der Request Analyzer ist, nach der Onlinehilfe, ein
Performance-Management-Tool, das bei der Optimierung von J2EE-Anwendungen hilft. Die Analyse
umfasst die Erkennung von schlechter Anwendungsperformance auf bestimmten Applikationsservern, Überbeanspruchung von J2EE-Resourcen,
sowie Probleme bei Zuverlässigkeit und Skalierbarkeit.
Progress Tracker
Dieses Werkzeug ermöglicht das Analysieren und
Vergleichen der Snapshots mittels übersichtlicher
Tabellen. Es stehen Ansichten für CPU- und Speicherprofiling sowie Code Coverage zur Verfügung.
Evaluierung
Filtereditor
100
Mit dem Filtereditor ist es möglich, einzelne Codebereiche vom Profiling auszuschließen. Dadurch
kann gezielt der Overhead reduziert werden.
Tabelle 3.10: JBuilder - Optimizeit Werkzeuge
Die Optimizeit-Suite ist zwar in die Entwicklungsumgebung integriert, ihre Werkzeuge unterscheiden sich im Vergleich zu anderen JBuilder-Komponenten jedoch
sowohl bei der Bedienung als auch im Aussehen.
Für die Arbeit mit Unit Tests bietet JBuilder umfassende Unterstützung des JUnit
Testframeworks, für das er auch eine Reihe von Assistenten zur Verfügung stellt,
siehe Abbildung 3.45. Die JUnit Unterstützung beschränkt sich derzeit auf Version
3.8. Um für eine bestehende Klasse Testfälle zu erstellen, generiert die IDE für
wählbare Methoden die entsprechenden Strukturen. Diese können anschließend um
die eigentliche Implementierung erweitert werden.
Abbildung 3.45: JBuilder - Unit Test Unterstützung
Beim Ausführen der Testfälle wird die JBTestRunner-Ansicht eingeblendet, deren
Oberfläche und Bedienung an die Orginal JUnit Swingoberfläche angelehnt ist, siehe
dazu Abbildung 3.45. Die Testfälle werden standardmäßig getrennt vom Produktivcode abgelegt, dieses Verhalten kann jedoch einfach geändert werden.
JBuilder stellt mit Cactus eine JUnit-Erweiterung bereit, die Unit-Tests für serverseitigen Java-Code ermöglicht. Laut der Onlinehilfe ist dies hilfreich beim Testen von
Enterprise JavaBeans und Webanwendungen.
Quality Audits, im JBuilder Code-Audits genannt, können auf Projektebene bequem
konfiguriert werden, siehe dazu Abbildung 3.46.
Evaluierung
101
Abbildung 3.46: JBuilder - Code Audits
Nach dem Aktivieren der Code-Audits, werden eventuelle Regelverstöße als Warnungen direkt in der Quelldatei sowie in der entsprechenden Strukturansicht durch
einen zusätzlichen Knoten „Warnungen“ visualisiert. Die Untersuchung des Quellcodes erfolgt im Hintergrund und arbeitet angenehm schnell. JBuilder erlaubt es derzeit nur vordefinierte Regeln zu wählen. Die Möglichkeit eigene Audits zu definieren, existiert derzeit nicht.
JBuilder 2006 unterstützt standardmäßig keine Qualitätsmetriken. Für die Vorgängerversion JBuilder 2005 war die Borland Erweiterung „Together“ erhältlich, die
unter anderem auch Metriken unterstützte. Together wird derzeit, wie bereits erwähnt, nicht für die aktuelle JBuilder Version angeboten.
Borland versucht den kompletten Lebenszyklus einer Applikationen mit eigenen
Produkten abzudecken. Nach [Bor06a] sind Borland’s Lösungen im ALM-Bereich
auf die einzelnen Phasen der Anwendungsentwicklung, d. h. Definition, Design, Entwicklung und Testen, abgestimmt. Sie bieten hierfür eine integrierte Plattform, in der
die Hauptfunktion für die verschiedenen Rollen des Anwendungslebenszyklus Analytiker, Architekt, Entwickler und Tester – zusammengeführt werden. Laut
[Bor06a] ermöglichen Borland’s ALM Lösungen den IT-Unternehmen, aus der
Softwareentwicklung einen überschaubaren Geschäftsprozess zu machen. Die für die
verschiedenen Rollen optimierten Lösungen sind nahtlos in einer gemeinsamen
Plattform integriert. Dadurch werden nicht nur die einzelnen Schritte des Anwen-
Evaluierung
102
dungsentwicklungszyklus überschaubar und lassen sich problemlos steuern, sondern
sie stehen – dank der verknüpften Entwicklungsprozesse – gleichzeitig in dauerhafter Verbindung mit den allgemeinen Geschäftszielen.
Abbildung 3.47: JBuilder - Borland ALM (Grafik: [MK06])
Abbildung 3.47 zeigt Borland’s Vorstellung zum Application Lifecycle Management. Für jede Entwicklungsphase stellt Borland ein entsprechendes Werkzeug zur
Verfügung. In JBuilder 2006 sind, neben der eigentlichen IDE für die Entwicklungsphase, einige Produkte, wie beispielsweise die Optimizeit-Suite (Testphase) oder die
JDataStore Datenbank (Deployphase) direkt integriert. Für manche Werkzeuge, wie
beispielsweise die Anforderungsverwaltungssoftware CaliberRM [Bor06i] (Anforderungsphase) oder diverse Datebanksysteme (Deployphase), stehen die notwendigen
Schnittstellen für eine saubere Integration bereit. Eine Ausnahme macht hier die
Modellierungsplattform Together, die derzeit nicht für JBuilder 2006 angeboten
wird.
JBuilder 2006 stellt mit der sogenannten OpenTools-API eine flexible und gut dokumentierte Schnittstelle bereit, damit die IDE um Zusatzkomponenten von Drittanbietern erweiterbar ist. Auf der Borland Homepage werden unter [Bor06j] rund 500
Erweiterungen aus den unterschiedlichsten Bereichen aufgelistet.
Hilfe und Support
JBuilder verfügt über eine umfangreiche und gut strukturierte Onlinehilfe. Diese
enthält neben den typischen Registern Inhalt, Index und Suchen auch das Register
Evaluierung
103
Aufgaben. In dieser Ansicht findet sich eine Liste mit Anleitungen die den Anwender bei der Einarbeitung in die Entwicklungsumgebung unterstützen sollen. Dabei
handelt es sich großteils um relativ einfache Aufgaben, die alle Bereiche der IDE
abdecken. Neben diesem Standard-Hilfesystem gibt es noch eine dynamische Hilfe,
welche schnellen Zugriff auf passende Hilfeinformationen während der Arbeit mit
der IDE anbietet. Das Verhalten der dynamischen Hilfe kann detailliert eingestellt
werden. So kann beispielsweise der Detailgrad festgelegt, die Verzögerungszeit bis
zur Anzeige definiert und die Art der Anzeige (Popup oder andockbares Meldungsfenster) bestimmt werden.
Die offizielle Borland Community Webseite, das Borland Developer Network
[Bor06k], behandelt Themen zu all ihren Produkten, wie eben den JBuilder aber
auch sämtliche andere IDEs (z. B. Borland Developer Studio) und ALM Produkte.
Um die dargestellten Informationen zu reduzieren, kann jedoch ein Interessensgebiet
gewählt werden. Im JBuilder- bzw. Java-Bereich finden sich folgende Inhalte:
Artikel
In diesem Bereich finden sich Neuigkeiten zu Produkten, FAQs und ausführliche Anleitungen typische Arbeiten mit den Produkten.
Audio & Video
Dieser Bereich ist besonders interessant. Hier finden
sich Produktpräsentationen und von Entwicklern
kommentierte Videos, die bestimmte Fähigkeiten
eines Produkts praxisnah und sympathisch vermitteln. Auch Interviews werden hier als Audiomitschnitt publiziert.
Beispiele
In diesem Bereich finden sich diverse Beispielprojekte für bestimmte Aufgaben. Diese sind ähnlich
den mitgelieferten Beispielprogrammen, jedoch oft
mit mehr Bezug zu aktuellen Technologien.
Termine
Im sogenannten EventCentral findet sich ein übersichtlicher Kalender mit Einträgen rund um Borland.
Termine für Seminare, Workshops und Messen sind
typischerweise hier nachzuschlagen.
Fehler und Vorschläge
Im QualityCentral haben Anwender die Möglichkeit, auf Fehler im Produkt hinzuweisen. Weiters
Evaluierung
104
kann mit anderen Anwendern diskutiert werden und
Borland-Mitarbeiter stellen gegebenenfalls Workarounds bereit.
Blogs
Viele Entwickler aus den einzelnen IDE-Teams führen ihre eigenen Blogs und schreiben Tipps und sehr
aktuelle Ankündigen über die jeweiligen Produkte.
Das JBuilder Team führt derzeit sieben Blogs.
Tabelle 3.11: JBuilder - Borland Communityaktivitäten
Für den JBuilder und allen anderen Borland Produkten steht ein kostenpflichtiges
Supportprogramm zur Verfügung. Dabei kann nach [Bor06l] zwischen drei Paketen
gewählt werden:
•
Assurance: Dieses Paket beinhaltet Produktupdates, sowie einen, auf drei Anfragen pro Jahr und einen Kontakt pro Lizenz beschränken, E-Mail und Telefonsupport innerhalb der Geschäftszeiten. Der Zugang zur Borland OnlineKnowlegebase wird ermöglicht. Dieses Paket ist bei JBuilder 2006 Enterprise
für ein Jahr im Kaufpreis enthalten.
•
Advantage: Im Vergleich zum Assurance-Paket beinhaltet es eine unbeschränkte Anzahl von Anfragen an den Support innerhalb der Geschäftszeiten, sowie drei autorisierte Kontakte für die Support-Leistungen.
•
Premium: Dieses Paket erlaubt zusätzlich fünf autorisierte Kontakte für die
Support-Leistungen und bietet Unterstützung bei Ausfällen, bei denen der
Kunde in kritischen Situation, d. h. wenn ein System nicht mehr betriebsbereit ist, gegebenenfalls einen Patch. Kunden dieses Pakets können zusätzlich
noch 24x7 Notfall-Support und erweiterte Hilfe für nicht mehr unterstützte
Produkte bestellen.
Die Preise dieser Pakete gibt es nur auf Anfrage und werden normalerweise individuell, je nach Kunden und eingesetzte Borland Produkte, verhandelt.
Sonstiges
In JBuilder 2006 wird besonders viel Wert auf Teamfähigkeit gelegt und daher besitzt die IDE in diesem Bereich interessante Funktionalitäten. So bietet JBuilder
2006 mit ClearCase [IBM06c], CVS [CVS06], StarTeam [Bor06m], Subversion
Evaluierung
105
[SubV06] und Visual SourceSafe [VSS06], im Vergleich zu den anderen evaluierten
Entwicklungsumgebungen standardmäßig die umfangreichste Unterstützung für Versions- und Konfigurationsmanagementsysteme, siehe dazu auch Abbildung 3.48.
Abbildung 3.48: JBuilder - Unterstützte VCS-Systeme
Mit der sogenannten Peer-to-Peer-Collaboration-Funktionaliät können mehrere Anwender als Team zusammen an demselben Projekt und Quelltext arbeiten. Dazu
werden folgende Funktionen bereitgestellt: Dateien senden, LAN-basierter Chat zwischen JBuilder Instanzen, gemeinsame Fehlersuche, gemeinsames Bearbeiten von
Dateien, verschlüsselte Kommunikation sowie einen integrierten Jabber-Client
[JAB06] für die Nutzung der Peer-to-Peer Funktionen über das Internet.
Abbildung 3.49: JBuilder - Peer-to-Peer Modus (Bildschirmfoto: [Bor06n])
Evaluierung
106
Abbildung 3.49 zeigt exemplarisch die Arbeit mit den Peer-to-Peer Funktionen. Es
wurden, zu Demonstrationszwecken auf einem Computer zwei JBuilder Instanzen
geöffnet, welche über das lokale Netzwerk kommunizieren. Die beiden Instanzen
arbeiten am selben Projekt. Am rechten Rand ist jeweils eine Chat-Ansicht eingeblendet. Wird eine Quelldatei zur Bearbeitung geöffnet, können Änderungen die seit
der letzten Bearbeitung von anderen Entwicklern durchgeführt wurden, einfach untersucht werden.
Öffnet ein Entwickler eine Datei, die derzeit von einem anderen Projektmitglied bearbeitet wird, werden alle durchgeführten Änderungen sofort auch auf der neu geöffneten Instanz sichtbar. Um Inkonsistenzen zu vermeiden, kann eine Datei nur von
einem Anwender aktiv bearbeitet werden. Dieser kann jedoch jederzeit die Kontrolle, mittels eines sogenannten Tokens, weiterreichen. Die sofortige Synchronisierung
funktioniert nicht nur bei der Bearbeitung auf Textebene, sondern auch bei aufwendigen grafischen Operationen, wie beispielsweise während einer Oberflächengestaltung im User Interface Designer. Jede Änderung im Designer, wie beispielsweise das
Markieren oder das Verschieben einer Schaltfläche, wird unmittelbar auch auf den
passiven Clients sichtbar.
Die Arbeit im Peer-to-Peer Modus ist sicher nicht immer sinnvoll. Doch gerade
wenn es um wichtige Designentscheidungen geht, beispielsweise um die Gestaltung
von User Interfaces, ist die Verwendung dieses Modus eine effiziente Form der
Kommunikation. Vorstellungen eines Teammitglieds können bequem anderen Entwicklern demonstriert werden und diesen wiederum ist es möglich, ihre Ideen rasch
und anschaulich einzubringen. Auch die Fehlersuche kann durch die Möglichkeit
gemeinsamer Debug-Sitzungen, interaktiv gestaltet werden.
Evaluierung
3.4
107
IntelliJ IDEA 6.0
Hersteller
JetBrains
Produktversionen
Standard
Testversion
IntelliJ IDEA 6.0
Anschaffungskosten
408 EURO6
Plattform
Windows, Linux, Mac OS X
Homepage
www.jetbrains.com/idea
3.4.1 Allgemeines
Die Firma JetBrains wurde, nach [JetB06c], im Februar 2000 von drei Softwareentwicklern gegründet. Ihr erstes Produkt, die Java Entwicklungsumgebung IntelliJ
IDEA, wurde bereits im Jänner des Folgejahres herausgebracht.
Der Markt für Java-IDEs schien zu diesem Zeitpunkt bereits gesättigt und so bescheinigten Kritiker JetBrains nur geringen Erfolg. Die Gründer rechtfertigten ihre
Entscheidung, eine neue Java-IDE zu entwickeln, nach [FSB06], mit dem Argument,
dass die, zu diesem Zeitpunkt vorhandenen IDEs, es zwar einfach ermöglichten
schnell eine Applikation zu erstellen, die Entwicklungsumgebungen jedoch nur in
sehr geringem Umfang Werkzeuge bereitstellten, die Hilfestellungen für zeitintensive Vorgänge beim eigentlichen Programmieren boten. IntelliJ IDEA erhielt viele
Funktionalitäten, die eine komfortable Umstrukturierung des vorhandenen Quelltexts
ermöglichten. Laut Eugene Belyaev, ein Chefentwickler von IntelliJ IDEA, war
JetBrains die erste Firma, die kommerzielle Unterstützung beim sogenannten Refactoring anbot. Auch der Leitspruch der Firma „Develop with pleasure!“ weist auf die
Bemühungen hin, die Softwareentwickler bei ihrer täglichen Arbeit zufrieden zu
stellen.
Der Erfolg gibt der Firma inzwischen Recht. Es verwenden, nach [JetB06c], inzwischen 60 000 Benutzer IntelliJ IDEA. Über 3000 Firmen, darunter 100 der Fortune
500 [For06] Unternehmen, zählen zu den Kunden von JetBrains.
6 Preis laut Onlineshop: http://www.jetbrains.com/idea/buy/buy.html (02.01.2007)
Evaluierung
108
Für Entwickler von OpenSource Software stellt JetBrains, bei Angabe des entsprechenden Projekts, eine spezielle Lizenz zur Verfügung, die ihnen eine kostenlose
Nutzung der IDE erlaubt.
Seit der Gründung von JetBrains erschien praktisch jährlich ein Major-Release von
IntelliJ IDEA, sodass im Oktober 2006 die aktuelle Version 6.0 veröffentlicht wurde.
Editor
IntelliJ IDEA verfügt über einen modernen und komfortabel zu bedienenden Codeeditor. Bis auf die fehlende Change Bar werden alle im entsprechenden Abschnitt
des Kriterienkatalogs aufgeführten Funktionalitäten bereitgestellt.
Abbildung 3.50: IntelliJ IDEA - Codeeditor
Abbildung 3.50 zeigt exemplarisch die Arbeit mit dem Quelltexteditor. Deutlich zu
sehen ist ein gesetzter Haltepunkt in Zeile 29, sowie die Arbeit mit der Code
Completion in Zeile 32. Faltbare Strukturen werden mit Minus-Pfeilen markiert
(z. B. Zeilen 24, 35, 40 und 42). Ein gefalteter Methodenrumpf ist bei Zeile 16 zu
Evaluierung
109
erkennen. Fehlerhafte Codeabschnitte werden rot unterwellt. Der Editor unterstützt
auch das Setzen von Lesezeichen, welche entweder als Häkchen dargestellt werden
(Zeile 39), oder, falls es eine Tastenkombination zugewiesen hat, als gelbes Kästchen mit einer entsprechenden Ziffer. Neben geforderten Editorfunktionalitäten nach
dem Kriterienkatalog bietet der Editor beispielsweise noch eine leistungsfähige
Makrofunktion, sowie Unterstützung beim Editieren von JavaDoc Kommentaren.
Zur Gestaltung grafischer Benutzeroberflächen wird ein leistungsfähiger und einfach
zu bedienender Designer zur Verfügung gestellt. Er unterstützt die Standard LayoutOutManager GridBagLayout, GridLayout, CardLayout, BorderLayout und FlowLayout. Zusätzlich kann noch das populäre FormLayout aus der JGoodies Forms
[Jgo06] Bibliothek verwendet werden.
Abbildung 3.51: IntelliJ IDEA - GUI Designer
Bei der Standardeinstellung werden die Komponenten unmittelbar nach dem Platzieren an einem Gitterraster ausgerichtet. Die grafischen Komponenten stehen, wie üblich, in einer Palette bereit und können per Drag-and-Drop auf der Arbeitsfläche
platziert werden. Die Arbeit mit dem Gittersystem gestaltet sich angenehm und auch
komplexe Oberflächen können jederzeit leicht geändert und erweitert werden. Falls
Übersetzungen der Komponenten als RessourceBündel vorliegen, kann während der
Gestaltung die Sprache gewechselt werden. Der Designer stellt eine Voransicht bereit, die das Austesten der erstellten GUI in Kombination mit installierten Java Look
& Feels [Sun06j] erlaubt. Die Designeransicht beinhaltet noch eine Strukturansicht
als Übersicht der Komponentenhierarchie, sowie die für JavaBeans typische Konfigurationstabelle. Die Oberflächeninformation wird in einer XML-Datei abgelegt.
Evaluierung
110
Die notwendigen Komponentendeklarationen werden, falls direkter Zugriff vom
Quelltext gewünscht ist, direkt in der Java Datei vorgenommen. Rümpfe für Ereignisbehandlungsroutinen können direkt aus dem Designer generiert werden. Für Oberflächen, die mit anderen Produkten erstellt wurden, steht das sogenannte
Snapshot Werkzeug zur Verfügung. Dieses analysiert die Struktur der Oberfläche,
erzeugt daraus die notwendige Beschreibungsdatei und ermöglicht anschließend die
Bearbeitung in gewohnter Manier.
Wie eingangs schon erwähnt, war IntelliJ IDEA eine der ersten Entwicklungsumgebungen mit professioneller Refactoring-Unterstützung. Dementsprechend umfangreich gestaltet sich der Funktionsumfang in diesem Bereich, siehe dazu Abbildung
3.52.
Abbildung 3.52: IntelliJ IDEA - Refactoring
Abbildung 3.52 zeigt links das Refactoring-Menü bei der Bearbeitung von Java
Quelltext, das einen Überblick über die Möglichkeiten von IntelliJ IDEA in diesem
Bereich gibt. Eine Besonderheit ist, dass Refactoring-Funktionalitäten nicht nur für
reine Java Dateien, sondern auch für JSP, XML, CSS, HTML und JavaScript Datei-
Evaluierung
111
en geboten werden. Rechts in Abbildung 3.52 wird beispielsweise der Editor beim
Refactoring einer XML Datei gezeigt. Bevor das Umbenennen eines XML-Tags
tatsächlich durchgeführt wird, kann auf Wunsch eine Vorschau angezeigt werden.
IntelliJ IDEA 6.0 ist derzeit nur in englischer Sprache erhältlich. Seit Version 5.1
wird jedoch eine Schnittstelle bereitgestellt, die eine Übersetzung der Oberfläche für
engagierte Anwender ermöglicht. Unter [JetB06b] wird der Übersetzungsvorgang
ausführlich beschrieben. JetBrains selbst stellte laut [JetB06a] Anfang 2006 eine
japanische Übersetzung bereit. Diese ist für die aktuelle Version noch nicht erhältlich. Die verfügbaren Inhalte auf der Produktwebseite sind durchwegs in Englisch
gehalten.
IntelliJ IDEA 6.0 bietet derzeit keine Unterstützung für Entwurfsmuster.
Der Aufbau der Arbeitsumgebung ist, für Entwicklungsumgebungen typisch, mit
einer zentralen Editorkomponente und diversen zusätzlichen Ansichten rund um diese realisiert. Die einzelnen Ansichten können beliebig angeordnet werden. Perspektiven, wie sie beispielsweise Eclipse bietet, stehen nicht zur Verfügung. Es können
jedoch automatisch Ansichten dem Arbeitsbereich hinzugefügt werden. So wird beispielsweise beim Ausführen von Komponententests eine entsprechende Unit TestAnsicht eingeblendet.
Modellierung
Im Bereich der Modellierung bietet IntelliJ IDEA standardmäßig praktisch keine
Funktionalitäten. Mit der kostenlosen Erweiterung SimpleUML [SUML06] ist es
zumindest möglich, den erstellten Code als Klassen- und Sequenzdiagramm grafisch
aufzubereiten. Erst mit der kommerziellen Modellierungserweiterung Visual Paradigm SDE [VP06] werden Funktionalitäten wie Forward-, Reverse- und Roundtripengineering geboten.
Programmierung
IntelliJ IDEA ist eine reine Java-Entwicklungsumgebung und unterstützt daher standardmäßig nur Java. Neben den JDKs von Sun kann auch IBM Jikes [IBM06b] verwendet werden. Für die populäre Skriptsprache Groovy [Gro06a] steht eine Erweiterung unter [Gro06b] zur Verfügung.
Es werden nur die notwendigsten Klassenbibliotheken und Frameworks mitgeliefert,
wie beispielsweise das JUnit-Testframework [JUnit06], Apache Ant [Ant06] oder
Evaluierung
112
das für den GUI-Designer benötigte FormLayout [Jgo06]. Werden für eine Webapplikation beispielsweise die Frameworks Struts [Apa06c] oder JSF [JSF06] benötigt,
werden diese direkt vom Assistenten heruntergeladen und integriert. Diese Vorgehensweise wird jedoch nicht konsequent für alle benötigten Zusatzbibliotheken angeboten. Für das Google Web Toolkit [Goo06], für welches auch einige Funktionalitäten angeboten werden (siehe Abschnitt Webentwicklung), muss das entsprechende
Framework manuell heruntergeladen und der Installationspfad anschließend angegeben werden.
Im Bereich der Middleware und Komponentenstandards wird eine umfangreiche
Unterstützung für Enterprise JavaBeans geboten, siehe dazu Tabelle 3.12 – Webentwicklung. RMI- bzw. IIOP-Stubs können mit einem entsprechenden Assistenten von
der IDE generiert werden. Für CORBA steht keine spezielle Unterstützung bereit.
Java-Klassenbibliotheken und Komponenten von Drittanbietern können in IntelliJ
IDEA auf drei Ebenen verwaltet werden:
•
Projekt Bibliotheken: Diese können nur vom jeweiligen Projekt genutzt werden.
•
Modul Bibliotheken: Ein Modul ist ein Teil eines Projekts. Diese Bibliotheken können nur vom dem Modul genutzt werden.
•
Globale Bibliotheken: Hier sollten Komponenten abgelegt werden, die in vielen Projekten genutzt werden und daher häufig benötigt werden. Klassenbibliotheken, die hier abgelegt wurden, können von jedem Projekt oder Modul
verwendet werden.
Abbildung 3.53: IntelliJ IDEA - Verwaltung der Klassenbibliotheken von Drittanbietern
Evaluierung
113
Abbildung 3.53 zeigt die Verwaltung der Klassenbibliotheken. Der Dialog ermöglicht für erweiterte Hilfefunktionalitäten bei der Nutzung der Komponenten auch das
hinzufügen einer entsprechenden JavaDoc API-Dokumentation oder den Quelltext
der Komponente.
Bei der Internationalisierung von Anwendungen wird der Entwickler durch eine Reihe nützlicher Funktionen unterstützt. Grundsätzlich können die Funktionalitäten in
diesem Bereich bei der Bearbeitung von normalen Java-Dateien, grafischen Benutzeroberflächen und JavaServer Pages genutzt werden. Zunächst stellt IntelliJ IDEA
die typischen Assistenten zum Suchen und Auslagern von fixkodierten Texten bereit.
Werden die Texte schließlich in sprachspezifische Ressourcenbündel ausgelagert,
steht bei der Nutzung der Schlüssel eine Code Completion zur Verfügung, siehe dazu Abbildung 3.54, links.
Abbildung 3.54: IntelliJ IDEA - Internationalisierungs-Funktionalitäten
Im rechten Teil von Abbildung 3.54 wird weiters der Editor für die Bearbeitung der
Sprachdateien gezeigt. Dieser erlaubt die Bearbeitung mehrere Sprachdateien gleichzeitig, indem er für jeden Schlüssel alle verfügbaren Übersetzungen anzeigt und man
diese ändern kann. Um bei vielen, zu übersetzenden, Einträgen die Arbeit übersichtlicher gestalten zu können, ist es möglich, die Schlüssel nach ihren Präfixen zu gruppieren.
Im Bereich der Datenbankprojekte steht zur Verwaltung von Datenquellen ein Dialog zur Verfügung, in dem der Entwickler die Verbindungsdaten und die zu verwendenden JDBC-Teiber definieren kann. Es gibt auch eine EJB PersistenzUnterstützung, die ein Datenmapping von JDBC- oder Hibernate [Hib06]Datenquellen ermöglicht. Für das Mapping steht auch ein Diagrammeditor zur Verfügung. Siehe dazu Abbildung 3.55.
Evaluierung
114
Abbildung 3.55: IntelliJ IDEA - EJB Persistenz Diagramm (Bildschirmfoto: [JetB06d])
Ein Abfrageeditor für SQL-Datenquellen existiert standardmäßig nicht. Mit der
kostenlosten Erweiterung DBHelper [DBH06] kann die Unterstützung relationaler
Datenbanken um einen SQL-Editor mit Syntax Highlighting und Code Completion,
einen Datenbankbrowser, eine grafische Schema-Ansicht und eine SQL-Konsole
erweitert werden.
Bei der Webentwicklung kommt IntelliJ IDEA mit umfangreichen Möglichkeiten.
Tabelle 3.12 gibt einen Überblick über die Art der unterstützten Technologien.
AJAX
Die Unterstützung von AJAX (Asynchronous JavaScript and XML) ist ein neues Feature der aktuellen Version 6.0. Bei der Arbeit mit AJAX gibt es
Refactoringmöglichkeiten, Erstellung eigener Bibliotheken, Code Completion und Syntax Highlighting. Eine einfache Integration des leistungsfähigen
AJAX Frameworks Google Web Toolkit [Goo06]
wird ebenfalls geboten.
JavaServer Faces/Pages
Die Editorkomponente für JSF und JSP bietet Code
Completion, Refactorings, Syntax Highlighting,
Code Vorlagen und die Möglichkeit der Internationalisierung. Nach [JetB06f] wird die JSP 2.0 Spezifikation vollständig unterstützt. Der integrierte Debugger kann auch für JSP-Quellcode verwendet
werden. Weiters steht eine JSP/JSF-Seiten Fluss-
Evaluierung
115
diagrammansicht zur Verfügung.
Enterprise JavaBeans
Enterprise JavaBeans werden in den Spezifikationen 1.0 bis 3.0 unterstützt. Für Routinearbeiten wie
Stub-Generierung stehen entsprechende Assistenten zur Verfügung. Es gibt leistungsfähige Refactoringmöglichkeiten, die auch auf die (XML) Descriptor-Dateien angewendet werden können.
Struts
Nach [JetB06g] wird ein Struts-Assistent zur Verfügung gestellt, der eine native Integration des Frameworks bereitstellt. Die Struts-Unterstützung bietet eine spezielle Projektansicht, um durch die
Struktur navigieren zu können. Die Quelltexteditoren bieten die typischen Funktionen wie Code
Completion und Refactoring Möglichkeiten. Für
Konfigurationsdateien stellt die IDE einige grafische Editoren zur Verfügung.
Applikationsserver Integration
IntelliJ IDEA erlaubt die Integration vieler gebräuchlicher Applikationsserver. Die Unterstützung beinhaltet nach [JetB06e] volle Debuggingmöglichkeiten, Verteilung und Entfernung von
Web-, J2EE- und EJB-Modulen sowie Start- und
Stoppmöglichkeit
der
Serverinstanz.
Nach
[JetB06e] werden folgende Server nativ unterstützt:
Apache TomCat 4.x und 5.x, Bea Systems WebLogic 7.x, 8x und 9.x sowie IBM WebShpere 5.1, 6.0
und 6.1. Für JBoss, Geronimo und Glassfish stehen
entsprechende Erweiterungen bereit.
JavaScript, (X)HTML, CSS
Auch bei der Arbeit mit diesen einfachen Webentwicklungstechniken bietet IntelliJ IDEA Hilfestellungen. Bei der Arbeit mit HTML-Dateien zeigt die
Code Completion beispielsweise die Browerkompatibilität einzelner HTML/CSS-Elemente an. Für
JavaScript-Funktionen gibt es Refactoringunterstützung.
Tabelle 3.12: IntelliJ IDEA - Webentwicklung
Evaluierung
116
Für die Entwicklung von Anwendungen mobiler Endgeräte steht standardmäßig nur
die Integration eines auswählbaren Wireless Toolkits, wie beispielsweise Sun’s
J2ME WTK, zur Verfügung. Beim Ausführen des erstellten Programms wird, wie
üblich, der entsprechende Emulator gestartet. Mit IntelliME [IME06] steht jedoch
eine kostenlose und ausgereifte Erweiterung für die Entwicklung von Midlets zur
Verfügung. IntelliME stellt einen leistungsfähigen Flow-Designer bereit, siehe Abbildung 3.56.
Abbildung 3.56: IntelliJ IDEA – Erweiterung IntelliME
Abbildung 3.56 zeigt die Arbeit mit der IntelliME Erweiterung. Aus der J2METoolbar können die entsprechenden Komponenten per Drag-and-Drop in den FlowDesigner gezogen werden. Die einzelnen Formulare können noch um Komponenten,
wie Eingabefelder und Beschriftungen, erweitert werden. Zwischen den Formularen
kann der Navigationsfluss mit Kanten festgelegt werden. Die Knoten im Diagramm
können entweder frei platziert werden oder mit einigen vorhanden LayoutAlgorithmen automatisch angeordnet werden. Aus dem Diagramm kann jederzeit
eine entsprechende Midlet-Struktur generiert werden, siehe IntelliME-Menü in Abbildung 3.56.
Evaluierung
117
JetBrains’ IDE verfügt über einen integrierten Debugger, der eine Untersuchung von
Anwendungen, Applets und Webanwendungen ermöglicht. Ein Debugging von entfernten Anwendungen ist durch die Verwendung von Sun’s JPDA Technologie
[Sun06k], auf welcher der integrierte Debugger nach [JetB06j] basiert, möglich. Jede
definierte Laufzeitkonfiguration kann im Debug-Modus gestartet werden.
Abbildung 3.57: IntelliJ IDEA - Debugger
Abbildung 3.57 zeigt die Arbeit mit dem Debugger. In der Editoransicht können
Haltepunkte (Breakpoints) gesetzt werden. IntelliJ IDEA unterscheidet vier verschiedene Arten von Breakpoints: Line-, Exception-, Field- und Methodbreakpoints.
In Abbildung 3.57 ist, in Zeile 10, ein Methodenbreakpoint und, in Zeile 14, ein Linenbreakpoint gesetzt. Das Debugfenster, in Abbildung 3.57 unten eingeblendet,
bietet eine Konsole zur Anzeige der Programmausgaben, eine Threadansicht, eine
Frameansicht, um den aktuellen Stack untersuchen zu können, sowie eine Watchansicht, die eine Untersuchung von definierbaren Ausdrücken ermöglicht. Da die Anwendung in der Abbildung durch einen Methodenbreakpoint angehalten wurde, zeigt
die Frameansicht beispielsweise gerade die Werte der Übergabeparameter in der
Frameansicht. Am linken Rand des Debugfensters sind Schaltflächen für das
schrittweise Ausführen der Applikation, sowie zur Steuerung des Debuggers sichtbar.
Evaluierung
118
IntelliJ IDEA enthält in der Standarddistribution keinen Profiler. Der leistungsfähige
und kommerzielle JProfiler [JPro06] kann jedoch in die Entwicklungsumgebung
integriert werden.
Für Komponententests ist das JUnit Testframework integriert. Es werden sowohl
Version 3.8 als auch 4.0 unterstützt. Nach dem Implementieren der Testfälle können
diese einfach über eine JUnit Laufzeitkonfiguration ausgeführt werden. Dabei wird
eine, der originalen JUnit-Oberfläche ähnelnde, Ansicht mit einigen Statistiken eingeblendet, siehe Abbildung 3.58.
Abbildung 3.58: IntelliJ IDEA - Durchführung von Unit Tests
Durch die standardmäßige Integration des EMMA Frameworks [EM06] kann optional eine Testabdeckungsanalyse aktiviert werden. Diese zeigt in der Editoreditoransicht genau an, welche Strukturen durch die implementierten Testfälle durchlaufen
wurden. In der Projektansicht, in Abbildung 3.58 links oben eingeblendet, wird für
jede Klasse bzw. jedes Paket angezeigt, welche Testabdeckung erreicht wurde.
Im Quality Audit-Bereich bietet die IDE den sogenannten Inspector, der den Quelltext entsprechend einstellbarer Regeln analysiert. Abbildung 3.59 zeigt den Einstellungsdialog, in dem die anzuwendenden Regeln ausgewählt werden können. Standardmäßig verfügt die IDE bereits über einen großen Regelumfang, beispielsweise
im Bereich Namenskonventionen oder potentielle Fehlerquellen.
Evaluierung
119
Abbildung 3.59: IntelliJ IDEA - Definition von Code Audit-Regeln
Für jede Regel kann der Grad der Information (Information, Warnung, Fehler) festgelegt werden. Interessant ist, dass verschiedene Profile angelegt werden können. So
kann bei unterschiedlichen Anforderungen rasch der Untersuchungsschwerpunkt
gewechselt werden. Die Entwicklungsumgebung bietet auch die Möglichkeit eigene
Regeln zu definieren. Für alternative Quality Audit-Analysewerkzeuge, wie
CheckStyle oder PMD, stehen Plugins für die Integration in IntelliJ IDEA zur Verfügung.
Einige einfache Methoden- und Klassenmetriken sind als Regelsammlung im Inspector vorhanden. Erweiterte Qualitätsmetriken können mit der kostenlosen Erweiterung
MetricsReloaded [MR06] abgedeckt werden. Das Plugin ermöglicht beispielsweise
Metrikanalysen in den unterschiedlichsten Bereichen. Abbildung 3.60 zeigt beispielsweise einige Komponententest-Metriken.
Abbildung 3.60: IntelliJ IDEA - Plugin MetricsReloaded
Evaluierung
120
Gewählte Metrik-Regeln können als Profil abgelegt werden, wie etwa das, in Abbildung 3.60 verwendete, Profil „JUnit testing metrics“. Die Erweiterung kann darüber
hinaus die ermittelten Werte mittels diversen Diagrammtypen grafisch aufbereiten.
JetBrains bietet kein explizites Application Lifecycle Management Programm. Einige Punkte eines solchen Programms können jedoch mit JetBrains Produkten abgedeckt werden. Für die Entwicklungs- und Testphase ist IntelliJ IDEA direkt geeignet.
Auch Konfigurations- und Änderungsmanagement kann durch die Integration diverser VCS-Systeme (siehe dazu Abschnitt „Sonstiges“ in diesem Kapitel) direkt von
der IDE übernommen werden. Vor allem für die Modellierungsphase wäre jedoch
noch eine direkte Unterstützung durch IntelliJ IDEA wünschenswert.
JetBrains stellt für Zusatzkomponenten von Drittanbietern eine eigene Plattform, das
Plugin Repository [JetB06h], zur Verfügung. Auf dieser können die jeweiligen Anbieter ihre Erweiterungen verwalten. Um IntelliJ IDEA mit diversen Erweiterungen
auszustatten, steht ein Dialog zur Pluginverwaltung zur Verfügung. Siehe Abbildung
3.61.
Abbildung 3.61: IntelliJ IDEA - Pluginverwaltung
Falls eine Internetverbindung hergestellt werden kann, wird nach dem Öffnen des
Dialogs zunächst eine aktuelle Liste mit Erweiterungen von der erwähnten Plattform
bezogen. Anschließend können Plugins gewählt werden, welche abschließend automatisch geladen und installiert werden. Ein Vorteil dieses Systems ist, dass nur Erweiterungen angeboten werden, die zur installierten Version der IDE kompatibel
sind. Derzeit können über das Plugin Repository circa 300 Erweiterungen bezogen
werden. Plugins können bei Bedarf auch manuell installiert werden.
Evaluierung
121
Hilfe und Support
Neben der umfangreichen und gut strukturierten Onlinehilfe bietet JetBrains unter
[JetB06k] weiterführende Artikel, die im PDF Format kostenlos bezogen werden
können. Weiters werden für komplexere Aufgaben, sowie innovativen Neuerungen
unter [JetB06l] Videopräsentationen bereitgestellt.
Eine innovative Form der Hilfe gibt die IDE während zeitaufwendigen Aktionen,
wie beispielsweise dem Öffnen umfangreicher Projekte oder Kompiliervorgänge.
Unter der entsprechenden Fortschrittsanzeige werden sogenannte Produktivitätstipps
angezeigt, siehe Abbildung 3.62. So kann, neben der IDE, auch der Anwender die
notwendige Zeit sinnvoll nutzen. Falls man mehr Zeit für das Lesen benötigt oder
zusätzliche Tipps lesen möchte, kann der Entwickler das Dialogfenster geöffnet halten.
Abbildung 3.62: IntelliJ IDEA - Hilfe während zeitaufwendigen Prozessen
Laut [JetB06c] wird die IntelliJ IDEA von über 60 000 Entwicklern verwendet. Für
die Community bietet JetBrains unter [intellij.org] eine Wiki Plattform, sowie ein
Forum [JetB06m] für Diskussionen. Weiters werden von JetBrains sogenannte Plugin Contests veranstaltet, welche einige Mitglieder zum Entwickeln von Erweiterungen für die IDE motiviert. Beispielsweise, die in dieser Evaluierung beschriebenen
Plugins, IntelliME und DBHelper gingen aus einem solchen Wettbewerb hervor.
Die Kundenbetreuung erfolgt großteils per E-Mail. Eine IntelliJ IDEA Lizenz beinhaltet laut [JetB06n] unlimitierten technischen Support per E-Mail. Weiters ist das
JetBrains-Team auch im Community-Forum aktiv. Es beantwortet dort häufig Anfragen und beteiligt sich auch aktiv an Diskussionen. Das IntelliJ Technology Net-
Evaluierung
122
work ITN [JetB06o] bietet kostenlosen Zugriff auf eine umfangreiche Wissensbasis.
Beta-Versionen von zukünftigen Produktversionen können ebenfalls hier bezogen
und getestet werden. Auf Fehlermeldungen und Funktionalitätswünsche kann im
Tracker des ITN aufmerksam gemacht werden.
Sonstiges
IntelliJ IDEA bietet einige interessante Funktionalitäten im Bereich der Teamzusammenarbeit. So gibt es seit der aktuellen Version eine Integration von TeamCity
[JetB06p]. Bei TeamCity handelt es sich um ein weiters JetBrains-Produkt das nach
[JetB06p] Funktionalitäten wie Continious Integreation, Build Management, serverseitige Code Coverage und Code Analyse bietet. TeamCity kann über eine Weboberfläche bedient werden und bietet eine Integration von Build-Systemen, Komponententest-Frameworks und Versionskontrollsystemen.
Im Bereich der VCS-Unterstützung werden von der IDE die Systeme CVS, Perforce,
StarTeam, Subversion sowie Visual SourceSafe standardmäßig unterstützt.
Mit dem sogenannten IDE talk ist ein, mit dem Jabber-Protokoll arbeitender, Instant
Messenger integriert. Dieser bieten neben typischen Kommunikationsfähigkeiten
beispielsweise auch die Möglichkeit Referenzen zu aktuell diskutierten Quelltextabschnitten oder Stacktraces zu übermitteln.
Abbildung 3.63: IntelliJ IDEA - Integrierter Instant Messenger (Bildschirmfoto: [JetB06i])
Für Entwickler, die nebenbei auch für die Software Dokumentation zuständig sind,
ist die integrierte DocBook-Unterstützung ein komfortables Feature. Bei DocBook
[DB06] handelt es sich um ein, vor allem bei technischen Dokumentationen, sehr
verbreitetes Format. Dieses kann durch XSLT-Transformationen in verschiedene
Formate wie PDF, RTF, HTML, CHM und JavaHelp [Sun06l] konvertiert werden.
Kapitel 4
Gegenüberstellung der Produkte
In diesem Kapitel werden die evaluierten Produkte gegenübergestellt und miteinander verglichen. Zunächst erfolgt eine allgemeine Gegenüberstellung mit augenscheinlichen Stärken und Schwächen der Umgebungen. Anschließend wird detailliert mit Hilfe des erstellten Kriterienkatalogs verglichen und bewertet. Abschließend
gibt es eine Tabelle, die den Vergleich aller Entwicklungsumgebungen unter Berücksichtigung aller Kritieren übersichtlich auf einer Seite zusammenfasst.
4.1
Allgemeine Gegenüberstellung
In diesem Abschnitt werden einige Stärken und Schwächen für die jeweilige Entwicklungsumgebung beschrieben. Die resultierende Tabelle 4.1 ermöglicht, aufgrund der Verschiedenheit der einzelnen Stärken und Schwächen, keinen direkten
Vergleich, bietet jedoch einen kurzen Überblick zu den untersuchten Produkten.
Ein detaillierter Vergleich sowie eine Bewertung auf Basis der einzelnen Kriterien
des Katalogs wird in den Abschnitten 4.2 (Gegenüberstellung nach Kriterienkatalog)
sowie 4.3 (Übersichtstabelle) durchgeführt.
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
Sehr große Commu- Gute UML2nity
Unterstützung
Innovative
Teamzusammenarbeitstechniken
Sehr leistungsfähige Refactoringmöglichkeiten
Viele Werkzeuge zur Performanceoptimierung
Durchdachte
PluginVerwaltung
Stärken
Größtes Erweiterungsangebot
Kostenlos erhältlich
Perspektivenkonzept GUI-Designer
Matisse
Natives GUIVerhalten
WYSIWYG JSPDesigner
Viele prominente
Firmen Mitglied der Leistungsfähige
Foundation
J2MEKomponente
Kostenlos erhältlich
Gute Verbindung
zum Java Team
(Hersteller: Sun)
Schwacher GUIDesigner
Schwächen
124
Grafische Modellierungstechniken
noch in Anfangsstadium
Keine Funktionen
im Bereich Quality-Audits/Metrics
Keine XMIExportmöglichkeit
der erstellten Modelle
Derzeit nur in
Englisch erhältlich
Innovative
Hilfetechniken
Für OpenSource-Entwickler
kostenlos
Minimalistische UMLUnterstützung
durch fehlendes TogetherModul
Hoher Anschaffungspreis
Undurchsichtige Supportangebote
Tabelle 4.1: Allgemeine Gegenüberstellung
Standardmäßig
keine UMLModellierung
Derzeit nur in
Englisch erhältlich
4.2
125
Gegenüberstellung nach Kriterienkatalog
In diesem Abschnitt werden die Entwicklungsumgebungen gemäß der einzelnen
Kriterien und Subkriterien des Katalogs verglichen und bewertet.
Editor - Subkriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.1 Editor
Codeeditor
+
+
+
+
User Interface Designer
o
+
o
+
Refactoring
+
+
+
+
Sprachunterstützung
+
-
+
-
Entwurfsmuster
-
+
-
-
Aufbau der Arbeitsumgebung
+
+
+
+
Tabelle 4.2: Bewertung: Editor7
Wie in Tabelle 4.2 ersichtlich, verfügen alle evaluierten Entwicklungsumgebungen
über einen leistungsfähigen Codeeditor mit umfangreichen Refactoringmöglichkeiten. Auch der Aufbau der Arbeitsumgebung ist bei den IDEs ähnlich gestaltet, kann
an den persönlichen Geschmack angepasst werden und ist standardmäßig übersichtlich.
NetBeans bietet mit dem GUI-Designer „Matisse“ in Kombination mit dem
GroupLayout die komfortabelste Möglichkeit, Desktop-Oberflächen zu gestalten.
Auch IntelliJ IDEA besitzt einen intuitven und leistungsfähigen Designer. Der Visual Editor von Eclipse sowie der JBuilder Designer sind umständlich zu bedienen und
bieten bei der Gestaltung keinen großen Vorteil gegenüber der manuellen Oberflächengestaltung. Für Eclipse gibt es mit der WindowBuilder-Erweiterung eine leis7 Für alle Tabellen mit +/-/o-Notation in diesem Kapitel gilt: +…gut unterstützt, -…nicht unterstützt,
o … schwache Unterstützung oder kommerzielle Erweiterung erforderlich
126
tungsfähige, kommerzielle Alternative.
Derzeit stehen nur für Eclipse und JBuilder Übersetzungen der Oberflächen zur Verfügung. Bei NetBeans und IntelliJ IDEA sind derzeit nur englische Versionen verfügbar. Mit Übersetzungen ist jedoch aufgrund übersetzter Vorgängerversionen noch
zu rechnen.
Entwurfsmuster werden derzeit nur von der NetBeans IDE angeboten.
Modellierung - Subkriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.2 Modellierung
Unified Modelling Language
o
+
o
o
Model Driven Architecture
o
-
-
-
Forward Engineering
o
+
-
-
Reverse Engineering
o
+
o
o
Roundtrip Engineering
o
o
-
-
Tabelle 4.3: Bewertung: Modellierung
Im Bereich der Modellierung gibt es für jede der evaluierten Entwicklungsumgebungen noch Verbesserungspotential
Eclipse stellt zwar mit EMF und GEF notwendige Komponenten für Modelleditoren
bereit, jedoch muss für grafische UML-Modellierungstechniken auf kommerzielle
Erweiterungen zurückgegriffen werden. Mit openArchitectureWare steht eine offene
Lösung für modellgetriebene Entwicklung zur Verfügung. Diese muss jedoch noch
um leistungsfähige grafische Editoren erweitert werden.
NetBeans bietet umfangreiche UML2-Unterstützung. Forward- sowie Reverse Engineering funktionieren intuitiv. Rountrip Engineering funktioniert prinzipiell, muss
jedoch manuell die Forward- bzw. Reverse Engineering Aktion durchgeführt werden. Abgesehen von Codevisualisierungen bietet NetBeans keine MDAFunktionalitäten.
JBuilder bietet minimale Reverse Engineering Möglichkeiten für Klassen mittels
127
einer Ansicht, die eine Kombination aus Klassen- und Paketdiagramm ist. Erweiterte
UML und MDA Fähigkeiten werden bei Borland normalerweise durch die Erweiterung „Together“ geboten. Diese wird jedoch für JBuilder 2006 nicht angeboten. Der
angekündigte JBuilder 2007 wird standardmäßig ein Together-Modul enthalten.
IntelliJ IDEA enthält in der Standardausführung keine UML bzw. MDA Modellierungsmöglichkeiten. Durch die Integration der kostenlosen Erweiterung
„SimpleUML“ wird zumindest einfaches Reverse Engineering mittels Klassen- und
Sequenzdiagrammen geboten. Für erweiterte Modellierungstechniken ist ein kommerzielles Plugin eines Drittanbieters erhältlich.
Programmierung - Subkriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.3 Programmierung
Compiler und Programmiersprachen
+
+
o
o
Mitgelieferte Klassenbibliotheken
+
+
+
+
Middleware und Komponentenstandards
+
+
+
+
Klassenbibliotheken von Drittanbietern
+
+
+
+
Internationalisierung von Anwendungen
+
+
+
+
Datenbankprojekte
+
+
+
+
Webentwicklung
o
+
o
+
Entwicklung für mobile Endgeräte
o
+
o
+
Tabelle 4.4: Bewertung: Programmierung
Bei diesem Kriterium schneiden die Entwicklungsumgebungen durchwegs gut ab.
Alle Hersteller liefern die wichtigsten Klassenbibliotheken mit. Für Java stehen zusätzlich viele Klassenbibliotheken zur Verfügung. Diese müssen die IDEs nur in
einer komfortablen Weise integrieren und verwalten, was alle elegant gelöst haben.
Auch bei der Internationalisierung von Anwendungen sowie bei der Arbeit mit Da-
128
tenbankprojekten unterstützen die IDEs den Entwickler mit vielen Werkzeugen und
Assistenten.
Neben Java bieten Eclipse und NetBeans Unterstützung für andere Programmiersprachen. Beide unterstützen die Entwicklung von C bzw. C++ Programmen. Für
Eclipse stehen zusätzlich noch Plugins für eine Reihe anderer Sprachen wie PHP,
Perl und Phyton zur Verfügung.
Bei der Webentwicklung bieten NetBeans und IntelliJ IDEA innovative Ansätze wie
ein WYSIWYG-Editor für JavaServer Pages (NetBeans) sowie eine Integration des
AJAX basierten Google Web Toolkits (IntelliJ IDEA). Eclipse verfügt mit dem
WTK über ein flexibles Framework für die Webentwicklung. Dieses sollte jedoch,
wie auch die JBuilder Webfähigkeiten, um grafische Designtechniken erweitert werden. Die Zusammenarbeit mit gängigen Applikationsservern funktioniert bei allen
getesteten IDEs gut.
Im Bereich der Entwicklung für mobile Endgeräte bieten die Entwicklungsumgebungen das Wireless Toolkit von Sun inklusive einer Integration der beiliegenden
Emulatoren. NetBeans und IntelliJ IDEA bieten zusätzlich die Möglichkeit, den
Workflow der Applikation grafisch zu modellieren und daraus entsprechende Midlets generieren. Diese Technik hat sich in den Tests als sehr hilfreich erwiesen.
Softwarequalitätssicherung - Subkriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.4 Softwarequalitätssicherung
Debugger
+
+
+
+
Remote Debugger
+
+
+
+
Profiler
+
+
+
o
Unit Tests
o
o
o
+
Quality Audits
+
+
+
+
Quality Metrics
+
-
-
+
Tabelle 4.5: Bewertung: Softwarequalitätssicherung
129
Alle untersuchten IDEs bieten einen leistungsfähigen Debugger mit remote Debugging-Funktionalität. Einen Profiler haben bis auf IntelliJ IDEA, wo auf eine kommerzielle Erweiterung eines Drittanbieters zurückgegriffen werden muss, integriert.
Besonders viele Werkzeuge im Bereich der Performanceanalyse bietet hier der JBuilder mit seiner sogenannten Optimizeit-Suite.
Für die Durchführung von Komponententests integrieren alle Umgebungen das JUnit-Testframework. Nur IntelliJ IDEA bietet standardmäßig noch eine Möglichkeit
zur Analyse der Testabdeckung.
Quality Audits können bei allen getesteten Entwicklungsumgebungen, teils mit kostenlosen Plugins von Drittanbietern, durchgeführt werden.
Im Bereich der Qualitätsmetriken stehen leistungsfähige und kostenlose Erweiterungen derzeit nur für die Entwicklungsumgebungen Eclipse und IntelliJ IDEA zur Verfügung. Diese Funktionalität wird bei Borland normalerweise durch das TogtherModul abgedeckt, welches für JBuilder 2006 nicht angeboten wird. In der Nachfolgeversion 2007 wird es jedoch integriert sein. Bei NetBeans wird derzeit an einer
Metriken-Erweiterung für zukünftige Versionen gearbeitet.
Erweiterbarkeit der IDE - Subkriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.5 Erweiterbarkeit der Entwicklungsumgebung
Einbindung in ein ALM
o
o
+
o
Zusatzkomponenten von Drittanbietern
+
+
+
+
Tabelle 4.6: Bewertung: Erweiterbarkeit der Entwicklungsumgebung
Einen kompletten Application Lifecycle kann derzeit nur JBuilder mit entsprechenden Zusatzprodukten von Borland abdecken. Die Eclipse Foundation hat für diesen
Zweck das ALF-Projekt ins Leben gerufen. Dieses befindet sich derzeit jedoch noch
in einem frühen Entwicklungsstadium. NetBeans und IntelliJ IDEA bieten zwar kein
spezielles ALM Programm, einige Punkte des Application Lifecycle können trotzdem abgedeckt werden.
Positiv fällt auf, dass für jedes Produkt eine Fülle von Zusatzkomponenten von Drittanbietern zur Verfügung stehen.
130
Hilfe und Support - Subkriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.6 Hilfe und Support
Dokumentation des Produkts
+
+
+
+
Größe der Community
+
+
+
+
Kundenbetreuung durch den Hersteller
+
+
o
+
Tabelle 4.7: Bewertung: Hilfe und Support
Die untersuchten Entwicklungsumgebungen verfügen alle über eine ausführliche
Dokumentation. Oft stehen auch Videopräsentationen für komplexe Aufgaben und
innovativen Neuerungen bereit.
Alle Entwicklungsumgebungen verfügen über große Anwendergemeinschaften, denen vom IDE-Hersteller Online-Plattformen zur Verfügung gestellt werden.
Die Firma JetBrains bietet für ihre IDE IntelliJ IDEA eine umfangreiche und faire
Kundenbetreuung mittels kostenlosen E-Mail Support, Beteiligung bei Forumsdiskussionen und Zugang zu einer Wissensbasis. Borland bietet für JBuilder hingegen
ein undurchsichtiges Supportprogramm, dessen Preis nur auf Anfrage bekanntgegeben wird. Die Hersteller der Open-Source Umgebungen leisten umfangreiche Kundenbetreuung über die Community-Plattformen. Zusätzlich bieten sie kommerziellen
Support entweder direkt (NetBeans) oder durch externe Firmen (Eclipse) an.
Kriterium
Eclipse 3.2
NetBeans 5.5
JBuilder 2006
IntelliJ IDEA 6
4.2.7 Sonstiges
Sonstiges
+
+
+
+
Tabelle 4.8: Bewertung: Sonstiges
131
Jede evaluierte Entwicklungsumgebung bietet neben den bisher untersuchten Kriterien noch einen großen Umfang an Zusatzfunktionalitäten. Im Bereich der Versionsund Konfigurationsverwaltung beispielsweise unterstützen die IDEs standardmäßig
zumindest eine VCS-Lösung.
Für Eclipse existiert ein kostenloses Service, das die Möglichkeit bietet, seine persönliche Eclipse Distribution mit auswählbaren Erweiterungen online zusammenzustellen, die dann als Archiv heruntergeladen werden kann.
NetBeans bietet eine sehr gute Unterstützung bei der Arbeit mit XML-Dateien. So
können Refactoringprozesse, wie z. B. das Umbenennen von Tags, auch für XML
basierte Dokumente angewendet werden.
JBuilder und IntelliJ IDEA verfügen über innovative Lösungen für die Teamzusammenarbeit wie etwa integrierte Instant Messenger und die Möglichkeit einer gemeinsamen Fehlersuche.
Übersichtstabelle
Kriterium
NetBeans
JBuilder
IntelliJ I.
Tabelle 4.9 vergleicht die IDEs unter Berücksichtigung aller Kriterien.
Eclipse
4.3
132
Editor
+
+
o
o
+
o
+
+
+
+
+
+
+
+
+
o
+
+
+
+
+
+
+
o
o
-
-
o
o
o
o
o
+
+
+
o
o
o
-
o
o
-
+
+
+
+
+
+
+
+
+
+
o
o
+
+
+
+
+
+
+
+
o
+
+
+
+
+
o
o
o
+
+
+
+
+
+
+
+
+
+
+
+
+
+
o
+
+
+
+
+
o
+
-
+
+
+
o
+
-
+
+
o
+
+
+
+
+
+
+
o
+
o
+
+
+
o
+
+
+
+
+
+
+
+
+
+
+
+
+
o
+
+
+
+
+
+
+
Codeeditor
User Interface Designer
Refactoring
Sprachunterstützung
Entwurfsmuster
Aufbau der Arbeitsumgebung
Modellierung
Unified Modeling Language
Forward Engineering
Reverse Engineering
Roundtrip Engineering
Programmierung
Compiler und Programmiersprachen
Mitgelieferte Klassenbibliotheken
Middleware und Komponentenstandards
Klassenbibliotheken von Drittanbietern
Internationalisierung von Anwendungen
Datenbankprojekte
Webentwicklung
Entwicklung für mobile Endgeräte
Debugger
Remote Debugger
Profiler
Unit Tests
Quality Audits
Quality Metrics
Erweiterbarkeit der EntwicklungsumgeEinbindung in ein ALM
Zusatzkomponenten von Drittanbietern
Hilfe und Support
Dokumentation des Produkts
Größe der Community
Kundenbetreuung durch den Hersteller
Sonstiges
Tabelle 4.9: Bewertung: Gesamtübersicht
Kapitel 5
Zusammenfassung und Ausblick
Zusammenfassend lässt sich sagen, dass jede Entwicklungsumgebung seine ganz
speziellen Stärken, siehe dazu Kapitel 4 (Gegenüberstellung der Produkte), aufweist.
Die Entscheidung für eine IDE sollte deshalb nach dem Einsatzgebiet der zu erstellenden Software getroffen werden. Da in dieser Arbeit alle Produkte auf Basis desselben Kriterienkataloges untersucht und anschließend gegenübergestellt wurden,
kann einfach festgestellt werden, ob die gewünschten Funktionalitäten unterstützt
werden. Falls diese von mehreren Produkten geboten werden, sollte die Unterstützung vom Entwickler auf persönliche Vorlieben untersucht, und die IDE entsprechend gewählt werden.
Bemerkenswert ist, dass alle untersuchten Produkte zumindest für die Betriebssysteme Windows (32-Bit Versionen) und Linux verfügbar sind. Alle Umgebungen
wurden selbst in der Programmiersprache Java realisiert und erwiesen sich im Zuge
der Evaluierung als performant und stabil. Eclipse verwendet als einzige IDE mit
SWT ein alternatives WidgetSet gegenüber Swing, das von den restlichen Produkten
eingesetzt wird.
Bei der Bewertung in Kapitel 4 sowie vom Umfang der jeweiligen IDEFunktionalitäten konnte zwischen kommerziellen und freien (Open Source) Produkten praktisch nicht unterschieden werden. Es ist jedoch zu sagen, dass mit den Firmen IBM (Eclipse) und Sun Microsystems (NetBeans) große Unternehmen die Produkte unterstützen.
In den Bewertungskriterien Editor, Programmierung, Softwarequalitätssicherung,
Erweiterbarkeit der Entwicklungsumgebung, Hilfe und Support verfügen alle Pro-
134
dukte über die notwendigen Fähigkeiten, um damit produktiv arbeiten zu können.
Einzig im Bereich Modellierung haben sämtliche Entwicklungsumgebungen noch
Verbesserungsbedarf. UML2-Modellierungstechniken werden lediglich von NetBeans adäquat unterstützt. Doch auch hier fehlen wichtige Features, wie beispielsweise die Möglichkeit, die erstellten Modelle im XMI-Format zu exportieren, um
nicht an ein Werkzeug gebunden zu sein. Ansätze für modellgetriebene Entwicklungstechniken sind derzeit nur in Eclipse zu finden.
Die IDEs werden sich in den nächsten Jahren aber sicher auch bei der Modellierung
verbessern. Wenn man typische Entwicklungsumgebungen, wie sie vor circa fünfzehn Jahren üblich waren (siehe dazu Abbildung 5.1), mit denen, in dieser Arbeit
vorgestellten, vergleicht, erkennt man den Unterschied.
Abbildung 5.1: Entwicklungsumgebung Borland C++ 3.1 (1991)
Ähnlich könnte es mit den Modellierungsfähigkeiten heutiger IDEs im Vergleich zu
zukünftigen Werkzeugen aussehen.
Ein Trend ist auch bei Erweiterungen für Entwicklungsumgebungen zu erkennen.
Jedes Produkt bietet ein leistungsfähiges Plugin-Konzept, um eventuell spezielle
Funktionalitäten von Drittherstellern nachrüsten zu können. Diese Vorgehensweise
ist durchaus zu verstehen, da die Umgebungen inzwischen derart umfangreich und
komplex sind, dass es zukünftig für einen Hersteller fast unmöglich sein wird, für
135
alle Funktionen Ressourcen bereitzustellen.
Die Firma Borland hat sich beispielsweise von ihrer Plattform, welche sie für JBuilder 2006 noch verwendete, getrennt. Die Nachfolgeversion 2007 setzt auf die Eclipse Plattform auf und besteht im Grunde nur aus einer Reihe von Plugins.
In Zukunft könnte es Standard sein, dass sich Entwickler ihre Entwicklungsumgebungen, je nach ihren persönlicher Bedürfnissen, selbst zusammenstellen.
Abkürzungsverzeichnis
AJAX
Asynchronous JavaScript and XML
ALM
Application Lifecycle Management
API
Application Programming Interface
ASP
Active Server Pages
AWT
Abstract Windowing Toolkit
BIRT
Business Intelligence and Reporting Tools
CDC
Connection Device Configuration
CLDC
Connection Limited Device Configuration
CDT
Eclipse C/C++ Development Tooling
CHM
Compiled HTML Help
CSS
Cascading Style Sheets
CSV
Comma Separated Values
CVS
Concurrent Versions System
DTD
Document Type Definition
DTP
Data Tools Platform
DSL
Domain Specific Language
EJB
Enterprise JavaBeans
EMF
Eclipse Modelling Framework
FAQ
Frequently Asked Questions
GDB
GNU Debugger
GEF
Graphical Editor Framework
GMF
Graphical Modelling Framework
GMT
Generative Modeling Technologies
GNU
GNU’s Not Unix
GoF
Gang of Four
GUI
Graphical User Interface
GWT
Google Web Toolkit
HTML
Hypertext Markup Language
IDE
Integrated Development Environment
IIOP
Internet Inter-ORB Protocol
ITN
IntelliJ Technology Network
J2EE
Java 2 Platform, Enterprise Edition
J2ME
Java 2 Platform, Mobile Edition
J2SE
Java 2 Platform, Standard Edition
JAD
Java Application Descriptor
JAR
Java Archive
JAXP
Java API for XML Processing
JDT
Eclipse Java Development Tools
JDBC
Java Database Connectivity
JMS
Java Message Service
JNDI
Java Naming and Directory Interface
137
JSF
JavaServer Faces
JSP
JavaServer Pages
JST
J2EE Standard Tools
JSTL
JavaServer Pages Standard Tag Library
JTA
Java Transaction API
kB
Kilobyte
MDA
MDSD
Model Driven Software Development
MIDP
Mobile Information Device Profile
MOM
Message Oriented Middleware
MVC
Model View Controller
oAW
openArchitectureWare
OCL
Object Constraint Language
ODA
Open Data Access
OMG
Object Management Group
ORB
Object Request Broker
OTI
Object Technologies International
OS
Operating System
PDA
Personal Digital Assistant
PDE
Plugin Development Environment
PDF
Portable Document Format
PHP
Hypertext Preprocessor
PSE
Pattern Support for Eclipse
138
RCP
Rich Client Platform
RM
Requirement Management
RMI
Remote Method Invocation
RTF
Rich Text Format
SDK
Software Development Kit
SOA
Service Oriented Architecture
SQL
Structured Query Language
SVG
Scaleable Vector Graphics
SWT
Standard Widget Toolkit
TPTP
Test and Performance Tools Platform
UDDI
Universal Description, Discovery and Integration
UI
User Interface
UML
Unified Modelling Language
URL
Uniform Resource Locator
VCS
Version Control System
VE
Visual Editor
VM
Virtual Machine
W3C
World Wide Web Consortium
WSDL
Web Service Definition Language
WST
Web Standard Tools
WTK
Wireless Toolkit
WTP
Web Tools Platform
WYSIWYG What You See Is What You Get
139
XHTML
Extensible Hypertext Markup Language
XMI
XML Metadata Interchange
XML
Extensible Markup Language
XSL
Extensible Stylesheet Language
XSLT
XSL Transformation
140
Literaturverzeichnis
Druckwerke:
[And04]
Andreas Andresen: Komponentenbasierte Softwareentwicklung, 2. Auflage, Carl Hanser Verlag, München, Wien, 2004
[AR04]
Stefan Matthias Aust, Michael Rusitska: Die zweite Sonnenfinsternis,
Javamagazin 11/2002
[AT06]
Daniel Adelhardt, Jens Trapp: Die NetBeans-Erweiterungspakete im Überblick, Javamagazin 11/2006
[BC06]
Tim Boudreau und Jan Chalupa im Interview, Javamagazin 9/2006
[Blo06]
Joshua Bloch: Effective Java Programming Language Guide, 12. Auflage, Addison-Wesley, 2006
[BWB+06] Kai Brüssau, Oliver Widder, Herbert Brücker, Martin Lippert, Matthias
Lübken, Birgit Schwartz-Reinken, Lars Wunderlich: Eclipse – Die Plattform, 2. Auflage, entwickler.press, 2006
[BZ05]
Java IDE survey, BZ Research, Software Development Times 2/2006
[Car05]
David Carlson: Eclipse Distilled, 1. Auflage, Addison-Wesley, 2005
[Cub05]
Ulrich Cuber: Einführung in Eclipse 3, 1. Auflage, Galileo Computing,
2005
[DA06]
Daniel Adelhardt: Mit Milch und Zucker – Enterprise-Java-Entwicklung
mit NetBeans, Javamagazin 9/2006
[EM05]
Jochen Krause: Gut Ding will Weile haben – Ziele, Vision und Status des
Eclipse Web Tools Project, Eclipse Magazin 2/2005
[FSB06]
Duane K. Fields, Stephen Saunders, Eugene Belyaev: IntelliJ IDEA in
Action, Manning Publications, 2006
[Fow05]
Martin Fowler: Refactoring oder wie Sie das Design vorhandener Software verbessern, 1. Auflage, Addison-Wesley München, 2005
[GoF96]
E. Gamma, R. Helm, R. Johnson, J. Vlissides: Elemente wiederverwendbarer objektorientierter Software, Addison Wesley Verlag, 1996
[GoF99]
J. Vlissides: Entwurfsmuster anwenden. Die Fortsetzung des Klassikers
der Gang of Four, 1. Auflage, Addison Wesley Verlag, 1999
[Kapp03a] G. Kappel, M. Hitz: UML@Work, Von der Analyse zur Realisierung, 2.
Auflage, dpunkt.verlag, 2003
142
[Kapp03b] G.Kappel: Web Engineering. Systematische Entwicklung von Webanwendungen, dpunkt.verlag, 2003
[KCC+06] Patrick Keegan, Ludovic Champenois, Gregory Crawley, Charlie Hunt,
Christopher Webster: NetBeans IDE Field Guide – Developing Desktop,
Web, Enterprise, and Mobile Applications, Prentice Hall Verlag, 2006
[Kent03]
Kent Beck: Extreme Programming, Neuauflage, Addison-Wesley München, 2003
[NM06a] Fernando Lozano: Open-Source UML Modeling, NetBeans Magazine
2/2006
[RGN03] Mike Rozlog, Geoffrey Goetz, Sung Nguyen: Mastering JBuilder, Wiley
Publishing, 2003
[Sko07]
Florian Skopik: Moderne Softwareentwicklungsumgebungen – Evaluierung C++/C#-basierter Ansätze, Magisterarbeit, Business Informatics
Group, TU Wien, 2007
[StVö05] Thomas Stahl, Markus Völter: Modellgetriebene Softwareentwicklung,
1. Auflage, dpunkt.verlag, Heidelberg, 2005
[Trap06]
Jens Trapp: Frisch aufgebrührt – Netbeans, Überblick über die Entwicklungsumgebung und Plattform, Javamagazin 09/2006
[Wes02]
Ivo Wessel: GUI-Design, 2. Auflage, Carl Hanser Verlag, 2002
[ZBGK01] W.Zuser, S.Biffl, T.Grechenig, M.Köhle: Software Engineering mit
UML und dem Unified Process, 1. Auflage, Pearson Studium, München,
2001
Weblinks:
[AM06]
Applied Models
http://www.appliedmodels.com (27.11.2006)
[Ant06]
Apache Ant
http://ant.apache.org/ (14.11.2006)
[Apa06a] Apache Commons Codec
http://jakarta.apache.org/commons/codec/ (29.10.2006)
[Apa06b] Apache Commons Logging
http://jakarta.apache.org/commons/logging/ (29.10.2006)
[Apa06c] Apache Struts Framework
http://struts.apache.org (2.12.2006)
[Apa06d] Apache Tomcat
http://tomcat.apache.org/ (9.12.2006)
[Apa06e] Apache Cactus
http://jakarta.apache.org/cactus (20.12.2006)
[Apa06f]
143
Apache Axis
http://ws.apache.org/axis (20.12.2006)
[Apa06g] Apache Cocoon
http://cocoon.apache.org (26.1.2007)
[Apa06h] Apache Xalan (Java Version)
http://xml.apache.org/xalan-j/ (26.1.2007)
[Apa06i]
Apache Batik SVG Toolkit
http://xmlgraphics.apache.org/batik/ (29.10.2006)
[Apa06j]
Apache Derby
http://db.apache.org/derby/ (29.10.2006)
[Bor06a]
Application-Lifecylce-Lösungen von Borland
http://www.borland.com/de/products/alm/index.html (28.11.2006)
[Bor06b]
JBuilder OpenTools
http://info.borland.com/jbuilder/resources/jbopentools.html (30.12.2006)
[Bor06c]
Borland announces CodeGear
http://bdn.borland.com/article/33819 (10.10.2006)
[Bor06d]
Borland announces plan to divest IDE product lines
http://www.borland.com/us/company/news/press_releases/2006/02_08_0
6_borland_acquires_segue_software.html (10.10.2006)
[Bor06e]
Borland C++ Builder
http://www.borland.com/de/products/cbuilder/index.html (03.01.2007)
[Bor06f]
Borland announces JBuilder Product Roadmap
http://www.borland.com/us/company/news/press_releases/2005/05_31_0
5_borland_announces_jbuilder_product_roadmap.html (03.01.2007)
[Bor06g]
Borland Together – Model Driven Architecture & Visual Modeling Application
http://www.borland.com/de/products/together/index.html (30.12.2006)
[Bor06h]
Borland VisiBroker ORB
http://www.borland.com/us/products/visibroker/index.html (28.12.2006)
[Bor06i]
Borland CaliberRM
http://www.borland.com/de/products/caliber/index.html (28.12.2006)
[Bor06j]
Borland CodeCentral
http://cc.codegear.com/Default.aspx (28.12.2006)
[Bor06k]
Borland Developer Network
http://bdn.borland.com (30.12.2006)
[Bor06l]
Borland Support Angebote
http://www.borland.com/de/services/support/offerings.html (30.12.2006)
[Bor06m] Borland StarTeam
http://www.borland.com/us/products/starteam/index.html (30.12.2006)
[Bor06n]
Präsentation: JBuilder 2006 Peer to Peer Collaboration
http://bdntv.borland.com/jbuilder/2006/jb2006_p2p.html (28.12.2006)
[Cas06]
The Castor Project
http://www.castor.org (20.12.2006)
[CkS06]
CheckStyle Audit Software
http://checkstyle.sourceforge.net/ (14.11.2006)
144
[COR06] CORBA 3.0
http://www.omg.org/technology/documents/formal/corba_2.htm
(14.11.2006)
[Cov06]
Coverlipse
http://coverlipse.sourceforge.net/ (12.11.2006)
[Clov06]
Clover
http://www.cenqua.com/clover/ (12.11.2006)
[CVS06]
Concurrent Versions System (CVS)
http://www.nongnu.org/cvs/ (10.11.2006)
[DB06]
DocBook
http://www.docbook.org (11.1.2007)
[DBH06] IntelliJ IDEA Plugin - DBHelper
http://ca.geocities.com/davidhuo2003/dbhelper.html (3.1.2007)
[EA06]
Enterprise Architect – UML Design Tools
http://www.sparxsystems.com/ea.htm (14.11.2006)
[Ecl06a]
Eclipse Platform Technical Overview
http://www.eclipse.org/whitepapers/eclipse-overview.pdf (22.09.2006)
[Ecl06b]
Feature Request: Enable Eclipse to be used as a rich client platform
https://bugs.eclipse.org/bugs/show_bug.cgi?id=36967 (22.09.2006)
[Ecl06c]
Standard Widget Toolkit (SWT)
http://www.eclipse.org/swt/ (22.09.2006)
[Ecl06d]
Eclipse Callisto
http://www.eclipse.org/callisto/ (4.10.2006)
[Ecl06e]
C/C++ Development Tooling (CDT)
http://www.eclipse.org/cdt/ (4.10.2006)
[Ecl06f]
Web Tools Platform (WTP)
http://www.eclipse.org/webtools/ (4.10.2006)
[Ecl06g]
Visual Editor Project (VE)
http://www.eclipse.org/vep/ (4.10.2006)
[Ecl06h]
Data Tools Platform (DTP)
http://www.eclipse.org/datatools/ (4.10.2006)
[Ecl06i]
Graphical Editor Framework (GEF)
http://www.eclipse.org/gef/ (4.10.2006)
[Ecl06j]
Business Intelligence and Reporting Tools (BIRT)
http://www.eclipse.org/birt/phoenix/ (4.10.2006)
[Ecl06k]
Eclipse Language Pack Download
http://download.eclipse.org/eclipse/downloads/drops/L3.2_Language_Packs-200607121700/index.php (9.10.2006)
[Ecl06l]
Eclipse Modeling Framework (EMF)
http://www.eclipse.org/emf/ (11.10.2006)
145
[Ecl06m] Eclipse Application Lifecycle Framework
http://www.eclipse.org/alf (16.11.2006)
[Ecl06n]
ALF Architecture Design Draft
http://www.eclipse.org/alf/includes/ALFArchitectureDraft-v00-07.pdf
(16.11.2006)
[Ecl06o]
Eclipse Community Page
http://www.eclipse.org/community (16.11.2006)
[Ecl06p]
Eclipse Modeling Framework (EMF)
http://www.eclipse.org/emf/ (16.10.2006)
[Ecl06q]
Graphical Modeling Framework (GMF)
http://www.eclipse.org/gmf/ (16.10.2006)
[Ecl06r]
Test and Performance Tools Platform
http://www.eclipse.org/tptp/ (16.10.2006)
[Ecl06s]
Eclipse profiling example
http://www.eclipse.org/tptp/home/documents/tutorials/profilingtool/profi
lingexample_32.html (12.11.2006)
[ECo06]
Eclipse CORBA Plugin
http://sourceforge.net/projects/eclipsecorba/ (14.11.2006)
[EJB06]
Enterprise JavaBeans Technology
http://java.sun.com/products/ejb/ (14.11.2006)
[EM06]
EMMA: a free Java code coverage tool
http://emma.sourceforge.net/ (6.1.2006)
[EMe06]
Eclipse Metrics Plugin
http://sourceforge.net/projects/metrics (14.11.2006)
[EME06] EclipseME
http://eclipseme.org/ (14.11.2006)
[EPC06]
Eclipse Plugin Central
http://www.eclipseplugincentral.com (16.11.2006)
[FB06]
FindBugs – Find Bugs in Java Programs
http://findbugs.sourceforge.net/ (14.11.2006)
[For06]
Fortune 500: Ranking of the top 500 American public corporations
http://www.fortune.com/fortune/fortune500 (3.1.2007)
[GDB06] GDB: The GNU Project Debugger
http://www.gnu.org/software/gdb/ (9.12.2006)
[Goo06]
Google Web Toolkit
http://code.google.com/webtoolkit/ (3.1.2007)
[Gro06a]
146
Groovy - An agile dynamic language for the Java Platform
http://groovy.codehaus.org/ (3.1.2007)
[Gro06b] GroovyJ - Groovy Integration into JetBrains’ IntelliJ IDEA
http://groovy.codehaus.org/IntelliJ+IDEA+Plugin (3.1.2007)
[Hib06]
Hibernate Persistence Framework
http://www.hibernate.org/ (14.11.2006)
[HM06]
Henry Matisse - Biografie
http://www.whoswho.de/templ/te_bio.php?PID=871&RID=1
(9.12.2006)
[HttpU06] HttpUnit
http://httpunit.sourceforge.net (26.1.2007)
[IBM06a] Eclipse’s Rich Client Platform
https://www6.software.ibm.com/developerworks/education/osrcp1/index.html (22.09.2006)
[IBM06b] Java Compiler Jikes
http://www.alphaworks.ibm.com/formula/Jikes (20.12.2006)
[IBM06c] Rational ClearCase
http://www-306.ibm.com/software/awdtools/clearcase/ (30.12.2006)
[IME06]
IntelliJ IDEA Plugin – IntelliME J2ME
http://sourceforge.net/projects/intellime (3.1.2007)
[INNO06] Innoopract Eclipse Solutions
http://www.innoopract.com (1.11.2006)
[Ins06]
WindowBuilder (SWT and Swing Development for Eclipse), Instantiations
http://www.instantiations.com/windowbuilderpro/default.htm
(9.10.2006)
[iText06] iText Java-PDF Library
http://www.lowagie.com/iText/ (29.10.2006)
[J2EE06] Java 2 Enterprise Edition (J2EE)
http://java.sun.com/javaee/ (14.11.2006)
[J2ME06] Java 2 Platform, Micro Edition
http://java.sun.com/javame/index.jsp (14.11.2006)
[J2SE06] Java 2 Standard Edition
http://java.sun.com/javase/ (14.11.2006)
[JAB06]
Jabber - Open Instant Messaging
http://www.jabber.org (31.12.2006)
[JAPI06a] Java Logging Framework, Java 1.5 API
http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/packagesummary.html (29.10.2006)
[JRPC06] Java API for XML-Based RPC (JAX-RPC)
http://java.sun.com/webservices/jaxrpc/ (9.12.2006)
[JaD06]
Javadoc Tool Home Page
http://java.sun.com/j2se/javadoc/ (14.11.2006)
[JCP06]
The Java Community Process
http://jcp.org (14.11.2006)
147
[JDBC06] Java Database Connectivity
http://java.sun.com/javase/technologies/database/index.jsp (14.11.2006)
[JetB06a] JetBrains Company History and Timeline
http://www.jetbrains.com/company/history.html (2.1.2007)
[JetB06b] Localizing (translating to national languages) IntelliJ IDEA
http://www.jetbrains.net/confluence/display/IDEADEV/Localization+Gu
ide (2.1.2007)
[JetB06c] JetBrains Corporate Overview
http://www.jetbrains.com/company/CorpOverview.pdf (3.1.2007)
[JetB06d] IntelliJ IDEA - EJB Features
http://www.jetbrains.com/idea/features/java_ejb.html (3.1.2007)
[JetB06e] IntelliJ IDEA - Application Servers Integration
http://www.jetbrains.com/idea/features/application_server.html
(4.1.2007)
[JetB06f] IntelliJ IDEA – JSP Editor
http://www.jetbrains.com/idea/features/jsp_editor.html (5.1.2007)
[JetB06g] IntelliJ IDEA - Struts
http://www.jetbrains.com/idea/features/jakarta_struts.html (5.1.2007)
[JetB06h] IntelliJ IDEA – Plugin Repository
http://plugins.intellij.net (11.1.2007)
[JetB06i] IntelliJ IDEA - Collaboration features
http://www.jetbrains.com/idea/features/collaboration.html (11.1.2007)
[JetB06j] IntelliJ IDEA – Running and Debugging
http://www.jetbrains.com/idea/features/compiler.html#Running_and_De
bugging (11.1.2007)
[JetB06k] IntelliJ IDEA - Developers Documentation
http://www.jetbrains.com/idea/documentation/documentation.html
(11.1.2007)
[JetB06l] IntelliJ IDEA - How to Get Started with IntelliJ IDEA (Videos)
http://www.jetbrains.com/idea/training/how_to_start.html (11.1.2007)
[JetB06m] IntelliJ IDEA – Support Forum
http://www.intellij.net/forums/ (11.1.2007)
[JetB06n] IntelliJ IDEA - Commercial License
http://www.jetbrains.com/idea/buy/buy.html (11.1.2007)
[JetB06o] IntelliJ IDEA – IntelliJ Technology Network ITN
http://www.intellij.net (11.1.2007)
148
[JetB06p] JetBrains TeamCity
http://www.jetbrains.com/teamcity/ (11.1.2007)
[Jgo06]
FormLayout for Java, JGoodies.com
http://www.jgoodies.com/freeware/forms/index.html (8.10.2006)
[JInto06]
JInto Eclipse Plugin
http://www.guh-software.de/jinto.html (14.11.2006)
[JMEU06] J2MEUnit – A J2ME Unit Testing Framework
http://j2meunit.sourceforge.net/ (9.12.2006)
[JMS06]
Java Message Service (JMS)
http://java.sun.com/products/jms/ (14.11.2006)
[JNDI06] Java Naming and Directory Interface (JNDI)
http://java.sun.com/products/jndi/ (14.11.2006)
[JPro06]
ej-technologies JProfiler
http://www.ej-technologies.com/products/jprofiler/overview.html
(6.1.2007)
[JSF06]
JavaServer Faces Technology
http://java.sun.com/javaee/javaserverfaces/ (2.12.2006)
[JSP06]
JavaServer Pages Technology
http://java.sun.com/products/jsp/ (14.11.2006)
[JSTL06] JavaServer Pages Standard Tag Library
http://java.sun.com/products/jsp/jstl/ (2.12.2006)
[JTA06]
Java Transaction API
http://java.sun.com/products/jta/ (14.11.2006)
[JUnit06] JUnit – Test Framework
http://www.junit.org (3.1.2007)
[JVMTI06] JVM Tool Interface (JVM TI)
http://java.sun.com/j2se/1.5.0/docs/guide/jvmti/index.html (9.12.2006)
[JWS06]
Java Web Services
http://java.sun.com/webservices/ (14.11.2006)
[JWTK06] J2ME Wireless Toolkit (WTK)
http://java.sun.com/products/sjwtoolkit/ (14.11.2006)
[L4J06]
Apache Log4j project
http://logging.apache.org/log4j/ (29.10.2006)
[MD06]
MagicDraw UML
http://www.magicdraw.com/ (14.11.2006)
[MIDP06] Mobile Information Device Profile
http://java.sun.com/products/midp/ (14.11.2006)
[MK06]
Accelerate. The Application Lifecycle
http://caparea.com/LinkClick.aspx?link=BorlandPresentation.ppt&tabid=
60&mid=378 (28.12.2006)
[MR06]
IntelliJ IDEA Plugin MetricsReloaded
http://www.sixthandredriver.com/metricsreloaded.html (7.1.2006)
[MS06a]
Offizielle User Interface Guidelines für Windows-Anwendungen
http://msdn.microsoft.com/ui (31.08.2006)
149
[MSDK06] Motorola SDK for J2ME
http://developer.motorola.com (14.11.2006)
[NB06a]
A Brief History of NetBeans
http://www.netbeans.org/about/history.html (9.10.2006)
[NB06b]
VM Options for Debugging
http://debuggercore.netbeans.org/docs/VM-options.html (5.12.2006)
[NB06c]
NetBeans Enterprise Pack
http://www.netbeans.org/products/enterprise/ (9.12.2006)
[NB06d]
NetBeans Mobility Pack
http://www.netbeans.org/products/mobility/ (9.12.2006)
[NB06e]
NetBeans Profiler
http://www.netbeans.org/products/profiler/ (9.12.2006)
[NB06f]
NetBeans Visual Web Pack
http://www.netbeans.org/products/visualweb/ (9.12.2006)
[NB06g]
NetBeanc C/C++ Development Pack
http://www.netbeans.org/products/cplusplus/ (9.12.2006)
[NB06h]
NetBeans JUnit Module
http://junit.netbeans.org/ (9.12.2006)
[NB06i]
NetBeans Metrics Module
http://metrics.netbeans.org/ (9.12.2006)
[NB06j]
NetBeans Plugin Catalogue
http://www.netbeans.org/catalogue/index.html (9.12.2006)
[NB06k]
NetBeans Community
http://www.netbeans.org/community/ (9.12.2006)
[NB06l]
NetBeans Support Resources
http://www.netbeans.org/community/ (9.12.2006)
[NB06m] NetBeans Subversion Integration
http://subversion.netbeans.org/ (9.12.2006)
[NBCS06] NetBeans CheckStyle Plugin
http://nbcheckstyle.sourceforge.net/ (9.12.2006)
[NSDK06] Nokia Developer Suite for J2ME
http://www.forum.nokia.com/main/resources/tools_and_sdks/tools_for_
mobile_java_developers.html (14.11.2006)
[NUnit06] NUnit Homepage – Komponententests für .NET
http://sourceforge.net/projects/nunit (31.08.2006)
150
[Omo06a] Omondo – The Live UML Company
http://www.omondo.de (11.10.2006)
[OSt06]
ORB Studio
http://www.orbzone.org/?p=125 (14.11.2006)
[OW06]
IONA Orbix
http://www.iona.com/products/orbix (28.12.2006)
[Pat06]
PatternBox – Entwurfsmuster Plugin für Eclipse
http://www.patternbox.com/ (14.11.2006)
[PeE06]
Eclipse Perl Integration
http://e-p-i-c.sourceforge.net/ (11.10.2006)
[PhE06]
PHPEclipse
http://www.phpeclipse.de (11.10.2006)
[PMD06] PMD
http://pmd.sourceforge.net/ (14.11.2006)
[ProG06] ProGuard Java Bytecode Obfuscator
http://proguard.sourceforge.net/ (14.11.2006)
[PSE06]
Pattern Support for Eclipse (PSE)
http://www.swe.uni-linz.ac.at/people/sametinger/research/pse.html
(14.11.2006)
[Pos06]
Poseidon for UML
http://www.gentleware.com/ (14.11.2006)
[PyE06]
PyDEV Python Development Environment
http://pydev.sourceforge.net/ (11.10.2006)
[RetG06] RetroGuard Java Bytecode Obfuscator
http://www.retrologic.com/ (14.11.2006)
[Rhino06] Rhino – JavaScript for Java
http://www.mozilla.org/rhino/ (29.10.2006)
[Rose06]
Rational Rose
http://www-306.ibm.com/software/awdtools/developer/rose/
(14.11.2006)
[SCC06]
Code Conventions for the Java Programming Language
http://java.sun.com/docs/codeconv/ (14.11.2006)
[SE06]
Sony Ericssons CDC Platform
http://developer.sonyericsson.com/site/global/docstools/symbian/p_symb
ian.jsp
[Serv06]
Java Servlet Technology
http://java.sun.com/products/servlet/ (14.11.2006)
[SL06]
Swing Layout Extensions
https://swing-layout.dev.java.net/ (2.12.2006)
[Struts06] Struts Framework
http://struts.apache.org/ (14.11.2006)
151
[SubV06] Subversion VCS System
http://subversion.tigris.org/ (9.12.2006)
[SUML06] IntelliJ IDEA Plugin - SimpleUML
http://www.intellij.org/twiki/bin/view/Main/SimpleUML (4.1.2007)
[Sun06a]
Abstract Windowing Toolkit AWT
http://java.sun.com/j2se/1.5.0/docs/guide/awt/ (23.09.2006)
[Sun06b] Without a Layout Manager (Absolute Positioning)
http://java.sun.com/docs/books/tutorial/uiswing/layout/none.html
(8.10.2006)
[Sun06c]
BorderLayout, Java 5 SE API Documentation
http://java.sun.com/j2se/1.5.0/docs/api/java/awt/BorderLayout.html
(8.10.2006)
[Sun06d] GridBagLayout, Java 5 SE API Documentation
http://java.sun.com/j2se/1.5.0/docs/api/java/awt/GridBagLayout.html
(8.10.2006)
[Sun06f]
GroupLayout, Java 6 SE Beta API Documentation
http://java.sun.com/javase/6/docs/api/javax/swing/GroupLayout.html
(8.10.2006)
[Sun06g] JavaBeans http://java.sun.com/products/javabeans/ (8.10.2006)
[Sun06h] Java Foundation Classes (JFC/Swing)
http://java.sun.com/products/jfc/ (8.10.2006)
[Sun06i]
JavaMail API
http://java.sun.com/products/javamail/ (20.12.2006)
[Sun06j]
Pluggable Look and Feel
http://java.sun.com/docs/books/tutorial/ui/features/plaf.html (3.1.2007)
[Sun06k] Java Platform Debugger Architecture (JPDA)
http://java.sun.com/products/jpda/ (11.1.2006)
[Sun06l]
JavaHelp System
http://java.sun.com/products/javahelp/ (11.1.2007)
[Sun06m] Building Compelling Services for the Wireless Market Using Java Technology
http://developers.sun.com/techtopics/mobility/getstart/articles/whyjava/
(18.1.2007)
[Sun06n] Ein Jahrzehnt der Zusammenarbeit
http://de.sun.com/homepage/feature/2005/javaone/learn_more.html
(24.1.2006)
[Sun06o] Lernen über Java-Technologie
http://www.java.com/de/about/ (24.1.2006)
[SVG06]
Scaleable Vector Graphics (SVG) 1.1 Specification
http://www.w3.org/TR/SVG/ (29.10.2006)
[UIQ06]
UIQ Platform
http://www.uiq.com/uiqplatform.html (9.12.2006)
[Völ06a]
Markus Völter: openArchitectureWare 4
http://www.eclipse.org/gmt/oaw/oAWFactSheet.pdf (13.08.2006)
[Völ06b]
Markus Völter: openArchitectureWare und Eclipse
http://www.voelter.de/data/articles/oaweclipse.pdf (14.11.2006)
[VP06]
Visual Paradigm SDE for IntelliJ IDEA
http://www.visual-paradigm.com/product/sde/ij/ (4.1.2007)
[VSS06]
MicroSoft Visual SourceSafe
http://msdn.microsoft.com/ssafe (30.12.2006)
152
[W3C06a] W3C XML Schema
http://www.w3.org/XML/Schema (20.12.2006)
[Wiki06a] Begriffserklärung: Gang of Four (GoF)
http://de.wikipedia.org/wiki/Viererbande_%28Softwareentwicklung%29
(31.08.2006)
[WinF06] Windows Forms .NET
http://www.windowsforms.net (9.12.2006)
[WOP06] WebOfPatterns – Entwurfsmuster Plugin für Eclipse
http://www-ist.massey.ac.nz/wop/ (14.11.2006)
[Xerces06] Apache Xerces
http://xerces.apache.org/ (29.10.2006)
[YOX06] Yoxos On Demand
http://yoxos.com/ondemand (16.11.2006)

paper - Business Informatics Group

Transcrição

Documentos relacionados

Praktikum Algorithmen-Entwurf Vier Gewinnt

Referenz: Generic Java Ontology API Thema: Eclipse Plug

MTD 2/08 072-076 Eclipse lila

Kurzanleitung Eclipse

und Installation Java

Inhaltsverzeichnis des Buches "Java für Windows"

JAVA – Installation und Einrichtung des Java

Eclipse Version Kepler - Benutzer-Homepage

Kurzprofil - Patrick Nehls Homepage

PAZIFISCHE PERLEN / PACIFIC PEARLS - Eclipse