Training Course | Engineering Principles
Fast-track your techniques and thinking that enable the creation of great software
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.
Duration: 2 days
Location: Virtual | Classroom
Skill Level: All levels
Course delegates will complete the course having gained the following knowledge.
- How to structure and decompose code at the class level
- How to create intention-revealing code
- How to unit test and test for behaviour properly
- How to identify and rectify code smells through refactoring
- How to apply the design principles in practice
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.
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.)
Hugely interesting course and eye opening to understand all the vulnerabilities that exist. Even though we have security reps within the company this would make you think there is a need for specially trained staff whose sole focus is that.
Delegates will complete a total of 10 modules over the duration of the course.
1. Functional, Imperative and Object Oriented Thinking
Functional, imperative, and object-oriented thinking are three programming paradigms that shape problem-solving in software development.
Delegates will be learn the outline of all three, and how to utilise these in the context of engineering best practices.
2. How to Structure and Decompose Code
Learn and level-up your knowledge of DRY, SRP, Encapsulation, Coupling & Cohesion, SOLID Vs CUPID principles.
3. How to Create Intention Revealing Code
Learn the principles on to write clear and concise code that effectively communicates its purpose. This will enable delegates in creating descriptive names, consistent conventions, and logical structure while improving code readability and maintainability.
Learn to utilise code smells to identify problematic areas in your code such as duplicated code, complex logic, and poor naming conventions.
Subsequent refactoring techniques will help you eliminate excess code smells by restructuring and optimising codebases, resulting in better quality code that is future-proofed for extension in the future
5. Organising Code
A hugely important aspect in creating future-proof, scalable code. In this module, get to grips with best practices in organising your code. Learn to code in a modular approach, navigate through essential and accidental complexity, and understand cohesion through scattered logic to monolithic classes.
6. Managing State
Effective state management is a fundamental aspect of software development, particularly when building complex applications. Take a deep dive into managing state, focusing on the concepts of mutable vs immutable data.
7. Using Standard Data Structures
Get to grips with data structures (including sets, maps and lists) to better solve problems.
8. Overview of Approaches to Testing
In this module, learn the fundamentals of software testing and gain a solid understanding of different testing methodologies. They will delve into the principles and practices of white box testing, black box testing, and grey box testing, and explore when and how to apply each approach to uncover defects and validate system behaviour.
9. Testing Strategies
Learn to leverage the best testing strategies to re reduce the chance of critical bugs reaching production code lines. In this module, we'll guide you through the best principles including pyramid and honeycomb models to help guide effective testing practices.
10. Deep Dive Into Unit Testing
You will explore the concept of testing behaviours, Domain-Specific Languages, Test-Driven Development and how to use mocks, stubs, and fakes to isolate units under test from their dependencies.
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.
Looking to continue on your learning path? The following courses are ideal as follow-on courses to Engineering Principles.
Or send us a quick message