Merely using an object-oriented language does not guarantee that the solutions you create are high-quality, flexible, and easy to maintain.

This three-day instructor-led course introduces the object-oriented design fundamentals, principles and heuristics using Test Driven Development (TDD) that allow us to create robust regression tests and good code. TDD is often mistaken for simply writing automated regression tests against an existing design. The deeper truth is that TDD is first and foremost about incrementally specifying, implementing, and improving your software’s design.

This course is heavily exercise-driven with the students spending the majority of the time accumulating greater skill by applying the concepts in incrementally more complex sub-projects.   As a group, the class will start by specifying acceptance criteria for a given set of requirements.  These will be translated in to executable requirements using a tool such as FitNesse.  These tests will of course fail at first, which will task the students, in pairs, to define the system interface specifications in the form of unit tests.  This will, in turn, extract the development of the system interface and all subsequent code and design until all unit tests and executable requirements pass.

Audience:

• Object-oriented programmers interested in learning more about TDD methods and best practices that yield the highest quality designs.

Participants will learn to:

• Extract acceptance criteria from a set of requirements
• Develop code using the TDD cycle
• Strike a comfortable balance between unit and acceptance testing
• Identify the limitations of unit and acceptance testing
• Structure tests with four distinct phases: Setup, Exercise, Verify, Teardown
• Define and prioritize the examples that are used to ignite TDD
• Design good tests so that they are independent and fast
• Use dummies, stubs, fakes and mocks as appropriate to achieve test isolation and repeatability
• Build robust object designs during TDD
• Detect suspicious code (smells)
• Apply techniques for refactoring bad code
• Recognize when and how to test existing code (legacy code, untested code)
• Use a unit testing tool
• Use a code coverage tool
• Use an executable requirements tool
• Explain Coupling and Cohesion
• Understand the connection between fundamental object-oriented design principles and design patterns