Task 1

Question C. 2

Visual Studio code programming environment

1. Visual Studio Code: Visual Studio Code is a popular, free, and open-source code editor
developed by Microsoft. It provides a feature-rich environment for coding, debugging, and
version control.

2. Python Extension: To work with Python in VS Code, you'll need to install the Python extension.
This extension provides essential features like code linting, auto-completion, debugging, and
running Python scripts directly from within the editor.

3. Version Control (e.g., Git): VS Code has excellent integration with version control systems like
Git, allowing you to track changes, collaborate with others, and manage your project's source
code effectively.

4. Debugger: VS Code comes with a built-in debugger that lets you set breakpoints, step through
code, inspect variables, and troubleshoot issues in your Python application.

5. Integrated Terminal: VS Code provides an integrated terminal within the editor, which allows
you to run terminal commands, manage virtual environments, and execute Python scripts
without leaving the environment.

6. Extensions: VS Code has a rich marketplace of extensions that can enhance your development
experience further, including code formatting, project management, and various language-
specific tools.

Hardware:

The hardware requirements for using VS Code for Python development are quite modest. Here's a basic
setup:

1. Computer: A desktop or laptop computer with sufficient processing power and memory. Even a
mid-range computer should be more than capable of running VS Code and Python.

2. Operating System: VS Code is available on Windows, macOS, and Linux, so you can choose the
one that best suits your preferences and needs.

3. Keyboard and Mouse: A standard keyboard and mouse (or trackpad) for input.

4. Display: A monitor with a decent resolution is beneficial for comfortable coding and easier
multitasking.

Question C. 5

Here are some factors that contribute to an efficient and easy-to-maintain software design:

1. Modularity and Separation of Concerns: A well-designed software system is divided into

modules, each responsible for a specific set of functions. This modular approach allows
developers to work on isolated components, reducing the likelihood of unintended interactions
 between different parts of the system. It also makes it easier to understand, test, and modify
individual modules without affecting the entire application.

2. Clear and Consistent Code Structure: Consistent coding conventions, naming conventions, and a
clear code structure make it easier for developers to read and understand the codebase. This
reduces confusion and accelerates development, debugging, and maintenance tasks.

3. Abstraction and Encapsulation: Abstraction involves hiding complex implementation details

behind a simplified interface. Encapsulation ensures that data and behavior are bundled
together within modules, limiting direct access to internal components. Both abstraction and
encapsulation contribute to reducing the impact of changes on other parts of the codebase.

4. Minimal Dependencies: Minimizing dependencies between modules reduces the ripple effect of
changes. When a module has fewer external dependencies, modifications to that module are
less likely to affect other parts of the system. This isolation allows for easier maintenance and
upgrades.

5. Design Patterns: Utilizing well-established design patterns provides proven solutions to common
software design problems. Design patterns promote code reuse, improve maintainability, and
make the system more understandable to developers familiar with these patterns.

6. Documentation and Comments: Clear and up-to-date documentation, along with meaningful
comments, help developers understand the purpose, behavior, and usage of different parts of
the codebase. This documentation serves as a valuable resource for both current and future
developers working on the project.

7. Testing and Testability: An efficient software design is inherently testable. When code is
designed with testability in mind, it becomes easier to write unit tests, integration tests, and
end-to-end tests. Comprehensive test coverage helps catch bugs early, ensures the correctness
of the software, and simplifies the process of making changes without introducing regressions.

8. Loose Coupling and High Cohesion: Loose coupling refers to minimizing the interdependence
between different components. High cohesion means that elements within a module are closely
related in terms of functionality. Both principles contribute to a design where changes can be
made to one component without affecting others, promoting easier maintenance.

9. Version Control and Continuous Integration: Utilizing version control systems (e.g., Git) and
continuous integration practices helps manage code changes, track history, and automate
testing. This ensures that changes are systematically integrated, tested, and deployed, reducing
the risk of introducing errors during maintenance.

10. Refactoring: Regularly reviewing and refactoring the codebase improves its quality over time.
Refactoring involves restructuring code to enhance its clarity, maintainability, and performance.
By addressing technical debt and improving the codebase incrementally, maintenance efforts
become more manageable and efficient.
 Task 2

1. Provide screenshots to show the status of all packages loaded onto each truck at a time between
8:35 a.m. and 9:25 a.m.

2. Provide screenshots to show the status of all packages loaded onto each truck at a time between
9:35 a.m. and 10:25 a.m.
3. Provide screenshots to show the status of all packages loaded onto each truck at a time between
12:03 p.m. and 1:12 p.m

E. Provide screenshots showing successful completion of the code that includes the total mileage
traveled by all trucks.