Sprint 9 - CSA Objectives (Final)

7 min read

Final Project

This Final Project demonstrates your progress in Computer Science, JavaScript, Java, and Object-Oriented Programming. By building a project, you will apply programming fundamentals and explore the impacts of computing through a topic of personal and social relevance (grouping, wayfinding, wayknowing, commerical availability (MySQL, S3), hall pass, etc).

Software Engineering Practices: Planning changes, using checklists, tracking progress (burndowns), writing commented code, and building help documentation.
Software Development Lifecycle Practices: Source control, forking, branching, building, testing and verification, pull requests, and merging/integrating.
Retrospective Engineering Practices: Presentations, live reviews, demos, code reviews, and revising plans.
Data Types: Numbers, strings, booleans, arrays, JSON objects, and SQLite tables.
Operators: String operations, mathematical operations, and boolean expressions.
Control Structures: Iteration, conditions, nested conditions, try/except, and .then/.catch.
Input/Output: HTML5 input, validation, and working with the Document Object Model (DOM).
Classes: Object-oriented design, writing classes, creating methods, instantiating and using objects, calling methods, using parameters, handling return values, abstraction, inheritance, polymorphism, and encapsulation.
Algorithms/Data Structures: Searching, sorting, hashing, algorithm analysis, collections, lists, stacks, queues, trees, sets, dictionaries, and graphs.
Deployment Practices: DNS, Docker, docker-compose, and nginx.

Mira Costa College

This project and course prepare you for college credit and future Computer Science pathways.

CS 113 Course Alignment Rubric

Required Evidence for College Credit

Students must demonstrate competency in all CS 113 learning objectives through their capstone project. Below is the alignment between CS 113 requirements and project deliverables.

Learning Objective	Project Evidence Required	Assessment Method
Data Structures
Collections	Use appropriate Java collections (ArrayList, HashMap, HashSet) in backend	Code review: Collection implementations in models/controllers
Lists	Implement list operations for managing data (add, remove, search, iterate)	Code review: List manipulation in service layer
Stacks/Queues	Apply stack/queue structures where appropriate (undo/redo, task queues)	Code review: Stack/queue usage in application logic
Trees	Implement tree structures OR use ML libraries (Smile, Weka) with tree-based algorithms (Decision Tree Classification, Random Forest)	Code review: Tree implementation, organizational hierarchy, or ML model integration
Sets	Use sets for unique data management (user roles, permissions, tags)	Code review: Set operations in authentication/authorization
Dictionaries/Maps	Implement key-value mappings for efficient data lookup	Code review: HashMap/JSONObject usage for configuration
Graphs	Model user relationships/networks using graph structures. Implement graph algorithms: friend recommendations (BFS/DFS for mutual connections), community detection (connected components), influence ranking (PageRank-style), task dependencies (topological sort), or collaboration networks	Code review: Graph representation (adjacency list/matrix), graph traversal algorithms, pathfinding for recommendations
Algorithms
Searching	Implement search algorithms (linear, binary, database queries)	Code review: Search functionality in API endpoints
Sorting	Apply practical sorting to data collections (by date, name, priority, score) using Comparator/Comparable. Note: Merge, Selection, and Insertion are requirements in AP study sessions	Code review: Comparator/Comparable implementations for business logic sorting
Hashing	Use hashing for passwords, data integrity, efficient lookups	Code review: BCrypt/hashing in authentication, HashMap usage
Algorithm Analysis	Analyze time/space complexity of implemented algorithms	Documentation: Big-O analysis in code comments or blog
Object-Oriented Design
Abstraction	Create abstract classes or interfaces to define contracts	Code review: Abstract base classes, interface definitions
Encapsulation	Use private fields with public getters/setters, hide implementation	Code review: Proper access modifiers in classes
Inheritance	Extend base classes to create specialized functionality	Code review: Class hierarchies (User → Student/Teacher)
Polymorphism	Override methods, use interface implementations for flexible design	Code review: Method overriding, interface polymorphism
Design Patterns	Apply appropriate design patterns (MVC, Repository, Factory, Singleton)	Code review: Pattern usage in application architecture
Software Development
Version Control	Use Git for branching, committing, pull requests, code reviews	GitHub: Commit history, PR descriptions, branch strategy
Testing	Write unit tests, integration tests, API tests	Code review: JUnit tests, Postman collections
Build Tools	Use Maven/Gradle for dependency management and builds	Code review: pom.xml/build.gradle configuration
Debugging	Use IDE debugger, logging, breakpoints to troubleshoot issues	Documentation: Debug process in blog, console logging
API Development	Design RESTful APIs with proper HTTP methods and status codes	Code review: Controller endpoints, ResponseEntity usage
Database Integration	Implement JPA/Hibernate with proper relationships (OneToMany, ManyToMany)	Code review: Entity models, repository interfaces, SQL queries
Deployment
Docker	Create Dockerfile and docker-compose for containerization	Code review: Dockerfile, docker-compose.yml configuration
DNS Configuration	Configure custom domain with proper DNS records	Deployment review: Live site accessible via custom domain
nginx	Set up nginx as reverse proxy for backend services	Code review: nginx.conf configuration
CI/CD	Implement automated deployment pipeline	GitHub Actions: Workflow files, successful deployments
Documentation
Code Comments	JavaDoc comments for classes, methods, complex logic	Code review: Comment density >10%, JavaDoc completeness
API Documentation	Document API endpoints, parameters, request/response formats	Documentation: Postman collections, API reference in blog
Help System	Create user guide or in-app help for features	Blog review: Help documentation with screenshots/videos
Blog Portfolio	Maintain detailed blog showing design, code, contributions	Blog review: Design docs, code highlights, PR/commit links
Personal/Social Relevance
Project Impact	Demonstrate how project addresses real-world problem	Blog/Demo: Clear explanation of project purpose and impact
Ethical Considerations	Address privacy, security, accessibility, equity in design	Documentation: Security practices, ethical design decisions

Grading Scale

A (90-100%): Demonstrates mastery of CS 113 objectives with sophisticated implementation and thorough documentation

B (80-89%): Meets all CS 113 required objectives with solid understanding and complete deliverables

Minimum Requirements for CS 113 Credit

✅ Backend implementation using Java Spring Boot with JPA/Hibernate
✅ 3+ data structures appropriately applied (Collections, Maps, Sets, Lists, etc.)
✅ 2+ algorithms implemented (searching, sorting, or custom algorithms with complexity analysis)
✅ Complete object-oriented design with abstraction, encapsulation, inheritance, and polymorphism
✅ RESTful API with proper HTTP methods, status codes, and error handling
✅ Database integration with proper entity relationships and queries
✅ JUnit tests for critical functionality (>50% code coverage)
✅ Docker deployment with docker-compose configuration
✅ Custom domain with DNS and nginx configuration
✅ JavaDoc comments on all public classes and methods
✅ Blog portfolio documenting design decisions, code contributions, and personal expertise
✅ LinkedIn page featuring project with professional summary
✅ Complete, functional capstone project addressing authentic real-world problem

Project Planning

Data Structures 2 Course Timeline

Sprint 7 (Weeks 25-29): Data Structures & Passion Project v1.0

Exploration and design phase for capstone projects
Learn and apply data structures (collections, maps, algorithms)
Build initial project prototype (v1.0)
Focus on backend architecture and database design
Peer teaching sessions on AP FRQs (Free Response Questions)

Sprint 8 (Weeks 30-33): AP Exam Preparation

v1.0 participation and feature completion live reviews
Individual checkout with instructor on Data Structures competency
Continue project development alongside AP study

Sprint 9 (Weeks 34-36): Passion Project v2.0 & N@tM

Refine and enhance project to v2.0 with advanced features
Focus on deployment, testing, and documentation
Team code reviews and integration
Final showcase at N@tM

Sprint 9 Project Requirements

During Sprint 9, you will:

Create Issues to describe your project and plans, including who is assigned, expected goals, and stretch goals
Build a Help system to guide current and future engineers working on the feature (use the search system of the project and categories, give yourself credit as author)
Develop Individual Blog to show personal expertise in project:
- Show depth by featuring Design documents
- Show contribution by highlighting PRs and Commits
Create a LinkedIn page and feature your capstone project

Sprint 9 Checkpoints

Development milestones:

Data restore/backup: Implement database backup/restore functionality
Testing: Achieve >50% code coverage with JUnit tests
UI workflow improvements: Refine user experience and interface design
Set and achieve at least one milestone each checkpoint, continuing the iterative cycle of development

Final Deliverables & Blog

Throughout Sprint 7-9, you will update your personal blog to document your project v2.0, expertise, and implementation details. Your blog will serve as the central point for communication with your instructor and showcase your CS 113 competency.

Blog Requirements:

Design documents showing data structures, algorithms, and architecture
Code highlights with explanations of OOP principles, patterns, and complexity analysis
PR and commit history demonstrating individual contributions
Testing documentation (JUnit tests, code coverage, API testing)
Deployment guide (Docker, DNS, nginx configuration)

Key Events:

Finals Week -1 (Week 35)
- Monday: Individual demo to instructor showing your custom code and CS 113 competency
- Thursday: N@tM (Night at the Museum) showcase at 6pm - team presentation
Finals Week (Week 36)
- Monday: Present LinkedIn page, Blog portfolio, and Analytics
- Final Day: Instructor completes final grading and CS 113 articulation qualification

Computer Science A