Download Monolith Movie 2021
Ara Scholze
A monolith is a geological feature consisting of a single massive stone or rock, such as some mountains. Erosion usually exposes the geological formations, which are often made of very hard and solid igneous or metamorphic rock. Some monoliths are volcanic plugs, solidified lava filling the vent of an extinct volcano.
In architecture, the term has considerable overlap with megalith, which is normally used for prehistory, and may be used in the contexts of rock-cut architecture that remains attached to solid rock, as in monolithic church, or for exceptionally large stones such as obelisks, statues, monolithic columns or large architraves, that may have been moved a considerable distance after quarrying. It may also be used of large glacial erratics moved by natural forces.
The word derives, via the Latin monolithus, from the Ancient Greek word μονόλιθος (monólithos), from μόνος (mónos) meaning "one" or "single" and λίθος (líthos) meaning "stone".
In addition to these formal constraints is the mission to write beautiful, understandable, and succinct code. Code that not only makes us smile while we write it, but also when we later have to extend or patch it. Such a mission is simply not compatible with an accidental monolith. It just gotta be majestic.
Is this still your view in 2019? Am a monolithic engineer embarking on a new project with v. small team and considering M/SOA. Do your points still stand in 2019 or has the tooling improved enough to make M/SOA manageable for a team of 5?
The complexities related to individual pieces of software make more sense as individual modules. Not as individual applications. The difference in resource usage and financial waste is tremendous. In this time of cutting down costs, why would people still choose to build microservices instead of a dynamic, modular monolith?
A monolith might have 1M+ lines of code. But I can do the same thing within the IDE without knowing all the code. I can invoke a method without a network interface and without a circuit breaker. The deployment is trivial.
Had you taken the time to read about the modular monolith you would have learned that you can split a monolith and get most of the benefits of microservices while still retaining the benefits of microservices.
Case in point: you continue to talk about monolith vs. microservices as if I had come out in favor of either one. But I proposed a third path, one that hasn't yet been tried anywhere I've seen, but which you reject out of hand without offering real argument other than that you've managed to stay in this field for multiples of ten years and you don't like it.
But yes, default to monolithic patterns - it's cheaper and simpler. If your monolith is well designed, it usually isn't too difficult to extract that one isolated feature or endpoint to a microservice, if that becomes necessary.
But things like NetFlix, Amazon and Twitter run, and run reliably - these could not have been realized with a monolith, I don't think. At least, I don't see how. So that's "proof", at least in the "the proof is in the pudding" sense.
The module approach supports scaling the teams easily since these become separate small projects. The compute scaling is the main thing I had a problem with. I think that dollar for dollar, scaling a modular monolith will be much cheaper if only due to reduction in observability costs.
The main problem with a traditional monolith is that it builds in the data model and business rules and tightly couples them to capabilities such as storage, integrations and messaging. Micro-services have had a similar issue, in that while they separate concerns they do so by segregation of the domain, rather than based on the capabilities. There is another approach, which is to expel the domain from code and store it in the DB or configuration. Build or buy general capabilities, and have each one handle only those specific responsibilities.
It is monolithic in the sense that it looks similar in structure to the bad old days, rather than a complex network of micro-services, but it is different because it expels the domain, and in the process the complexity, into runtime configuration stored in the DB.
This is what I run across a lot with Springboot and .NET developers. The frameworks encourage a monolithic approach. Why learn a new DB query interface when you can keep using the ORM? That's why SQL is so strong.
Our society was built on bloody crusades and slavery, and to this day, it is fed by unsustainable resources like coal. Building a monolith is fine, but there is a reason we have modern architecture. I know this analogy is extreme and over the top. The point, though is that just because we did it one way and it worked doesn't mean that it continues to be the way to do things moving forward.
Indeed Typescript helped JavaScript a lot and made larger projects more practical. Notice I specifically said JavaScript and NOT Type Script. But it's still not at the scales of Java in terms of ease in building a monolith and there are a few reasons:
Now, here is the thing. In my pricing "domain" I might decide to not just have a database but to put a huge machine learning platform in place that calculates the best pricepoint and discounts to optimize revenue. Maybe that requires that I completely overhaul the way I store and access pricing data. All that is abstracted away behind the "public" pricing APIs. I can iterate and develop without breaking "the monolith" in this service approach.
There will always be bugs. If you write 100% unit test coverage on your code, you will find most of them. And if your teams screw up and break an API, event or other data contract then yeah - life sucks. The tooling is strong now for tracing problems in a distributed system. That said, I can honestly say that it just isn't an issue. I work with so many large enterprises, and cascading failures in a modern microservices pattern are not an issue. It is the cascading failures in the monolith that are common.
I can agree here. I use tools that make distributed architecture so much easier. Deploying multiple containers is just as easy as deploying a single monolith. If anything, it is easier because, by proper practice, each part is atomic and can be adjusted, knowing I won't break the whole.
OMG. I wish. Typescript developers will often grab things like NextJS, GraphQL, maybe TRPC, etc. and these are cool technologies. They all encourage monolithic patterns, sometimes by accident. At least there is some awareness like GraphQL Federations.
I get what you're saying about abstracting individual parts and not disrupting the monolith. 100%. But you'd eventually need to deploy it and then there will be some disruption. You can use a module approach with a monolith to get complete separation where a new version of the module would just "plugin into place". You can create staged roll-outs. You can do feature flags in a monolith. All these tools work just the same.
That said, I can honestly say that it just isn't an issue. I work with so many large enterprises, and cascading failures in a modern microservices pattern are not an issue. It is the cascading failures in the monolith that are common.
That hasn't been my experience but I'll chuck that up to personal biases on both ends. I think a lot of monoliths are old. When they fail people complain they have to fix a bug in the old system. I think we tend to notice it more since it's also a pain. Newer systems still have the developers around. They just fix the respective bugs. I think we'll get a clearer picture with time.
The right choice is to build something "properly".
A monolith CAN work, and microservices CAN work too.
How well they work simply depends on what the developer(s) working on it know how to do. If their skills and experience are sufficient and the buget [time AND money] allow for it, they can build something good and it will last.
Read your post. Agree that - mostly - transactional heavy workloads implemented with microservices add some complexity. But in any way, benefits of splitting complex monoliths and layered applications in smaller units deployed as microservices overcome any issue.
I refactored a decent-sized system over the past year to a more unified architecture. We've been able to introduce new features faster and safer, and write better documentation as a result. I think it's a happy medium between the single monolithic architectures of yesteryear and the whack-a-mole environment that microservices can be.
I have seen a monolith outgrow what one big PostgreSQL replica set was able to handle, and we ended up sharding, which is a fine solution. But it's also possible, like you say, to have each module use a different logical database, and do any necessary cross-module data joining in application code. These logical databases could all live in the same replica set, until they outgrow it, at which point the heaviest ones could be moved to their own cluster, with few, if any changes to application code. I've never tried this, but I'm interested in doing so, as doing it right would reinforce the boundaries between modules, though I'm aware of what's lost in terms of query-ability, enforce-ability of constraints, etc.
I would also add that the "start with a modular monolith - break it up into separate deployment units when you need to - which will probably be never" idea is a key point of "Clean Architecture" by Uncle Bob, great book.
For my recent project (in C#) I wrote an analyzer that plugs into the compiler and enforces architectural rules that I can specify using a DSL. The enforcement makes it easy to maintain the discipline of a modular monolith because it won't compile unless the architecture is respected.
Microservices is an architecture that is over sold in my opinion. Consultants love to sell it as a silver bullet to all woes. Some of the smarter shops never left monolith and have not looked back like stack overflow blog.bytebytego.com/p/ep27-stack-o...
Lesson is, always start with a monolith, only look at microservices if there is a compelling need for it. Plus the operational overhead running K8s is a great reason not to go there.