Question catalogue — SYP, year 3

What is acceptance, and what changes at that moment? (lo-1)

Why are acceptance criteria written at the start? (lo-2)

How is an acceptance session run? (lo-3)

What is the difference between acceptance with defects and refusal? (lo-4)

What must a handover contain? (lo-5)

Why must the team not operate the system during acceptance? (lo-3, lo-1)

Why are software estimates systematically too low? (lo-1)

How should an estimate be phrased? (lo-2)

How do you forecast with your own measured throughput? (lo-3)

What is the difference between an estimate and a commitment? (lo-4)

When do you re-estimate, and what do you record afterwards? (lo-5)

Somebody asks you to lower your estimate. What do you do? (lo-4, lo-2)

Why are generating and selecting ideas kept apart? (lo-1)

Describe the 6-3-5 procedure and say what it produces (lo-2)

Name the six techniques and the situation each one suits (lo-3)

Build a morphological box for a small problem and read a solution out of it (lo-4)

How do Bionik and the Delphi method differ from the intuitive techniques? (lo-5)

Why is "ask an agent for fifty ideas" not a replacement? (lo-1, lo-3)

What is the difference between a milestone, a phase, a task and a deadline? (lo-1)

How do you write a milestone that somebody else can check? (lo-2)

Where in the year do milestones belong? (lo-3)

What does a milestone trend chart show that a status report cannot? (lo-4)

A milestone is missed. What are the legitimate responses? (lo-5)

Why does "the implementation phase is complete" fail as a milestone? (lo-1, lo-2)

Which criteria make a piece of work a project? Give an example that fails one (lo-1)

What belongs in an initial situation, and what does not? (lo-2)

Name the three constraints and explain which one moves in a school year (lo-3)

Where does the initial situation live in the project repository, and why there? (lo-2)

Name the fields of the project application and what belongs in each (lo-1)

What is the difference between Projektantrag and Projektauftrag? (lo-2)

What does "frozen" mean, and what would go wrong without it? (lo-3)

Give the German terms for research objective, planned deliverable and effort estimate (lo-4)

Why is "work on the frontend" not a milestone? (lo-1, lo-3)

Name the four elicitation techniques, what each delivers and what it costs (lo-1)

How do you prepare and conduct an interview so the answers are usable? (lo-2)

What does a document analysis deliver that no interview can, and how do you run one? (lo-3)

In which order do you use the techniques, and why that order? (lo-4)

Two techniques for two situations, each with a justification (lo-4)

What must elicitation produce before it counts as finished? (lo-5)

What is a stakeholder, and how do internal and external ones differ? (lo-1)

Turn "the app should be fast" into a verifiable goal (lo-2)

Why does a charter contain non-goals? (lo-3)

Why is "we implement a REST API" a bad goal? (lo-2, lo-3)

In which three dimensions is a project goal stated, and what is an Ergebnisziel? (lo-4)

Which four questions do you ask before writing a goal down? (lo-5)

What is Zielkonkurrenz, and what do you do about it? (lo-6)

Describe the four steps of a weighted scoring (lo-1)

What makes a criterion useful, and what makes one useless? (lo-2)

Two alternatives end 745 to 738. What does that mean? (lo-3)

How can a weighted scoring be manipulated, and what prevents it? (lo-4)

Why is the result written into the project proposal at all? (lo-1, lo-3)

What is presented at a milestone review, and what is not? (lo-1)

What counts as evidence, and what is only an assertion? (lo-2)

How do you review another team’s repository? (lo-3)

What makes a review comment usable? (lo-4)

What happens to the findings after the review? (lo-5)

How do you prepare for a milestone review, and why does it take forty minutes? (lo-1, lo-5)

How does the second review differ from the first? (lo-1)

What does a forecast at this review consist of? (lo-2)

Why must a deployed end-to-end slice be shown at this review? (lo-3)

The forecast does not fit the deadline. What do you bring to the review? (lo-4)

What do you look for when reviewing another team at this stage? (lo-5)

"We are aware of that finding." Why is that not an answer? (lo-1)

Map the charter fields onto their artefacts (lo-1)

Turn a charter objective into a requirement with a scenario (lo-2)

Why is "change archived by date" a better milestone than a status report? (lo-3)

How is individual responsibility visible without a separate document? (lo-4)

What goes wrong if you copy the charter text into the specs? (lo-1, lo-2)

Why is "we are 90 % done" not a progress measure? (lo-1)

How do you derive progress from archived changes? (lo-2)

What does a team’s working rhythm predict? (lo-3)

What can the repository not show, and how is that covered? (lo-4)

How is individual responsibility shown without a separate report? (lo-5)

Why does an unarchived change count as not done? (lo-2, lo-1)

Walk through the loop from proposal to archive (lo-1)

What does each artefact answer? (lo-2)

When do you write a design document? (lo-3)

How do you notice that a change is too large, and what do you do? (lo-4)

Why archive continuously instead of at the end of the year? (lo-1, lo-4)

What is the invariant pattern behind every process model? (lo-1)

Place waterfall, Scrum and SDD by tempo and say what follows from each (lo-2)

Why does the choice of process model not affect the charter? (lo-3)

Where has the uncertainty moved, now that code is cheap to produce? (lo-1, lo-2)

When would you still choose a long loop? (lo-4)

Name the states of a change and the condition for each transition. (lo-1)

What does archiving do, and why is it the point of the loop? (lo-2)

A change turns out to be wrong. What do you do? (lo-3)

Along which line do you split a change that is too large? (lo-4)

What can you read off a project’s changes/ and archive/ folders? (lo-5)

Why must specs/ never be edited directly? (lo-2, lo-1)

Which artefacts does a change carry, and what does each answer? (lo-1)

What is the difference between the target state and the delta? (lo-2)

Write a requirement with a scenario, and say what makes it checkable. (lo-3)

When does a change need a design document? (lo-4)

What must a task contain to be usable? (lo-5)

Why is the proposal separate from the specification? (lo-1, lo-2)

Why does a requirements document go stale, and why does a target state not? (lo-1)

If the target state may change, what stops a team from redefining success? (lo-2)

Trace one requirement from elicitation to verification. (lo-3)

Where does a given sentence belong — charter, target state or change? (lo-4)

What replaces the signed requirements document at acceptance? (lo-5)

Why must a Pflichtenheft and a target state not be maintained side by side? (lo-1, lo-4)

What is a specification, and how does it differ from a requirements document? (lo-1)

What are Lastenheft and Pflichtenheft, who writes each, and what is in them? (lo-5)

Which chapters does a Pflichtenheft have, and what is the Kriterienkatalog for? (lo-6)

Write a requirement with a scenario for "sessions have a capacity limit" (lo-2)

Why did precise statements of intent become the scarce resource? (lo-3)

What is frozen, what is alive, and why do you need both? (lo-4)

Why is "the service uses a repository class" a bad requirement? (lo-1, lo-2)

Describe the agentic loop. Which part of it is your responsibility? (lo-1)

What makes a stop condition usable? (lo-2)

How do you recognise a loop that is not converging? (lo-3)

What kind of work can an agent do unattended in a loop? (lo-4)

Which work is safe to run unattended, and what precautions apply? (lo-5)

Why does "keep going until the code is good" fail as an instruction? (lo-2, lo-3)

What does a language model do, and what follows for its reliability? (lo-1)

Which three ingredients make a task formulation checkable? (lo-2)

Name four failure modes and how you would notice each (lo-3)

What may you hand to an agent, and what must stay out? (lo-4)

Why is a large single prompt worse than several small ones? (lo-2, lo-3)

What belongs in the context for a task, and what only adds noise? (lo-1)

What happens when the context window fills up? (lo-3)

Which four parts does a continuation prompt have? (lo-2)

Why does project knowledge belong in the repository and not in a chat? (lo-4)

What is wrong with a continuation note that lists what you did? (lo-2)

What is a harness, and which of its parts can you change? (lo-1)

What belongs in a project instruction file, and what does not? (lo-2)

How do you decide which commands an agent may run without asking? (lo-3)

A result is wrong. How do you tell whether the model or the harness failed? (lo-4)

Why is the harness kept in version control, and what must never be in it? (lo-5)

You keep telling the agent the same thing every session. What do you do? (lo-2, lo-5)

Why is documentation kept as text in the repository? (lo-4)

Show the AsciiDoc markup for a section, a table, a code block and a warning (lo-1)

How do you convert the document, and why through a container? (lo-2)

Why are diagrams kept as PlantUML source rather than as images? (lo-3)

What must accompany every image in this course? (lo-3, lo-4)

Which problem do containers solve? (lo-1)

Distinguish image, container and registry. (lo-2)

Which commands run, inspect and clean up a container? (lo-3)

Why is a container not a virtual machine? (lo-4)

When is a container the wrong tool? (lo-5)

Why does editing files inside a running container not fix anything? (lo-2, lo-3)

Write a Dockerfile for a small application and explain each instruction. (lo-1)

How does the layer cache work, and how do you order instructions for it? (lo-2)

What does a multi-stage build achieve? (lo-3)

Which security rules apply to an image others will run? (lo-4)

How do you tag and publish an image so somebody else can reproduce your run? (lo-5)

Why is COPY . . early in a Dockerfile usually a mistake? (lo-2, lo-4)

Why might an image built on one machine not run on another? (lo-1)

How do you recognise an architecture mismatch? (lo-2)

How do you build and publish a multi-architecture image? (lo-3)

What is an image index and how is the right variant chosen? (lo-4)

When is a multi-architecture build worth its cost? (lo-5)

Why can buildx build --platform amd64,arm64 --load never work? (lo-3, lo-4)

Why must data and configuration live outside the image? (lo-1)

Named volume or bind mount? (lo-2)

How does configuration reach a container? (lo-3)

Where must a secret never be, and where does it go instead? (lo-4)

How do you back up and restore the data of a containerised service? (lo-5)

A team keeps three images — dev, test and prod. What is wrong? (lo-1, lo-3)

Describe the four parts of the smallest useful pipeline (lo-1)

Why does CI run the same script as the local build? (lo-1, lo-3)

What does the neutral build environment settle? (lo-3)

A run is red. How do you find the cause? (lo-2)

How does the site get published, and what happens on a red build? (lo-4)

Name the three states of a file in git and the commands that move it (lo-2)

What does a commit contain, and why is it a state rather than a diff? (lo-1, lo-2, lo-7)

What makes a commit message useful? Give a bad and a good example (lo-3)

Name five commit types and say what each is for (lo-3)

Which files must not be committed, and why does deleting them later not help? (lo-4)

How do you read what changed in a specific commit? (lo-1)

Where does the network start in the git picture, and what follows from that? (lo-5)

What is the difference between a centralized and a distributed VCS, and what does the distributed one make possible? (lo-6)

You commit three times, and the third commit deletes a file. What is in the repository afterwards? (lo-7)

What is a branch technically, and why is creating one cheap? (lo-2)

When do you get a fast-forward and when a merge commit? (lo-3)

Show the commands for creating, merging and deleting a branch (lo-1)

Which branching rules apply in this course, and why each? (lo-4)

You deleted a branch by mistake. Is the work gone? (lo-2, lo-4)

What is a detached HEAD, how do you get into one, and why is committing there dangerous? (lo-5)

What is origin/main, and how does it differ from the remote’s main? (lo-1)

When does a conflict occur, and why does git not resolve it itself? (lo-3)

Walk through resolving a conflict (lo-2)

Your push is rejected with "fetch first". What happened, what do you do? (lo-4)

You committed to main by mistake. How do you fix it? (lo-4)

What does a pull request add that a local merge does not? (lo-3)

When do you need a fork, and when is a branch enough? (lo-5)

Walk through opening a pull request from a fork (lo-5, lo-1)

Which three questions does a pull request description answer? (lo-1)

What makes a review comment useful? Give an example of each kind (lo-2)

Which rules apply to pull requests in this course? (lo-4)

Why is a two-thousand-line pull request a problem? (lo-1, lo-4)

Which checks happen before the partition table is touched, and why each one? (lo-1)

Why not WSL2? (lo-2)

What does idempotent mean, and why is it required here? (lo-3, lo-4)

Why are tool installation and identity setup separate scripts? (lo-3)

Your setup run aborted halfway. What do you do? (lo-4)

What distinguishes software engineering from programming? (lo-1)

Name the forces that make software hard, with one example each (lo-2)

Which practice answers which force? Give two pairs (lo-2)

What did cheap code production change, and what did it not? (lo-3)

Why is "engineering is obsolete now" the wrong conclusion? (lo-3)