During this highly-interactive course, participants will spend five days in a single problem domain. They will be given a set of rough, high-level stories and will subsequently learn to deconstruct them and continually groom the product backlog according to the product owner’s (instructor’s) direction. UML diagrams will serve as final deliverables for the class, including conceptual-level class diagrams, sequence diagrams and use cases. Participants are not given complete requirements up front and will be expected to evolve their design as they uncover new requirements with each new lab, all the while working under the assumption that previous lab work has been coded (thus they must make changes to their existing design that result in the least amount of waste).
This class is taught in a Socratic fashion, meaning students will be given requirements BEFORE lecture and will work in teams to do their best design. The instructor will teach to the problem – what forces are at work in the design, what are the key problems that the requirements created for us, what are the consequences we have to deal with when choosing our design, etc. – and will present a solution. Class participants will be encouraged to challenge it and then refactor their own solutions.
5 days
Labs are done in Agile fashion, requiring teams to provide estimates, reprioritize and so on. Therefore, prior training or experience with Agile practices is required for students. Some knowledge of Scrum, OO and UML is also helpful.
- Provide a solid foundational understanding of key object-oriented concepts
- Learn to use the Unified Modeling Language (UML) in a minimalistic and efficient manner
- Understand how to blend OO, Agile and UML to write the best software as quickly as possible
- Gain hands-on practice by actually designing, not just theorizing about it
- Applied OO
- Definition and Motivation for OOP
- Ensure Understanding of OOP Fundamentals
- OOP “First Principles”
- Lab
- UML Essentials
- Use Cases
- Class Diagrams
- “Turning Straw into Gold” with UML
- Lab
- Agile Development
- Overview of Agile Software Development
- Agile Manifesto Values and Principles
- Introduction to Iterative Coding Practices
- Release Planning
- First Time Estimates
- Sizing Your Stories
- Velocity-Driven Release Planning
- Applying Themes
- Leveraging Use Cases for “Check and Balance”
- Lab – Release Planning
- Product Owner Roles and Responsibilities
- Will the Real Product Owner Please Stand Up?
- Product Backlog and Requirements
- Roles and Personas
- Story Workshops
- Spikes and Special Stories
- Lab – User Roles and User Story Writing
- Grooming the Backlog
- Prioritization
- Looking Ahead
- Groom Continually
- Value Assessment
- Risk-Based Prioritization
- Lab – Successful Spring Planning Meeting
- Commonality and Variance
- Translating Stories or Use Cases to a Class Diagram
- Fundamentals of Commonality/Variability Analysis(CVA)
- CRC Cards
- How to Handle Variations with New Requirements
- Understanding and Using Factories
- Lab
- Delegation
- Why It’s So Powerful
- How Various Design Patterns Leverage Delegation
- Adapter Pattern
- Strategy Pattern
- Lab
- Refactoring
- What is Refactoring?
- Why Refactor?
- Identifying Code Smells
- How the IDE Can Assist in Refactoring
- Lab
- Using Abstraction
- Understanding the Template Method Pattern
- Importance of Depending on Abstraction
- Lab
- Model-View-Controller
- MVC Principles and the Motivation for Using MVC
- Model 1 and Model 2 Architectures
- Benefits of the Front Controller Pattern
- Using the Observer Pattern to Reduce Coupling
- Lab
- Managing Access
- The Proxy Pattern and Its Motivation
- How a Dynamic Proxy Works
- The Dynamic Proxy as a Flexible Proxy Solution
- Lab
- Dynamic Responsibilities
- Using the Decorator Pattern to Bring Flexibility to Designs
- Adding Functionality and Flexibility
- Decorator Pattern – Class Diagram
- Decorators in the Java/IO Pattern
- Designing a Custom I/O Decorator
- Lab
