Project Management Principles Quiz

A design principle that emphasizes the importance of creating classes that are loosely coupled and highly cohesive.

Poor requirements management refers to the lack of a clear understanding of what the project aims to achieve, leading to ambiguity, inconsistency, and ultimately, project failure.

The triple constraint states: reducing the project budget (cost) will necessitate either reducing the project timeline (time) or the project scope (features), or a combination of both.

A project is a temporary endeavor undertaken to create a unique product, service, or result.

Use cases are descriptions of how users interact with a system to achieve specific goals.

The phases of a project management life cycle typically include initiation, planning, execution, monitoring and controlling, and closing.

A milestone represents a significant achievement in a project, often marking the completion of a major phase, while a tollgate is a checkpoint used to assess whether a project has met specific criteria and should be allowed to proceed to the next phase.

Agile development emphasizes iterative and incremental development, with a focus on customer collaboration and responding to change. It prioritizes working software and continuous feedback loops.

The core of 'agile' is the assumption that requirements will change over time and that the development process should be flexible enough to accommodate those changes.

Good design is flexible, maintainable, and adaptable to future changes.

A domain model is a conceptual representation of the data and relationships within a specific problem domain. It does not include methods.

Analysis focuses on understanding the 'what' of a system, while design focuses on the 'how' to implement it.

The two main types of software requirements are functional and non-functional. Functional requirements define the features and functionalities of the system, while non-functional requirements specify the quality attributes, constraints, and performance aspects.

Interaction diagrams, such as sequence diagrams and communication diagrams, show how objects in a system interact with each other over time.

Java is a compiled language that is then executed on a Java Virtual Machine (JVM), providing platform independence.

A class should have only one reason to change, meaning that a single modification should not affect multiple functionalities of the class, making the code more manageable and less prone to errors.

Delegation, composition, and aggregation are alternatives to inheritance that allow for code reuse without tight coupling.

GRASP patterns are a set of design principles that help developers make design decisions based on key responsibilities and interactions between objects in a system. The GRASP pattern High Coupling refers to the tight interdependence of classes. It suggests that classes should be loosely coupled to improve maintainability and reusability.

The two evaluative GRASP patterns are Low Coupling and High Cohesion. Low Coupling refers to the loose interdependence of classes, promoting maintainability and reusability. High Cohesion suggests that classes should have a single, well-defined purpose, improving modularity and reducing complexity.

When other GRASP patterns don't provide a suitable solution, consider Pure Fabrication, which involves creating an artificial class to fulfill a specific responsibility without being directly tied to the domain model.

A Composite pattern describes a way to compose objects into tree structures to represent part-whole hierarchies.

The Information Expert GRASP principle states that a responsibility should be assigned to the class that has the most information about its fulfillment.

In the Observer pattern, a publisher (subject) notifies its subscribers (observers) when its state changes. Subscribers register their interest with the publisher, and receive updates as needed.

We categorize responsibilities into two categories: doing, which refers to actions or behavior that a class performs, and knowing, which represents the information or data that a class possesses.

Architectural factors refer to the high-level requirements and considerations that influence the design of a software system's architecture.

Great software is maintainable, reusable, extendable, easy to change, reliable, secure, and user-friendly.

The Evolutionary Prototyping model might be more suitable in this scenario as it allows for rapid development of prototypes to gather user feedback and refine requirements iteratively.

GRASP patterns are also applicable on a larger scale in software architecture. Some patterns encountered on the architectural level include layered architecture, client-server architecture, and microservices architecture.

A Design Model is a more detailed representation of the system, focusing on the software implementation aspects, while a Domain Model captures the real-world concepts and relationships within the problem domain, providing a more conceptual view.

Requirements change over the course of an IT project due to several factors: evolving user needs, changing business priorities, emerging technologies, and unforeseen circumstances.

The Controller is a suitable choice for handling invalid input in an MVC design. It can validate the input from the View, provide feedback to the user, and handle the necessary actions based on the validation result.