CSC-210 study plan

Map each SOLID principle to a concrete code smell it prevents, writing a one-paragraph example of a violation and its refactor for all five principles

Compare layered, hexagonal, and microservices architectures on coupling, deployment, and testability using a single worked scenario

Implement from scratch a singly linked list, a dynamic array, and a hash table with open addressing, including insert, delete, and lookup

Derive Big-O time and space complexity for every operation you implemented and justify each bound in writing

Diagram a system you know using component, deployment, and sequence views, and annotate each dependency direction

Apply the Dependency Inversion and Interface Segregation principles to break a cyclic module dependency you identify in that diagram

Implement binary search trees, balanced-tree rotations, and a priority queue, then benchmark them against your Week 1 structures

Trace and explain at least two concurrency hazards such as race conditions or deadlocks in pseudocode and propose fixes

Write a unit, integration, and end-to-end test for one feature and classify each by scope, speed, and failure signal

Compute statement and branch coverage for a small module and identify two untested paths that coverage metrics hide

Contrast Waterfall, Scrum, and Kanban on change handling, cadence, and estimation approach using one project scenario

Design a test plan for a sprint increment that states entry criteria, exit criteria, and defect triage rules

Apply boundary value analysis and equivalence partitioning to derive test cases for a validation rule with numeric and string inputs

Explain the test pyramid and justify where your team should invest automation effort for a given release cadence

Map the V-model test levels to artifacts produced in each SDLC phase and note which phase owns each defect class

Write a regression strategy that selects tests based on change impact rather than running everything

Elicit and write ten functional requirements and five non-functional requirements with measurable acceptance criteria

Rewrite three vague requirements into testable statements and flag each ambiguity you resolved

Set up a Git repository with a branching model, protected main branch, and a pull-request review checklist

Build a CI pipeline that runs build, tests, and static analysis on every push and blocks merges on failure

Implement semantic versioning and a changelog convention, then tag two releases with reproducible build artifacts

Trace one requirement ID from specification through commit, test, and deployment to demonstrate end-to-end traceability

Produce a three-point estimate for five backlog items and compare the total with a planning-poker consensus estimate

Build a burndown or cumulative flow chart from simulated sprint data and interpret two anomalies in it

Identify and rank five project risks by probability and impact, and assign a mitigation owner and trigger to each

Apply the OWASP Top Ten to a design you produced earlier and list the three highest-exposure weaknesses with concrete controls

Threat-model one feature using STRIDE and record at least six threats with mitigations

Explain how secure coding practices such as input validation, output encoding, and least privilege map to specific development tasks

Analyze two ethical dilemmas involving user data, disclosure, or schedule pressure using a recognized code of ethics and reach a defensible recommendation

Validate a requirements set for completeness, consistency, and verifiability, and log every defect you find

Take two timed practice exams under exam conditions and categorize every miss by domain

Build a targeted review list of your three weakest subdomains and close each gap with a written summary