The single most effective way to improve your code quality
- Master agile development practices and tools
- Learn how to write effective tests to improve your code
- Keep development focused on core requirements
- Create a higher quality product for your end user
- Become a Java master…
This course is a practical and pragmatic workshop in which you will learn the latest agile development practices and tools. The workshop gives students practical experience across the full scope of agile development activities, including requirements gathering, acceptance test driven development (ATDD), behavior driven development (BDD), test driven development (TDD), agile architecture and design, clean coding practices, continuous integration and agile development teamwork and collaboration. During the course, students will build a small application from the ground up using ATDD and TDD practices and getting exposure to innovative tools such as Spock, JBehave and Thucydides.
Automated testing techniques are covered in detail in this workshop. Indeed, learning how to write more effective tests is an excellent way to write better designed, more maintainable and more reliable code. It also helps keep development focused on the real requirements, resulting in a higher quality product for the end user. These are skills that every Java developer needs to master.
The course is made up of two modules:
- Fundamental ATDD, TDD and BDD practices for Java Developers (3 days)
- Advanced ATDD and automated acceptance testing practices for Java Developers (1 day)
This module covers essential Agile technical practices, with an emphasis on BDD and automated testing practices. The topics covered are outlined here:
- Principles of Behavior Driven Development (BDD)
An introduction to the fundamental concepts and motivations behind Behavior-Driven Development and related techniques.
- Agile Requirements gathering
BDD principles can be applied to requirements gathering and analysis activities. In this module, we learn how techniques such as Acceptance Test Driven Development, Executable Specifications and Feature Injection can significantly improve the quality, reliability and relevance of the application being built, and provide a much better traceability back to, and understanding of, the core business requirements.
In practical terms, we will use high-level BDD tools such as JBehave and Thucycides to build a working set of executable specifications from the ground up.
- Agile Architecture
Architecture is just as important in Agile projects as it is in conventional software projects. In this module we discuss the key principles of Agile architecture and design, including the role of architecture in Agile projects, when, how and by whom architecture is specified, implemented and validated.
- Test Driven Development
Test Driven Development (TDD) is a key Agile development practice, and is arguably the single most effective way to improve code quality and reliability. In this section, we focus on core TDD and BDD practices at the coding level, and learn how to effectively apply BDD practices in Java both by using advanced JUnit features and with more specific BDD libraries such as Spock. We also cover topics such as good test design and organization and testing databases.
- Refactoring and Clean Coding
Refactoring is an essential part of maintaining high code quality and reducing maintenance costs. And a solid understanding of clean coding principles is vital to writing maintainable and understandable code.
This module explores refactoring principles and patterns, and also discusses effective techniques to help make your code clean, readable and highly maintainable. We also discuss how code quality metrics can be used to help.
- Continuous Integration and Delivery
This module covers how Continuous Integration and Delivery practices can be used to enhance team communication and accelerate feedback.
This module discusses team collaboration and communication techniques such as Pair Programming and Code Reviews, and the best ways to get the customer involved.
This module covers more advanced ATDD and automated acceptance testing techniques, with a strong emphasis on automated web testing using Selenium 2/WebDriver. Topics covered include:
- Principles of automated acceptance testing
- Introduction to Selenium 2/WebDriver
- Identifying Web Elements
- Using Page Objects
- Working with AJAX applications
- Writing automated acceptance tests Thucydides
- Using Thucydides with JUnit
- Using Thucydides with JBehave
- Working with Thucydides Step libraries
- Managing state
- Reporting on requirements and progress with Thucydides
- Using the Thucydides Page Object API
- Data-driven tests
- Integrating with other systems
- Acceptance Testing best practices - writing reproducible tests
This course is delivered both as a public course and in a tailored onsite format.