This intensive hands-on course will teach you how to integrate Agile development, test-driven development (TDD), object-oriented principles and practices, design patterns and UML to fully harness the power of modern best practices to provide the most valuable software possible. The length of the course is typically two weeks but can be customized.

nTier boot camp is taught using the Socratic Method, meaning teams of three developers are taught to do Agile by building a single working piece of software over 10 days. Just as in real-life, teams are not told all the requirements up front, they are not told step-by-step directions and they are required to deliver quality code consistently. The typical iteration in the classroom is 20 minutes! Teams must learn to “Do The Code Right,” an acronym that reminds them to Design – Test (first!) – Code – Refactor every 20 to 30 minutes.

Note that this course is an intensive boot camp with at least 70 percent of class time is dedicated to hands-on programming.

Course Duration: 10 days
Prerequisites:

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

Course Objectives:
  • Learn to integrate Agile, TDD and OOAD
  • Get hands-on, intensive experience using OO principles
  • Learn to apply design patterns in the real world
  • Equip your project team to give the best ROI possible
Course Outline:
  • Definitions and Uses of Test-Driven Development
  • Test-Driven Development Benefits
  • Test-Driven Developments Anti-Patterns
  • Definition and Motivation for OOP
  • OOP “First Principles”
  • Use Cases
  • Sequence Diagrams
  • “Turning Straw into Gold” – Using UML
  • Agile Software Development and What it Means for Information Technology
  • Commonality and Variance
    • Fundamentals of Commonality/Variability Analysis (CVA)
    • How to Handle Variations as We Get New Requirements
      • Delegation
        • How Various Design Patterns Leverage Delegation
        • Strategy Pattern
      • What is Refactoring
      • Handling API Changes
      • Refactoring and Testing
      • Using Abstraction
        • Importance of Depending on Abstraction
        • Model-View-Controller
          • Differentiating between the Model 1 and Model 2 Architectures
          • Managing Access
            • How a Dynamic Proxy Works
            • Dynamic Responsibilities
              • Adding Functionality Flexibility
              • Decorator Pattern – Class Diagram
              • Writing a Custom I/O Decorator
            • Optional Appendixes
              • Javadocs
              • Open UP
              • Extreme Programming (XP)