Was versteht man unter Programmierstil?

Es bezeichnet die Art und Weise, wie Entwickler ihren Code schreiben. Dazu gehören Konventionen zu Syntax, Formatierung und Namensgebung sowie Prinzipien für sauberen und effizienten Code. Ein konsistenter Programmierstil fördert die Lesbarkeit und verhilft anderen Entwicklern zu einem schnelleren Verständnis des Codes, was wiederum die Wartbarkeit und Fehlersuche erleichtert.

Historische Entwicklung des Programmierstils

In den frühen Tagen der Programmierung standen Effizienz und Ressourcensparsamkeit im Vordergrund, da die verfügbare Hardware stark limitiert war. Mit der Zeit und dem technologischen Fortschritt rückten jedoch Aspekte wie Wartbarkeit, Skalierbarkeit und Teamkollaboration in den Fokus. Standards und Richtlinien für guten Programmierstil entstanden, um diesen Anforderungen gerecht zu werden.

Bewährte Praktiken für einen guten Programmierstil

Ein guter Programmierstil zeichnet sich durch Klarheit, Konsistenz und Einfachheit aus. Bewährte Praktiken umfassen:

• Einheitliche Formatierung: Einhaltung von Konventionen bezüglich Einrückungen, Zeilenlängen und Klammerungen.
• Klare Namensgebung: Variablen, Funktionen und Klassen tragen aussagekräftige Namen.
• Kommentierung und Dokumentation: Der Code enthält hilfreiche Kommentare und ist ausreichend dokumentiert.
• Vermeidung von Code-Duplikaten: Wiederverwendung von Code statt Kopieren und Einfügen.
• Einhalten von Design-Prinzipien: Anwendung von SOLID-Prinzipien für eine modulare und erweiterbare Codebasis.

Praktische Beispiele für den Einsatz von Programmierstil

Konsistente Formatierung

// Schlechter Stil:

function add(a,b){return a+b;}

// Besserer Stil:

function add(a, b) {
  return a + b;
}

Die zweite Version folgt einer klaren und konsistenten Formatierung, wodurch sie leichter lesbar wird.

Klare Namensgebung

// Schlechter Stil:

def calc(x, y):
    return x * y

// Besserer Stil:

def multiply_numbers(number1, number2):
    return number1 * number2

Die Funktion im besseren Stil trägt einen aussagekräftigen Namen und auch die Parameter sind klar benannt.

Fazit

Ein guter Programmierstil ist entscheidend für die Qualität von Softwareprojekten. Er fördert die Lesbarkeit, erleichtert die Wartung und steigert die Produktivität der Entwicklerteams. Durch die Einhaltung bewährter Praktiken und Standards lassen sich diese Vorteile realisieren und die Grundlagen für erfolgreiche Softwareprojekte legen. An dieser Stelle möchte ich auch auf meinen Beitrag über Clean Code verweisen.

Der Beitrag Programmierstil – Coding Standards 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.

Definition

Der Begriff wurde zum ersten Mal in einer Arbeit von Ralph Johnson und William Opdyke 1990 gebraucht (Refactoring: An aid in designing application frameworks and evolving object-oriented systems. In: Proceedings of Symposion on Object-Oriented Programming Emphasizing Practical Applications (SOOPPA), September 1990). Opdyke promovierte 1992 zu dem Thema. Sie entwickelten die Idee einer Software-Refactory, die das Umgestalten (eben das Refactoring) von Computerprogrammen erleichtern sollte. Die unzutreffende Übersetzung Refaktorisierung stammt aus einer Verwechslung mit einer häufig zitierten Analogie, die ursprünglich nicht Begriffsinhalt war: Refactoring ist eine Art, ein Programm so zu modifizieren, dass man verborgene Strukturen offenlegt, ohne die Funktionalität zu ändern. Dies, so der (fälschliche) Analogieschluss, entspreche dem Vorgehen der Faktorisierung von Polynomen in der Mathematik. Bin aber kein Mathematiker 😉

Warum ist Refactoring wichtig?

• Verbesserung der Code-Lesbarkeit: Lesbarkeit ist entscheidend, um den Code effizient zu warten und zu erweitern. Durch das Refactoring können Entwickler den Code vereinfachen, Duplikate entfernen und konsistente Benennungen und Formatierungen verwenden, um die Lesbarkeit zu verbessern.
• Reduzierung der technischen Schulden: Technische Schulden entstehen, wenn man die Software in Eile entwickelt, ohne auf Qualitätsstandards zu achten. Sie führen oft zu schwer zu wartendem und unzuverlässigem Code. Es hilft, technische Schulden zu reduzieren und verhindert, dass sie sich im Laufe der Zeit anhäufen.
• Optimierung der Code-Wartbarkeit: Refactoring hilft dabei, den Code modular und gut strukturiert zu halten, was die Wartung und Fehlerbehebung erleichtern kann.
• Verbesserung der Code-Performance: Durch das Entfernen von unnötigem Code und die Optimierung von Algorithmen kann Refactoring dazu beitragen, die Performance der Software zu steigern.
• Erleichterung der Teamarbeit: Ein sauberer und gut strukturierter Code ist leichter zu verstehen und ermöglicht eine effektivere Zusammenarbeit zwischen Entwicklern.

Strategien für effektives Refactoring

• Code Smells identifizieren: „Code Smells“ sind Anzeichen dafür, dass man den Code möglicherweise verbessern muss. Beispiele sind lange Methoden, große Klassen, doppelter Code und unklare Benennungen. Entwickler sollten diese Anzeichen erkennen und entsprechende Maßnahmen ergreifen, um den Code zu verbessern.
• Schrittweise Verbesserungen vornehmen: Refactoring sollte schrittweise erfolgen, um den Code schrittweise zu verbessern und gleichzeitig die Funktionalität intakt zu halten.
• Automatisierte Tests verwenden: Um sicherzustellen, dass die Funktionalität nach dem Refactoring unverändert bleibt, ist es entscheidend, automatisierte Tests zu verwenden. Dies stellt sicher, dass Änderungen am Code keine unerwünschten Nebenwirkungen verursachen.
• Konsistente Coding-Standards einhalten: Ein konsistenter Codierungsstil erleichtert das Lesen und Verstehen des Codes. Es ist wichtig, dass das gesamte Team die gleichen Standards einhält, um Inkonsistenzen zu vermeiden.
• Regelmäßiges Refactoring betreiben: Man Refactoring als fortlaufenden Prozess betrachten, der in die tägliche Arbeit eines Entwicklers integriert ist. Regelmäßiges Refactoring hilft dabei, den Code kontinuierlich sauber und auf dem neuesten Stand zu halten, wodurch man die langfristige Wartbarkeit der Software verbessern kann. Außerdem hilft es dabei, den Code zu besser verstehen und tiefere Erkenntnisse über das Programmieren selbst zu erhalten.

Beliebte Refactoring-Techniken

1. Extract Method: Wenn eine Methode zu lang oder zu komplex ist, kann sie in kleinere, gut definierte Methoden aufgeteilt werden, um die Lesbarkeit und Wartbarkeit des Codes zu verbessern.
2. Rename Variable/Method/Class: Durch das Umbenennen von Variablen, Methoden und Klassen in klarere und aussagekräftigere Namen kann man den Code verständlicher und leichter pflegbar machen.
3. Remove Duplication: Duplikate im Code können Wartungsprobleme verursachen und man sollte sie entfernen. Bei der Erkennung von Duplikaten können Entwickler allgemeine Funktionen extrahieren und wiederverwenden, um den Code zu straffen.
4. Replace Conditional with Polymorphism: Anstatt mehrere bedingte Anweisungen zu verwenden, kann man Polymorphismus eingesetzen, um den Code besser zu strukturieren und die Lesbarkeit zu erhöhen.
5. Encapsulate Field: Durch das Kapseln von Feldern in Klassen und die Bereitstellung von Zugriffs- und Mutationsmethoden kann man den Code modularer und besser wartbar machen.

Tools und Programme

Es gibt eine Vielzahl von Tools und Programmen, die Entwicklern beim Refactoring helfen. Nachfolgend sind einige der gängigsten Tools für verschiedene Programmiersprachen (Einige davon habe ich bereits in diversen Beiträgen thematisiert. Hierzu einfach auf die jeweiligen Verlinkungen klicken oder die Suchfunktion verwenden 😉 ):

Integrated Development Environments (IDEs): Viele moderne IDEs bieten integrierte Refactoring-Unterstützung für verschiedene Programmiersprachen an. Einige der bekanntesten sind:

a. JetBrains IntelliJ IDEA (Java, Kotlin, Scala, u.a.)

b. JetBrains PhpStorm (PHP)

c. JetBrains PyCharm (Python)

d. JetBrains ReSharper (C# in Visual Studio)

e. Microsoft Visual Studio (C#, C++, VB.NET)

f. Eclipse (Java)

g. Xcode (Swift, Objective-C)

Standalone-Tools: Es gibt auch eigenständige Refactoring-Tools, die man unabhängig von der IDE verwenden kann. Einige Beispiele sind:

a. JDeodorant (Java)

b. SonarLint und SonarQube (Java, JavaScript, TypeScript, u.a.)

c. JSLint und ESLint (JavaScript)

d. RuboCop (Ruby)

e. Clang-Tidy (C++, Objective-C)

Code-Editor-Erweiterungen: Viele Code-Editoren, wie Visual Studio Code und Sublime Text, verfügen über Erweiterungen, die Refactoring-Unterstützung für verschiedene Programmiersprachen bieten. Einige dieser Erweiterungen sind:

a. Visual Studio Code Refactoring Extensions (z.B. Python, JavaScript, TypeScript, PHP, Ruby, C#)

b. Sublime Text Refactoring Plugins (z.B. Anaconda für Python, JsPrettier für JavaScript)

Es ist wichtig zu beachten, dass jedes Tool seine eigenen Stärken und Schwächen hat. Ein Entwickler sollte die verfügbaren Optionen für seine Programmiersprache und seinen Arbeitsablauf sorgfältig prüfen, um das am besten geeignete Refactoring-Tool zu finden.

Fazit

Refactoring ist ein wesentlicher Bestandteil des Softwareentwicklungsprozesses, der es ermöglicht, den Code sauber, lesbar und wartbar zu halten. Durch das Identifizieren von „Code Smells“, die Anwendung bewährter Techniken und das kontinuierliche Integrieren von Refactoring in den Arbeitsablauf können Entwickler qualitativ hochwertigen Code schreiben, der leicht zu verstehen und zu erweitern ist.

Die Investition in regelmäßiges Refactoring zahlt sich langfristig aus, indem sie dazu beiträgt, die technischen Schulden zu reduzieren und die Zusammenarbeit im Team zu verbessern. Der Schlüssel zum erfolgreichen Refactoring liegt in der Kombination aus automatisierten Tests, konsistenten Codierungsstandards und einem proaktiven Ansatz zur Code-Optimierung. Durch die Priorisierung von Refactoring in der Softwareentwicklung können Entwickler sicherstellen, dass ihre Projekte skalierbar und zukunftssicher sind.

Der Beitrag Refactoring – Optimierung und Evolution für nachhaltigen Code erschien zuerst auf CEOsBay.

Wie funktioniert YAML?

YAML ist eine Dateiformatierungssprache, die mithilfe von Schlüssel-Wert-Paaren und Einrückungen arbeitet, um die Datenstruktur zu definieren. Ein YAML-Dokument besteht aus Blöcken von Daten, die in Hierarchien und Listen organisiert sind. Jeder Block enthält einen Schlüssel und einen dazugehörigen Wert, die durch einen Doppelpunkt voneinander getrennt sind.

Hier ein Beispiel:

name: John
age: 30
hobbies:
  - reading
  - hiking

In diesem Beispiel enthält das YAML-Dokument drei Schlüssel-Wert-Paare: „name“, „age“ und „hobbies“. Der Schlüssel „hobbies“ hat eine Liste von Werten, die durch Einrückungen unter dem Schlüssel definiert sind.

Man verwendet es oft, um Konfigurationsdateien zu definieren, die Programmen lesen und interpretieren können. Ein Beispiel dafür ist eine Docker Compose-Datei, die eine Anwendung und ihre Abhängigkeiten in einer einzigen Datei definiert. Man kann YAML auch verwenden, um Daten in einer Datenbank oder einer anderen Dateiformatierung zu speichern.

Warum ist YAML nützlich?

Es bietet mehrere Vorteile gegenüber anderen Markup-Sprachen wie XML oder JSON. Hier sind einige davon:

• Lesbarkeit: Es ist sehr leicht lesbar und strukturiert, was es einfacher macht, Dokumente zu erstellen und zu bearbeiten.

• Kompakt: Es ist im Vergleich zu XML oder JSON sehr kompakt und benötigt weniger Code zum Definieren von Daten.

• Einfache Verwendung: Man kann es schnell und einfach verwenden, ohne dass ein spezielles Werkzeug oder ein besonderes Wissen erforderlich ist.

• Erweiterbarkeit: Es ist erweiterbar und man kann es leicht an die Bedürfnisse einer bestimmten Anwendung oder eines bestimmten Datenformats anpassen.

Fazit

YAML ist eine leistungsfähige, einfach lesbare und schreibbare Markup-Sprache, die in der Softwareentwicklung sehr nützlich ist. Es bietet eine Vielzahl von Vorteilen gegenüber anderen Markup-Sprachen und findet häufig bei der Definition von Konfigurationsdateien und Datenstrukturen Einsatz.

Lediglich die Fehlererkennung sollte man nicht außer Acht lassen. Denn YAML-Dokumente können fehlerhaft sein und es kann sich als schwierig erweisen, diese Fehler zu erkennen. Da es sehr auf die Einhaltung der Einrückungen angewiesen ist, kann ein kleiner Fehler in der Formatierung schnell zu Problemen führen.

Auch der Mangel an Expressivität ist nicht zu vernachlässigen. Obwohl es für die meisten Anwendungsfälle ausreichend ist, gibt es Fälle, in denen es an Expressivität mangelt. In einigen Fällen muss man komplexe Datenstrukturen definieren, die über die Fähigkeiten von YAML hinausgehen. In solchen Fällen bieten sich möglicherweise andere Sprachen wie JSON oder XML an.

Trotz der erwähnten Nachteile bleibt es eine nützliche und beliebte Markup-Sprache in der Softwareentwicklung. Wenn man sich entscheidet, YAML zu verwenden, sollte man jedoch diese Nachteile berücksichtigen und geeig

Der Beitrag YAML – Klarheit und Einfachheit für strukturierte Daten und Konfigurationen erschien zuerst auf CEOsBay.

Eine wirklich kurze Zeitreise

Die Extensible Markup Language wurde vom World Wide Web Consortium (W3C) am 10. Februar 1998 veröffentlicht. Die aktuelle Fassung ist die fünfte Ausgabe vom 26. November 2008. Alle bisherigen und aktuellen Publikationen kann man hier einsehen.

Was ist XML nun wirklich und was tut es?

Es ist eine Metasprache, auf deren Basis durch strukturelle und inhaltliche Einschränkungen anwendungsspezifische Sprachen definiert werden. Diese Einschränkungen werden entweder durch eine Document Type Definition (DTD) oder durch ein XML Schema ausgedrückt. Beispiele für XML-Sprachen sind: RSS, MathML, GraphML, XHTML, XAML, Scalable Vector Graphics (SVG), GPX, aber auch das XML-Schema selbst. Auf diese Sprachen gehe ich in zukünftigen Sprachen ein. Besonders SVG hat einen Großteil meiner persönlichen Entwicklung geprägt.

Die Standardzeichenkodierung eines XML-Dokumentes ist UTF-8. XML-bearbeitende Systeme müssen die Kodierungen UTF-8 und UTF-16 beherrschen. XML-Dokumente, die UTF-8 oder UTF-16 verwenden, können in allen Texteditoren, die diese Kodierungen unterstützen, angezeigt und bearbeitet werden. Damit sind so ziemlich alle „Browser“ gemeint 😉

Wenn das XML-Dokument Binärdaten enthalten soll, müssen diese Daten zu Text konvertiert bzw. umkodiert werden. Dazu kann z. B. die Base64-Kodierung verwendet werden.

Das Element

Die essenzielle Struktureinheit eines XML-Dokumentes ist das Element. Elemente können Text wie auch weitere Elemente als Inhalt enthalten. Elemente bilden die Knoten des Strukturbaumes eines XML-Dokumentes. Der Name eines Elementes kann in Dokumenten ohne Dokumenttypdefinition (DTD) frei gewählt werden. In XML-Dokumenten mit DTD muss der Name eines Elementes in der DTD deklariert sein und das Element muss sich in einer zugelassenen Position innerhalb des Strukturbaumes gemäß DTD befinden. In der DTD wird u. a. der mögliche Inhalt eines jeden Elementes definiert. Elemente sind die Träger der Information in einem XML-Dokument.

Tag

Für die Auszeichnung von Elementen werden Tags verwendet. Auf den ersten Blick sehen XML-Tags fast wie HTML-Tags aus. Start-Tags beginnen mit < und End-Tags mit </. Bei beiden folgt anschließend der Name des Elements, und sie werden beide durch > geschlossen. Anders als bei den HTML-Tags können Sie jedoch neue Tags erzeugen. Um eine Person zu beschreiben, benutzt man die Tags <person> und </person>. Um ein Tier zu beschreiben, verwendet man die Tags <tier> und </tier>. Die Namen der Tags spiegeln im Allgemeinen die Art des Inhalts innerhalb des Elements wider und nicht die Art und Weise, wie der Inhalt formatiert wird.

Wohlgeformtheit

Ein XML-Dokument ist „wohlgeformt“ (well-formed), wenn es alle Regeln einhält.

Die Regeln

• Das Dokument besitzt genau ein Wurzelelement. Als Wurzelelement wird dabei das jeweils äußerste Element bezeichnet, z. B. <html> in XHTML.
• Alle Elemente mit Inhalt besitzen einen Start- und einen Endtag (z. B. <eintrag>Eintrag 1</eintrag>). Elemente ohne Inhalt können mit einem Leertag gekennzeichnet werden (z. B. <eintrag />).
• Die Start- und Endtags sind ebenentreu-paarig verschachtelt. Dies bedeutet, dass alle Elemente geschlossen sind, bevor die End-Auszeichner des entsprechenden Elternelements oder die Beginn-Auszeichner eines Geschwisterelements erscheinen.
• Ein Element darf nicht mehrere Attribute mit demselben Namen besitzen.
• Attributwerte müssen in Anführungszeichen stehen („…“ oder ‚…‘).
• Die Start- und Endtags sind Case sensitive, also beachten die Groß- und Kleinschreibung (z. B. <eintrag></Eintrag> ist ungültig).

Gültigkeit (Validität)

Verwendet man es für den Datenaustausch, ist es von Vorteil, wenn das Format mittels einer Grammatik (z. B. einer Dokumenttypdefinition oder eines XML-Schemas) definiert ist. Der Standard definiert ein XML-Dokument als gültig (oder englisch valid), wenn es wohlgeformt ist, den Verweis auf eine Grammatik enthält und das durch die Grammatik beschriebene Format einhält.

Parser

Programme oder Programmteile, die XML-Daten auslesen, interpretieren und ggf. auf Gültigkeit prüfen, nennt man XML-Parser. Prüft der Parser die Gültigkeit, so ist er ein validierender Parser. Darauf gehe ich aber in einem zukünftigen Beitrag genauer ein.

Wie sieht die Extensible Markup Language eigentlich aus?

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<verzeichnis>
    <titel>Städteverzeichnis</titel>
    <eintrag>
        <stichwort>München</stichwort>
        <eintragstext>München ist der Sitz von ...</eintragstext>
    </eintrag>
    <eintrag>
        <stichwort>Donauwörth</stichwort>
        <eintragstext>Donauwörth ist eine Stadt, die ...</eintragstext>
    </eintrag>
</verzeichnis>

XML-Dokumente besitzen einen physischen und einen logischen Aufbau.

Der physische Aufbau

• Die Dokument-Entität (Document entity) enthält das Hauptdokument.
• Weitere mögliche Entitäten sind über Entitätenreferenzen (&name; für das Dokument bzw. %name; für die Dokumenttypdefinition) eingebundene Zeichenketten, eventuell auch ganze Dateien, sowie Referenzen auf Zeichenentitäten zur Einbindung einzelner Zeichen, die über ihre Nummer referenziert wurden (&#Dezimalzahl; oder &#xHexadezimalzahl;).
• Eine XML-Deklaration wird verwendet, um die Version, Zeichenkodierung und eine mögliche Verarbeitbarkeit ohne DTD zu spezifizieren.
• Eine DTD wird verwendet, um Entitäten sowie den erlaubten logischen Aufbau zu spezifizieren. Die Verwendung einer DTD kann in der Deklaration abgewählt werden.

Der logische Aufbau

Der logische Aufbau entspricht einer Baumstruktur und ist damit hierarchisch organisiert. Es gibt folgende Baumknoten:

• Elemente, deren physische Auszeichnung mittels eines passenden Paars aus Starttag <Tagname> und End-Tag </Tagname> oder eines Leertags <Tagname/> erfolgen kann.
• Attribute als bei einem Starttag oder Leertag geschriebene zusätzliche Eigenschaften der Elemente in der Syntax Attributname=Attributwert.
• Verarbeitungsanweisungen <?Zielname Daten?> (engl. Processing Instructions).
• Kommentare <!– Kommentar-Text –>.
• Text, der als normale Zeichendaten oder in Form eines CDATA-Abschnittes <![CDATA[ beliebiger Text]]> auftreten kann.

Ein XML-Dokument muss genau ein Element auf der obersten Ebene enthalten. Unterhalb dieses Dokumentelements können weitere Elemente und Texte verschachtelt werden.

Was ist DTD

Wie vorher kurz ausgeschrieben und angeschnitten, handelt es sich dabei um die Dokumenttypdefinition und beschreibt die Struktur sowie Grammatik von Dokumenten. Sie ist Systembestandteil von XML und per Standard aktiviert.

Werden Dokumente mit Bezug zu einer externen Dokumenttypdefinition oder mit einer integrierten Dokumenttypdefinition erstellt, prüft der Parser das Dokument bereits beim Öffnen (Lesen). Ein Dokument auf Basis einer Dokumenttypdefinition ist stets ein valides Dokument. Die Übereinstimmung des Dokumentinhaltes mit den Regeln der Dokumenttypdefinition steht im Vordergrund. Die technische Lesbarkeit, also auch das Lesen von nicht validen Dokumenten ist nachrangig. Das ist für Volltextdokumente (erzählende Dokumente, engl. narrative documents) vorgesehen und der Haupteinsatzzweck.

Dokumente ohne DTD sind eher für den beliebigen Datenaustausch geeignet. Der Parser prüft diese Dokumente nur nach den Regeln der Wohlgeformtheit. Die technische Lesbarkeit steht hier an erster Stelle. Das Prüfen und Auslesen der eigentlichen Informationen wird mit nachgelagerten Prozessen realisiert.

Lesbarkeit

Wie zu Beginn erwähnt, können alle Webbrowser wie Apple Safari, Google Chrome, Microsoft Edge, Mozilla Firefox, Opera usw. XML-Dokumente mit Hilfe des eingebauten Parsers direkt visualisieren. Dadurch werden keine zusätzlichen PlugIns oder der Gleichen benötigt.

Klassifizierung von XML-Dokumenten

XML-Dokumente lassen sich anhand ihrer Bestimmung und ihres Strukturierungsgrades in dokumentzentrierte und datenzentrierte Dokumente unterteilen. Die Grenze zwischen diesen Dokumentenarten ist fließend. Mischformen können als semistrukturiert bezeichnet werden.

Dokumentzentriert

Das Dokument ist an ein Textdokument angelehnt, dass für den menschlichen Leser größtenteils auch ohne die zusätzliche Metainformation verständlich ist. XML-Elemente werden hauptsächlich zur semantischen Markierung von Passagen des Dokuments genutzt. 

Das Dokument ist nur schwach strukturiert. Aufgrund der schwachen Strukturierung ist eine maschinelle Verarbeitung schwierig.

Datenzentriert

Das Dokument ist hauptsächlich für die maschinelle Verarbeitung bestimmt. Es folgt einem Schema, das Entitäten eines Datenmodells beschreibt und definiert, in welcher Beziehung die Entitäten zueinanderstehen und welche Attribute die Entitäten haben. Das Dokument ist somit stark strukturiert und für den unmittelbaren menschlichen Gebrauch weniger geeignet.

Semistrukturiert

Semistrukturierte Dokumente stellen eine Art Mischform dar, die stärker strukturiert ist als dokumentzentrierte Dokumente, aber schwächer als datenzentrierte Dokumente.

Es ist typisch für datenzentrierte XML-Dokumente, dass Elemente entweder Elementinhalte oder Textinhalte haben. Der sogenannte gemischte Inhalt (Mixed Content), bei dem Elemente sowohl Text als auch Childs (Kind-Elemente) enthalten, ist für die anderen XML-Dokumente typisch.

Verarbeitungskriterien der Extensible Markup Language

Grundsätzlich sind drei Aspekte beim Zugriff auf ein XML-Dokument von Bedeutung:

1. Wie erfolgt der Zugriff auf die XML-Datei: sequenziell oder wahlfrei?
2. Wie ist der Ablauf beim Zugriff auf die Daten gestaltet: „Push“ oder „Pull“? (Push bedeutet, dass die Ablaufkontrolle des Programms beim Parser liegt. Pull bedeutet, dass die Ablaufkontrolle im Code, der den Parser aufruft, implementiert ist.)
3. Wie erfolgt das Baumstrukturmanagement der XML-Daten: hierarchisch oder verschachtelt?

Programmgesteuerter Zugriff auf XML-Dokumente

Das Einlesen von XML-Dokumenten erfolgt auf unterster Ebene über eine spezielle Programmkomponente, einem XML-Prozessor, auch XML-Parser genannt. Er stellt eine Programmierschnittstelle (API) zur Verfügung, über die die Anwendung auf das XML-Dokument zugreift. Ich habe zwar in einem vorherigen Beitrag über die REST API geschrieben, doch werde ich definitiv die Programmierschnittstelle explizit nochmals ein einem Beitrag thematisieren.

Die XML-Prozessoren unterstützen dabei drei grundlegende Verarbeitungsmodelle

1. DOM: Ein DOM-API repräsentiert ein XML-Dokument als Baumstruktur und gewährt wahlfreien Zugriff auf die einzelnen Bestandteile der Baumstruktur. DOM erlaubt außer dem Lesen von den Dokumenten auch die Manipulation der Baumstruktur und das Zurückschreiben der Baumstruktur in ein XML-Dokument. Aus diesem Grund ist DOM sehr speicherintensiv.
2. SAX: Ein SAX-API repräsentiert ein XML-Dokument als sequentiellen Datenstrom und ruft für im Standard definierte Ereignisse vorgegebene Rückruffunktionen (callback function) auf. Eine Anwendung, die SAX nutzt, kann eigene Unterprogramme als Rückruffunktionen registrieren und auf diese Weise die Daten auswerten.
3. Pull-API: Eine XML-Pull-API verarbeitet Daten sequenziell und bietet sowohl ereignisbasierte Verarbeitung als auch einen Iterator an. Es ist hoch speichereffizient und ggf. leichter zu programmieren als das SAX-API, da die Ablaufkontrolle beim Programm und nicht beim Parser liegt.

Weitere Verarbeitungsmodelle sind das Data-Binding, welches die XML-Daten als Datenstruktur direkt für einen Programmzugriff bereitstellt. Die XML-Daten werden per Unmarshalling (Dies ist der Prozess der Umwandlung einer Art von Darstellung auf niedrigerer Ebene, oft ein „Drahtformat“, in eine Struktur auf höherer Ebene (Objekt).) direkt in z. B. Objekte gewandelt. Und die Nicht-extrahierende-XML-API, bei der die Daten auf Byte-Ebene sehr effizient verarbeitet sind.

Oftmals greift der Anwendungscode nicht direkt auf die Parser-API zu. Stattdessen wird es weiter gekapselt, so dass der Anwendungscode mit nativen Objekten / Datenstrukturen arbeitet, welche sich auf darauf abstützen. Beispiele für solche Zugriffsschichten sind JAXB in Java, der Data Binding Wizard in Delphi oder das XML Schema Definition Toolkit in .Net. Die Umwandlung von Objekten in die Extensible Markup Language ist üblicherweise bidirektional möglich. Diese Umwandlung bezeichnet man als Serialisierung oder Marshalling.

Transformation und Darstellung von XML-Dokumenten

Ein XML-Dokument kann mittels geeigneter Transformationssprachen wie XSLT oder DSSSL in ein anderes Dokument transformiert werden. Oftmals dient die Transformation zur Überführung eines Dokuments aus einer Extensible Markup Language in eine andere Extensible Markup Language, beispielsweise zur Transformation nach XHTML, um das Dokument in einem Webbrowser anzuzeigen.

Warum XML?

Unterstützung von und bei Transaktionen

Wenn ein Unternehmen eine Ware oder Dienstleistung an ein anderes Unternehmen verkauft, müssen die beiden Unternehmen Informationen wie Kosten, Spezifikationen und Lieferpläne austauschen. Man kann damit alle erforderlichen Informationen elektronisch teilen und komplexe Geschäfte automatisch abschließen, ohne dass ein menschliches Eingreifen erforderlich ist.

Aufrechterhaltung der Datenintegrität

Man kann damit Daten zusammen mit der Beschreibung der Daten übertragen und so den Verlust der Datenintegrität verhindern. Folglich kann man so die Datengenauigkeit überprüfen, automatische Anpassungen der Datenpräsentation für verschiedene Benutzer vornehmen und Daten konsistent über mehrere Plattformen hinweg speichern 

Sucheffizienz verbessern

Computerprogramme wie Suchmaschinen können die Dateien damit effizienter und präziser sortieren und kategorisieren als andere Arten von Dokumenten. Beispielsweise kann das Wort mark (markieren) entweder ein Substantiv oder ein Verb sein. Basierend auf XML-Tags können Suchmaschinen mark für relevante Suchergebnisse genau kategorisieren. Somit hilft es, die natürliche Sprache für Maschinen effizienter interpretierbar zu machen.

Flexible Anwendungen entwerfen

Man kann damit auch das eigene Anwendungsdesign bequem aktualisieren oder ändern. Viele Technologien, insbesondere neuere Technologien, verfügen dafür über eine integrierte Schnittstelle bzw. Unterstützung. So kann man automatisch Datendateien lesen und verarbeiten, sodass die Änderungen stattfinden können, ohne gleich die gesamte Datenbank neu formatieren zu müssen.

Der Beitrag XML – Effiziente Datenstrukturierung erschien zuerst auf CEOsBay.