All applications are destined to become unmanageable monoliths – the proverbial Big Ball of Mud.  It doesn’t matter how good the original plan was, successful applications are enhanced over and over again until they take on responsibilities that were not originally imagined. As that happens maintenance and feature addition becomes more and more difficult while bug rates increase.  The application then officially becomes a “Legacy Monolith” – and a problem.

The solution to this problem is to continually refactor the application to inject the appropriate architecture to keep up with the new requirements.  What happens, though, when your internal team does not have the technical skill to do this?  They continue to build things the old way and the application trudges down the path towards obsolescence.

To solve this problem, you need the Team Skill Update Training program.

Big Ball of Mud

Program Goal

The goal of the Team Skill Update Program is to teach your internal team the skills they need to update your existing applications to streamline feature addition and ease deployment.

Good architectural practices are generic.  They are necessary for a healthy application, but they are also very similar from one application to the next.  Your internal business logic, however, is specific to your business and training on it cannot be found anywhere else.

Should I Hire or Train?

It is faster and more cost efficient to teach internal people how to build the proper architecture than try to teach new developers your business.

To get your team’s skills up to date, we offer a set of training modules that address your specific situation.

Training Module Topics

The core training modules must be given as a group and in order.  Each topic builds on the previous ones so skipping any one of them can result in the subsequent ideas being misunderstood.  The advanced topics may be chosen ala carte, but only after the core training is complete.

Core Training Topics are given in this order.

This class discusses what Dependency Inversion is and why it’s necessary. I discuss the different types of dependency inversion, show the pros and cons of each, then give a live demonstration of how to inject it into an existing application.

We discuss what a SOA is, and the difference between external services and internal services. I show the advantages of implementing business logic as services, how to identify business logic that lends itself well to a service, and how to refactor existing code into a service.

I discuss what unit testing is and the advantages it brings. I address head-on the frequent complaint that it will double the time to complete tasks.  I show the difference between integration tests and unit tests, and do a live demo on how to begin unit testing an existing application.  We will also discuss code coverage and tracking coverage statistics.

Unit tests can have limited usefulness without being able to mock services. This is a complicated topic, so we spend an entire module on it to ensure developers understand how and when to use it.

Data access patterns are one of the most restrictive of the legacy code habits I run into. Unfortunately, they can also be one of the most difficult to fix.  In this module I describe what a repository is and what its advantages are.  I also show examples of how to migrate from the current data access technology (ADO or ORM) to repositories.  We then look at how that dramatically improves our unit testing experience.

ASP Classic and WebForms are still being used extensively.  They were valid alternatives in their time, but now there are better approaches to building effective systems.  The code in ASP Classic and WebForms is difficult to test and often suffers quality problems.  In this final class, we review how we an address the quality of ASP Classic and Webforms by moving to the MVC pattern which allows the code behind a form to be testable.

Standard Training Module Format

Each training module consists of a 4-hour class regarding a particular topic from above.  Each class consists of lecture on the theory along with extensive code samples to demonstrate how the theories are applied.  All examples are available from Github in Before and After format so students can participate and update the code during the class, and also review topics later.

Classes are delivered remotely or on site over 3 consecutive days for up to 20 attendees.

Lecture to Class

Custom Training

The custom training format consists of the same material, but all examples are taken from your internal source code.  This can make the class much more useful because the students can see the patterns and theories at work in their own code.

This approach lets me address the two most common objections a development team has to these patterns:

  1. “It will take way too long to implement. We need to get our stories done.”
  2. “That pattern looks great, but it won’t work in our app – it’s way too complicated.”

In order to prepare for the customized classes, I will need access to your code repository at least 1 week before the first class, as well as 2-3 hours of time from a senior developer to show me where things are and how the code works.  This is necessary so I can pick examples that clearly demonstrate the topic at hand, making the classes much more valuable.

Working Together