Im Grunde genommen handelt es sich dabei um zwei Arten von Tools, die zum einen Anweisungen dem Java-Quellcode hinzufügen und dessen Neukompilierung einfordern und zum anderen Tools, die den Bytecode entweder vor oder während der Ausführung instrumentieren. Das Ziel von JaCoCo ist es, herauszufinden, welche Teile des Codes getestet werden, indem es die Codezeilen registriert, die man bei der Ausführung eines Tests ausführt. TDD bzw. Test Driven Development ist diesbezüglich ebenfalls ein gutes Stichwort.

Features von JaCoCo

• Abdeckungsanalyse von Anweisungen (C0), Verzweigungen (C1), Zeilen, Methoden, Typen und zyklomatischer Komplexität (McCabe-Metrik).
• Basiert auf Java-Bytecode und funktioniert daher auch ohne Quelldateien.
• Einfache Integration durch Java-Agent-basierte On-the-fly-Instrumentierung. Andere Integrationsszenarien wie benutzerdefinierte class loader sind über die API möglich.
• Framework-unabhängig: Reibungslose Integration in Java VM-basierte Anwendungen wie einfache Java-Programme, OSGi-Frameworks, Web-Container oder EJB-Server.
• Kompatibel mit allen freigegebenen Java-Klassendateiversionen.
• Unterstützung für verschiedene JVM-Sprachen.
• Verschiedene Berichtsformate (HTML, XML, CSV).
• Remote-Protokoll und JMX-Steuerung zur Anforderung von Ausführungsdaten-Dumps vom Coverage Agent zu jedem beliebigen Zeitpunkt.
• Ant-Tasks zum Sammeln und Verwalten von Ausführungsdaten und zum Erstellen strukturierter Abdeckungsberichte.
• Maven-Plug-in zum Sammeln von Abdeckungsinformationen und Erstellen von Berichten in Maven-Builds.

JaCoCo bietet die Instructions, Line- und Branchabdeckung. Im Gegensatz zu beispielsweise Atlassian Clover und OpenClover, die eine Instrumentierung des Quellcodes erfordern, kann JaCoCo Java Bytecode mit zwei verschiedenen Ansätzen instrumentieren:

1. JCov on the fly, während der Code mit einem Java-Agenten ausgeführt wird beispielsweise wie Cobertura und JCov vor der Ausführung (offline)
2. Man kann es aber auch so konfigurieren, dass man die gesammelten Daten in einer Datei speichert oder via TCP versendet. Im Gegensatz zu Cobertura und EMMA ist die Unterstützung von so ziemlich allen Java Versionen ab der Java Version 7 gewährleistet.

Tools, die JaCoCo verwenden oder enthalten

Einige davon habe ich bereits in diversen Beiträgen thematisiert. Mit einem Klick auf das jeweilige Tool kommt man auf den jeweiligen Beitrag.

• SonarQube JaCoCo Plugin – Standardmäßig für Code Abdeckungsanalysen innerhalb der Code-Qualitätsmanagement-Plattform
• EclEmma Eclipse (Software) Code Coverage Plugin
• Jenkins JaCoCo Plugin
• Netbeans JaCoCo support
• IntelliJ IDEA (Seit Version 11)
• Gradle JaCoCo Plugin
• Visual Studio Team Services
• TeamCity

Fazit

JaCoCo bietet sich für die Codeabdeckungsanalyse bei der modularen Softwareentwicklung bzw. bei den Unit Tests an. Die Abdeckungsgrade geben an, wie viele Anweisungen, Zweige usw. die Tests durchlaufen. Auf Basis der so gewonnenen Erkenntnisse kann man weitere sinnvolle Testfälle ermitteln oder aber nicht beanspruchten bzw. toten Code entfernen. Es gibt kein allgemeingültiges Mindestmaß an Codeabdeckung. Man definiert die jeweils erforderliche Testabdeckung in Anbetracht des Anwendungsfalls nach einer Risikoeinschätzung sowie der eigenen Entwickler-Fähigkeiten.

Der Beitrag JaCoCo – Messen und Optimieren von Testabdeckung für robuste Java-Anwendungen erschien zuerst auf CEOsBay.

Kurze Zeitreise

Eclipse ist im Grunde genommen der Nachfolger von IBM Visual Age for Java 4.0. Der Quellcode dafür wurde im Jahr 2001 von IBM freigegeben. Im Jahr 2004 beschloss das von IBM geführte Eclipse-Konsortium die Ausgründung der rechtlich eigenständigen Eclipse Foundation, die seitdem für die Entwicklung von Eclipse verantwortlich ist. Es unterstützt die Java-Version 5 ab Version 3.1 und Java 6 ab Version 3.2. Ab dem Jahr 2006 wurden die Veröffentlichungstermine neuer Versionen der wichtigsten Eclipse-Komponenten harmonisiert, um Versionskonflikte zu vermeiden und Eclipse-Anwendern die Nutzung zu erleichtern. Man hat den Veröffentlichungszyklus ab der Version 2018-09 auf Quartalsaktualisierungen verkürzt, da ab Java 9 nicht mehr alle 3 Jahre, sondern alle 6 Monate eine neue Java Version erscheint. Es folgt nun einem Rolling Release Modell.

Rolling Release

(„rollen“ und „veröffentlichen“. Sinngemäß handelt es sich dabei um die kontinuierliche Aktualisierung der Software und ist ein Begriff aus der Softwareentwicklung. Bei einem Betriebssystem, dass das Rolling-Release-Prinzip anwendet, gibt es keine Betriebssystem-Versionen, bei denen bei einem Versions-Upgrade eine große Menge an Software auf einmal aktualisiert wird. Die einzelnen Software-Pakete werden vielmehr immerfort aktualisiert. Dies schließt sogenannte Releases, also Veröffentlichungen des Betriebssystems, aber nicht aus. Im Gegensatz zu einem Betriebssystem ohne Rolling Releases sind die Veröffentlichungen jedoch keine Versionen, sondern sogenannte Snapshots. Dies bedeutet, eine Kopie aller im Moment im Repository liegenden Software-Versionen. Diese Snapshots dienen meistens auch als Installations-Medien.

Die Projektnamen waren bisher nach den Jupitermonden (Callisto, Europa und Ganymede), den Raumsonden Galileo und Helios, die Version 3.7 nach der für Eclipse typischen Farbe Indigo benannt. Die Anfangsbuchstaben der Projektnamen werden ab Version 3.5 in alphabetischer Reihenfolge vergeben. Die Version 3.8 erschien gleichzeitig mit der Version 4.2. Um mit dem schnelleren Release-Zyklus von Java mitzuhalten, hat man 2018 von einem jährlichen Release auf vier Releases pro Jahr umgestellt. Damit hat man auch das Namensschema der Release-Versionen auf „{Jahreszahl}-{Monat}“ vereinfacht, also beispielsweise „2018-09“. Die einzelnen Versionen werden jeweils als Grundversion oder als Zusammenstellung aus verschiedenen Programmpaketen veröffentlicht. Einzelne Programmpakete kann man jedoch auch später noch nachinstallieren. Die Benutzeroberfläche von Eclipse ist standardmäßig englischsprachig. Es gibt jedoch zu jeder Version Babel-Language-Packs, die man sich in den entsprechenden Sprachen als Plugin installieren kann.

Darauf gehe ich so explizit ein, da ich mich in den letzten Tagen mit Kollegen über Eclipse ausgetauscht und in einem Quellcode verweise auf „Jupiter“ entdeckt habe. In der jüngsten Vergangenheit habe ich mich mit Jupyter beschäftigt. Daher auch hier ein Verweis auf den Beitrag damit es zu keiner Verwechslung der Themen kommt. Beides von Grund auf verschiedene Themen bzw. Dinge 😉

Architektur

Bis einschließlich zur Version 2.1 ist Eclipse als erweiterbare IDE konzipiert gewesen. Ab Version 3.0 ist es selbst nur der Kern, der die einzelnen Plug-ins lädt, die dann die eigentliche Funktionalität zur Verfügung stellt. Diese Funktionalität basiert, wie bereits erwähnt, auf Equinox. Sowohl Eclipse als auch die Plugins sind vollständig in Java implementiert. Zur Erstellung der GUI (grafischen Benutzeroberfläche) wurde SWT verwendet. Zur Darstellung der GUI-Komponenten basiert SWT ähnlich wie AWT auf den nativen GUI-Komponenten des jeweiligen Betriebssystems. Eclipse steht für 14 verschiedene Systeme und Architekturen zur Verfügung und gilt somit als plattformunabhängig. Die Plugins lassen sich direkt von einem Update-Server, über den „Market Place“, oder durch Entpacken einer Installationsdatei installieren.

Das frei verfügbare Eclipse SDK umfasst die Eclipse-Plattform, Werkzeuge zur Java-Entwicklung (Java Development Tools, JDT) und die Umgebung zur Entwicklung von Eclipse-Plugins (Plugin Development Environment, PDE).

Rich Client Platform

Eclipse bietet eine Rich Client Platform, welche es Anwendungsentwicklern ermöglicht, basierend auf dem Eclipse-Framework, von der Eclipse-IDE unabhängige Anwendungen zu schreiben. Die folgenden Komponenten (Plugins) werden typischerweise mindestens für eine Eclipse-Rich-Client-Platform-Anwendung verwendet:

• Eclipse Core Platform – steuert den Lebenszyklus einer Eclipse-Anwendung
• Eclipse Platform UI – stellt die Workbench mit den Konzepten Sichten, Editoren, Perspektiven, Menüs und Toolbars zur Verfügung
• Standard Widget Toolkit (SWT)
• JFace

Weitere Eclipse-Komponenten, wie das Hilfesystem oder das automatische Aktualisierungssystem, kann man ebenfalls einsetzen. In der Regel nutzt man das Eclipse-OSGi-Framework Equinox zum Kombinieren (bundling) der Komponenten.

Das UI (User Interface)

Eclipse ist in Komponenten (parts) gegliedert, die in Sichten (views) und Editoren (editors) gegliedert sind. Wobei die Unterscheidung in view und editor sich an der Nutzung orientiert und nicht technischer Natur ist. Diese Fenster kann man durch Drag and Drop beliebig anordnen oder minimieren.

Sichten

Mit Hilfe der views kann man Daten direkt bearbeitet und darunterliegende Datenstrukturen verändern.

Beispiele für views sind die auch aus den meisten anderen Editoren bekannte Navigator-View, die im Projektverzeichnis enthaltene Dokumente anzeigt, der Klassenexplorer, der baumartig strukturiert Symbole für die Klassen, Funktionen, Variablen und Importe eines geöffneten Quelltextes anzeigt oder das Suchfenster, dass die Ergebnisse einer Suche auflisten kann.

Editoren

Editoren sind Komponenten, die nur das jeweils geöffnete Datenelement bearbeiten und in denen der Nutzer explizit speichern muss, um Daten zu verändern. Beispiele sind Fenster, die meist den Quelltext mit Syntaxhervorhebung anzeigen, wobei es für viele Programmiersprachen einen eigenen Editor gibt. Beispielsweise für Java, C, PHP, Python, HTML, aber auch einen einfachen Texteditor. Genauso gibt es auch visuelle Editoren (beispielsweise UML-Editoren, GUI-Builder) oder solche, die Baumstrukturen anzeigen (etwa der XML-Editor). Editoren nehmen normalerweise den meisten Raum des Programmfensters in Anspruch. Mehrere geöffnete Quelltexte kann man als Reiter öffnen, die man dann über Tabs am oberen Rand in den Vordergrund bringen kann. Außerdem kann man Tabs fixieren, damit man beispielsweise den zugehörigen Quelltext nicht versehentlich schließt. Auch kann man die Editoren weitestgehend frei per Drag and Drop anordnen. Davon abgesehen ist es möglich, eine Datei in mehreren Editoren gleichzeitig zu öffnen.

Perspektiven

Perspektiven sind vollständige Anordnungen von parts. Ein editor bleibt beim Perspektivwechsel erhalten. Perspektiven sind weitestgehend frei konfigurierbar und man kann benutzerdefinierte Konstellationen speichern sowie laden. Meistens stellen Plugins, die man nachinstalliert, vorkonfigurierte Perspektiven zur Verfügung, diese passt man dann meisten den eigenen Wünschen und Vorlieben an.

Plugins und Erweiterungen

Es gibt zahlreiche Erweiterungen für Eclipse. Teils proprietär, teils frei verwendbar bzw. Open Source. Primär verwendet man es als Java IDE. Dabei kommen vor allem die in den Java Development Tools zusammengefassten Plugins zum Einsatz. Es existieren aber etliche Plugins für andere Sprachen, die ich bereits unter Editoren erwähnt habe. Hinzu kommt noch die Entwicklung von OSGi-Bundles. Dazu zählt vor allem das CDT-Projekt, welches C und C++ unterstützt und unter Anderem die GNU Compiler Collection sowie die LLVM (-Clang und -GCC) abdeckt. Darüber hinaus gibt es auch Plugins für Perl, PHP, ColdFusion, Ruby, Python, C#, Fortran, Ada2005, Scala usw. Diese kann man über ein Menü in Eclipse einbinden. Neben Plugins für konkrete Programmiersprachen gibt es auch solche, die allgemeine Entwicklungsprozesse unterstützen, wie beispielsweise Mylyn für „aufgabenorientierte Entwicklung“ oder Saros für Verteilte Paarprogrammierung auch Distributed Pair Programming, DPP oder Pair Programming, PP genannt. Oft sind diese Ergänzungen – anders als das Kernprogramm – ausschließlich in der englischen Sprache erhältlich.

Neben den Java Development Tools gibt es viele weitere Projekte, die man ebenfalls auf der Eclipse-Website koordiniert. Ein solches Projekt ist das Eclipse Tools Project, dass verschiedene Hilfsmittel entwickelt, die Entwickler erweitern können. Weitere Projekte sind das Eclipse Modeling Framework (EMF), das Graphical Editing Framework (GEF) und die eingestellte Eclipse Riena Platform (Riena). Mit EMF lässt sich ein Datenmodell erstellen, das zum Beispiel auf UML basieren kann. GEF ist ein Projekt, dass es Entwicklern erlaubt, mit Hilfe eines existierenden Datenmodells schnell einen grafischen Editor zu erstellen. Riena unterstützt Entwickler bei der Ausstattung einer Anwendung mit einem benutzerfreundlichen Interaktionskonzept und ansprechenden Oberflächenelementen.

Basierend auf diesen Erweiterungen und dem modularen Aufbau von Eclipse selbst, lassen sich für Projekte spezifische Eclipse-Bundles erstellen. Diese enthalten alle für ein bestimmtes Projekt notwendigen Teile und Erweiterungen von Eclipse, ohne mit unnötigen Teilen Hauptspeicher und Rechenleistung zu verbrauchen.

Inzwischen gibt es auch Open Source-Erweiterungen, die eine automatisierte Bereitstellung und Konfiguration erheblich erleichtern. Dazu zählen oasp4j-ide, Oomph und Yatta Profiles, von denen ich einige in zukünftigen Beiträgen thematisiere.

Fazit

Durch den quelloffenen Ansatz und der kostenfreien Nutzungsmöglichkeit ist Eclipse neben IntelliJ eines der beliebteren IDEs. Man kann durch Plugins und Erweiterungen viele Programmiersprachen bedienen. Der Programmkern von Eclipse stellt in dem Zusammenhang die einzige versionsübergreifende Konstante dar. Jede Aktualisierung führt Neuerungen in den Kern ein und die integrierten Plugins bzw. Erweiterungen erfordern dadurch meist eine Anpassung an die neue Version.

Die grafische Oberfläche von Eclipse ist auf eine effiziente Arbeitsweise ausgerichtet. Der konzeptionelle Aufbau durch Views, Editoren und Perspektiven sorgt für eine anpassbare Optik und eine bequeme Arbeitsweise mit und in der IDE. Man kann sowohl die Funktionalitäten als auch die GUI von Eclipse durch die manuelle oder automatische Installation von Plugins bzw. Erweiterungen anpassen. Entsprechende Möglichkeiten finden sich in dem standardmäßig integrierten Market Place von Eclipse.

Der Beitrag Eclipse – Die flexible Entwicklungsumgebung erschien zuerst auf CEOsBay.

Features

Im Wesentlichen unterscheiden sich die beiden Versionen im Funktionsumfang. Hierzu von der Ultimate Version unterstützte Sprachen: Java, Groovy, Kotlin, Scala, Python and Jython, Cython, Ruby and JRuby, Rust, PHP, Go, Dart, SQL, HTML, XML, JSON, YAML, XSL, XPath, Markdown, JavaScript, TypeScript, CSS, Sass, SCSS, Less, Haml, Slim, Liquid

Wobei zu beachten ist, dass die Ultimate Edition von IntelliJ IDEA neben den nativ unterstützten Sprachen, einige der Sprachen lediglich durch den Einsatz von PlugIns unterstützt. In der Community Edition sind auch einige Sprachen gar nicht berücksichtigt. Eine explizite bzw. genaue Differenzierung möchte ich in diesem Beitrag nicht vornehmen. Also sind die Angaben bzgl. der Features mit Vorsicht zu genießen.

Auch ist zu beachten, dass lediglich die Ultimate Edition von IntelliJ IDEA die umfangreiche Framework Unterstützung mitbringt. Im Enterprise Umfeld sind diese in der Regel unabdingbar.

Auch bei den Build Tools gibt es Unterschiede. Besonders auffällig ist dabei die Tatsache, dass npm zwar in der Ultimate Edition läuft, jedoch nicht in der Community Edition. Ich habe es auch in der Community Version zum Laufen gebracht. Dennoch ist dies mit Vorsicht zu genießen, da ich aufgrund von Fehlern dennoch auf die Ultimate Edition geswitched bin.

Versionskontrolle

Auf die Funktionsfähigkeit bei der Versionskontrolle bzw. bei Cloud-basierten Diensten wie Git, GitHub, Subversion, Mercurial und Team Foundation Server kann man sich verlassen. Bei Perforce ist man zumindest in der Community Edition verlassen.

Deployment

Während die Community Edition lediglich Docker für das Deployment unterstützt sind es mit der Ultimate Edition Kubernetes, Java Applications Servers als auch Docker.

Codevervollständigung

Die Codevervollständigung ist eine Funktion, die vor allem Programmieranfängern sehr entgegenkommt. Nur wenige werden als Coder geboren, oder!? Da vergisst man schon mal schnell eine import-Anweisung, IDEA aber nicht. Meistens weist IntelliJ einen auf den Fehler hin und schlägt Korrekuren vor. Dies gilt auch für nicht verwendete Importe, die IntelliJ entsprechend einer manuellen Zustimmung entsorgt.

Es nimmt einem den Grossteil der Tipparbeit ab, damit man sich dem Programmdesign widmen kann und nicht über korrekt formulierte JAVA-Anweisungen nachdenken muss. Ich muss gestehen, dass ich mich bisher noch nicht wirklich mit JAVA auseinandergesetzt habe. Doch dies hole ich derzeit nach und auch darüber gibt es in der nahen Zukunft einen Beitrag.

Code Layout Manager

Den Code Layout Manager weiß man spätestens dann zu schätzen, wenn man im eigenen Quelltext nicht mehr durchblickt oder fremden Quelltext bearbeiten muss. Dann kann man Text markieren und von IDEA neu formatieren lassen. Dies geht relativ intelligent von statten.

Refactoring

Auch die Refactoringfähigkeiten von IntelliJ sind nicht zu unterschätzen. Wer die Funktionen einmal in Aktion erlebt hat, der möchte sie nicht mehr missen. Dazu gehören u.A. das Renaming, Move, Introduce Explaining Variable, Extract Method usw.

Fazit

Ich arbeite noch nicht lange mit dem Programm. Doch IntelliJ hat scheinbar in enger Kooperation mit den Anwendern ein relativ gutes Produkt entwickelt, mit dem man gut im Enterprise Umfeld arbeiten kann. Besonders die große PlugIn Bibliothek als auch die individuelle Erweiterbarkeit durch eine offen gelegte API haben mir persönlich sehr gefallen. Dadurch ist es auch möglich eigene PlugIns für IntelliJ zu schreiben und diese zu selbst zu implementieren.

Der Beitrag IntelliJ IDEA – Die intelligente und leistungsstarke Entwicklungsumgebung erschien zuerst auf CEOsBay.

Hintergrund von Visual Studio Code

Visual Studio Code (VS Code) ist ein plattformübergreifender Open-Source-Code-Editor von Microsoft. Er wurde erstmals im Jahr 2015 veröffentlicht und hat sich seitdem kontinuierlich weiterentwickelt. Der Editor unterstützt Windows, macOS und Linux. Es bietet Entwicklern eine nahtlose und einheitliche Erfahrung über verschiedene Plattformen hinweg.

Eine kurze Zeitreise

Visual Studio Code entstand als Teil von Microsofts Bemühungen, Entwicklern leichtgewichtige, leistungsfähige und plattformübergreifende Werkzeuge zur Verfügung zu stellen. Die Geschichte von Visual Studio Code reicht zurück bis ins Jahr 2011. Als Erich Gamma, einer der Erfinder des berühmten Design-Patterns-Buchs und der Eclipse-Plattform, bei Microsoft anfing. Zusammen mit anderen Entwicklern arbeitete er an einem Projekt namens „Project Monaco“. Es begann als Experiment, um browserbasierte Entwicklungs-Umgebungen zu erforschen.

Project Monaco fokussierte sich darauf, eine leistungsfähige, webbasierte Code-Editing-Umgebung zu schaffen. Genutzt von mehreren Microsoft-Produkten wie Azure DevOps (früher Visual Studio Online) und OneDrive. Im Laufe der Zeit vergrößerte sich das Projekt immer weiter. Das Team erkannte schon bald, dass die wachsende Codebasis und die leistungsstarken Funktionen das Zeug zu einem eigenständigen Produkt hatten.

Am 29. April 2015 stellte Microsoft Visual Studio Code erstmals während der Build-Konferenz in San Francisco vor. Es war von Anfang an als Open-Source-Projekt konzipiert und steht unter der MIT-Lizenz der Masse zur Verfügung. Seit der ersten Veröffentlichung hat VS Code eine große Entwickler-Community angezogen, die ständig zur Verbesserung des Produkts beiträgt.

Mit der Veröffentlichung von Visual Studio Code verfolgte Microsoft eine neue Strategie. Sie öffneten die Pforten zu der Technologie und zu den Werkzeugen für Entwickler aller Plattformen und Programmiersprachen. VS Code war eines der ersten Produkte, das diese neue Richtung widerspiegelte. Heute ist VS Code einer der am häufigsten verwendeten Code-Editoren. Darüber hinaus hat es dazu beigetragen, das Bild von Microsoft als Unternehmen zu verändern. Ein Bild der Offenheit und Zusammenarbeit in der Entwicklergemeinschaft.

Hauptmerkmale von Visual Studio Code

• Syntax-Hervorhebung und IntelliSense: VS Code unterstützt Syntax-Hervorhebung für eine Vielzahl von Programmiersprachen. Es bietet Entwicklern eine klar strukturierte und leicht verständliche Darstellung des Codes. IntelliSense ist eine intelligente Code-Vervollständigungsfunktion. KI-Algorithmen helfen dabei, den Code effizienter und schneller zu schreiben. Dies passiert, indem es automatisch Vorschläge für Variablen, Funktionen und andere Code-Elemente anzeigt.

• Git-Integration: Die Integration von Git ermöglicht es Entwicklern, direkt aus dem Editor heraus Änderungen am Code vorzunehmen. Sowohl das committen und mit Remote-Repositories zu synchronisieren sind möglich. Darüber hinaus erfolgt die Anzeige der Änderungen im Code direkt im Editor. Dadurch kann man leichter erkennen, was, wer, wann verändert hat.

• Debugging: VS Code bietet umfangreiche Debugging-Möglichkeiten für viele Programmiersprachen und Plattformen. Es ermöglicht das Anlegen von Breakpoints, das Verfolgen von Variablenwerten und das Ausführen von Code schrittweise. Dies hilft Entwicklern, Fehler effizienter zu finden und zu beheben.

• Anpassung und Erweiterbarkeit: VS Code ermöglicht es den Nutzern, den Editor individuell anzupassen und mit zusätzlichen Funktionen zu erweitern. Es gibt eine Vielzahl von Plugins und Erweiterungen, die man im Visual Studio Code Marketplace finden und installieren kann.

• Terminal-Integration: VS Code integriert das Terminal direkt in den Editor. Dadurch kann man problemlos Terminal Befehle direkt im Editor ausführen. Auch die Build-Tools lassen sich direkt darüber verwenden. Folglich muss man den Editor nicht verlassen, um auf die Befehlszeile zuzugreifen.

• Code-Navigation und -Refactoring: Mithilfe von Funktionen wie „Go to Definition“, „Find All References“ und „Rename Symbol“ können Entwickler ihren Code effizienter navigieren und organisieren. Diese Funktionen machen das Code-Refactoring leichter und fördern die Erstellung von sauberem, gut strukturiertem Code. Nachdem ich erst kürzlich diese Funktion in IntelliJ auch recht vorteilhaft fand noch der Verweis auf den Beitrag.

• Unterstützung von Programmiersprachen und Frameworks: VS Code unterstützt eine Vielzahl von Programmiersprachen und Frameworks. Darunter JavaScript, TypeScript, Python, C#, C++, Java, PHP, Ruby, Go, Rust und viele mehr. Dank der Unterstützung von zahlreichen Frameworks wie Angular, React, Vue.js, Django und .NET Core sind Entwickler in der Lage, in ihren bevorzugten Sprachen und Umgebungen zu arbeiten.

• Arbeitsbereiche und Multifunktionsfenster: VS Code ermöglicht das Öffnen mehrerer Projekte und Arbeitsbereiche gleichzeitig und unterstützt auch das Teilen von Fenstern, sodass man problemlos mehrere Dateien nebeneinander anzeigen und bearbeiten kann. Dies erleichtert die Zusammenarbeit an komplexen Projekten erheblich.

• Live Share: Mit der Live Share-Funktion können Entwickler ihre Arbeitsbereiche in Echtzeit mit anderen teilen und gemeinsam am Code arbeiten. Dies ist besonders hilfreich für Teamarbeit, Pair-Programming und das Lösen von Problemen gemeinsam mit Kollegen.

Fazit

Visual Studio Code ist ein mächtiges und vielseitiges Tool für Entwickler, das sich in den letzten Jahren zu einem unverzichtbaren Bestandteil der Softwareentwicklung entwickelt hat. Durch die kontinuierliche Weiterentwicklung und die Anpassungsfähigkeit des Editors befindet sich VS Code mit an der Spitze der IDE’s bzw. Code Editoren und hilft Entwicklern dabei, produktiver und effizienter zu arbeiten. Obwohl es viele großartige Funktionen in Visual Studio Code gibt, ist es wichtig, sich daran zu erinnern, dass kein Tool oder Editor perfekt ist. Davon abgesehen hat jeder Entwickler seine eigenen Präferenzen und Arbeitsweisen. Wenn man jedoch auf der Suche nach einem leistungsstarken, anpassungsfähigen und umfangreichen Code-Editor ist, kann man Visual Studio Code auf jeden Fall in Betracht ziehen.

Der Beitrag Visual Studio Code – Das leichte Schwergewicht erschien zuerst auf CEOsBay.

Maven vereinfacht den Softwareerstellungsprozess, bietet ein einheitliches System für die Entwicklerarbeit, hochwertige Projektinformationen, Richtlinien für das Festlegen von Best Practices und erleichtert die Migration zu neuen Funktionen durch mehr Transparenz. Es beschreibt sowohl, wie Software gebaut wird, als auch deren Abhängigkeiten. Apache hilft sowohl bei der Verwaltung von Projekten und dient als Tool zum Verständnis. Es hilft also dabei, den Zustand eines Projekts zu organisieren und relativ schnell darzustellen.

Primär wird das Programm von Entwicklern und Projektmanagern bei Java-Anwendungsprojekten verwendet. Das Tool kann nützlich sein, um den Zustand eines Projektes auf einem Blick für technisch weniger versierte Personen, wie Führungspersönlichkeiten und Investoren, zusammenzufassen und gleichzeitig, um einige Prozesse bei der Softwareentwicklung zu automatisieren.

Maven basiert auf dem Objektmodell. Projekte werden als eine Pom.xml-Datei gespeichert. Das Tool verwaltet Projekt-Builds, Reportings und Dokumentationen aus einer zentralen XML-Informationsbasis. Mit der Standard-Plug-in-Architektur kann man es über den Standard-Input mit so gut wie jeder Anwendung nutzen und kollaborieren. Es vereinfacht den Prozess für das Erstellen von Java-Anwendungen erheblich, sodass der Nutzer den Status des Projektes viel einfacher einschätzen kann.

Der Name Maven kommt aus dem Jiddischen und bedeutet so viel wie „Sammler des Wissens“.

Kurze Zeitreise

Maven entstand in der Apache Software Foundation aus Frust über den Build-Prozess von Turbine. Es wurde bald zum Top-Level-Projekt aufgrund der Notwendigkeit, die Builds der vielen unterschiedlichen Projekte der Apache Software Foundation möglichst zu vereinheitlichen und somit auch zu vereinfachen.

Durch die vereinheitlichten Strukturen konnten Mitglieder unterschiedlicher Entwicklungsteams zwischen den einzelnen Teilprojekten wechseln und produktivere Arbeitsergebnisse erzielen. Dank der projektübergreifenden Standardisierung war es nicht mehr notwendig, sich in komplizierte Prozesse einzuarbeiten, um das Projekt ausführen und testen zu können.

Die Entwicklung von Maven 1 wurde im Jahr 2003 begonnen und am 13. Juli 2004 als Version 1.0 veröffentlicht. Die Umsetzung wurde jedoch sehr schnell realisiert, sodass einige Eigenheiten nicht bedacht wurden. Beispielsweise gab es Probleme bei der Performance sowie einen Überschuss an Konfigurationsdateien und -angaben, die es zu beherrschen galt. 2014 wurde das End of Life (EoL) von Maven 1 verkündet. Die letzte veröffentlichte Version ist 1.1 vom 25. Juni 2007.

Im Jahr 2005 wurde parallel damit begonnen, Maven 2 zu entwickeln, welches mit Version 2.0 am 19. Oktober 2005 fertiggestellt wurde. Mit dem Major-Release 2 wurde Maven von Grund auf überarbeitet und bekannte Probleme aus der Vorgängerversion wurden behoben. Aus diesem Grund sind Maven 1 und Maven 2 untereinander inkompatibel. Am 18. Februar 2014 wurde das End of Life von Maven 2 kommuniziert. Die letzte veröffentlichte Version ist 2.2.1 aus November 2009.

Die Entwicklung von Maven 3 begann im Jahr 2008, bei der man sich insbesondere auf die Kompatibilität zwischen Maven 2 und 3 konzentrierte.

In der zweiten Hälfte des Jahres 2021 wurden die Arbeiten an Maven 4 begonnen. Eine wesentliche Verbesserung ist die stark optimierte Unterstützung von Multi-Modul-Projekten.

Wie funktioniert Maven?

Maven benötigt zur Ausführung eine Java virtuelle Maschine (JVM) und ist aufgrund dieses Umstandes plattformunabhängig. Aus diesem Grund kann es auf jedem Betriebssystem ausgeführt werden, für das eine Java VM verfügbar ist.

Der Kern von Maven ist mit wenigen Megabyte als Paket kompakt gehalten. Die interne Struktur ist modular aufgebaut. Sämtliche Funktionen werden über Erweiterungen, sogenannte Plugins, bei der erstmaligen Verwendung über ein öffentliches im Internet verfügbares Repository, Maven Central genannt, nachgeladen und in einem lokalen Repository abgelegt.

Maven ist deklarativ und basiert auf zwei wesentlichen Paradigmen. Zum einen auf „Don’t Repeat Yourself“ (DRY bzw. Wiederhole dich nicht selbst) bedeutet sinngemäß im Kontext von Maven, dass man nicht bei jedem Projekt dieselben Build-Schritte neu definiert muss. Und auf „Convention over Configuration“ (CoC bzw. Konvention vor Konfiguration). Dies bezieht sich auf die Konfigurationsdatei (POM), mit denen Maven-Projekte beschrieben werden. Durch festgelegte Konventionen haben möglichst viele Konfigurationseinträge gemeingültige Vorbelegungen (Default-Werte), die für die meisten Anwendungsfälle bereits die erwünschten Ergebnisse produzieren.

Maven folgt den beiden beschriebenen Paradigmen über den gesamten Zyklus der Softwareerstellung konsequent. Eine wichtige Voraussetzung für eine erfolgreiche Automatisierung der einzelnen Schritte des Softwareerstellungsprozesses sind strikte Vereinheitlichungen, wie sie durch die beiden Paradigmen DRY und CoC geschaffen werden.

Obwohl Maven bereits sehr viele Vorgaben liefert, können Projekte diese Vorgaben an ihre tatsächlichen Bedürfnisse anpassen. Sowohl für künftige neuere Versionen von Maven als auch bei der Anbindung von Drittanbieterprodukten ist es eine bewährte Praxis, möglichst nahe am Maven-Standard zu bleiben.

Wichtige Begriffe bei der Arbeit mit Maven

Im Zusammenhang mit Maven werden wichtige Begriffe verwendet, mit denen man vertraut sein sollte, um effektiv damit zu arbeiten:

• Artifacts (Artefakte) Diese werden in Maven sowohl Plugins als auch Abhängigkeiten zu externen Programmbibliotheken und die selbst erstellten binären Programmdateien des eigenen Softwareprojektes bezeichnet.
• Lifecycles (Lebenszyklen) Dies kann auch als Workflow oder Prozess verstanden werden. Maven kennt drei Lifecycles: „clean“, „site“ und „build“.
• Phases (Phasen) In diesen werden die einzelnen Schritte innerhalb eines „Lifecycles“ bezeichnet, die in festgelegter linearer Reihenfolge durchlaufen werden. Der Build-Lifecycle Default kennt 23 Schritte.
• Goals (Ziele) Sind einzelne Aktionen bzw. Funktionalitäten, die in einem Plugin bereitgestellt werden.
• Archetypes (Archetypen) In diesen können Gerüste für unterschiedlichste Arten von Softwareprojekten erstellt werden, deren Struktur dem Standard von Maven entspricht. Was auch als ein wesentliches Merkmal von Maven-Projekten ist. Die einheitliche Verzeichnisstruktur, auf die ich nachfolgend eingehen werde.

Verzeichnisstruktur

my-project/ – Wurzelverzeichnis

pom.xml – Projektbeschreibung (Build-Logik)

src/ – alle Eingabedateien

main/ – Eingabedateien für die Erstellung des eigentlichen Produkts

java/ – Java-Quelltext-Dateien

resources/ – Projektdateien, die kein Java-Quellcode sind, aber für die Übersetzung oder zur Laufzeit benötigt werden, z. B. Bilder, SQL, Java-Properties-Dateien etc.

test/ – Eingabedateien, die für automatisierte Testläufe benötigt werden

java/ – Testfälle, die als Java-Quellcode vorliegen, z. B. JUnit-Testfälle

resources/ – Zusätzliche Ressourcen für Testfälle

target/ – Alle durch Maven während des Build-Vorgangs erstellten Dateien

classes/ – kompilierte Java-Klassen

Die Konfigurationsdatei „pom.xml“

Die Konfigurationsdatei für Maven-Projekte hat die offizielle Bezeichnung „Project Object Model (POM)“und ist als pom.xml im Wurzelverzeichnis des Projektes abgelegt. Im Kontext des Build-Managements ist die pom.xml die Build-Logik, die von externen Werkzeugen wie dem Automatisierungsserver Jenkins aufgerufen wird. Über Jenkins habe ich bereits geschrieben.

Die zwingenden Basisangaben für ein Projekt innerhalb einer POM sind die sogenannten GAV-Parameter, zuzüglich des Packagetyps. GAV steht für (G) = GroupID, (A) = ArtifactId und (V) = Version. Die GAV-Koordinaten müssen für jedes Projekt eindeutig sein und dürfen nicht mehrfach Verwendung finden.

Abhängigkeiten bzw. (Dependency Management)

Einer der wichtigsten Faktoren für den Erfolg von Maven ist der einfache Umgang mit fremden Abhängigkeiten, sogenannten 3rd Party Libraries. Externe Abhängigkeiten werden in der pom.xml notiert und über ihre GAV-Koordinaten eindeutig und transitiv aufgelöst. Die definierten Abhängigkeiten werden nicht physisch in die Versionsverwaltung mit aufgenommen, sondern während des Buildvorgangs im Projekt-Ausgabeverzeichnis target bereitgestellt.

Bei der Verwendung eines Artefaktes prüft Maven, ob es bereits lokal im Repository vorhanden ist. Das lokale Repository ist ein verstecktes Verzeichnis mit der Bezeichnung .m2/repository und findet sich im home-Verzeichnis des am Betriebssystem angemeldeten Nutzers.

Wird von Maven das angeforderte Artefakt im lokalen Repository nicht gefunden, wird in einem öffentlichen Remote-Repository danach gesucht. Bei erfolgreicher Suche wird das Artefakt im lokalen Repository verfügbar gemacht. Das Wichtigste öffentlich frei verfügbare Repository für Java-Artefakte lautet „Maven Central“ und wird von dem Unternehmen Sonatype betrieben.

Es besteht die Möglichkeit, einen eigenen Repository-Server zu betreiben, um selbst erstellte Artefakte im Unternehmen bzw. im Intranet für andere Projekte bereitzustellen oder diese über das Internet zur Verfügung zu stellen.

Wichtige Implementierungen zum Hosten eigener Artefakte sind Sonatype Nexus OSS oder JFrog Artifactory, für die es sowohl freie Community Versionen als auch kommerzielle Enterprise-Varianten gibt. Diese Lösungen können neben den verschiedenen Java-Artefakten auch andere Formate wie beispielsweise Docker Images, RubyGems, .NET nuget oder NPM verwalten. Maven Central, das größte Open-Source-Repository, wird mit Nexus OSS betrieben.

Maven-Lebenszyklen (Lifecycles)

Wie bereits vorher erwähnt, kommen in einem Maven Workflow verschiedene Lebenszyklen zum Einsatz. Diese sind:

• clean (Zum Löschen von Ergebnissen vorheriger Builds, mit den Phasen pre-clean, clean, post-cl
• build (default) (Zum Erstellen eines Projekts im Rahmen der verschiedenen Phasen
• site (Zum Erstellen von Webseiten zur Projektdokumentation und Reports, mit den Phasen pre-site, site, post-site, site-deploy.

Maven geht dabei jeweils von einem Zyklus aus, der bei der Softwareerstellung im Allgemeinen durchlaufen wird. Es muss aber nicht jedes Softwareprojekt alle Phasen des im Folgenden verkürzt dargestellten Default-Zyklus verwenden. Die Standardfunktionalität kann durch die Einbindung von zusätzlichen Plug-ins an die entsprechende Phase erweitert werden.

• validate bzw. validieren (Es wird überprüft, ob die pom.xml und die Projektstrukturen vollständig, valide und gültig sind.
• compile bzw. kompilieren (In dieser Phase wird der Quellcode kompiliert.
• test bzw. testen (Hier wird der kompilierte Code durch das eingebundene Unit-Test-Framework (z. B. JUnit, TestNG) getestet. Maven berücksichtigt dabei in späteren Zyklen, dass Testklassen normalerweise nicht in der auszuliefernden Software vorhanden sind.
• package bzw. verpacken (Das Kompilat wird – ggf. mit anderen nicht kompilierbaren Dateien – zur Weitergabe verpackt. Häufig handelt es sich dabei um eine JAR-Datei.
• integration-test bzw. Integrationstests (Bereitstellen der programmatisch erstellten Integrationstests mittels Behavior Driven Development (z. B. Cucumber, jGiven).
• verify bzw. Gültigkeitsprüfung des Softwarepakets (Überprüfung der Artefakte, ob die festgelegten Spezifikationen erfüllt wurden, D.H. die bereitgestellten Integrationstests werden ausgeführt.
• install bzw. das Kopieren in die lokale Maven-Repository (Kopiert das Softwarepaket ins lokale Maven-Repository, um es dann in anderen lokalen Maven-Projekten verwenden zu können. Dies ist insbesondere für modulare Projekte von Bedeutung.
• deploy bzw. anwenden (Lädt das Softwarepaket in ein entferntes Maven-Repository hoch, wonach es auch anderen Entwicklern global zur Verfügung steht.

Fazit

Hierbei kann man sich relativ kurzfassen. Ein Software-Projekt sollte stehts mit einem vernünftigen Buildmanagement ausgestattet sein. Das Open-Source-Tool bietet sich dabei vor allem bei Java-Projekten an, zumal es selbst auf Java basiert. Es ist ebenso möglich, Maven durch selbst entwickelte Plugins zu erweitern. Aufgrund dieser Eigenschaft wird es auch als Plugin Execution Framework bezeichnet. Man kann damit die Kollaboration bei der Entwicklung durch Programmierer und Projektmanager mit verschiedensten Skill-Sets wesentlich erleichtern bzw. vereinfachen.

Der Beitrag Apache Maven – Projekte inklusive Abhängigkeiten mühelos verwalten erschien zuerst auf CEOsBay.