Professions and Their Origins

A modeling language used to design and document software systems.

Modeling at different phases of software development, including requirements analysis, design, and implementation.

The process of identifying user needs and translating them into functional requirements for software.

The act of analyzing requirements and breaking them down into design specifications.

The process of creating the high-level structure and organization of the software system.

The detailed design of classes, interfaces, and components to implement the software system.

The process of creating a usable software artifact from the designs.

A technique used to manage complex systems by breaking them into smaller, manageable parts. It's about simplifying a problem into smaller, easier-to-solve pieces.

A decomposition approach that focuses on breaking down a system into modules, each representing a major processing step or function within the application. Modules can be further divided into smaller modules.

A decomposition approach that structures a system into objects, each representing a key abstraction in the application domain. Objects are grouped into classes, which can be further decomposed into smaller classes.

When using functional decomposition, functionality can be spread across different parts of the system, making code difficult to understand and maintain.

With functional decomposition, changing one part of the system might require understanding and modifying other, seemingly unrelated parts, making code maintenance challenging.

Functional decomposition can lead to complex and hard-to-maintain code, ultimately leading to poor code quality.

The user interface can be awkward and unintuitive as a result of the functional decomposition approach.

Object-oriented decomposition emphasizes encapsulating functionality within objects, leading to more modular and maintainable code.

Using object-oriented decomposition, changes to one part of the system are less likely to affect other parts, resulting in easier code maintenance.

A software development paradigm that uses objects, classes, inheritance, and polymorphism to represent and organize components of a system.

The process of identifying classes, which are blueprints for creating objects, in a software system.

The process of designing a software system from scratch.

The process of analyzing and restructuring an existing system to identify its components and improve its design.

The process of creating a class-based interface for a system, allowing interactions with the system's functionalities.

The approach chosen for designing a software system, either based on functional decomposition or object-oriented principles.

The purpose or goal of a software system, which influences the choice of decomposition approach.

A language with a set of symbols and rules used to visually represent and communicate software design, such as UML.

A question that helps understand the reason behind choosing one decomposition approach over another.

A sequence of activities and their relationships, supporting the development of a software system.

Describes the functionality of a system, outlining what the system should do and how it should interact with users.

Defines the structure and organization of a software system. It focuses on the classes and objects that will be used in the system.

An object in a model can have attributes, which are specific characteristics describing the object's state.

An object in a model can have operations, also known as methods, which define the object's behavior and actions.

A representation of the static structure of a system, showing the classes and their relationships.

An object in a model can have relationships with other objects, defining how they interact.

The process of continuously refining and improving the software model as development progresses.

A model can have different levels of detail depending on the specific purpose and phase of development.

A model should accurately reflect the intended system and serve its purpose within the development process.

Different models may be created for different purposes, such as analyzing requirements, designing the architecture, or documenting the code.

Models should be evaluated to ensure they are relevant, accurate, and useful for the given development context.