This intensive, hands-on boot camp teaches teams how to integrate agile development, test-driven development (TDD), object-oriented (OO) design principles and practices, design patterns and UML into the development process in order to fully harness the power of modern best practices to create the most valuable software possible.

If your organization wants to learn Agile by doing Agile, this is the course! It can be customized to any Agile implementation you choose (SAFE, SCRUM, XP, Lean, etc.). As a boot camp, at least 70 percent of class time is spent in hands on programming.

Note: The course length can be customized to fit your team’s availability.

Course Duration: 2 weeks
Prerequisites:

We recommend six months of programming experience with an Object Oriented language (Java, C#, VB.net, C++).

Course Objectives:
  • Teach your team to produce a higher return on investment (ROI)
  • Get hands-on, intensive practice using OO principles
  • Build an iterative development habit
  • Learn to apply design patterns in the real world
  • Understand why the best Agile is the one you customize
  • Learn to integrate UML, Agile, TDD and OOAD
Course Outline:
  • Test-Driven Development (TDD)
    • Definitions and Uses of TDD
    • Principles and Techniques of TDD
    • Benefits of TDD
    • Best Practices in TDD
    • TDD Anti-Patterns
  • Applied Object-Oriented Programming (OOP)
    • Definition and Motivation for OOP
    • Ensure Understanding of OOP Fundamentals
    • OOP “First Principles”
  • UML Essentials
    • Use Cases
    • Class Diagrams
    • Sequence Diagrams
    • “Turning Straw into Gold” with UML
  • Agile Software Development
    • What it Means for Information Technology
    • Implementing Iterative Coding
  • Commonality and Variance
    • Translating Requirements or Use Cases to a Class Diagram
    • Fundamentals of Commonality/Variability Analysis (CVA)
    • CRC Cards
    • How to Handle Variations from New Requirements
    • Understanding and Using Factories
  • Delegation
    • Why It’s So Powerful
    • How Various Design Patterns Leverage Delegation
    • Adapter Pattern
    • Strategy Pattern
  • Refactoring
    • What is Refactoring?
    • Why Refactor?
    • Handling API Changes
    • Identifying Code Smells
    • Refactoring and Testing
    • Using your IDE
  • Using Abstraction
    • Understanding the Template Method Pattern
    • Importance of Depending on Abstraction
    • Serializing Objects to XML Files
  • Model-View-Controller
    • MCV Principles and the Motivation for MVC
    • Model 1 and Model 2 Architectures
    • Benefits of the Front Controller Pattern
  • Managing Access
    • The Proxy Pattern and Its Motivation
    • How a Dynamic Proxy Works
    • The Dynamic Proxy as a Flexible Proxy Solution
  • Dynamic Responsibilities
    • Using the Decorator Pattern to Bring Flexibility to Designs
    • Adding Functionality Flexibility
    • Decorator Pattern and Illustration
    • Decorator Pattern – Class Diagram
    • Decorators in the Java/IO Pattern
    • Writing a Custom I/O Decorator
  • Optional Appendixes
    • JUNIT
    • Javadocs
    • Java Server Faces (JSF)
    • The Spring Framework
    • Struts
    • Hibernate
    • SCRUM
    • SAFe (Scaled Agile Framework)
    • Open UP
    • The Rational Unified Process
    • Extreme Programming (XP)