History of service-based architectures

- We cannot have a discussion on "Modern Application Architectures," without taking a brief look at where we have come from. When I started writing code professionally, end tier architectures, usually three tier and monolithic applications were the norm. We used to build a single binary web artifact and then decompose that application internally into layers. You would build a data access layer and then a process layer, and then on top of that, a presentation layer. Each of these layers would often then decompose into layers themselves, often in threes again, over and over. This layered architecture still gives me chills down my spine as I ponder the crazy pass through layers that we would build just to satisfy the architecture. What we did get, however, was separation of concerns from the decomposition of our code into functional components. As monoliths continue to rule the environment, we started to see an anti-pattern that still hinders us today in many situations. The tight coupling of components in monoliths make changes hard. And the older the application was, the more coupling would develop. In addition to the coupling issues, monolithic applications require considerable time to build, test, and deploy. The issues with monolithic applications compounded on top of itself as coupling caused code issues, which could only be fixed with long cycles from code 'fix' to deploy, and the issues go on and on. We then saw a shift, and that shift was to service-based architectures, specifically SOA or service-oriented architecture. While these decomposed our applications into smaller modules, it brought about several other issues. Now I will discuss the two that were most impactful to me. One, is the web service technology was based on SOAP, and while not a deal breaker in its own, it makes a lot of compromises that are contrary to how HTTP works. HTTP was designed with response codes, SOAP ignores these except for "OK", or "Internal Server Error." With SOAP, you get a 500 only, yet if the error is recoverable, you have to wrap it. The client then has to inspect the Unmarshaled XML to see if the error is recoverable or not. The second and more prevalent issue is with the aggregation layer itself. While the aggregation layer can be written very thin, the reality is that not only do the transformations of XML get added, but eventually Logic Operations started getting added to the bus itself. This added a new level of coupling now between internal and external elements of the system as a whole. SOA was however the hottest architecture pattern of the time. Enter into the picture microservices. Now, I would be the first to state that microservices based architectures are not the silver bullet. In fact, they bring their own sets of problems. They do however, have the promise of a more agile framework that can be extended into a cloud native world much easier than either monolithic applications or SOA based architectures. The rage of microservices is not an accident either. The model fits well in both the web developer and web service developer, in part because HTTP is at the heart of the model when rest is utilized. Now, some choose GraphQL or GRPC, and while they have the same issues that SOAP has, they do have benefits as well. As we begin to dig in, keep in mind the trade-offs we will take in microservices and use that to evaluate if this architecture pattern is for you. Now, we're going to dig into this pattern a little more deeply so we can focus on the lessons of the past to make for a better future.