Software Craftsmanship is at the heart of this course. Throughout this training series, your team will learn about the Software Craftsmanship mindset and how to apply it within your organisation.
Writing Clean Code is difficult. Cleaning existing code, even more so. Your team should attend if you need them to:
- Align technology to business requirements
- 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
Clean code necessitates good design. Your team will learn how to:
- Understand design principles that lead to clean code
- Avoid over-engineering and large rewrites by incrementally evolving design using tests
Once your team has mastered their understanding of these principles, they will apply them to legacy code. This will allow them to gain confidence working with legacy code.
The software design portion of this training series focuses on the application and microservices levels using business requirements to drive design making. Many of the design discussions during the exercises are focused on real-world scenarios that can be implemented in your organisation.
- internal structure
- delivery mechanism
- core domain
- define the responsibility of each service
- how services collaborate
- internal/external visibility
This course is designed for software development teams that:
- are familiar with a minimum of one Object-Oriented language
- 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
- Test-Driven Development (TDD)
- Object-Oriented Design (OOD)
- Domain-Driven Design (DDD)
- Interaction-Driven Design (IDD)
- TDD lifecycle and modelling behaviors
- Writing unit tests that express intent, not implementation
- Using unit tests to drive good design
- Expressive code
- Testing and refactoring legacy code
- How to structure projects so that it expresses what the application does and what it is about
- Understanding the differences between layers, hexagons, features, and components
- Identifying services from business rules
- Express design and architecture in code, but keeping your domain clear
- Understanding Impact Mapping and how a services architecture can be derived from it
The is a hands on training course. Software development teams will be required to write a lot of code.
- Bring their own laptop
- Be able to create projects, 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 Github is preferable
Software craftsman, author, Co-Founder of Codurance, and Founder of the London Software Craftsmanship Community (LSCC). Sandro has been coding since a very young age, but only started his professional career in 1996. He has worked for startups, software houses, product companies, international consultancy companies, and investment banks.
During his career Sandro has had the opportunity to work on a variety of projects, spanning different languages, technologies, and industries. Sandro has a lot of experience in bringing the Software Craftsmanship ideology and Extreme Programming practices to organisations of all sizes. Sandro is internationally renowned for his work on evolving and spreading Software Craftsmanship. His professional aspiration is to raise the bar of the software industry by helping developers become better at their craft.