Software Projektmanagement - Exam

Aufgabe 1)

Ein Softwareentwicklungsunternehmen wurde beauftragt, ein neues Kundenmanagementsystem zu entwickeln. Das Projekt hat einen festen Abgabetermin in sechs Monaten. Ihr Team besteht aus 8 Entwicklern, 2 Testern und einem Projektmanager. Sie müssen sicherstellen, dass alle Projektaufgaben effizient geplant und verwaltet werden, um den Abgabetermin einzuhalten. Verwenden Sie die unten beschriebenen Konzepte und Werkzeuge, um die Planung durchzuführen.

a)

Erstellen Sie eine WBS (Work Breakdown Structure) für das Kundenmanagementsystem. Identifizieren Sie mindestens fünf Hauptaufgaben und unterteilen Sie jede Hauptaufgabe in mindestens drei Unteraufgaben.

Lösung:

Work Breakdown Structure (WBS) für das Kundenmanagementsystem

• 1. Anforderungsanalyse
  • 1.1. Bedarfsanalyse mit Stakeholdern
  • 1.2. Erstellen von Anforderungsspezifikationen
  • 1.3. Validierung und Feedback
• 2. Systemdesign
  • 2.1. Architekturentwurf
  • 2.2. Datenmodellierung
  • 2.3. User Interface Design
• 3. Implementierung
  • 3.1. Backend-Entwicklung
  • 3.2. Frontend-Entwicklung
  • 3.3. API-Integration
• 4. Testen
  • 4.1. Unittesting
  • 4.2. Integrationstests
  • 4.3. Systemtests
• 5. Deployment und Wartung
  • 5.1. Deployment auf Produktionsserver
  • 5.2. Überwachung der Systemleistung
  • 5.3. Fehlerbehebung und Support

b)

Entwerfen Sie ein Gantt-Diagramm basierend auf der WBS, das Sie im vorherigen Teil erstellt haben. Stellen Sie sicher, dass alle Aufgaben zeitlich angeordnet sind und dass Abhängigkeiten zwischen den Aufgaben klar dargestellt sind.

Lösung:

Gantt-Diagramm für das Kundenmanagementsystem

Das Gantt-Diagramm zeigt die zeitliche Anordnung der Aufgaben und die Abhängigkeiten zwischen ihnen. Die folgenden Schritte bilden die Basis für das Gantt-Diagramm:

• 1. Anforderungsanalyse (30 Tage)
  • 1.1. Bedarfsanalyse mit Stakeholdern (10 Tage)
  • 1.2. Erstellen von Anforderungsspezifikationen (10 Tage)
  • 1.3. Validierung und Feedback (10 Tage)
• 2. Systemdesign (40 Tage)
  • 2.1. Architekturentwurf (15 Tage, beginnt nach 1.3.)
  • 2.2. Datenmodellierung (15 Tage, beginnt parallel zu 2.1.)
  • 2.3. User Interface Design (10 Tage, beginnt nach 2.2.)
• 3. Implementierung (60 Tage)
  • 3.1. Backend-Entwicklung (30 Tage, beginnt nach 2.1.)
  • 3.2. Frontend-Entwicklung (30 Tage, beginnt parallel zu 3.1.)
  • 3.3. API-Integration (15 Tage, beginnt nach 3.1. und 3.2.)
• 4. Testen (30 Tage)
  • 4.1. Unittesting (10 Tage, beginnt nach 3.1. und 3.2.)
  • 4.2. Integrationstests (10 Tage, beginnt nach 4.1.)
  • 4.3. Systemtests (10 Tage, beginnt nach 4.2.)
• 5. Deployment und Wartung (20 Tage)
  • 5.1. Deployment auf Produktionsserver (5 Tage, beginnt nach 4.3.)
  • 5.2. Überwachung der Systemleistung (10 Tage, beginnt nach 5.1.)
  • 5.3. Fehlerbehebung und Support (5 Tage, beginnt nach 5.2.)

Jetzt, basierend auf den oben angegebenen Aufgaben und Zeitplänen, kann das Gantt-Diagramm gezeichnet werden. Ein typisches Gantt-Diagramm wird horizontal über eine Zeitachse erstellt, wobei die Aufgaben individuell farbcodiert werden können, um ihre Dauer darzustellen. Die Abhängigkeiten zwischen den Aufgaben können durch Pfeile oder Linien angezeigt werden.

Ein Beispiel für das Gantt-Diagramm:

Task\time →	1 Mo	2 Mo	3 Mo	4 Mo	5 Mo	6 Mo
1.1. Bedarfsanalyse mit Stakeholdern
1.2. Erstellen von Anforderungsspezifikationen
1.3. Validierung und Feedback
2.1. Architekturentwurf
2.2. Datenmodellierung
2.3. User Interface Design
3.1. Backend-Entwicklung
3.2. Frontend-Entwicklung
3.3. API-Integration
4.1. Unittesting
4.2. Integrationstests
4.3. Systemtests
5.1. Deployment auf Produktionsserver
5.2. Überwachung der Systemleistung
5.3. Fehlerbehebung und Support

Hinweis: Die genauen Start- und Endtermine sind abhängig vom Projektstartdatum und sollten entsprechend angepasst werden.

c)

Erstellen Sie ein PERT-Diagramm (Program Evaluation and Review Technique) für das Projekt. Berechnen Sie den kritischen Pfad und schätzen Sie die minimale Projektdauer. Gehen Sie dabei von folgenden Schätzungen der Aufgaben aus (in Tagen): a. Analyse (5), b. Design (10), c. Implementierung (20), d. Testen (15), e. Bereitstellung (5). Berücksichtigen Sie auch Pufferzeiten.

Lösung:

PERT-Diagramm für das Kundenmanagementsystem

Ein PERT-Diagramm ist ein Netzwerkdiagramm, das die Abhängigkeiten zwischen den Aufgaben und die Zeitschätzungen darstellt. Für das Kundenmanagementsystem lassen sich basierend auf den gegebenen Schätzungen und Abhängigkeiten die folgenden Schritte unternehmen:

• 1. Aufgaben und Schätzungen
  • a. Analyse: 5 Tage
  • b. Design: 10 Tage
  • c. Implementierung: 20 Tage
  • d. Testen: 15 Tage
  • e. Bereitstellung: 5 Tage

Um das PERT-Diagramm zu erstellen und den kritischen Pfad zu berechnen, folge diesen Schritten:

• 2. Aufgaben und Abhängigkeiten festlegen
  • Start → Analyse
  • Analyse → Design
  • Design → Implementierung
  • Implementierung → Testen
  • Testen → Bereitstellung
  • Bereitstellung → Ende

Das Netzwerkdiagramm sieht dann folgendermaßen aus:

 Start → [5] → Analyse → [10] → Design → [20] → Implementierung → [15] → Testen → [5] → Bereitstellung → Ende 

3. Kritischen Pfad berechnen

Der kritische Pfad ist der Pfad durch das Netzwerk mit der längsten Gesamtdauer. Alle Aufgaben auf diesem Pfad haben keine Pufferzeit und bestimmen die minimale Projektdauer. Für dieses Projekt:

• Gesamtdauer des kritischen Pfads:
  • Analyse: 5 Tage
  • Design: 10 Tage
  • Implementierung: 20 Tage
  • Testen: 15 Tage
  • Bereitstellung: 5 Tage
  • Gesamtsumme: 55 Tage

Die minimale Projektdauer beträgt also 55 Tage. Da hier keine alternativen Pfade und Pufferzeiten in den Aufgaben definiert wurden, ist der kritische Pfad einfach alle Aufgaben hintereinander in der Reihenfolge ihrer Abhängigkeiten.

d)

Planen Sie die Ressourcen für das Projekt, indem Sie jedem Teammitglied Aufgaben aus Ihrer WBS zuordnen. Schätzen Sie, wie viele Tage jedes Teammitglied an jeder Aufgabe arbeiten wird. Berücksichtigen Sie dabei ihre Verfügbarkeit (Annahme: Jeder Mitarbeiter kann maximal 80% seiner Zeit für das Projekt aufwenden). Stellen Sie sicher, dass keine Überlastung stattfindet.

Lösung:

Ressourcenplanung für das Kundenmanagementsystem

Um die Ressourcen effizient zu planen, verteilen wir die Aufgaben aus der WBS auf die Teammitglieder und berücksichtigen dabei ihre Verfügbarkeit. Wir nehmen an, dass jeder Mitarbeiter maximal 80% seiner Zeit für das Projekt aufwenden kann. Das bedeutet bei einer 5-Tage-Woche, dass jeder Mitarbeiter 4 Tage pro Woche für das Projekt arbeiten kann.

Teamzusammensetzung

• 8 Entwickler (D1 - D8)
• 2 Tester (T1, T2)
• 1 Projektmanager (PM)

Aufgabenverteilung und Zeitschätzung

• 1. Anforderungsanalyse (30 Tage)
  • 1.1. Bedarfsanalyse mit Stakeholdern (10 Tage) → PM: 10 Tage
  • 1.2. Erstellen von Anforderungsspezifikationen (10 Tage) → PM: 10 Tage
  • 1.3. Validierung und Feedback (10 Tage) → PM: 10 Tage
• 2. Systemdesign (40 Tage)
  • 2.1. Architekturentwurf (15 Tage) → D1, D2, D3, D4: 3.75 Tage/Mitarbeiter
  • 2.2. Datenmodellierung (15 Tage) → D5, D6, D7, D8: 3.75 Tage/Mitarbeiter
  • 2.3. User Interface Design (10 Tage) → D1, D2: 5 Tage/Mitarbeiter
• 3. Implementierung (60 Tage)
  • 3.1. Backend-Entwicklung (30 Tage) → D1, D2, D3: 10 Tage/Mitarbeiter
  • 3.2. Frontend-Entwicklung (30 Tage) → D4, D5, D6: 10 Tage/Mitarbeiter
  • 3.3. API-Integration (15 Tage) → D7, D8: 7.5 Tage/Mitarbeiter
• 4. Testen (30 Tage)
  • 4.1. Unittesting (10 Tage) → T1: 5 Tage, T2: 5 Tage
  • 4.2. Integrationstests (10 Tage) → T1: 5 Tage, T2: 5 Tage
  • 4.3. Systemtests (10 Tage) → T1: 5 Tage, T2: 5 Tage
• 5. Deployment und Wartung (20 Tage)
  • 5.1. Deployment auf Produktionsserver (5 Tage) → D1, D2: 2.5 Tage/Mitarbeiter
  • 5.2. Überwachung der Systemleistung (10 Tage) → D3, D4: 5 Tage/Mitarbeiter
  • 5.3. Fehlerbehebung und Support (5 Tage) → D5, D6: 2.5 Tage/Mitarbeiter

Zusammenfassung der Ressourcennutzung

• D1: 3.75 (Architekturentwurf) + 5 (UI-Design) + 10 (Backend) + 2.5 (Deployment) = 21.25 Tage
• D2: 3.75 (Architekturentwurf) + 5 (UI-Design) + 10 (Backend) + 2.5 (Deployment) = 21.25 Tage
• D3: 3.75 (Architekturentwurf) + 10 (Backend) + 5 (Überwachung) = 18.75 Tage
• D4: 3.75 (Architekturentwurf) + 10 (Frontend) + 5 (Überwachung) = 18.75 Tage
• D5: 3.75 (Datenmodellierung) + 10 (Frontend) + 2.5 (Support) = 16.25 Tage
• D6: 3.75 (Datenmodellierung) + 10 (Frontend) + 2.5 (Support) = 16.25 Tage
• D7: 3.75 (Datenmodellierung) + 7.5 (API) = 11.25 Tage
• D8: 3.75 (Datenmodellierung) + 7.5 (API) = 11.25 Tage
• T1: 5 (Unit) + 5 (Integration) + 5 (System) = 15 Tage
• T2: 5 (Unit) + 5 (Integration) + 5 (System) = 15 Tage
• PM: 10 (Bedarfsanalyse) + 10 (Anforderungsspez.) + 10 (Validierung) = 30 Tage

Damit wird sichergestellt, dass keine Teammitglieder überlastet werden und die Aufgaben effizient auf die verfügbaren Ressourcen verteilt sind.

Aufgabe 2)

Du bist der Projektmanager eines Softwareentwicklungsprojekts zur Entwicklung einer neuen mobilen Applikation. Dein Projekt hat ein festgelegtes Budget von 500.000 €, eine Projektlaufzeit von 12 Monaten und ein Team von 10 Entwicklern. Du musst die Projektressourcen effizient zuweisen und verwalten, um die Projektziele zu erreichen. Dein Team arbeitet in einem agilen Umfeld mit dreiwöchigen Sprints.

a)

Stelle einen detaillierten Ressourcenplan für die ersten drei Monate des Projekts auf. Berücksichtige dabei die Verteilung der 10 Entwickler auf die verschiedenen Aufgaben, die im Entwicklungsprozess anfallen werden. Denke an die verschiedenen Rollen wie Frontend-Entwicklung, Backend-Entwicklung, Qualitätssicherung, und Projektkoordination.

Lösung:

Ressourcenplan für die ersten drei Monate

Als Projektmanager musst Du die Ressourcen deines Teams effizient zuteilen, um die Projektziele zu erreichen. Hier ist ein detaillierter Ressourcenplan, der die verschiedenen Rollen und Aufgaben während der ersten drei Monate des Projekts berücksichtigt.

Überblick über die ersten drei Monate

• Monat 1 – Anforderungsanalyse, Design, und Beginn der Entwicklung
• Monat 2 – Fortsetzung der Entwicklung, erste Implementierungen und Tests
• Monat 3 – Weiterführung der Entwicklung, Integrierung der Module, und umfangreichere Tests

Teamaufstellung und Aufgabenverteilung

Entwicklungsteam:

• Frontend-Entwicklung: 3 Entwickler
• Backend-Entwicklung: 3 Entwickler
• Qualitätssicherung (QA): 2 Entwickler
• Projektkoordination: 1 Entwickler
• Reserve/Flexible Ressourcen: 1 Entwickler

Detailplan für die ersten drei Monate

Monat 1:

• Frontend-Entwicklung (3 Entwickler):Aufgaben: Erstellung der Benutzeroberfläche (UI) und Implementierung grundlegender Features.Arbeitsaufteilung: Alle drei Entwickler widmen sich der UI und der Implementierung von Prototypen.
• Backend-Entwicklung (3 Entwickler):Aufgaben: Aufbau der Server-Architektur und Datenbankdesign.Arbeitsaufteilung: Alle drei Entwickler arbeiten an der Basis-API und dem Datenbankdesign.
• Qualitätssicherung (2 Entwickler):Aufgaben: Erstellen von Testplänen und -fällen.Arbeitsaufteilung: Beide QA-Entwickler arbeiten an der Erstellung und dem Review von Testplänen.
• Projektkoordination (1 Entwickler):Aufgaben: Planung und Organisation, sowie Kommunikation mit Stakeholdern.Arbeitsaufteilung: Koordination der Aufgaben, Meetings und die Überwachung der Projektmeilensteine.
• Reserve/Flexible Ressourcen (1 Entwickler):Aufgaben: Unterstützung in Bereichen, die zusätzlichen Bedarf haben.

Monat 2:

• Frontend-Entwicklung (3 Entwickler):Aufgaben: Detaillierte Funktionalitäten und Benutzerinteraktionen.Arbeitsaufteilung: Entwickler 1 und 2 arbeiten an Kombination von UI-Komponenten, Entwickler 3 an dem Entwicklungsframework.
• Backend-Entwicklung (3 Entwickler):Aufgaben: Weitere Entwicklung der API und Integration mit externen Services.Arbeitsaufteilung: Entwickler 1 und 2 entwickeln die API weiter, Entwickler 3 integriert externe Services.
• Qualitätssicherung (2 Entwickler):Aufgaben: Durchführung erster Tests und Fehlerberichte.Arbeitsaufteilung: Entwickler 1 konzentriert sich auf Frontend-Tests, Entwickler 2 auf Backend-Tests.
• Projektkoordination (1 Entwickler):Aufgaben: Fortlaufende Überwachung, Anpassung des Projektplans.Arbeitsaufteilung: Koordination der Sprint-Reviews, Feedback-Runden und regelmäßige Status-Updates.
• Reserve/Flexible Ressourcen (1 Entwickler):Aufgaben: Unterstützung von Frontend oder Backend je nach Bedarf.

Monat 3:

• Frontend-Entwicklung (3 Entwickler):Aufgaben: Abschluss der Implementierung der Benutzeroberfläche und Verbesserung des Designs.Arbeitsaufteilung: Entwickler 1 und 2 finalisieren die UI, Entwickler 3 überprüft die Integration und bereinigt den Code.
• Backend-Entwicklung (3 Entwickler):Aufgaben: Abschluss der API-Entwicklung und Sicherheitsimplementierungen.Arbeitsaufteilung: Entwickler 1 und 2 arbeiten an die API-Tests, Entwickler 3 fokussiert sich auf Sicherheitsmaßnahmen.
• Qualitätssicherung (2 Entwickler):Aufgaben: Detaillierte Systemtests und Bugtracking.Arbeitsaufteilung: Entwickler 1 konzentriert sich auf Integrationstests, Entwickler 2 auf Performance-Tests.
• Projektkoordination (1 Entwickler):Aufgaben: Vorbereitung auf den Launch und Endabnahme.Arbeitsaufteilung: Abschlussberichts, Kommunikation mit Stakeholdern für Launch-Einführung und Überwachung der letzten Sprint.
• Reserve/Flexible Ressourcen (1 Entwickler):Aufgaben: Unterstützung der QA oder Backend je nach Bedarf.

Fazit

Der Ressourcenplan für die ersten drei Monate ist darauf ausgelegt, eine gleichmäßige Verteilung der Aufgaben zu gewährleisten und gleichzeitig flexibel auf unvorhergesehene Probleme reagieren zu können. Die Zuordnung berücksichtigt die verschiedenen Entwicklungsstufen und die Notwendigkeit, alle kritischen Bereiche des Projekts zu adressieren.

b)

Berechne das monatliche Budget für die ersten drei Monate des Projekts basierend auf den identifizierten Ressourcen und ihrem Bedarf. Gehe davon aus, dass jeder Entwickler ein monatliches Gehalt von 5.000 € hat. Berücksichtige auch andere Kosten (z.B. Software-Lizenzen, Hardware, Bürokosten), die 20% des Entwicklerbudgets ausmachen.

Lösung:

Berechnung des monatlichen Budgets für die ersten drei Monate

Um das monatliche Budget für die ersten drei Monate des Projekts zu berechnen, müssen wir das Gehalt der Entwickler sowie die zusätzlichen Kosten für Betriebsmittel, Software-Lizenzen und Hardware berücksichtigen.

Grundlagen

• Monatliches Gehalt pro Entwickler: 5.000 €
• Anzahl der Entwickler: 10
• Weitere Kosten: 20% des Entwicklerbudgets

Berechnungen

1. Schritt: Berechnung des monatlichen Entwicklerbudgets

Das monatliche Gehalt eines Entwicklers beträgt 5.000 €. Bei 10 Entwicklern ergibt sich folgendes monatliches Entwicklerbudget:

• Monatliches Gehalt pro Entwickler = 5.000 €
• Anzahl der Entwickler = 10
• Monatliches Entwicklerbudget = 5.000 € * 10 = 50.000 €

2. Schritt: Berechnung der zusätzlichen Kosten

Die zusätzlichen Kosten betragen 20% des Entwicklerbudgets:

• Zusätzliche Kosten = 20% von 50.000 € = 0,20 * 50.000 € = 10.000 €

3. Schritt: Gesamtes monatliches Budget

Das gesamte monatliche Budget setzt sich aus dem Entwicklerbudget und den zusätzlichen Kosten zusammen:

• Gesamtes monatliches Budget = Entwicklerbudget + zusätzliche Kosten = 50.000 € + 10.000 € = 60.000 €

Monatliches Budget für die ersten drei Monate

• Monat 1: 60.000 €
• Monat 2: 60.000 €
• Monat 3: 60.000 €

Daraus ergibt sich das Budget für die ersten drei Monate des Projekts:

• Gesamtes Budget für drei Monate = 3 * 60.000 € = 180.000 €

Fazit

Das monatliche Budget für die ersten drei Monate des Projekts beträgt jeweils 60.000 €. Damit errechnet sich ein Gesamtbudget von 180.000 € für die ersten drei Monate. Dieses Budget umfasst die Gehälter der Entwickler sowie die zusätzlichen Betriebskosten.

c)

Entwickle ein Konzept zur Ressourcenkontrolle und -anpassung. Beschreibe, wie Du sicherstellen würdest, dass die Ressourcen effizient genutzt werden und wie Du auf unerwartete Änderungen der Projektsituation reagieren würdest. Berücksichtige hierbei sowohl personelle als auch finanzielle Aspekte.

Lösung:

Konzept zur Ressourcenkontrolle und -anpassung

Um sicherzustellen, dass die Ressourcen in unserem Softwareentwicklungsprojekt effizient genutzt werden und das Projekt auf unerwartete Änderungen reagieren kann, bedarf es eines klaren und strukturierten Plans zur Ressourcenkontrolle und -anpassung. Dabei werden sowohl personelle als auch finanzielle Aspekte berücksichtigt.

Ressourcenkontrolle

1. Regelmäßige Überprüfung und Berichterstattung

• Wöchentliche Meetings: Regelmäßige Team-Meetings, um den Fortschritt jedes Sprints zu überprüfen und sicherzustellen, dass alle Aufgaben im Zeitplan liegen.
• Projekt-Dashboards: Nutzung von Projektmanagement-Tools wie Jira oder Trello, um Echtzeit-Daten zum Projektfortschritt, Aufgabenzuweisungen und Ressourcennutzung zu erhalten.
• Monatliche Reviews: Detaillierte monatliche Überprüfung der Projektziele, Budgetausgaben und Ressourcenzuweisungen. Diese Reviews helfen, unerwartete Abweichungen frühzeitig zu erkennen und entsprechende Maßnahmen zu ergreifen.

2. Transparente Kommunikation

• Offene Kommunikation: Fördern einer offenen Kommunikationskultur, in der Teammitglieder Herausforderungen, Risiken und Ideen zur Verbesserung offen teilen können.
• Statusberichte: Regelmäßige schriftliche Statusberichte an Stakeholder, um Transparenz über den Projektfortschritt und die Ressourcennutzung sicherzustellen.

3. Ressourcenauslastung

• Arbeitszeiterfassung: Implementierung eines Zeiterfassungssystems, um die Arbeitszeiten der Entwickler zu überwachen und sicherzustellen, dass die Ressourcen effizient genutzt werden.
• Kapazitätsplanung: Erstellung von Kapazitätsplänen, um sicherzustellen, dass genügend Ressourcen für kritische Aufgaben verfügbar sind und Überlastungen vermieden werden.

Anpassung der Ressourcen

1. Flexibilität und Reserven

• Flexible Ressourcen: Die Zuweisung eines Entwicklers als Reserve ermöglicht es, schnell auf auftretende Engpässe oder unvorhergesehene Probleme reagieren zu können.
• Notfallbudget: Einrichtung eines Notfallbudgets (z.B. 10% des Gesamtbudgets), um finanzielle Flexibilität bei unvorhergesehenen Kostensteigerungen zu gewährleisten.

2. Priorisierung und Repriorisierung

• Priorisierung der Aufgaben: Regelmäßige Überprüfung und Anpassung der Prioritäten im Backlog, basierend auf den aktuellen Projektanforderungen und Ressourcenverfügbarkeiten.
• Kritische Pfade: Identifikation und Überwachung kritischer Pfade im Projekt, um sicherzustellen, dass ressourcenintensive und zeitkritische Aufgaben priorisiert und effizient abgearbeitet werden.

3. Anpassungsstrategien

• Ressourcen-Umschichtung: Bei Erkennung von Ressourcen-Engpässen oder -Überschüssen können Entwickler zwischen den Bereichen (z.B. von Frontend zu Backend) verschoben werden, um eine optimale Auslastung zu gewährleisten.
• Zusätzliche Ressourcen: Bei Bedarf kann kurzfristig zusätzliches Personal (z.B. Freelancer) engagiert werden, um vorübergehende Engpässe zu überbrücken.
• Budgetanpassungen: Regelmäßige Überwachung des Budgets und Anpassungen (z.B. Verschiebungen innerhalb des Budgets), um auf finanzielle Änderungen oder unerwartete Kosten zu reagieren.

Fazit

Ein konsequentes Konzept zur Ressourcenkontrolle und -anpassung ist unerlässlich, um die effiziente Nutzung der Ressourcen sicherzustellen und flexibel auf unerwartete Änderungen der Projektsituation reagieren zu können. Durch regelmäßige Überprüfungen, transparente Kommunikation, flexible Ressourcenplanung und gezielte Anpassungsstrategien, kann das Projekt erfolgreich und innerhalb der gesetzten Rahmenbedingungen durchgeführt werden.

Aufgabe 3)

Gegeben ist ein Softwareprojekt zur Entwicklung einer neuen Web-Anwendung für ein mittelständisches Unternehmen. Du bist als Projektmanager in dieses Projekt involviert und hast die Aufgabe, potenzielle Risiken zu identifizieren und zu analysieren. Um eine gründliche Risikoanalyse durchführen zu können, sollen verschiedene Techniken wie eine Risikomatrix und eine SWOT-Analyse eingesetzt werden.

a)

Identifiziere und beschreibe jeweils zwei potenzielle Risiken aus den Hauptkategorien: Technische Risiken, Programmmanagement-Risiken sowie Organisations- und Personalrisiken, die in diesem Softwareprojekt auftreten könnten. Nutze die Informationen aus den Projektangaben und deinen bisherigen Kenntnissen aus der Vorlesung.

Lösung:

• Technische Risiken:
  • 1. Technische Komplexität: Die Entwicklung der Web-Anwendung könnte auf unvorhergesehene technische Schwierigkeiten stoßen, wie z.B. Integrationsprobleme zwischen verschiedenen Systemen oder unzureichende Performance der Anwendung.
  • 2. Technologieveränderungen: Neue Technologien könnten während des Projekts auf den Markt kommen, die das bestehende Design oder die Architektur der Web-Anwendung obsolet machen oder umfangreiche Änderungen erfordern.
• Programmmanagement-Risiken:
  • 1. Zeitüberschreitungen: Das Projekt könnte länger dauern als geplant, sei es aufgrund von unzureichender Planung, unvorhergesehenem Arbeitsaufwand oder anderen Verzögerungen.
  • 2. Budgetüberschreitungen: Es besteht das Risiko, dass die Kosten für das Projekt die ursprünglich geschätzten Budgets überschreiten, etwa durch zusätzliche Ressourcen oder unvorhergesehene Ausgaben.
• Organisations- und Personalrisiken:
  • 1. Fluktuation der Mitarbeiter: Schlüsselpersonen des Projektteams könnten das Unternehmen verlassen, was zu Wissensverlust und Verzögerungen führen könnte.
  • 2. Mangel an Fachwissen: Es könnte sich herausstellen, dass das vorhandene Team nicht über die nötigen Fähigkeiten oder Erfahrungen verfügt, um die Web-Anwendung erfolgreich zu entwickeln.

b)

Erstelle eine Risikomatrix für dein Projekt. Gib jeweils die Eintrittswahrscheinlichkeit (in %) und die Auswirkungen (in einem Skalenwert von 1-10) für jedes der identifizierten Risiken an. Priorisiere die Risiken anhand ihrer Eintrittswahrscheinlichkeit und Auswirkungen und begründe deine Entscheidungen. Diskutiere zudem geeignete Maßnahmen zur Risikominderung für jedes Risiko.

Lösung:

Risikomatrix für das Softwareprojekt

Risiko	Eintrittswahrscheinlichkeit (%)	Auswirkungen (1-10)	Priorität	Maßnahmen zur Risikominderung
Technische Komplexität	70%	8	Hoch	Regelmäßige technische Reviews und Tests durchführen, zusätzliche Schulungen für Entwickler
Technologieveränderungen	50%	6	Mittel	Kontinuierlicher Markt- und Technologiebewertung, flexible Architektur designen
Zeitüberschreitungen	60%	7	Hoch	Detaillierte Zeitplanung erstellen, Meilensteine festlegen, regelmäßige Überprüfungen
Budgetüberschreitungen	40%	6	Mittel	Strenges Budgetmanagement, regelmäßige Kostenkontrolle
Fluktuation der Mitarbeiter	50%	7	Hoch	Mitarbeiterbindung durch Anreize, Wissenstransfer fördern
Mangel an Fachwissen	30%	8	Mittel	Externe Experten hinzuziehen, Schulungsprogramme ansetzen

Begründung der Priorisierung:

• Technische Komplexität und Zeitüberschreitungen: Aufgrund der hohen Eintrittswahrscheinlichkeit und der gravierenden Auswirkungen auf das Projekt haben diese beiden Risiken oberste Priorität.
• Fluktuation der Mitarbeiter: Trotz der geringeren Eintrittswahrscheinlichkeit sind die Auswirkungen erheblich, wodurch dieses Risiko ebenfalls hohe Priorität erhält.
• Technologieveränderungen und Budgetüberschreitungen: Diese Risiken weisen mittlere Priorität auf aufgrund der moderaten Eintrittswahrscheinlichkeit und der Auswirkungen.
• Mangel an Fachwissen: Obwohl die Eintrittswahrscheinlichkeit geringer ist, sind die Auswirkungen bedeutend, was eine mittlere Priorität rechtfertigt.

Maßnahmen zur Risikominderung:

• Technische Komplexität: Regelmäßige technische Reviews und Tests gewährleisten die frühzeitige Identifikation und Lösung technischer Probleme. Zusätzliche Schulungen für die Entwickler helfen, deren Kompetenz zu stärken.
• Technologieveränderungen: Eine kontinuierliche Bewertung von Markt- und Technologietrends hilft, frühzeitig auf Änderungen zu reagieren. Eine flexible Architektur sorgt dafür, dass Anpassungen einfacher umgesetzt werden können.
• Zeitüberschreitungen: Eine detaillierte Zeitplanung mit festgelegten Meilensteinen und regelmäßigen Überprüfungen hilft, den Fortschritt des Projekts im Blick zu behalten und Verzögerungen frühzeitig zu erkennen.
• Budgetüberschreitungen: Strenges Budgetmanagement und regelmäßige Kostenkontrollen ermöglichen eine bessere Überwachung der Ausgaben und helfen, Budgetüberschreitungen zu vermeiden.
• Fluktuation der Mitarbeiter: Anreize und Programme zur Mitarbeiterbindung können die Fluktuation verringern. Der Wissenstransfer innerhalb des Teams stellt sicher, dass Wissen nicht verloren geht.
• Mangel an Fachwissen: Das Hinzuziehen externer Experten und die Durchführung von Schulungsprogrammen gewährleisten, dass das Team über das nötige Fachwissen verfügt.

c)

Führe eine SWOT-Analyse für das Softwareprojekt durch. Identifiziere je vier Stärken (Strengths), Schwächen (Weaknesses), Chancen (Opportunities) und Bedrohungen (Threats). Erläutere zudem, wie die identifizierten Risiken in die SWOT-Analyse einfließen.

Lösung:

SWOT-Analyse für das Softwareprojekt

• Stärken (Strengths):
  • 1. Erfahrenes Entwicklungsteam: Das Team verfügt über umfangreiche Erfahrung in der Entwicklung von Web-Anwendungen.
  • 2. Klare Projektziele: Die Anforderungen und Ziele des Projekts sind klar definiert.
  • 3. Moderne Technologien: Verwendung aktueller und bewährter Technologien für die Web-Entwicklung.
  • 4. Engagierte Stakeholder: Starkes Engagement und Unterstützung der Stakeholder und des Managements.
• Schwächen (Weaknesses):
  • 1. Begrenztes Budget: Das Projekt muss mit einem vorgegebenen und möglicherweise knappen Budget arbeiten.
  • 2. Enge Zeitpläne: Die Projektzeitpläne sind eng gesteckt, was wenig Spielraum für Verzögerungen lässt.
  • 3. Abhängigkeit von Drittanbietern: Teile des Projekts erfordern die Zusammenarbeit mit externen Dienstleistern, was zu Abhängigkeiten führen kann.
  • 4. Fachkräftemangel: Mangelndes Fachwissen in spezifischen neuen Technologien könnte die Entwicklung verlangsamen.
• Chancen (Opportunities):
  • 1. Wachsende Nachfrage nach digitalen Lösungen: Die steigende Nachfrage nach digitalen und webbasierten Lösungen eröffnet neue Geschäftsmöglichkeiten.
  • 2. Technologische Innovation: Neue Technologien und Tools können die Effizienz und Qualität des Projekts verbessern.
  • 3. Erweiterung des Kundenstamms: Erfolgreiche Implementierung könnte zu neuen Kunden und Märkten führen.
  • 4. Positives Markenimage: Eine erfolgreiche Web-Anwendung kann das Markenimage des Unternehmens verbessern.
• Bedrohungen (Threats):
  • 1. Technologiewechsel: Schnelle Veränderungen in der Technologie könnten die entwickelte Lösung veralten lassen.
  • 2. Zeit- und Budgetüberschreitungen: Unvorhergesehene Probleme könnten zu Verzögerungen und höheren Kosten führen.
  • 3. Fluktuation im Team: Schlüsselmitarbeiter könnten das Unternehmen verlassen, was zu Wissensverlust und Projektverzögerungen führt.
  • 4. Sicherheitsrisiken: Daten- und Sicherheitsrisiken könnten die Anwendung gefährden und das Vertrauen der Kunden beeinträchtigen.

Einfluss der identifizierten Risiken auf die SWOT-Analyse:

• Technische Komplexität (Schwächen, Bedrohungen): Erhöht die Gefahr von Verzögerungen und Problemen in der Implementierung. Dies kann die Schwächen im Bereich Fachkompetenz und die Bedrohungen durch Zeit- und Budgetüberschreitungen verstärken.
• Technologieveränderungen (Chancen, Bedrohungen): Einerseits bieten Technologieveränderungen Chancen für technologische Innovation, andererseits stellen sie eine Bedrohung durch die mögliche Obsoleszenz der Lösung dar.
• Zeitüberschreitungen (Schwächen, Bedrohungen): Die engen Zeitvorgaben und die Gefahr von Zeitüberschreitungen betonen die Schwächen des engen Zeitplans und die Bedrohung durch unvorhergesehene Projektverlängerungen.
• Budgetüberschreitungen (Schwächen, Bedrohungen): Ein begrenztes Budget macht das Projekt anfällig für Budgetüberschreitungen, was eine signifikante Bedrohung darstellt.
• Fluktuation der Mitarbeiter (Schwächen, Bedrohungen): Der Verlust von Schlüsselmitarbeitern kann als Schwäche im Teamzusammenhalt und als Bedrohung für den Projekterfolg gewertet werden.
• Mangel an Fachwissen (Schwächen, Bedrohungen): Dies kann das Projekt verlangsamen und die Komplexität der technischen Umsetzung erhöhen, was zu Risiken in Form von Schwächen und Bedrohungen führt.

Aufgabe 4)

Du leitest ein Softwareentwicklungsprojekt und möchtest sicherstellen, dass die Softwarequalität während des gesamten Entwicklungszyklus gewährleistet ist. Um dies zu erreichen, planst Du die Implementierung eines umfassenden Qualitätssicherungsprozesses.

a)

Beschreibe die Hauptziele eines Qualitätssicherungsprozesses. Welche Vorteile bietet es, Fehler frühzeitig zu erkennen und zu beheben?

Lösung:

• Hauptziele eines Qualitätssicherungsprozesses:
• Mängelfreiheit sicherstellen: Der Prozess soll sicherstellen, dass die Software möglichst fehlerfrei ist. Dadurch wird die Zuverlässigkeit und Funktionalität der Software erhöht.
• Anforderungen erfüllen: Überprüfung, ob die Software alle festgelegten Anforderungen erfüllt und den Bedürfnissen der Nutzer gerecht wird.
• Kontinuierliche Verbesserung: Durch regelmäßige Tests und Überprüfungen sollen Schwachstellen identifiziert und langfristig behoben werden, um die Softwarequalität stetig zu verbessern.
• Risikominimierung: Frühzeitiges Erkennen von Problemen hilft, größere Risiken und teure Fehler in späteren Entwicklungsphasen zu vermeiden.
• Kundenzufriedenheit: Gewährleistung einer hohen Softwarequalität führt zu zufriedeneren Kunden und einem besseren Ruf des Unternehmens.
• Vorteile des frühzeitigen Erkennens und Behebens von Fehlern:
• Kostenersparnis: Das Beheben von Fehlern in frühen Phasen ist deutlich günstiger als in späteren Phasen oder nach der Auslieferung der Software.
• Zeiteffizienz: Frühe Fehlererkennung und -behebung beschleunigt den Entwicklungsprozess, da größere Verzögerungen durch umfassende Nacharbeiten vermieden werden.
• Bessere Planbarkeit: Geringere Wahrscheinlichkeit für unvorhergesehene Probleme und Verzögerungen, was die Einhaltung von Zeitplänen erleichtert.
• Qualitätssteigerung: Durch kontinuierliche Tests und Überprüfungen wird eine höhere Softwarequalität erreicht.
• Bessere Kommunikation: Ein frühes Feedback ermöglicht eine bessere Kommunikation innerhalb des Teams und fördert die Zusammenarbeit.

Ein umfassender Qualitätssicherungsprozess ist daher unerlässlich, um eine hochwertige Software zu entwickeln und langfristig erfolgreich zu sein.

b)

Erkläre den Unterschied zwischen Verifizierung und Validierung im Kontext der Softwarequalitätssicherung. Warum ist es wichtig, beide Prozesse durchzuführen?

Lösung:

• Unterschied zwischen Verifizierung und Validierung:
• Verifizierung: Bei der Verifizierung handelt es sich um den Prozess, bei dem überprüft wird, ob die Software dem Entwurf und den Spezifikationen entspricht. Hierbei wird sichergestellt, dass die Software technisch richtig entwickelt wurde und die festgelegten Anforderungen und Designvorgaben erfüllt.
• Beispiel: Überprüfung, ob alle Funktionen gemäß den Anforderungen implementiert wurden.
• Beispielmethoden: Code-Reviews, Unit-Tests, statische Analysen.
• Validierung: Die Validierung stellt sicher, dass die entwickelte Software den tatsächlichen Bedürfnissen und Erwartungen der Nutzer entspricht. Es wird überprüft, ob die richtige Software gebaut wurde, d.h., ob die Software im realen Einsatz den gewünschten Zweck erfüllt.
• Beispiel: Tests im realen Einsatz, um sicherzustellen, dass die Software problemlos in der vorgesehenen Umgebung funktioniert.
• Beispielmethoden: Systemtests, Integrationstests, Akzeptanztests.
• Warum ist es wichtig, beide Prozesse durchzuführen?
• Umfassende Qualitätssicherung: Verifizierung und Validierung ergänzen sich gegenseitig und stellen sicher, dass sowohl die technischen Anforderungen als auch die Nutzerbedürfnisse erfüllt werden.
• Fehlerfrüherkennung: Durch Verifizierung können technische Fehler frühzeitig erkannt und behoben werden, bevor sie sich auf den gesamten Entwicklungsprozess auswirken.
• Nutzerzufriedenheit: Die Validierung stellt sicher, dass die Software im praktischen Einsatz funktioniert und den Nutzern einen tatsächlichen Mehrwert bietet, was die Kundenzufriedenheit erhöht.
• Kosteneffizienz: Frühzeitige Erkennung und Behebung von Fehlern durch Verifizierung reduziert die Anzahl und Schwere der Fehler, die bei der Validierung gefunden werden. Dies spart Zeit und Kosten.
• Risiken minimieren: Beide Prozesse tragen dazu bei, das Risiko von Ausfällen und Fehlfunktionen im Produktionsumfeld zu minimieren.

Zusammenfassend stellen Verifizierung und Validierung sicher, dass die Software sowohl technisch korrekt entwickelt wurde als auch den tatsächlichen Bedürfnissen der Nutzer entspricht, was zu einer insgesamt hohen Softwarequalität führt.

c)

Welche Werkzeuge könntest Du für die Qualitätssicherung in Deinem Projekt einsetzen? Wähle zwei aus der Liste (JUnit, Selenium, SonarQube) und erläutere ihre spezifischen Funktionen und Anwendungsgebiete.

Lösung:

• Werkzeuge für die Qualitätssicherung in Deinem Projekt:
• Für dieses Projekt könnten JUnit und SonarQube ausgewählt werden.
• JUnit:
• Spezifische Funktionen: JUnit ist ein Framework zum Schreiben und Ausführen von Unit-Tests in Java. Es ermöglicht Entwicklern, einzelne Codeeinheiten, wie Methoden und Klassen, unabhängig zu testen.
• Tests schreiben: Entwickler können Testfälle erstellen, um die Funktionalitäten von Methoden zu überprüfen.
• Testausführung: JUnit bietet Funktionen für die automatische Ausführung der Tests.
• Assertions: Mit Hilfe von Assertions können Bedingungen definiert werden, die während des Testlaufs überprüft werden. Wenn eine Assertion fehlschlägt, wird der Test als fehlgeschlagen markiert.
• Integration in CI/CD: JUnit lässt sich leicht in Continuous Integration/Continuous Deployment (CI/CD)-Pipelines integrieren, um sicherzustellen, dass alle neuen Änderungen getestet und überprüft werden.
• Anwendungsgebiete: JUnit wird hauptsächlich verwendet, um die korrekte Funktion auf der Methodik-Ebene zu verifizieren. Es hilft Entwicklern, Fehler frühzeitig zu erkennen und sicherzustellen, dass Änderungen am Code keine neuen Fehler einführen.
• SonarQube:
• Spezifische Funktionen: SonarQube ist ein Open-Source-Tool zur kontinuierlichen Inspektion und Bewertung von Codequalität. Es analysiert den Quellcode auf Schwachstellen und bietet detaillierte Berichte und Metriken.
• Codeanalyse: SonarQube prüft den Quellcode auf eine Vielzahl von Qualitätsregeln und -standards, einschließlich Code-Metadaten, Stil-Konventionen, potenzielle Bugs und Sicherheitslücken.
• Qualitätsmetriken: Es bietet Metriken wie technische Schulden, Codeabdeckung durch Tests, Komplexität und Duplikate im Code.
• Berichterstattung: Generiert detaillierte Berichte und Dashboards, die den Status und die Historie der Codequalität darstellen.
• Integration: SonarQube lässt sich in CI/CD-Pipelines und verschiedene IDEs integrieren, um Entwicklern kontinuierliches Feedback zur Codequalität zu geben.
• Anwendungsgebiete: SonarQube wird verwendet, um den gesamten Quellcode einer Anwendung umfassend zu analysieren. Es hilft Teams, langfristig eine hohe Codequalität zu gewährleisten und technische Schulden zu reduzieren.

Durch den Einsatz von JUnit und SonarQube kannst Du sicherstellen, dass sowohl die funktionalen Anforderungen auf Methodik-Ebene erfüllt sind als auch die gesamte Codebasis von hoher Qualität und frei von potenziellen Schwachstellen ist.

d)

Berechne die Testabdeckung (Code Coverage) für folgendes Szenario und interpretiere das Ergebnis: In Deinem Projekt gibt es 1000 Zeilen produktiven Code. Dein Testprozess umfasst unittests, die insgesamt 650 Zeilen dieses Codes ausführen. Was sagt diese Metrik über die Qualität Deiner Tests aus? Wie könntest Du diese Metrik verbessern?

Lösung:

• Berechnung der Testabdeckung (Code Coverage):
• Gegebener produktiver Code: 1000 Zeilen
• Mit Unittests ausgeführter Code: 650 Zeilen
• Formel zur Berechnung der Testabdeckung:
• Die Testabdeckung in Prozent wird berechnet als:

 Testabdeckung (%) = (Mit Tests abgedeckte Zeilen / Gesamte Zeilen produktiven Codes) * 100  Testabdeckung (%) = (650 / 1000) * 100 = 65% 

Interpretation des Ergebnisses:

• Eine Testabdeckung von 65% bedeutet, dass 65% des produktiven Codes durch Unittests abgedeckt werden. Dies deutet darauf hin, dass ein erheblicher Teil des Codes getestet wird, jedoch bleiben 35% ungetestet.
• Eine Testabdeckung von 65% ist ein guter Anfang, aber es zeigt auch, dass noch Bereiche im Code existieren, die potenziell fehleranfällig sind, da sie nicht durch Tests überprüft werden.
• Möglichkeiten zur Verbesserung der Testabdeckung:
• Weitere Unittests schreiben: Schreibe Tests für die ungetesteten Teile des Codes, um die Abdeckung zu erhöhen.
• Integrationstests hinzufügen: Ergänze Unittests durch Integrationstests, die die Interaktion zwischen verschiedenen Modulen prüfen.
• Codeabdeckungsanalyse-Tools verwenden: Nutze Tools wie JaCoCo oder das integrierte Coverage-Tool in vielen IDEs, um zu identifizieren, welche Teile des Codes noch nicht getestet sind. Diese Tools können detaillierte Berichte liefern, die helfen, die Testabdeckung zielgerichtet zu verbessern.
• Refaktorisieren des Codes: Überprüfe und refaktoriere den Code, um ihn testbarer zu machen, besonders wenn es schwer ist, Tests für bestimmte Bereiche zu schreiben.
• Pair Programming und Code-Reviews: Arbeiten im Team und regelmäßige Code-Reviews können helfen, unbeachtete Bereiche im Code zu identifizieren und entsprechende Tests zu entwickeln.

Insgesamt bietet eine Steigerung der Testabdeckung eine bessere Absicherung gegen Fehler und stellt sicher, dass Änderungen am Code weniger wahrscheinlich unentdeckte Probleme mit sich bringen.