Erkunden, wie Software entwickelt wird

  • 9 Minuten

Die moderne Softwareentwicklung hat sich grundlegend von der Entwicklung von Grund auf zu einer Zusammenstellung von Anwendungen aus bestehenden Komponenten gewandelt. Das Verständnis dieses komponentenbasierten Ansatzes ist für die effektive Implementierung und Verwaltung von Software in modernen Entwicklungsumgebungen unerlässlich.

Das komponentenbasierte Softwaremodell

Die heutigen Anwendungen werden erstellt, indem originaler Code mit wiederverwendbaren Komponenten kombiniert wird. Anstatt jeden Funktionsteil zu schreiben, zusammenstellen Entwicklungsteams Lösungen aus:

  • Ursprünglicher Geschäftslogikcode: Benutzerdefinierter Code, der bestimmte Geschäftsanforderungen, Workflows und eindeutige Features implementiert, die Ihre Anwendung unterscheiden.
  • Open-Source-Bibliotheken und Frameworks: Von der Community erstellte und verwaltete wiederverwendbare Komponenten, die allgemeine Funktionen wie Datenverarbeitung, Authentifizierung, Benutzeroberflächen und Kommunikationsprotokolle bieten.
  • Kommerzielle Komponenten: Drittanbieterbibliotheken, die von Anbietern angeboten werden, bieten häufig spezielle Funktionen, Support und Garantien an.
  • Integrationscode: "Glue"-Code, der Komponenten miteinander verbindet, Schnittstellen anpasst und Interaktionen zwischen verschiedenen Teilen des Systems koordiniert.

Die Forschung zeigt konsequent, dass moderne Anwendungen aus ca. 80% vorhandenen Komponenten bestehen , die außerhalb des Projekts verwaltet werden, wobei nur 20% originaler Code vom Entwicklungsteam geschrieben wurde. Diese Zusammensetzung spiegelt eine grundlegende Veränderung der Entwicklung von Software wider – vom Aufbau bis hin zur Montage.

Warum Software auf diese Weise erstellt wird

Der komponentenbasierte Ansatz bietet erhebliche Vorteile:

Entwicklungsgeschwindigkeit

Die Wiederverwendung vorhandener Komponenten beschleunigt die Entwicklung erheblich:

  • Bewährte Lösungen: Anstatt Probleme zu lösen, die andere bereits gelöst haben, enthalten Teams battle-getestete Komponenten, die zuverlässig funktionieren.
  • Reduzierte Entwicklungszeit: Das Erstellen eines Webanwendungsframeworks, eines Datenbanktreibers oder eines Authentifizierungssystems von Grund auf würde Monate oder Jahre dauern. Die Verwendung vorhandener Komponenten reduziert dies auf Tage oder Stunden.
  • Konzentrieren Sie sich auf den Geschäftlichen Wert: Entwickler konzentrieren sich auf einzigartige Geschäftslogik, anstatt die gemeinsame Infrastruktur neu zu erfinden.
  • Schnellere Markteinführungszeit: Anwendungen erreichen die Produktion früher, da Teams nicht jede Ebene von Grund auf neu erstellen.

Qualität und Zuverlässigkeit

Gut gepflegte Open-Source-Komponenten überschreiten häufig die Qualität von benutzerdefiniertem Code:

  • Community-Überprüfung: Beliebte Open-Source-Projekte verfügen über Tausende von Benutzern, die Probleme identifizieren und melden, was zu robustem, zuverlässigem Code führt.
  • Expertenentwicklung: Viele Open-Source-Projekte werden von Experten erstellt und verwaltet, die sich auf bestimmte Problemdomänen spezialisiert haben.
  • Kontinuierliche Verbesserung: Aktive Projekte erhalten regelmäßige Updates, Fehlerbehebungen und Verbesserungen von Mitwirkenden weltweit.
  • Produktionstests: Komponenten, die von Tausenden von Anwendungen verwendet werden, wurden in verschiedenen Umgebungen und Szenarien getestet.

Kosteneffizienz

Die Verwendung von Open-Source-Komponenten reduziert entwicklungs- und Wartungskosten:

  • Keine Lizenzgebühren: Die meisten Open-Source-Komponenten sind kostenlos zu verwenden und es entfallen Lizenzierungskosten pro Arbeitsplatz oder pro Bereitstellung.
  • Gemeinsame Wartungslast: Fehlerkorrekturen und Verbesserungen werden von der Community beigetragen, wodurch die Wartungskosten Ihrer Organisation reduziert werden.
  • Verringerter Personalbedarf: Teams benötigen keine Spezialisten für jede Technologieschicht, da sie vorhandene Kenntnisse über Komponenten integrieren können.
  • Niedrigere Gesamtbetriebskosten: Während kommerzielle Komponenten direkte Kosten haben, bieten Open-Source-Alternativen häufig ähnliche Funktionen ohne Lizenzgebühren.

Zugang zu Innovation

Open-Source-Communitys fördern technologische Innovation:

  • Modernste Features: Viele neue Technologien und Ansätze entstehen zuerst in Open-Source-Projekten.
  • Ökosystemeffekte: Beliebte Frameworks schaffen Ökosysteme kompatibler Komponenten, Tools und Wissen.
  • Flexible Einführung: Organisationen können ohne große finanzielle Verpflichtungen mit neuen Technologien experimentieren.
  • Wissen der Gemeinschaft: Umfangreiche Dokumentationen, Lernprogramme und Communityunterstützung erleichtern die Einführung.

Open-Source-Komponenten im Vergleich zu Closed-Source-Komponenten

Komponenten enthalten zwei grundlegende Kategorien, die auf der Verfügbarkeit von Quellcode basieren:

Open-Source-Komponenten

Open-Source-Code ist öffentlich für alle Personen verfügbar , um Folgendes zu prüfen, zu verwenden, zu ändern und häufig dazu beizutragen:

  • Sichtbarkeit des Quellcodes: Sie können die tatsächliche Implementierung untersuchen, verstehen, wie die Komponente funktioniert, und Sicherheitspraktiken überprüfen.
  • Beteiligung der Gemeinschaft: Viele Personen können Verbesserungen beitragen, Fehler beheben und Features hinzufügen.
  • Lizenzgesteuerte Nutzung: Open-Source-Lizenzen geben zulässige Verwendungen an, von uneingeschränkter Verwendung bis hin zu Anforderungen, die abgeleitete Werke dieselbe Lizenz gemeinsam nutzen.
  • Transparenz: Sicherheitsforscher, Entwickler und Benutzer können Code für Sicherheitsrisiken, Hintertüren oder Qualitätsprobleme überwachen.

Beliebte Open-Source-Komponenten umfassen:

  • Programmiersprachen und Laufzeiten: Python, Node.js, .NET Core, Go, Rust.
  • Webframeworks: React, Angular, Vue.js, Express, Django, Spring Boot.
  • Datenbanken: PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch.
  • Entwicklungstools: Visual Studio Code, Git, Docker, Kubernetes.
  • Bibliotheken: Lodash, Moment.js, NumPy, Pandas, TensorFlow.

Komponenten für geschlossene Quellen

Komponenten für geschlossene Quellen (proprietäre Komponenten) bieten Funktionen, ohne Quellcode verfügbar zu machen:

  • Binäre Verteilung: Komponenten werden als kompilierte Binärdateien oder verpackte Bibliotheken ohne Quellcode bereitgestellt.
  • Kontrolle durch den Anbieter: Die Organisation des Anbieters steuert Updates, Funktionen und Lizenzbedingungen.
  • Kommerzielle Unterstützung: Viele Komponenten für geschlossene Quellen umfassen professionelle Unterstützung, Vereinbarungen auf Serviceebene und garantierte Wartung.
  • Eingeschränkte Transparenz: Benutzer können keine Implementierungsdetails überprüfen, wodurch Sicherheits- und Qualitätsbewertungen schwieriger werden.

Beispiele hierfür sind viele kommerzielle Datenbanktreiber, proprietäre SDKs, herstellerspezifische Tools und spezielle branchenspezifische Bibliotheken.

Verteilung von Komponenten

Pakete bieten einen formalisierten Mechanismus zum Verteilen und Verwalten von Komponenten:

Paketstruktur

  • Binärcode: Kompilierte Bibliotheken, die in Anwendungen verwendet werden können.
  • Metadaten: Informationen zum Paket, einschließlich Name, Version, Autor und Beschreibung.
  • Abhängigkeiten: Liste der anderen Pakete, die für die Funktion der Komponente erforderlich sind.
  • Lizenzinformationen: Rechtliche Bestimmungen zur Verwendung des Pakets.
  • Dokumentation: Verwendungsanweisungen, API-Verweise und Beispiele.

Paketökosysteme

Verschiedene Programmiersprachen haben Paketökosysteme eingerichtet:

  • npm (Knotenpaket-Manager): JavaScript- und TypeScript-Pakete, die weltweit größte Paketregistrierung mit über 2 Millionen Paketen.
  • PyPI (Python Package Index): Python-Pakete, die Bibliotheken für Data Science, Webentwicklung, Automatisierung und vieles mehr bereitstellen.
  • NuGet: .NET-Pakete für C#-, F#- und Visual Basic-Anwendungen.
  • Maven Central: Java-Pakete für die Unternehmens- und Android-Entwicklung.
  • RubyGems: Ruby-Pakete für Webanwendungen und Automatisierung.
  • Crates.io: Rust-Pakete für die Systemprogrammierung.

Paketverwaltungstools

Paketmanager automatisieren das Herunterladen, Installieren und Aktualisieren von Abhängigkeiten:

  • Abhängigkeitsauflösung: Ermitteln und Installieren erforderlicher Abhängigkeiten automatisch.
  • Versionsverwaltung: Verfolgen Sie, welche Versionen von Paketen Ihre Anwendung verwendet.
  • Aktualisieren von Benachrichtigungen: Informieren Sie Entwickler, wenn neuere Versionen verfügbar sind.
  • Überprüfung der Sicherheitsanfälligkeit: Einige Paketmanager integrieren Sicherheitsüberprüfungen, um bekannte Sicherheitsrisiken zu identifizieren.

Die Auswirkungen der komponentenbasierten Entwicklung

Während der komponentenbasierte Ansatz enorme Vorteile bietet, stellt er auch Herausforderungen vor:

Komplexität der Abhängigkeitsverwaltung

  • Abhängigkeitsbäume: Ihre Anwendung hängt möglicherweise direkt von 20 Paketen ab, aber diese Pakete hängen von anderen ab, und erstellen Bäume von Hunderten oder Tausenden von Abhängigkeiten.
  • Versionskonflikte: Für unterschiedliche Komponenten sind möglicherweise inkompatible Versionen freigegebener Abhängigkeiten erforderlich.
  • Aktualisierungskaskaden: Das Aktualisieren einer Komponente erfordert möglicherweise eine Aktualisierung vieler anderer Komponenten.

Sicherheitsüberlegungen

  • Geerbte Sicherheitslücken: Sicherheitslücken in Abhängigkeiten können Ihre Anwendung beeinträchtigen.
  • Lieferkettenangriffe: Böswillige Akteure können beliebte Pakete kompromittieren, um Anwendungen anzugreifen, die von ihnen abhängig sind.
  • Nicht gesicherte Abhängigkeiten: Komponenten, die nicht mehr verwaltet werden, erhalten keine Sicherheitsupdates.

Lizenzkonformität

  • Lizenzverpflichtungen: Jede Open-Source-Lizenz hat Anforderungen – einige erlauben eine uneingeschränkte kommerzielle Nutzung, andere erfordern die Freigabe Ihres Quellcodes.
  • Lizenzverbreitung: Eine Anwendung kann Hunderte von Paketen mit Dutzenden verschiedener Lizenzen enthalten.
  • Compliance-Belastung: Organisationen müssen Lizenzverpflichtungen nachverfolgen und die Einhaltung sicherstellen.

Operative Abhängigkeiten

  • Externes Hosting: Viele Anwendungen sind von Paketen abhängig, die auf öffentlichen Registrierungen gehostet werden, die Ausfälle haben könnten.
  • Verfügbarkeit der Registrierung: Wenn eine öffentliche Registrierung nicht verfügbar ist, können Builds und Bereitstellungen fehlschlagen.
  • Paketentfernung: Autoren können manchmal Pakete aus öffentlichen Registern entfernen und Anwendungen unterbrechen, die von ihnen abhängig sind.

Das Verständnis, wie moderne Software mit Komponenten erstellt wird, bietet einen wesentlichen Kontext für die Sicherheits-, Rechts- und Betriebsbedenken, die Organisationen bei der Implementierung von Open Source-Software berücksichtigen müssen. Die verbleibenden Einheiten in diesem Modul untersuchen diese Bedenken und Strategien zur effektiven Verwaltung.