Blog

Softwarearchitektur erfolgreich verbessern - Best Practices für Hardware-Unternehmen 

Von Roger Kulläng & Ingo Bögemann 

Traditionell auf Hardware ausgerichtete Unternehmen sind häufig mit verschiedenen Problemen bei ihrer Softwarearchitektur konfrontiert, die von zu geringer Entwicklungsgeschwindigkeit bis hin zu mangelnder Kostenkontrolle reichen. Viele dieser Probleme stammen daher, dass solche Unternehmen häufig mit mehreren Softwaremonolithen arbeiten, die im Laufe der Jahre zur Unterstützung verschiedener Hardwareplattformen entwickelt wurden.

Angesichts der immer weiter zunehmenden Bedeutung der Softwarekomponenten im Produktportfolio von Unternehmen ist es nur logisch, dass die bestehende Softwarearchitektur verbessert werden muss. Allerdings eröffnet die Verbesserung der eigenen Softwareplattform nicht nur Chancen, sondern stellt das Unternehmen auch vor neue Herausforderungen. Viele Unternehmen wissen daher nicht, wie Sie eine solche Verbesserung am besten in Angriff nehmen sollen, und wie der Übergang hin zu einer Neuausrichtung von Hard- auf Software gelingen kann.

In diesem Blog-Artikel werden wir Ihnen deshalb sechs praktische Tipps geben, wie Sie Ihre Produktarchitektur erfolgreich verbessern können. Außerdem zeigen wir Ihnen an zwei Beispielen, was der Nutzen einer optimierten Softwarearchitektur ist. Zunächst wollen wir uns jedoch ansehen, mit welchen Softwareproblemen Unternehmen, die aus dem Hardwarebereich kommen, typischerweise konfrontiert sind. 

 

Leseempfehlung: Kennen Sie bereits unseren Artikel “Von Hardware-First zu Software-First mit einer modularen Softwarearchitektur”? Darin verraten wir Ihnen, wie Modularisierung Ihnen bei der Transformation hin zu einem Software-First-Ansatz hilft.

New call-to-action

 

Softwarearchitektur in traditionellen Hardware-Unternehmen: Typische Probleme

Viele traditionell auf Hardware ausgerichtete Unternehmen haben ihre Softwarearchitekturen im Laufe der Jahre passend zu ihren Hardwareprodukten entwickelt. Das Resultat ist häufig eine Reihe von Softwaremonolithen, die jeweils für eine bestimmte Produktplattform entwickelt wurden. Das führt zu den folgenden Problemen.

Zu lange Entwicklungszeiten

Eins der Hauptprobleme von Unternehmen, deren Softwarearchitektur aus einem oder mehreren Softwaremonolithen besteht, ist die geringe Entwicklungs- und Innovationsgeschwindigkeit. Ohne eine strategisch in mehrere Bestandteile gegliederte Software muss diese bei Neuentwicklungen als komplett fertiges Softwarepaket geliefert werden. Um neue Software zu veröffentlichen, müssen alle Funktionen aufeinander abgestimmt sein, und jede Verzögerung beim Entwickeln der einzelnen Funktionen kann kritisch für die Veröffentlichung der neuen Softwarevariante oder -version werden. Zudem ist der Testaufwand sehr hoch, da der gesamte Code für jede Version erneut getestet und überprüft werden muss, selbst wenn er nicht geändert wurde.

Sie können sich die Entwicklung von Funktionalitäten für einen Softwaremonolithen wie das Einfädeln auf eine einzelne Spur im Straßenverkehr vorstellen. Die Funktionalitäten müssen eine nach der anderen entwickelt und implementiert werden, bevor die Software als Ganzes getestet wird. Wenn hierbei Fehler auftauchen, betreffen die Verzögerungen die wartende Schlange aller anderen Funktionalitäten.

softwarearchitektur-monolith

Die Problematik verschärft sich, wenn die gleichen Funktionen in mehreren Softwareplattformen implementiert werden sollen, die für verschiedene Hardwareplattformen gedacht sind. In dem Fall muss für jede dieser Softwareplattformen separat derselbe Test- und Verifizierungsaufwand betrieben werden. Fällt der Implementierungsprozess aufgrund von Unterschieden in der Hardware für jede Softwareplattform unterschiedlich aus, muss dieselbe Funktion außerdem separat implementiert werden. Diese Faktoren erhöhen die Aufwände und verzögern die Entwicklungsgeschwindigkeit. Je nachdem, wie groß der dadurch entstehende Aufwand ist, werden alte Hardwareplattformen unter Umständen beim Aufspielen neuer Funktionen übergangen, was zu Unzufriedenheit bei den Kunden führen kann.

 

modularisierung-softwarearchitektur-releases-2

Viele Unternehmen versuchen die mangelnde Entwicklungsgeschwindigkeit durch kleinere Releases von Funktionen und Verbesserungen zu kompensieren. Aus Zeitgründen werden dabei allerdings nur ausgewählte Tests durchgeführt, weswegen dieses Vorgehen nicht ohne Risiko ist. Der Grund liegt darin, dass vorgenommene Änderungen auch unerwartete Auswirkungen auf die Software haben können. So können beispielsweise neue Funktionen Speicherressourcen in Anspruch nehmen, die eigentlich von einem anderen Teilsystem gebraucht werden. Da diese Auswirkungen durch Tests nicht ausreichend abgedeckt wurden, treten die Probleme dann bei der Nutzung durch den Kunden auf.

Schwierige Kostenkontrolle und Gewährleistung der erforderlichen Qualität

Ein weiteres Problem von monolithischen Softwarearchitekturen sind die anfallenden Entwicklungskosten. Da alle Teilsysteme und Funktionen zusammenhängen, ist es schwer, die Kosten für die Entwicklung einzelner Funktionen vorherzusagen. Denn diese hängen von einem (insgesamt höheren) Integrations- und Testaufwand für das gesamte System ab. Da ein Großteil der Kosten häufig im Rahmen eines größeren Release abgedeckt wird, werden die Kosten für einzelne Features in der Regel unterschätzt. Die Kostentransparenz ist in diesen Fällen sehr gering.

Aufgrund der mangelnden Transparenz sind auch die Kosten für die Fehlersuche und -behebung nur schwer zu ermitteln. Mit zunehmender Komplexität des Codes kommen immer mehr versteckte Kosten hinzu, da die Abhängigkeiten einzelner Funktionen und Bestandteile im Softwaresystem nicht klar sind.

Wird jedoch bei Tests und Validierung gespart, hat dies schnell negative Auswirkungen auf die Qualität. Bis eine Software wirklich ausgereift und für die Veröffentlichung bereit ist, bedarf es umfangreicher Systemtests, da im Voraus nicht genau gesagt werden kann, auf welche Teile des Softwaresystems sich bestimmte Änderungen auswirken. Werden Änderungen vorgenommen, ist es daher üblich, alle bekannten potentiellen Problemstellen in der Software erneut zu testen, um die Qualität der Software zu gewährleisten. Dies führt jedoch erneut zu höheren Kosten.

Fehlende Entkopplung von Hardware- und Softwarearchitektur

In vielen Unternehmen, die traditionell einen Hardware-First-Ansatz bei der Entwicklung ihrer Softwarearchitektur verfolgen, ist die Software häufig stark an die Hardware gekoppelt, da sie erst nachträglich für eine schon fertig konstruierte Hardware geschrieben wird. Eine solche Software orientiert sich demnach sehr stark an den durch die Hardware gegebenen Voraussetzungen, was zu einer starken Abhängigkeit der Softwarearchitektur von der Hardware führt.

Eine gute Verdeutlichung dieser Abhängigkeit ist die seit Beginn der Corona-Pandemie zu beobachtende weltweite Verknappung von Mikrochips, deren Auswirkungen bis heute noch zu spüren sind. Unternehmen, die bislang bei ihren Produkten auf 15 Jahre alte Chips gesetzt haben, sehen sich nun gezwungen, ihre Hardware auf moderne Chips umzurüsten, da sie keine Hersteller mehr finden, die die zuvor genutzten Chips liefern können beziehungsweise wollen. Da diese Hardware-Designs in der Regel ohne Betriebssystem implementiert sind, muss die komplette Software neu geschrieben werden.

 

Sechs Tipps zur Verbesserung Ihrer Softwarearchitektur

Zu lange Entwicklungszeiten, eine schwierige Kostenkontrolle und zu starke Abhängigkeiten der Software von der Hardware sind Probleme, die häufig in Unternehmen mit ursprünglichem Fokus auf Hardware auftreten. Jedoch mit der richtigen Strategie lassen sich diese Probleme beheben. Hierzu stellen wir Ihnen im Folgenden sechs Best Practices vor.

1.      Setzen Sie auf eine modulare Softwarearchitektur

Eine Möglichkeit, die zuvor beschriebenen Probleme mit monolithischen Softwarearchitekturen zu lösen, besteht darin, diese nach den Prinzipien eines modularen Baukastensystems zu organisieren. Modularisierung der Software bedeutet, diese in ein System modularer Software-Einheiten mit standardisierten Schnittstellen zu gliedern, in dem jede Funktion in einem separaten Softwaremodul gebündelt ist.

Die so entstandene modulare Softwarearchitektur erlaubt es, neue Versionen durch das Kombinieren, Entfernen oder Hinzufügen von Modulvarianten zu erstellen. Eine modulare Softwarearchitektur ermöglicht es außerdem, bereits vorhandene Softwaremodule für neue Produkte zu verwenden. Unternehmen schreiben ihre Software oftmals komplett neu, um neue Technologien zu implementieren. Allerdings gibt es keinen Grund, funktionierende Elemente des bereits bestehenden Codes nicht erneut zu verwenden. Alles, was es dazu braucht, sind passende Schnittstellen, um den alten Code in der Zukunft mit neuen Elementen zu verbinden.

 

Leseempfehlung: Warum Sie Ihre Codebase modularisieren statt neu schreiben sollten und wie Sie dazu am besten vorgehen, lesen Sie hier in unserem separaten Blog-Artikel.

 

Der Vorteil einer modularen Softwarearchitektur ist, dass eine Funktion nur einmal implementiert, getestet und bereitgestellt werden muss. So wird die Entwicklung, das Testen, die Integration und die Freigabe neuer Softwarevarianten beschleunigt. Neue Funktionen können freigegeben werden, sobald sie fertig sind, ohne dass mit gegenseitigen Beeinträchtigungen gerechnet werden muss. Zudem wird die Fehlerbehebung vereinfacht, da der Einfluss innerhalb einzelner Module isoliert ist.

Wenn wir noch einmal an unser eingangs erwähntes Beispiel der durch einen Unfall blockierten Fahrspur zurückdenken, kann Modularisierung so verstanden werden, dass eine modulare Softwarearchitektur mehrere Fahrspuren bietet, auf denen verschiedene Module in ihrer eigenen Geschwindigkeit entwickelt werden können.

softwarearchitektur-modular

Anstatt für jedes einzelne Hardwareprodukt eine separate Softwarearchitektur zu entwickeln und zu pflegen, ist es vorteilhafter, eine modulare Softwarearchitektur zu erstellen, die mehrere Hardwareprodukte unterstützt und auch für zukünftige Produktentwicklungen verwendet werden kann. Ein in diesem Zusammenhang häufig verwendetes Konzept ist Software Portability. Hierbei geht es darum, die Software von der Hardware zu entkoppeln, damit die Software auf verschiedenen Hardwareprodukten verwendet werden kann.

Jedes Modul kann dabei einen eigenen Release-Zyklus haben. Für geschäftskritische Funktionen, wie z. B. Drive-by-Wire-Funktionen, kann dieser länger ausfallen, während für kleinere Verbesserungen etwa der Benutzeroberfläche kürzere Release-Zeiten möglich sind, wie in der folgenden Grafik dargestellt.

modularisierung-software-modul-releases-1

 

Leseempfehlung: Eine detaillierte Anleitung, wie Sie Ihre modulare Produktarchitektur für Ihre Hard- und Software definieren, bietet Ihnen unsere Blog-Artikel “Digitalisierung und Industrie 4.0 – Mit modularer Maschinensoftware”.

2.      Definieren Sie strategische Softwaremodule

Um die Vorteile einer modularen Softwarearchitektur bestmöglich zu nutzen, sollte die Einteilung der Architektur in Module nach strategischen Kriterien erfolgen. Module können drei strategische Dimensionen erfüllen. Diese sind: operative Exzellenz, Kundennähe und Produktführerschaft.

Unter der strategischen Dimension “operative Exzellenz” lassen sich diejenigen Teile der Software zusammenfassen, die nicht oft geändert werden müssen und die nicht zur Kundenindividualisierung beitragen. Es handelt sich hierbei um den Kern des Produkts, der wiederverwendet werden kann und bei dem es keine Varianz braucht. Da dieser Bereich der Software nicht direkt kundenorientiert ist, ist die Kundschaft in der Regel nicht bereit, für Verbesserungen und Veränderungen an diesem Teil der Softwarearchitektur zu bezahlen.

Daneben gibt es Softwareelemente, die für die Positionierung auf dem Markt relevant sind und direkt mit der Erfüllung der Kundenwünsche in Zusammenhang stehen. Kundenbedürfnisse variieren je nach Region, Land und Art der Branche, weshalb es hier meist notwendig ist, eine große Varianz zu ermöglichen, um in verschiedenen Märkten Anteile zu sichern. Diese Teile des Codes sind der strategischen Dimension “Kundennähe” zuzuordnen.

Schließlich bleibt der Teil der Software, der durch Entwicklungstrends und Innovationsprojekte Ihres Unternehmens beeinflusst wird. Um weiterhin mit der Konkurrenz Schritt zu halten und auf dem Markt relevant zu bleiben, ist es erforderlich, diese Module häufig zu aktualisieren. Unter Umständen sind die anfallenden Änderungen auch direkt relevant für den Kunden, was einen Aufpreis rechtfertigen könnte. Solche Teile der Codebase sind dem Modultreiber “Produktführerschaft” zugeordnet. In der nachfolgenden Grafik sind die drei strategischen Dimensionen noch einmal dargestellt.

 

modularisierung-softwarearchitektur-strategie

3.      Nutzen Sie Testautomatisierung und Over-the-Air-Updates

Bei Software, die häufig geändert wird, fällt ein großer Testaufwand an. Wenn Sie die durchzuführenden Tests automatisieren, können Sie die Testgeschwindigkeit erhöhen und Probleme frühzeitig erkennen, was die für die Integration der Änderungen notwendige Zeit und Ressourcen reduziert. Die Modularisierung der Software ist eine wichtige Voraussetzung für Testautomatisierung. Indem sich häufig ändernde Teile des Codes in separaten Modulen isoliert werden, die über standardisierte Schnittstellen mit anderen Teilen der Software verbunden sind, ist es möglich, kleinere Komponententests durchzuführen. Dadurch wird sowohl das Testen als auch die Fehlersuche beschleunigt.

Leseempfehlung: Lesen Sie auch unseren Blog-Artikel zum Thema “Mehr Qualität und Effizienz in der Softwareentwicklung”.

Ein weiteres Verbesserungspotenzial für Ihre Softwarearchitektur, das sich dank Modularisierung gut realisieren lässt, ist das Ermöglichen von Over-the-Air-Updates. Bei Over-the-Air (kurz: OTA) handelt es sich um eine Methode für Softwareaktualisierungen, die über eine Funkschnittstelle an einem bereits installierten System vorgenommen werden. Damit das Aktualisieren der Software kontrolliert und effizient durchgeführt werden kann, ist es wichtig, häufig zu aktualisierende Module von kritischen Modulen zu trennen, da bei Letzteren das mit Änderungen verbundene Risiko viel höher ist. Die Aktualisierung kleinerer Teile der Software ist außerdem schneller und weniger ressourcenintensiv. OTA-Updates ermöglichen zudem eine höhere Softwarequalität, eröffnen Geschäftsmöglichkeiten, da das Unternehmen Kunden neue Funktionalitäten via Update anbieten kann, und erlauben eine schnelle und effiziente Bekämpfung von Sicherheitslücken.

4.      Binden Sie andere Abteilungen in die Entwicklung Ihrer modularen Softwarearchitektur mit ein

Die Modularisierung Ihrer Softwarearchitektur betrifft nicht nur Ihre F&E-Abteilung. Es ist zwar korrekt, dass ein Team aus den besten Softwarearchitekten und -entwicklern technisch gesehen ausreicht, um eine modulare Softwarearchitektur aufzubauen, allerdings sollte man nicht vergessen, dass das Budget für solche Projekte andernorts im Unternehmen festgelegt wird. Wird der Wert der angestrebten Verbesserungen der Softwarearchitektur nicht von allen Abteilungen im Unternehmen verstanden, ist es unwahrscheinlich, dass einem derartigen Projekt das nötige Budget und Engagement zugestanden werden, die es für eine erfolgreiche Umsetzung braucht.

Werden neben der Führungsebene auch noch andere Bereiche wie beispielsweise Vertrieb, Einkauf, Kundenservice und Lieferkette mit in das Modularisierungsprojekt miteinbezogen und die in den jeweiligen Abteilungen bestehenden Probleme berücksichtigt, kann dadurch ein echter Mehrwert für das gesamte Unternehmen geschaffen werden. Überlegen Sie zum Beispiel, wie Sie die Art und Weise, wie Sie Ihr Produkt vertreiben, mit der technischen Umsetzung in der Softwarearchitektur in Einklang bringen können.

5.      Quantifizieren Sie den Wert einer verbesserten Softwarearchitektur

Dieser Tipp für eine erfolgreiche Verbesserung der unternehmensinternen Softwarearchitektur hängt eng mit der zuvor beschriebenen Einbindung aller Abteilungen zusammen. Wenn Sie in der Lage sind, den finanziellen Wert einer verbesserten Softwarearchitektur zu beziffern, wird es Ihnen viel leichter fallen, alle Abteilungen zum Mitwirken zu bewegen. Die Voraussetzung dafür ist jedoch ein gutes Verständnis der verschiedenen Kostentreiber, die mit der Software in Verbindung stehen. Die Einflüsse der Hard- und Softwareentwicklung auf verschiedene Bereiche haben wir in der folgenden Grafik dargestellt.

modularisierung-software-einfluss-2

 

Direkte Materialkosten spielen im Softwarebereich in der Regel keine große Rolle, ebenso wenig wie die Effizienz der Lieferkette und die Produktionskosten. Stattdessen entfällt der Großteil der Kosten einer Softwarearchitektur auf die Entwicklung sowie auf Softwaretests, Wartung und Support. In diesen Bereichen hat eine verbesserte modulare Softwarearchitektur also einen besonders großen Einfluss.

Je nach Status Ihrer aktuellen Softwarearchitektur kann dieser Wert sehr unterschiedlich ausfallen. Hier sind einige Fragen, die Sie sich in diesem Zusammenhang stellen können:

  • Müssen Sie Entwicklungskapazitäten für sich überschneidende Arbeiten an mehreren Softwareplattformen aufwenden?
  • Mangelt es an wieder verwendbaren Softwarekomponenten, weshalb Implementierungen mehrmals an verschiedenen Stellen des Systems durchgeführt werden müssen?
  • Führen Sie bei jeder Version umfangreiche manuelle Tests und Überprüfungen durch? Könnte dies durch kleinere Releases verbessert werden?
  • Welche Kosten entstehen durch das Auffinden und Beheben von Fehlern und durch das Implementieren und Ausrollen der Updates auf allen Systemen?

6.      Definieren Sie frühzeitig passende KPIs

Wie bei allen anderen Projekten im Unternehmen ist es auch bei der Modularisierung der Softwarearchitektur notwendig, rechtzeitig passende Key Performance Indicator (KPI) festzulegen, anhand derer der Fortschritt des Projekts verfolgt werden kann. Nur so kann das Modularisierungsprojekt effizient gesteuert und vorangetrieben und der erhoffte Mehrwert für das Unternehmen realisiert werden.

Welche KPIs für Ihr Unternehmen die Richtigen sind, hängt von Ihren Zielen ab. Hier sind jedoch einige Beispiele für KPIs, die im Softwarebereich interessant sein können:

  • Benötigte Entwicklungszeit für die gesamte Softwarearchitektur
  • Anzahl der öffentlichen APIs, die automatisch getestet werden
  • Anzahl der internen APIs, die automatisch getestet werden
  • Durchschnittliche Entwicklungszeit für einen Release
  • Durchschnittliche Zeit für Fehlerbehebung
  • Dauer für die Behebung kritischer Fehler in bereits installierten Systemen

Leseempfehlung: Sie interessieren sich auch für die Modularisierung Ihrer Hardware und suchen noch nach passenden Key Performance Indicators? Dann empfehlen wir Ihnen unseren Blog-Artikel “Modularisierung messen: KPIs für ein nachhaltiges Baukastensystem”.

Nach diesem Überblick über verschiedene Tipps, mit denen Sie die Softwarearchitektur in Ihrem Unternehmen verbessern können, wollen wir uns anhand von zwei konkreten Beispielen ansehen, wie erfolgreiche Softwarearchitekturen in der Praxis aussehen. Dazu werden wir auch jeweils auf die oben aufgeführten Tipps eingehen.

Tesla

Das wohl bekannteste Beispiel einer erfolgreichen Softwarearchitektur ist das Softwaresystem des Automobilherstellers Tesla. Für die Integration neuer Software-Updates in bereits ausgelieferten Modellen setzt der Hersteller auf Over-The-Air-Technologie, wodurch die Autos wöchentlich intelligenter und einfacher zu bedienen werden. Tritt ein Sicherheitsproblem auf, kann die betreffende Funktion außerdem per Fernsteuerung deaktiviert werden, wodurch groß angelegte Rückrufaktionen vermieden werden.

Die in den Fahrzeugen verwendete zentrale Hardwarekomponente ist so ausgelegt, dass sie mehr leisten kann, als aktuell von der Software gefordert und daher auch für zukünftige Modelle und Funktionen wie etwa vollständig autonomes Fahren verwendet werden kann, was wiederum dem Prinzip der Modularisierung entspricht. Auf der Basis von über die Software gesammelten Daten entwickelt und veröffentlicht der Hersteller regelmäßige Upgrades seiner Software. So war Tesla beispielsweise in der Lage, den Bremsweg des Model 3 (90-0 km/h) durch eine verbesserte Kalibrierung des Antiblockiersystems um 5 Meter zu verkürzen und per OTA-Update auf alle Fahrzeuge zu übertragen.

Und auch wenn für die gesteigerten Kapazitäten der Hardware bei der Datenverarbeitung direkte Kosten entstehen, so hat der Hersteller es geschafft, diese über zusätzliche Dienstleistungen zu kompensieren und die Lebensdauer seiner Produkte zu verlängern und deren Wettbewerbsfähigkeit zu verbessern. Das Resultat ist ein verlängerter Produktlebenszyklus und eine hohe Kundenzufriedenheit.

iRobot OS

iRobot zeigt mit seinen Staubsaugerrobotern, wie Software von Generation zu Generation immer intelligenter werden kann. Die neuesten Versionen reinigen zwar nicht viel besser als die (bereits guten) Vorgängermodelle, aber sie werden durch die iRobot Genius Software immer besser darin, sich durch den Wohnraum zu navigieren. Durch neue zusätzliche Muster, die die Sensoren der Roboter erkennen, wird die Navigation der Roboter kontinuierlich verbessert. Auch bei Reinigungszonen und -intervallen werden die Saugroboter immer intelligenter. So schlagen neue Modelle beispielsweise eine häufigere Reinigung während des Fellwechsels des im Haushalt lebenden Hundes vor.

All diese Verbesserungen werden als neue Funktionen in Form von zusätzlichen Softwarekomponenten per OTA-Update auf die Roboter aufgespielt, wenn diese in ihrer Ladestation aufgeladen werden. Daneben sind die Staubsaugerroboter von iRobot auch ein Beispiel für eine gelungene Entkopplung von Software und Hardware. Der Hersteller hat seine Roboter von Anfang an mit intelligenten Sensoren ausgestattet, die Raum für Entwicklung in der Software erlauben, ohne dass es einer Veränderung der Hardware bedarf.

In einer digitalen Welt brauchen auch Hardware-Unternehmen eine modulare Softwarearchitektur

In der heutigen zunehmend digital geprägten Welt kommt der Softwarekomponente in Produkten eine immer größere Rolle zu. Selbst Unternehmen mit Hardware-Orientierung müssen heutzutage in der Lage sein, robuste Softwaresysteme für ihre Produkte zu entwickeln. Dabei gilt es jedoch zuerst, die Probleme mit der bereits vorhandenen Softwarearchitektur zu lösen.

Um die eigene Softwarearchitektur erfolgreich zu verbessern, können Unternehmen verschiedene Strategien anwenden. Diese reichen von Testautomatisierung bis hin zu Over-the-Air-Updates für bereits installierte Softwaresysteme. Der Modularisierung der Softwarearchitektur kommt hierbei eine besondere Rolle zu. Die Entwicklung einer Softwarearchitektur auf der Grundlage strategischer modularer Prinzipien kann Unternehmen dabei helfen, schneller und besser qualitativ hochwertige Software zu veröffentlichen und dadurch eine langfristige Präsenz auf dem Markt aufzubauen.

Für noch mehr nützliche Tipps zum Thema Modularisierung der Softwarearchitektur empfehlen wir Ihnen unser englischsprachiges Webinar “Best Practices for Software Architecture in Hardware Companies”, für das Sie sich hier registrieren können.

New call-to-action