Software Product Mastering / Das unsichtbare Biest / Das "Was" und das "Wie" / Stacey Matrix / Cynefin-Modell
Komplexität von Software im Laufe der Jahre¶
1980er Jahre: Personal Computer-Ära¶
Was: Desktop-Software (z. B. Textverarbeitung, Spiele) für Einzelplatzanwendungen
Wie: Monolithische Entwicklung, einfache Sprachen (C, Pascal), geringe Teamarbeit
Nochmal als Folie...
1990er Jahre: Internet & Client-Server-Architektur¶
Was: Netzwerk- und Webanwendungen, z. B. Browser und Client-Server-Modelle
Wie: Objektorientierte Programmierung (Java, C++), erste Versionierungstools (CVS), größere Teams
Nochmal als Folie...
2000er Jahre: Web 2.0 und verteilte Systeme¶
Was: Interaktive, skalierbare Webanwendungen (soziale Netzwerke, E-Commerce)
Wie: Agile Methoden (Scrum), Frameworks (Ruby on Rails), Cloud-Computing
Nochmal als Folie...
2010er Jahre: Microservices & DevOps¶
Was: Skalierbare, unabhängige Microservices und mobile Anwendungen
Wie: DevOps, CI/CD, Container (Docker, Kubernetes), Observability-Tools
Nochmal als Folie...
2020er Jahre: Künstliche Intelligenz & Automatisierung¶
Was: KI-basierte Anwendungen (z. B. Chatbots, Bilderkennung), IoT und Edge-Computing
Wie: KI-Frameworks (TensorFlow, PyTorch), MLOps, automatisierte Sicherheit (Zero-Trust)
Nochmal zum Nachlesen...
Seit den 1980er Jahren hat sich die Komplexität von Software in vielen Dimensionen kontinuierlich erhöht, was sowohl die Funktionalität und Anwendungsfälle ("Was") als auch die Methoden und Werkzeuge zur Entwicklung und Verwaltung dieser Software ("Wie") betrifft. Hier ist ein Überblick, wie sich die Softwarelandschaft seitdem verändert hat.
1980er Jahre: Beginn der Personal Computer-Ära¶
Was:
- Software wurde in den 1980ern primär für Desktop-Umgebungen und einfache Benutzeranwendungen entwickelt, z. B. Textverarbeitungsprogramme, Tabellenkalkulationen und einfache Spiele.
- Komplexität zeigte sich hauptsächlich in der Funktionalität und Benutzerfreundlichkeit. Ziel war es, Software für den individuellen Gebrauch auf Personal Computern zugänglich zu machen.
Wie:
- Programmiersprachen wie C, Pascal und BASIC waren dominant. C wurde vor allem im System- und Betriebssystembereich verwendet, Pascal häufig in der Bildung.
- Die Softwareentwicklung erfolgte meist monolithisch: Ein einzelnes Programm wurde als Ganzes kompiliert und ausgeführt.
- Versionskontrolle und Zusammenarbeit standen noch am Anfang. Meistens arbeitete ein Entwickler oder ein kleines Team an einem Programm, ohne ausgefeilte Methoden zur Teamkoordination.
Beispiel:
- MS-DOS, ein relativ einfaches Betriebssystem, bot eine textbasierte Schnittstelle ohne Multitasking und ohne moderne Speicherverwaltung. Die Komplexität lag primär in der Hardwareinteraktion und Benutzerfreundlichkeit.
1990er Jahre: Aufkommen des Internets und der Client-Server-Architektur¶
Was:
- Die Softwareentwicklung verlagerte sich von reinen Desktop-Anwendungen hin zu Netzwerkanwendungen, was durch das Aufkommen des Internets und den Client-Server-Modellen angetrieben wurde.
- Neue Arten von Software wie Webbrowser (z. B. Netscape) und Client-Server-Anwendungen in Unternehmen führten zu einer erhöhten Komplexität.
- Auch Datenbanken und serverseitige Applikationen gewannen an Bedeutung.
Wie:
- Die Einführung objektorientierter Programmierung (OOP) in Sprachen wie Java und C++ erleichterte die Modellierung komplexer Anwendungen.
- Die Strukturierung in Client-Server-Modelle führte dazu, dass Applikationen in mehrere Komponenten (Client und Server) unterteilt wurden, die miteinander kommunizierten.
- Es entstanden erste Versionierungstools wie CVS, die die Zusammenarbeit in Teams förderten.
Beispiel:
- Netscape Navigator ermöglichte den Zugang zum World Wide Web, wobei eine Client-Server-Architektur eingesetzt wurde. Die Komplexität lag nun in der Netzwerkkommunikation und der Handhabung dynamischer Inhalte.
2000er Jahre: Web 2.0 und verteilte Systeme¶
Was:
- Der Begriff "Web 2.0" steht für die Entwicklung interaktiver, dynamischer Webanwendungen. Plattformen wie soziale Netzwerke, E-Commerce, und cloudbasierte Software gewannen an Bedeutung.
- Die zunehmende Vernetzung und Globalisierung erforderten Skalierbarkeit und Hochverfügbarkeit, die durch verteilte Systeme ermöglicht wurden.
- Die Software entwickelte sich von einfachen Webseiten zu komplexen Webanwendungen mit Echtzeit-Interaktion und Personalisierung.
Wie:
- Sprachen wie JavaScript und Frameworks wie Ruby on Rails ermöglichten die Entwicklung dynamischer und interaktiver Webanwendungen.
- Die Verwendung von Datenbanken und Caching-Systemen zur Speicherung und schnellen Bereitstellung großer Datenmengen wurde Standard.
- Methoden wie Agile und Scrum setzten sich durch, um die Entwicklung in schnell veränderlichen Umfeldern zu unterstützen.
- Cloud-Computing-Anbieter wie Amazon Web Services (AWS) machten es möglich, skalierbare und verteilte Systeme zu betreiben.
Beispiel:
- Facebook und andere soziale Netzwerke entwickelten sich zu komplexen Webplattformen, die Benutzerinteraktionen in Echtzeit verarbeiten mussten. Die Herausforderung bestand darin, sowohl Personalisierung als auch Skalierbarkeit zu gewährleisten.
2010er Jahre: Microservices und DevOps¶
Was:
- Die Anwendungen wurden durch die fortschreitende Digitalisierung noch umfangreicher, mit einer Vielzahl von Funktionen und Integrationen (z. B. Zahlungssysteme, Benachrichtigungen).
- Mobile Apps traten verstärkt in den Vordergrund, was zu einer Diversifizierung der Plattformen (iOS, Android, Web) führte.
- Anwendungen wurden in immer kleinere Einheiten aufgeteilt (Microservices), um die Komplexität beherrschbar zu halten und eine schnellere Skalierung und Wartung zu ermöglichen.
Wie:
- DevOps und CI/CD (Continuous Integration/Continuous Deployment) wurden als Antwort auf die Notwendigkeit entwickelt, schnell und zuverlässig Updates bereitzustellen.
- Container-Technologien wie Docker und Kubernetes ermöglichten eine plattformunabhängige Bereitstellung von Anwendungen.
- Es entstanden Observability-Tools wie Prometheus und Grafana, um den Zustand verteilter Systeme zu überwachen und Fehler schneller zu finden.
Beispiel:
- Netflix führte die Microservices-Architektur ein, die es ermöglichte, dass verschiedene Entwicklerteams unabhängig voneinander an einzelnen Teilen des Systems arbeiten konnten. Die Herausforderung bestand darin, die Vielzahl der Services orchestrieren und überwachen zu können.
2020er Jahre: Künstliche Intelligenz und Automatisierung¶
Was:
- Die Komplexität der Software zeigt sich zunehmend in der Integration von Künstlicher Intelligenz (KI), maschinellem Lernen (ML) und Automatisierung. Software wird heute "intelligenter" und kann Entscheidungen auf Basis von Daten treffen.
- Anwendungen wie Chatbots, automatische Bilderkennung und Sprachverarbeitung sind allgegenwärtig.
- Edge-Computing ermöglicht die Verarbeitung von Daten am Rand des Netzwerks, was besonders für IoT-Geräte wichtig ist.
Wie:
- KI-Frameworks wie TensorFlow und PyTorch sowie cloudbasierte ML-Plattformen erleichtern die Entwicklung und Bereitstellung von Modellen.
- MLOps, eine Kombination aus DevOps und Machine Learning, wird eingeführt, um ML-Modelle kontinuierlich zu trainieren und zu aktualisieren.
- Sicherheitskonzepte wie Zero-Trust und automatisierte Sicherheitsscans sind notwendiger, da sich Angriffsflächen durch vernetzte und KI-gesteuerte Systeme vergrößert haben.
Beispiel:
- Sprachassistenten wie Alexa oder Google Assistant kombinieren KI, NLP und Cloud-Computing, um Sprachbefehle zu verstehen und darauf zu reagieren. Die Herausforderung liegt hier in der Komplexität der Datenverarbeitung und dem Datenschutz, da sensible Informationen verarbeitet werden.
Fazit¶
Die Softwareentwicklung hat sich über die Jahrzehnte erheblich weiterentwickelt:
- Was: Die Art der Anwendungen wurde immer komplexer, von Einzelplatzanwendungen auf PCs bis hin zu KI-getriebenen, global vernetzten Anwendungen mit Echtzeitverarbeitung.
- Wie: Es wurden neue Paradigmen, Architekturen und Tools eingeführt, um diese zunehmende Komplexität handhaben zu können. Die Methoden zur Entwicklung, Bereitstellung und Wartung von Software wurden immer spezialisierter, um mit der Geschwindigkeit und dem Umfang moderner Anwendungen Schritt zu halten.