| CS-665 | Software Design & Patterns |
|---|---|
| Name | Raymond Chen |
| Date | 12/03/2024 |
| Course | Fall |
| Assignment # | Project |
The Due Manager is a command-line application designed to help students manage their academic assignments and deadlines effectively.
The project demonstrates the implementation of several software design patterns and principles:
- Builder Pattern: Used in the Due class to create due objects with flexible, readable construction
- Command Pattern: Implements undo/redo functionality for all operations (add, remove, mark complete)
The application integrates with the OpenRouter AI API to parse natural language inputs, making it more user-friendly while maintaining robust data management capabilities.
The program runs assuming the API works and not in maintenance/exceed rate time, etc. The default API model is meta-llama/llama-3.2-90b-vision-instruct:free. If any reason the API is not working, try other APIs from link: https://openrouter.ai/models?max_price=0&q=llama
Suggest other API that could work with the project, edit line 111 in file OpenRouterClient.java to any of the following:
- meta-llama/llama-3.1-405b-instruct:free
- meta-llama/llama-3.1-70b-instruct:free
- meta-llama/llama-3.2-3b-instruct:free
https://github.com/Mo2artGit/cs-665-project-DueManager
Builder Pattern for Due Objects:
- The Due.DueBuilder class allows for flexible object creation
- Optional fields (location, notes) can be added
- New attributes can be added to the Due class by extending the builder
- Maintains backward compatibility when new fields are added
Command Pattern Implementation:
- New operations can be easily added by creating new classes that implement the DueCommand interface
- Each command encapsulates its own execute and undo logic
Each component is independent and can be modified without affecting others New features can be added by creating new modules that integrate with existing interfaces
Code Organization:
- Logical package structure:
- model: Data structures
- command: Command pattern implementation
- service: Business logic
- Comprehensive JavaDoc comments explaining functionality
- Each pattern serves a clear purpose:
- Builder: Simplifies Due object creation
- Command: Enables undo/redo functionality
- Each command type implements only its unique behavior
- Shared logic is centralized in base classes/interfaces
- All due operations are managed through DueManager
- Consistent error handling and validation
- JSON handling is centralized
We'll use Apache Maven to compile and run this project. You'll need to install Apache Maven (https://maven.apache.org/) on your system.
Apache Maven is a build automation tool and a project management tool for Java-based projects. Maven provides a standardized way to build, package, and deploy Java applications.
Maven uses a Project Object Model (POM) file to manage the build process and its dependencies. The POM file contains information about the project, such as its dependencies, the build configuration, and the plugins used for building and packaging the project.
Maven provides a centralized repository for storing and accessing dependencies, which makes it easier to manage the dependencies of a project. It also provides a standardized way to build and deploy projects, which helps to ensure that builds are consistent and repeatable.
Maven also integrates with other development tools, such as IDEs and continuous integration systems, making it easier to use as part of a development workflow.
Maven provides a large number of plugins for various tasks, such as compiling code, running tests, generating reports, and creating JAR files. This makes it a versatile tool that can be used for many different types of Java projects.
Type on the command line:
mvn clean compileJUnit is a popular testing framework for Java. JUnit tests are automated tests that are written to verify that the behavior of a piece of code is as expected.
In JUnit, tests are written as methods within a test class. Each test method tests a specific aspect of the code and is annotated with the @Test annotation. JUnit provides a range of assertions that can be used to verify the behavior of the code being tested.
JUnit tests are executed automatically and the results of the tests are reported. This allows developers to quickly and easily check if their code is working as expected, and make any necessary changes to fix any issues that are found.
The use of JUnit tests is an important part of Test-Driven Development (TDD), where tests are written before the code they are testing is written. This helps to ensure that the code is written in a way that is easily testable and that all required functionality is covered by tests.
JUnit tests can be run as part of a continuous integration pipeline, where tests are automatically run every time changes are made to the code. This helps to catch any issues as soon as they are introduced, reducing the need for manual testing and making it easier to ensure that the code is always in a releasable state.
To run, use the following command:
mvn clean testSpotBugs is a static code analysis tool for Java that detects potential bugs in your code. It is an open-source tool that can be used as a standalone application or integrated into development tools such as Eclipse, IntelliJ, and Gradle.
SpotBugs performs an analysis of the bytecode generated from your Java source code and reports on any potential problems or issues that it finds. This includes things like null pointer exceptions, resource leaks, misused collections, and other common bugs.
The tool uses data flow analysis to examine the behavior of the code and detect issues that might not be immediately obvious from just reading the source code. SpotBugs is able to identify a wide range of issues and can be customized to meet the needs of your specific project.
Using SpotBugs can help to improve the quality and reliability of your code by catching potential bugs early in the development process. This can save time and effort in the long run by reducing the need for debugging and fixing issues later in the development cycle. SpotBugs can also help to ensure that your code is secure by identifying potential security vulnerabilities.
Use the following command:
mvn spotbugs:gui For more info see https://spotbugs.readthedocs.io/en/latest/maven.html
SpotBugs https://spotbugs.github.io/ is the spiritual successor of FindBugs.
Checkstyle is a development tool for checking Java source code against a set of coding standards. It is an open-source tool that can be integrated into various integrated development environments (IDEs), such as Eclipse and IntelliJ, as well as build tools like Maven and Gradle.
Checkstyle performs static code analysis, which means it examines the source code without executing it, and reports on any issues or violations of the coding standards defined in its configuration. This includes issues like code style, code indentation, naming conventions, code structure, and many others.
By using Checkstyle, developers can ensure that their code adheres to a consistent style and follows best practices, making it easier for other developers to read and maintain. It can also help to identify potential issues before the code is actually run, reducing the risk of runtime errors or unexpected behavior.
Checkstyle is highly configurable and can be customized to fit the needs of your team or organization. It supports a wide range of coding standards and can be integrated with other tools, such as code coverage and automated testing tools, to create a comprehensive and automated software development process.
The following command will generate a report in HTML format that you can open in a web browser.
mvn checkstyle:checkstyleThe HTML page will be found at the following location:
target/site/checkstyle.html