Design for change and extensibility in Software Engineering - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the Open/Closed Principle

Which statement best describes the Open/Closed Principle in software design?

A Software entities should be open for extension but closed for modification.

B Software entities should be closed for both extension and modification.

C Software entities should be open for modification but closed for extension.

D Software entities should be open for both extension and modification.

💡 Hint

Think about how to add new features without changing existing code.

The Open/Closed Principle means software components should allow new functionality by adding new code (extension) without changing existing tested code (modification), reducing risk of bugs.

❓ Reasoning

intermediate

Benefits of Using Interfaces for Extensibility

Why do interfaces help in designing software that is easy to extend?

A They force all classes to have the same implementation details.

B They prevent any changes to the software once implemented.

C They allow different classes to be used interchangeably through a common contract.

D They make the software run faster by avoiding method calls.

💡 Hint

Consider how different parts of software can work together without knowing internal details.

Interfaces define a common set of methods that different classes can implement differently. This allows new classes to be added without changing existing code, supporting extensibility.

🔍 Analysis

advanced

Analyzing Impact of Tight Coupling on Extensibility

What is the main problem with tight coupling between software modules when designing for change?

A It causes modules to depend heavily on each other's internal details, making changes risky and difficult.

B It makes modules run slower due to extra communication overhead.

C It increases the number of modules needed in the software.

D It allows modules to be replaced easily without affecting others.

💡 Hint

Think about how changes in one module affect others when they are tightly connected.

Tight coupling means modules rely on each other's internal workings. Changing one module often requires changes in others, reducing flexibility and increasing risk of bugs.

❓ Comparison

advanced

Comparing Design Patterns for Extensibility

Which design pattern is primarily used to allow adding new behaviors to objects dynamically without altering their structure?

A Singleton Pattern

B Decorator Pattern

C Observer Pattern

D Factory Pattern

💡 Hint

Consider which pattern wraps objects to add features at runtime.

The Decorator Pattern lets you add responsibilities to objects dynamically by wrapping them, supporting extensibility without changing original code.

🚀 Application

expert

Applying the Dependency Inversion Principle

Given a system where high-level modules depend directly on low-level modules, what change best aligns the design with the Dependency Inversion Principle to improve extensibility?

A Combine high-level and low-level modules into a single module to avoid dependency issues.

B Make low-level modules depend on high-level modules to reduce dependencies.

C Remove all abstractions and let modules communicate directly for simplicity.

D Introduce abstractions (interfaces or abstract classes) that both high-level and low-level modules depend on.

💡 Hint

Think about how to invert dependencies to depend on abstractions rather than concrete details.

The Dependency Inversion Principle states that both high-level and low-level modules should depend on abstractions. This reduces direct dependencies and makes the system easier to extend and maintain.