This 2-day course is designed to improve your team's skills around creating well-crafted, testable and maintainable code.
With a strong focus on software craftsmanship, this hands-on course will teach software developers practical techniques they can immediately apply to real-world projects — both new development and legacy codebases. The techniques covered in this course provide the foundation needed for more frequent and safer releases.
Writing Clean Code is difficult. Cleaning existing code, even more so. Your team should attend if you need them to:
- Write clean code that is easy to understand, maintain, and adapt
- Become more proficient in Test-Driven Development (TDD): using tests to design and build
- Learn with hands-on exercises the difference between the two most important TDD styles: Chicago school (classicist) and London School (outside-in).
- Learn how to define test boundaries and responsibilities.
- How do we define a unit?
- What is the difference between the test boundary and test responsibility?
- What should we mock? What should not be mocked?
- Learn how to write tests that express business behaviour, not technical implementation.
- Learn how to test and refactor legacy code
- How to deal with hard-wired dependencies
- How to localise tests while avoiding a major refactor of the code
- Refactor the code to express business rules
Software Craftsmanship is a mindset that focuses on professionalism and quality. Clean Code and Test-Driven Development are part of that mindset and are at the heart of this course. More than learning the techniques, the course also touches on the attitude expected from professional software developers.
Learn how to:
Design code that expresses business requirements.
Understand design principles that lead to clean code
Pay attention to every minor detail at the code level, like names, responsibilities of classes, methods and types
Look closely at key design principles like coupling and cohesion and how they are applied at the code level.
Avoid over-engineering and large rewrites by incrementally evolving the software design using tests.
In this course we'll cover:
- Test-Driven Design (TDD)
- Object-Oriented Design (OOD)
- Domain-Driven Design (DDD)
- Advanced introduction to TDD lifecycle
- Chicago School (classicist) TDD
- London School (Outside-In) TDD
- Expressing business behaviour via tests, not the implementation
- Principles of Clean Code and good design
- Using unit tests as a tool to drive good design
- Mocking as a design tool
- Expressive code that describes business rules
- Testing and refactoring legacy code
This course is designed for software development teams that:
- have a fluency with at least one Object-Oriented language, such as Java, C#, or C++;
- are able to understand Java or C#;
- are able to write and execute unit tests using a framework, such as JUnit, NUnit, etc.;
- have a basic understanding of mock objects.
Note: This is not a course for people learning how to code. Developers with a few years in the industry will benefit more from this course then people with limited industry experience. Also, this is not a basic TDD training. This course is fully hands-on and fast-paced. Although the course can be attended and followed by developers without TDD experience, people with TDD experience will benefit more.
The is a fast-paced and hands-on training course. Software development teams will be required to write a lot of code.
- Bring your own laptop
- Be able to create projects from scratch, add test and mocking libraries, build source code, and run test cases in their development environment
- Have a development environment that consists of the following:
- Object-Oriented language
- A unit test framework
- A mocking library
- A distributed version control system such as git