Intuitive Benutzeroberflächen und Visualisierungsmöglichkeiten sind gerade in Zeiten von Big Data entscheidend, damit die vorhandene Datenflut im richtigen Moment vollständig beurteilt und entsprechende Entscheidungen getroffen werden können. Es muss jedoch nicht immer eine komplexe Weboberfläche sein, die über Webdienste auf einen unternehmensweiten Server zugreift. Oftmals handelt es sich dabei schlicht um eine einfache LED direkt am intelligenten Knoten, die bei der Entwicklung oder Wartung erste allgemeine Informationen über den Zustand der jeweiligen Systemkomponente anzeigt.
Doch gerade diese Bandbreite stellt insbesondere kleine Entwicklerteams vor große Herausforderungen. Denn für die jeweilige Visualisierung müssen unterschiedliche Programmiersprachen oder Entwicklungswerkzeuge eingesetzt und für den Zugriff auf globale Daten Sicherheitsmechanismen implementiert werden. Zusätzlich erwarten Anwender eine ähnliche Bedienbarkeit wie bei Consumer-Geräten, in die in der Regel hunderte Stunden Entwicklungsarbeit geflossen sind.
Programmierung mit abstrakten Bausteinen
Wie ist dieser Komplexität also zu begegnen? Ein erster Ansatz läge darin, die Programmierprinzipien zu vereinfachen. So wären kleine Entwicklungsteams mit sehr spezifischem Fachwissen in der Lage, Technologien und Konzepte zu nutzen, die sonst nur Embedded- oder Softwareentwicklern zur Verfügung stehen. Bereits 1977 beschrieb John W. Backus, dass die grundlegende Computerarchitektur, die auf einer textbasierten Programmierung beruht, insbesondere Programmierer vor enorme geistige Herausforderungen stellt. Dabei zeigt er auch ein erstes Lösungskonzept auf: eine Programmierung, die mit größeren oder, anders ausgedrückt, abstrakteren Bausteinen arbeitet.
Wie könnte eine solche Programmierung nun aussehen? Eine schwierige Aufgabe, der textuelle Programmierer gegenüberstehen, ist das Verständnis der Verknüpfungen der vielen Funktionsaufrufe in einer Software – insbesondere beim Einsatz von objektbasierter Software. Ein gängiges Hilfsmittel für Programmierer sind hier Stift und Papier. Dabei werden die Funktionen als Blöcke aufgezeichnet und mit dem aufrufenden Programm verbunden, was dem Programmierer einen Überblick über den komplexen Code zu verschafft.
Viele Entwicklungsumgebungen bieten zudem Werkzeuge, die beispielsweise Klassenabhängigkeiten direkt grafisch abstrahieren. Oft werden vor der eigentlichen Programmierung auch grafische Ansätze gewählt, wie das Nassi-Shneiderman-Diagramm oder ein Zustandsübergangsdiagramm, um das spätere Programm zu beschreiben. Warum diese Konzepte also nicht direkt für die Programmierung nutzen und so von diesen abstrahierten und besser verständlichen Konzepten Gebrauch machen?
Ein Schritt dahin wäre es nun, alle Softwarewerkzeuge zusammenzuführen. Dadurch ließen sich grundlegende und häufige Arbeitsabläufe wie beispielsweise das Verwenden von Tastenkürzeln, das Speichern von Daten beziehungsweise Informationen und das Konfigurieren der Umgebung vereinheitlichen und somit einfacher handhaben. Dies würde auch die Einarbeitung neuer Nutzer beschleunigen, da sie unabhängig vom Einsatzbereich immer die gleiche Softwareumgebung nutzen. Hierfür müssten jedoch zunächst die Entwicklungsumgebungen für die Oberflächengestaltung nahtlos mit denen für die Anwendungsentwicklung kombiniert werden.
Im nächsten Schritt sollte sich mithilfe entsprechender Funktionen auch die Hardware nahtlos integrieren lassen. Das bedeutet, dass für nahezu jedes Messgerät, jede Schnittstelle oder jedes Bussystem auch die erforderlichen Treiber und
Bibliotheken zur Verfügung gestellt werden. Die Verwendung einheitlicher Grundprinzipien würde auch hier wieder für weniger Komplexität bei der Programmierung von Geräten sorgen. Vorgefertigte Bibliotheken und Frameworks würden insbesondere kleinere Entwicklerteams entlasten, da diese auf vertrauenswürdigen Code aufbauen könnten und lediglich neue Module oder Teilkomponenten für fertige Softwareframeworks entwickeln müssten.
Zusätzlich werden Softwarewerkzeuge benötigt, die die Entwicklungsprozesse unterstützen, indem sie für eine hohe Codequalität sorgen und erforderliche Normen und Standards erfüllen. Dazu zählen Werkzeuge, mit denen sich festgelegte Anforderungen und Spezifikationen verfolgen lassen und die dem Anwender somit einen besseren Überblick über den aktuellen Entwicklungsstand verschaffen. Des Weiteren gehören dazu Anwendungen aus dem Bereich Softwaretest, wie zum Beispiel fertige Frameworks für das Testen von Software, Analysewerkzeuge, die den Code anhand bestimmter Qualitätsrichtlinien überprüfen und begleitende Werkzeuge zur Verwaltung von Quellcode. All diese Werkzeuge müssen konfiguriert und eingesetzt werden. Die nahtlose Integration dieser Werkzeuge in eine Entwicklungsumgebung ermöglicht dank der einheitlichen Anwendungsumgebung auch hier wieder eine intuitive Bedienung. Darüber hinaus lassen sich, abhängig von der Implementierung, auch Updates beziehungsweise die Wartung der Software mit weniger Aufwand durchführen.
Eine weitere nicht zu vernachlässigende Komponente ist das Training. Wissen kann auf vielen Wegen erworben werden, sei es mithilfe von Trainingskursen, Online-Schulungen,
Whitepapern, Tutorien oder Diskussionsforen. Öffentliche Anwendertreffen bieten Entwicklern eine gute Gelegenheit, stets auf dem Laufenden zu bleiben und sich über den eigenen Firmenhorizont hinaus Ideen und Inspirationen zu holen.
Entwicklungsumgebung Labview
In der Summe ergeben all diese Ansätze eine Entwicklungsumgebung, die durch ihre Durchgängigkeit, Abstraktionsfähigkeit und nahtlose Hardwareintegration eine deutlich effizientere Programmierung erlaubt. Jeff Kodosky, der geistige Vater der Entwicklungsumgebung Labview, hatte genau das im Sinn. Mithilfe der visuellen, datenflussorientierten Programmierung, die komplexe Funktionen durch grafische Blöcke und die Übertragung von Daten zwischen diesen Blöcken durch Verbindungen darstellt, kann der Anwender auch ohne umfassende Erfahrungen in der Softwareentwicklung Applikationen erstellen.
Trotz des hohen Abstraktionsgrades der Entwicklungsumgebung müssen jedoch auch in Labview Kenntnisse erworben werden. Hierfür bietet National Instruments neben vielfältigen kostenfreien Informationen in Form von Webcasts, Tutorien und Whitepapern auch ein umfassendes Trainingsangebot, um zukünftigen Labview-Entwicklern eine möglichst effiziente Lernkurve zu ermöglichen. Mithilfe umfangreicher Funktionsbibliotheken, die von mathematischen Analysefunktionen über Speicherfunktionen bis hin zu Steuer- und Regelalgorithmen reichen, lassen sich Anwendungen zudem noch schneller implementieren.
Auch eigens entwickelter Code kann in Funktionsblöcke umgewandelt und wiederverwendet werden. Häufig ist der benötigte Funktionsblock aber bereits in der Community oder als getestete Bibliothek im Labview-Tools-Network verfügbar. Und dank der über 10.000 Gerätetreiber im ID Network und der zahlreichen weiteren Bibliotheken für nahezu jede Schnittstelle lässt sich mit Labview so gut wie jede Hardware in eine Applikation einbinden. Durch die aktive Anwendergemeinde und die kontinuierliche Weiterentwicklung von Labview stehen auch zahlreiche Werkzeuge für die begleitenden Prozesse bei der Softwareentwicklung zur Verfügung. Diese sind bereits in die Entwicklungsumgebung integriert und können so zügig verwendet werden.
Labview kommt mit seinem grafischen Ansatz und den vorgestellten Konzepten einer idealen Entwicklungsumgebung zwar schon sehr nahe, dennoch gibt es noch viel zu tun. National Instruments hat über die letzten Jahrzehnte viel Entwicklungsarbeit in Labview investiert, um die optimale Entwicklungsumgebung zu schaffen. Es bleibt spannend, was uns hier in den nächsten Jahren noch erwartet.
.jpg "Mit Phosphor zu optoelektronischen Bauelementen")
