Deklarative Programmierung

Was ist deklarative Programmierung?

Die deklarative Programmierung konzentriert sich auf das "Was", anstatt auf das "Wie" von Programmen. Das bedeutet, dass du beschreibt, was das Programm tun soll, anstatt die Schritte oder den Algorithmus zu beschreiben, die zur Erreichung des Ziels erforderlich sind.

Im Gegensatz zu imperativen Programmiersprachen, bei denen du den Computer Schritt für Schritt durch eine Aufgabe führst, gibt eine deklarative Programmiersprache an, welches Ergebnis erzielt werden soll. Die Programmiersprache enthält eine Reihe von Bausteinen, Regeln und Bedingungen, die definiert werden, um das Problem zu lösen. Die zugrundeliegende Low Code Plattform entscheidet dann, wie diese Bausteine, Regeln und Bedingungen umgesetzt werden, um das gewünschte Ergebnis zu erzielen.

Beispiele für deklarative Programmiersprachen sind SQL (Structured Query Language), Prolog, XSLT (Extensible Stylesheet Language Transformations) und Haskell. Diese Sprachen werden oft für komplexe Aufgaben wie Datenbankabfragen, künstliche Intelligenz und die Verarbeitung von XML-Dokumenten eingesetzt.

Zwei Beispiele

Ein Beispiel für eine deklarative Programmiersprache ist SQL (Structured Query Language), die in Datenbanken verwendet wird.

In SQL wird beschrieben, welche Daten abgefragt werden sollen, anstatt explizit anzugeben, wie sie abgerufen werden sollen. Beispielsweise gibst du an, dass du alle Kunden in einer bestimmten Region abrufen möchtest, aber nicht, wie der Computer dies erreichen soll. SQL nutzt dann eine Reihe von Bausteinen, Regeln und Bedingungen, um die angeforderten Daten aus der Datenbank abzurufen.

Hier ist ein Beispiel einer einfachen SQL-Abfrage:

SELECT Vorname, Nachname, Stadt FROM Kunden WHERE Stadt = 'München'

In dieser Abfrage wird angegeben, welche Daten abgerufen werden sollen (Vorname, Nachname, Stadt) und welche Bedingungen erfüllt sein müssen (Stadt = 'München'). Die Datenbank entscheidet dann, wie die Abfrage ausgeführt wird, um die gewünschten Ergebnisse zu erzielen.

 

Ein weiteres Beispiel für eine deklarative Programmiersprache ist die Stylesheet-Sprache XSLT (Extensible Stylesheet Language Transformations), die zur Transformation von XML-Dokumenten verwendet wird.

In XSLT kannst du beschreiben, wie ein XML-Dokument umgewandelt werden soll, anstatt eine Reihe von Schritten anzugeben, um das Ergebnis zu erreichen. Beispielsweise gibst du an, welche Elemente aus dem XML-Dokument extrahiert und wie sie formatiert werden sollen. XSLT nutzt dann eine verschiedene Bausteinen, Regeln und Bedingungen, um die gewünschte Transformation durchzuführen.

Hier ist ein Beispiel einer einfachen XSLT-Transformation:

    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
       <html>
          <body>
             <h1><xsl:value-of select="//title"/></h1>
             <p><xsl:value-of select="//body"/></p>
          </body>
       </html>
    </xsl:template>
   </xsl:stylesheet>
 

In dieser Transformation wird angegeben, wie ein XML-Dokument in HTML umgewandelt werden soll. Das <xsl:template>-Element gibt an, dass das gesamte Dokument übereinstimmen soll, während <xsl:value-of> angibt, welche Elemente ausgewählt und in das HTML-Dokument eingefügt werden sollen. Der XSLT-Interpreter entscheidet dann, wie die Transformation durchgeführt wird, um das gewünschte Ergebnis zu erzielen.

 

Aber keine Sorge, die deklarative Programmiersprache für unseren Software Composer ist sehr viel einfacher und übersichtlicher. Es geht hier lediglich darum, die Grundidee der deklarativen Programmierung zu erklären.

Biz

Die deklarative Programmiersprache des Software Composer heißt Biz, mit der du deine Webanwendungen erstellst.

Die Elemente von Biz werden als Bausteine bezeichnet, die konfiguriert und miteinander kombiniert werden. Somit erstellst du eine Webanwendung, indem du Stück für Stück Bausteine hinzufügst, bei bestehenden Bausteinen die Konfiguration änderst oder zu einem späteren Zeitpunkt auch wieder Bausteine entfernst.

Das berühmte Programm "Hello world!" würde mit Biz wie folgt aussehen. Es fügt ein Hauptmenü mit einen Menüpunkt "Hello, world!" ein, der die Meldung "Hello, world!" ausgibt.

    menu: (
        item: Activity(
            label: "Hello, world!"
            activity: Message(message: "Hello, world!")
        )
    )

In diesem Beispiel wird der Haupt-Menü-Baustein mit "menu:" erzeugt. Der Menüeintrag-Baustein wird mit "item:" erzeugt, in diesem Fall ein Activity-Menüeintrag, um eine Aktion ausführen zu können. Die Aktion ist der Message-Baustein, der die Meldung "Hello, world!" ausgibt.

Das Programm "Hello, world!" kann auch als Maske mit dem Eingabefeld "Hello-World" umgesetzt werden. Das würdest du wie folgt umsetzen:

    entity: (
        name: HelloWorld
        attribute: (name: hello_world; label: "Hello, world!"; type: String(max: 100))
    )

    query: (name: HelloWorld; entity: HelloWorld)

    view: (
        name: Hello-World
        query: Hello-World
        function: C1RU
        contents: (
            child: (attribute: hello_world)
    )
 

Mit dem Entity-Baustein erzeugst du die Entität Hello-World mit einem Attribut hello_world, das als String, d.h. als Text definiert ist. Mit der Angabe persistent wird diese Entität automatisch als Datenbank-Tabelle gepflegt, ohne dass du etwas tun musst - das übernimmt automatisch der Software Composer für dich.

Mit dem Query-Baustein erzeugst du eine einfache Abfrage auf diese Entität.

Schließlich erzeugst du eine Maske für diese Entität, in der du einen neuen Datensatz anlegen und in der Folge auch anschauen und ändern kannst (via function: C1RU). Mit dem child-Baustein erzeugst du ein Eingabefeld für das Attribut hello_world. Das passende Widget wird automatisch anhand des Attributtyps ermittelt. Das kannst du natürlich bei bedarf anpassen. So wird ein Ja/Nein-Feld standardmäßig als Checkbox dargestellt. Du kannst das z.B. in ein Auswahlfeld mit den Einträgen Ja und Nein oder in zwei Radio-Buttons Ja und Nein abändern.

Bei Biz wurde sehr stark auf die Lesbarkeit geachtet, da Quellcode viel öfters gelesen als geschrieben oder geändert wird. Das Beispiel zeigt insbesondere, dass du die Bausteine entweder kompakt in einer Zeile oder auch strukturiert über mehrere Zeilen definieren kannst. Das bleibt dir überlassen, was im Einzelfall für dich übersichtlicher ist.

Aber keine Sorge, du musst das nicht im Detail verstehen. Dafür bieten wir unseren Basis-Kurs an, um dir den Umgang mit dem Software Composer und Biz zu erklären (siehe Online-Akademie).

Welche Vorteile hast du?

Die deklarative Programmierung hat mehrere Vorteile gegenüber der imperativen Programmierung:

Abstraktion
Eine deklarative Programmiersprache ermöglicht es dir, dich auf das "Was" zu konzentrieren, anstatt auf das "Wie". Das bedeutet, dass du dich auf das Ziel des Programms konzentrieren kann, anstatt dich mit der Implementierung von Schritten und Algorithmen auseinandersetzen zu müssen.

Kurzer und einfacher Quellcode
Eine deklarative Programmiersprache erfordert in der Regel weniger Quellcode als eine klassische, imperative Programmiersprache. Dadurch kannst du den Quellcode viel einfacher lesen und warten. Außerdem besteht eine geringere Wahrscheinlichkeit von Fehlern, da es schlicht weniger Quellcode gibt.

Wiederverwendbarkeit
Die Bausteine, Regeln und Bedingungen, die in einer deklarativen Programmiersprache verwendet werden, kannst du oft wiederverwenden. Das bedeutet, dass du sie in verschiedenen Programmen einsetzen kannst, um ähnliche Probleme zu lösen.

Skalierbarkeit
Eine deklarative Programmiersprache ist oft besser skalierbar als eine klassische, imperative Programmiersprache. Da die Low Code Plattform entscheidet, wie die Bausteine, Regeln und Bedingungen umgesetzt werden sollen, kann die Entwicklung mit einer solchen Plattform auf einfache Weise parallelisiert werden, um größere Probleme zu lösen.

Fehlervermeidung
Da die deklarative Sprache die Details der Implementierung abstrahiert und kapselt, besteht eine geringere Wahrscheinlichkeit, dass du fehlerhafte Quellcode-Zeilen schreibst. Außerdem kann die Low Code Plattform bestimmte Fehler automatisch erkennen und korrigieren, bevor das Programm ausgeführt wird.

Diese Vorteile machen eine deklarative Programmiersprache, wie sie der Software Composer bietet, zu einer guten Wahl für webbasierte Anwendungen. Und das unabhängig davon, ob die Anwendung einfach oder anspruchsvoll und umfangreich ist.

Kein Licht ohne Schatten

Die deklarative Programmierung hat auch Nachteile, die nicht unter den Teppich gekehrt werden sollen.

Einschränkungen
Eine deklarative Programmiersprache kann für einige Anwendungsfälle zu einschränkend sein, insbesondere für komplexe Aufgaben, die eine feinere Steuerung und detailliertere Eingriffe erfordern. In diesem Fall musst du auf die klassische Programmierung zurückgreifen. In der Regel ist dieser Anteil jedoch sehr gering.

Komplexität
Obwohl der Quellcode mit einer deklarativen Programmiersprachen oft kürzer und einfacher zu lesen ist, kann die Konstruktion von Bausteinen, Regeln und Bedingungen komplex und schwieriger zu verstehen sein.

Schwierigkeiten beim Debuggen
Wenn ein Fehler auftritt, kann es schwierig sein, die Ursache zu finden, da die Low Code Plattform die Bausteine, Regeln und Bedingungen auf eine Art und Weise ausführt, die du nicht direkt sehen und debuggen kannst.

Performance
Bei bestimmten Arten von Anwendungen kann eine deklarative Programmiersprache langsamer sein als eine klassische, imperative Sprache, da die Low Code Plattform eigenständig die Entscheidungen darüber trifft, wie die Bausteine, Regeln und Bedingungen umgesetzt werden.

Lernkurve
Die Konzepte und Praktiken, die in einer deklarativen Programmiersprache verwendet werden, können für dich ungewohnt sein und eine steile Lernkurve haben, insbesondere wenn du zuvor nur mit imperativen Sprachen gearbeitet hast. Wenn du allerdings mit Excel arbeitest und nicht gerade VBA-Makros programmierst (das wäre in der Tat eine imperative Programmierung), verwendest du im Grunde bereits eine deklarative Programmierung mit Formeln und Diagrammen.

 

Das soll dich jedoch nicht davon abhalten, die deklarative Programmiersprache und den Software Composer zu nutzen. Wenn du webbasierte Anwendungen mit dem Software Composer erstellst, überwiegen klar die Vorteile.

Fazit

Insgesamt bietet dir eine deklarative Programmiersprache eine leistungsstarke Möglichkeit, komplexe Probleme durch die Deklaration von Bausteinen, Regeln und Bedingungen zu lösen. Der Software Composer hilft dir, anspruchsvolle webbasierte Anwendung erstellen zu können.

Zudem ermöglicht dir die deklarative Programmierung, dich auf das "Was" zu konzentrieren, anstatt dich auf das "Wie" zu konzentrieren. Dies führt zu einem kürzeren und leichter verständlichen Quellcode. Sie bietet auch eine höhere Abstraktionsebene. Das bedeutet, dass du dich auf die Problemlösung konzentrieren kannst, anstatt dich mit Implementierungsdetails einer klassischen, imperativen Programmiersprache herumzuschlagen.

Allerdings haben deklarative Programmiersprachen im Allgemeinen auch Nachteile, wie die Einschränkungen bei den möglichen Einsatzgebieten, Schwierigkeiten beim Debugging und eine gegebenenfalls steilere Lernkurve aufgrund der für dich möglicherweise neuartigen Konzeption und Herangehensweise.

Bei der Erstellung von webbasierten Anwendungen überwiegen klar die Vorteile.

Wir benötigen Ihre Zustimmung zum Laden der Übersetzungen

Wir nutzen einen Drittanbieter-Service, um den Inhalt der Website zu übersetzen, der möglicherweise Daten über Ihre Aktivitäten sammelt. Bitte überprüfen Sie die Details in der Datenschutzerklärung und akzeptieren Sie den Dienst, um die Übersetzungen zu sehen.