| Section | 1 |
|---|---|
| Instructor(s) | Vassilatos, Peter (pete) |
| Location | Ryerson 277 |
| Meeting Times | Thursday 5:30pm - 8:30pm |
| Fulfills | Elective Specialization - Software Engineering (SE-1) Specialization - Software Engineering (SE-2) |
Course Description
Writing first-class software requires top-notch architecture, design and coding skills, but successful software project execution--from identifying the need to providing support--depends on many factors besides technical prowess. This course surveys the key practices and processes that help ensure successful projects. It provides an introduction to central activities of software engineering other than just coding, such as planning, requirements, testing and management. It balances this discussion of typical engineering activities against the development process models in which they take place -- specifically, it addresses the tension between traditional plan-driven approaches and adaptive agile techniques. By examining the underlying principles of major development models, it shows how those principles address (or fail to address) the various problems encountered by project teams. Students who complete this course will gain a solid understanding of both plan-driven and agile software development principles and how to negotiate between them in different contexts.
The project planning topic of the course begins with project inception and interpretation of the business case and proceeds through project deployment and support. The chief emphasis is on understanding the many interrelated dimensions of a project. It addresses the bread-and-butter planning topics, such as estimation and scheduling, and surveys the dominant models for these tasks. It explains the key metrics necessarily for successful project control and the means of collecting and interpreting them. Significant time is spent on the topic of risk and risk management. The requirements topic introduces a structured framework for thinking about software requirements. It teaches not only how to elicit and capture requirements (an art in itself), but also how to assign appropriate attributes to requirements to enable effective prioritization, management, and validation. The quality topic discusses practices that have been shown to reduce software defects. It examines requirements validation and the traceability of project decisions from user needs, through requirements, to design decisions, implementation, and testing. It shows how key architectural decisions affect product quality, and offers guidelines to determine which decisions must be made up front and which are better deferred. Formal quality verification processes, such as reviews and inspections are explained, as are best practices for designing and administering tests. Finally, change control and configuration management practices are reviewed.
Course Contents
• Lean software development principles
• The seven wastes of software development
• Agile methods: Scrum, XP, Kanban, Feature-Driven Development
• Estimation of size and effort
• Requirements management, elicitation, analysis, specification, verification and validation
• Software testing (dynamic)
• Software inspection
• Iterative and incrementation strategies
• Risk management
• Software capability maturity
• Software project metrics
• Change management
• Software development life cycles
• When -- and when not -- to use various approaches and techniques
• Software process management and improvement
• Transforming software organizations
Coursework
You will apply the course material to an ongoing case study, developing work products such as plands, requirements and analysis models.
You will regularly be expected to hand in answers (usually brief) to a few questions about the material covered. For example, you might be given a few scenarios and asked to select the appropriate software development lifecycle for each and write a sentence or three justifying your choice.
You should expect frequent quizzes, none of which will be worth very many points. The scope of the course is broad, and the quizzes help ensure that we stay aligned. If the quizzes prove unnecessary, we'll stop having them.
The course has a midterm and final. A study guide will be provided for each. The final is cumulative, but weighted toward the latter half of the course.
Finally, you'll be expected to choose a topic, such as an agile development practice, and prepare a written overview in which you explain it and discuss its strengths, limitations and applicability. If the class size permits, you'll present a summary of your report to the class. Topics will be selected early in the quarter, and presented toward the end.
Course Textbooks
• Lean Software Development: An Agile Toolkit. Mary Poppendieck and Tom Poppendieck (2003)
• Quality Software Project Management. Robert T. Futrell, Donald F. Shafer and Linda Isabell Shafer (2002)
Core Programming
This course requires competency in Unix and Linux. Please plan to attend the MPCS Unix Bootcamp (https://masters.cs.uchicago.edu/page/mpcs-unix-bootcamp) or take the online MPCS Unix Bootcamp Course on Canvas.
This class is scheduled at a time that conflicts with these other classes: