Learn and explore the techniques and disciplines that underpin the development of great software
|Level||Beginner / Intermediate|
Engineering Best Practices is a fast-track exploration of the disciplines, techniques and thinking that enable the creation of great software. By the end of this workshop, students will have a much better understanding of why clean code matters and of the techniques for creating better, cleaner, more robust code. Topics covered include:
- how to structure and decompose code at the class level
- how to partition code across classes and subsystems
- how to create intention revealing code
- how to apply data structures effectively
- how to unit test and test for behaviour properly
- how to identify and rectify code smells through refactoring
- how to apply the SOLID principles in practice
- how to use the IDE for ultimate productively
This is an intensive 2 to 3 day workshop (depending on level) and can be tailored for beginner and advanced students alike. We simply ratchet up the complexity of the exercises for the advanced attendees, and build in additional time for discussion.
We aim to move the students away from thinking and struggling at the syntax level, and give them a toolset of best practice thinking and technique so that they code better. Students should come armed with a good understanding of Java or C#. (The course can be delivered in either language.)
This is a workshop in the truest sense in that it mostly stays clear of slides. The majority of the class is delivered through programming exercises of various complexity, with the instructor live coding with the class. Along the way we discuss topics such as:
- Functional, imperative and object oriented thinking
- Managing state: mutable versus immutable
- Single responsibility principle, intention revealing names, information hiding, etc
- Using standard data structures (sets, maps and lists) to better solve problems
- Understanding essential and accidental complexity
- Unit testing basics: white box, black box and grey box testing
- Developing backwards through BDD and letting the IDE do the heavy-lifting
- Understanding when to mock, when to stub and when to avoid
- How to write better (and shorter) unit tests using DSLs
- Loose versus tight coupling
- Separating creational logic from business logic using dependency injection
- Understanding cohesion, from scattered logic to monolithic classes
- Design by Contract: defensive programming versus assertions
- The course can be tailored to any modern OO language (Java, C# etc) but the delegates should come armed with a good understanding of the language used.
'' Best course I have attended so far. Learnt a lot about how powerful your IDE can be, how to go about writing tests before writing any production code( TDD) and how refactoring really improves your end product. Great instructor who knows his stuff and was very willing to help when needed. ''
'' This course has massively grown my knowledge of best practice design principles and will change the way I program in the future. It will be immediately beneficial for me in my current project. ''
'' A very well put together course with a lot of practical coding and examples. I really enjoyed the challenge the katas presented and coding the solution to them. Really good amount of actual practical work.''