Einsatz und Nutzung Integrierter Software- Entwicklungsumgebungen (IDEs)

Einsatz und Nutzung Integrierter Software- Entwicklungsumgebungen (IDEs) Autoren: Ronald Melster Marco Mosconi Carsten Pfeiffer Jan Wloka Wolfgang Zimmer Report: ViSEK/038/D Version 1.0 28.10.2003 Klassifikation: öffentlich

Zusammenfassung Die Studie Einsatz und Nutzung integrierter Software- Entwicklungsumgebungen des Fraunhoferinstitutes für Rechnerarchitektur und Softwaretechnik (FIRST) gibt ein umfassendes Bild von Nutzungskonzepten, Features und Anwendungsbereichen der auf dem Markt verfügbaren IDEs. Erweitert wird dieses Bild durch eine Befragung unterschiedlicher Software produzierender Unternehmen mit dem Ziel, den potentiellen Nutzern bei der Auswahl und der Einführung einer IDE behilflich zu sein. Aufgrund der mehrjährigen Arbeit im Bereich Softwaretechnik (SWT) basiert diese Darstellung auf einem kontinuierlich gewachsenen Erfahrungsschatz. Die seitens der Autoren angeführten Werkzeuge stellen lediglich eine Teilmenge der im Entwicklungsprozess anwendbaren Werkzeuge dar und erheben keinen Anspruch auf Ausschließlichkeit. Schlagworte: Integrierte Entwicklungsumgebung (IDE), Konzepte und Features von IDEs, Einsatz- und Nutzungsbereiche von IDEs, Produktivitäts- und Qualitätssteigende Faktoren Das diesem Bericht zugrundeliegende Vorhaben wurde mit Mitteln des Bundesministeriums für Bildung und Forschung unter dem Förderkennzeichen 01 IS A02 gefördert. Die Verantwortung für den Inhalt dieser Veröffentlichung liegt beim Autor. Copyright Fraunhofer FIRST 2003 iii

Inhaltsverzeichnis 1 Einleitung 1 2 Konzepte und Features 3 2.1 Allgemeine Eigenschaften von IDEs 5 2.2 Kernfunktionalitäten 6 2.2.1 Editor 6 2.2.2 Navigation 7 2.2.3 Übersetzen / Compiler 7 2.2.4 Build-Prozess 8 2.2.5 Debugging 9 2.3 Erweiterte Funktionalitäten 10 2.3.1 Konfigurationsmanagement 10 2.3.2 Codegenerierung 11 2.3.3 Testen 12 2.3.4 Refactoring 12 2.3.5 Modellierung/Design (UML) 13 2.3.6 Datenbanken 15 2.3.7 Deployment/Laufzeitumgebung/Server 15 2.3.8 GUI-Designer 16 2.3.9 Internationalisierung 16 2.3.10 Hilfe-System 16 2.3.11 Utilities 17 3 Marktübersicht 19 3.1 Borland C++Builder 6.0 19 3.2 Borland Kylix 3 20 3.3 Borland JBuilder 9.0 21 3.4 Borland Delphi 7.0 22 3.5 Borland Together ControlCenter 6.1 23 3.6 Eclipse 2.x 23 3.7 IBM WebSphere Studio Application Developer 5.1 24 3.8 IBM Rational XDE Developer 25 3.9 JetBrains IntelliJ IDEA 3.0 25 3.10 Interactive Objects Software: ArcStyler 3.1 26 3.11 KDevelop 2.1/3.1 27 3.12 Microsoft Visual Studio.NET 29 3.13 NetBeans 3.5 29 3.14 Sun ONE Studio 5 30 4 Quantitative Ergebnisse der Umfrage 32 4.1 Vorgehensweise 32 Copyright Fraunhofer FIRST 2003 v

4.1.1 Beschreibung des Fragebogens 33 4.2 Untersuchung 35 4.2.1 Unternehmensdaten 35 4.2.2 Umgebung und Verwendung der untersuchten IDEs 37 4.2.3 Allgemeine Eigenschaften 42 4.2.4 Kernfunktionalitäten 45 4.2.5 Erweiterte Funktionalitäten 49 4.2.6 Gesamteindruck 55 5 Einschätzung des Marktes 56 5.1 Ein Markt im technologischen Umbruch 56 5.1.1 Die bewährten Alleskönner 58 5.1.2 Jüngste Entwicklungen 60 5.2 Anwendungsbeispiele 61 5.2.1 Kleine Unternehmen 62 5.2.2 Mittelgroße Unternehmen 62 5.2.3 Großunternehmen 63 5.2.4 Produkttypen 63 5.3 Typische Entscheidungsszenarien 64 5.3.1 Einstieg 65 5.3.2 Umstieg 66 5.3.3 Upgrade 67 5.4 Ausblick die IDE für Model-Driven Architecture (MDA) 68 vi Copyright Fraunhofer FIRST 2003

Einleitung 1 Einleitung In der Informationstechnologie wird der Lebenszyklus neuer Produkte immer kürzer. Auch die Kunden und Auftraggeber von Softwareentwicklungsprojekten erwarten, dass in immer kürzerer Zeit immer bessere Software erstellt wird. Oft ist Software noch nicht einmal fertig produziert, da muss sie bereits an veränderte Systemvoraussetzungen angepasst werden. Unter diesen Umständen wird die Fähigkeit, in kurzer Zeit qualitativ hochwertige Software zu entwickeln und sie an die variierenden Anforderungen der Kunden anzupassen ein entscheidender Erfolgsfaktor. Entwickler können nur wettbewerbsfähig bleiben, wenn ihnen dafür in allen Phasen der Softwareproduktion effektive Techniken und Werkzeug zur Verfügung stehen. Hierbei können so genannte Integrierte Softwareentwicklungsumgebungen (IDEs) helfen, die Entwickler bei ihrer täglichen Arbeit unterstützen, die Produktivität und die Qualität der entwickelten Software zu erhöhen. Das Ziel der vorliegenden Studie ist es, Konzepte und Features existierender IDEs darzustellen (Kapitel 2) und einen Überblick über den derzeitigen Markt für IDEs zu geben (Kapitel 3). Um die Einsatzbereiche, die Verbreitung und die Zufriedenheit der Entwickler mit derzeitig auf dem Markt verfügbaren IDEs zu untersuchen, wurde eine Umfrage unter Programmierern und Entwicklungsleitern durchgeführt. Die Experten wurden in einem ausführlichen Interview während der CeBIT zu ihren Anforderungen, zu den bisherigen Erfahrungen und ihrer Einschätzung der von ihnen verwendeten IDEs befragt. Die Vorgehensweise und die Ergebnisse dieser Umfrage finden sich in Kapitel 0. Im Kapitel 5 werden aktuelle Produkte auf ihre Stärken und Schwächen untersucht und die derzeitige Umbruchsituation auf dem IDE-Markt analysiert. Die Konzepte existierender IDEs und neu auf den Markt drängender Umgebungen werden gegenübergestellt und ein Ausblick auf mögliche zukünftige Entwicklungen gegeben. Weiterhin werden Anwendungsbeispiele (Kapitel 5.2) und Entscheidungsszenarien für typische Einsatzsbereiche von IDEs Copyright Fraunhofer FIRST2003 1

Einleitung dargestellt (Kapitel 5.3). Es werden Faktoren vorgestellt, die bei der Entscheidung im Rahmen eines Einstiegs in die IDE-Nutzung, beim Umstieg auf eine neue IDE bzw. beim Upgrade von einer Version auf eine aktuellere Version beachtet werden müssen. 2 Copyright Fraunhofer FIRST 2003

Konzepte und Features 2 Konzepte und Features Um in angemessener Zeit qualitativ hochwertige Software zu erstellen, bedarf es der Unterstützung durch spezialisierte Werkzeuge, die die verschiedenen Aufgaben innerhalb des Entwicklungsprozesses übernehmen. Auch wenn für die Entwicklung von Software grundsätzlich ein Editor für die Eingabe des Quellcodes sowie ein Compiler, der daraus ein ausführbares Programm erzeugt, ausreichen würden, ist dies heutzutage und in Anbetracht immer komplexerer Software-Systeme kaum noch ausreichend. Ein Texteditor allein genügt mittlerweile nicht mehr, um Anforderungen, Design, Implementierung und Testfälle zu erfassen und dem Entwickler alle dabei anfallenden Artefakte 1 übersichtlich zu präsentieren. Auch der Übersetzungsvorgang ist im Allgemeinen so komplex, dass er nicht ohne weitere Hilfswerkzeuge durchgeführt werden kann. Durch die mit der Entwicklung neuer Technologien ständig ansteigende Anzahl unterschiedlicher Werkzeuge erhöht sich der Aufwand für den Entwickler, da er mit verschiedenen Oberflächen und Konzepten konfrontiert wird. Meist muss der Entwickler manuell für Konsistenz zwischen den Daten und Werkzeugen sorgen. Die Verwendung vieler einzelner Werkzeuge erhöht den Einarbeitungsaufwand und hat negative Auswirkungen auf die Produktivität. Dieser Problematik widmen sich integrierte Entwicklungsumgebungen (Integrated Development Environment IDE), die den Entwickler bei der Erstellung von Software unterstützen, indem sie für die diversen Aufgaben im Entwicklungsprozess spezialisierte Teilwerkzeuge anbieten. IDEs fassen verschiedene, bei der Software-Entwicklung benötigte Werkzeuge unter einer einheitlichen Oberfläche zusammen 1 Artefakte sind Strukturelemente der Software und deren Aggregationen, die der Versionen unterliegen. In der Regel handelt es sich bei Artefakten um Dateien, die im Konfigurationsmanagementsystem abgelegt werden. Copyright Fraunhofer FIRST2003 3

Konzepte und Features Dabei sind die einzelnen, interoperierenden Werkzeuge in eine gemeinsame Oberfläche integriert und bieten eine einheitliche Benutzungsschnittstelle. Eine Erleichterung und Optimierung der Entwicklungsarbeit wird einerseits durch die Zusammenarbeit der einzelnen Werkzeuge erreicht: so erlaubt beispielsweise das Zusammenspiel von Editor und Compiler das direkte Anspringen der Codezeilen, die vom Compiler als fehlerhaft bemängelt werden; die Kopplung von Editor und Debugger ermöglicht das Setzen von Haltepunkten direkt im Quelltext. Weiterhin werden viele komplexe Tätigkeiten durch Automatisierung weitgehend vor dem Entwickler versteckt oder durch intelligente Benutzerführung (z.b. Wizards ) vereinfacht. Andererseits wird durch eine abstraktere und partielle Darstellung der Artefakte und ihre Zusammenfassung in der IDE die sichtbare Komplexität deutlich reduziert. Der Entwickler erhält so einen besseren Überblick über das gesamte Projekt. Zusätzliche Erleichterung bringen Navigationsmöglichkeiten zwischen den Elementen und deren Visualisierung, beispielsweise in Form von UML-Diagrammen. Zusammen mit Abfragemöglichkeiten, die weit über textuelles Suchen in Dateien hinausgehen, trägt dies zum besseren Verständnis des Projektes bei und wirkt sich produktivitätssteigernd aus. Historisch betrachtet sind IDEs aus der stetigen Weiterentwicklung und Erweiterung von Editoren hervorgegangen, die im Laufe der Zeit an Funktionalität zunahmen und immer mehr Aufgaben erledigen konnten. Zunächst gab es erweiterte Editoren, die Compiler und Linker einbinden konnten, die Werkzeuge der ersten Generation boten bereits zusätzliche Navigationsmöglichkeiten, um das Auffinden von Stellen im Quellcode zu vereinfachen. In der zweiten Generation integrierter Entwicklungsumgebungen wurden vormals externe Werkzeuge wie Debugger, Build- und Konfigurationsmanagement, sowie visuelles Entwerfen von grafischen Benutzungsschnittstellen (GUIs) aufgenommen. Aktuelle IDEs schließlich beinhalten zusätzliche Unterstützung wie z.b. konsistentes Restrukturieren von Quellcode (Refactoring) sowie die Automatisierung und Verwaltung von Testfällen. 4 Copyright Fraunhofer FIRST 2003

Konzepte und Features 2.1 Allgemeine Eigenschaften von IDEs Generell lassen sich Integrierte Entwicklungsumgebungen in allgemeine und spezialisierte IDEs unterscheiden. Spezialisierte IDEs haben i.d.r. einen bestimmten Fokus, innerhalb dessen sie die Werkzeugunterstützung besonders ausgebaut haben. So gibt es IDEs, die sich auf bestimmte Plattformen, wie z.b. PDAs mit PalmOS oder Windows CE, spezialisiert und viele ihrer Funktionalitäten gezielt darauf ausgerichtet haben. Auch sind oft IDEs zu finden, die eine begrenzte Anzahl von Zielsprachen in Verbindung mit bestimmten Anwendungstypen, wie z.b. Java, JSP, XML und HTML speziell für die Entwicklung von WebServices oder J2EE Applikationen unterstützen. Neben häufig noch deutlich stärker spezialisierten Herstellereigenen IDEs z.b. für die Entwicklung von Applikationsservern bietet auch eine Reihe von Produkten explizite Unterstützung für die Entwicklung von Komponenten, wie COM+, ActiveX oder Enterprise Java Beans. Allgemeine IDEs sind gewöhnlich offen was die Wahl der Zielapplikation bzw. der -plattform angeht, aber dennoch nicht selten auf bestimmte Programmiersprachen beschränkt. Es lässt sich aber ein Trend zur offenen IDE beobachten, bei der nahezu beliebige Erweiterungen durch Plugins nachträglich noch integriert werden können. So bietet z.b. die Eclipse Plattform eine solche offene Architektur, die auch schon von einigen Herstellern für umfangreiche Erweiterungen genutzt worden ist. Neben der Erweiterbarkeit einer IDE ist auch die Konfigurierbarkeit (bzw. Individualisierbarkeit) von Entwicklungsumgebungen ein entscheidender Faktor für den erfolgreichen Einsatz in unterschiedlichen Projekten. So fördern die Anpassbarkeit von Verhalten, Benutzeroberfläche und Code-/Diagramm- Formatierungen durch gewohnte Handhabung und Darstellung die Produktivität und können den Einarbeitungsaufwand deutlich verringern. IDEs bieten eine Vielzahl von Funktionalitäten durch die die Softwareentwicklung erleichtert und beschleunigt werden kann. Im Folgenden werden zum besseren Verständnis der anschließenden Marktübersicht sowohl die grundlegenden Kernfunktionalitäten aktueller IDEs erläutert, als auch erweiterte Funktionalitäten, mit denen sich die betrachteten Produkte voneinander abheben. Copyright Fraunhofer FIRST2003 5

Konzepte und Features 2.2 Kernfunktionalitäten Die Funktionen Editieren, Navigieren, Übersetzen und Debuggen können als Basisfeatures einer jeden IDE aufgefasst werden. Doch selbst diese Grundfunktionalitäten sind in den verschiedenen Entwicklungsumgebungen teilweise unterschiedlich ausgeprägt. In diesem Kapitel werden die zentralen Features moderner IDEs beschrieben und motiviert. 2.2.1 Editor Jeder Quelltext-Editor sollte heutzutage das Hervorheben der Syntax der jeweiligen Programmiersprache unterstützen. Da oft nicht nur Quelltext, sondern auch andere textuelle Dateien (z.b. Konfigurationsdateien oder Skripte) editiert werden müssen, sind Hervorhebungsmöglichkeiten für unterschiedliche Sprachen wünschenswert, die sowohl konfigurierbar, als auch ausreichend erweiterbar sein sollten. Der Code-Formatierer sollte sowohl während des Eingebens aktiv sein und beispielsweise den Cursor automatisch an die richtige Position setzen, als auch manuell zum Formatieren existierenden Codes aufgerufen werden können. Durch das automatisierte Formatieren von bestehendem Code kann dieser nachträglich an Firmenstandards angepasst werden, was die Lesbarkeit für die Entwickler erhöht und somit das Verständnis erleichtert. Neben der Darstellung sollte auch die automatische Formatierung von Code konfigurierbar sein. Coding Standards geben die Formatierung von Quelltext vor, z.b. die Einrückungstiefe, die Platzierung von Klammern oder die Bezeichnung von Variablen. Ein Übersicht schaffendes Feature ist das Ein- und Ausfalten von Codeblökken. Damit kann der Kontrollfluss durch Ausblenden von Blöcken auch in längeren Funktionen verfolgt werden. Oft ist es auch hilfreich, wenn mehrere Dateien oder unterschiedliche Teile einer Datei gleichzeitig angezeigt werden können das Arrangieren mehrerer Editorfenster oder das Aufteilen eines Editorfensters ermöglichen dies. Konfigurierbare Tastaturbelegungen sollten zum Standardrepertoire eines aktuellen Editors gehören. Jegliche Editierfunktion kann dabei vom Benutzer 6 Copyright Fraunhofer FIRST 2003

Konzepte und Features mit einem Tastenkürzel versehen werden, damit die Texteingabe nicht ständig mit einem Griff zur Maus unterbrochen werden muss. Weiterhin kann die Eingabe durch automatische Vervollständigung von Typen, Methodennamen, etc. und Überprüfung von Eingabefehlern optimiert werden. Dies erspart Schreibarbeit und vermeidet Tippfehler. Das mühselige Konsultieren von API-Dokumentation kann durch Annotationen im Editor erleichtert werden, indem die Dokumentation einer aufgerufenen Methode beispielsweise in einem Tooltip angezeigt wird oder wenigstens eine Option besteht, direkt zur Dokumentation zu springen. 2.2.2 Navigation IDEs arbeiten in der Regel projektbasiert und verwalten sämtliche damit verbundenen Informationen und Artefakte. Die Auswertung dieser gebündelten Informationen ermöglicht unter anderem eine intelligente Navigation zwischen den einzelnen Artefakten und ist ein großer Vorteil von IDEs gegenüber Werkzeugen, die nur Zugriff auf einzelne Dateien besitzen. Mit diesem weit reichenden Informationszugriff sind nicht nur unterschiedliche Ansichten auf die Artefakte möglich (zum Beispiel paketorientiert oder hierarchisch nach der Klassenstruktur), es sollte auch die Möglichkeit bestehen, z.b. von der Verwendung einer Methode direkt zu deren Dokumentation oder Implementierung zu springen. Ebenso sollte die umgekehrte Richtung durch Abfragen möglich sein: sämtliche Verwendungen einer Methode oder eines Attributs sollten auffindbar sein ( cross-referencing ). Insbesondere die Suchfunktion sollte sich von einer normalen textbasierten Suche abheben, indem eine typisierte Suche z.b. nach Klassen, Methoden, Attributen oder Verwendungen davon ermöglicht wird. Insbesondere bei umfangreichen Projekten kann eine Filter-Möglichkeit in den verschiedenen Ansichten die Übersichtlichkeit deutlich erhöhen. 2.2.3 Übersetzen / Compiler Als Beispiel für einen Vorgang, der hauptsächlich im Hintergrund abläuft und durch IDEs stark vereinfacht wird, ist der Übersetzungsvorgang zu nennen. Wird ausschließlich mit der IDE gearbeitet, kann der Kompiliervorgang durch integrierte Abhängigkeitswerkzeuge komplett automatisiert werden, so dass der Kompiliervorgang nicht mehr als einen Klick erfordert. Bei einigen IDEs Copyright Fraunhofer FIRST2003 7

Konzepte und Features wird sogar fortlaufend im Hintergrund kompiliert, so dass Fehler sofort im Editor sichtbar gemacht werden können. Die Erkennung der Abhängigkeiten von Quelltexten ermöglicht inkrementelles Übersetzen, was bedeutet dass nur die Teile übersetzt werden, die geändert wurden, beziehungsweise von den Änderungen direkt oder indirekt abhängig sind. Stehen für die Übersetzung mehrere Compiler zur Auswahl, sollten diese einzeln konfigurierbar und je nach Bedarf einsetzbar oder austauschbar sein. Konfigurations-Optionen wie Kompatibilitätseigenschaften (bei Java: 1.3/1.4), Fehler- und Warnmeldungen sowie weitere Parameter sollten innerhalb der IDE einstellbar sein. Die Automatisierung des Kompilierprozesses erspart zwar einerseits Zeitaufwand, kann sich aber andererseits auch als zu inflexibel herausstellen, wenn externe Werkzeuge wie Quellcodetransformatoren verwendet werden, die in den Übersetzungsvorgang integriert werden müssen. Daher sollte es möglich sein, den integrierten Kompiliervorgang entweder zu erweitern oder durch den Aufruf eigener Skripte zu ersetzen (siehe nächster Abschnitt). Weiterhin sollte eine Unterscheidung zwischen Entwicklungsversionen und Endnutzerversionen möglich sein. Während des Entwickelns sollte die Kompilierzeit möglichst gering gehalten und gegebenenfalls Extrainformationen für den Debugger erzeugt werden. Im Gegensatz dazu sollten Release- Builds diese Informationen gerade nicht enthalten und stattdessen auf Performanz optimiert sein - die Dauer der Übersetzung spielt hierbei kaum eine Rolle. 2.2.4 Build-Prozess Die Erstellung einer kompletten, ausführbaren Anwendung aus dem Sourcecode und weiteren benötigten Artefakten kann unter Umständen ziemlich komplex sein und viele Schritte und Abhängigkeiten beinhalten. IDEs bieten hier in der Regel einen einfach zu bedienenden internen Build-Prozess an, bei dem die Verwaltung der einzelnen Elemente komfortabel und dessen Ausführung mit Hilfe weniger Kommandos möglich ist. Durch die Abstraktion vom Dateisystem und den konkreten Artefakten, die für einen Build notwendig sind, reduziert sich der Aufwand für den Entwickler erheblich. Im besten Fall reicht ein Mausklick, um die Anwendung zu übersetzen und auszuführen (ggf. im Debugger oder in einer Test-Umgebung). 8 Copyright Fraunhofer FIRST 2003

Konzepte und Features Zusätzlich erlauben einige IDEs die Nutzung alternativer Build-Werkzeuge wie Ant oder make. Die entsprechenden Skripte können dann direkt aus der IDE gestartet und dort teilweise auch komfortabel editiert werden. Außerdem lassen sich auf diese Weise externe Werkzeuge einbinden, z.b. zur Generierung von Dokumentation oder zum Deployment auf Testservern, was insbesondere bei der Entwicklung von J2EE- und Web-Applikationen sinnvoll ist. Eine weitere Möglichkeit ist der Export solcher Build-Skripte, um das Erstellen der Anwendung auf externen Hosts durchführen zu können, auf denen die IDE nicht verfügbar ist, oder es automatisiert (z.b. zeitgesteuert) vornehmen zu lassen. Unabhängig vom verwendeten Build-Prozess ermöglichen einige IDEs die Erstellung der Anwendung in Form von selbst-installierenden Paketen bzw. Installationsroutinen, um die Installation auf den Zielrechnern so einfach wie möglich zu gestalten. 2.2.5 Debugging Das Zusammenspiel von Editor und Debugger zum Setzen und Entfernen von Haltepunkten direkt im Quelltext hat sich bei praktisch allen IDEs durchgesetzt. Komfortabler könnte man kaum debuggen, als den gewünschten Haltepunkt im Quellcode zu markieren, das Programm per Knopfdruck zu starten und bei Erreichen der Stelle grafisch Zugriff auf den Stack zu bekommen, Parameter und Variablen zu erhalten, Werte auszulesen, Strukturen zu überprüfen und Ausdrücke auszuwerten. Neben solchen absolut definierten Haltepunkten erleichtern bedingte Haltepunkte, beispielsweise um in einer Schleife nicht bei jeder Iteration zu stoppen, die Fehlersuche. Weitere Standardfeatures sollten die unterschiedlichen Arten sein, den Programmcode schrittweise ausführen zu können: einen Schritt in einen Funktionsaufruf hinein machen und dort bei der nächsten Instruktion anhalten ( step in ), aus einer Funktion herausspringen, d.h. alle folgenden Instruktionen der Funktion ausführen und danach anhalten ( step out ) und einen Funktionsaufruf überspringen, d.h. diese Funktion komplett ausführen und danach anhalten ( step over ). Copyright Fraunhofer FIRST2003 9

Konzepte und Features Ebenso sollte jeder aktuelle Debugger das Überwachen von Variablen beherrschen. An spezielleren Funktionen wäre das Auffinden von nicht freigegebenen Ressourcen ( memory/resource leaks ) oder nicht initialisierten Speicherbereichen zu nennen sowie das Überwachen/Analysieren von Programmein- und ausgaben in Dateien oder Netzwerkschnittstellen. Das Debuggen von Programmen auf einem entfernten Rechner ( remote debugging ) oder sogar das Debuggen von verteilten Programmen können derzeit als Besonderheit angesehen werden. Auch die Unterstützung des Debuggens von multi-threaded Programmen, d.h. Visualisierung, Synchronisation, Anhalten und Fortfahren einzelner Threads ist noch nicht im Funktionsumfang aller IDEs enthalten. Manche Debugger für Java-Anwendungen besitzen ein Hot Code Replace Feature (ab JDK 1.4). Dies erlaubt es in gewissen Grenzen, während des Debuggens Änderungen im Code durchzuführen, welche sich beim Speichern sofort auf die Version im Debugger auswirken. Das erneute Starten und Wiederholen der Debug-Sitzung wird dadurch unnötig. 2.3 Erweiterte Funktionalitäten Neben den oben beschriebenen Kernfunktionalitäten bieten viele IDEs zusätzliche, produktivitätssteigernde Erweiterungen, die im Folgenden näher betrachtet werden. 2.3.1 Konfigurationsmanagement Entwicklung von nicht-trivialer Software ist ohne Konfigurationsmanagement heutzutage kaum noch denkbar. Alle Artefakte eines Softwareprojektes werden typischerweise zentral in einem Repository verwaltet, damit eine einheitliche Basis für sämtliche beteiligten Entwickler besteht. Dabei werden die Änderungen an jedem Artefakt in sogenannten Revisionen aufgezeichnet, so dass einerseits eine Nachvollziehbarkeit gewährleistet ist (optional in Verbindung mit einem Bugtracking System), andererseits bei fehlerhaften Änderungen auf frühere Revisionen zurückgegriffen werden kann. Insbesondere bei evolutionär entwickelter Software ist es oft hilfreich, auch zu späterer Zeit den Autor bzw. die Intentionen für bestimmte Codefragmen- 10 Copyright Fraunhofer FIRST 2003

Konzepte und Features te ermitteln zu können. Eine Notiz, die zusammen mit der Revision aufgezeichnet wurde, leistet dafür gute Dienste. Einzelne Artefakte in bestimmten Revisionen können zu einer Version des gesamten Programms zusammengefasst werden, z.b. einer ausgelieferten Version für Endanwender ( Release ). Im Laufe der weiteren Entwicklung entstehen neue Revisionen, die irgendwann in einer weiteren Version münden. Mit Hilfe des Versionsmanagements ist es stets möglich, auf beliebige Versionen zuzugreifen oder sich die Unterschiede von einer Version zur anderen anzeigen zu lassen. Dies ist insbesondere für den Support älterer Versionen unerlässlich. Es ermöglicht die zentrale Verwaltung der Artefakte bei einer Teambasierten Softwareentwicklung. 2.3.2 Codegenerierung Durch den Einsatz von Wizards und interaktiv über Dialoge erstellte Programm-Elemente wie Klassen, Features oder ganzer Komponenten kann dem Entwickler eine Menge Schreibarbeit erspart werden. Außerdem können so Fehler vermieden und Coding Standards besser eingehalten werden eine konsistente Formatierung und aussagekräftige Bezeichner können forciert werden. Der Entwickler gibt nur noch die notwendigen Informationen wie Klassenname, Paket und Vererbungsbeziehungen an; der Code und gegebenenfalls weitere Artefakte werden von der IDE auf der Grundlage von vordefinierten Schablonen ( Templates ) generiert. Die so erzeugten Elemente werden automatisch in das aktuelle Projekt und den Build-Prozess eingebunden. Neben der interaktiven, dialog-basierten Erstellung von einzelnen Elementen, wie Klassen und Methoden, gibt es zunehmend auch die Möglichkeit, komplette Klassenstrukturen nach bestimmten Entwurfsmustern per Wizard zu generieren. Bei der Verwendung von Schablonen für die Code-Generierung ist es von Vorteil, wenn diese flexibel und individuell angepasst werden können, um beispielsweise Firmenstandards einzuhalten. Ein weiteres Beispiel ist die Generierung von Code für grafische Benutzungsschnittstellen (Graphical User Interface - GUI), die mit Hilfe eines visuellen Werkzeugs entworfen werden. Der Entwickler muss dann lediglich die Verknüpfung der GUI-Elemente mit den entsprechenden Funktionalitäten vornehmen, was in der Regel auch visuell geschieht (siehe Abschnitt 2.3.8. GUI-Designer ). Copyright Fraunhofer FIRST2003 11

Konzepte und Features 2.3.3 Testen Ist im Entwicklungsprozess (wie z.b. beim Extreme Programming) eine Form des Unit-Testens parallel zur Programmierung vorgesehen, sollte dies von der IDE unterstützt werden. Dazu gehören die komfortable Erstellung von Tests und deren einfache Durchführung während der Entwicklungsarbeit, ohne den aktuellen Kontext verlassen zu müssen. Die Erstellung von Testfällen kann von der Entwicklungsumgebung derart unterstützt werden, dass die Rümpfe und Testtreiber aus den zugehörigen Klassen abgeleitet oder aus entsprechenden Modellen generiert werden, was eine erhöhte Konformität zu bestehenden Test-Frameworks und -Werkzeugen zur Folge hat. Die Ausführung der Tests sollte einfach aus dem Editor oder einer Navigationsansicht erfolgen können und die Ergebnisse der Tests in einem separaten Fenster angezeigt werden. Um fehlgeschlagene Testfälle verfolgen und die Implementierung dementsprechend korrigieren zu können, ist eine Sprungmöglichkeit direkt an die betroffenen Stellen im Code, ähnlich wie bei einem Debugger, sinnvoll. Zusätzlich sollte der Test-Code selbst in einem Debugger evaluiert werden können. 2.3.4 Refactoring Eine weitere wichtige Tätigkeit in der Softwareentwicklung und zentraler Bestandteil des Extreme Programming ist das so genannte Refactoring. Beim Refactoring wird bestehender Sourcecode umstrukturiert, ohne das tatsächliche Verhalten der Anwendung zu verändern. Durch diese nachträgliche, systematische Reorganisierung von Code veraltet dieser nicht so schnell es muss nicht gleich alles neu implementiert werden. Zum Refactoring zählen Vorgänge wie das Erzeugen von Methoden aus Code-Fragmenten oder das Extrahieren von Schnittstellen aus bestehenden Klassen. Auch das nachträgliche Verschieben von Klassen innerhalb der Vererbungshierarchie, das Umbenennen von Klassen, Methoden und Attributen oder die Änderung von Methoden-Signaturen gehören zu den typischen Aufgaben im Refactoring. Eine IDE sollte hierbei sicherstellen, dass alle Abhängigkeiten, d.h. Benutzungen der geänderten Elemente, entsprechend mit geändert werden. Wird beispielsweise der Name einer Methode geändert, müssen alle Aufrufe dieser Methode entsprechend angepasst werden und das mindestens im gesamten aktuellen Projekt, gegebenenfalls auch darüber hinaus. Des Weiteren kann bei der Verschiebung von Klassen und Paketen eine Änderung 12 Copyright Fraunhofer FIRST 2003

Konzepte und Features der verwendeten Importe in den beteiligten Klassen erforderlich sein. Insbesondere Änderungen, die sich direkt auf die zugrunde liegenden Artefakte auswirken, haben teilweise auch Auswirkungen auf das Build- und Konfigurationsmanagement. Wird zum Beispiel in Java ein Dateiname geändert, hervorgerufen durch die Änderung des Klassennamens, muss dies im darunter liegenden Repository nachvollzogen werden und eventuelle Build- Skripte angepasst werden. Eine manuelle Durchführung der genannten Restrukturierungen ist in größeren Projekten ohne Werkzeugunterstützung kaum denkbar und würde mit hoher Wahrscheinlichkeit zu Folgefehlern führen, die erst später an unerwarteter Stelle vom Compiler bemängelt werden würden. Gute Werkzeugunterstützung für das Refactoring ist hauptsächlich in Sprachen wie Smalltalk und Java verbreitet und findet sich eher selten bei C/C++ oder ObjectPascal. 2.3.5 Modellierung/Design (UML) Neben den klassischen IDEs, die eher Code- bzw. Editor-zentriert ausgelegt sind, existieren Design-Werkzeuge, deren Fokus auf der Modellierung von Software liegt. Zunächst waren dies reine Diagramm-Editoren, mit denen sich Software-Modelle in bestimmten Notationen erstellen ließen, entweder im Rahmen des Design-Prozesses vor der eigentlichen Implementierung, oder auch nachträglich zur Dokumentation und Kommunikation. Die vorherrschende Notation für solche Modelle ist die Unified Modeling Language (UML), die sich als Standard insbesondere für objektorientierte Modellierung etabliert hat. In der UML gibt es 12 verschiedene Diagrammtypen, die sich grob in Struktur beschreibende (statische) und Verhalten beschreibende (dynamische) unterteilen lassen. Zu den strukturellen Diagrammtypen zählen unter anderem Klassen-, Komponenten- und Deployment-Diagramme. Beispiele für dynamische Diagrammtypen sind Aktivitäts-, Sequenz- und Kollaborations-Diagramme. Bei IDEs mit UML-Unterstützung kann man unterscheiden zwischen Codeorientierten und Modell-orientierten Benutzungsführungen. Bei ersterer steht die Bearbeitung des Sourcecodes im Vordergrund, die UML-Diagramme dienen lediglich der Visualisierung (Beispiel: JBuilder). Die zweite Kategorie nutzt das grafische Modell zur Navigation und als zentrales Element zum Erstellen neuer Klassen und anderer Elemente (Beispiel: Together). Copyright Fraunhofer FIRST2003 13

Konzepte und Features Design-Werkzeuge bieten in der Regel Import-/Export-Schnittstellen an, um Diagramme mit anderen Werkzeugen austauschen zu können. Im Falle von UML geschieht dies über XMI (XML Metadata Interchange). Häufig lassen sich auch Diagramme als Grafiken speichern und komplette Modelle nach HTML exportieren, um diese auch außerhalb des Diagramm-Editors lesen zu können. Weitere Funktionen, die ein Modellierungs-Werkzeug bereitstellen kann, sind Validitäts- und Konsistenzüberprüfungen innerhalb des Modells, Unterstützung für Entwurfsmuster ( Design Patterns ) und ein System zum Auffinden von schlechten Designs und Vorschlagen von Alternativen ( Design Critics ). Über die Gemeinsamkeiten im zugrunde liegenden Metamodell lassen sich grafische Notationen und Programmiersprachen zu einem gewissen Grad ineinander überführen. So kann beispielsweise aus einem UML Klassen- Diagramm leicht der entsprechende Java Sourcecode generiert werden ( Forward Engineering ) oder umgekehrt, Source- oder Bytecode durch Diagramme visualisiert werden ( Reverse Engineering ). Die Motivation für Forward Engineering ist im Wesentlichen die Reduzierung der Tipparbeit und die durch festgelegte Generierungs-Vorschriften geringere Fehleranfälligkeit. Reverse Engineering ermöglicht hingegen eine gute Abstraktion und somit ein besseres Verständnis des zugrunde liegenden Codes und kann zur Erstellung von Dokumentation genutzt werden. Als Round-Trip Engineering bezeichnet man die Kombination dieser beiden Generierungsschritte, so dass wechselseitig im Modell und im Code gearbeitet werden kann. Die Synchronisation zwischen Modell und Code erfolgt dann entweder manuell oder automatisch, wobei die Diagramm-spezifischen Informationen je nach IDE direkt im Code (in der Regel in Kommentaren) oder getrennt davon gespeichert werden. Die Benutzung von externen Design-Werkzeugen stellt häufig einen erheblichen Bruch in der Softwareentwicklungs-Kette dar, da die Konsistenz zwischen Design und Implementierung in diesem Fall meist von Hand sichergestellt werden muss. Aus diesem Grund wurden viele der vorher einseitig ausgerichteten Werkzeuge um das fehlende Gegenstück erweitert. So unterstützen mittlerweile fast alle Diagramm-Editoren Forward und Reverse Engineering, wobei das Editieren des generierten Codes in einem externen Editor bzw. einer IDE erfolgt. Auf der anderen Seite wurden viele Codezentrierte IDEs um Diagramm-Editoren erweitert, die zumindest eine Visuali- 14 Copyright Fraunhofer FIRST 2003

Konzepte und Features sierung des Source- oder Bytecodes in Form von UML-Diagrammen ermöglichen. Ein vollwertiges Round-Trip Engineering, also das wechselseitige Editieren in Code und Diagramm bei automatischer Synchronisierung aller Artefakte, bieten indes nur wenige dieser Werkzeuge. Eine solche Unterstützung kann unter anderem auch die Funktion von Wizards zur Erstellung von Programm-Elementen übernehmen. Der Entwickler legt dabei zum Beispiel eine neue Klasse im Diagramm an und die IDE erzeugt im Hintergrund automatisch die entsprechende Java-Datei und öffnet diese im Editor. Auch Vererbungsbeziehungen, Methoden und Attribute können so bequem im Modell eingepflegt werden und sind trotzdem sofort im Code sichtbar. 2.3.6 Datenbanken Soll im Verlauf der Softwareentwicklung eine Datenbank erstellt oder benutzt werden, kann es hilfreich sein, wenn die Entwicklungsumgebung hierfür entsprechende Funktionen oder Anbindungsmöglichkeiten bereitstellt. Zur Erstellung von Datenbank-Schemata bietet sich die Modellierung von ER- Diagrammen ( Entitiy-Relationship ) an, aus denen dann Code und Skripte für den Zugriff auf die Datenbank generiert werden können. Auch das komfortable Erstellen von Abfragen und die direkte, visuelle Bearbeitung von Datensätzen könnten in die IDE integriert sein, um für diese Aufgaben den Kontext nicht verlassen zu müssen. 2.3.7 Deployment/Laufzeitumgebung/Server Wie bereits erwähnt, gibt es IDEs, die ein direktes Installieren ( Deployment ) und Ausführen der entwickelten Anwendungen oder Komponenten auf externen oder in die IDE integrierten Web- bzw. Applikationsservern erlauben, was ein schnelles und unkompliziertes Testen und Debuggen ermöglicht. Hierzu muss die IDE entweder eine eigene Laufzeitumgebung zur Verfügung stellen oder die Möglichkeit haben, auf externe zuzugreifen. Dabei wird bei kommerziellen Produkten oft die hauseigene Plattform am besten unterstützt, was eventuell dazu führen kann, dass die Wahl der IDE Einfluss auf die Entscheidung für einen Applikationsserver haben kann oder umgekehrt. Ein so genanntes Hot Deployment ermöglicht das Installieren oder Austauschen von Komponenten, ohne den Server stoppen zu müssen. Besonders während der laufenden Entwicklung ist dies von Vorteil, da weniger Zeit durch Neustarts verloren geht. Copyright Fraunhofer FIRST2003 15

Konzepte und Features 2.3.8 GUI-Designer Das Erstellen grafischer Benutzeroberflächen (GUIs) geht am leichtesten mit Hilfe eines GUI-Builders" vonstatten. Dieser erlaubt das visuelle Zusammenstellen der Oberfläche aus den einzelnen Bedienelementen (Menüzeile, Werkzeugleisten, Schaltflächen, Auswahlboxen, etc.), welche dann zum Einbinden in das Programm in Code überführt wird. Unterschiede gibt es hierbei insbesondere in der Art und Weise, wie die Anordnung der Elemente geschieht. Eine feste, pixelbasierte Platzierung wirkt sich negativ auf Bedienung aus (Fenster oder deren Inhalte können nicht verkleinert oder vergrößert werden). Auch die Übersetzung des Programms in mehrere Sprachen wird dadurch erschwert, da die Größe der Bedienelemente typischerweise abhängig von der Beschriftung ist. Sinnvoller ist daher die Unterstützung von Layout Managern", die die Elemente relativ zueinander anordnen und dafür den gesamten verfügbaren Platz nutzen. Von Vorteil ist es, wenn die Bedienelemente nicht nur ausgewählt und arrangiert, sondern auch noch konfiguriert werden können, z.b. der initiale Inhalt eines Textfeldes, das Aussehen (Farbe, Schrift,...), Hilfstexte oder gar Verbindungen zu einer Datenbank ( data-aware widgets ). 2.3.9 Internationalisierung Oft wird Software an unterschiedliche Regionen angepasst. Idealerweise sollte eine IDE Unterstützung zum Internationalisieren der entwickelten Software bieten. Dazu ist einerseits ein Mechanismus nötig, die Beschriftungen und Meldungen im Quellcode zu erfassen und ein Werkzeug zum Übersetzen dieser bereitzustellen. Andererseits muss die Oberfläche der Software flexibel genug gestaltet werden können, so dass sich die Größe der grafischen Elemente auch bei Übersetzung in eine andere Sprache nach der Beschriftung richtet (die Beschriftungen sind in der Regel für jede Sprache unterschiedlich breit). Weiterhin müssen die Elemente abhängig von der Sprache von links nach rechts oder andersherum angeordnet werden. 2.3.10 Hilfe-System Die grobe Funktionsweise einer IDE ist zwar meist intuitiv zu erfassen, um sie richtig anzuwenden und die Fähigkeiten auszureizen ist jedoch ein Studium der Anleitung ratsam. Eine gute (kontextsensitive) Online-Hilfe kann 16 Copyright Fraunhofer FIRST 2003

Konzepte und Features die Notwendigkeit, gedruckte Handbücher lesen zu müssen, reduzieren, sofern die zugrunde liegenden Konzepte bekannt sind und beispielsweise nur die Verwendung eines Features erlernt werden muss. Heutige IDEs beinhalten verschiedene Arten von Hilfen. So werden Standard-Hilfen, wie z.b. Inhaltsverzeichnis, Index und Suche angeboten aber auch aus dem Kontext der aktuellen Funktionalität zusätzlich Informationen über Bibliotheksfunktionen, Schlüsselwörter, Parameter, etc. automatisch zur Verfügung gestellt. Tutorials und geführte Beispielentwicklungen für unterstützte Anwendungstypen helfen beim ersten Verständnis der Konzepte der benutzten IDE. Ebenso wie die IDE sollten auch die damit entwickelten Anwendungen mit Handbüchern und Online-Hilfe bestückt sein. Bei der Erstellung der Entwicklung von der IDE unterstützt werden sollte. Für die Entwicklung selbst ist die Anzeige von verlinkten API-Dokumentationen verwendeter Softwarebibliotheken interessant sowie die Erzeugung der Dokumentation des eigenen Codes. 2.3.11 Utilities Task-Liste Abgerundet wird der Funktionsumfang einer IDE durch eine projektbezogene Taskliste (Aufgabenliste), die sämtliche zu erledigende Tätigkeiten festhält und auf die jedes Werkzeug Zugriff hat. Beispielsweise können im Editor als TODO markierte Stellen automatisch in die Taskliste aufgenommen werden. Ein Klick auf diesen Eintrag in der Taskliste öffnet sodann die entsprechende Stelle im Editor. Ebenso kann der Compiler je einen Task für jede Warnung und jede Fehlermeldung erzeugen. Da dies schnell zu einer Vielzahl an Tasks führen kann, sollte die Taskliste durchsuchbar und nach unterschiedlichen Kriterien sortierbar sein. Die Übersicht kann durch Filter gewahrt werden, mit denen sich Tasks einzeln oder quantitativ anhand ihrer Eigenschaften ausblenden lassen. Quick Fix Produktivitätssteigernd wirkt sich zusätzlich eine Quick Fix"-Funktion aus, die es ermöglicht, bestimmte Tasks zur Behebung einfacher Fehler automa- Copyright Fraunhofer FIRST2003 17

Konzepte und Features tisiert durchzuführen. Kompilierfehler aufgrund fehlender Importe, welche automatisch von der IDE aufgelöst und eingefügt werden können, sind Kandidaten hierfür, ebenso wie einfache Syntaxfehler (z.b. fehlendes Semikolon, Klammern). Makros Die Automatisierung möglichst vieler Arbeitsvorgänge ist einer der Gründe für den Einsatz einer IDE. Optimierend wirkt sich die Automatisierung wiederkehrender Arbeitsvorgänge durch Makros aus, die die Arbeitsweise des Entwicklers unterstützen. Mit einem Makrorekorder aufgenommene Sequenzen von Aktionen oder eingegebenem Text können somit komfortabel beliebig oft wiederholt werden. 18 Copyright Fraunhofer FIRST 2003

Marktübersicht 3 Marktübersicht Die folgende Marktübersicht bietet einen ausschnittweisen Überblick über am Markt verfügbare IDEs und geht kurz auf die jeweiligen Eigenschaften und Besonderheiten der einzelnen Werkzeuge ein. 3.1 Borland C++Builder 6.0 Der Borland C++Builder ist in drei Editionen erhältlich: Personal Edition, Professional Edition und Enterprise Edition. Der Funktionsumfang nimmt in der Reihenfolge der Aufzählung zu. Im Borland C++Builder ist zusätzlich die Borland Kylix- Entwicklungsumgebung enthalten. Die mit Borland-CLX (Component Library for Crossplattform) erstellten Anwendungen sind mit Kylix Quellcode kompatibel. So ist es auch möglich, Applikationen für Linux-Plattformen zu erstellen. Eine der Hauptkomponenten des C++Builders ist die BizSnap-Web- Services-Entwicklungsplattform. Sie soll das Erstellen von SOAP-/XML- Webservices und Verbindungen vereinfachen (SOAP = Simple Object Access Protocol, ein auf XML basierendes Protokoll, das für den Informationsaustausch in dezentralen, verteilten Umgebungen geeignet ist). Eine weitere hinzugefügte Funktionalität ist WebSnap. Es vereinfacht und beschleunigt die komponentenbasierte Web-Anwendungsentwicklung. Ein integrierter Web-Applikations-Debugger erleichtert das Auffinden von Fehlern. Zusätzlich ist beim C++Builder 6 das ein Tool namens DataSnap integriert. DataSnap soll die Unterstützung für Datenbankentwicklungen verbessern. Alle gängigen Standards zur verteilten Programmierung, wie SOAP/XML, COM, TCP/IP und Corba werden unterstützt. Außerdem können mit DataSnap RDBMS-Serververbindungen und die Bandbreite optimiert werden. Die IDE verfügt ansonsten über die Standardtools (Editor, Compiler, Debugger) mit gängigen Standardfunktionen. Erweiterte Navigationshilfen, wie z.b. Copyright Fraunhofer FIRST2003 19

Marktübersicht die Möglichkeit zur Deklaration von Bezeichnern zu springen, sind auch vorhanden. Der Compiler unterstützt "precompiled headers", so dass die Kompilierzeiten stark verkürzt werden können. Eine Unterstützung für das Versionsverwaltungssystem PVCS ist nur in der Enterprise Edition vorhanden. Ein Designwerkzeug ist nicht integriert. 3.2 Borland Kylix 3 Borland Kylix ist in drei Editionen erhältlich: Open, Professional und Enterprise, wobei in der Reihenfolge der Aufzählung der Funktionsumfang zunimmt. Der Editor verfügt soweit über die Standards wie Syntaxhighlighting oder Autoformatierungen. Allerdings sind Formatierungen nicht konfigurierbar. Neben der Autovervollständigung von C++- und Delphi-Code ist nun auch eine Autovervollständigung für HTML-Sourcecode integriert. Kylix unterstützt die Programmierung in den Sprachen Delphi und C/C++. Es sind zwei Native-Code-Compiler für C/C++ und Delphi integriert. Wie beim Borland C++Builder ist auch bei dieser IDE die Neuerung des "Precompiled header support" erwähnenswert, da sich dadurch die Kompilierzeiten bei der Sprache C++ verkürzen. Der Debugger besitzt u.a. die Funktionalität des "Multi-Process-Debuggens". Die neue BizSnap-Web-Services-Entwicklungsplattform soll das Erstellen von SOAP-/XML-Webservices und Verbindungen vereinfachen. Eine weitere Funktionalität der IDE ist ein Tool namens WebSnap. Es soll die komponentenbasierte Web-Anwendungsentwicklung vereinfachen und beschleunigen. Ein integrierter Web-Applikations-Debugger erleichtert das Auffinden von Fehlern. 20 Copyright Fraunhofer FIRST 2003

Marktübersicht Außerdem ist in die IDE DataSnap integriert worden. Es handelt sich hierbei um ein Tool, dass eine bessere Datenbankunterstützung gewährleisten soll. DataSnap unterstützt die Standards der verteilten Programmierung wie SOAP/XML, COM, TCP/IP und Corba. DataSnap soll RDBMS- Serververbindungen und Bandbreite optimieren. Die Navigationsfunktionen bieten die Möglichkeit des Sprungs zur Deklaration von Bezeichnern sowie des Wechsels zwischen Schnittstelle und Implementierung. 3.3 Borland JBuilder 9.0 Der Borland JBuilder ist in drei Editionen erhältlich: Personal Edition, Professional Edition und Enterprise Edition, wobei ähnlich wie bei den meisten Borland Produkten in dieser Reihenfolge der Funktionsumfang zunimmt. Borland JBuilder ist eine plattformübergreifende, integrierte Entwicklungsumgebung für die Entwicklung von Java-Anwendungen, Applets, JSP/Servlets, JavaBeans, Enterprise Java Beans, und verteilte Applikationen auf Basis von J2EE. In der Enterprise Version wird zusätzlich die Entwicklung von EJB-, Web-, XML- und Datenbankanwendung mit Hilfe eines visuellen Two-Way-Designer und dem Hot-Deployment auf einem J2EE- Applikationsserver vereinfacht. Auch können hier UML-Klassendiagramme automatisch generiert generiert werden. Generell bietet der JBuilder Werkzeugunterstützung für alle Phasen eines Softwareentwicklungsprozesses: Design (nur Enterprise Edition), Programmierung, Kompilieren, Debuggen, Testen, und Deployment. Für ein vollständiges Round-Trip-Engineering ist Together ControlCenter als Designwerkzeug integrierbar. Die IDE ist weiterhin in das Borland StarTeam integriert, ein Konfigurationsmanagementwerkzeug, das zur Versionsverwaltung zur Verfügung steht. Es ist aber auch problemlos möglich, andere Versionsverwaltungswerkzeuge zu integrieren. Ein direkte Unterstützung steht z.b. für CVS, MS Visual Source- Safe und Rational ClearCase zur Verfügung. Aufgrund der Anbindungsmöglichkeit des JBuilders an viele verschiedene Applikationsserver (Borland Enterprise Server, BEA WebLogic Server, IBM WebSphere, Oracle 9i Applica- Copyright Fraunhofer FIRST2003 21

Marktübersicht tion Server, Sybase EAServer und Sun ONE Application Server) besteht eine größere Unabhängigkeit bei der Wahl der technischen Infrastruktur. Der Editor verfügt über die üblichen Standardfunktionen mit der Ausnahme der Autokorrektur von Fehlern im Quellcode. Die automatische Code Formatierung ist ausreichend konfigurierbar. Eine verbesserte Navigationsunterstützung bietet die Möglichkeit zur Definition von Bezeichnern und Methoden zu springen, den Tausch von Deklarationen, Sprung zur Implementierung und Verwendungen (Cross-Referencer). Der JBuilder bietet auch Unterstützung für das Refactoring und ein visueller Debugger ist ebenfalls vorhanden. Als wesentliche Stärken des Debuggers sind das Remote-Debugging und das Debuggen von Class-Dateien über TCP/IP zu nennen. 3.4 Borland Delphi 7.0 Borland Delphi ist in vier Editionen erhältlich: Personal Edition, Professional Edition, Enterprise Edition und Architect Edition. Der Funktionsumfang nimmt ebenfalls in dieser Reihenfolge zu. In der Enterprise- und Architect-Edition unterstützt die IDE den kompletten Entwicklungszyklus vom Design, über das Programmieren, Kompilieren, Debugging, und Testen bis hin zum Deployment. Eine Versionsverwaltung wird ebenfalls unterstützt. Es ist möglich neue, aber auch ältere, Anwendungen zu.net-applikationen zu migrieren. Mit der enthaltenen Umgebung Borland Kylix 3 ist es zusätzlich möglich, Anwendungen für Linux-Plattformen zu erstellen (ausgenommen Personal-Edition). Als UML-Technologie bietet Borland Delphi in der Architect-Version die Unterstützung der Designtools Rational Rose und Model Maker. Dies ist ein Teil der neuen "Bold-für-Delphi"-Technologie. Der Compiler gibt Warnungen und Hinweise für die.net-kompatibilität der Anwendungen. Der Debugger wurde im Vergleich zu früheren Versionen erweitert. Beim Multithreading ist es jetzt möglich, die einzelnen Threads zu benennen, damit man sie später besser identifizieren kann. Früher wurde den Threads lediglich eine ID zugeordnet. Ein Source-Code-Management ist bei der Enterprise- und der Architect-Edition integriert. Dasselbe trifft auf die Unterstützung von PVCS oder einem anderen modularen Versionsverwaltungssystem zu. 22 Copyright Fraunhofer FIRST 2003

Marktübersicht 3.5 Borland Together ControlCenter 6.1 Nach der Übernahme von Togethersoft bietet Borland nun auch eine eigene IDE mit umfassender UML Funktionalität an. Together ControlCenter, das umfassendste Produkt aus der Together Familie, unterstützt den gesamten Entwicklungsprozess von der Analyse über Design bis hin zum Deployment. Besonders hervorzuheben sind das simultane Roundtrip Engineering, die umfangreichen Refactoring-Möglichkeiten sowie Funktionen zur Qualitätssicherung wie Audits, Metriken und Profiler. Together ControlCenter bietet darüber hinaus verschiedene vordefinierte Rollen (Business Modeler, Designer, Entwickler und Programmierer), die eine für die jeweiligen Aufgaben angepasste Oberfläche und Konfigurationen beinhalten. Die Konfiguration ist getrennt auf Programm-, Projekt- und Diagramm-Ebene möglich. Together ist inzwischen auch in weiteren Editionen erhältlich, unter anderem in einer abgespeckten Version (Together Solo), die auf Real-Time und Qualitätssicherungsfunktionen, Geschäftsmodellierung sowie weitere spezielle Features verzichtet. Des Weiteren gibt es Together als Add-Ons für JBuilder, Eclipse, WebSphere Studio und SAP NetWeaver, welche verschiedene der Funktionen von ControlCenter in der jeweiligen IDE zur Verfügung stellen. 3.6 Eclipse 2.x Eclipse ist eine Open-Source-IDE, die frei im Internet erhältlich ist. Eclipse ist eine vielseitige, robuste, qualitativ hochwertige IDE. Sie verfügt u.a. über einen Editor mit Syntaxhiglighting, eine inkremetelle Code Kompilierung, einen "thread-aware source-level Debugger", einen Klassennavigator, einen Datei- und Projektmanager sowie ein Versionsmanagementtool. Des Weiteren verfügt Eclipse über Features wie beispielsweise Code-Refactoring, automatische Code-Updates, eine Task-Liste, eine Testunterstützung mit JUnit und die Integration des Ant Build Tools. Ein herausragender Vorteil von Eclipse ist die vollständige Plattform- und Sprachunabhängigkeit. Copyright Fraunhofer FIRST2003 23

Marktübersicht Als besondere Stärken von Eclipse sind die Web-ähnliche Navigation durch den Code ("Vorwärts/Rückwärts", Zurück zur letzten Modifikation ), der mächtige Refactoring-Support mit Vorschau und die umfangreichen Suchfunktionen (genaue Angabe des Kontextes durch Parameter) zu nennen. Ein besonderes Feature ist auch die Tatsache, dass man während des Debuggens Änderungen im Code vornehmen kann (Hot Code Replace). Eclipse ist über Plugins vielseitig erweiterbar. Die Plugins können in Eclipse selbst geschrieben und getestet werden; hierfür gibt es eine eigene Laufzeitumgebung. 3.7 IBM WebSphere Studio Application Developer 5.1 Die WebSphere Studio Produkte von IBM haben die bisherigen VisualAge- Produkte zumindest auf dem Java-Sektor abgelöst. Technisch haben sie allerdings nichts mehr mit ihren Vorläufern gemein, sie basieren auf der WebSphere Studio Workbench, die eine kommerzielle Version der Eclipse Plattform darstellt. Ähnlich wie in Eclipse gewährleisten das Konzept der Perspektiven optimierte Ansichten für bestimmte Aufgaben und Rollen bei konsistentem Look and Feel. Gegenüber Eclipse beinhaltet WebSphere Studio eine komplette Unterstützung für die Entwicklung von J2EE-Anwendungen und Web Services. Die aktuelle Version beinhaltet einen GUI Builder mit automatischer Code- Synchronisation und Events, sowie Visualisierung und Bearbeitung von UML-Diagrammen. Enthalten ist außerdem Rational ClearCase LT für das Software Configuration Management (SCM), eine Integration Edition ermöglicht die Anbindung von Legacy-Systemen. Die Enterprise Developer Version ist erweitert um die Unterstützung für die visuelle Entwicklung von Webanwendungen nach dem MVC Muster, CO- BOL-Integration sowie Rapid Application Development durch eine eigene Enterprise Generation Language (EGL), aus der der Applikations-Code generiert werden kann. 24 Copyright Fraunhofer FIRST 2003