PSD Professional Scrum Developer 1 (PSD I) Question and Answers

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.

The Product Owner.

The Scrum Team.

The Scrum Master.

The Developers.

Discover decisions to be made as soon as possible but postpone making those decisions until the latest reasonable moment.

Making decisions as soon as possible to close feedback loops as soon as possible.

The last moment in a Sprint when code changes are allowed; after this, only stabilization work should be conducted.

The last moment a Developer is responsible for quality; after this, the Tester is responsible.

Handle them during a risk mitigation phase before development

Scrum is for functional, frontend development only

Include them in the Product Backlog

Before the release, they should be tested and validated in a hardening sprint

Specific expectations can be used as acceptance criteria to specific product backlog items

Important, recurring non-functional requirements can be added to the definition of done

A technique for ensuring that units of co-dependent systems integrate correctly

A way to ensure product code satisfies the user requirements

A test that isolates and verifies individual units of functionality

A test that ensures a specific method integrates properly with the code calling it

Every team must make their own DoD, a meeting should be organised so that the differences are known.

It depends on the product owner

All development teams must have a DoD that makes their combined work releasable.

Every team uses its own. The differences are discussed in a hardening sprint.

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

The need for a stable velocity

The benefit of the teams figuring it out theirselves

The need to have all developers busy with work

The ability of the scrum teams to produce integrated increments

They support Continuous Integration

The eliminate the need for build engineers

They ensure your product remains bug free

They clearly define the build process

They allow frequent validation and ensure the product remains in a potentially releasable state

Scrum requires no documentation

Technical writers

Scrum master

Product owner

Developers

A term representing the eventual consequences of poor technical choices

Developers that have to pay college debt

Code that hasn’t been documented

The money an organization owes to tool and hardware vendors

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

Build.

Security.

Design pattern selection.

Scalability.

It promotes good design and separation of concerns

It causes you to construct a test harness that can be automated

It improves quality and reduces bugs

D It reduces the cost of maintenance over time

It ensure there will be no bugs in the code

Keeping stakeholders at bay

Optimizing the value of the developers’ work

Managing the project and ensuring the work gets done in line with the requirements

Directing the developers

Work together and self manage to create value

Design the full architecture before starting

Creating a plan for the entire project

Create a potentially shippable functionality in the sprint

A fundamental architectural problem found in an existing application

The result of an exhaustive architectural planning effort

A small development activity to learn about technical elements of a proposed solution

A decision made by a systems architect to settle disagreement amongst the developers

Less than 50% of the application is working correctly

There are no bugs in the application

At least 50% of the application is working correctly

You did not break any of the unit tests that already existed

After the tests passes

When preparing legacy code for unit tests

When I can see the debt building in the code

After the tests fails

True

False

sprint retrospective

sprint goal meeting

backlog refinement

sprint planning

sprint review

daily scrum

Execution is fast

Independent of others

Includes exercising the persistence layer

Makes assertions about only one logical concept

Do all the work except for deployment

Complete the work in the within the foreseen time and costs

Create a potentially releasable increment from the product backlog items

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

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

Continuous Integration / Continuous Deployment / Continuous Delivery.

Blue-Green-Deployment.

Hypothesis-Driven Development.

Vertical Teams.

Blameless Post-Mortems.

All of the above.

The developers emerge architecture as the system is created

The architect works in the early part of each sprint to define the architecture of that sprint

Upfront designs are presented to the developers prior to the first sprint

The architecture cares for itself as code is written and deployed

An architect on the team undertakes all architecture tasks

When the Product Owner says it is ready.

At the end of Sprint Planning.

When the Scrum Team agrees it is precise enough.

When the Product Backlog Refinement timebox expires.

True

False

The person who is responsible for configuration management within the team

The person who broke the build

The tester responsible for validating builds

The next person who needs the build to complete successfully

Resolving conflicts amongst the developers

Selecting the product owner

Organizing work required to meet the sprint goal

Reporting productivity

Create a plan for testing the application

Identify tools and techniques to be used in testing the product

Define acceptance criteria for features

Delay test activities until a feature has been coded

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

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

A unit tests only runs on the developer’s computer

A unit test is automated

An integration test runs overnight

A unit tests isolates a specific system behavior

An integration test may be composed of unit tests

Definition of done

Sprint goal

Sprint planning outcome

Product goal

Enough to deploy the increment and update the product backlog based on the outcome of the sprint review

Enough to clean up lingering definition of done points

None, a new sprint starts immediately after the end of the previous one

At most a week for a one-month sprint

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

True

False

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

After every sprint review

From the beginning and throughout the sprints, but let's call them developers

When the developers are done

When the product is complete

Architecture is an ongoing discussion amongst the developers, focusing on implementing current Sprint Backlog Items

The developers focus only on adding functionality. The architecture will take care of itself as the developers add functionality

The developers have a set of guiding architecture principles that every developer understands and follows when writing code

Developers assign someone to the role of software architect to ensure the architecture

Architecture is dealt with in sprint 0

Identifying a particular codebase as ready for distribution

Combining two or more versions of code into a single codebase

Copying a portion of a codebase to isolate it from the original codebase

Two or more developers working together to ensure proper coding and configuration management

An approach to make decisions easier to change in the future and find the best possible point in time to make decisions.

Starting development of a software product requires a clear understanding of the underlying software architecture, and Emergent Architecture describes the process of creating this final architecture.

In Scrum there is no Architect-Role; therefore, architecture emerges naturally.

Enterprise Architects must be involved to create the foundation of each software product.

The software architecture emerges solely from decisions the Developers make from a technical perspective.

The Architect chosen by the Scrum Team.

The software architect assigned to the Scrum Team.

The Developers with input from the Scrum Team and others.

The Chief Architect.