Software engineering principles - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the Single Responsibility Principle

Which of the following best describes the Single Responsibility Principle (SRP) in software engineering?

A A class should have only one reason to change, meaning it should have only one job or responsibility.

B A class should inherit from multiple classes to reuse code efficiently.

C A class should handle all aspects of a program to reduce dependencies.

D A class should be designed to perform multiple unrelated tasks to improve performance.

💡 Hint

Think about how responsibilities affect the reasons for changing a class.

The Single Responsibility Principle states that a class should have only one reason to change, meaning it should focus on a single responsibility. This makes the code easier to maintain and understand.

📋 Factual

intermediate

Identifying the Open/Closed Principle

What does the Open/Closed Principle (OCP) state about software entities like classes or modules?

A They should be open for both extension and modification.

B They should be open for modification but closed for extension.

C They should be closed for both extension and modification.

D They should be open for extension but closed for modification.

💡 Hint

Consider how new features should be added without changing existing code.

The Open/Closed Principle means software entities should allow their behavior to be extended without modifying their source code, helping to avoid bugs and maintain stability.

🔍 Analysis

advanced

Applying the Liskov Substitution Principle

Given a base class Bird with a method fly(), and a subclass Penguin that cannot fly, which design violates the Liskov Substitution Principle (LSP)?

A Penguin overrides <code>fly()</code> to throw an exception because it cannot fly.

B Penguin does not override <code>fly()</code> and inherits the flying behavior.

C Penguin is designed as a separate class not inheriting from Bird.

D Penguin has a separate method <code>swim()</code> and does not override <code>fly()</code>.

💡 Hint

Think about substituting a subclass where the base class is expected.

LSP states that subclasses should be replaceable by their base classes without altering the correctness of the program. Throwing an exception in fly() breaks this because Penguin cannot be used where Bird is expected.

❓ Comparison

advanced

Comparing Coupling and Cohesion

Which statement correctly compares coupling and cohesion in software design?

A High coupling and high cohesion both improve software maintainability.

B Low coupling and low cohesion are ideal for modular design.

C Low coupling and high cohesion improve modularity and maintainability.

D High coupling and low cohesion reduce dependencies and improve clarity.

💡 Hint

Consider how components depend on each other and how focused their tasks are.

Low coupling means components have few dependencies, and high cohesion means components have focused, related tasks. Together, they make software easier to maintain and understand.

❓ Reasoning

expert

Reasoning about Dependency Inversion Principle

In a system where high-level modules depend directly on low-level modules, which change best applies the Dependency Inversion Principle (DIP)?

A Combine high-level and low-level modules into a single module to reduce dependencies.

B Make both high-level and low-level modules depend on abstractions like interfaces.

C Make low-level modules depend on high-level modules to control behavior.

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

💡 Hint

Think about how to reduce direct dependencies between different levels of modules.

DIP states that both high-level and low-level modules should depend on abstractions, not on concrete implementations. This reduces coupling and improves flexibility.