Effizienz bei der Entwicklung steigern

Mit der zunehmenden Bedeutung der IT steigt auch der Bedarf an individuellen Software-Lösungen. Unternehmen erkennen, dass die Digitalisierung der Geschäftsprozesse vermehrt zu einem Wettbewerbsfaktor wird. In vielen Branchen scheint die Zukunft das nahezu vollständig digitalisierte Unternehmen zu sein.

Die Digitalisierung wirkt dabei auf alle Bereiche entlang der Wertschöpfungskette. Beispielsweise werden Zulieferer über vollständig integrierte Schnittstellen angebunden. Da­rüber erfolgt der Austausch der notwendigen Daten für die Bestellung der Vorprodukte, Materialien und Werkstoffe. Auf der anderen Seite der Wertschöpfungskette kommunizieren die Unternehmen verstärkt digital mit ihren Kunden. Das beginnt bei der Produktpräsentation, setzt sich beim automatischen Bestellprozess fort und umfasst auch die Zeit nach dem Kauf mit Service- und Wartungsangeboten. Ein Blick in die Unternehmen selbst zeigt, dass die Produktionsprozesse immer autonomer und selbstgesteuerter ablaufen. Routinetätigkeiten werden durch voll vernetzte Industrieroboter übernommen, die weitgehend eigenständig mit den anderen IT-Systemen agieren.

Um diese Anforderungen zu realisieren, müssen Geschäftsprozesse digitalisiert und Software-Werkzeuge bereitgestellt werden. Die Rolle der IT wandelt sich vom Unterstützer der  Effizienzsteigerung zum Treiber von Innovationen. Um dieses Ziel zu erreichen, muss es gelingen, individuelle Software-Lösungen zeitnah und qualitativ hochwertig zur Verfügung zu stellen.

Die Ressourcen der IT-Abteilungen hinsichtlich des Budgets und des Per­sonals können mit dem beschriebenen Bedarf an Software kaum Schritt halten. Das zwingt die Beteiligten, in allen Phasen des Software-Lebenszyklus nach effizienten Lösungen zu suchen und diese zu etablieren.

Gut funktionierende und bekannte Ansätze in technischer und organisatorischer Hinsicht sind eine agile Projektsteuerung, eine Beschleunigung des Entwicklungsprozesses durch sogenanntes Rapid Application Development (RAD), der Einsatz von Low-Code-Plattformen und die Etablierung von DevOps zur Verbesserung der Zusammenarbeit zwischen den Beteiligten, um Entwicklung und Betrieb möglichst nahtlos zu integrieren.

Trotz agiler Vorgehensweisen und dem damit verbundenen Ziel einer weitgehend flexiblen Durchführung sollten zu Beginn eines Projekts die Anforderungen erhoben werden. Wichtiger Bestandteil ist in der Regel auch das frühzeitige Erstellen von Prototypen. Diese sollen möglichst schnell zur Verfügung stehen und einen ersten Eindruck vom User Interface (UI) des künftigen Software-Systems vermitteln. Anhand dieser Prototypen können die Beteiligten die Umsetzung der Anforderungen validieren und einen möglichen Änderungsbedarf erkennen.

Der Vorgang wird mit Blick auf die schnelle und zeitnahe Durchführung auch als Rapid Proto­typing bezeichnet und ist ein essenzieller Bestandteil eines modernen, professionellen Entwicklungszyklus.

Wenn die Design- und Entwicklungswerkzeuge geschickt ausgewählt, konfiguriert und eingesetzt werden, kann es gelingen, schnell und ohne Systembrüche Prototypen der künftigen Software zu erstellen und damit die Zusammenarbeit der Experten aus den Fachabteilungen, der Designer und Entwickler spürbar zu verbessern.

Der Erfolg der Software-Entwicklung ist zu einem sehr hohen Maß von den organisatorischen Belangen und der Art und Weise der Projektdurchführung abhängig. In der Praxis haben sich zwei Ansätze bewährt, die gemeinsam ein solides Fundament der modernen Entwicklung bilden können. Die Rede ist von einer agilen Vorgehensweise und der integrativen Zusammenarbeit durch DevOps.

Agilität steht für die Fähigkeit, mit Änderungen umzugehen, das heißt schnell und flexibel auf Kundenanforderungen zu reagieren. Änderungen in den Anforderungen werden nicht mehr als störend aufgefasst, sondern tragen dazu bei, dass das Anwendungssystem frühzeitig in die richtige Richtung gesteuert wird. Ein wesentliches Ziel dieses Vorgehens ist es, in möglichst kurzer Zeit eine erste Version des späteren Endprodukts an den Kunden auszuliefern und bereits in sehr frühen Phasen des Entwicklungsprozesses mit Prototypen zu arbeiten und Feedback einzufordern. Das Feedback wiederum ist die Ausgangsbasis dafür, mögliche Modifikationen zeitnah in den weiteren Projektverlauf einzuarbeiten.

Rapid Prototyping sorgt dafür, dass man sowohl eine Be­stätigung der Richtung (Strategie) als auch der Umsetzung (Operation) bekommt und bei Bedarf reagieren kann. Ein schnelleres Go-live ist das Ziel. Es gibt unterschiedliche Ansätze agiler Entwicklungsmethoden. Scrum gilt heute als sehr weit verbreitet, hat sich vielfach bewährt und ist gut akzeptiert.

Der Begriff DevOps setzt sich zusammen aus Dev für Development und Ops für Operations. Damit wird ein Schulterschluss zwischen den Mitarbeitern beider Bereiche symbolisiert. Dieser Ansatz versucht, den Graben zwischen diesen wichtigen Gebieten der IT zu überwinden, der vor allem aus Zielkonflikten resultiert. Demnach ist der Entwicklungsbereich stark daran interessiert, die implementierten Features möglichst kurzfristig an die Nutzer der Software auszuliefern. Dem IT-Betrieb ist dagegen vorrangig an einem kontinuier­lichen und sicheren Betrieb der gesamten IT-Landschaft gelegen. Die Übernahme von Software-Updates stellt in diesem Sinn stets einen Eingriff in das laufende System dar und kann dessen Stabilität immer bedrohen. Statt kurzfristiger und häufiger Releases werden lange Laufzeiten und umfassend geplante Updates bevorzugt.

Diese Form der Arbeitsteilung ist heute überholt. DevOps zielt also genau darauf ab, die Prozesse in Unternehmen von der Entwicklung über die Bereitstellung in der Produktion bis hin zur Wartung von Software so miteinander zu verzahnen, dass die beschriebenen Herausforderungen gelöst werden. Das kann nur dann gelingen, wenn die gegenläufigen Ziele einer Software-Entwicklung und der Anspruch eines sicheren und stabilen Betriebs in Einklang gebracht werden. Vo­raussetzung ist, dass sich die Personen und das Team als Ganzes stetig an die neuen Herausforderungen anpassen.

DevOps ist zwar ein Thema, das in der Informationstechnik angesiedelt ist, aber im Kern mit der Entwicklung der Organisation in Verbindung steht (Change-Management). Damit ist auch klar, dass DevOps eine Aufgabe des Managements ist und kein technischer Ansatz. Der Lernprozess muss daher von der Ebene des Managements initiiert werden, sonst bleibt er stecken.

Mittels agiler Software-Entwicklung und DevOps wird nun versucht, die „Lücken“ im Entwicklungsprozess zu schließen. Die Ansatzpunkte sind folgende: Das Requirements Engineering stößt an seine Grenzen, wenn es versucht, die Anforderungen an das zu entwickelnde System im Vorhinein quasi generalstabsmäßig zu planen und auch umzusetzen. Wie man es besser machen kann, zeigen agile Methoden, zum Beispiel Scrum. DevOps schließt die Lücke innerhalb der IT und hat sehr viel mit Organisation und einem Veränderungsbewusstsein der Mitarbeiter zu tun. Werden beide Ansätze umfassend, korrekt und vor allem durchgängig angewendet, dann entsteht eine neue Form des Software-Lebenszyklus.

Dabei arbeiten von der ersten Idee und der Erhebung der Anforderungen über das Development bis hin zur Bereitstellung der Software alle Beteiligten zusammen. Lücken und Systembrüche werden weitgehend vermieden. Der gesamte Vorgang wird agil gestaltet, sodass Änderungen in den Anforderungen und Rahmenbedingungen kein Dilemma mehr darstellen. Die Verantwortung der Beteiligten aufseiten der IT ist stets umfassend und nicht an Silos gebunden. Vielmehr hat man es mit einem multidisziplinären Team zu tun, dessen Ziel eine zügige und qualitativ hochwertige Software ist. Damit dies funktionieren kann, sind die passenden Werkzeuge notwendig.

In der Software-Entwicklung werden schon immer umfassend Werkzeuge verwendet, um den Prozess der Entwicklung neuer Applikationen zu beschleunigen. Es gilt, die bestmögliche Tool-Unterstützung für die jeweilige Aufgabe zu finden. Weder ein sogenanntes Overtooling noch ein zu minimalistischer Werkzeugeinsatz sind zielführend, wenn es um eine hohe Effizienz des Entwicklungszyklus geht. Bei einem zu geringen Werkzeugeinsatz werden zu viele Auf­gaben manuell erledigt, obwohl es dafür ausgereifte und passende Tools gibt, die die Arbeit vereinfachen und beschleunigen. Ist der Werkzeugeinsatz zu umfassend, dann leidet die Flexibilität. Trotz ähnlicher Aufgabenstellungen und einem hohen Maß an Wiederverwendung sind in der Regel indi­viduelle Ansätze gefragt. Das bedeutet: Der Tool-Einsatz ist sorgfältig abzuwägen. In vielen Bereichen bedient man sich Rapid-Application-Development- beziehungsweise Low-Code-Tools.

Rapid Application Development (RAD) steht für schnelle Anwendungsentwicklung. Der Begriff wurde in den 1980er-Jahren als Konzept der Software-Entwicklung nach dem prototypischen Vorgehensmodell erdacht. RAD dient dazu, die Software-Entwicklung im Vergleich zu klassischen Vorgehensmodellen flexibler zu gestalten und sie an sich schnell ändernde Anforderungen anpassen zu können. Ursprüngliche Grundlage ist das Spiralmodell, das ein prototypisches Vorgehen vorsieht. Selbstverständlich ist dieses Konzept auch auf agile Modelle übertragbar.

Werkzeuge für Rapid Application Development haben üblicherweise gemeinsam, dass man die Bedienoberfläche mit Hilfe eines Designers per Drag and Drop und über die Anpassung von Eigenschaften erstellen kann. Darüber hinaus stehen nicht visuelle Komponenten zur Verfügung, beispielsweise um mit einer Datenbank aus der Applikation zu interagieren oder um einen Dateidialog aufzurufen. Über Extensions, Plug-ins oder externe Bibliotheken lässt sich das Angebot der Komponenten  meist vielfältig erweitern.

Das Ziel von RAD-Tools ist es, den Entwickler von Routineaufgaben der Software-Entwicklung zu entlasten. Damit wird die Effizienz des Entwicklungsprozesses auf vielen Ebnen verbessert und die Time-To-Market beschleunigt.

Low-Code-Tools gehen noch ein Stück weiter. Durch deren Einsatz möchte man die Entwicklung von Business-Anwendungen teilweise den Fachabteilungen überlassen. Dafür gibt es gute Gründe. Zum einem sind Entwicklungskapazitäten knapp und zum anderen steigt der Bedarf an individuellen Software-Lösungen in Unternehmen stetig. Technikbegeisterte und versierte Anwender in den Fachabteilungen, sogenannte Citizen Developer, sind durchaus in der Lage, einen Teil der Entwicklungsaufgaben zu übernehmen. Dazu werden ihnen hochintegrierte Tools an die Hand gegeben, die ihnen das weitgehende Erstellen von Software-Lösungen erlauben. Diese Tools werden als Low-Code-Plattformen bezeichnet. (Eine Sonderform sind No-Code-Plattformen; hier ist für die Erstellung von Software überhaupt kein Code erforderlich.) Low Code steht für möglichst wenig Code-Einsatz. Typischerweise werden Low-Code-Plattformen für Anwendungen aus den Bereichen Vertrieb, Marketing oder Produktionsplanung genutzt. Sie haben also das Ziel, wiederkehrende Aufgaben der Software-Entwicklung zu standardisieren.

Dabei setzen sie nicht auf technischer Ebene an, es geht also nicht um die Wiederverwendung von Programm-Code, sondern ihr Fokus ist die Ebene der Funktionen einer Software (Use Cases). Hier gibt es viel Standardisierungs-Po­tenzial. Typische sich wiederholende Aufgaben sind zum Beispiel: formularbasierte Datenerfassung, Validierung der Daten, Bereitstellung der Bedienoberfläche, lokale Datenhaltung, Umsetzung eines spezifischen Workflows und Anbindung der neuen Software an die bestehende Unternehmens-IT.

Eine spezielle Ausprägung sind die erwähnten No-Code-Systeme, die eine Software-Bereitstellung ohne Codierung versprechen. Das kann nach dem heutigen Stand der Technik jedoch nur für sehr begrenzte Aufgabenbereiche funk­tionieren.

Die organisatorische Gestaltung des Entwicklungsprozesses und der geplante Werkzeugeinsatz sollten Hand in Hand gehen. Um die Effizienz des Entwicklungsvorhabens nicht auszubremsen, sollte es gelingen, Systembrüche zu vermeiden, die etwa ein Wechsel der Werkzeuge verursachen könnte. Ein solcher Systembruch könnte zum Beispiel beim Übergang von der Konzeptionsphase (Erstellen der Prototypen) hin zur Implementierung (endgültige technische Umsetzung) auftreten. Idealerweise klappt es, beide Teilprozesse durchgängig zu gestalten, das bedeutet das Entwicklungsvorhaben möglichst nahtlos abzuwickeln und damit Verständnisprobleme und Doppelarbeiten größtenteils zu umgehen.

Diesen Gedanken kann man versuchen aufzugreifen und im gesamten Entwicklungsprozess umzusetzen. Viele Tools unterstützen eine solche Herangehensweise. In vielen Fällen sind dazu nur etwas Organisation und eine Feinabstimmung der Werkzeuge zwischen den Beteiligten notwendig. Das gemeinsame Ziel besteht also darin, von der Idee bis zur Entwicklung möglichst aus einen Guss zu arbeiten.

Unternehmen entscheiden sich heute bei der Neukonzeption oder auch bei der Software-Migration häufig für Web-App­likationen. Diese Anwendungen weisen die folgenden Vorzüge auf:

Installation: Es ist lediglich eine Installation auf dem Server notwendig. Die Clients greifen über das Netzwerk beziehungsweise das Internet mit Hilfe eines Browsers zu.

Aktualität: Web-Applikationen sind aus Sicht des Nutzers stets aktuell. Updates werden direkt auf dem Server installiert.

Mehrbenutzerbetrieb: Ein Mehrbenutzerbetrieb ist für eine Web-Applikation in der Regel der Standard.

Systemanforderungen: Man kann von jedem System mit nahezu jedem beliebigen Browser arbeiten, das heißt, man kann Web-Applikationen auch auf weniger leistungsfähiger Hardware oder unterschiedlichen Betriebssystemen ausführen.

Kosten: Die Wartungs- und Bereitstellungskosten liegen meist um ein Vielfaches unter denen einer Desktop-Anwendung.

Es gibt verschiedene Technologien für die Umsetzung von Web-Applikationen. Insbesondere kann danach unterschieden werden, welche Aufgaben vom Client und welche vom Server übernommen werden. Dem Entwickler steht eine Vielzahl technischer Ansätze und Frameworks zur Verfügung. Von erheblichem Nachteil sind dabei sehr häufig die Komplexität der Anforderungen, die vielen unterschiedlichen Technologien und - daraus resultierend - ein oft ineffizienter Entwicklungszyklus.

Die Auswahl des passenden Technologie-Stacks wird unter anderem durch die folgenden Aspekte bestimmt:

Eignung: Bietet das Framework die passende Unterstützung zur Realisierung der Anforderungen?

Beständigkeit: Unternehmensanwendungen werden über lange Zeiträume eingesetzt. Ist davon auszugehen, dass das Framework noch für eine absehbare Zeit gewartet und weiterentwickelt wird?

Lernkurve: Wie groß ist der Einarbeitungsaufwand? Kann auf vorhandene Kenntnisse der Programmierer aufgebaut werden?

Tooling: Auf welche Art und Weise wird das User Interface erstellt?

Business-Applikationen, die vom Desktop ins Web wandern sollen, sind oft durch komplexe Bedienoberflächen gekennzeichnet. Eine Vielzahl von Einzeldialogen mit umfassenden Dateneingabefeldern und Auswahloptionen ist die Regel. Eine schnelle Time-to-Market ist für die beauftragenden Unternehmen ein wichtiges Kriterium.

Es gibt Ansätze, wie aus Entwicklersicht auch Web-Applikationen sehr effektiv realisiert werden können, zum Beispiel mit dem Framework Wisej. Wisej wählt einen RAD-Ansatz, um eine Web-Applikation mit primärem Business-Kontext zu erstellen. Entwicklern gelingt es damit auch ohne tiefere Kenntnisse in den Web-Technologien, moderne Applikationen zu bauen. Alternativ kann C# oder VB .NET als Programmiersprache eingesetzt werden, um in Visual Studio zu entwickeln. Mit Hilfe eines grafischen Designers erstellt man das User Interface auf der Basis von Komponenten. Die Vorgehensweise ist den meisten Entwicklern vertraut, denn seit vielen Jahren werden auf diese Art und Weise Desktop-Anwendungen erstellt. Die Komponenten von Wisej sind weitgehend zu Windows-Forms-Komponenten kompatibel, sodass Wisej auch für größere Migrationsvorhaben sehr gut geeignet ist.

Während der Programmierung muss man sich keine Gedanken über das Zusammenspiel von HTML5, CSS3 und Java­Script machen. Man kann sich vollständig auf die Umsetzung seines Geschäftsmodells und eines ansprechenden User Interfaces kümmern. So können Designer und Entwickler direkt in Zusammenarbeit mit dem Fachanwender das User Interface der Dialoge und Eingabemasken gestalten. Die Praxis hat gezeigt, dass dieses Vorgehen auch bei Applikationen gelingt, die eine sehr große Anzahl an interaktiven Elementen enthalten. Die Entwicklung des User Interfaces kann direkt im grafischen Designer gestartet werden, frühe Prototypen erlauben eine schnelle Abstimmung und es wird daraus sofort eine erste produktionsfähige Version generiert. Es gibt eine große Auswahl an Standardkomponenten, die durch Extensions erweitert werden können. Der Entwickler wählt die passenden Komponenten für das User Interface aus der Tool-Palette aus und platziert diese auf den Formularen.  Diese Komponenten basieren auf .NET und werden zur Entwurfszeit im Designer erstellt. Die Programmlogik wird über Events verknüpft. Wisej Widgets bilden die serverseitig verwendeten Komponenten für die Darstellung im Client ab. Es besteht auch die Möglichkeit, Third-Party-Komponenten einzubinden.

Auf diese Weise ist es möglich, den Ansatz des Rapid Application Developments auch auf Web-Applikationen anzuwenden. Bei der Auswahl einer Entwicklungsumgebung sollten daher auch verstärkt Argumente eine Rolle spielen, die effiziente Prozesse gewährleisten.

Bekannte RAD-Entwicklungsumgebungen sind zum Beispiel Visual Studio, RAD Studio und RapidClipse. Solche Werkzeuge arbeiten wie erwähnt alle nach einem ähnlichen Prinzip. Die Bedien­oberfläche der zu programmierenden Software lässt sich mit der Maus zusammenklicken. Mit nicht visuellen Komponenten ist es möglich, mit einer Datenbank zu interagieren. Da­rüber hinaus lassen sich viele dieser RAD-Entwicklungsumgebungen um zusätzliche Komponenten erweitern. Hierfür unterstützen sie zum Beispiel entsprechende externe Bibliotheken.

Anwender in den Fachabteilungen, Analysten und Designer versuchen das Konzept der künftigen Software bestmöglich in Form eines visuellen Prototyps zu entwerfen. Zur Anwendung kommen dabei spezialisierte Programme wie Balsamiq oder Photoshop. Die entstehenden grafischen Entwürfe werden dann an die Entwickler weitergegeben.

Durch den Wechsel der Arbeitsebene und der verwendeten Werkzeuge kann es zu Problemen kommen:

Diese typischen Probleme treten immer dann auf, wenn bei der Entwicklung des Prototyps die realen Gegebenheiten der Zielplattform und der Entwicklungsumgebung nicht ausreichend beachtet werden. Mit anderen Worten: Der Prototyp ist praktisch und technisch nicht oder nur unter größeren Anpassungen umsetzbar.

Um diese Probleme zu vermeiden, sind umfassende Absprachen notwendig. Idealerweise hat man bei der Erstellung des Prototyps auch nur die gestalterischen Elemente zur Verfügung, die sich später technisch auch wirklich realisieren lassen.

Eine mögliche Lösung besteht darin, dass man entsprechende Templates für den Prototyping- und Designprozess zur Verfügung stellt. Wie das gelingen kann, lässt sich beispielhaft anhand der Arbeit mit der integrierten Entwicklungsumgebung RAD Studio verdeutlichen. Mit RAD Studio können geräteübergreifende Anwendungen, also sowohl für den Desktop (Windows, MacOS, Linux) als auch für die mobilen Systeme (Android, iOS) erstellt werden. Das User Interface wird durch den Entwickler auf der Basis der geräteübergreifenden User-Interface-Bibliothek FireMonkey vollständig im grafischen Designer der Entwicklungsumgebung realisiert.

Die Auswahl und die Bezeichnung der Designelemente zur Gestaltung des User Interfaces sind dann im Design-Tool und in der Entwicklungsumgebung identisch. Es entstehen auf diese Weise direkt umsetzbare Prototypen. Mit Hilfe von Templates kann man vorgefertigte Entwürfe für typische und häufig auftretende Anwendungsfälle schnell umsetzen. So wird das Thema Wiederverwendung auf die Teile des User Interfaces und der Arbeit des Konzept- und Designentwurfs ausgeweitet. Statt immer wieder im sprichwörtlichen Sinn das Rad neu zu erfinden, hat man eine Auswahl an Temp­lates für vollständige Screens zur Verfügung.

Viele technische und organisatorische Ansätze optimieren die Vorgehensweise des Entwicklungsprozesses. Mit Rapid Prototyping, einer sehr gut geplanten Zusammenarbeit von Anwendern und der Auswahl und Abstimmung der passenden Werkzeuge kann bereits am Anfang des Software Lifecycles für eine erhebliche Beschleunigung des Projektstarts gesorgt werden.

Der Prototyp ist damit  kein „Luftschloss“, sondern ein erstes produktionsfähiges Muster der späteren Applikation.