Introduction to Variability in Software Systems

A data structure that represents connections between entities called nodes or vertices.

A type of graph where the connections between nodes have a direction.

A type of graph where the connections between nodes are bidirectional.

A graph where each connection has an associated numerical value.

A graph where each node has a specific label or color.

The concept of allowing software to adapt to different configurations and environments during runtime.

A variable whose value can be accessed and modified by any part of a program.

A programming technique where code blocks are executed only if specific conditions are met.

In this context, it refers to a setting that determines if a graph should have weights associated with its edges.

A boolean (true or false) value that determines if the nodes in a graph should be colored.

A specific type of variable used to represent the color of a node in a graph.

A programming pattern that allows for code to be executed based on a configuration setting.

The ability to change the behavior of a program without modifying or recompiling its source code.

Variability refers to the ability of software systems to adapt to different needs without requiring major changes in the core code.

Binding time is the moment when a design decision is made and implemented in a software system.

Runtime variability allows software applications to adapt to different user contexts and situations while the system is running.

A non-variable graph implementation is a fixed structure where the connections between nodes are predefined and cannot be changed at runtime.

In the provided code example, features like the color, weight, and printing behavior of the graph can be configured and modified during runtime.

Implementing runtime variability requires careful design considerations and appropriate code structures to ensure that changes can be made efficiently and without disrupting the core functionality.

Design patterns are established solutions to common software design problems, including runtime variability.

Using design patterns can help create robust and maintainable systems with runtime variability, as they provide structured solutions to common challenges.

A programming concept where code for a feature or functionality is spread across multiple parts of the codebase.

Changes to configuration options (e.g., color settings) don't automatically update the current state of the program.

Code that relies on specific conditions being met or certain initialization steps to function correctly.

A design pattern that addresses code scattering by providing a centralized and organized way to manage feature variations.

A type of runtime variability where the program's behavior is determined by configuration settings that are defined at compile time. The configuration settings are fixed and cannot be altered during execution.

A type of runtime variability where the program's behavior can be adjusted during execution based on external factors. This could include user input or environment variables.

Global variables that are read-only and cannot be changed after the program starts. These variables are a good way to implement compile-time configurations.

A class designed to store constants that represent configuration settings for a program. This class makes it easier to manage and modify configurations throughout the codebase.

The process of altering the behavior of a class or method based on configuration settings. The configuration might determine which features are enabled, what data structures are used, or how computations are performed.

A mechanism for exposing and modifying configuration settings through method parameters. This allows users to customize the behavior of a class or method at runtime.

A design technique where the program's behavior is influenced by configuration settings passed in as part of the method parameters. This allows customization of behavior based on the user's preferences or specific requirements.

A design pattern where classes extend functionality by wrapping existing objects, allowing for dynamic composition of behaviors at runtime. It focuses on delegation instead of inheritance, promoting modularity and flexibility.

A design pattern that promotes modularity by allowing the addition of features or behaviors to an existing object without modifying its core functionality.

Extensions, or features, which can be combined in different ways at runtime, are independent of each other and do not rely on inheritance.

A way to add new behaviors to an object by wrapping it in a decorator.

The inability to add public methods to an object using only decorators, limiting extensibility.

An overhead incurred when using decorators due to additional function calls and indirections.

Multiple physical objects, each implementing a specific feature, collaborate to form a single conceptual object.