| Date | Lecture/Lab Topics | Assigned Reading | Quiz | Slides |
|---|---|---|---|---|
| T 8/31 |
1A Administrative Introduction 1B Introduction to S/W Engineering 1C Introduction to Projects |
Syllabus McC 1-2 (s/w development) Kessler: Why Projects Fail Brooks: No Silver Bullet |
quiz 1 | lecture 1 |
| R 9/2 |
2A Project Post-Mortems 2B Project Planning 2C Basic Tools & Techniques |
McC 28.2 (configuration management) Spolsky: 12 steps to better code Kampe: Reproducibility and Control Kampe: Surviving Larger Projects Kampe: What is a Post-Mortem? Schaefer: Diablo Postmortem |
quiz 2 | lecture 2 |
| F 9/3 | P1A: concepts and plans |
P1A.1 (team & concept) P1A.2 (plan) |
(due Sun 9/5) | |
| T 9/7 |
2D S/W Process concepts 13A Waterfall: Critque & Defense 13B Issues with Waterfall Model 13C Evolutionary Models 13D Choosing the Right Model |
McC 3-3.2 (pre-requisites) McC 34.2 (process model) Kampe: S/W Process Models Boehm: Spiral Development Big Requirements up Front |
quiz 3 | lecture 3 |
| R 9/9 |
3A Requirements Introdution 3B Requirements Development Process |
McC 3.3-4 (requirements) Wiki: Requirements Analysis Kampe: User Requirements Wiegers: Requirements Traps Wiegers: Prioritizing Requirements |
quiz 4 | lecture 4 |
| F 9/10 | P1B: Competitve research |
P1B (research report) |
(due Sun 9/12) | |
| T 9/14 |
4A User Characterization 4B Use Cases 4D Representing Use Cases |
Sisson: User Characterization Rouse: What Players Want Wiegers: Developing Use cases Wiki: User Story Cards Wiki: UML introduction Agile: UML use case diagrams Agile: UML activity diagrams Agile: UML state diagrams |
quiz 5 | lecture 5 |
| R 9/16 | DEMO: Requirements Elicitation | |||
| F 9/17 | P1C: Requirements Development |
P1C.1 (preliminary requirements) P1C.2 (intro presentation) P1C.3 (elicitation) P1C.4 (report) |
(due Sun 9/19) | |
| T 9/21 |
6A General Principles of Modeling 6B Descritpive Models 6C Analytical Models 6D Prototypes and Proofs of Concept |
Kampe: Why we model Ambler: Agile Modeling Principles Ambler: UML component diagrams Ambler: UML deployment diagrams Gabler: Game Prototyping |
quiz 6 | lecture 6 |
| R 9/23 |
6E Good Architecture |
McC 3.5-6 (architecture) McC 5.2 (concepts) SEI: S/W Architecture Garlan: S/W Architecture (ch 1-2) Foote: Big Ball of Mud (digest) Wiki: Mechanism/Policy Separation Kampe: Software Testability Kampe: Interface Stability |
quiz 7 | lecture 7 |
| F 9/24 | P1D: Final Proposal |
P1D.1 (proposal) P1D.2 (post mortem) |
(due Sun 9/26) | |
| T 9/28 |
6F Problems Architecture must solve 6G Evolving an Architecture 6H Describing an Architecture |
McC 5.1 (challenges) McC 5.3 (heuristics) McC 5.4 (design practices) McC 34.1 (managing complexity) McC 34.6 (levels of abstraction) Kampe: Architecture Does All That? |
quiz 8 | lecture 8 |
| R 9/30 |
5A Elements of Quality 5B Quality Assurance Process |
McC 20 (s/w quality) Spolsky: Five Worlds Rakitin: What is Software Quality Assurance? Boehm: S/W Defect Reduction Wieger: Peer Reviews |
quiz 9 | lecture 9 |
| F 10/1 | P2A: Plan (and Preliminary Architecture) |
P2A.1 (plan) P2A,2 (preliminary architecture) |
(due Sun 10/03) | |
| T 10/5 |
5E Quality and Reviews 5F Formal Reviews 5G Informal Review Processes |
McC 21.4 (walk-throughs and other processes) Wieger: Inspections Wieger: 7 Deadly Sins |
quiz 10 | lecture 10 |
| R 10/7 |
7A Problems of U/I Design 7B Elements of good U/I design 7C Designing U/Is 7D Supplementary subjects |
Wiki: Usability Testing usability.net: User Centered Design Talin: U/I Design Principles Bay: Designing Games that Don't Suck Thompson: Halo 3 Usability Nielsen: Web U/Is are different from GUIs Kampe: Content Architecture Kampe: CLI Design |
quiz 11 | lecture 11 |
| F 10/8 | P2B: Architectural Review (demo) |
P2B.1 (notes) P2B.2 (report) |
(due Sun 10/10) | |
| T 10/12 | MIDTERM EXAM | Solutions | ||
| R 10/14 |
8A Specifications, Design, & Components 8B Classes 8C Packages 8D Diagramming Classes in UML |
McC 6 (classes) McC 34.4 (language limitations) Object Mentor: Packaging Granularity Spolsky: What are specs? Wiki: Refactoring Agile: UML class diagrams Agile: UML package diagrams Agile: UML object diagrams |
quiz 12 | lecture 12 |
| F 10/15 | P2C: Final Architecture |
P2C.1 (final architecture) P2C.2 (post mortem) |
(due Sun 10/24) | |
| T 10/19 | FALL BREAK | |||
| R 10/21 |
8E Routine Design 8F Representing Routine Designs |
McC 7-7.2 (routines, skim 7.3-7) McC 9-9.3 (pseudo-code) McC 18 (tables) Agile: UML Sequence diagrams |
quiz 13 | lecture 13 |
| F 10/22 | P3A: Component Specifications |
P3A.1 (plan) P3A.2 (component spec) |
(due Sun 10/24) | |
| T 10/26 |
9A Algorithmic patterns 9B Architectural patterns 9C Modularity/Class patterns 9D Synchronization |
Garlan: S/W Architecture (ch 3) Wiki: Client/Server Model Creational: singleton, object-pool Behavioral: iterator (up to "Specific Problems"), observer, strategy, visitor Structural: adapter, bridge, proxy Synchronization: events, locking, leases, transactions |
quiz 14 | lecture 14 |
| R 10/28 |
10A Good Test Cases 10B Black Box Testing 10C White Box Testing 10D Complexity and Coverage 10M Automated Testing Frameworks |
McC 19.5-6 (code complexity) McC 22 (unit testing) Kampe: Software Testability Kampe: Introduction to S/W Test Cases Cornett: Code Coverage Wiki: Test Driven Development Kampe: Test Harnesses CUnit - a unit testing framework (just skim) Python unittest (just skim) JUnit - a unit testing framework (just skim) |
quiz 15 | lecture 15 |
| F 10/29 | P3B: Component Design and Test Plan |
P3B.1 (design) P3B.2 (test plan) |
(due Sun 10/31) | |
| T 11/2 |
10E Robustness Terminology 10F Developing Robust Software 10G Failure Mode Analysis |
McC 8 (defensive programming) Kampe: HA taxonomy Kampe: S/W HA |
quiz 16 | lecture 16 |
| R 11/4 |
11A Elements of Maintainability 11B Program Readability 11C Coding Standards |
McC 30.2 (source-code tools) McC 31 (layout and style) McC 32.1-4 (commenting) McC 34.3 (understandability) McC 34.5 (conventions) Wiki: Doxygen (documentation generation) |
quiz 17 | lecture 17 |
| F 11/5 | P3C: Component Design Reviews |
P3C.1 (review notes) P3C.2 (review report) |
(due Sun 11/07) | |
| T 11/9 |
10H Finding Problems 10I Fixing Problems 10J Psychological issues in Debugging 10K Bug Reports and Tracking |
McC 23 (debugging) Kampe: Forensic Debugging Kampe: Root Cause Analysis Bug Life-Cycle Black: writing a bug report Kampe: Severity and Priority Github Issues |
quiz 18 | lecture 18 |
| R 11/11 |
10L Integration Approaches & Practices |
McC 29 (integration) Kampe: Integration Strategy Fowler: Continuous Integration Kampe: The Train Model |
quiz 19 | lecture 19 |
| F 11/12 | P3D: Final Component Design and Test Plan |
P3D (final spec, design, test plan) |
(due Sun 11/14) | |
| T 11/16 |
10N System Testing 10O Bug Finding 10P Performance Management 10Q Release Planning |
McC 25 (performance) Wiki: System Testing Kampe: Load & Stress Testing Kampe: Testing and Bug Discovery Kampe: Scenario Based Testing Kampe: Release Phases & Criteria Gnu: Gprof (just skim) |
quiz 20 | lecture 20 |
| R 11/18 |
13E Agile Process Rebellion 13F SCRUM and sprints |
McC 34.9 (pragmatism) Wiki: Agile S/W Development Wiki: Scrum (Roles, Sprint, Meetings, Artifacts) Github: Project Boards |
quiz 21 | lecture 21 |
| F 11/19 | P4A: Implementation and testing |
P4A.1 (code) P4A.2 (tests) P4B.1 (pair programming) P4B.2 (code review) P4B.3 (test driven development) |
(suggested Sun 11/28) | |
| T 11/23 |
12A Productivity 12B Collaboration Models |
McC 21.1-2 (pair programming) McC 28.1 (good code) McC 28.5 (work environments) McC 33 (personal character) XP: Project Activities XP: Rules XP: Values XP: Collective Ownership Williams: Pair Programming Rosenberg: Problems w/Pair Programming |
quiz 22 | lecture 22 |
| R 11/25 | THANKSGIVING | |||
| F 11/26 | THANKSGIVING | |||
| T 11/30 |
12C Work Estimation 12D Project Risk |
McC 27 (program size) McC 28.3 (estimation) Kampe: S/W Estimation Principles Peters: S/W Project Estimation Wiegers: Risk Assessment & Management Scrum backlog grooming |
quiz 23 | lecture 23 |
| R 12/2 |
12E Project Scheduling 12F Project Status Tracking 12G Causes of slippage and failure |
McC 34.7 (danger signs) Wiegers: Successful Project Management Wiki: Mythical Man Month (digest) Kampe: Project Management Concepts Kampe: Project Milestones Kampe: Putnam Norden Rayleigh curves Kampe: Scrum points and velocity Wiki: Earned Value Analysis |
quiz 24 | lecture 24 |
| F 12/3 | P4C: Integration + Demo Prep |
P4C (demo) |
(suggested Sun 12/05) | |
| F 12/10 | P4D: Demo + Post-Mortem |
P4D (final post mortem) |
(due Fri 12/10) | |
| R 12/16 | FINAL EXAM | Solutions |
There is a (Sakai) quiz that must be completed prior to each lecture session. These are timed (5 mintues) closed book quizzes intended to be non-difficult if you have done the reading. Most questions can be answered in a one-digit number of words. I am not looking for essay answers or even complete sentences ... just enough to show that you remember a few details from the reading.
You will need to get set up on GitHub and learn basic git use. I have created a Git Cheat Sheet that:
Or, if you would like a more comprehensive introduction, Udacity offers a free Version Control with Git course.
In addition to using github for version control, you will almost surely want to use it to track the many tasks associated with each project. I strongly encourage you to use:The primary text for this course (McConnell, Code Complete) actually has several excellent chapters on variables (chapters 10-13), programming (chapters 14-19) and refactoring (chapter 24). The only reasons I do not assign these chapters are:
This book by Gamma, Helm, Johnson and Vlissides (the Gang of Four) is considered by many to be one of the foundations of object oriented design. Design patterns will not solve all of your problems, but studying and using them will make you a better programmer. I did not make it required reading for this class because it would have taken us too deeply into programming, but if you have not already read it, I strongly encourge you to do so.
