Wie ist die fortschreitende Digitalisierung ohne Programmierung möglich? Durch interaktives Zusammenklicken vorgefertigter Softwarebausteine. Dadurch können Anwender und Power-User der Fachabteilungen viel besser in die Entwicklung ihrer Softwarelösungen einbezogen werden. So werden eine wirklich agile Softwareentwicklung und ein gemeinsames Erarbeiten optimaler Lösungen 'direkt am lebenden Objekt' möglich - durch Konzeption und Umsetzung in einem Zuge, mit modernen Methoden des Design Thinking über alle Projektphasen hinweg.
Foto: Gajus - shutterstock.com
Bei Low-Code geht es also nicht nur darum, Kosten zu sparen und schneller zu Ergebnissen zu kommen - es ist ein völlig anderer Ansatz, Softwarelösungen konzeptionell zu erarbeiten. Es geht auch darum, nicht am realen Bedarf vorbei zu entwickeln, und den gesamten Prozess der Konzeption, Entwicklung und Pflege in einem Maße zu flexibilisieren, wie man es sich bislang kaum vorstellen konnte. Das ist der Grund, warum Forrester Research den Low-Code-Plattformen eine Schlüsselrolle bei der Digitalisierung aller Geschäftsprozesse zuschreibt, und warum künftig kein Unternehmen mehr umhinkommen wird, für Low-Code-Plattformen eine Rolle in seiner IT-Strategie vorzusehen.
Softwareentwicklung ohne Programmierung: Wie geht das?
Schon seit langem arbeiten viele Innovatoren an immer neuen Ideen, um den äußerst langwierigen Prozess der Softwareentwicklung drastisch zu verkürzen. Und naturgemäß kommen dabei völlig unterschiedliche Lösungsansätze zum Tragen. Von den sogenannten 4GL-Sprachen der 90er Jahre über Computer-Aided Software Engineering (CASE) bis hin zur sogenannten Modellgetriebenen Softwareentwicklung. So ziemlich alles wurde versucht, um irgendwie Programmcode automatisch generieren zu lassen. Der Durchbruch aber kommt aus einer völlig andere Ecke: mit Plattformen, die die gesamte voraussichtlich benötigte Funktionalität bereits vorgefertigt parat halten, und die intern intelligent genug gebaut sind, dass man die Objekte und Features quasi nur noch zusammenstöpseln muss, ohne sich um die technischen Belange im Detail kümmern zu müssen.
Komplette Neuentwicklungen sind so nach wenigen Wochen statt nach vielen Monaten oder Jahren produktiv verfügbar, und Programmerweiterungen in Tagen statt in Monaten. Das ist ein Traum für die Verantwortlichen der Fachabteilungen - aber zugleich auch eine große Herausforderung für die IT-Verantwortlichen, die die Sicherheit und Stabilität der gesamten IT zu verantworten haben.
Die Bedenken, die da aufkommen, sind verständlich, aber die Vorteile von Low-Code-Ansätzen im Vergleich zur klassischen Softwareentwicklung sind so gravierend, dass man nicht umhinkommt, es trotzdem zu tun. Die etablierten Low-Code-Plattformen genügen heute bereits den höchsten Sicherheitsanforderungen, vielleicht sogar besser als manche handgeschriebene Software. Denn der Standardsoftwareansatz ermöglicht unter anderem auch Datensicherheit, Barrierefreiheit und vieles mehr 'out of the box'.
Was bedeutet das 'Low' in Low-Code?
Der von Forrester Research 2014 aufgebrachte Begriff Low-Code ist in mehrfacher Hinsicht gut gewählt. Nicht nur, dass die klangliche Assoziation andeutet, dass manchmal der Verzicht auf etwas Althergebrachtes sinnvoll sein könnte. Besonders treffend ist das 'Low': Zum einen ermöglichen Low-Code-Plattformen, mit wenig handgeschriebenem Programmcode auszukommen, und zum anderen kann man sich, wenn man doch mal etwas dazu programmieren muss, auf niedrigschwelligen Programmcode beschränken.
Damit ist gemeint, dass man sich auch mit IT-Basiswissen so einigermaßen darin bewegen kann. Auch wenn der Informatiker letztlich mehr herausholen kann, so kann ein Nicht-Informatiker zumindest den Code lesen und verstehen und auch verändern. Die Objektstrukturen sind bereits automatisch von der Plattform erzeugt, Programmschleifen 'über alle selektierten Datensätze' sind von Haus aus vorhanden, und alle gängigen Rechen- und Konvertierfunktionen liegen direkt zur Verwendung bereit. So kann sich sich das kleine bisschen Programmcode, das man hin und wieder mal ergänzen muss, auf vergleichsweise einfache Funktions- und Variablendefinitionen mit einfachen Aktionsfolgen und Verzweigungen beschränken.
Was ist ein 'Citizen Programmer'?
Die meisten Low-Code-Produkte zielen genau auf die Schnittstelle zwischen den zentralen IT-Abteilungen der Unternehmen und den eigentlichen Anwendern ab. Hierbei gibt es unterschiedliche Ausprägungen bei den Tools. Manche sind eher für Endanwender, andere dann doch eher für IT-Profis optimiert.
Die wichtigste Zielgruppe der Low-Code-Bewegung aber ist immer die, die genau dazwischenliegt: also IT-kundige Mitarbeiter der Fachbereiche, sowie IT-Spezialisten, die sich über viele Jahre hinweg so tief in die Themen der Fachabteilungen eingearbeitet haben, dass sie längst nicht mehr aktiv in der komplexen objektorientierten Programmierung zuhause sind. Für diese Gruppe von fach- und zugleich hinreichend IT-kundigen Mitarbeitern steht der neu erfundene Begriff 'Citizen Programmer'. Das ist jemand, der in der Fachabteilung zuhause, zugleich aber auch in der Lage ist, im Bedarfsfall mal etwas zu programmieren.
Es ist schon lange nicht mehr so, dass es im Unternehmen nur auf der einen Seite die um den CIO gescharten IT-Gurus, und auf der anderen Seite völlig IT-unkundige Fachleute gibt. In nahezu allen größeren Unternehmen hat sich längst eine sogenannte 'Schatten-IT' entwickelt, in der sich die Fachabteilungen um ihre eigenen Fachanwendungen selbst kümmern, mit mehr oder weniger Unterstützung aus der Zentral-IT - getrieben von Power Usern und fachlich orientierten Informatikern und Beinahe-Informatikern, die sich jetzt allesamt Citizen Programmer nennen können.
Mit oder gegen die Schatten-IT?
In manchen Unternehmen bemüht man sich, die Schatten-IT zurückzudrängen, aber das scheint ein aussichtloses Vorhaben zu sein. Vielfach ist die Eigen-IT der Fachbereiche heute wichtiger denn je, denn schließlich kommen die meisten Bedarfe und Ideen zur immer weitergehenden Digitalisierung meist aus den Fachbereichen, und nicht unbedingt aus der Zentral-IT.
Zentralistische Ansätze, etwa nach dem Prinzip 'wir machen alles mit SAP' sind für zentrale, klar geregelte und gut standardisierbare Aufgaben zweifelsfrei richtig. Dies muss aber nicht für die vielen kleinen Besonderheiten der Fachbereiche, über die sich die Unternehmen ja auch ganz bewusst vom Wettbewerb abgrenzen wollen, gelten. Zudem sind zentrale IT-Aufgaben durch die sehr ausgereiften ERP-Systeme bereits soweit durchdigitalisiert, dass sich die Frage stellt, was man denn außer den letzten Lücken, wie etwa der elektronischen Rechnung, noch weiter digitalisieren könne.
Ganz anders sieht es in den Fachbereichen aus. In den feinen Verästelungen des tagtäglichen Geschäfts ist die Digitalisierung noch ganz am Anfang. Und die Mitarbeiter der Fachbereiche wissen auch oftmals ganz genau, was man tun müsste, um ihre Prozesse weiter zu optimieren und zu automatisieren.
Die unzähligen Ideen aus den Fachbereichen stoßen dabei oft an die Kapazitätsgrenzen der Zentral-IT, und die Fachverantwortlichen verzweifeln an der Langwierigkeit der typischen ERP-nahen klassischen Softwareentwicklung und der damit verbundenen Entscheidungsprozesse. So kommt es, dass allzu viele Potentiale der Digitalisierung nicht genutzt werden.
Kein Wunder also, wenn sich die Fachbereiche großer Unternehmen zunehmend darauf konzentrieren, sich lieber selbst zu helfen. Die Zentral-IT kann und sollte diese Entwicklung als Chance aufnehmen, um diese Entwicklung nicht passiv zu erdulden, sondern selbst zu steuern und aktiv voranzutreiben.
Low-Code-Plattformen, die von der Zentral-IT unterstützt und betrieben werden, können helfen, Licht in die Schatten-IT zu bringen. Deshalb sollten Low-Code-Plattformen einen Platz in der IT-Strategie jedes Unternehmens finden.
Wie funktionieren Low-Code-Plattformen?
Im Detail folgen die einzelnen Produkte teils recht unterschiedlichen Konzepten. Allen gemeinsam ist aber, dass man eine Cockpit-ähnliche Entwicklungsplattform hat, mit der Browseranwendungen oder Apps interaktiv zusammengeklickt werden, und dass das Ergebnis des Zusammenklickens in irgendeiner strukturierten und deklarativen Form (z.B. als Metadaten in einer Metadatenbank) vorliegt, so dass die entsprechenden Programmteile jederzeit weiterentwickelt werden können.
Einige Low-Code-Plattformen sind streng an den Einsatz in der Cloud, und auch an eine Entwicklung in der Cloud gebunden, während andere Tools bzw. ihre Runtime-Systeme auch on-premise installiert werden können. Dementsprechend arbeiten einige interpretativ, benötigen also zur Laufzeit ein auf dem Server oder in der Cloud installiertes Laufzeitsystem. Andere Tools hingegen sehen sich als Weiterentwicklung der modellgetriebenen Softwareentwicklung und generieren ausführbaren Code, der dann im günstigsten Fall final ist, der also, um die Flexibilität nicht zu verlieren, nicht manuell weiter ausprogrammiert werden sollte.
Teils wird auch auf eine Kombination beider Methoden gesetzt, um zum einen hochinteraktiv am echten lebenden Objekt entwickeln und dennoch abschließend reinen Programmcode ausliefern zu können. Vermutlich ist das, zumindest für den Einsatz der fertigen Anwendungen im eigenen Rechenzentrum, der erfolgversprechendste Weg.
Nahezu allen Methoden gemeinsam ist, dass man im interaktiven Entwicklermodus nicht nur die Programme selbst, sondern auch das zugrundeliegende Datenmodell quasi in einem Zuge mitentwickelt. Ebenso interaktiv werden Datenbankabfragen und -sichten ganz einfach zusammengeklickt und dann jeweils geeignete Visualisierungen ausgewählt, z.B. Formular- oder Tabellenansicht bzw. Map-, Tree- oder Chart-Controls. Die Anbindung der Controls an die Datensichten erfolgt dabei weitgehend eigenintelligent.
Programmoberflächen werden aufgebaut, indem man sich die jeweiligen Datensichten in der gewählten Visualisierungsform einfach auf den Bildschirm zieht und miteinander verlinkt. Zum Feintuning des Layouts, und auch für solche Herausforderungen wie das Responsive Design, sowie für das Einbringen geeigneter zusätzlicher Bedienelemente, stehen dann Form Designer und andere herstellerspezifische Designwerkzeuge bereit.
Im Zuge diese Konfigurationen entsteht auch der Grundstock der benötigten Anwendungslogik automatisch, zumindest soweit sie sich bereits aus dem evolutionär entwickelten Datenmodell und aus diversen Eigenschaftsklassifikationen, die sich im Konfigurationsprozess so ansammeln, ableiten lässt.
Alle Anbieter verfolgen damit eine relativ einheitliche Grundmethodik, und man kommt damit erstaunlich weit. Die meisten Anwendungen sind tatsächlich fast fertig, ehe man das erste Mal an die Stelle kommt, wo ein Gap zwischen der automatisch mitgenerierten Integritäts- und Anwendungslogik und den realen Anforderungen an die Geschäftslogik aufkommt.
Ansätze für weitergehende Anforderungen an die Programmlogik
Diese Lücke versuchen nun die einzelnen Hersteller mit unterschiedlichen Ansätzen zu füllen. Einige Produkte setzen massiv auf das Prinzip regelbasierter Systeme, indem alle weiterführende Programmlogik in Form von bedingten Regeln definiert wird, beispielsweise in der Art von "Wenn Feld A größer als Null und Feld B kleiner als 100, dann muss Feld C größer sein als das Doppelte von Feld D", allerdings in herstellerspezifischen kompakten Notationen, die teilweise an Excel-Formeln erinnern.
Mit einem Mix aus unterschiedlichen Regeltypen, wie zum Beispiel Plausibilitäts-, Berechnungs-, Sichtbarkeits- und Zugriffsregeln lässt sich auf rein deklarative Weise sehr komplexe Anwendungslogik komplett beschreiben. Was zur Laufzeit mit den Regeln jeweils zu tun ist, das weiß die Low-Code-Plattform dann von selbst, so dass man sich auch hierbei auf die Inhalte konzentrieren kann und um die technische Umsetzung nicht kümmern muss. Der Charme solch regelbasierter Systeme ist die Einfachheit, mit der sich das Verhalten und die Eigenschaften von Daten umfassend beschreiben lassen.
Andere Hersteller setzen verstärkt auf graphische Werkzeuge, um Programmabläufe bildhaft darzustellen, auf eingebettete Workflow-Engines oder auf andere Mechanismen. Vermutlich werden hier in der nächsten Zeit noch etliche weitere spannende Konzepte aufkommen, um auch den letzten noch verbliebenen Herausforderungen so gut wie möglich zu begegnen.
Und schließlich gibt es noch einen Ansatz, der nahezu immer funktioniert: Er besteht darin, für besondere Anforderungen kleine handgeschriebene Programmbausteine ergänzen zu können, und zwar als niedrigschwelliger Code. Dieser greift direkt auf die automatisch generierten Objekte zu und kann mit diesen alles das tun, was das interaktive Klickersystem nicht von Haus aus abdeckt. Einige wenige Produkte verzichten auf diesen Weg, und nennen sich deshalb 'No-Code-Plattformen', allerdings bleibt zu bezweifeln, ob sich dieser hehre Anspruch auf Dauer aufrechterhalten lässt. Die Praxis zeigt, dass man doch immer mal wieder an den Punkt kommt, wo für bestimmte Spezialalgorithmen dann doch kleine eingebettete Low-Code-Scripts erforderlich sind.
So oder so, letztlich kommt man nicht umhin, zuzugeben, dass der Low-Code-Ansatz an sich in seinen Möglichkeiten endlich ist, gewissermaßen ein 98-Prozent-Ansatz. Während man theoretisch alles nur Denkbare programmieren kann, wird man hier immer mal wieder an Grenzen stoßen. Die Erfahrung zeigt aber, dass man bei der Entwicklung kundenspezifischer Softwarelösungen sowieso immer an Grenzen stößt. Und oftmals ist es weit weniger schmerzhaft, auf das eine oder andere Luxus-Feature technologiebedingt zu verzichten, als wenn ein theoretisch perfektes Programm niemals fertig wird und Termine und Budgetgrenzen letztlich weitaus härtere Restriktionen mit sich bringen.
Man könnte das so zusammenfassen: "Lieber 98 Prozent sofort fertig als 100 Prozent vielleicht irgendwann".
Und ganz viel zusätzlich 'out of the box'
Low-Code-Plattformen haben noch einen weiteren großen Vorteil. Da sie auf einem Fertigsoftware-Ansatz beruhen, können sie eine große Menge an Funktionalität standardmäßig mitbringen, deren Entwicklung im Einzelfall zu teuer wäre: Features, die Sie nur gelegentlich benötigen, dann aber sehr zu schätzen wissen werden.
Beispielsweise bringen viele Produkte gleich ihre eigene Test-, Freigabe- und Deployment-Umgebung mit. Andere wiederum punkten mit integrierten Reengineering-Werkzeugen oder mit einer 'mit einem Mausklick' zuschaltbaren Vollhistorisierung aller Änderungen in der Datenbank, mit eingebauten intelligenten Ad-hoc-Reportingwerkzeugen, eingebetteten Analysefunktionen oder vorimplementierten Webservice-Schnittstellen zu gängigen ERP-Produkten. Die Vielfalt an Möglichkeiten, was man hier noch so alles 'out of the box' mitliefern könnte, ist grenzenlos, und da ist für die Zukunft definitiv noch eine ganze Menge mehr zu erwarten.
Gängige Erweiterungen einiger Low-Code-Plattformen sind zum Beispiel einfach bedienbare Schnittstellengeneratoren, die direkt auf die Metabeschreibungen der Plattform abgestimmt sind, sowie leistungsfähige Systeme zur Output-Generierung, etwa zur Generierung von Microsoft Word-, Excel- und PowerPoint-Dokumenten, HTML-Dateien, E-Mails und vieles mehr.
Besonderheit: Sach- und Geodaten in einer Anwendung
Besonderes Highlight unter den Features, die dann eben einfach mal so mit dabei sind, ist die mehr oder weniger umfangreiche Ausweitung des Low-Code-Ansatzes auf den Umgang mit Geodaten.
Das ist sehr sinnvoll, weil heutzutage nahezu alles einen Geodatenbezug hat. Dergleichen mit händischer Programmierung im Einzelprojekt umzusetzen, erscheint aus Kostengründen fast unmöglich. Deshalb sind Low-Code-Produkte vielleicht auch der aussichtsreichste Weg zu bezahlbaren, kombinierten Sach- und Geodaten-Anwendungen, ohne hochspezialisierte Experten, die in beiden Welten zuhause sind.
Man kann sagen, dass die vielen Vorteile, die sich zusätzlich noch aus dem Standardsoftwareansatz ableiten lassen, die wenigen verbliebenen funktionalen Einschränkungen mehr als wettmachen.
Sind Low-Code-Plattformen schon erwachsen? Oder steckt das alles noch in den Kinderschuhen?
Die Antwort lautet: sowohl als auch.
Die Vorreiter der Low-Code-Idee sind schon viel länger auf dem Markt als der Begriff existiert. Einige sind schon über zehn Jahre erfolgreich im Echteinsatz und gehen auf zum Teil noch viel länger zurückliegende Entwicklungs- und Pilotierungsphasen zurück.
In den USA gibt es bereits seit geraumer Zeit sehr viel Erfahrung mit von Endanwendern selbst zusammengeklickten Kleinstanwendungen, die dann in der Regel auch nur in der Cloud, also völlig losgelöst von der Zentral-IT,-betrieben werden, oder die sich um cloudbasierte CRM-Lösungen herumranken.
In Deutschland setzen die frühen Anbieter eher auf die Kooperation zwischen zentraler und dezentraler IT, und können auf zum Teil beeindruckende, komplett mit Low-Code-Technologien umgesetzte Großprojekte als Referenz verweisen. Solche Lösungen werden dann zumeist on-premise in den Rechenzentren der Kunden installiert, und sie werden dafür auch als generierter Programmcode frei von Runtime-Komponenten ausgeliefert.
Die Eignung der Low-Code-Technologie, sowohl für Klein- und Kleinstanwendungen als auch für große und kritische IT-Projekte, ist längst nachgewiesen. Und auch der Nachweis, dass die großen Versprechungen hinsichtlich Schnelligkeit und Flexibilität, Anwenderzufriedenheit und Projektsicherheit tatsächlich erfüllt werden, ist erbracht.
Die wirtschaftliche Vernunft spricht derart massiv für den flächendeckenden Einsatz von Low-Code-Plattformen für typische dezentral entwickelte Fachanwendungen, dass es verwundert, wieviel Vorbehalte dem immer noch im Wege stehen.
Auf der anderen Seite aber schießen seit der Namensgebung für die Technologie durch Forrester Research, und seit den damit verbundenen atemberaubenden Umsatzprognosen Start-ups mit immer neuen Low-Code-Produkten wie Pilze aus dem Boden. Dutzende neue Anbieter, zumeist mit viel Venture Capital ausgestattet, beleben die Szene auf beeindruckende Weise. Welche davon sich am Markt behaupten werden, und welche der von diesen aufgebrachten neuen Ideen die Technologie insgesamt weiter vorantreiben werden, bleibt abzuwarten. Die Technologie als solche ist ausgereift, aber durchaus noch offen für weitere Innovationen.