Was ist ein Generic Code Editor (GCE)?

Ein Generic Code Editor ist ein universeller Code-Editor, der eine Vielzahl von Programmiersprachen unterstützt, ohne sich auf eine bestimmte Umgebung oder Sprache zu spezialisieren. Seine Hauptmerkmale sind:

• Syntax-Highlighting für verschiedene Sprachen
• Autovervollständigung für besseren Workflow
• Erweiterbarkeit durch Plugins
• Plattformunabhängigkeit für eine flexible Nutzung
• Leichtgewichtige Performance, ohne eine komplexe Projektverwaltung

Ein Generic Code Editor ist kein vollständiges Entwicklungswerkzeug, sondern ein flexibler Editor zur Bearbeitung von Code in mehreren Sprachen. Er eignet sich besonders für schnelle Änderungen an Code-Dateien, Skripte oder für Entwickler, die in mehreren Programmiersprachen arbeiten.

Vorteile eines Generic Code Editors

1. Flexibilität – Unterstützt verschiedene Sprachen ohne spezielle Anpassungen.
2. Leichtgewichtigkeit – Schneller Start und geringe Systemanforderungen.
3. Erweiterbarkeit – Plugins und Erweiterungen können individuell hinzugefügt werden.
4. Plattformunabhängig – Funktioniert auf Windows, macOS und Linux.
5. Kein Overhead – Keine komplexen Projektkonfigurationen notwendig.

Bekannte Generic Code Editors

• Visual Studio Code (VS Code) – Sehr populär mit einer großen Erweiterungsbibliothek. (Siehe auch meinen Beitrag „Visual Studio Code – Das leichte Schwergewicht„)
• Atom – Open-Source-Editor von GitHub (War eines meiner Lieblingseditoren, wird allerdings nicht mehr aktiv weiterentwickelt).
• Sublime Text – Leichtgewichtig, schnell und mit guter Plugin-Unterstützung. (Aktuell eines meiner Lieblingseditoren auf macOS)
• Notepad++ – Einfacher, schneller Editor mit grundlegenden Funktionen. (Aktuell eines meiner Lieblingseditoren auf Windows)
• Vim/NeoVim – Terminal-basierter Editor mit hoher Anpassbarkeit. (Aktuell eines meiner Lieblingseditoren auf Linux-Systemen wie KALI, Debian und Ubuntu)

Vergleich: GCE vs. IDE

Was zählt nicht als Generic Code Editor?

Einige Entwicklungsumgebungen unterstützen zwar mehrere Sprachen, sind aber keine GCEs, weil sie mehr als nur reine Code-Bearbeitung bieten. Dazu gehören:

1. IntelliJ IDEA – Die Power-IDE für Java & Co.

IntelliJ IDEA von JetBrains ist primär für Java und Kotlin entwickelt, unterstützt jedoch durch Plugins viele weitere Sprachen. Es bietet:

• Automatisches Refactoring für sauberen Code
• Integrierten Debugger zur Fehleranalyse
• Projektmanagement mit Build-Tools (Maven, Gradle)
• Intelligente Code-Analyse zur Fehlererkennung
• Version Control (Git, SVN) direkt integriert

2. Visual Studio – Microsofts leistungsstarke Entwicklungsumgebung

Visual Studio ist besonders für .NET- und C#-Entwicklung optimiert, unterstützt aber auch C++, Python und andere Sprachen. Seine Merkmale umfassen:

• Integrierte Compiler & Debugging-Tools
• Automatische Code-Generierung & AI-gestützte Features
• GUI-Designer für App-Entwicklung
• Umfassendes Projektmanagement mit Solution Explorer

Was ist mit Visual Studio Code?

Eine interessante Ausnahme ist Visual Studio Code (VS Code). Es ist leichter als Visual Studio, unterstützt viele Sprachen und wird oft als Generic Code Editor genutzt. Durch Erweiterungen kann es jedoch zu einer fast vollständigen IDE ausgebaut werden.

Wann solltest du einen GCE statt einer IDE nutzen?

Ein Generic Code Editor eignet sich besonders, wenn du:

• Mit vielen verschiedenen Programmiersprachen arbeitest und schnelle Bearbeitung benötigst.
• Kein vollständiges Projektmanagement brauchst, sondern nur einzelne Dateien editieren möchtest.
• Leichtgewichtige Tools bevorzugst, die nicht viele Ressourcen verbrauchen.
• Oft in Terminal- oder Cloud-Umgebungen arbeitest und keinen GUI-basierten Editor benötigst.

Fazit: GCE oder IDE?

Ein echter Generic Code Editor ist leichtgewichtig, universell und nicht an eine bestimmte Sprache oder Umgebung gebunden. IntelliJ IDEA und Visual Studio hingegen sind vollständige IDEs mit Debugging- und Projektmanagement-Funktionen, die über die Eigenschaften eines GCE hinausgehen.

Wenn du also nach einem leistungsstarken Entwicklungswerkzeug mit Debugging und Projektmanagement suchst, sind IntelliJ IDEA oder Visual Studio großartige Optionen. Falls du hingegen einen flexiblen, leichtgewichtigen Editor für mehrere Sprachen möchtest, sind VS Code, Sublime Text oder Vim die bessere Wahl.

Der Beitrag Generic Code Editors – Flexibel, Leicht & Vielseitig erschien zuerst auf CEOsBay.

Grundlagen Inkrementelles Entwicklungsmodell

Das inkrementelle Entwicklungsmodell basiert auf der Idee, ein umfangreiches Softwareprojekt in kleinere, handhabbare Teile zu zerlegen. Entwickler implementieren diese Teile in aufeinanderfolgenden Phasen, wobei jedes Inkrement auf dem vorherigen aufbaut und es erweitert. Diese Vorgehensweise ermöglicht eine frühzeitige Auslieferung von Teilfunktionalitäten, was wiederum eine schnelle Rückmeldung von den Endnutzern erlaubt. Die konsequente Einbindung von Nutzerfeedback in den Entwicklungsprozess führt zu einer höheren Benutzerzufriedenheit und ermöglicht eine effektivere Fehlerbehebung.

Ursprung und Entwicklung

Die Ursprünge des inkrementellen Entwicklungsmodells liegen in den 1960er und 1970er Jahren. Als Softwareingenieure nach flexibleren Alternativen zu den bis dahin vorherrschenden, starren Entwicklungsmodellen suchten. Das inkrementelle Modell bildete eine Antwort auf die wachsenden Anforderungen an Softwarelösungen. Besonders, die Notwendigkeit, sich schnell an veränderte Benutzeranforderungen und Marktbedingungen anzupassen.

Optimale Anwendungsmethoden

Für eine erfolgreiche Anwendung des inkrementellen Entwicklungsmodells gilt es, einige Schlüsselelemente zu berücksichtigen:

1. Klare Definition der Inkremente: Teams sollten jedes Inkrement klar definieren und festlegen, welche Funktionen es umfasst.
2. Kontinuierliche Integration und Testing: Die kontinuierliche Integration neuer Inkremente und deren umfassendes Testing sind unerlässlich. Dadurch lassen sich Fehler frühzeitig identifizieren und somit die Softwarequalität sichern. (Siehe meinen Beitrag über CI/CD – Continuous Integration und Continuous Deployment.)
3. Nutzerfeedback einbeziehen: Entwicklerteams müssen Nutzerfeedback aktiv einfordern und in den Entwicklungsprozess integrieren, um die Software stetig zu verbessern.

Inkrementelles Entwicklungsmodell Beispiele aus der Praxis

1. Mobile Applikationen: Bei der Entwicklung mobiler Apps hat sich das inkrementelle Modell als besonders effektiv erwiesen. Entwicklerteams können einzelne Funktionen wie Benutzeranmeldung, Profilerstellung und Nachrichtenfunktion in separaten Inkrementen implementieren und ausliefern.
2. Web-Plattformen: Auch im Bereich der Web-Entwicklung findet das inkrementelle Modell breite Anwendung. Beispielsweise kann ein E-Commerce-Unternehmen seinen Online-Shop schrittweise um Funktionen wie Produktsuche, Warenkorb und Zahlungsabwicklung erweitern.

Fazit

Ein inkrementelles Entwicklungsmodell stellt einen flexiblen und effizienten Ansatz in der Softwareentwicklung dar. Durch die Zerlegung des Gesamtprojekts in kleinere Teile, die man schrittweise implementiert und testet, ermöglicht eine schnelle Reaktion auf Benutzerfeedback und sich verändernde Anforderungen. Zahlreiche Erfolgsbeispiele aus der Praxis belegen die Effektivität dieses Modells. Dies macht es zu einer attraktiven Wahl für Softwareentwicklungsprojekte unterschiedlichster Art.

Der Beitrag Inkrementelles Entwicklungsmodell – Kleine Schritte, große Fortschritte erschien zuerst auf CEOsBay.

Übrigens ist BDD aus der testgetriebenen Entwicklung hervorgegangen. Über BDD bzw. Behavior Driven Development habe ich bereits gestern geschrieben.

Klassisch und fast schon nostalgisch hat man und praktiziert man die Entwicklung heute noch nach dem Wasserfall- oder dem V-Modell-Prinzip. Man entwickelt die Tests parallel zum und unabhängig vom zu testenden System oder sogar erst nachdem die Anwendung „fertiggestellt“ wurde. Aufgrund dieser Tatsache resultiert meist daraus, dass der Code schwer testbar ist und somit der Aufwand für die Tests verhältnismäßig hoch ausfällt. Darüber hinaus kommt es auch vor, dass die Tests nicht die gewünschten oder erforderlichen Testabdeckungen und Ergebnisse liefern, die man sich erhofft.

Dies kann unter anderem daran liegen, dass die fehlende oder mangelnde Testbarkeit des Systems auf die Nutzung von Fremdkomponenten zurückzuführen ist. Auch die Verweigerung einer Investition in nicht-funktionale Programmteile seitens der Entscheider bzw. Unternehmensführung kann ein Grund dafür sein. So im Sinne von, „Arbeit, von der man später im Programm nichts sieht, seien vergeudete Ressourcen.“ Die Erstellung von Tests unter Zeitdruck, rein um die gewünschte Testabdeckung zu erzielen ist ebenfalls ein Grund dafür. Nicht selten, ist es aber auch die Nachlässigkeit und mangelnde Disziplin der Entwickler bei der Testerstellung. An dieser Stelle sein auch das White-Box-Testing zu erwähnen, den ich aber in einem zukünftigen Beitrag thematisieren werde.

Die Methode der testgetriebenen Entwicklung versucht den Nachteilen entgegenzuwirken und dabei auch ein auf die Aufgabenstellung der Software besser angepasstes und wartbareres Softwaredesign zu liefern.

Alles in allem ist es eine Tatsache, dass man bei der Anwenung von testgetriebener Entwicklung im Schnitt bis zu 45 Prozent aller Fehler erkennen bzw. vermeiden kann. Im Vergleich dazu, werden beim reinen Einsatz von Unittests im Schnitt nur bis zu 30 Prozent der Fehler erkannt.

Wie funktioniert TDD?

Bei der testgetriebenen Entwicklung ist zwischen dem Testen im Großen (Integrationstests, Systemtests, Akzeptanztests) und dem Kleinen Modultests (Unit Tests) zu unterscheiden.

Testgetriebene Entwicklung mit Unit-Tests (Stichwort Tests First bzw. Middle-Out-TDD)

Man schreibt Unit-Tests in der Regel vor der eigentlichen Entwicklung der Anwendung. Es ist nicht festgelegt, ob der Entwickler, der die Implementierung vornimmt, auch die Unit-Tests erstellt. Es ist erlaubt, dass mehrere fehlschlagende Unit-Tests gleichzeitig existieren. Die Umsetzung des von einem Unit-Test geforderten Verhaltens in der Anwendung kann zeitlich verschoben werden.

Die Methode Tests First kann als Vorstufe der testgetriebenen Entwicklung betrachtet werden.

TDD nach Kent Beck

Man entwickelt Unit-Tests und die mit ihnen getesteten Units stets parallel. Die eigentliche Entwicklung erfolgt in kleinen, wiederholten Mikroiterationen. Eine solche Iteration, die nur wenige Minuten dauern sollte, hat drei Hauptteile, die man im englischen schlicht als Red, Green und Refactor bezeichnet.

1. Red: Schreibe einen Test, der ein neues zu programmierendes Verhalten (die Funktionalität) prüfen soll. Dabei fängt man mit dem einfachsten Beispiel an. Ist die Funktion schon älter, kann dies auch ein bekannter Fehler oder eine neu zu implementierende Funktionalität sein. Dieser Test wird vom vorhandenen Programmcode erst einmal nicht erfüllt und muss folglich fehlschlagen.
   
2. Green: Ändere den Programmcode mit möglichst wenig Aufwand ab und ergänze ihn, bis er nach dem anschließend angestoßenen Testdurchlauf alle Tests besteht.
   
3. Räume dann im Code auf (Refactoring): Entferne Wiederholungen (Duplizierten Code), abstrahiere wo nötig, richte ihn nach den verbindlichen Code-Konventionen aus. In dieser Phase darf kein neues Verhalten eingeführt werden. Nach jeder Änderung werden die Tests ausgeführt. Der Fehlschlag der Tests verbietet es, die offenbar fehlerhafte Änderung in den bereits genutzten Code zu übernehmen. Ziel des Aufräumens ist es, den Code schlicht, elegant und verständlich zu machen.

Diese drei Schritte wiederholt man so lange und so oft, bis die bekannten Fehler bereinigt sind, der Code die gewünschte Funktionalität liefert und dem Entwickler keine sinnvollen weiteren Tests mehr einfallen, die vielleicht noch scheitern könnten. Die so behandelte programmtechnische Einheit (Unit) wird dann als einstweilen fertig angesehen. Die gemeinsam mit ihr geschaffenen Tests werden beibehalten, damit auch nach künftigen Iterationen und Änderungen getestet werden kann, ob die schon erreichten Aspekte des Verhaltens weiterhin erfüllt werden.

Damit die – auch Transformationen genannten – Änderungen in Schritt 2 zum Ziel führen, muss jede Änderung zu einer allgemeineren Lösung führen. Sie darf also nicht etwa nur den aktuellen Testfall auf Kosten anderer behandeln. Tests, die immer mehr ins Detail gehen, treiben den Code so zu einer immer allgemeineren Lösung. Die Beachtung der Transformationsprioritäten führt dabei regelmäßig zu effizienteren Algorithmen und damit Anwendungen. Die konsequente Befolgung dieser Vorgehensweise ist eine evolutionäre Entwurfsmethode, indem jede der einzelnen Änderungen bzw. Iterationen das System von Natur aus weiterentwickelt.

Testgetriebene Entwicklung mit System- oder Akzeptanztests (Stichwort Outside-In-TDD)

Wie bereits erwähnt, entwickelt man Systemtests bei der testgetriebenen Entwicklung immer vor dem System selbst oder aber man erstellt zumindest das Konzept dafür. Aufgabe der Systementwicklung ist bei testgetriebener Entwicklung nicht mehr, wie klassisch, schriftlich formulierte Anforderungen zu erfüllen, sondern spezifizierte Systemtests zu bestehen.

Akzeptanztestgetriebene Entwicklung (ATDD)

ATDD ist zwar mit testgetriebener Entwicklung verwandt, unterscheidet sich jedoch in der Vorgehensweise von testgetriebener Entwicklung. Akzeptanztestgetriebene Entwicklung ist ein Kommunikationswerkzeug zwischen dem Kunden bzw. den Anwendern, den Entwicklern und den Testern. Es soll sicherstellen, dass die Anforderungen gut beschrieben sind. Akzeptanztestgetriebene Entwicklung verlangt keine Automatisierung der Testfälle, wenngleich diese für das Regressionstesten hilfreich sind. Die Tests bei akzeptanztestgetriebener Entwicklung müssen dafür auch für Nicht-Entwickler lesbar sein. Die Tests der testgetriebenen Entwicklung können in vielen Fällen aus den Tests der akzeptanztestgetriebenen Entwicklung abgeleitet werden.

Der Beitrag TDD – Test Driven Development – Qualitativ hochwertige Software von Anfang an 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.