Training Classes and Sessions

The following are classes and conference sessiosn I offer for in-person private corporate training and conference workshops. Please click on any of the course images below to view the detailed course description and agenda.

For more information about the pricing and details of these courses for private corporate training, please contact Mark Richards at info@developertoarchitect.com.

Full Day Classes



Conference and Training Sessions  

Modern Practices in Microservices: Lessons Learned
Duration: 60 minutes
Microservices has been around for over a decade now. Over the years we’ve learned a lot, and have developed new practices, processes, techniques, and tools to wrangle this highly complicated architecture style. In this informative and entertaining session I discuss the current state of microservices, including some of the lessons learned over the years. In the session I also talk about some of today's current techniques, tips, and practices to help maneuver around the complexity surrounding microservices. 


Elements of Distributed Architectures
Duration: 50 to 90 minutes
Most architects and developers agree that distributed architecture is hard—really hard. But what makes distributed architecture so much more difficult than monolithic architectures? In this session I talk about the hard decisions and choices developers and architects face every day when designing and implementing distributed architectures, including things like service granularity, communication protocols, databases, contracts, workflow topologies, and distributed transactions. 


Architectural Modularity vs. Service Granularity
Duration: 50 to 90 minutes
Modularity and granularity are very much different. Modularity is about the breaking apart of systems into smaller deployment units, whereas granularity is about the size of those separate deployment units. In this session I describe the technical and business drivers for architectural modularity and shows various approaches for breaking apart systems. I then show how to achieve the right level of granularity for those separate parts by introducing various disintegration drivers and integration drivers that you can use to not only justify service granularity, but also get it right. 

Architectural Thinking
Duration: 50 to 90 minutes, half-day workshop, full-day class
Architectural thinking is seeing things with a “software architect’s eye”, similar to how a meteorologists, artists, and mariners see clouds with a different point of view and with different meaning. Architectural thinking isn’t just for architects - senior developers and tech leads can apply architectural thinking into their daily activities as well to better understand the architectural implications of decisions they make. In this session or workshop you’ll learn what architectural thinking is and how to apply this kind of thinking to your daily work and activities, regardless of your role or title, and learn about architectural characteristics (“-ilities”), how to increase your technical breadth, and how to analyze trade-offs. In the half-day and full-day workshop format you’ll also learn about logical architecture and common architecture styles and patterns, when to use them, and when to avoid them.

Analyzing Architecture Risk
Duration: 50 to 90 minutes, half-day workshop
Software architecture is full of risk. Will the system scale to accommodate an increase in user load? Is end user responsiveness getting better or worse over time, particularly as changes are made to the system? Is the system as available as it needs to be? Are you at risk for losing orders, particularly at times of peak load? Is the data as accurate as it should be? In this session you’ll learn how to effectively perform an architecture risk assessment to determine the level of risk within your systems, particularly as you undergo application modernization and transform your architecture. By leveraging the techniques demonstrated in this session, you can help prevent your systems from eventually breaking down, and, in many cases, simply stop working. 

Testing Software Architecture
Duration: 50 to 90 minutes
Software developers continuously test their source code using unit and functional tests to ensure the code works properly and contains no defects. But how does one test a software architecture? It turns out that testing a software architecture is just as important as testing your source code. In this session I talk about what it means to test a software architecture. I start the session by discussing what things to test to ensure the architecture is structurally sound and that it's meeting the goals and needs of the business. I then show how to construct various unit tests (fitness functions) for software architecture. 

Decomposition Patterns: Migrating From the Monolith
Duration: 50 to 90 minutes
Microservices is a software architecture styles that promises to deliver benefits such as ease of testing, fast and easy deployments, fine-grained scalability, architectural modularity, and overall agility. Unfortunately, many companies are struggling trying to break apart their existing monolithic or service-oriented architectures and move them to a microservices architecture, and are finding it more effort than they bargained for. In this session I walk you through eight component-based decomposition patterns that allow you to effectively move to microservices in a controlled, iterative manner while minimizing risk and cost. 
 

Patterns of Event-Driven Architecture
Duration: 50 to 90 minutes, half-day workshop
Well-built event-driven architectures leverage asynchronous messaging and event processing to decouple services and maximize your system’s responsiveness, performance, scalability, and elasticity. Unfortunately, with all this power comes a fair amount of complexity, making event- driven architectures hard to build. In this session I take you through various event-driven design patterns that will help you achieve better overall resiliency, responsiveness, scalability, and reliability in your event-driven architecture. 

Analyzing Architecture Tradeoffs
Duration: 50 to 90 minutes
The first law of software architecture from the book Fundamentals of Software Architecture by Mark Richards and Neal Ford states that “Everything in software architecture is a tradeoff”. As a result, one of the key skills an architect must have is to be able to analyze tradeoffs. Most people know the famous response “it depends...” from so many software architectures around the world when asked any architecture-related question. However, the more important question is, “it depends on what?” In this session you’ll learn numerous tips and techniques for identifying tradeoffs and perform modern tradeoff analysis, allowing you to make better and more effective decisions. 


Domain to Architecture Isomorphism
Duration: 45 to 90 minutes
Isomorphism is a mathematical term that determines if two structures are equal in shape. It is derived from the Greek terms Isos (meaning “equal”) and morphe (meaning “form”, or “shape”). Domain to Architecture Isomorphism determines to how close the problem you are trying to solve (the domain, or application”) matches the architecture style you are using (such as Microservices, Event-driven architecture, Space-based architecture, and so on). In this session I explore this concept to help determine of you are using the right architecture style for your problem. I start this session with describing the “shape” of various architecture styles, and then use real-world examples to demonstrate how to match the “shape” of a problem with the “shape” of an architecture.
















©1998-2024 DeveloperToArchitect