Overview
Engineering Best Practices is a fast-track exploration of the disciplines, techniques and thinking that enable the creation of great software. This intensive workshop provides developers with the mindset and toolsets needed to write clean, maintainable code that delivers lasting value.
By the end of this workshop, delegates will have a much better understanding of why clean code matters and of the techniques for creating better, cleaner, more robust code. The course emphasises practical application through hands-on programming exercises, moving developers beyond syntax-level struggles to confident implementation of best practices. We aim to move the delegates away from thinking and struggling at the implementation level, and give them a toolset of best practice thinking and techniques so that they code better.
This workshop can be tailored for beginner and advanced developers alike. We simply adjust the complexity of the exercises for more experienced attendees and allow additional time for in-depth discussions.
Outline
Foundations of Modern Software Development
- Evolution of software engineering methodologies and practices
- Understanding why predictions in software development often fail
- Critical thinking in software engineering, including questioning assumptions and balancing pragmatism
- Tools and frameworks for better decision-making in complex projects
- Moving from syntax-level thinking to architectural perspectives
Clean Code Principles
- Writing good code through simplicity, readability, DRY principles and managing accidental complexity
- Creating intention-revealing names through consistent conventions across programming languages
- Effective code organisation, decomposition and right-sizing methods and classes
- API design using contracts, outside-in approaches and proper interface design
- Using standard data structures (maps, sets, lists) to better solve common problems
- Information hiding, encapsulation strategies and appropriate comment usage
Design Principles and Patterns
- The classic SOLID principles and their relevance today
- Modern design guidelines including CUPID, GRASP, KISS, YAGNI and Law of Demeter
- Balancing simplicity with performance by understanding when and how to optimise
- Managing coupling (loose vs tight) and cohesion in software components
- Composition vs inheritance strategies for different programming paradigms
- Immutability benefits and implementation approaches across languages
- Design by Contract: comparing defensive programming with assertions and preconditions
Test-Driven Development
- The importance of testing and TDD workflows, including the Arrange-Act-Assert pattern
- Testing techniques: black/white/grey box approaches for different testing scenarios
- Effective test doubles: using stubs, mocks, fakes and spies appropriately
- Dependency injection for better test isolation and separation of concerns
- Testing edge cases, contracts and defensive code for robust software
- Creating readable, maintainable tests that serve as living documentation
Refactoring and Code Improvement
- Refactoring principles and practices, including the Scout Rule and avoiding broken windows
- Recognising and addressing common code smells through targeted refactoring
- Language-specific refactoring techniques and automated tools across development environments
- IDE-assisted refactoring to improve productivity and reduce errors
- Refactoring towards design patterns and better architectural structures
Modern Development Workflows
- Continuous Integration and Delivery practices for faster, more reliable software delivery
- Version control best practices using Git, including Flow models (Git Flow, GitHub Flow, Trunk-Based)
- Effective code reviews, pull requests and collaborative development techniques
- Productivity enhancement through modern IDEs, keyboard shortcuts and powerful extensions
Sustainable Software Engineering
- Technical debt management: identification, measurement and systematic reduction
- Building maintainable systems through good design, documentation and knowledge sharing
- Growing junior developers through effective mentorship and skill development paths
- Ethical considerations in software development including accessibility and inclusivity
Requirements
The course can be tailored to any modern OO language (Java, C#, JavaScript/TypeScript, Python, etc.), but delegates should come armed with a good understanding of the language used. Additional training in language fundamentals can be requested on enquiry.
This is an intensive 2-3 day workshop (depending on level) that consists primarily of hands-on coding exercises rather than slides. Through live coding sessions with the instructor, delegates will immediately apply the concepts they learn, cementing their understanding through practical experience.