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.