Software Product Mastering / Produkt & Projekt / Methoden / Deliberating structures
Paperplane Spiel¶
Hier ist die gesamte Beschreibung des Paper Plane Games mit den integrierten Rollen und Veränderungen der Produktanforderungen:
Paper Plane Game – Agile Simulation mit Rollen und Veränderungen der Produktanforderungen¶
Ziele des Spiels:¶
- Verständnis der agilen Prinzipien: Die Studierenden erleben die Vorteile von Iteration, Feedback und kontinuierlicher Verbesserung.
- Simulation von Teamrollen: Einführung der wichtigsten agilen Rollen wie Product Owner, Frontend-Entwickler, Backend-Entwickler und Scrum Master.
- Veränderung von Produktanforderungen: Simulieren von Änderungen während des Projekts, um das Management von sich ändernden Anforderungen zu erleben.
Benötigte Materialien:¶
- Papier (A4 oder ähnlich) für die Papierflieger.
- Stifte oder Marker zum Beschriften der Flieger.
- Maßband oder Lineal zur Messung der Flugdistanzen.
- (Optional) Notizkarten für Feedback.
- Materialien für verschiedene Designs (z.B. Klebeband, farbiges Papier, etc.).
Rollen im Spiel:¶
Product Owner (PO):
- Verantwortlich für die Produktvision und Priorisierung der Anforderungen. Gibt die Anforderungen und Änderungen vor und stellt sicher, dass das Team auf das richtige Ziel hinarbeitet.
Frontend-Entwickler (FE):
- Fokussiert sich auf das Design des Fliegers und die Benutzererfahrung. Sorgt dafür, dass der Flieger ästhetisch und ansprechend aussieht.
Backend-Entwickler (BE):
- Verantwortlich für die Stabilität des Fliegers und die Flugeigenschaften. Stellt sicher, dass der Flieger stabil fliegt und strukturell gut funktioniert.
Scrum Master (SM):
- Moderiert das Team, hilft bei der Organisation des Prozesses und sorgt dafür, dass das Team effizient arbeitet und agile Prinzipien befolgt.
Ablauf des Spiels:¶
1. Einführung und Rollenverteilung (20 Minuten)
- Ziele: Den Teilnehmern die agilen Rollen und ihre Verantwortlichkeiten erklären.
- Die Teilnehmer werden in Teams eingeteilt, wobei jede Rolle im Team besetzt wird (PO, FE, BE, SM).
- Klärung der Aufgaben der jeweiligen Rollen:
- PO: Gibt Anforderungen vor und priorisiert Änderungen.
- FE: Arbeitet am Design des Fliegers.
- BE: Stellt sicher, dass der Flieger funktional und stabil ist.
- SM: Moderiert den Prozess und sorgt für eine effektive Zusammenarbeit.
2. Erste Iteration (15 Minuten)
- Aktivität:
- Die Teams haben 5 Minuten Zeit, um ihren ersten Papierflieger zu bauen.
- PO: Gibt die grundlegende Anforderung vor (z.B. „Der Flieger muss gut fliegen und stabil sein“).
- FE: Konzentriert sich darauf, den Flieger ästhetisch zu gestalten.
- BE: Sorgt dafür, dass der Flieger stabil genug ist, um zu fliegen.
- SM: Hilft dabei, den Prozess zu moderieren und stellt sicher, dass jeder in seiner Rolle bleibt.
- Flugversuch: Jedes Team lässt seinen Flieger fliegen und misst die Distanz.
3. Feedback und Anpassungen (10 Minuten)
- Aktivität:
- Jedes Team gibt sich gegenseitig Feedback über den Flieger.
- PO: Priorisiert das Feedback und bestimmt, welche Änderungen für die nächste Iteration wichtig sind.
- FE und BE: Überlegen, wie sie den Flieger entsprechend den Anforderungen des PO verbessern können.
- SM: Moderiert die Diskussion und stellt sicher, dass die Verbesserungen schnell umgesetzt werden.
4. Einführung von Änderungen der Produktanforderungen (15 Minuten)
- Aktivität:
- Nach der ersten Iteration führt der PO eine Änderung der Produktanforderungen ein, z.B.:
- „Der Flieger muss aus mindestens zwei verschiedenen Papierarten bestehen.“
- „Der Flieger muss ein Designmerkmal haben (z.B. eine Markierung oder ein Logo).“
- FE: Arbeitet an der ästhetischen Anpassung, um das Design zu ändern.
- BE: Sorgt dafür, dass die Änderungen die Flugeigenschaften des Fliegers nicht beeinträchtigen.
- SM: Stellt sicher, dass die Anforderungen klar sind und dass das Team effizient zusammenarbeitet, um die Änderungen umzusetzen.
- Nach der ersten Iteration führt der PO eine Änderung der Produktanforderungen ein, z.B.:
5. Weitere Iterationen (30 Minuten)
- Aktivität:
- Weitere Iterationen, bei denen neue Anforderungen oder Änderungen hinzugefügt werden. Jede Runde könnte eine neue Anforderung beinhalten:
- „Der Flieger muss in der Lage sein, mindestens zwei Kurven in der Luft zu fliegen.“
- „Der Flieger muss in weniger als 5 Sekunden gefaltet werden.“
- In jeder Iteration:
- PO: Gibt die neue Anforderung vor und sorgt dafür, dass das Team die richtigen Prioritäten setzt.
- FE und BE: Passen ihre Arbeit an, um die neuen Anforderungen zu erfüllen.
- SM: Moderiert den Prozess, achtet auf den Fortschritt und sorgt für einen effektiven Ablauf.
- Flugversuche: Nach jeder Iteration fliegen die Teams ihren Flieger erneut und messen die Distanz.
- Weitere Iterationen, bei denen neue Anforderungen oder Änderungen hinzugefügt werden. Jede Runde könnte eine neue Anforderung beinhalten:
6. Abschlussdiskussion (15 Minuten)
- Aktivität:
- Reflexion über die Erfahrung:
- Wie haben die Teams auf die Änderungen reagiert?
- Welche Herausforderungen gab es bei der Anpassung der Flieger an die neuen Anforderungen?
- Wie haben sich die Teamrollen auf den Erfolg der Iterationen ausgewirkt?
- Reflexion über die Erfahrung:
- PO: Diskutiert, wie die Anforderungen priorisiert wurden und ob der Fokus richtig gesetzt war.
- FE und BE: Teilen ihre Erfahrungen, wie sie zusammengearbeitet haben, um Design und Funktionalität in Einklang zu bringen.
- SM: Reflektiert darüber, wie der agile Prozess während des Spiels unterstützt wurde.
Schlussfolgerungen und Agile Prinzipien¶
- Iterative Verbesserung: Die Teams haben gelernt, wie wichtig es ist, regelmäßig Feedback zu erhalten und den Flieger basierend auf diesem Feedback zu verbessern – ähnlich wie bei der kontinuierlichen Verbesserung in agilen Projekten.
- Zusammenarbeit und Kommunikation: Die Simulation fördert die Bedeutung der Zusammenarbeit zwischen den verschiedenen Rollen. Der PO sorgt für die Priorisierung der Anforderungen, der FE kümmert sich um das Design, der BE um die Stabilität, und der SM sorgt für den reibungslosen Ablauf.
- Veränderung der Anforderungen: Die Einführung von Änderungen der Produktanforderungen in jeder Runde zeigt, wie agile Teams mit wechselnden Anforderungen umgehen und schnell reagieren können.
Mit dieser Simulation können die Studierenden die dynamische und kollaborative Natur agiler Methoden in einer praktischen, interaktiven Weise erleben.
Paperplane Spiel Begleitprogramm¶
Das folgende Agile Paper Plane Game-Programm simuliert den Einsatz agiler Methoden, indem Teams mit verschiedenen Rollen (z.B. Product Owner, Frontend- und Backend-Entwickler, Scrum Master) arbeiten, um Papierflieger zu bauen. In jeder Iteration haben die Teams 30 Sekunden Zeit, einen Flieger zu erstellen, der einer vorgegebenen Anforderung entspricht. Nach jeder Iteration erhalten sie Feedback und müssen ihren Flieger anpassen. Das Programm zeigt den gesamten Prozess, einschließlich der Anzeige von Anforderungen, eines Countdown-Timers für jede Iteration und der Möglichkeit, Feedback zu geben, was die Prinzipien der kontinuierlichen Verbesserung und Anpassung in agilen Projekten simuliert.
import time
import random
import ipywidgets as widgets
from IPython.display import display, clear_output
# Define the roles
roles = ["Product Owner", "Frontend Engineer", "Backend Engineer", "Scrum Master"]
# Define the possible changes in requirements
requirements_changes = [
"The paper plane must be made of at least two different types of paper.",
"The paper plane must have a design feature (e.g., a logo or a marking).",
"The paper plane must perform at least two turns in the air.",
"The paper plane must be folded in less than 5 seconds."
]
# Define the teams
teams = {
"Team A": {"PO": "", "FE": "", "BE": "", "SM": ""},
"Team B": {"PO": "", "FE": "", "BE": "", "SM": ""}
}
# Create text widgets to input role names
role_inputs = {}
for team in teams:
role_inputs[team] = {}
for role in roles:
role_inputs[team][role] = widgets.Text(
description=f'{role} for {team}:',
layout=widgets.Layout(width='300px')
)
display(role_inputs[team][role])
# Time tracking for iterations with countdown
def time_iteration(duration):
remaining_time = duration
timer_label = widgets.Label(value=f"Remaining time: {remaining_time}s")
display(timer_label)
def countdown():
nonlocal remaining_time
while remaining_time > 0:
time.sleep(1)
remaining_time -= 1
timer_label.value = f"Remaining time: {remaining_time}s"
# Once time is up, display the message for feedback
timer_label.value = f"Time's up! You can now provide feedback."
return remaining_time
countdown()
# Function to start the game
def start_game():
print("Welcome to the Agile Paper Plane Game!\n")
# Get roles from inputs
for team in teams:
for role in roles:
teams[team][role] = role_inputs[team][role].value
print("\nGame Starting...\n")
# Start iterations
for iteration in range(3):
print(f"\n--- Iteration {iteration + 1} ---")
# Display the requirement for this iteration
new_requirement = random.choice(requirements_changes)
print(f"\nNew Requirement: {new_requirement}")
# Simulate time taken to build the plane with a countdown
print("You have 30 seconds to complete this iteration.")
time_iteration(30) # 30 seconds countdown per iteration
# Provide feedback after each iteration
print("\nFeedback Time:")
feedback = widgets.Text(description="Feedback:")
display(feedback)
def on_submit_change(change):
print(f"Feedback: {feedback.value}")
feedback.observe(on_submit_change, names='value')
# Simulate time taken to build the plane with a countdown
print("You have 10 seconds to complete the feedback.")
time_iteration(10) # 10 seconds countdown per feedback
# After countdown and feedback, start the next iteration
print("\nStarting next iteration...\n")
#clear_output(wait=True) # Clears the output to keep it clean and show the next iteration
# Button to start the game
start_button = widgets.Button(description="Start Game")
start_button.on_click(lambda x: start_game())
display(start_button)
Text(value='', description='Product Owner for Team A:', layout=Layout(width='300px'))
Text(value='', description='Frontend Engineer for Team A:', layout=Layout(width='300px'))
Text(value='', description='Backend Engineer for Team A:', layout=Layout(width='300px'))
Text(value='', description='Scrum Master for Team A:', layout=Layout(width='300px'))
Text(value='', description='Product Owner for Team B:', layout=Layout(width='300px'))
Text(value='', description='Frontend Engineer for Team B:', layout=Layout(width='300px'))
Text(value='', description='Backend Engineer for Team B:', layout=Layout(width='300px'))
Text(value='', description='Scrum Master for Team B:', layout=Layout(width='300px'))
Button(description='Start Game', style=ButtonStyle())
Welcome to the Agile Paper Plane Game! Game Starting... --- Iteration 1 --- New Requirement: The paper plane must perform at least two turns in the air. You have 30 seconds to complete this iteration.
Label(value='Remaining time: 30s')
Feedback Time:
Text(value='', description='Feedback:')
You have 10 seconds to complete the feedback.
Label(value='Remaining time: 10s')
Starting next iteration... --- Iteration 2 --- New Requirement: The paper plane must be made of at least two different types of paper. You have 30 seconds to complete this iteration.
Label(value='Remaining time: 30s')
Feedback Time:
Text(value='', description='Feedback:')
You have 10 seconds to complete the feedback.
Label(value='Remaining time: 10s')
Starting next iteration... --- Iteration 3 --- New Requirement: The paper plane must be folded in less than 5 seconds. You have 30 seconds to complete this iteration.
Label(value='Remaining time: 30s')
Feedback Time:
Text(value='', description='Feedback:')
You have 10 seconds to complete the feedback.
Label(value='Remaining time: 10s')
Starting next iteration... Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: k Feedback: kj Feedback: kjj Feedback: kjjl Feedback: kjjlk Feedback: kjjlkj Feedback: kjjlk Feedback: kjjl Feedback: kjj Feedback: kj Feedback: k Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback: Feedback:
Erklärung:¶
Rollen und Teamaufbau: Zu Beginn des Spiels müssen die Teilnehmer für jedes Team ihre Rollen festlegen (Product Owner, Frontend-Entwickler, Backend-Entwickler, Scrum Master). Jede Rolle hat spezifische Aufgaben:
- Der Product Owner legt die Anforderungen fest und priorisiert Änderungen.
- Der Frontend-Entwickler ist für das Design des Fliegers verantwortlich.
- Der Backend-Entwickler sorgt für die Flugeigenschaften und Stabilität des Fliegers.
- Der Scrum Master sorgt dafür, dass der Prozess reibungslos abläuft und unterstützt das Team bei der Zusammenarbeit.
Iterationen und Anforderungen: In jeder Iteration haben die Teams 30 Sekunden Zeit, um ihren Flieger zu bauen, wobei eine neue Anforderung durch den Product Owner vorgegeben wird. Diese Anforderungen können Änderungen im Design, der Funktionalität oder der Flugeigenschaft des Fliegers betreffen.
Countdown: Der Countdown zeigt die verbleibende Zeit für jede Iteration an. Nach Ablauf der Zeit müssen die Teams Feedback zu ihren Fliegern geben, das anschließend in die nächste Iteration integriert wird.
Feedback: Nach jeder Iteration können die Teams ihr Feedback zu den Anpassungen und dem Bau des Fliegers geben. Dies stellt sicher, dass die Teams auf das Feedback reagieren und die Anforderungen kontinuierlich verbessern.
Das Spiel fördert die Zusammenarbeit im Team, das schnelle Reagieren auf Änderungen und das Anwenden von agilem Feedback in einem interaktiven und spielerischen Rahmen.