Was ist der Systemtest im Software Testing?

Im Kontext des Software Testings ist der Systemtest eine Teststufe, bei der man das komplette und vollintegrierte Softwareprodukt testet. Dabei prüft man, ob das System als Ganzes die spezifizierten Anforderungen erfüllt und ob alle Komponenten effizient zusammenarbeiten. Neben funktionalen Aspekten beinhaltet der Systemtest auch nicht-funktionale Aspekte wie Leistung, Sicherheit und Benutzerfreundlichkeit.

Systemtests unterscheiden sich von anderen Teststufen, insbesondere von den Unit-Tests und Integrationstests, in ihrem Fokus. Während Unit-Tests einzelne Softwarekomponenten (z.B. Funktionen oder Methoden) testen und Integrationstests die korrekte Interaktion von Komponenten überprüfen, konzentriert sich der Systemtest auf das gesamte Softwareprodukt.

Kurze Zeitreise und ein historischer Überblick über den Systemtest

Die genaue Herkunft des Systemtests als Testmethode lässt sich schwer auf eine einzelne Person oder ein bestimmtes Ereignis zurückführen. Es ist jedoch allgemein anerkannt, dass die Praxis des Software Testings und insbesondere der Systemtests mit der Entwicklung der Softwaretechnik einherging.

In den frühen Tagen der Computertechnik, als man Software noch von Hand mittels Lochkarten programmierte, gab es wenig Bedarf für systematische Tests. Fehler wurden oft „on-the-fly“ während des Betriebs behoben. Mit zunehmender Komplexität der Software und der Entwicklung von höheren Programmiersprachen wurde jedoch ein systematischer Ansatz zur Fehlervermeidung und -erkennung notwendig.

Einen wichtigen Meilenstein für die Entwicklung des Software Testings stellt das Jahr 1972 dar. In diesem Jahr veröffentlichte die US-amerikanische Software-Ingenieurin und Computerwissenschaftlerin Glenford J. Myers das Buch „The Art of Software Testing“, das als eines der ersten umfassenden Werke zum Thema Software Testing gilt. Auch wenn man Myers nicht explizit als „Erfinder“ der Systemtests bezeichnen kann, so hat doch seine Arbeit maßgeblich dazu beigetragen, das Bewusstsein für die Notwendigkeit des Software Testings und die Entwicklung von standardisierten Testverfahren zu schärfen.

Aktueller Stand der Systemtests

Die Praxis des Systemtests hat sich in den letzten Jahrzehnten weiterentwickelt und professionalisiert. Die Einführung von agilen Methoden in der Softwareentwicklung und das Aufkommen von DevOps haben die Art und Weise, wie Software getestet wird, verändert und den Systemtest weiter in den Mittelpunkt gerückt. Heute ist der Systemtest ein integraler Bestandteil jedes seriösen Softwareentwicklungsprozesses.

Aktuell gibt es verschiedene Tools und Frameworks zur Unterstützung von Systemtests. Dazu gehören sowohl kommerzielle Lösungen als auch Open-Source-Werkzeuge. Mit deren Hilfe kann man Tests automatisiert durchführen und Testergebnisse dokumentieren.

Welche Software-Lösungen gibt es?

Selenium, ein Open-Source–Framework für automatisiertes Testen, JUnit, ein Framework zum Testen von Java-Anwendungen, TestComplete, eine kommerzielle Lösung für automatisiertes Testen, Postman, ein Tool für API-Tests, LoadRunner, eine kommerzielle Lösung für Leistungs- und Lasttests, und Appium, ein Open-Source-Tool für das automatisierte Testen von mobilen Anwendungen.

Fazit

Im Hinblick auf die Zukunft ist zu erwarten, dass die Bedeutung des Systemtests weiter zunehmen wird. Insbesondere vor dem Hintergrund der fortschreitenden Digitalisierung und der damit einhergehenden Komplexität von Software werden zuverlässige und effiziente Testverfahren immer wichtiger.

Insgesamt trägt der Systemtest dazu bei, die Qualität von Software zu sichern und eine zuverlässige und effiziente Leistung des Softwareprodukts zu gewährleisten. Dabei hat er sich seit seinen Anfängen stetig weiterentwickelt und wird auch in Zukunft ein zentraler Bestandteil des Software Testings bleiben.

Der Beitrag Systemtest – Im Software Testing erschien zuerst auf CEOsBay.

Hauptmerkmale von Vue.js

• Leichtgewichtig und Modularität: Vue.js ist für seine geringe Größe bekannt, wobei die kompilierte und gzip-komprimierte Version gerade einmal 20 KB wiegt. Das Framework ist in verschiedene Module unterteilt, sodass Entwickler nur diejenigen auswählen müssen, die sie für ihr Projekt benötigen, um den Overhead gering zu halten.
• Progressive Anpassung: Vue.js ist als progressives Framework konzipiert, was bedeutet, dass man es schrittweise in bestehende Projekte implementieren kann. Es ermöglicht Entwicklern, bestehenden Anwendungen schrittweise Verbesserungen hinzuzufügen, ohne die gesamte Anwendung neu schreiben zu müssen.
• Reaktive Datenbindung: Eine der Hauptstärken von Vue.js ist die reaktive Datenbindung. Dies bedeutet, dass die Übertragung aller Änderungen auf die Benutzeroberfläche automatisch stattfindet, ohne dass der Entwickler explizit eingreifen muss.
• Single-File-Komponenten: Vue.js bietet eine einfache Möglichkeit, wiederverwendbare Komponenten zu erstellen, indem HTML, JavaScript und CSS via Kapselung in einer einzigen .vue-Datei zusammengefasst sind. Diese Tatsache vereinfacht die Strukturierung und Wartung von Projekten maßgeblich.
• Declarative Rendering: Mit Vue.js können Entwickler deklarativ angeben, wie die Anwendung auf der Grundlage der zugrunde liegenden Daten rendert. Diese Herangehensweise verbessert die Lesbarkeit und Wartbarkeit des Codes, indem sie sich auf die Logik und das Verhalten der Anwendung konzentriert, anstatt auf die Implementierungsdetails.
• Hervorragende Dokumentation und Community: Die offizielle Dokumentation von Vue.js ist umfassend und gut organisiert, was den Einstieg in das Framework wesentlich erleichtert. Die Vue.js-Community ist aktiv und wächst stetig, was zu einer Vielzahl von Ressourcen, Plugins und Erweiterungen führt, die Entwicklern zur Verfügung stehen.

Warum Vue.js für Webentwickler von Vorteil ist

• Einfache Einarbeitung: Im Vergleich zu anderen Frameworks wie Angular oder React, ist die Lernkurve relativ flach. Dies ermöglicht neuen Entwicklern einen schnellen Einstieg, während erfahrene Entwickler leicht von anderen Frameworks umsteigen können.
• Flexibilität und Skalierbarkeit: Aufgrund der modularen Architektur und progressiven Anpassung eignet sich Vue.js sowohl für kleine als auch für große Projekte. Entwickler können es sowohl für einfache Widgets als auch für komplexe Anwendungen verwenden. Man kann es problemlos in bestehende Projekte integrieren oder als Grundlage für neue Projekte verwenden.
• Verbesserte Produktivität: Durch die Verwendung von Single-File-Komponenten und reaktiven Datenbindungen ermöglicht Vue.js Entwicklern, schneller und effizienter zu arbeiten. Weniger Zeit wird für die Aktualisierung des UI-Codes und die Synchronisierung von Daten aufgewendet, was zu einer höheren Produktivität führt.
• Vast Ecosystem: Das Vue.js-Ökosystem umfasst eine breite Palette von Tools, Bibliotheken und Erweiterungen, die die Entwicklung von Anwendungen beschleunigen und vereinfachen. Beispiele hierfür sind das Vue CLI (Command Line Interface), Vuex für State Management und das Vue Router-Modul für die Navigation.
• Aktive Entwicklung und Wartung: Die Weiterentwicklung und Wartung erfolgt stetig. Folglich kann man immer mit zeitgemäßen neuen Funktionen und Verbesserungen rechnen. Dies stellt sicher, dass das Framework auf dem neuesten Stand der Webentwicklungstechniken bleibt und gleichzeitig sicher und stabil ist.

Fazit

Vue.js hat sich als vielseitiges und leistungsstarkes JavaScript–Framework etabliert, das Entwicklern ermöglicht, auf einfache Weise schnelle und skalierbare Webanwendungen zu erstellen. Mit seinen progressiven Anpassungsmöglichkeiten, reaktiven Datenbindungen und einem wachsenden Ökosystem ist es ein ausgezeichnetes Werkzeug für Webentwickler, unabhängig von ihrem Erfahrungsstand. Die einfache Einarbeitung und Flexibilität von Vue.js machen es zu einer attraktiven Wahl für Entwickler, die nach einer modernen Lösung für die Webentwicklung suchen.

Der Beitrag Vue.js – Das progressive JavaScript Framework erschien zuerst auf CEOsBay.

Was ist ein Test-Harnisch?

Ein Test-Harnisch (engl. test harness) ist ein Framework oder eine Sammlung von Tools, die dazu beitragen, das Testen von Softwareanwendungen zu automatisieren, zu koordinieren und zu überwachen. Im Wesentlichen stellt ein Test-Harnisch eine Umgebung bereit, in der Entwickler und Tester den Code einer Anwendung testen und sicherstellen können, dass er korrekt funktioniert und die Anforderungen erfüllt. Man kann Test-Harnische sowohl für manuelles als auch für automatisiertes Testen verwenden.

Funktionsweise eines Test-Harnisch

Ein Test-Harnisch besteht aus vier Hauptkomponenten:

1. Testtreiber: Der Testtreiber ist für die Ausführung der Tests verantwortlich. Er stellt die Schnittstelle zur Verfügung, über die die Tester die Testfälle ausführen und die Ergebnisse erfassen können.
2. Testdaten: Testdaten sind die Eingaben, die man während des Testprozesses verwendet. Sie bestehen in der Regel aus verschiedenen Datentypen, die man verwendet, um die verschiedenen Funktionen und Komponenten der Anwendung zu testen.
3. Testskripte: Testskripte sind Skripte, die den Testprozess automatisieren. Sie enthalten Anweisungen, wie die Tests ausgeführt und die Analyse der Ergebnisse stattfinden soll.
4. Testergebnisse: Testergebnisse sind die gesammelten Informationen, die aus dem Testprozess resultieren. Sie enthalten Daten über die Leistung der Anwendung, Fehler, die während des Testprozesses aufgetreten sind, und Informationen über die Korrektheit der Funktionen.

Vorteile von Test-Harnischen

• Automatisierung: Test-Harnische automatisieren den Testprozess und reduzieren so den Zeitaufwand und die Mühe, die mit manuellem Testen verbunden sind. Dies ermöglicht es Entwicklern und Testern, sich auf die Analyse der Testergebnisse und die Verbesserung der Softwarequalität zu konzentrieren.
• Wiederverwendbarkeit: Test-Harnische ermöglichen es, Testfälle und Testdaten wiederverwendbar zu gestalten, sodass man sie in verschiedenen Projekten und Anwendungen einsetzen kann.
• Vereinfachung: Test-Harnische vereinfachen den Testprozess, indem sie alle Testaktivitäten zentralisieren und eine einheitliche Testumgebung bereitstellen.
• Effizienz: Test-Harnische steigern die Effizienz des Testprozesses, indem sie die Testabdeckung erhöhen, den Testaufwand reduzieren und eine schnellere Fehlerbehebung ermöglichen.
• Kontinuierliche Integration: Test-Harnische unterstützen kontinuierliche Integration (CI) und kontinuierliche Bereitstellung (CD) in der Softwareentwicklung, indem sie die automatisierte Ausführung von Tests bei jedem Commit oder Build sicherstellen. Siehe hierzu den Beitrag über CI/CD.
• Berichterstattung und Analyse: Test-Harnische bieten umfangreiche Berichtsfunktionen, die es Entwicklern und Testern ermöglichen, den Fortschritt und den Status der Tests zu überwachen, Fehler und Schwachstellen schnell zu identifizieren und fundierte Entscheidungen über die Softwarequalität zu treffen.

Gängige Test-Harnisch-Tools in der Softwarebranche

Es gibt viele Test-Harnisch-Tools und Frameworks auf dem Markt, die verschiedene Programmiersprachen und Anforderungen unterstützen. Einige der bekanntesten sind:

JUnit: JUnit ist ein weit verbreitetes Testframework für Java-Anwendungen, das Test-Harnisch-Funktionalitäten wie Testausführung, Testdatenverwaltung und Ergebnisberichterstattung bietet.

TestNG: TestNG ist ein Testframework für Java-Programme, das auf JUnit basiert und erweiterte Funktionen wie Paralleltestausführung, Testkonfiguration und flexible Testskripterstellung bietet.

NUnit: NUnit ist ein Testframework für .NET-Anwendungen, das Test-Harnisch-Funktionen wie Testausführung, Testdatenverwaltung und Berichterstattung bietet.

Pytest: Pytest ist ein Testframework für Python-Anwendungen, das Test-Harnisch-Funktionalitäten wie Testausführung, Testdatenverwaltung und Ergebnisberichterstattung bietet.

Jasmine: Jasmine ist ein Testframework für JavaScript-Anwendungen, das Test-Harnisch-Funktionalitäten wie Testausführung, Testdatenverwaltung und Ergebnisberichterstattung bietet.

Fazit

Test-Harnische spielen eine entscheidende Rolle in der Softwareentwicklung, indem sie den Testprozess automatisieren, vereinfachen und effizienter gestalten. Durch den Einsatz von Test-Harnischen können Entwickler und Tester sicherstellen, dass ihre Anwendungen die gewünschte Qualität erfüllen und potenzielle Fehler frühzeitig identifiziert und behoben sind, bevor der Release stattfindet. Mit der wachsenden Anzahl von Test-Harnisch-Tools und Frameworks auf dem Markt können Entwickler und Tester leicht eine Lösung finden, die ihren spezifischen Anforderungen und Projektzielen entspricht.

Der Beitrag Test-Harnisch – Qualität und Zuverlässigkeit von Anfang an durch effektive Teststrategien erschien zuerst auf CEOsBay.

Was ist Clean Code?

Clean Code bezieht sich auf den Ansatz, Code so zu schreiben, dass er leicht verständlich, wartbar und erweiterbar ist. Das Konzept wurde von Robert C. Martin, auch bekannt als „Uncle Bob“, in seinem Buch „Clean Code: A Handbook of Agile Software Craftsmanship“ populär gemacht. Im Kern geht es darum, Softwareentwicklung als Handwerk zu betrachten und stets auf hohe Qualität und Präzision in der Codegestaltung zu achten.

Warum ist es wichtig?

Sauberer Code bietet verschiedene Vorteile, sowohl für den Entwickler selbst, für das gesamte Team und meiner Meinung nach auch für die ganze Welt.

• Verständlichkeit: Clean Code ist einfacher zu lesen und zu verstehen. Das hilft Entwicklern, sich schneller mit dem Code vertraut zu machen und Fehler oder Verbesserungsmöglichkeiten schneller zu erkennen.
• Wartbarkeit: Sauberer Code ist leichter zu warten, da er klar strukturiert und weniger anfällig für Fehler oder unerwartete Probleme ist.
• Effizienz: Da Clean Code einfacher zu verstehen ist, kann das Team schneller arbeiten und die Produktivität steigt.
• Zusammenarbeit: Ein sauberer Code erleichtert die Zusammenarbeit im Team, da jeder den Code anderer Entwickler leichter lesen und verstehen kann.

Prinzipien von Clean Code

Es gibt viele Prinzipien und Praktiken, die beim Schreiben von sauberem Code helfen können. Einige der wichtigsten sind:

• Lesbarkeit: Der Code sollte leicht lesbar und verständlich sein. Das bedeutet, dass man Variablen, Funktionen und Klassen sinnvoll benamt und ihre Funktion leicht erkennbar ist. Kommentare setzt man sparsam ein, um den Code nicht zu überfrachten.

• Einfachheit: Man hält den Code so einfach wie möglich, ohne unnötige Komplexität oder Verwirrung. Das bedeutet, dass man sich auf das Wesentliche konzentrieren und abstrakte Konzepte wie Design Patterns oder Funktionen nur verwendet, wenn sie tatsächlich nützlich sind.

• Modularität: Man teilt den Code in kleine unabhängige Module auf, die jeweils eine bestimmte Funktion erfüllen. Dadurch wird der Code leichter zu verstehen und zu warten.

• Wiederverwendbarkeit: Man schreibt den Code so, dass die Wiederverwendbarkeit gewährleistet ist. Dies bedeutet, dass Funktionen oder Klassen, die eine bestimmte Aufgabe erfüllen, generisch genug sind, um in verschiedenen Situationen Verwendung zu finden.

Clean Code in der Praxis

Hier sind einige konkrete Schritte, die man beim Schreiben von Clean Code in der Praxis beachten sollte:

• Variablen-, Funktions- und Klassennamen: Man wählt sinnvolle, beschreibende Namen, die klar machen, was eine Variable, Funktion oder Klasse macht. Die Vermeidung von Abkürzungen oder unverständliche Namen ist eines der obersten Gebote.

• Single Responsibility Principle (SRP): Jede Funktion oder Klasse sollte nur eine einzige Verantwortung haben. Dies bedeutet, dass sie nur einen Aspekt des Problems lösen sollte, um den Code einfacher und leichter zu warten.

• Funktionen und Methoden: Man hält Funktionen und Methoden kurz und konzentrieren sich darauf, dass sie eine einzige Aufgabe erfüllen. Eine Funktion oder Methode sollte in der Regel nicht länger als 20 Zeilen sein, um ihre Verständlichkeit zu gewährleisten.

• KISS (Keep It Simple, Stupid) Prinzip: Man versucht, den Code so einfach wie möglich zu halten und unnötige Komplexität zu vermeiden. Wenn es eine einfachere Lösung gibt, zieht man diese der komplexeren vor.

• Don’t Repeat Yourself (DRY) Prinzip: Man vermeidet doppelten Code, indem man wiederverwendbare Funktionen oder Klassen erstellt. Das verringert die Wahrscheinlichkeit von Fehlern und macht den Code leichter zu warten.

• Code-Kommentare: Man sollte Kommentare dazu verwenden, den Zweck und die Funktionsweise von Code-Teilen zu erläutern, die nicht sofort offensichtlich sind. Man sollte jedoch nicht zu viele Kommentare schreiben, da dies den Code unübersichtlich machen kann.

• Fehlerbehandlung: Die Implementierung einer angemessenen Fehlerbehandlung sollte unabdingbar sein, um unerwartete Probleme zu erkennen und angemessen darauf zu reagieren. Die Verwendung von Exceptions und try-catch-Blöcken, kann eine gute Lösung darstellen, um Fehler abzufangen und entsprechend darauf zu reagieren.

• Testgetriebene Entwicklung (TDD): Man schreibt zuerst Tests, bevor man den eigentlichen Code entwickelt. Auf diese Weise kann man sicherstellen, dass die Implementierung den gewünschten Anforderungen entspricht und weniger fehleranfällig ist. Siehe hierzu meinen Beitrag über Test Driven Development.

• Kontinuierliche Integration (CI) und Continuous Deployment (CD): Man verwendet CI/CD-Tools, um den Code regelmäßig zu testen und automatisch zu deployen. Dies stellt sicher, dass der Code immer auf dem neuesten Stand ist und das man potenzielle Probleme schnell erkennen kann.

Fazit

Im Grunde genommen ist dies für mich eine relativ neue Angelegenheit, da ich in der Vergangenheit schon recht of den Code einfach reingehackt habe, da ich mich unter Zeitdruck gefühlt habe. Ich ertappe mich hin und wieder immer noch dabei und dies sehr oft, wie ich auf alte Gewohnheiten und Muster zurückgreife. Doch dies sollte sich hoffentlich in den nächsten Monaten und Jahren auf ein Minimum reduzieren lassen. Ich bin davon überzeugt, dass Clean Code ein wesentlicher Bestandteil einer erfolgreichen Softwareentwicklung ist. Indem man sich auf Lesbarkeit, Einfachheit, Modularität und Wiederverwendbarkeit konzentriert, kann man den eigenen Code nicht nur leichter verstehen, sondern auch schneller und effizienter arbeiten. Durch die Anwendung der oben genannten Prinzipien und Praktiken kann man den Code verbessern und letztendlich zu erfolgreichen, wartungsfreundlichen Softwareprodukten beitragen.

Der Beitrag Clean Code – Elegante Lösungen für effiziente und wartungsfreundliche Software erschien zuerst auf CEOsBay.

MapStruct nutzt dabei die Annotationen, die auf den Java-Objekten angebracht sind, um automatisch Mapping-Code (Bean-Mappings) zu generieren. Das Framework generiert dabei standardmäßig Mappings zwischen Objekten mit gleichem Namen und Typ, es können aber auch eigene Mappings definiert werden. Dabei können auch komplexere Mappings erstellt werden, beispielsweise wenn Attribute in den Quell- und Zielobjekten unterschiedliche Namen haben oder wenn sie unterschiedliche Typen haben.

MapStruct ist sehr einfach zu verwenden und erfordert nur eine minimale Konfiguration. Es integriert sich nahtlos in das Build-System, da es als Annotation Processor fungiert und beim Kompilieren des Codes aufgerufen wird. Das Framework ist relativ schnell und hat einen geringen Overhead, da es keine Laufzeit-Abhängigkeiten hat.

Vorteile auf einem Blick

• Schnelle Ausführung durch Verwendung einfacher Methodenaufrufe anstelle von Reflexion (Bedeutet: Ein Programm kennt seine eigene Struktur und kann diese modifizieren)
• Kompilierzeit-Typensicherheit. Nur Objekte und Attribute, die einander zugeordnet sind – Es findet keine versehentliche Zuordnung einer Auftragsentität zu einem Kunden-DTO statt.
• In sich geschlossener Code – keine Laufzeit-Abhängigkeiten
• Eindeutige Fehlerberichte zur Erstellungszeit, wenn: 
  • Mappings unvollständig sind (Wenn nicht alle Zieleigenschaften gemappt sind)
  • Mappings fehlerhaft sind (Wenn es keine geeignete Mapping-Methode oder Typkonvertierung findet)
• Leicht zu debuggender Mapping-Code (Oder manuell editierbar, z. B. im Falle eines Fehlers im Generator)

Fazit

Zusammenfassend ist MapStruct ein leistungsfähiges und einfach zu bedienendes Framework, das die Entwicklung von Mapping-Code vereinfacht und beschleunigt. Vor allem, weil das Übertragen von Daten zwischen Objektmodellen meist eine wiederkehrende Aufgabe bei der Anwendungsentwicklung ist. Es ist eine gute Wahl, wenn man schnell und effizient Mapping-Funktionalitäten in Anwendungen integrieren möchte. Man kann es in Befehlszeilen-Builds (Maven, Gradle usw.) als auch in der bevorzugten IDE wie z.B. IntelliJ oder Eclipse verwenden.

Der Beitrag MapStruct – Schnelle und sichere Objektmapper für saubere und wartungsfreundliche Java-Anwendungen erschien zuerst auf CEOsBay.

1. Autokonfiguration
2. Ein Opinionated-Konfigurationsansatz
3. Die Fähigkeit, eigenständige Anwendungen zu erstellen

Das Zusammenspiel dieser Funktionen ermöglicht die Installation einer Spring basierten Anwendung mit minimalem Konfigurations- bzw. Einrichtungsaufwand, worauf ich nachfolgend näher eingehe. Mit einem breiten Spektrum an Funktionalitäten ist es eine ganzheitliche Lösung, wobei die Entkopplung der Applikationskomponenten im Vordergrund steht.

Was ist das Spring Framework und was stellt Spring Boot damit an?

Ein Spring Framework bietet eine Abhängigkeitsinjektionsfunktion, mit der Objekte ihre eigenen Abhängigkeiten definieren können.Der Spring-Container injiziert diese nachfolgend. So kann man als Entwickler modulare Anwendungen erstellen, die aus losen verbundenen Komponenten bestehen. Diese eignen sich ideal für Microservices und verteilte Netzanwendungen.

Das Spring Framework bietet auch die integrierte Unterstützung für typische Aufgaben, die eine Anwendung ausführen muss. Beispiele hierfür sind Datenbindung, Typumsetzung, Prüfung und Bewertung, Ausnahmebehandlung, Ressourcen- und Ereignismanagement und vielem mehr. Darüber hinaus lässt es sich mit verschiedenen Java EE-Technologien wie RMI (Remote Method Invocation), AMQP (Advanced Message Queuing Protocol), Java Web Services und anderen integrieren. Alles in allem liefert das Spring Framework Entwicklern alle Tools und Funktionen, die man benötigt, um lose verbundene, plattformunabhängige Java EE-Anwendungen zu erstellen, die man in den verschiedensten Umgebungen ausführen kann. So leistungsfähig und umfassend das Spring Framework auch ist, so viel Zeit und Know-How erfordert es, Spring-Anwendungen sauber zu konfigurieren, einzurichten und bereitzustellen. Spring Boot verringert diesen Aufwand mit den bereits zu Beginn erwähnten drei wichtigen Funktionen.

Autokonfiguration in Spring Boot

Unter der Autokonfiguration verstehen man die Initialisierung von Anwendungen mit voreingestellten Abhängigkeiten ohne den manuellen Eingriff eines Entwicklers. Da Java Spring Boot über integrierte Autokonfigurationsfunktionen verfügt, konfiguriert es sowohl das zugrunde liegende Spring Framework als auch die Pakete von Drittanbietern automatisch auf der Grundlage der eigenen individuellen Einstellungen. Dies trägt auch zur grundlegenden Fehlervermeidung bei. Auch wenn man die Standardeinstellungen nach Abschluss der Initialisierung überschreiben kann, ermöglicht die Autokonfigurationsfunktion von Java Spring Boot einen schnellen Start bei der Entwicklung von Spring-basierten Anwendungen. Dies reduziert die Möglichkeit menschlicher Fehler.

Opinionated-Konfigurationsansatz

Der Optionated-Ansatz bei Spring Boot findet Anwendung beim Hinzufügen und bei der Konfiguration von Steuer-Abhängigkeiten, basierend auf den Projektanforderungen. Spring Boot wählt nach eigenem Ermessen die passenden Pakete zur Installation aus und setzt auch die Standardwerte, ohne dass ein nachträgliches manuelles Eingreifen erforderlich ist.

Man kann die Anforderungen des jeweiligen Projekts während des Initialisierungsprozesses definieren. Dabei wählt man zwischen mehreren Starter-Abhängigkeiten (den Spring Starters) die typische Anwendungsfälle abdecken. Man startet den Spring Boot Initializr (Das ist kein Rechtschreibfehler 😉 ), indem man ein einfaches Webformular ausfüllt. Alles erst einmal ohne zu programmieren und ohne Code.

Mit der Starter-Abhängigkeit „Spring Web“ kann man beispielsweise Spring-basierte Webanwendungen mit minimaler Konfiguration erstellen, indem man im Projekt alle erforderlichen Abhängigkeiten – wie den Apache Tomcat Webserver – hinzufügt. „Spring Security“ ist eine weitere vielfach eingesetzte Starter-Abhängigkeit, die automatisch Authentifizierungs- und Zugriffskontrollfunktionen zur Verfügung stelllt. Spring Boot enthält von Haus aus über 50 Spring-Starter, und viele weitere Starter von Drittanbietern sind ebenfalls verfügbar.

Eigenständige Anwendungen

Spring Boot hilft Entwicklern, Anwendungen zu erstellen, die einfach funktionieren. Insbesondere kann man damit eigenständige Anwendungen erstellen, die ohne einen externen Webserver auskommen, indem man einen Webserver wie Tomcat oder Netty während des Initialisierungsprozesses in der eigenen Anwendung einbettet. So kann man die Anwendung auf jeder Plattform starten, indem man einfach auf den Befehl „Ausführen“ klickt. Man kann aber auch auf diese Funktion verzichten, indem man dies in der Konfiguration deaktiviert.

Fazit

In der Praxis ist die Verwendung von Spring Boot durchaus zu empfehlen. Außer man hat vor, eine sehr spezielle Konfiguration zu implementieren. Man kann weiterhin das vielfach eingesetzte Annotationssystem von Spring Framework verwenden, mit dem man auf einfache Weise zusätzliche Abhängigkeiten (deren Abdeckung nicht von Spring Starters gewährleistet ist) in die Anwendung implementieren kann. Auch hat man weiterhin Zugriff auf alle Spring Framework-Funktionen, einschließlich der einfachen Ereignisverarbeitung, Prüfung und Bewertung, Datenbindung, Typumsetzung und der integrierten Sicherheits- und Testfunktionen. Kurz zusammengefasst – Wenn die Abdeckung des Projektumfangs lediglich ein Spring Starter gewährleistet, kann Spring Boot die Entwicklung signifikant rationalisieren.

Der Beitrag Spring Boot – Schnell und einfach Webanwendungen erstellen 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.

Cucumber wurde ursprünglich in der Programmiersprache Ruby für Ruby-Anwendungen geschrieben. In der Zwischenzeit unterstützt es aber auch andere Programmiersprachen wie Java und alle anderen auf der Java Virtual Machine gängigen Programmiersprachen sowie C++ und JavaScript. Darüber hinaus gibt es Projekte, die Cucumber noch für weitere Programmiersprachen zur Verfügung stellen und sich als Teil der Cucumber-Familie sehen. Darunter beispielsweise SpecFlow, eine Implementierung für C#.

Wie funktioniert Cucumber?

Wie auch bei den meisten anderen BDD-Frameworks werden in Cucumber Funktionalitäten mittels der Beschreibungssprache „Gherkin“ beschrieben. Gherkin verwendet natürliche Schriftsprache als Grundlage. Lediglich bestimmte Schlüsselwörter werden besonders behandelt.

Gherkin

Gherkin ist die Sprache, die Cucumber verwendet, um Testfälle zu definieren. Sie ist so konzipiert, dass sie sich nicht-technisch und für den Menschen lesbar gestaltet. Es beschreibt Anwendungsfälle in Bezug auf ein Softwaresystem. Der Zweck hinter der Gherkin-Syntax ist die Förderung verhaltensorientierter Entwicklungspraktiken in einem Entwicklungsteam, einschließlich Geschäftsanalysten und Managern. Sie zielt darauf ab, bereits in den ersten Phasen der Anforderungsdefinition durch die Geschäftsleitung und in anderen Phasen des Entwicklungslebenszyklus einer Anwendung feste, eindeutige Anforderungen durchzusetzen.

Syntax

Die Syntax ist ähnlich wie bei Python zeilenorientiert aufgebaut. Die Struktur einer Datei wird durch Leerzeichen und andere Steuerzeichen definiert. # wird als Zeilen bzw. Kommentarzeichen verwendet und kann an jeder beliebigen Stelle in einer Datei stehen. Anweisungen sind jede nicht leere und nicht kommentierte Zeile. Sie bestehen aus einem konkreten Gherkin-Schlüsselwort, gefolgt von einer Zeichenkette.

Alle Gherkin-Dateien haben die Dateierweiterung .feature. Sie enthalten eine einzelne Feature-Definition für das zu testende System und sind ein ausführbares Testskript.

Neben der Bereitstellung eines Skripts für automatisierte Tests ist die Syntax von Gherkin so konzipiert, dass sie eine einfache Dokumentation des zu testenden Codes ermöglicht. Gherkin unterstützt derzeit Schlüsselwörter in Dutzenden von Sprachen.

Schlüsselwörter der Gherkin Sprache

• Feature: Name bzw. die Bezeichnung des Features
• Rule: Regeln des Features
• Example oder Scenario: Die Bezeichnung des Szenarios (Beispielsweise „Die erfolgreiche Anmeldung mit gültigen Anmeldeinformationen.“)
• Given, When, Then, And, But für die steps (oder *)- Vorbedingungen (Gegeben sei), die Aktion, die ausgeführt wird bzw. die Erweiterung durch andere Schlüsselwörter um die Aktion die ausgeführt wird zu ergänzen bzw. zu erweitern. (Der User gibt beispielsweise seine Zugangsdaten, Username and Password ein), gefolgt von der erwarteten Reaktion des Systems (Beispielsweise die Nachricht, bei einem erfolgreichen Login.)
• Background – Ein Background ermöglicht es einem, den nachfolgenden Scenarios einen gewissen Kontext hinzuzufügen. Es kann einen oder mehrere Vorgegebene Schritte enthalten, die vor jedem Scenario aber nach jedem Before hook ausgeführt werden.
• Scenario Outline oder Scenario Template – Damit lässt sich dasselbe Szenario mehrmals mit unterschiedlichen Wertekombinationen ausführen.
• Examples oder Scenarios – Eine Scenario Outline muss einen oder mehrere Abschnitte mit Examples bzw. Scenarios enthalten. Sie dienen als Steps bzw. Interpretationsvorlage, die nie direkt ausgeführt werden. Stattdessen wird die Szenariogliederung einmal für jede Zeile mit den darunter liegenden Abschnitten von Examples ausgeführt.

Gherkin in deutscher Sprache

Um eine Funktionalität auf Deutsch zu schreiben, muss am Beginn des Features # language: de angegeben werden. Damit sind u.A. folgende deutsche Schlüsselwörter verfügbar:

• Funktionalität
• Grundlage
• Szenario
• Szenariogrundriss
• Beispiele
• Angenommen
• Gegeben sei
• Wenn
• Dann
• Und und Aber, sowie *

Die Command line (CL)

Cucumber verfügt über eine integrierte Kommandozeilenschnittstelle, die eine umfassende Liste von Anweisungen enthält. Wie die meisten Kommandozeilen-Tools bietet Cucumber die Option –help an, die eine Zusammenfassung der Befehle liefert, die diese Command Line akzeptiert.

$ cucumber --help
        -r, --require LIBRARY|DIR        Require files before executing the features.
        --i18n LANG                      List keywords for in a particular language.
                                         Run with "--i18n help" to see all languages.
        -f, --format FORMAT              How to format features (Default: pretty).
        -o, --out [FILE|DIR]             Write output to a file/directory instead of
        ...

Fazit

Gherkin ist nicht nur zum Schreiben von automatisierten Tests geeignet. Man kann Gherkin grundsätzlich auch dazu verwenden, um strukturierte Tests zu erstellen, die man später als Projektdokumentation verwendet kann. Erst die Eigenschaft, strukturiert zu sein, gibt uns die Möglichkeit zu automatisieren.

Sowohl die Sprache Gherkin wie auch das Tool Cucumber, bieten weitaus mehr Funktionalitäten, die ich hier nicht thematisiert habe. Zumal ich auch recht frisch in dieses Thema eingestiegen bin. So ist beispielsweise ein Datengetriebenes Szenario mithilfe von Tabellen möglich. Fernab können verschiedene Schritte, die im Prinzip das Gleiche tun, über Platzhalter definiert werden.

Um solche und weitere Vorteile zu nutzen, ist neben Cucumber oder anderen Testtools vor allem Disziplin beim Verfassen der Dokumentation bzw. der Gherkin Dokumente gefragt. Gleichzeitig müssen die formulierten Schritte präzise genug sein, um die gewünschten Verhaltensweisen ausreichend genau zu beschreiben. Ansonsten zerfällt die Abstraktion und Gherkin Dokumente werden lediglich zu etwas besser lesbaren Testskripten statt dem Ansatz des BDD zu folgen.

Cucumber lässt sich auch mit IntelliJ nutzen. Aber darüber gibt es dann in naher Zukunft einen weiteren Beitrag.

Der Beitrag Cucumber – Das kollaborative Tool für Behavior Driven Development erschien zuerst auf CEOsBay.

Es bietet eine Reihe von Funktionen und Tools, die es Entwicklern erleichtert, effektive und zuverlässige Tests für ihre JavaScript-Anwendungen zu schreiben. Zu den Funktionen von Jest gehören unter anderem:

Automatisierte Testausführung:

Jest führt Tests automatisch aus, wenn es Codeänderungen erkennt. Dies beschleunigt den Entwicklungsprozess und sorgt dafür, dass man häufiger bzw. effektiver Tests ausführen kann. Dies steigert am Ende des Tages die Qualität der Anwendungen grundsätzlich.

Snapshot-Tests:

Mit Jest können Entwickler Snapshot-Tests durchführen. Dadurch stellt man sicher, dass das Rendering der Komponenten oder Funktionen konsistent stattfindet. Dies kann auch dabei helfen, visuelle Fehler in der Benutzeroberfläche zu identifizieren und zu beheben.

Mocking:

Jest erleichtert das Erstellen von Mocks und Stubs für Abhängigkeiten, die man in den zu entwickelnden Anwendungen verwendet. Dies kann Entwicklern dabei helfen, ihre Tests zu isolieren und sicherzustellen, dass die Ausführung unabhängig voneinander stattfindet.

Codeabdeckung:

Jest bietet eine integrierte Codeabdeckungsfunktion. Dies ermöglicht den Entwicklern die Überprüfung, wie viel des Codes während der Testausführung abgedeckt ist. Dies kann helfen, Lücken in der Testabdeckung zu identifizieren und die Qualität der Anwendung insgesamt zu verbessern.

Parallele Testausführung:

Jest kann Tests parallel ausführen, was die Testdauer verkürzt, und die Gesamtgeschwindigkeit des Entwicklungsprozesses erhöht.

Fazit

Insgesamt ist Jest ein leistungsstarkes Testframework für JavaScript-Anwendungen, dass eine breite Palette von Funktionen bietet, um Entwicklern dabei zu helfen, effektive und zuverlässige Tests für ihre Anwendungen zu schreiben. Es ist eine wichtige Technologie für die Entwicklung moderner JavaScript-Anwendungen und viele Entwickler sowie Unternehmen weltweit nutzen es.

Der Beitrag Jest – Test-Framework für Testautomatisierung erschien zuerst auf CEOsBay.

Für den effektiven Ansatz des dezentralisierten Austausches, ist ein solcher Mechanismus unabdingbar. Änderungen auf der Blockchain müssen für ein zuverlässiges System durch einen Konsensmechanismus bestätigt werden. Der Proof of Work stellt in der Regel die Lösung einer mäßig schweren Aufgabe durch den Nutzer oder dessen Computer dar. Das Ergebnis kann vom Diensterbringer ohne großen Aufwand nachgeprüft werden.

Definition

Um es zu verstehen, kann es Sinn machen, die Grundlagen der Distributed Ledger Technologie anzusehen. Man kann die Blockchain als eine Art Verzeichnis betrachten, dass mit Transaktionen und Blöcken gefüllt ist. Die Speicherung erfolgt aufeinander aufbauend über ein verteiltes Netzwerk. Zur Speicherung ist ein Freigabeprotokoll erforderlich, dass die dezentralisierte Übermittlung von Daten zwischen den Netzwerkteilnehmern ermöglicht.

Durch die dezentralisierte Speicherung der Daten ist sichergestellt, dass die Manipulation extrem minimiert wird. Ich möchte hier bewusst mit absoluten Aussagen sparsam umgehen. Mit dem Aufkommen der Quantentechnolgie, wird sich dahingehend durchaus etwas machen lassen, glaube ich. Dennoch ist stand heute eine Überprüfung durch die Teilnehmer im Netzwerk nicht erforderlich.

Durch die gemeinsame Nutzung der Daten von unabhängigen Netzwerk-Teilnehmern, auch Nodes bzw. Knoten genannt, durch die Blockchain, verfügt jeder Teilnahme eine exakte Kopie der gesamten Daten, der Blockchain. Folglich müsste für einen erfolgreichen Angriff bzw. eine Manipulation der Daten, die Mehrheit aller Netzwerkteilnehmer zeitgleich einer Änderung zustimmen. Bei diesem Konsensmechanismus spricht man vom Proof of Work.

Funktionsweise des Proof of Work

Im Grunde genommen gilt es rechenintensive mathematische Aufgaben zu lösen, um einer Blockchain neue Blöcke bzw. Datensätze hinzuzufügen. Bei diesem Vorgang spricht man vom Mining.

Jede erfolgreiche Lösung eines vorgegebenen mathematischen Problems, durch ein Trial And Error Verfahren, führt zu der Generierung eines neuen Blocks in der Blockchain. Um genau zu sein der erste Schüler… Ich meinte natürlich Netzwerkteilnehmer, der eine Lösung findet, kann auf die Hausaufgabe verzichten… Und auch hier meinte ich eher, dass dieser die Lösung im Netzwerk teilen kann. Grüße Doc Bock – Ist ein bisschen was anderes als Nullstellen berechnen. Macht auch etwas mehr Spaß, vorausgesetzt der Gegenwert passt 😀

Alle anderen Teilnehmer bauen dann auf dem neu generierten Datenblock auf. Hinzu kommt, dass je mehr Rechenarbeit eine Node aufwendet, die Wahrscheinlichkeit, für die Generierung neuer Blöcke erhöht wird.

Die Nutzung und Bereitstellung von Proof of Work ist rechenintensiv. Und komplexe Rechenoperationen durch Computer benötigen enorm viele Ressourcen. Vor allem, weil die Berechnungen mit jeder Erstellung eines neuen Blocks komplizierter werden und folglich auch länger dauern.

Bekannte Proof of Work Lösungen

Zu den bekanntesten PoW Lösungen zählen der Bitcoin (BTC), Litecoin (LTC) und Dogecoin (DOGE)

Fazit

PoW hat sich als Konsens Algorithmus bewährt. Die Wahrscheinlichkeit für die Manipulation der Blockchain ist äußerst gering. So, zumindest der Status Quo. Der große Nachteil ist der enorme Energiebedarf, der erforderlich ist, um die komplexen Berechnungen zu lösen. Dies ist vor allem in der heutigen Zeit der Energiekriese ein großes Manko, was zu einer relativ schlechten Reputation dieses Konsensalgorithmus führt. Dies ist unter anderem ein Grund dafür, warum Ethereum bzw. ETH / Ether nicht mehr unter PoW verweilt und auch viele andere Kryptowährungen auf Proof of Stake geswitched sind. Die Vor- und Nachteile zu diesem Konsensalgorithmus findet ihr, wie bereits angesprochen, in dem Beitrag, der genau diesem Thema gewidmet ist.

Der Beitrag Proof Of Work (PoW) – Der Algorithmus für eine sichere und vertrauenswürdige Blockchain erschien zuerst auf CEOsBay.