Welcome to the course!

• Slides
• Syllabus
• Work Preferences Form
• Your Name + Github Handle

• Syllabus Quiz

• Slides

1. Maitre, N.L., Marra, L., Kjeldsen, W. et al. A social media-delivered intervention for motor delays: stage-Ib randomized clinical trial and implementation exploration. Pediatr Res (2025). https://doi.org/10.1038/s41390-025-04151-5. Full text available via UNCA library.
2. Rasmusson, J. (2010). The Agile Samurai. Ch. 1: Agile in a Nutshell
3. Rasmusson, J. (2010). The Agile Samurai. Ch. 2: Meet Your Agile Team

• Slides
• Backend Deep Dive

• Starter Code Setup Quiz

• Testing workshop focused on contract-level API tests (not full coverage)
• Studio: write tests for existing endpoints
• Live critique of one test PR: clarity, naming, and what behavior is asserted

• Pytest Workshop

1. Intro to FastAPI
2. Testing API Endpoints

• Intro to FastAPI
• Testing API Endpoints

• Team agreements
• How is testing going? Any questions?
• Mini-lecture on relationship design and tradeoffs
• Activity: whiteboard the domain model before coding
• Begin implementation plan and test plan (what behavior must be true)

• Schedule a meeting with Prof. Sanft
• Domain Modeling

1. SQLAlchemy Models and Queries
2. Decorators and Dependency Injection
3. JWTs and Authentication

• SQLAlchemy
• FastAPI Dependencies
• JWT Authentication

• HW1 Feedback & Discussion
• Show & Tell: Compare your implementation with your counterpart on the other team and discuss.
• Discussion of each team's data model

• Lecture using your codebase as examples: cohesion/coupling, DRY, function/class size, and data minimization
• Studio: refactor or extend an existing API safely (tests as guardrails)

• Activity:Code Refactoring Worksheet
• Design Principles for Coding

1. Martin, R. C. (2009). Clean Code. Chapters 2 (Meaningful Names), 3 (Functions), and 17 (Smells and Heuristics) Link
2. Clean Code Best Practices

• Clean Code Best Practices

• React as an architectural system: pages vs components, local vs global state, and data flow
• Activity: map one backend feature to a UI flow and identify states/edge cases

• Slides
• React Architecture

1. React Team. Thinking in React. React Documentation. Link
2. Short handout: Mapping User Goals to UI State Link

• Studio: implement UI integration with a tested backend endpoint
• Review focus: component responsibility and predictable data flow
• Quick check: 'What can a user do now?'

• TypeScript, Contexts, Hooks

• React Native vs React: similarities and differences
• Expo: what it is, why we use it
• Team activity: set up Expo project, understand structure
• Discussion: "How is mobile different from web? What's the same?"

• Slides
• React Native + Expo

1. Expo Documentation. Getting Started Link

• Mobile UI patterns: navigation, screens, components
• Team studio: build mobile UI for existing backend feature
• Connect mobile app to same backend API
• Pair programming: one codes, one reviews, then switch
• Reflection: "What's hard about mobile? What's easier than web?"

• Mobile UI Integration

• Intro to HCD
• Create low-fidelity prototypes (paper or Figma) for a targeted flow
• Studio critique: identify mismatches between current UI/system behavior and user goals

• Slides
• Human-Centered Design + Low-Fi Prototyping

1. Krug, S. (2014). Don’t Make Me Think. (Ch. 1–2 -- selected) Link
2. Nielsen Norman Group. 10 Usability Heuristics. (selected) Link

• Studio: revise a flow or UI element based on prototype critique
• Review focus shifts: assess user assumptions and flow clarity (not code style)

• High-Fidelity Prototyping + Implementation

• High-fidelity prototyping and alignment: confirm prototype behaviors map to system behaviors
• Studio: prepare Sprint 1 demos and ensure PRs are reviewable and rebased (linear history)

• Demo Prep + Phase 1 Reflection

1. Short reading: Agile Overview (forward-looking; prepares for Phase 2) Link

• Sprint 1 demos
• Phase 1 retrospective: what improved (tests, reviews, design clarity), what remained hard, and what will change in Phase 2 (shared repo, vertical slices)

• Sprint 1 Demos + Phase 1 Retrospective

• Agile principles: iterations, user stories, sprints
• Form vertical teams: backend + web + mobile developers
• Team working agreement for Phase 2 (collaboration, communication)
• Discussion: "How is Phase 2 different? What skills do we need?"

1. Schwaber, K., & Sutherland, J. The Scrum Guide. Link

• Review shared repo structure and workflow
• Assign features to vertical teams
• Sprint 1 planning: break features into user stories and tasks
• Define API contracts (shared types)
• Set up feature branches
• Team reflection: "What are our goals? What are we worried about?"

• Teams begin feature work
• Daily standup protocol: what did you do, what will you do, blockers
• Pair programming: backend + frontend developers work together
• Discussion: "How do we coordinate? What's hard about shared codebase?"

• Teams continue feature work
• Open PRs, practice code review across teams
• Resolve merge conflicts, coordinate API changes
• Team reflection: "What's working? What's challenging? How are we communicating?"

• Teams continue Sprint 1 feature work
• Daily standups
• Pair programming and collaboration
• Team check-in: "What progress have we made? What blockers do we have?"

• Teams continue feature work
• Integration testing across components
• Code review and PR refinement
• Team reflection: "What's working well? What needs improvement?"

• Sprint 1 demos: teams show what they built
• Sprint retrospective: what worked, what didn't, what to improve
• Sprint 2 planning: next features, user stories, tasks
• Reflection: "How did Sprint 1 go? What did we learn about teamwork?"

• Teams begin Sprint 2 features
• Continue daily standups
• Practice cross-team coordination
• Team reflection: "How are we improving? What's still hard?"

• Teams continue Sprint 2 feature work
• Daily standups
• Integration and testing
• Team check-in: "What progress have we made?"

• Teams continue feature work
• Code review and PR refinement
• Integration testing
• Team reflection: "What's working? What needs improvement?"

• Sprint 2 demos
• Sprint retrospective
• Final sprint planning: polish, integration, testing
• Discussion: "What features are complete? What needs polish?"

• Teams begin final sprint features
• Polish existing features, fix bugs
• Write integration tests
• Team reflection: "What are we proud of? What needs work?"

• Teams continue final sprint work
• Cross-team integration: ensure features work together
• Bug fixes and polish
• Team check-in: "What's left to do?"

• Teams finalize features
• Final integration testing
• Code review and PR refinement
• Team reflection: "What are we proud of? What would we do differently?"

• Final integration testing: all features work together
• Bug fixes and polish
• Prepare for final demo
• Team reflection: "What did we accomplish? What are we proud of?"

1. Martin, R. C. (2011). The Clean Coder. (Ch. 12-13) Link

• Final team demos: showcase completed features
• Course reflection: "How did we grow? What did we learn?"
• Celebration and wrap-up