"Mike brings a rare combination of qualities to the classroom -- mastery of the subject matter, infectious enthusiasm, and the ability to truly teach (not just demonstrate). I heartily recommend this class." David Rupp Developer
What You Get
Managers get a one-hour presentation and discussion before the workshop begins to address the benefits of test-driven development, how it fits into the development process, and what developers will learn in the workshop.
Developers get a two-day workshop where they learn JUnit and test-driven development through lecture and a series of hands-on exercises guided by a renowned expert.
What You Learn
This workshop teaches you a dozen ways to get the testing bug that you can start applying immediately on your project. You'll learn how to write and run automated tests that check their own results using JUnit, and best practices for writing good tests. Building on JUnit as a foundation, you'll also learn how to use open source tools for database, web, performance, integration, and acceptance testing.
But it's not just about testing. You'll also experience a powerful synergy between software design and testing that helps you deliver high-quality software with extraordinary productivity. The best way to experience these benefits of test-driven development is by doing it. Through a series of guided hands-on exercises, you'll develop software by writing tests first---expressing the software's intent and validating the usability of its design through automated tests, and incrementally writing code that satisfies those tests.
You'll also learn how to capitalize on the testing investment by automating your build and test process using Ant and CruiseControl so that the tests are run mercilessly throughout the development process. That way, you can economically make software changes with confidence, knowing that the tests will detect any adverse side effects. You'll feel less stressed about meeting deadlines and rediscover the joy of writing great software!
Workshop Outline
In this workshop, we'll cover a dozen ways to get the testing bug through a combination of lecture and hands-on exercises. Topics covered include:
- Why Test-Driven Development?
- Why change?
- The benefits of test-driven development
- Reducing the cost (and fear) of change
- How TDD helps you build better software, faster
- Writing Automated JUnit Tests
- Test cases
- Assertions
- Test fixtures
- Test suites
- JUnit best practices
- "What should I test?"
- Properties of good tests
- Data-driven testing approaches
- Applying test coverage and mutation testing feedback
- Hands-on exercises
- Test-Driven Development
- Test-driven development demystified
- Red, green, refactor rhythm
- "How am I going to test this?"
- Experiencing design insights
- Decreasing coupling, increasing cohesion
- Hands-on exercises
- Mock Objects
- What they are
- When to reach for them
- When to avoid them
- How to use them effectively
- Creating mocks with jMock and EasyMock
- Hands-on exercises
- Refactoring
- Why and when to refactor
- Live refactoring episode
- Detecting code smells
- Writing code that responds to change
- Examples of quick and valuable refactorings
- Code reviews with refactoring
- Testing Legacy Code
- Pragmatic approaches to testing legacy code
- Techniques for breaking dependencies
- Refactoring for testability
- Examples from your project
- Hands-on exercises
- Making Testing Part of Your Build Process
- Integrating JUnit with Ant
- Setting up a continuous integration environment using CruiseControl
- Scheduling builds for different types of tests
- "What if my tests take too long?"
- Monitoring the build and test status
- Hands-on exercises
- Expanding Your Toolbox
- Testing the database layer with DbUnit
- Testing web applications with HtmlUnit, Canoo WebTest, etc.
- Using Cactus to test server-side J2EE components
- Testability of dependency injection containers (e.g., Spring and PicoContainer)
- Continuous performance testing with JUnitPerf
- Acceptance testing with FitNesse
- Rolling your own integration/acceptance testing harness atop JUnit
- Hands-on exercises
You have the option of customizing the outline and the tools discussed based on your specific project needs.
Instructor
Mike Clark is a long-time member of the JUnit community and a self-proclaimed test-driven development junkie. In addition to teaching, Mike regularly speaks and writes about his experiences with TDD. His credentials in this area include:
- Author of the book Pragmatic Project Automation
- Author of the JUnit Primer
- Author and maintainer of the JUnit FAQ
- Author of the article A Dozen Ways to Get the Testing Bug
Who Should Attend
Attendees should have a basic working knowledge of Java and object-oriented design principles.
What You Need
This workshop is taught on-site at your location. This requires a room big enough to accommodate at least 15 attendees and an instructor, and a laptop projector and whiteboard to keep them all entertained throughout the workshop. Attendees need to bring laptops or share laptops to complete the hands-on exercises.
All other supplies are provided, including handouts and a CD containing a self-contained Java project, required software, and copies of the manager presentation and workshop handouts.
Duration
2 days
Price and Availability
Call 1-303-886-5202 today for pricing information and to schedule a TDD workshop that's customized to help you write better software, faster.
Workshop Praise
"Mike's class on Test-Driven Development with JUnit was just what my group needed to get the testing bug. It was fun to see the gleam in their eyes when they "got it". Mike has a relaxed, personable delivery, as well as a keen sense of pacing that kept us from being either too overwhelmed or too bored. Mike brings a rare combination of qualities to the classroom -- mastery of the subject matter, infectious enthusiasm, and the ability to truly teach (not just demonstrate). I heartily recommend this class." David Rupp Senior Software Engineer Great-West Life & Annuity
"Your class went over very well...everyone is on fire to use this approach and wants to get it cemented in now." Carin Lockhart Manager, Software Development Polycom, Inc.
"Mike just completed a Test-Driven Development with JUnit workshop with Lands' End that I can only describe as a great success. As the Technical Lead for many of the students in the class, I took the opportunity to sit in on the training and was delighted to observe a master in action. Mike is a natural born teacher who easily leads a class through the process of learning a new skill. From both his formal presentation and his answers to questions, it was obvious to all that we were in the presence of a skilled practitioner of his craft." Simon P. Chappell Technical Lead, IS Department Lands' End, Inc.
"I want to express our appreciation for the great training you provided on Test-Driven Development with JUnit at webMethods. Your presentation was exactly what we were looking for -- an explanation of the use of JUnit and other open source tools, the best practices on those tools, and how these tools can fit into our environment. The information you've presented gives us a great understanding of how test-driven development can maximize our time and resources for better quality software. Both our QA and Development engineers enjoyed the content of the class and the very professional delivery of the presentation. We will be recommending your training services to other development groups within webMethods." Artie Alvidrez QA Manager webMethods, Inc.
