24 ms·
Well-Architected Monoliths Are Okay
- d3ckard 8y agoIf you try to differentiate monolith acceptability based on "quality of architecture", you really have never understood why they are hated in the first place.
- vorpalhex 8y agoNo architectual pattern can survive a lack of maintenance and grooming. Sprawling microservices written in a dozen different languages can be worse then a mangled monolith.
- maxxxxx 8y agoI always say if you can't design a monolith then don't bother with microservices. You shouldn't use microservices to cover up for a lack of design skills or a lack of communication between teams.
- xab9 8y agoEvery man is an island in the world of microservices. Look, my microservice is clean and nice and has a 100% test coverage, I couldn't care less if you can't communicate with it from yours. Solve it somehow. Now get off my lawn and let me rewrite the whole thing in scala.
- deleted 8y ago[deleted]
- vorpalhex 8y agoI agree entirely. Microservices have advantages but they also bring along severe complexity. Many problems can be cleanly modeled as a monolith - and they should be. No architecture pattern is immune to abuse.
- monkeydreams 8y ago> Microservices have advantages but they also bring along severe complexity. Worse, often the complexity they bring is undocumented because it lies in the relationships between applications, accounts, infrastructure, and so on, and does not lie within the boundary of a single application. Microservices are simpler to write because you can pretend a lot of the ecosystem does not exist.
- InclinedPlane 8y agoOn top of that, microservices often suffer from inadequate tooling. Companies like Amazon have been working on tooling for their services for literal decades, most companies have some half-assed attempts at tooling and don't understand why that's a problem. Consider deployment, for example, how do you know what's deployed at any given time? Well, the answer is usually something along the lines of "oh, that's just the head revision of all of the relevant repos/branches". And what about the staging and dev environments? And what about logging and history? How much work is it to figure out what code was running when certain bugs were filed?
- romed 8y agoThat sounds like a monitoring problem and nothing to do with microservices vs. monoliths. If you have 10000 replicas of your monolith, how do you know what version they are running? If you can answer that question then you can also answer it for 100 replicas of 100 difference services.
- gav 8y agoThe advantage of microservices is the ability to scale, both in terms of system performance and feature velocity. They are worse at basically everything else. Any system architecture needs to consider the specific case, there’s no best pattern for everything.
- the_arun 8y agoIf microservices are worse, may be we have not architected them well. For eg, if two micro-services are chatty, may be they need to be together to begin with. Micro Monoliths are good compromise :)
- red_hare 8y agoCan anyone recommend good examples of monoliths in open source? Preferably in Go? I inherited a bunch of micro services at my current job with a fairly small team. My feelings have been that the code had been prematurely micro-serviced considering the team is so small and every service was mainly just CRUD in front of then same Postgres instance. I’ve slowly been demonstrating the benefit of modularlized “sub-apps” in a single monolith over lots of microservices that all reinvent the wheel. And I think I’ve convinced them that this is easier going forward. But I’m at a loss sometimes about what boundaries I should be putting in place such that we don’t end up with a ball of mud in two years.
- sarabande 8y agoKubernetes is a pretty large open-source Go project: https://github.com/kubernetes/kubernetes https://github.com/kubernetes/kubernetes Docker is, too: https://github.com/docker/docker-ce https://github.com/docker/docker-ce
- ben_jones 8y agoKubernetes always gets brought up but I would argue that while it is large it is not simple and was not architected to be understood by novices to monolith projects. The goal of kubernetes is to be kubernetes, not to be a pristine learning example - and though you can learn from studying it it is probably not the best place to start learning.
- threeseed 8y agoIs Kubernetes really a monolith ? It isn't one codebase and when deployed there are multiple daemons running.
- snail_98 8y agoPeople confuse monolith and monorepo all the time. If you have a monolith where each independent module communicate via queue, like described in the article, you are so close to having a monorepo of horizontally scalable micro-services.
- dave_sid 8y agoIt’s fashionable just now to hate monoliths, so much so that developers would probably be afraid to suggest anything other than creating a suite of microservices for fear of sounding backward or inexperienced. It’s a bit like if anyone ever dared to suggest that they don’t adopt Agile. You’d probably be chased out the room by an angry mob.
- jacob019 8y agoI've been seeing more and more backlash against micro-service architecture recently. Seems silly to me. Developers should match the architecture to th problem and adapt as needed rather than sticking to an ideological pattern.
- brbrodude 8y agoBut "monolith" is a concept of bad stuff so everyone must get away from it, apparently. The thing is, they're just throwing this word around, before the micro-service trend "monolith" to me meant software with no boundaries, modules, design, like it solidified in a bad state, to which the antidote was design. Seeing this word being used to describe "not running micro-service architecture" gives me feels of lobby/marketing manipulation in the craft, this is plain bullshit. If the application is well designed, it is not a monolith! If it's well designed then it has well defined pieces and well defined API then if you need to micro-service anything you can just plug it out, it still is just a fucking API, you could be calling it by pigeon carrier, it doesn't matter. Having basic software development concepts being pushed, or positioned, as trendy pricey buzzword-manager-throws-around hot-architecture concern is nothing more than a corruption of the craft. Damn fools.
- dave_sid 8y agoExactly!
- anothergoogler 8y agoIt's fashionable right now to like monoliths. It's "thought leaders" trying to one-up other "thought leaders," contradicting for sport. And who cares anyway? Software fashion is cargo cult nonsense pushed by people who probably struggle to ship anything that's robust or reusable. They're obsessed with keeping up with "thought leaders" on Twitter and Medium. They fly to speak at conferences and make a big name for themselves while the rest of us are busy grinding and limiting the damage they can do.
- threeseed 8y agoThe famous J2EE + ESB style pattern. Many of us have worked on dozens of these before and sure they work but microservices were invented specifically to address the serious concerns with these patterns. 1) It's far too easy to create spaghetti code that spreads across multiple modules. And because they are so intertwined teams are very reluctant to do major refactors. Especially when the original authors eventually leave. 2) It's less flexible at scaling. In a monolith you have to horizontally scale the entire application behind some load balancer. So if you have an Email concern that needs to handle 100x more load what do you do ? 3) API contracts are far easier and safer to evolve than ESB ones. There are also clean mechanisms in APIs for handling versioning, capability discovery e.g. HATEOS, documentation e.g. Swagger, rate limiting, caching, analytics, billing, authentication etc. 4) Microservices are much easier to reason about, test, document, teach new starters about and most importantly replace. If I replace a microservice I just need to verify that the API contract is the same. In a monolith I need to basically retest everything since there is no guaranteed isolation. I could keep going on. But not sure this blog post offers anything particularly insightful in how to deal with the negatives of a monolith architecture.
- qaq 8y agoOne can create an equally long list of problems with micro services.
- mifreewil 8y agoIt’d be way longer.
- DenisM 8y agoIt seems that apart from scaling your concerns boil down to enforcing discipline? Perhaps there are methods of enforcing discipline that don’t involve serializomg and deserializing a bunch of data several times per request.
- dave_sid 8y agoBingo! Agreed. You’ve summed it up brilliantly. Other than the scaling advantages, micro-services mainly thrive as a method of strictly enforcing separation of concerns. Maybe that’s a good reason to use them. Or maybe there are other ways to do this without incurring the management overhead of micro services. Who knows. Also, I’m not entirely sold on the horizontal scaling advantages either. Are you building a website that’s going to have to scale to millions of requests per second at the click of a button? Probably often not.
- shearnie 8y agoMy angle on building products: Monolith to market. Break it up and optimise where the sticking points are as customer base and feature set matures.
- ianamartin 8y agoTotally agree with this. No idea why anyone would do things different. Other paradigms are cool and fun, but if you need to get your prototype out there now, this is absolutely the way to do it. I do the same thing with the components of the monolith. I'll use Pyramid + SQLAlchemy + WTForms all day long with a reasonable separation of concerns. When I hit a real problem where the ORM is causing a bottleneck, hey, that's a good time to drop the ORM and use stored procs. Same thing with almost any element of the web app. When it's a clear bottleneck, drop one layer of abstraction and move on. This will get you excellent performance without the overhead of an SPA for 99% of your use cases. Design your way around page refreshes, and judiciously apply ajax calls, and you're done. If you aren't one of the big 5, this is good enough, even with a slow language like Python.
- pfarnsworth 8y agoIt's not that simple, and that's the problem with microservices. You'll learn that "break it up" means a huge investment in devops, logging, stats dashboards to understand what the problems are, etc. It's like transitioning dimensions from 2D to 3D, and that's the trap that most people fall into. You cannot survive microservices without real-time dashboards and proper logging to understand the health of your environment, whereas with a monolith, it was fairly obvious because there's the server and usually a database, and that's it.
- shearnie 8y agoTotally agree it's not simple. But monolith in early stages enables a must faster change cycle from early adopter feedback since there's less wiring up to consider as features change.
- batiste 8y agoAll true about monitoring and logging. Is is a huge cost and overhead. Consider it the other way around: micro-service to monolith. It seems to me it is as difficult, if not more difficult. Potentially different language or different build system are used. Different framework might be in place. Sometimes a merge is completely infeasible without a total rewrite. So going from micro-service to monolith is like going from 3D to VR. Splitting seems in a way way easier than merging back.
- the_arun 8y agoWe need to define - what is a monolith before concluding - Well architected monoliths are okay.
- andy_ppp 8y agoAnd arbitrary micro service boundaries are a disaster.
- dragonwriter 8y agoEr, but the description of a “well-architected monolith” here is a set of loosely coupled components (with specific criteria for where you at component boundaries) communicating over an external set of message queues, which, while it doesn't have all the features which define a microservice architecture, is itself a widely documented, well-known, older (heavily documented in the 1990s, possibly older) alternative to monoliths. I suppose this is being called a monolith because everything except the message bus is implicitly jammed into a single process rather than each module being in its own process. But, even aside from the modularization being different from a monolith, bringing messaging out of process makes a huge difference compared to even a modularized single-process solution.
- keithnz 8y agoI'd argue you don't need an external message queue. You can use inprocess ones or an Actor based system.
- taeric 8y agoI'd argue the message queue is, itself, likely not needed. Not directly. I think, ideally, for a system to be successful, you need to understand all places that you either build up messages, threads, buffers, whatever. It ultimately doesn't matter which you do. Just don't do too many. And don't make migrating a solution from one type to another part of your critical path to launch. Logging, in particular, is something I've grown tired of people reinventing before they have even launched.
- justbaker 8y agoPlay framework has support for this via akka and it works quite well from my experience ^^
- dragonwriter 8y agoObviously, you don't need an external message queue to have a functioning system, only to have one that meets the article's definition of a “well-architected monolith”.
- iameli 8y agoSo... keep modules separate, use queues and databases to communicate between modules, make sure the queues and databases are a separate process from the monolith. This sounds a bit less like a monolith and a bit more like a bunch of microservices that you've welded together in one container. Which is great! If you're disciplined about maintaining that, it will be very easy to spin off these individual modules as their own microservices when the time comes. But I'm not sure that this constitutes an argument for monoliths > microservices.
- rossdavidh 8y agoWhat is presented here as a monolith is, however, what the word "monolith" means in current design conversations that I hear in workplaces. Also, I don't think the article was trying to advocate monoliths > microservices, but rather more like "it's ok to use a monolith if that works, and at first it probably will". Because true microservices introduces a lot of infrastructure work at the very beginning, when you desperately need to be working on code for your basic product.
- alexandercrohde 8y agoUnderstatement of the month. Last I heard, the HN consensus was that it's better to delay microservices (personally I'd say wait until profitable or >100 engineers). Even Twitter, probably the most successful performant microservice-at-scale company advocates waiting as long as absolutely possible to make microservices. They said "It fixes one problem, and makes every other piece of application development significantly harder."
- keithnz 8y agoI generally agree, but I'd make a bit of a distinction that doesn't mean making a pure monolith, you can still spinoff dedicated services where it makes sense without adopting a a full "microservices architecture".
- Waterluvian 8y agoI found this to be true with auth. Big monolith but I split off auth, which made using a single user authority much easier for all kinds of stuff that wanted nothing to do with the rest of the monolith.
- karmakaze 8y agoI specifically agree. The 'where it makes sense' has to be based on something practical, not theoretical nor in-the-not-immediate-future. Currently in one of our products we have 4 back-end services: webapp, api, relay, and broadcast. The scaling requirements and lifetimes of the relay and broadcast instances differ. The relay also has audio requirements. It all depends on your environment and the teams ability to deal with what's required.
- thefactotum 8y ago> they let development teams focus on delivering features I agree, but later on, when the team and the codebase grows, you'll need to split it into smaller parts, and microservices (or any other similar architecture) gives you some guidance that can be shared across the team/s making architecture decisions more consistent and providing a common framework that improve reusability, but it's not an easy path!
- diminoten 8y ago> a complicated microservice architecture > Microservices are complicated to develop > Microservices dependencies are difficult Well, if you say so! Kind of hard to take this article seriously when the argument boils down to a tautology. Microservices may be hard! This article contributes nothing to that conversation, though.
- lucidone 8y agoI agree with this. However, for whatever reason, suggesting a monolith or (gasp!) not writing a spa for an app and using traditional ssr html seems to signal that you're antiquated and old fashioned. I've only been doing this for 3 years and it's ridiculous.
- collyw 8y agoYes this is the problem I am am facing just now (been doing this for 15 years). I care more about writing decent code than chasing trends, but it means my skillset looks stagnant.
- tannhaeuser 8y agoWhat's a monolith anyway? At this point just a straw man to pitch microservices against. There are many ways to modularize code; after all, (class-based) OOP is about code organization via modularizarion. In my experience, "REST microservices" is one of the worst, as it derives its working principles from the unrelated problem of loose coupling of web browser and web servers just because it has to use HTTP for unclear reasons, then applies these principles incorrectly, naively, religiously, and dogmatically, while mimicking a two-tier application model that isn't called for. It's really the mother of all antipatterns.
- tanilama 8y agoOf course they are OK. It doesn't matter it is microserivce or monolith, what matters is how well your architecture executes the principle of separation of concerns. That is largely irrelevant of what philosophy you are choosing.
- pvorb 8y ago"Monolith" literately translates to "Einstein" in German, which can't be that bad. Or can it? ;-)
- halayli 8y agoThis still looks like a micro service architecture to me, or very close. A monolith solution would probably be everything in a single process (1 tier). Queues decouple services, whether the code base includes the consumer & producer together or are separate doesn't matter, they are still deployed separately. It's definitely not black/white, but a spectrum.
- balfirevic 8y agoSo, in micro-service architecture services don't have to be particularly small. They also don't need to actually be services. Do words not have meaning any more?
- tln 8y agoUndoing microservices at my current job has been nothing but positive.
- barbecue_sauce 8y agoI often read about (Silicon Valley) companies saying things like "we have a thousand microservices" or "we have hundreds of microservices" and I really can't wrap my head around what all of these services do. As someone who has primarily worked on monoliths, service-oriented architecture seems like an intelligent idea to me, particularly with regard to scaleability. However, I can't see getting so fine-grained that you have that many services, especially considering that from what I've read each microservice should be backed by it's own datastore. Perhaps its just my own lack of first-hand experience showing, but it seems like it would eventually devolve into a confusing, fragmented, and non-performant mess.
- jfz 8y agoI have seen companies saying they have a thousand microservices to mean that they have a thousand microservice servers running, but they might have hundreds of application servers in each service pulling from the same queue.
- DasIch 8y agoWhat you need to keep in mind is that micro services have a huge fixed cost but the marginal cost of adding a new one is small. In other words: Creating or migrating to a micro service architecture is very expensive but once it’s in place, adding a new micro service is trivial. In Zalando the goal is that you can do so within half an hour, that is take an idea, implement it and deploy it to production. This leads to architectural decisions no sane person would make at a smaller company. For example let’s say you get data from an external company via SFTP and you make it internally available, so what do you do? 1. You create a micro service that polls the SFTP of the supplier for new files and sticks them into an S3 bucket 2. You create a micro service that takes the files from S3, parses, transforms into JSON and publishes events to Kafka. 3. You create a micro service that takes those events enriches them with some other data and republishes new events. ... Especially when you use Kubernetes, you also start thinking about infrastructure completely differently. Why use multiple threads or processes for example, when you can just run multiple instances of your application very cheaply and temporarily run further instances to handle background tasks?
- rossdavidh 8y agoA recurring pattern that I have noticed: 1) a company the size of Amazon, Facebook, or Google runs into a problem that comes from their gigantic scale, or the fact that they're trying to do something very different (e.g. Google Maps compared to old-style web pages) 2) Big Company comes up with a new technology to solve their problem 3) Many, many small companies that will never become big enough to need this, and are doing far less exotic things that require it, will try to make their ordinary web page into a microservice single page app with a NoSQL backend, because that's what successful companies do. Imitating success often makes sense; after all, we don't want to imitate failure. But your company is almost certainly not facing issues at all like Amazon, Facebook, or Google, and also does not have nearly as many programmers to do it.
- _pmf_ 8y agoAdding to 1): more often than not, the "scaling" issues are 95% social and 5% technical.
- GiorgioG 8y agoKubernetes comes to mind.
- mmt 8y ago> also does not have nearly as many programmers to do it. Nor the underlying infrastructure, such as, for example, physical server hardware that's a fraction of the cost of cloud.
- pmiller2 8y agoThis doesn’t only apply to technology. It applies to hiring and other organizational processes as well.
- SideburnsOfDoom 8y agoe.g. "the spotify model"
- rossdavidh 8y agoRings true. I once worked a contract at a place with proprietary hardware, that wanted their software extras to be purchased separately, and accessible through an "app store". This seemed to imply they thought somebody else would develop apps for their store, which was odd because if their proprietary hardware (which was quite expensive, justifiably so) sold 1000 units it would be considered successful. Basically nobody made apps for their app store except the people who worked for the same company that made the hardware, and I had a hard time understanding why they didn't use the (much simpler) model of "if you pay us $X more we'll throw in this bit of software". Instead, they had to develop all of the software for running and maintaining an app store, including the issues of making sure that apps uploaded to their store were not malware. Then, I realized what was going on: Apple had introduced their app store a few years before, and it was a big deal. Steve Jobs was the CEO on the cover of every magazine. The CEO looked at Apple, and said, "we must have an app store", and that was all there was to it, even though Apple sold several orders of magnitude more units, making the concept of an app store way more suitable for them than for the company I was working for.
- Sophistifunk 8y agoThis sounds like a great way to get most of the problems of monoliths and most of the problems of microservices at the same time.
- franzwong 8y agoIt is also difficult to keep a monolith as "well architected" in reality. No matter what, we should start from a "well architected" monolith first as the last part of the article says.
- twodave 8y agoWorked for a place recently (and briefly) that claimed to be building a platform on micro services. When I got there I found that while they indeed had a bunch of independent processes hanging around they all relied on a single data source. All introducing micro services accomplished was a LOT more network overhead between processes and the main (SQL) data store. When you have a bunch of processes talking to the same data store, you still have a monolith whether you want to call it that or not, because you lack the freedom to refactor your schema without changing every service that relies on the store.
- maccam94 8y agoAh yes, the distributed monolith antipattern.
- throwaway83628 8y agoMicroservices move tranasactional concerns out of the database and between service boundaries. If you ever need to transactionally write data to two different microservices, you need to roll your own rollbacks. And unless you store this rollback state in a reliable datastore, there's no going back. The tooling to do this properly, as far as my research goes, does not currently exist. I much prefer horizontally scaling a big old monolith backed by a sharding database like CockroachDb or Cassandra. Same scalability and you get to keep some ACID semantics. Concerns about code size are overblown. Facebook's mobile app is utterly massive and it still runs mostly okay even on weak devices. The maximum practical code size for a monolithic server side app will probably never be reached. We're talking maybe 100 million LoC before you run into real problems, especially if you use a VM lanuage like Java or C# where hot and cold code can be dynamically swapped out and code is stored in a very space-efficient fashion When you reach the scale where the codebase size is an issue you've probably already several rewrites to deal with such massive traffic volume.
- scarface74 8y agoFacebook's mobile app is utterly massive and it still runs mostly okay even on weak devices. I agree with your comments but this is a bad example. The Facebook app is horrible to use on high end devices. The mobile website is much more performant and has most of the core functionality. The app is actually worse in one way - they chose to use the iOS WebView that doesn’t support the native ad blocking framework. So when you click on an external page, it’s usually horrible - bacause modern web.
- jpalomaki 8y agoAnd let’s face it - you are never going to get your own rollback logic right. There will be simply too many edge cases to worry and test.
- throwaway83628 8y agoYes. That's why I'm amazed there isn't some Zookeeper ish system out there for supporting microservices. The fact is that microservice tooling is in it's infancy, and shouldn't be used in production unless you're willing to roll your own everything. I worked at a place that tried to use microservices+event sourcing+CQRS, predictably a massive disaster. I still think the monolith+distributed database will win out . I've never heard of a time when horizontal scaling was a problem not related to the databse
- adamdrake 8y agoI run into the microservices obsession very often in the high-growth startups I advise, so often that I wrote Enough With The Microservices (https://adamdrake.com/enough-with-the-microservices.html https://adamdrake.com/enough-with-the-microservices.html). I typically see people try to push microservices as a "best practice" for improving the delivery rate of software teams. They carve the codebase into separate services, but still leave all of the persistence in place so that all services are communicating with the same DB(s). The result is a tangled web of interdependent services, plus additional tooling like Docker, Kubernetes, etc. that actually makes the teams even slower than they were before. I'm glad to see us as a community getting more pragmatic about these topics, and realizing that _best practices_ are highly context dependent!
- cottsak 8y agoMicroservices pundits have strategically (or accidentally) engineered the hate for non-microservice design. They chose the term "monolith" to disparage anything that wasn't SOA. "Monolith" has a natural negative connotation so right there, you're winning at the "tech pissing fest" at the bar after work. The fact is that "monolith" applications can scale, and they can be deployed as a unit and they can still adjust to varying load using modern cloud infrastructure. The enemy to scale, productivity and success isn't "monoliths". It's complexity! And an experienced and pragmatic developer will tell you that they fight daily to avoid complexity at every turn. Yes, sometimes it's necessary, but they weigh the pros and cons on a case-by-case basis to ensure that the gradient to complexity is always as low as possible.
- edejong 8y agoAnd, how is complexity caused? What are the origins? It is caused by bringing together unrelated things. It is caused by violating the single responsibility principle. So, we isolate state from communication. We separate interface from implementation. We see as many, where others see one. We try to see the network of dependencies, where others see a single line of code. Using this new perception, we find that the large application entangles the change of (code) state of one part with every other through its deployment. The static typing guarantees only validate one specific instant in time, but nothing about the future or the past. So, take a step back and see the deployment of code as a functional part of the code. Now the monolith forms complexity and the microservice isolates it to the minimal surface. Take it one step further, and we see that the actor model is the exponent of this idea. Late binding, late dependency tracking, programming by behavioural contract.
- gfs78 8y ago>And, how is complexity caused? What are the origins? >It is caused by bringing together unrelated things. It is also caused by wrongly separating things that are closely related and putting a network or something similar in between. You cannot reduce software development to a formula.
- 8y ago
- bg4 8y agoBoth my current employer and last have fallen into this trap. Trying to do microservices with a small team and moderate to low complexity. Both built distributed monoliths with a shared core and were spending lots of money keeping it from falling over. They incur all the costs of microservices with none of the benefits. Microservices are a siren song for many small/medium sized companies. What they need is clean separation between subdomains (composing domain level API functionality together in the user level APIs to implement business logic) and clean separation between domain and infrastructure code. There are a lot less complex ways to achieve this without microservices.
- ilovecaching 8y agoI think we're just bad at predicting the future. You can go go fast and sling code at the wall because the odds of ever reaching FAANG scale is low and you want to be pragmatic, and then one day you accidentally do hit FAANG scale and you're in the news every week for security breaches and outages. You can also do everything DRY and micro-serviced from the beginning, run out of runway and crash. Or you could get to FAANG scale and realize you need to rewrite everything because you didn't foresee X, Y, Z requirements and technology has shifted 20 yards to the left. My approach is the gardener mindset. Think about organic growth up front when writing the code, but also be pragmatic and start with a "minilith" with interfaces in the right places.
- kkarakk 8y agoif you keep yourself aware from day one about the issues in your codebase/service and what doesn't scale it is not that hard to switch from monolith to microserviced is the point of this article i think. there's a difference between a conscious decision to ship a monolith and code quick "ship it now" monolith most companies won't reach FAANG,they'll be lucky to even reach preferred local service
- xab9 8y agoMicroservices are the cure for cancer.
- macca321 8y agoFor anyone trying to put together a well architected 'monolith' using C#, I can recommend https://github.com/realvizu/NsDepCop https://github.com/realvizu/NsDepCop, which allows you to set up far more granular and useful dependency rules within your code than standard project references.
- samat 8y agoThis is quite funny. People are basically saying 'think about your problem, do not follow the hype' and that feels like a revelation. Says something about state of the industry, doesn't it?
- eternalban 8y agoA reminder that the space of architectural possibilities is not merely a binary domain of {microservice, monolith}.
- he0001 8y agoI think there’s something that people mostly forget. Most of the times we are compairing microservices with monoliths but forget that almost all monoliths are much older than whatever microservice someone have recently built. Also whoever built those mostly have the luxury of not making the inevitable mistakes you did when you built the monolith. So saying that microservice is better than a crappy monolith is kind of not true. You can argue all you want about whatever style but anything well build is still good. And it’s easy to fuck things up in both scenarios.
- tvon 8y agoWhat "well-architected" system is not okay?
- tomerbd 8y agoDidn't he say he runs the async queue consumer in another process? Doesn't it make it practically another "micro service"?
- cristianklein 8y agoI don't get it. The article argues that a "good monolith" is composed of a code base + RabbitMQ deployed in Docker. The code base probably needs a database too, let's say MySQL. You probably also need to serve static assets (JS and friends), so an nginx container might be handy. Isn't this already an application composed of four micro-services: three micro-services are 3rd-party, while one is developed in-house?