Scrum management

Introduction

Here we’ll discuss some key topics regarding Scrum management of projects

Scrum stages

Sprints

Sprint 0 (It doesn’t exist, really!!)

What this sprint isn’t:

  • It is not the phase in which the team is put together
    • In order to conduct a Sprint in the first place, a team must already be in place
  • It is not the phase for setting up infrastructure which should already be implemented or easily implemented on demand, but not as part of a Sprint Zero
  • It should not involve adding products to a backlog or Consider Planning as classical project with Gantt Diagrams plannings

The main goal of a Sprint Zero is to deliver some usable value that can be built upon by the next team.

Sprint Zeroes are required to:

  • Create the project’s skeleton, including research spikes
  • Keep design minimal
  • Develop a small number of stories to completion
  • Be low velocity and lightweight

More specifically, the deliverables of a Sprint Zero should be as follows:

  • A usable piece of code, however small
  • A minimal environment for writing code
  • A prioritization of features or a list of stories
  • A release plan assigning each story to a Sprint
  • A plan for the most likely implementation of features

Keywords of a Sprint Zero:

Let’s take the example of the Library Laboratory SE03-01

sprintZero Sprint Zero Sprint Zero Sprint Zero 1 - Project 1 - Project Sprint Zero–1 - Project 2 - DDD 2 - DDD Sprint Zero–2 - DDD 3 - UML 3 - UML Sprint Zero–3 - UML 4 - Code 4 - Code Sprint Zero–4 - Code Use Case Use Case 1 - Project–Use Case Documentation Documentation 1 - Project–Documentation Mock-up Mock-up 1 - Project–Mock-up Open? Open Project? 1 - Project–Open? Vocabulary Vocabulary 2 - DDD–Vocabulary Packages Packages 2 - DDD–Packages Model Model 2 - DDD–Model Controller Controller 2 - DDD–Controller Refactor Refactor Domain 2 - DDD–Refactor Relationships Relationships 3 - UML–Relationships Utilities Utilities 4 - Code–Utilities Core model Core model 4 - Code–Core model Managers Managers 4 - Code–Managers Dependencies Dependencies 4 - Code–Dependencies Maven Maven 4 - Code–Maven Refactor Refactor Code 4 - Code–Refactor Test Test 4 - Code–Test Git Git 4 - Code–Git User Stories User Stories Use Case–User Stories Quarto Quarto Documentation–Quarto Obsidian Obsidian Documentation–Obsidian New Feature New Feature Mock-up–New Feature Common Common Language Vocabulary–Common Controller–Managers If there isCode If there is Legacy Code Refactor–If there isCode Refactor–Refactor Composition Composition Relationships–Composition Inheritance Inheritance Relationships–Inheritance Multiplicity Multiplicity Relationships–Multiplicity Book Book Core model–Book Borrow Borrow Core model–Borrow User User Core model–User lombok lombok Dependencies–lombok JUnit JUnit Dependencies–JUnit Jupiter Jupiter Dependencies–Jupiter faker faker Dependencies–faker Make Borrow Make Borrow Test–Make Borrow GitHub GitHub Git–GitHub Create Create faker–Create 100 books 100 books Create–100 books 100 users 100 users Create–100 users

Sprint 1

We’ll define multiple tasks in the backlog and assign priorities and complexity to each of them. Don’t worry about defining tasks that might not be needed, they should be removed if they aren’t addressed after some sprints:

Template –> Task name (priority) (complexity)

  • Spring backlog:
    • Project:
      • Business Model (21) (13)
      • Use cases (21) (13)
      • Define Release Plan:
        • Number of Sprints (21) (8)
        • Goal for each Sprint (21) (8)
      • Mock-ups (13) (13)
      • Security (21) (21)
      • Deployment:
        • Programming languages and versions () ()
        • Dependencies () ()
        • Pipeline () ()
      • Documentation: (21) (13)
        • Git:
          • Technology to use (GitHub, GitLab) (8) (5)
          • Stylebook: (13) (13)
            • Branch names
            • Commit texts and labels
          • Roles (13) (8)
            • Who reviews pull requests?
            • Who can merge code?
            • Who can push to production?
      • Scrum concepts: (13) (8)
        • Define “Done” task
    • Domains:
      • Common language (21) (13)
      • Rethink Test Borrow by Console (5) (21)
    • UML:
      • Functional diagram (21) (13)
      • Core classes (21) (13)
      • Manager classes (13) (13)
    • Code:
      • Sandbox: (21) (8)
      • Git:
        • Initialization (21) (8)
      • Refactor user interface (13) (13)
      • Test Borrow (13) (13)
      • Book Manager (13) (8)
      • Borrow Manager (13) (21)
      • User Manager (13) (8)
      • Create fakers for each Manager (13) (13)
      • Deployment (21) (21)

After that, we’ll work with a Kanban table to keep track of the status of each task:

  • Options:
    • GitHub projects
    • OpenProject