With a desire, then, to reduce complexity, we endeavor to reduce dependencies. The advent and adoption of microservices resulted from this push away from monolithic design, and an attempt to do exactly this. However, do microservices really solve the dependency problem? Not really. Microservices give the appearance of independence, but rely heavily on other services in addition to dependencies that are pushed into coordination, transaction management, and the like. There have been many attempts to architecturally solve the dependency problem without eliminating these Implicit Dependencies.
The right architecture must be determined by first understanding the true sources of complexity. In the vast majority of microservices implementations I’ve seen, the architecture fundamentally didn’t solve the dependency problem it set out to solve. I also believe that many, if not most systems can eliminate majority of the problems by addressing design flaws rather than moving to microservices.
In order to build the right architecture, Implicit, or hidden, dependencies must be understood – and understanding is actually pretty simple. Anything that is shaped specifically, or anything that cares about content is a dependency. As an example, an API function that has specified values as parameters is itself an implicit dependency. Not only the information it sends and receives, but the contract itself is a dependency. This is why the best APIs are simply a function accepting a string and returning a string. This removes any implicit dependencies in the API itself, and it can truly remain version-less, which is ideal decoupling.
Consider comparing a simple telephone to a SOAP XML interface written with XML validation routines. Both are intended to transmit information. In the case of the telephone, the phone could care less about the language of the speaker or any of the words spoken. It does not care about any new words or other changes in communication. There are no implicit dependencies in the phone. However, implementors of the XML interfaces (arguably designed to simply facilitate communication like a phone) felt they had to check the content of the XML before passing it to whomever actually acts on the content. This XML validation means the interface cares about the information. Why? Good question. Someone thought it was better to reject data at the transmission layer as opposed to leaving it up to the system that really should care. Regardless, this is a great example of implicit dependency. These implicit dependencies became the standard way to implement XML, became a major problem, and is likely the greatest reason people think they should move away from XML interfaces. XML isn’t the problem, the dependencies are.
Now consider if an architect has created too many layers in a bloated infrastructure (see my previous post on the Infrastructure Imbalance), complexity is compounded when these needless layers contain implicit dependencies.
In order to build scalable and affordable enterprise systems, be diligent to remove any implicit dependencies, starting with making sure the shapes of your components are the least specified as possible, and that they don’t care about information they are not designed specifically to act upon.
In my next post, we’ll examine our biggest enemy in enterprise systems: complexity.
About Mark Loyd, President, Jonas Chorum
Starting his technology career in the late 90’s as a software developer for a property management system, he quickly worked his way through the ranks and entered his first leadership position in 2000, managing a team of five developers. Twenty years later, having served as COO, CSO, CTO, and now President, Mark leads a talented team of 120 people that follow his passion and vision in making Jonas Chorum a technology leader in the hospitality industry.
The post Mark My Words: Enterprise System Pitfalls Part IV – Implicit Dependencies appeared first on Jonas Chorum.
