Scrum PSD Professional Scrum Developer 1 (PSD I) Exam Practice Test

False

True

The Sprint is extended temporarily. Lessons are taken to ensure it does not happen again.

The Sprint length is unchanged, and the Scrum Team continuously learns and adapts.

The Sprint is extended, and future Sprints use this new duration.

Screenshots or pictures of the bug in action, if possible

Explains some new system functionality desired

Includes build or version number where bug was found

Expected results and observed results

Provides simple and repeatable reproduction steps

Includes code for a proposed fix

True

False

Combining two or more branches of code into a single code base

Creating a copy of existing code, isolated from the original code

Releasing a specific codebase into a production environment

Tagging or labeling a particular codebase as production ready

Just before the first check-in

Just before the product is released

When the product owner asks for a build

Just before the end of the sprint

As soon as there is code in the version control system

True

False

As needed, taking into account a short term reduction in productivity

Every sprint to remain agile

Never, it will reduce the velocity

As needed, but it should not affect the productivity

Meet with the team to see why it fails

Change the test in a way that is passes

Run it again to verify it fails.

Write the code to satisfy the test

sprint retrospective

sprint goal meeting

backlog refinement

sprint planning

sprint review

daily scrum

The sprint backlog

The product goal

The Sprint goal

Sprint review minutes

typically 10 or fewer people

this differs every sprint

at least 8 people

3 to 11

Improves quality in the requirement itself.

Promotes the use of the DRY principle.

Tracking of completeness.

Using a code generation tool, the solution can be generated from the requirements model.

Clear acceptance criteria for each feature.

True

False

They may update estimates for Product Backlog items.

They do not. The Scrum Master and the Product Owner are responsible for Product Backlog refinement.

They give input on technical dependencies.

They do not. The Developers are only responsible for prioritizing technical work.

They ask QUESTION NO:s to clarify the intent of Product Backlog items.

The feature-branch is generally kept in a buildable state.

Know immediately how a change affected the product.

Reduce effort and risk when integrating changes.

Readability of code is improved.

During the sprint planning when they can’t fit enough into the sprint

Prior to starting a new sprint

In the retrospective when it turns out they can improve quality

Prior to starting a new project

Models are not used by agile teams

Models are maintained along with the software as it emerges

Models are assembly instructions for the developers

Modeling may be useful to increase shared understanding

By keeping high-value features high in the Product Backlog.

By facilitating Scrum Team decisions.

By ensuring the meetings start and end at the proper time.

By removing impediments that hinder the Scrum Team.

The developers

Everyone invited by the product owner

The scrum master

The manager of the IT department

It is optional, no one has to attend

The product owner

The scrum process

All of these

The increment

Coding and engineering practices

Until everyone is done.

Max two hours for a one month sprint

Max two hours

Max four hours

Max four hours for a one-month sprint

Continuous Integration / Continuous Deployment / Continuous Delivery.

Blue-Green-Deployment.

Hypothesis-Driven Development.

Vertical Teams.

Blameless Post-Mortems.

All of the above.

Each team’s automated build is integrated toward the end of the sprint

Developers should perform a combination of local and private builds

Each team should have its own automated build

There is one automated build for all teams

Scrum team

The product owner

Developers

The scrum master lets them know whether they need to be preset

The degree to which the system under test has been exercised by tests.

The number of Developers that understand how the code works.

An insurance policy that covers the code for defects.

The percentage of code in version control included in a build.

Build.

Security.

Design pattern selection.

Scalability.

Because testers are terrible coders

Because the tests are checked in before the code exists

Because the product code to satisfy the test doesn’t exist yet

Because the test needs to be refactored

A test of the user interface

A test that runs during a continuous integration build

A test of multiple units of functionality

A test of a single unit of functionality

It is a great way for Testers to contribute early in the Sprint as they can start creating all the tests from the beginning.

It increases collaboration between Developers as it requires Pair Programming.

It helps to identify gaps in understanding the desired behavior.

It might lead to better code as refactoring is part of the Test-Driven Development cycle.

It helps break down complex problems into smaller ones that are much easier to be tackled.

It makes Integration Tests obsolete and by doing so saves a lot of time.

This way documentation is obligated and cannot be skipped

It creates a shared understanding of what done means

Management knows what the work of the developer needs to be checked for

It helps the developers know how much work to select during the sprint planning

Deductive

Hybrid

Empirical

Technical

Definition of done

Sprint goal

Sprint planning outcome

Product goal

To make the code more readable

To make it easy to distinguish between different software products

To communicate the identity of the developer that wrote the code

To reduce friction in a shared codebase

To ensure that orphan functions are not created

Doing all work needed to meet the Definition of Done.

Updating Sprint tasks properly in the electronic tracking tool.

Keeping track of and estimating all undone work to be completed in a “hardening" Sprint.

Reporting Sprint progress to the stakeholders daily.

Analysis performed on software at runtime

A tool that inspects the correctness of static keyword usage

Work performed by the business analyst

Analysis performed on code

The developers

Product owner

The company’s database specialist

Scrum master

It eliminates bugs completely.

It leads to higher transparency and rapid feedback for the team.

The build is executed once every night and at least once each weekend.

It can increase collaboration within the Developers.

Fix the bug

Revise the tests to hide the bug from the tests reports

Talk to the product owner

Stub out the code that causes the bug

Code review is done

Acceptance tests pass

Regression tests pass

The product is released at the end of every sprint

Code coverage 90%

Analyze, describe, and document the requirements for the subsequent Sprints.

Define the major product features and a release plan architecture.

Make up a plan for the rest of the project.

Create at least one valuable and useful Increment.

It is a chance for inspecting the outcome of a sprint and determining the next steps

It is a mechanism to control the work of the developers

It is a demo of the work that was done

Function points

Cyclometic complexity

Depth of inheritance

Visual representation of work that is still to do and time that is left

A chart showing progress towards the product goal

A chart that shows whether bugs came up

Visual representation of the product backlog items left

You are unable to check in code without them

They help you find defects and configuration management issues

Without them you can’t tell if your code works

They are part of the Definition of Done

False

True

Allow the developers to self-manage and decide what to do their selves.

Raise it as an impediment and make sure that management solves it.

Create a schedule and alternate who is responsible for the daily scrum logistics

Decide the best solution and arrange a meeting to inform the developers.

Release planning

Daily scrum

Sprint review

Sprint retrospective

Refinement meeting