Chapter_9-11

Design Class Diagram (DCD)

A UML diagram that serves as a design blueprint derived from behavioral and domain models.

UML

Unified Modeling Language, a standardized modeling language in software engineering.

Test-Driven Development

A software development process where requirements are turned into specific test cases before software is fully developed.

Integration Testing

Testing the interfaces between components to ensure they work together as intended.

Package Diagrams

Diagrams used to group related classes to manage complexity in a large DCD.

Domain Model (DM)

A conceptual model that defines the various entities and the relationships between them in the problem space.

Behavioral Models

Models representing the dynamic behavior of a system, often visualized through use case diagrams.

Iteration Use Cases

Refined use cases developed during each iteration of the agile development process.

Actor-System Interaction Modeling

Modeling the interaction between external users (actors) and the system.

Responsibility Assignment

The process of assigning responsibilities to various components within a system.

Controller Pattern

A design pattern that handles requests from actors, typically in the context of UI frameworks.

Singleton Pattern

A design pattern ensuring that a class has only one instance and provides a global point of access to it.

Attributes

Characteristics or properties of a class, represented as variables.

Methods

Functions associated with a class that define its behavior.

Association Relationship

A relationship that represents how two classes are related to each other.

Dependencies

A relationship in which one class relies on another class for its operations.

Use Case Controller

A controller dedicated to managing interactions for a specific use case.

Facade Controller

A controller that provides a simplified interface to a larger system.

Low Coupling

A design principle that promotes minimizing dependencies between components.

High Cohesion

A design principle where elements within a module or class are closely related in purpose.

GRASP Patterns

General Responsibility Assignment Software Patterns that advocate principles for assigning responsibilities in software design.

Command Pattern

A behavioral design pattern that encapsulates a request as an object.

Decorator Pattern

A structural design pattern allowing behavior to be added to individual objects, either statically or dynamically.

Observer Pattern

A behavioral design pattern defining a one-to-many dependency between objects.

Memento Pattern

A behavioral design pattern that allows the state of an object to be saved and restored.

Agile Methodology

A group of software development methodologies centered around iterative development, where requirements and solutions evolve through collaboration.

Object-Oriented Design

A programming paradigm based on the concept of objects, which can contain data and code.

Responsibility Assignment Patterns

Patterns that guide the assignment of responsibilities in object-oriented design.

Actor

An external entity that interacts with the system, representing a user or another system.

Sequence Diagram

A diagram that shows how objects interact in a particular scenario of a use case.

Information Expert

A principle that suggests assigning responsibility to the class that has the necessary information to fulfill a request.

Design Patterns

Reusable solutions to common design problems in software development.

Scenario Table

A table that organizes the interactions of a system to facilitate the construction of sequence diagrams.

Background Processing

The processing that occurs behind the scenes in response to user actions.

Foreground Processing

The processing that interacts directly with the user, usually through a GUI.

Interaction Modeling

The process of defining how objects in a system interact with each other.

Aggregate

A collection of related objects treated as a single unit in data modeling.

Stupid Objects

Objects that have minimal responsibilities and maintain a clear interface.

Prototype Pattern

A creational design pattern that allows creating new objects by copying an existing object.

Composite Pattern

A structural design pattern that allows treating individual objects and compositions of objects uniformly.

Return Type

The data type of the value returned by a method or function.

Parameter

A variable that is passed into a method or function to provide input.

Separation of Concerns

A design principle for separating a computer program into distinct sections, such that each section addresses a separate concern.

Management of Classes

The organizational structure of classes to better manage complexity in software development.

Use Case Diagrams

Visual representations of a system’s functional requirements.

Constructor

A special method used to initialize objects.

Class Diagram

A type of static structure diagram that describes the structure of a system by showing the system's classes and their relationships.

Communicating Objects

Objects that invoke methods on each other to perform operations.

Parameter Typing

The data type associated with a parameter in a function or method signature.

Code Implementation

The actual development phase where software designs are translated into code.