Software Training & Development
Following is a list of training courses I have developed and teach on a regular basis to uplift individual and team capabilities:
school Training
Managing Technical Debt
To maintain business, market, and technological advantages, you must effectively manage technical debt incurred within all artifacts that define, implement, and validate your software. This course examines what technical debt is, explains why defining a quality model is essential to understanding technical debt and teaches how to effectively manage risks associated with impacts to that model. Discussions will encompass tracking quality issues as defects vs. technical debt, dealing with code smells, and methods for minimizing technical debt.
Learn More schedule 2 Hours
school Training
Principles & Practices of Test-Driven Development
This course teaches the principles and practices of Test-Driven Development (TDD) and demonstrates how proper software design evolves through application of the eXtreme Programming principle of Test First. Unit testing principles are introduced, along with a thorough discussion on the benefits of TDD. An application is developed (from start to finish) during this course to explain step-by-step and demonstrate first-hand how a high quality, testable design evolves by applying the three laws of Test-Driven Development.
Learn More schedule 3 Hours
school Training
Unit Testing and Beyond
This course teaches the principles and practices of unit testing, along with core techniques for writing testable software and avoiding test smells. Dependency Inversion is taught as an effective method for isolating the system under test, along with test doubles for overriding behavior. Test-Driven Development (TDD) is also taught and demonstrated to show how proper software design evolves through application of the XP principle of Test First. An application is developed during this course to demonstrate how a high quality design evolves by applying the three laws of TDD.
Learn More schedule 6 Hours
school Training
The Technical Discipline of Being Agile™
Agile was created by 17 technical leaders in the software industry who crafted a lightweight development process that was intended to heal the divide between business and developers. They also established technical norms that would mitigate common issues such as excessive cruft, tightly coupled architectures, rigid code, immature test suites, technical debt, along with other anti-patterns that slowed delivery of high quality software. This course examines the characteristics of good and bad software and explores technical practices that resolve the issues and enable teams to deliver great software fast.
Learn More schedule 6 Hours
school Training
How to Craft Stories of Value
Of course, user stories do not align to the SOLID principles. But the code that implements them should conform to these fundamentals of clean code. This course teaches team members how to align user stories with the six INVEST principles to provide a foundation for a healthy backlog, along with a structure that promotes alignment with the five SOLID principles to facilitate clean code.
Learn More schedule 2 HoursInside Unit Testing: Principles & Practices
Product quality, code quality, and time to market can all be improved and optimized through effective use of unit tests. Testing in small, isolated, and deterministic units fosters code characteristics such as testability, adaptability, and reliability. This testing strategy shifts failures towards the left of our SDLC and greatly reduces development time, costs, and risks.This course teaches the principles and practices of unit testing, along with core techniques for writing testable software and avoiding test smells. Dependency Inversion is taught as an effective method for isolating the system under test, along with test doubles for overriding behavior, further enhancing testability. An introduction to Test-Driven Development (TDD) is used to integrate unit testing practices with those of TDD.
SOLID Principles of Object-Oriented Design
Quality can never be added to software; you must plan, design, and build for it. The SOLID principles provide a set of standards by which quality software can be developed, enhancing characteristics such as functionality, extensibility, reliability, portability, and testability among others. This course teaches the five SOLID principles of class design and associated practices that will help realize high quality software.Principles & Practices of Software Component Design
Modern, mature software solutions should fully support continuous delivery through an automated delivery pipeline using containerization and cloud infrastructure. To realize this goal, software needs be designed and built around loosely coupled, independent components.This course teaches how to deliver high quality and highly adaptive software through component design principles, supported by SOLID principles of object-oriented design.
Decoupling the Monolith
As companies and organizations move towards a DevOps model for software delivery, it is more important than ever that software be designed and built for the cloud that enables zero downtime deployment through an automated delivery pipeline. Committing a total rewrite of a legacy application is rarely feasible, while enabling continuous delivery is essential to remain competitive in tomorrow’s market.This course teaches software engineering practices that enable delivery of highly adaptive, resilient, cloud applications that support continuous delivery. Class, component, and microservice design practices are taught as methods for gradually decoupling monolithic applications without committing a complete rewrite. Through continuous refactoring, tightly coupled code can be teased apart to deliver independently deployable components and services, promote a high-quality architecture, and support continuous deployment. An introduction to containerization is used to emphasize the importance of delivering loosely coupled, highly cohesive software.