Separation of concerns in Software Engineering - Mini Project: Build & Apply

Separation of Concerns in Software Design

📖 Scenario: You are designing a simple software system for a library. The system needs to manage books, handle user interactions, and store data.To keep the system easy to maintain and understand, you will apply the principle of Separation of Concerns. This means dividing the system into parts where each part has a clear and separate responsibility.

🎯 Goal: Build a simple model that shows how to separate concerns by creating three parts: one for managing book data, one for user interaction, and one for data storage.This will help you understand how to organize software so each part does its own job without mixing responsibilities.

📋 What You'll Learn

Create a data structure to hold book information

Create a variable to represent the user interface type

Write a function that handles book data management

Add a final step that connects all parts logically

💡 Why This Matters

🌍 Real World

Separating concerns helps developers build software that is easier to maintain, test, and update by keeping different parts independent.

💼 Career

Understanding separation of concerns is essential for software engineers to write clean, modular code and collaborate effectively in teams.

1

Create the Book Data Structure

Create a dictionary called books with these exact entries: '1984': 'George Orwell', 'To Kill a Mockingbird': 'Harper Lee', and 'The Great Gatsby': 'F. Scott Fitzgerald'.

Software Engineering

# Create the books dictionary with the given entries
# Your code here

Hint

Use a Python dictionary with book titles as keys and authors as values.

2

Set the User Interface Type

Create a variable called user_interface and set it to the string 'console' to represent the type of user interface.

Software Engineering

books = {
    '1984': 'George Orwell',
    'To Kill a Mockingbird': 'Harper Lee',
    'The Great Gatsby': 'F. Scott Fitzgerald'
}
# Set the user_interface variable to 'console'
# Your code here

Hint

Assign the string 'console' to the variable user_interface.

3

Write the Book Management Function

Define a function called manage_books that takes no arguments and returns the books dictionary.

Software Engineering

books = {
    '1984': 'George Orwell',
    'To Kill a Mockingbird': 'Harper Lee',
    'The Great Gatsby': 'F. Scott Fitzgerald'
}
user_interface = 'console'
# Define the manage_books function that returns books
# Your code here

Hint

Define a function with no parameters that returns the books dictionary.

4

Connect the Parts Logically

Create a variable called system_components that is a dictionary with keys 'data', 'interface', and 'logic'. Assign books to 'data', user_interface to 'interface', and the function manage_books to 'logic'.

Software Engineering

books = {
    '1984': 'George Orwell',
    'To Kill a Mockingbird': 'Harper Lee',
    'The Great Gatsby': 'F. Scott Fitzgerald'
}
user_interface = 'console'

def manage_books():
    return books

# Create system_components dictionary connecting data, interface, and logic
# Your code here

Hint

Create a dictionary linking the three parts by their names and variables.

Practice

1. What is the main purpose of Separation of concerns in software engineering?

easy

A. To combine all functions into one large module

B. To write all code in a single file for simplicity

C. To make programs run faster by using fewer lines of code

D. To divide a program into parts that each handle a specific task

Solution

1. Step 1: Understand the concept of Separation of concerns

   It means splitting a program into parts where each part does one specific job.

2. Step 2: Compare options with the concept

   Only To divide a program into parts that each handle a specific task describes dividing a program into parts with specific tasks, matching the concept.

3. Final Answer:

   To divide a program into parts that each handle a specific task -> Option D

4. Quick Check:

   Separation of concerns = dividing tasks [OK]

Hint: Think: one part, one job for clarity [OK]

Common Mistakes:

• Confusing separation with combining code
• Thinking it speeds up code execution
• Believing it means fewer files always

2. Which of the following is a correct way to apply separation of concerns in a web application?

easy

A. Separating HTML for structure, CSS for style, and JavaScript for behavior

B. Writing all logic inside the HTML file

C. Mixing HTML, CSS, and JavaScript all in one file

D. Using only one programming language for everything

Solution

1. Step 1: Identify how separation of concerns applies to web development

   It means keeping structure, style, and behavior in separate parts.

2. Step 2: Match options to this principle

   Separating HTML for structure, CSS for style, and JavaScript for behavior correctly separates HTML, CSS, and JavaScript by their roles.

3. Final Answer:

   Separating HTML for structure, CSS for style, and JavaScript for behavior -> Option A

4. Quick Check:

   Separate structure, style, behavior = C [OK]

Hint: Remember: HTML = structure, CSS = style, JS = behavior [OK]

Common Mistakes:

• Putting all code in one file
• Mixing style and logic together
• Ignoring the role of each language

3. Consider this code snippet in a program:

def calculate_area(radius):
    return 3.14 * radius * radius

def print_area(radius):
    area = calculate_area(radius)
    print(f"Area is {area}")

print_area(5)

Which part shows separation of concerns?

medium

A. calculate_area handles calculation; print_area handles output

B. Both functions handle calculation and printing together

C. print_area calculates area and prints it

D. No separation; all code is mixed in one function

Solution

1. Step 1: Analyze the roles of each function

   calculate_area only calculates the area; print_area calls it and prints the result.

2. Step 2: Identify separation of concerns

   Calculation and printing are handled by separate functions, showing separation.

3. Final Answer:

   calculate_area handles calculation; print_area handles output -> Option A

4. Quick Check:

   Separate calculation and printing = B [OK]

Hint: Look for functions doing one job each [OK]

Common Mistakes:

• Thinking one function does both jobs
• Ignoring function responsibilities
• Assuming printing is part of calculation

4. A developer wrote this code mixing data processing and user interface:

def process_and_show(data):
    result = []
    for item in data:
        if item > 10:
            result.append(item * 2)
    print("Processed data:", result)

What is the main problem related to separation of concerns?

medium

A. The function uses a loop incorrectly

B. Data processing and displaying results are combined in one function

C. The condition item > 10 is wrong

D. The print statement should be outside the function

Solution

1. Step 1: Identify tasks in the function

   The function both processes data and prints output, mixing concerns.

2. Step 2: Understand separation of concerns principle

   Processing and displaying should be in separate parts for clarity and maintenance.

3. Final Answer:

   Data processing and displaying results are combined in one function -> Option B

4. Quick Check:

   Mixing processing and UI = problem [OK]

Hint: Separate logic and display in different functions [OK]

Common Mistakes:

• Blaming loop or condition instead of separation
• Thinking print must be outside always
• Ignoring function responsibility clarity

5. You have a program that reads user input, processes data, and saves results to a file. How should you apply separation of concerns to improve it?

hard

A. Write one function that does input, processing, and saving all together

B. Only separate input and processing; saving can be mixed with processing

C. Create separate functions: one for input, one for processing, one for saving

D. Combine input and saving, but separate processing

Solution

1. Step 1: Identify the distinct tasks in the program

   Input reading, data processing, and saving results are three different jobs.

2. Step 2: Apply separation of concerns principle

   Each task should be handled by its own function to keep code clear and maintainable.

3. Final Answer:

   Create separate functions: one for input, one for processing, one for saving -> Option C

4. Quick Check:

   Separate input, processing, saving = D [OK]

Hint: Split tasks into separate functions for clarity [OK]

Common Mistakes:

• Combining multiple tasks in one function
• Partially separating tasks incorrectly
• Ignoring maintainability benefits