Only $35.99/year

Terms in this set (345)

A software development team just started using Kanban. They had the following columns with WIP limit of 3 for each column on their Kanban board from left to right: Backlog(3), Analysis(3), Development(3), Testing(3), Deployment
There are currently 3 items in Testing (3 items being tested)
Similarly, there are 3 items in Development column (2 items are in development and 1 item is done being developed)
One of the developers does not have anything to work on so the manager wants to add one more item to the development column so the developer looking for work can work on it.
Which one of the following would be a valid action in this situation? (Select any 3)

A. The manager should ask the testers to move one of the items of the Test column temporarily to the Deployment column so that we can move items from the Development column. Later, we can move items back from the Deployment column to the Testing column.
B. Add another tester in the Testing team so this bottleneck can be resolved quickly.
C. Team should get together and discuss if we should increase the WIP limit of the development column as we have more developers and it will be smoother flow if WIP limit of the Development column is increased.
D. It does not make sense for the developer to wait before one of the items moved to another column. The manager should add one more item to the development column and no other change needed.
E. Manager should ask the developer waiting for work to help the testers so that they can finish one of the items from their column and move it to Deployment column.
A software development team just started using Kanban. They had the following columns on their Kanban board, in order from left to right: Backlog, Analysis, Development, Testing, Deployment. Each column has a WIP limit of 3.
There are currently 3 items in testing (3 items being tested). Similarly, there are 3 items in the development column (2 items that are in development and 1 item is done with its development).
One of the developers does not have anything to work on, so the manager wants to add one more item to the development column so the developer looking for work can work on it.
Which of the following are valid next actions in this situation? Select all that apply.

A. The manager should ask the testers to temporarily move an item from the test column to the deployment column so that we can move a different item from development to test. Later, we can move the item back from the deployment column to the testing column

B. The manager should ask the developer waiting for work to help the testers so that they can finish one of the items in their column and move it to the deployment column.

C. The team should get together and discuss if they should add another tester to the test team so this bottleneck can be resolved quickly.

D. The manager should ask the deployment team if a done item in the testing column can be deployed so there is space to move an item from development to testing.

E. It does not make sense for the developer to wait for items to move out of testing. The manager should add one more item to the development column with no other change needed.
While calculating LCOM4, we ignore constructors and destructors. Constructors and destructors frequently set and clear all variables in the class, making all methods connected through these variables, which increases cohesion artificially.

LCOM4 = 1 indicates a cohesive class, which is the "good" class.
LCOM4 >= 2 indicates a problem. The class should be split into so many smaller classes.
LCOM4 = 0 happens when there are no methods in a class. This is also a "bad" class.

Calculate the value of the LCOM4 measurement for the following code:

#include "src/route.h"
Route::Route(std::string name, Stop * stops, double distances,
int num_stops, PassengerGenerator * generator) {
//Constructors ignored in LCOM4 calculation
}
void Route::Update() {
GenerateNewPassengers();
for (std::list<Stop *>::iterator it = stops_.begin();
it != stops_.end(); it++) {
(*it)->Update();
}
}
bool Route::IsAtEnd() const {
return destination_stop_index_ >= num_stops_;
}
void Route::NextStop() {
destination_stop_index_++;
if (destination_stop_index_ < num_stops_) {
std::list<Stop *>::const_iterator iter = stops_.begin();
std::advance(iter, destination_stop_index_);
destination_stop_ = *iter;
} else {
destination_stop_ = (*stops_.end());
}
}
Stop * Route::GetDestinationStop() const {
return destination_stop_;
}
double Route::GetTotalRouteDistance() const {
int total_distance = 0;
for (std::list<double>::const_iterator iter = distances_between_.begin();
iter != distances_between_.end();
iter++) {
total_distance += *iter;
}
return total_distance;
}
double Route::GetNextStopDistance() const {
std::list<double>::const_iterator iter = distances_between_.begin();
std::advance(iter, destination_stop_index_-1);
return iter; // resolving the iterator gets you the Stop from the list
}
int Route::GenerateNewPassengers() {
// returning number of passengers added by generator
return generator_->GeneratePassengers();
}