Clean Code: Architecture & Design Masters Class for Software Developers

Clean Code: Architecture & Design Masters Class for Software Developers

Actions and Detail Panel

From $1,500

Date and time


Online event

Refund policy

Contact the organizer to request a refund.

Eventbrite's fee is nonrefundable.

Software Architecture is a complex domain that warrants a semester-level course. SOLID, Components, Patterns... Earn CUEs and Certificate.

About this event

In this 13-week course, Bob will walk you through all aspects of Software Architecture.

Upon completion of the course, we will send you a signed certificate of completion notating continuing education units totaling 26 hours.

This course will be held every Wednesday from September 7th to November 30th from 10am -12pm central. All sessions will be recorded and available to the participant for review.

Software Architecture is a complex domain that is deserving of a semester-level course. So prepare yourself for some hard study, and some hard work.

Week 1: Who? What? and Why?

Who is an architect? What is architecture? Why is it important? These are the questions we will explore in this two-hour session. We will walk through a case study of an architecture gone wrong, and talk about what happens when an architecture goes right. We’ll discuss the roles and qualifications of an architect, and the value architecture brings to the business.

Week 2: Starting with the Bricks.

In this session, we will walk through the three major software revolutions that have impacted our industry since its inception in the late 1940s. Structured Programming, Object-Oriented Programming, and Functional Programming. These are the bricks upon which all architectures are built; and all three are essential for building a Clean Architecture.

Week 3: The SOLID Principles: SRP

Now we begin a five-week deep dive into the SOLID principles of software design. After introducing the principles in general, we explore the Single Responsibility Principle. This principle is probably the most misunderstood of the five. By the time we are done, you will understand this principle at a deep level.

Week 4: The Open Closed Principle.

Of all the design principles, this one sets the highest ideological goal and has the most profound effect upon architecture. The elements of software should be extensible without requiring modification. We will walk through many examples, and show how the bricks of software architecture are hung on the superstructure of this principle.

Week 5: The Liskov Substitution Principle

Perhaps the most complicated of all the principles. The LSP starts with the simple premise that subclasses should be substitutable for their base classes. The complexities that arise from this simple beginning will startle you, and will explain why the subtype hierarchies, that all architectures depend upon, so often end in chaos.

Week 6: The Interface Segregation Principle

Perhaps the worst named of all the principles. In this two-hour session we will learn how this principle arose, and its true meaning. It ends in a mantra that all architects must internalize: Don’t Depend on Things You Don’t Need.

Week 7: The Dependency Inversion Principle.

This is the principle upon which all the others rely. For two hours we will explore what turns out to be the fundamental operation of all software architecture: The inversion of source code dependencies against the flow of control.

Week 8: Design Patterns I

Design patterns are crystalized exemplars of the SOLID principles. For the next two weeks we will explore several of the most common patterns, and show how they fit into the architecture of a system.

Week 9: Design Patterns II

This week continues the exposition of Design Patterns, but turns to those that impact higher-level structures that lead directly into next week’s topic of components.

Week 10: Component Cohesion

Now we enter the domain of high-level architecture. Components are the first stop. They live within the architectural boundaries that remain a few weeks in our future. In this two-hour session, we will discuss the principles that bind source code modules together into components. We will learn about the internal tensions between these principles, and the implication of those tensions for the long-term stability of every software architecture.

Week 11: Component Coupling.

Yet another step up in our architectural exploration. In this two-hour session we’ll learn the principles that govern the relationships between components; and the mathematical relationships they imply. Get ready for some surprises. This is where the _science_ of architecture starts to appear.

Week 12: Architecture: The Art of Drawing Lines

Building to the climax. In this two-hour session we talk about Business Entities, Use Cases, and Boundaries. We look at the anatomy of those boundaries and the rules for managing them. We talk about service both big and small. And we culminate with the iconic description of The Clean Architecture.

Week 13: Sweeping the Street.

In this final week, we gather up all the details that the last 12 weeks left behind. We’ll talk about the main component, the test boundary, frameworks, databases, and a plethora of other final topics.

Interested in registering a team of 6 or more?

Email with questions.

Share with friends