My Publications

These are books I’ve written that might help you in your journey as a software architect. 

Software Architecture: The Hard Parts 
by Neal Ford, Mark Richards, et. al. 
O’Reilly Media, October 2021
ISBN 978-1492086895
O’Reilly Learning Platform  

Fundamentals of Software Architecture 
by Mark Richards and Neal Ford
O’Reilly Media, February 2020
ISBN 978-1492043454
O’Reilly Learning Platform  | Companion Website | Updated Images

Software Architecture Patterns 2nd Edition
by Mark Richards
O’Reilly Media, August 2022
ISBN 978-1-098-13427-3

97 Things Every Java Programmer Should Know
Contributing Author
O’Reilly Media, June 2020
ISBN 978-1491952696

Microservices AntiPatterns and Pitfalls
by Mark Richards
O’Reilly Media, July 2016
ISBN 978-1491963319
PDF Download

Microservices vs. Service-Oriented Architecture
by Mark Richards
O’Reilly Media, November 2015
ISBN 978-1491956687
PDF Download

Java Message Service 2nd Edition
by Mark Richards, Richard Monson-Haefel, David Chappell
O’Reilly Media, June 2009
ISBN 978-0596522049

97 Things Every Software Architect Should Know
Contributing Author
O’Reilly Media, February 2009
ISBN 978-0596522698

No Fluff Just Stuff 2007 Anthology
Contributing Author
Pragmatic Bookshelf, April 2007
ISBN 978-0978739287

No Fluff Just Stuff 2006 Anthology
Contributing Author
Pragmatic Bookshelf, June 2006
ISBN 978-0977616664

Java Transaction Design Strategies
by Mark Richards
C4Media Media, June 2006
ISBN 978-1411695917

Articles I’ve Published

These are articles I've published that might help you in your software architecture journey.

Finding Structural Decay in Architectures 
by Mark Richards
NFJS Magazine, April 2017

Most things around us wear out and eventually experience decay; the car we drive, household appliances and electronics, highway bridges, even ourselves. Software architecture is no different. One of the many responsibilities of a software architect is to continually assess the architectures supporting applications to determine whether they are still sound or in need of repair. But what does that mean and how do we do that? In this article I will discuss both architectural (macro) and source code analysis (micro) techniques for finding and fixing structural decay in your application architectures.

Tips for Transitioning into Software Architecture (Video) 
by Mark Richards
O’Reilly SACON Interview, April 2016 

In this interview video I discuss the attributes that a developer needs in order to transition into architecture. Ik also outlines the common mistakes that new software architects tend to make, as well as how established software architects can stay current.

The Challenges of Service-Based Architecture
by Mark Richards
NFJS Magazine, Nov 2015

Microservices is taking the IT industry by storm as the go-to style for developing highly scalable and modular applications. While Microservices offers significant advantages over monolithic architectures, there are some significant challenges to consider and overcome before jumping onto the Microservices bandwagon. In this article I will discuss some of the challenges you will face when considering a service-based architecture style and some ways of overcoming those challenges.

Architecting For Change
by Mark Richards
NFJS Magazine, June 2014

As an architect, you have probably heard at some point from the business “Our business is constantly changing to meet new demands of the marketplace”, or “We need faster time to market to remain competitive”, or even “Our plan is to engage heavily in mergers and acquisitions.” What do all these statements have in common? Change. It’s a different world than it was many years ago. Both business and technology are in a constant state of rapid change. That means architectures have to sometimes change as well. However, the very definition of architecture is “something that is really hard to change.” So how can we make our architectures respond faster and easier to change? In this article, I will explore the “architecting for change” meme and discuss several common techniques for ensuring that your architecture can properly adapt to change.

Leveraging the Roles and Responsibility Model
by Mark Richards
NFJS Magazine, June 2012

Whether starting out from scratch or maintaining an existing application, there will always come a time when you need to add new business functionality and capabilities to an application. Which classes and components should contain the new functionality? This question may sound simple and obvious but in most cases it isn't. All too often applications end up becoming overly complex and unmaintainable due to one missing component: the simple but powerful roles and responsibility model. This article shows how the roles and responsibility model can be leveraged to build robust and maintainable software applications.

The Secret to Building Highly Available Systems
by Mark Richards
NFJS Magazine, July 2010

During the summer of 2008 more than 200 flights were delayed or canceled at the Dublin airport due to a shutdown in the Dublin air traffic control radar system. In 2009, a shutdown in the FAA’s automated flight planning and communication system caused significant flight delays and cancellations across the country. In 2006 almost 200 flights were canceled at                                                                                                                                                                                                                                        the Seattle Tacoma International Airport due to power outages and system failures in the Terminal Approach Radar system. Real-life situations such as these can place people in significant danger simply because critical systems were not available when they were needed the most. This article talks about how to approach highly available systems.   

Creating an Effective SOA Service Taxonomy
by Mark Richards
SOA World, Oct 2008

It’s hard to think about Service Oriented Architecture without thinking of services; after all, services are the main focus of SOA (it’s even in the name). If Service Oriented Architecture is an approach where the business and technical architecture is oriented around services, then what exactly is a service? Unfortunately, the answer to this question varies greatly depending on whom you talk to and how you are using SOA in your organization. This variation tends to create quite a bit of confusion when trying to design and implement a SOA-based solution. 

Videos I’ve Recorded

These are videos I’ve recorded that might help you in your software architecture journey.

Software Architecture Fundamentals: 2nd Edition
by Mark Richards, Neal Ford
O’Reilly Media, November 2017
9 hours 37 minutes

Being a successful software architect is more than just possessing technical knowledge. It’s about thinking like an architect, being a leader, and understanding the architectural elements, patterns, and styles necessary to create effective software architectures. In this full update to their "Software Architecture Fundamentals 2015" (O'Reilly Media) video course, Neal Ford and Mark Richards empower you with the essential skills you need to be effective in this role. You’ll be introduced to previously unmentioned architecture patterns, such as command query responsibility segregation (CQRS) and LMAX, along with the most effective tools and strategies for analyzing architecture. This video is designed for senior-level developers who want to become software architects and for junior architects who want to bump up their skill sets.

Microservices AntiPatterns and Pitfalls
by Mark Richards
O’Reilly Media, June 2016
4 hours 9 minutes

Microservices is an increasingly popular architecture style that promotes scalability and ease of testing and deployment through small, highly distributed service components. It may sound like the correct architecture for your situation, but if you’re new to microservices, how do you really know? Understanding microservices’ pitfalls (practices that are never a good idea) and anti-patterns (practices that seem like a good idea, but aren’t) is a good place to start. In this video, software architecture veteran Mark Richards doesn’t just identify the pitfalls and anti-patterns of microservices, he shows you how to avoid them. You’ll learn about service granularity estimation, database migration, microservices reporting, distributed transaction management, remote access latency, contract versioning, distributed logging, and much more. 

Enterprise Messaging: JMS 1.1 and JMS 2.0 Fundamentals
by Mark Richards
O’Reilly Media, October 2014
5 hours 29 minutes

Learn the basics of messaging, a powerful paradigm that makes it easier to decouple and integrate enterprise applications. In this video course, messaging expert Mark Richards takes you through messaging fundamentals with the Java Message Service (JMS) API. You’ll learn the basics of how to use the JMS 1.1 and 2.0 API to send and receive messages, how to do request/reply processing, how to use message selectors, and how to use publish and subscribe messaging—all through live, interactive coding with ActiveMQ and OpenMQ. This video begins with some fundamental messaging concepts, then takes you on a live coding journey through the JMS 1.1 API, the new JMS 2.0 simplified API, then a variety of messaging fundamentals topics that will enable you to understand and effectively use messaging for enterprise-wide applications.

Enterprise Messaging With JMS: Advanced Topics
by Mark Richards
O’Reilly Media, October 2014
3 hours 52 minutes

Dive into advanced topics for using Java Message Service (JMS) in the enterprise with this comprehensive video course. Through live, interactive coding in both JMS 1.1 and JMS 2.0, messaging expert Mark Richards take you deep into several advanced JMS features and techniques, including JMS transaction management, embedded messaging, RESTful JMS, Spring JMS, and message streaming. If you’re a Java developer who understands JMS basics, particularly though Mark Richards’ introductory video—Enterprise Messaging Using JMS: Fundamentals—this advanced course is the ideal way to continue your journey through enterprise messaging.

©2023 DeveloperToArchitect