Implementation Aclass TodoList

def initialize

@tasks $=[]$

enddef add$\_$task$($description$)$

@tasks $$ description

puts "Task added: #$\{$description$\}"$

enddef complete$\_$task$($index$)$

if index $>=0$ && index $$ @tasks.length

task $=$ @tasks$[$index$]$

@tasks.delete$\_$at$($index$)$

puts "Completed: #$\{$task$\}"$

else

puts "Task not found"

end

enddef show$\_$tasks

puts "Todo List:"

@tasks.each$\_$with$\_$index do $|$task$,$ index$|$

puts $"$#$\{$index $+1\}.$ #$\{$task$\}"$

end

enddef save$\_$tasks

file $=$ File.open$("$tasks$.$txt$","$w$")$

@tasks.each do $|$task$|$

file.puts$($task$)$

end

file.close

puts "Tasks saved to file"

end

end

Notes: Implementation BThe Task class represents an individual task with a description.

class Task

def initialize$($description$)$

@description $=$ description

enddef description

@description

end

endclass TodoList

def initialize

@tasks $=[]$

enddef add$\_$task$($description$)$

task $=$ Task.new$($description$)$

@tasks $$ task

puts "Task added: #$\{$description$\}"$

enddef complete$\_$task$($index$)$

if index $>=0$ && index $$ @tasks.length

task $=$ @tasks$[$index$]$

@tasks.delete$\_$at$($index$)$

puts "Completed: #$\{$task$.$description$\}"$

else

puts "Task not found"

end

end

# Displays all tasks in the list. def show$\_$tasks

puts "Todo List:"

@tasks.each$\_$with$\_$index do $|$task$,$ index$|$

puts $"$#$\{$index $+1\}.$ #$\{$task$.$description$\}"$

end

enddef tasks

@tasks

end

endclass FileManagerdef save$\_$tasks$($tasks$)$

file $=$ File.open$("$tasks$.$txt$","$w$")$

tasks.each do $|$task$|$

file.puts$($task$.$description$)$

end

file.close

puts "Tasks saved to file"

end

end

Notes:

Responsibilities are divided among multiple classes:

Task class: Represents individual tasks.

TodoList class: Manages the collection of tasks.

FileManager class: Handles file operations.

Tasks are instances of the Task class, encapsulating task data.

File Operations are handled separately by the FileManager class.

Guiding Questions:

Representation of Tasks:

What's the main difference in how tasks are represented in each

implementation?

Consider how this affects the ability to manage and extend task

functionality.Single Responsibility Principle $($SRP$)$:

How does Implementation B separate concerns compared to

Implementation A$?$

Identify which classes in Implementation B adhere to SRP and

how.

Extensibility:

Which implementation would be easier to add new features to$,$ like

task due dates or priorities? Why?

Discuss how the design impacts the ease of adding new

attributes or methods to tasks.

Coupling and Cohesion:

How does each implementation handle the task of saving to a file?

Analyze the level of coupling between task management and file

operations in both implementations.

Evaluate the cohesion within the classes.

Understandability and Maintainability:

Which implementation do you think is easier to understand and

maintain? Why?

Reflect on how the design principles affect code readability and

maintainability.

Tips for Success:

Be Specific: Use concrete examples from the code to support your analysis.

Apply OOP Terminology: Use appropriate OOP concepts and vocabulary in

your explanations.

Think Critically: Analyze not just what the code does, but how it's structured

and why that matters.

Submission

This file with answers for each question and your brief summary.Objective:

Analyze two implementations of a simple todo list application written in Ruby.

Compare and contrast the designs, focusing on how they adhere to the basic OOP

principles of Single Responsibility Principle $($SRP$),$ Coupling, Cohesion, and

Separation of Concerns.

Note: This is a simplified version of a todo list application designed for educational

purposes to illustrate fundamental OOP design principles.

Instructions:

Review the Code Implementations:

Implementation A: A basic version with a single class handling

multiple responsibilities.

Implementation B: An improved version with responsibilities divided

among multiple classes.

Perform a Comparative Analysis:

Examine how each implementation handles tasks, file operations, and

overall functionality.

Focus on identifying how each design adheres to or violates the OOP

principles.

Answer the Guiding Questions:

Provide detailed answers to the questions, using specific examples

from the code to support your points.

Summarize Your Findings:

Conclude with a brief summary highlighting the importance of applying

OOP design principles.