In der Softwareentwicklung geht es nicht darum, einfach mit dem Programmieren loszulegen. Es braucht Planung, Überlegung und Strukturierung. Gleiches gilt für das Arbeiten mit Embedded Systems. Denn bei der Hardware-Software-Integration stoßen Entwickler:innen auf ganz neue Hürden.
Generell gilt: Erst denken, dann machen!
Starten ohne gute Vorbereitung
Kläre, die Definition of Done und Ready
Fange niemals an, bevor Du nicht die feste Zusage von Deinen Kund:innen hast. Ohne arbeitest Du im Zweifel unentgeltlich und umsonst. Zu der Zusage gehört auch, das Gespräch zu suchen. Ihr müsst im Lasten- und Pflichtenheft oder über anderem Wege alle grundlegenden Strukturen sowie Aufgaben klären. Wann gilt das Projekt als abgeschlossen – ist die Definition of Done (DoD) erreicht? Was braucht es, damit Du Deine Arbeit beginnen kannst – wann ist die Definition of Ready (DoR) erreicht? Die Antworten auf diese Fragen sind essenziell, damit Du weißt, worauf Du Deine Entwicklung auslegen musst. So schaffst Du eine nachhaltige und qualitätsgesicherte Softwareentwicklung.
Setze Prioritäten
Das heißt auch, dass Du Prioritäten setzen musst. Alles, was Dich der DoD näherbringt oder ein Hot-Fix ist, solltest du zuerst bearbeiten. Denn das Projekt muss fertig werden. Verliere Dich nicht in optionalen Features. Die kannst Du implementieren, falls am Ende noch Zeit und Geld übrig sind. Das heißt auch, dass Du mithilfe der Priorisierung darauf achten musst, kein unfertiges Produkt abzugeben. Halte Dich so nah wie möglich an die Vorgaben und sprich Probleme frühzeitig an.
Plane die Architektur
Bevor Du mit dem Coden beginnen kannst, heißt es strukturieren. Setze auf Planen, statt auf Ausprobieren!
Dir muss Deine Architektur vorher klar sein, damit Du weißt, in welche Richtung sich das Projekt bewegt. Überlege Dir von Anfang an, welche Komponenten des Systems miteinander interagieren müssen. Triff direkt Entscheidungen bezüglich der zu verwendenden Technologien, Plattformen und Frameworks. Sie legen den Grundstein für Deinen Softwareentwicklungsprozess und den Betrieb des Systems.
Wenn Du das berücksichtigt hast, musst Du Deine Architektur mit den Anforderungen der Kund:innen abgleichen. Geh sicher, dass Du den Ansprüchen gerecht wirst. Dann schaffst Du es, Komplexität zu managen, Risiken zu minimieren und die Qualität des Endprodukts sicherzustellen.
Embedded Sytems stellen Dich vor einer neuen Herausforderungen der Softwareentwicklung: Du musst mit beschränktem Arbeitsspeicher und geringerer Leistungsfähigkeit umgehen. Das solltest Du bereits in der Architektur einberechnen. Zu der Architektur gehört auch, dass Du das richtige Werkzeug für Deine Implementierung verwendest. Werde Dir klar, welche Anforderungen es erfüllen muss. Für Embedded Softwareentwicklung gelten C und C++ als beliebte Sprachen. Aber auch MikroPython gewinnt immer mehr Einzug in die Embedded Systems. Die drei Sprachen sind hardwarenah, verbrauchen wenig Rechenleistung und somit wenig Speicher.
Vernachlässigen von Tests und Fehlerbehandlungen
Optimiere Systemleistungen durch Tests
Keine Fehlerbehandlung für ein System zu machen und auf Tests zu verzichten, ist problematisch. Deshalb gehört das für uns – bei 8tronix – zum essenziellen Teil des Softwareentwicklungsprozesses. Denn es sorgt für eine sichere Softwareentwicklung.
Arbeitest Du mit Embedded Produkten, entstehen andere Herausforderungen als in der ‚normalen‘ Programmierung. Das System muss sich mit außen abstimmen. Es findet eine Hardware-Software-Integration statt. Daher ist es sinnvoll, alle Faktoren, die zum Ressourcenverbrauch beitragen könnten, zu testen: Zeit, Speicher, Rechenleistung, Netzwerk und Speicherplatz.
Generell solltest Du so viel wie möglich testen. Neben dem normalen Funktions- und Zeitverhaltenstest solltest Du Stress- und Lasttests durchführen, um zu sehen, wie das System unter extremen Bedingungen funktioniert. Auch wenn es mit Entwicklungsboard und -hardware funktioniert, so ist es erforderlich und sinnvoll, so früh wie möglich auf der eigentlichen Zielhardware zu testen. So stößt Du auf Fehler, die Dein System vermeidet. Außerdem stellst Du sicher, dass das System unter allen erwarteten Betriebsbedingungen zuverlässig funktioniert. Die Qualitätssicherung der Softwareentwicklung ist garantiert.
Beuge durch Fehlerbehandlung vor
Eine Softwareentwicklungs-Herausforderung ist die Fehlerbehandlung. Das System verhält sich in der Realität oft anders. Deine Kreativität und Fantasie sind gefragt. Überlege Dir alle möglichen Probleme, die auftreten könnten. Dafür brauchst Du informative Fehlermeldungen. Diese können Dir und Deinem Team helfen, die Ursache von Problemen schnell zu identifizieren.
Überdies solltest Du Fail-Safe-Mechanismen einbauen. Sie sind Teil der sicheren Softwareentwicklung. Dein Design solltest Du so gestalten, dass das System auch im Fehlerfall in einen sicheren Zustand übergeht. Dies ist besonders wichtig in Anwendungen, bei denen ein Systemfehler zu gefährlichen Situationen führen könnte. Denn sobald das System eingebaut ist, stellt es sich als schwierig heraus, den Fehler durch Nutzer:innen zu beheben.
Beachte alle Fehler
Wenn Dein System im Betrieb oder im Testen einen Fehler wirft, solltest Du diesen auf keinen Fall ignorieren. Das kann in der Realität fatale Folgen mit sich ziehen. Betrachte nur Systeme der Medizin: Wenn dort in der Entwicklung Fehler ignoriert worden sind, kann das Leben kosten. Deswegen ist es auch wichtig, Feedback von Endnutzer:innen und aus Feldbeobachtungen ernst zu nehmen. Dadurch kannst Du das Produkt kontinuierlich verbessern. Denn oftmals treten in der realen Welt Szenarien auf, die Du in Testszenarien nicht vollständig antizipiert hast.
Verzicht auf effizientes Ressourcenmanagement
Code-Refactoring: Reinigung und Optimierung
Arbeitest Du mit einem Embedded System, musst Du auf die System-Ressourcen achten. Du darfst keine zu großen und zu komplexen Programme schreiben, da dies zu Überlastung führen kann. Wenn Du und Dein Team regelmäßig Code-Refactoring durchführt, könnt ihr überflüssige oder zu komplexe Funktionen ändern und löschen. Ihr betreibt nachhaltige Softwareentwicklung und erhöht die Lesbarkeit.
Sauberer, gut organisierter Code ist leichter zu verstehen. Das erleichtert neuen und bestehenden Teammitgliedern das Einarbeiten und die Weiterentwicklung des Projekts. Durch das Refactoring als Teil des Softwareentwicklungsprozesses kannst Du Fehler und Unstimmigkeiten im Code frühzeitig erkennen und beheben. Dies trägt dazu bei, die allgemeine Zuverlässigkeit der Software zu steigern. Indem Du den Code regelmäßig überprüfst und verbesserst, minimierst Du das Risiko von Bugs und Sicherheitslücken. Diese können in schlecht strukturierten oder veralteten Codeabschnitten versteckt sein.
Gestalte Algorithmen effizient
Softwareentwicklungs-Herausforderungen stecken in Algorithmen. Überprüfe sie. Verwendest Du die sinnvollsten Varianten? Embedded Systeme haben oft strenge Hardwarebeschränkungen, darunter begrenzter Speicher, geringere Verarbeitungsgeschwindigkeiten und eingeschränkte Energieversorgung. Es ist entscheidend, Algorithmen auszuwählen, die effizient innerhalb dieser Grenzen arbeiten. Überprüfe die Zeit- und Raumkomplexität Deiner Algorithmen. Wähle welche mit einer niedrigeren Komplexität (z.B. lineare vs. quadratische Komplexität). Sie benötigen weniger Rechenressourcen und liefern schneller Ergebnisse. In einigen Fällen kann es sinnvoll sein, flexible oder konfigurierbare Algorithmen zu implementieren. Sie können sich an unterschiedliche Betriebsbedingungen anpassen.
Optimiere mit Hotspot-Analyse
Damit Du genau weißt, wo das Problem in Deinem Code liegt, solltest Du ihn analysieren. Führe eine Hotspot-Analyse durch und führe so eine Qualitätssicherung der Softwareentwicklung durch. Mithilfe von Werkzeugen erhältst Du detaillierte Daten über die Ausführung Deines Codes.
Für die Analyse kannst Du Dir als Werkzeug einen Profiler selbst bauen. Mit einer Funktion, die Du in Dein Embedded Programm integrierst, kannst Du kritische Stellen herausfinden. Lasse sie mitzählen, wie oft eine Funktion aufgerufen wurde. Basierend auf den Ergebnissen Deiner Hotspot-Analyse kannst Du gezielte Änderungen am Code vornehmen. Diese Optimierungen solltest Du nach der Implementierung erneut testen. So stellst Du sicher, dass Du auch das gewünschte Ergebnis erzielst. Generell heißt es bei der Analyse: Messen, Messen, Messen. Es bringt nichts, Deinen Code auf Source-Level zu optimieren. Dieses Umorganisieren fördert keinen Mehrwert und frisst Zeit.
Dein Produkt nicht zukunftsorientiert gestalten
Setze auf Dokumentation
Ein unbeliebter Teil der Entwicklung ist die Dokumentation. Sie ist jedoch unerlässlich für die langfristige Wartbarkeit Deines Codes. Natürlich solltest Du so logisch und klar programmieren, dass es keiner Dokumentation bedarf. Trotzdem bleibt es meistens nicht aus, eine zu erstellen. Denn sie ermöglicht neuen und bestehenden Entwickler:innen ein schnelles Verständnis der Systemarchitektur, der verwendeten Algorithmen und der Geschäftslogik. Mangelnde oder veraltete Dokumentation kann zu Missverständnissen und Fehlern führen, die die Entwicklung verlangsamen. Nachhaltige Softwareentwicklung bedeutet auch, in eine leicht zugängliche und regelmäßig aktualisierte Dokumentation zu investieren.
Gestalte Deine Software wartbar
Die Wartbarkeit eines Systems ist ein kritischer Faktor für dessen Langlebigkeit und Effektivität. Software, die Du nicht pflegst, altert. Sie ist nicht mehr auf die neuesten Gegebenheiten angepasst. Dein zukunftsorientiertes Produkt sollte so gestaltet sein, dass Du es leicht aktualisieren, modifizieren und erweitern kannst. Dazu gehört die Verwendung modularer Designs, die Einhaltung von Codierungsstandards und die Implementierung von Designmustern, die die Wartung vereinfachen. Vernachlässigst Du die Wartbarkeit, führt dies zu erhöhten Kosten, wenn das System an neue Anforderungen angepasst werden muss.
