Tech Talk

Recent posts

Enterprise System Pitfalls: Summary
Today I’m wrapping up a series of posts on the broad topic of Enterprise System Pitfalls. In this series, my hope was to help shed light on the primary problems that cause us to miss budgets, fall short on capabilities, or completely fail when implementing an enterprise system. 

The Year in Review
As 2019 comes to a close, it’s time to count our blessings. One of mine has been the privilege (and fun!) of being able to reach out to so many interesting companies and get them to tell me what they’re doing that’s different, disruptive, and game-changing. The list of things I have to write about in future columns has only gotten longer in the nine months since I started writing this column.

Sustainable Innovation
Sustainability can yield multiple benefits to hotels. Saving energy and water yields direct cost savings. Revenue can be generated by guests who prefer to deal with businesses that minimize their environmental impact. And many would argue that conserving scarce resources is simply the right thing to do.

Meetings Innovation
The sale and delivery of groups and meetings is perhaps the most significant and under-automated functions for many hotels. Even though groups often account for 30% to 60% of revenue, most group bookings are still handled manually for most if not all of steps, as they move from a meeting planner’s research to a confirmed booking.

The biggest enemy to any system is complexity. In a system of inputs and outputs, such as an enterprise system, more complexity means more parts are used in interaction with inputs to create the outputs. Every part that must be built and maintained costs time and money

want to read more articles like this?

want to read more articles like this?

Sign up to receive our twice-a-month Watercooler and Siegel Sez Newsletters and never miss another article or news story.


Enterprise System Pitfalls Part IV: Implicit Dependencies

by Mark Loyd
In this fourth post in my series on Enterprise System Pitfalls, I’m going to discuss a conceptually difficult topic called Implicit Dependencies. I reiterate to my R&D team all the time that complexity is our number one enemy, and that dependencies have the most significant impact on complexity. Most architects understand that dependencies create complexity, and it is one of the primary reasons there has been such a shift away from monolithic design. Interwoven dependencies inside a monolith is the reason updates begin to be very difficult. A change in one area of the system can have a negative side affect in unexpected ways in unexpected modules. Many times, a small update will require an entire system build and deploy, slowing down our ability to improve the system quickly, or to create smaller independent teams. Most of these problems trace back to dependencies. Well, that and poor system design, but let’s just focus on dependencies.
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. And 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 most 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 than 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 The Author
Mark Loyd
Jonas Chorum

Mark has two passions… technology and the outdoors. Starting his technology career in the late '90s 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 5 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. 

Blog post currently doesn't have any comments.
Leave comment

 Security code