Course 5 - Software Development Process

CS 6300 · Difficulty: 3/5

Brief Overview

This course covers the software engineering lifecycle end to end: requirements gathering, design and UML modeling, implementation, testing, and team-based development. Unlike the systems courses, the focus is less on hard technical problems and more on the process of building software correctly — version control workflows, design documents, test coverage criteria, and working on a team.

The work breaks down into three tracks:

• Individual assignments covering Git workflows, Java development, UML class diagrams, and software testing concepts.
• An individual Android project built from a requirements document, taken through design, implementation, and testing.
• A group project building a complete Android application with a team, including deliverables for design documents, use case models, test plans, and iterative releases.

Detailed Overview

Assignments

A series of individual assignments that ramp up through the tools and concepts used in the larger projects:

• Git and GitHub workflow — branching, merging, pull requests, and the collaboration patterns used for the rest of the course.
• Java application development — a small command-line application built to spec, exercising requirements interpretation.
• UML and design modeling — class diagrams, use case models, and translating requirements into design artifacts.
• Software testing — JUnit test development against provided classes, covering coverage criteria including statement, branch, path, and MC/DC coverage, plus reasoning about when full coverage is impossible for a given code structure and proving why.

Difficulty: 2/5

Summary: Individually light, but the testing assignment has more depth than it first appears — reasoning rigorously about MC/DC and path coverage impossibility takes real thought even when the code under test is small.

---

Group Project: Android Application

The centerpiece of the course: a team of three or four builds an Android app from a requirements description through multiple graded deliverables.

• Design phase — use case models, design documents, and UML class diagrams produced as a team before writing code.
• Implementation — a working Android app in Java with Activities, RecyclerViews, and SQLite persistence for local data storage.
• Practical engineering concerns that come up along the way: input validation strategy, correct money handling (integers for cents rather than floating point), background threading to keep database work off the UI thread, and navigation/back-stack behavior.
• Team workflow — feature branches, pull request reviews, merge conflict resolution, and coordinating work across teammates.
• Testing deliverables — unit tests and a test plan tied back to the requirements.

Difficulty: 3/5

Summary: The difficulty is not the code — it's coordination. Android has a learning curve if you haven't touched it before (lifecycle, threading rules, SQLite integration), and working from a shared codebase with real PR review makes this feel closer to an actual job than any other project in the program. Debugging subtle logic bugs in a codebase multiple people touch is its own education.

Overall

Difficulty: 2/5

Summary: [In progress — summer 2026. Final verdict after the group project wraps.] So far: a low-stress course that pairs well with full-time work. The material is familiar if you've worked in industry, but the Android project provides genuinely new skills, and the testing assignments sharpen concepts most developers only know informally.