13 ms·
Death by a Thousand Microservices
- new_here 3y agoPosts laden with cynicism are always popular on HN. Gets boring after a while. Was hoping for a more measured take on a genuine issue like this.
- corethree 3y agoI'm actually sick of the apples and oranges view point. There's always someone saying that everything is a different tool in the toolbox. The reality is some tools are honest to god pieces of shit. That's where the interesting content is. The whole fair and balanced viewpoint is played out, boring and obvious.
- hughesjj 3y agoThere's always something hot to hate on. I'm getting flashbacks to the days where everyone was going "nosql is trash" because they all cargo culted to mongodb back in the day and then tried to do olap on it. Heck, this isn't even the first time SOA has been in the frame of hate. Member SOAP? Member how everyone more or less jumps between doing everything on the server vs everything on the client every year? We've been having that battle ever since networking or things clients have been a thing, the "sportsification" of that dichotomy is older than I am. I like the other person's take in this thread about how you can largely get the semantic benefits of micro services by making a well crafted monolith. I honestly agree, but I think the followup is "aren't people who poorly break up service boundaries going to go do regardless if the interface is a network endpoint or a function call/dependency injected class?"
- throwaway_036 3y ago> "aren't people who poorly break up service boundaries going to go do regardless if the interface is a network endpoint or a function call/dependency injected class?" Today there are several tools we can use that enforces boundaries in a monolith (Spring Modulith for example). If the project uses one of these tools, it is harder to accidentally cross boundaries and you get many of the same benefits as you get with a micro service. The big advantage is that if you find out that you made a mistake, your only dependencies are within the same service and is easier to refactor. In a micro service oriented architecture, changes might impact several services and teams that needs to be coordinated. I'm not saying that refactoring a monolith can't be time consuming, but you have at least a better control of the flow of data between modules.
- smokel 3y agoAn interesting angle would be how to get out of this mess. Here's one: In politics we see national and supranational governments take on the job of making large decisions. Style guides and best practices on whether to use microservices or not are, at best, made at a company level. Would it be interesting if these architecture decisions were made, or at least kept in check by a body that is larger than a company? Perhaps we could have some laws that dictate that you must (at least partially) understand how software works before you can buy it. Especially for government contracts.
- threeseed 3y agoJust a lesson in life. The second you think you are smarter and more informed than the people on the ground is the second you revealed yourself to be a fool. Because having spent decades working for government and enterprises I can assure you that we aren't all stupid and need laws to protect us from ourselves. Instead we are often placed in really challenging and unique circumstances that drive the architecture and design of what gets built. For example micro-services often works well in places where you have distributed teams that for security, governance or logistical reasons need to work independently and can't collaborate effectively with a monolith architecture. Or where certain components e.g. authentication, payments need a hard separation from the rest of the platform.
- smokel 3y agoHm, your ad hominem isn't really called for. Obviously not all in government are stupid, I was not implying this. I was rather suggesting that some are, and that something might be done to avoid problems with that. Also, microservices can be great, but when used in the wrong context, obviously are not. We are not discussing that either. Edit: perhaps you may have misunderstood my comment, and that may be due to my clumsy way of stating it. I was actually suggesting that companies learn from governments.
- guideamigo_com 3y agoFWIW, Google and Facebook are mostly monoliths and not microservices.
- gigatexal 3y agoI thought Google at least was a bunch of micro services which is why they needed something like Borg and eventually open sourced a version of it called K8s.
- guideamigo_com 3y agoTotal BS. Google has tons of services. They are lots of them but they don't have a `fileRead` service and `fileWrite` service. Rather, they have a `gfs` service that can read/write/modify etc. everything related to files.
- tra3 3y agoThere was a paper published about facebooks infrastructure: https://www.usenix.org/system/files/atc23-huye.pdf https://www.usenix.org/system/files/atc23-huye.pdf > Scale is measured in millions of instances: On 2022/12/21, the microservice topology contained 18,500 active services and over 12 million service instances. They do go on to say that microservice as a concept is poorly defined. Are you suggesting that they mostly have 18500 of what we’d normally consider monoliths?
- guideamigo_com 3y agoProbably some unit inside Meta. Most of Facebook backend was a deployed as a single unit.
- andrewstuart 3y agoMicroservices you trade application complexity for devops complexity. My theory is to make devops as simple as possible and push complexity into application code. This includes a rule to use cloud VMs but use the minimum possible cloud services, ideally none, especially not things like lambda/ cloud functions.
- corethree 3y ago>Microservices you trade application complexity for devops complexity. There's a second trade off. Overall complexity. The application as a whole is more complex when split into two than when existing as one. So three things happen: 1. Complexity of the individual microservices goes down. 2. Dev ops complexity goes up. 3. Overall complexity of the entire system in general goes up.
- aledalgrande 3y agoAdd data complexity to that (consistency)
- andrewstuart 3y agoYeah great point. Then trying to work out where the problem is spans both DevOps and development and suddenly you are in a world of hurt.
- hosh 3y agoA lot of microservices introduce unnecessary complexity. Erlang and Elixir are unusual in that you can have independent “microservices” running within a monolith.
- Maxion 3y agoI am literally working on a project where the backend team consists of three coders, and the backend currently consists 33 microservices. Common tasks for this platform involves calling around 7+ microservices. Thankfully I am working on the frontend side of things, but this is going to be hell when when we launch.
- ttyyzz 3y agoYup. Are you using grphql+federation?
- no_butterscotch 3y agoDo you think GraphQL has contributed to more microservice driven development?
- ttyyzz 3y agoYes, not in a bad way. I love graphql to be honest. Federation (using Apollo) is awesome.
- Maxion 3y agoLOL no, we're using websockets but doing REST-like requests over it. It's fun!
- ttyyzz 3y agoSounds like you're making it hard for yourselves on purpose. May I ask why you (the team) chose this over other technology and what was the decision process at the start the project?
- guideamigo_com 3y agoI once saw 5 backend engineers, 100 AWS lambdas, and 30+ GitHub repos! Awesome job security for everyone.
- 3y ago
- chronid 3y agoI have been fighting this in my current position, with some success with some teams and far less success with others (who are now fighting with the distributed monolith they have created). Ironically the ex-faanmg folks are all pro-monolith. I think most people fail to realize microservices are what you get from an iterative process. You pull out of the monolith the things you need to scale eventually. Microservices need plenty of basic infrastructure that you don't want to mantain unless you need to. Most companies don't have an adequate platform to support the pattern anyway.
- deleted 3y ago[deleted]
- EricDeb 3y agoAs with a lot of things I find the answer is usually somewhere in the middle. Break out larger chunks when it makes sense.
- threeseed 3y agoUnfortunately in the middle where the answer is pragmatic and nuanced isn't clickbait enough.
- renegade-otter 3y agoDidn't I mention the Citadel pattern, "trunk and branches"? Neither did I suggest that somehow starting with a monolith will force you to write better code. But it will definitely be easier to debug and refactor by those who come after.
- baz00 3y agoMicroservices is mostly an RDD (Resume Driven Development) practice I've found. Really, as the article says correctly and hilariously, unless you're a greenfield or exceptionally large, you end up with a fleet of shitty golf carts. My personal anecdote is, watching from the sidelines with face cupped in hands, watching a monolith being broken into hundreds of microservices at the cost of decreasing performance, increasing complexity and 90% of the traffic still hitting the monolith. Of course there's no time to do anything for the customers any more because everyone is updating software versions in all the microservices and promoting that "it'll all be fine if we just move one more thing to a microservice". The architectural vision will be complete in 2130 at this rate. I want out from this demented ego driven fashion show.
- readthenotes1 3y agoI got out in part because of this. I weathered the EJB craze somehow and microservices plus the JavaScript framework du jour was too much...
- jack_riminton 3y agoEJB?
- m0llusk 3y agoEnterprise Java Beans, apparently now called Jakarta Enterprise Beans
- est 3y agoMicroservices was literally invented by a software outsourcing company. Why make only one service when you can bill more.
- wiradikusuma 3y agoAnd cloud provider
- deleted 3y ago
- synack 3y agoMicroservices are a solution to a social problem, not a technical one. A team of N engineers requires N² coordination. Large teams get mired in endless meetings, email, design reviews. Small teams are more effective, but struggle to maintain large systems. Splitting a system into subsystems allows each team to focus on their piece of the puzzle while minimizing the amount of peer-to-peer coordination. Yes, microservices add complexity and overhead, but this approach enables a large organization to build and iterate on large systems quickly.
- meowtimemania 3y agoif you have a well modularized monolith, you can get best of both worlds.
- synack 3y agoAgreed! Software modules and libraries can achieve the same independence of subsystems without implying a network topology.
- jayd16 3y agoNot really. You can't really reduce the blast radius of crashes or bad deployments. You need to have the discipline of a good CI/CD instead of siloed but decoupled workflows. Just keeping things neat doesn't go nearly as far as a separate process on separate machines. Monolith might be better but I don't think it's a situation where you can have it all.
- aidos 3y agoThis argument always confuses me. It depends on what you’re doing but if you’re doing web services, as most here are, the crash is limited to the request being served. The blast radius is a single request, right? In every likelihood it _is_ a separate process on a separate machine.
- threeseed 3y ago
- yieldcrv 3y agoThe small org I work for has two distinct AWS accounts and nobody knows whats in each one, let alone whats in the regions for each one. Everyone is an IAM user that a third party IT company creates after emailing helpdesk a few business days prior. both AWS Accounts have a bunch of lambdas randomly doing necessary things in a variety of our development environments, but mostly production a single AWS account is fully capable of catering to multiple development environments this is hilariously Byzantine
- CraigJPerry 3y agoThis article is off the rails (to borrow the authors amtrak metaphor). The author posits that if you make pile of crap microservices then all you had to do instead was make a monolith and magically it’ll all be fine. You can put the same kind of design and engineering work in that results in a pile of crap microservices but if you target a monolith instead then you’ll be golden. The author enjoys stroking his own ego as he goes (the comment about full stack js devs for example). And yet, there’s very little here in terms of actual engineering. Want some measurements or some data to back up the waffle? Well the author says tough! You just get a diatribe instead. Keeping the cost to change a system low by managing complexity is a fine goal, but that’s not what’s being proposed here. This article could have been better if it recognised this. This article could have been better if it gave some data - hell even anecdata, a single motivating example, would have been a start. On my team, I’ll take on a bright enthusiastic front end dev who decided they want to spread their wings and grow into a full stack dev over someone who believes they already know everything and has no growing left to do.
- bradhe 3y agoAgreed the dichotomy presented is so reductive that it makes you question the author’s credibility. Any architecture that isn’t well maintained will become crushing over time. Ask me how I know.
- ConcernedCoder 3y agoupvoted, but honestly, the other side of that coin is: "The author posits that if you make pile of crap monolith then all you had to do instead was make microservices and magically it’ll all be fine."
- nelsonic 3y agoJust use Elixir/Phoenix and get all the scaling benefits of Microservices running seamlessly across datacenters while maintaining the sanity running a single app on your localhost that is fast to test, easy to reason about and deploy! Having worked in several places that adopted Microservices with nowhere near the Netflix or Uber scale just because it's trendy I can attest to the mess and glacial pace of both learning and development for new team members. If you want to move fast and make something people want, don't pretend you need "webscale", you don't. You're building an apartment block for a few people not a city for millions. The beauty of Erlang/OTP is that it's designed to scale to millions without any extra effort from the individual contributors or fancy DevOps.
- bsaul 3y agoi don't see how erlang / otp or elixir / phoenix is relevant to solve the problem most companies are facing when hitting their first "web scale" problem : bottleneck at the DB level.
- nelsonic 3y agoAgreed. The DB is the bottleneck way before the code architecture. But that is a "solved" problem from a deployment perspective. All the Cloud providers have managed Postgres that scales to petabytes and millions of transactions per second. And the part being discussed in the article is the Microservices. Where Elixir/Phoenix shines at delivering the benefits of Microservices i.e. scaling a specific function in your codebase to multiple processors/instances while still being easy+fast to run on a single Dev machine without hundreds of Docker processes.
- tacker2000 3y agoSorry but what are you talking about? Microservices in a monolith without containers? How does that even work?
- nelsonic 3y agoErlang/OTP (and therefore all BEAM Languages such as Elixir) have a supervision tree which means that each module in a monolithic application can be run independently in as many processors/machines as required. Essentially you get Kubernetes + Docker for free (virtually zero overhead) inside the Erlang VM. See: https://blog.appsignal.com/2021/08/23/using-supervisors-to-organize-your-elixir-application.html https://blog.appsignal.com/2021/08/23/using-supervisors-to-o...
- jedberg 3y agoI am one of the biggest proponents of microservices. I helped build the platform at Netflix, I've literally traveled around the world extolling the virtues of microservices. But I also advise a lot of startups, and you know what I tell them nearly every time? Build a monolith. It's so much easier to start out with one codebase and one database, and that will scale for a while. Especially if you use a key/value store like DynamoDB (although you will lose relational functionality that can be helpful at the start). And did you know that you can deploy a monolith to Lambda and still get all the benefits of Lambda without building services? And then, when you start growing, that's when you break out an independently scalable part of the system into a microservice (with it's own data store!). The one that may need to scale independently, or that you want to be able to deploy separately. Microservices takes at least 25% of your engineering time just maintaining the platform. It's not worth it unless you can recoup that 25% in efficiency.
- crooked-v 3y ago"A while" is underselling it. As long as you have people who are half-decent with SQL, "just put Postgres on a big db server" will get you to 50 million row tables before you have to start thinking about even hiring a real DBA.
- jedberg 3y agoTrue. "While" for some large value of time. And if you set up the auto-vacuumer correctly from the start, you can go even further!
- zarzavat 3y agoMicroservices are a bit like NoSQL DBs. There is nothing intrinsically wrong with the technology, it’s just overused. Many users of microservices would be better off with a monolith. Many users of NoSQL DBs would be better off with Postgres.
- tzahifadida 3y agoThe name microservice is a fanatical view of how a service should work. That is the problem. If you say you made a service, then it is not a "micro"-service, so you are lacking "experience" with microservices :) Therefor we must build microservices to have jobs. In reality, you need services that are engineered properly. They can be monolith or not, can share databases or not, can live on the same server or not... depends on the situation. But, as soon as you say the work "micro"service, you are doomed because it won't be a microservice if it does not adhere to millions of articles on the internet saying how to it should behave...
- Joel_Mckay 3y agoIt is true anything can be done poorly, for example an article 84.2% LLM lexical barf people may assume as meaningful. I am sure there is points in the article someplace, but it is hard to resolve with all the hypocritical half-digested corn chunks. Have a glorious day =)
- ansmithz42 3y agoA post like this pops up every few months arguing one way or the other. I have lived in absolute nightmare monolith systems with so much cyclic dependency that you couldn't move without breaking something. So monolith isn't the answer. I have also seen many instances where people have completely missed the underlying principles of microservices and have ended up with an equal nightmare. Neither is a hero or panacea, what matters is to understand what you are building and why and get the interfaces correct. Then understand the principles of different architectures before moving forward. If you fail on this, you get predictably a nightmare. There is plenty of nightmare code sitting on this planet everywhere we look. My recommendation isn't to vilify either architecture but to understand their strengths and weaknesses.
- antonvs 3y agoI agree. What’s the answer to the question “monolith or microservice”? The answer is “architecture”.
- mattgreenrocks 3y ago“Architecture” and “software design” are seen as antiquated, but discussing microservices and monorepos are somehow seen as relevant and important.
- fendy3002 3y agoIf you have an expert in design / architecture and know the domain problem / scope / boundaries, go for microservice. Otherwise, monolith. A good microservice is better than a good monolith since the boundaries are clearer. However a bad microservice are many times worse than bad monolith since on top of the wrong scope, intertwined boundaries and other problem from bad design that exists in monolith, now you're faced with additional infra challenges.
- cfeduke 3y agoI feel this, working on a small team moving things to microservices. My primary problem is observability. It's become a huge chore figuring what, exactly, is going wrong in production when something goes wrong. It's not enough to tail the logs of some distributed application, I need to tail the logs of several distributed applications where there messages are interspersed with one another. I suppose when we get some way to visualize these traces - tooling - it'll be okay. But, small team, limited human bandwidth, and we don't have this tooling in place yet. The monolith, in contrast, had NewRelic integrated years ago. There were performance problems with this monolith which have been mostly solved through indexes and a couple of materialized views. Trivial to figure out what is going wrong. The code may be old and full of race conditions, but solving problems isn't difficult. I dread dealing with multiple separate database instances each backing their own microservice when it comes time to upgrade those databases instances. I was hoping for a single database instance with multiple databases, but that particular architecture isn't on the menu. :\
- antonvs 3y agoAre you not using cloud? Because the cloud providers provide centralized logging, so all you need to do is pass a request id between services and include that I’d in log entries, and you can trace requests across services.
- jskrablin 3y agoTake a look at the OTEL (Open Telemetry) tooling and libraries. Or Grafana stack/offering with Prometheus, Tempo and Loki. Centralized logging and service calls/code execution tracing is not exactly new. It is often an afterthought.. and then you get yourself is this kinds of unpleasant situations. And since you didn't implement correct tooling from the start, your team is even smaller and more limited... because you have little to zero idea on what your services are up to. As per db instances... you upgrade them one by one. Unless there's some really bad bugs present (security or otherwise) there's no rush in upgrading stuff just because.
- mdtrooper 3y agoAs other gifts of computers field: death by a thousand tables in DB, death by a thousand class in Java, death by a thousand tickets in Jira/Redmine/Bugtracker/Gitlab..., death by a thousand "go to" in Basic...
- molly0 3y agoBeen working for 6 month at a company with ~150 engineers that uses Microservices. As a simple software engineer I love it, It allowed me to easily get right in to parts of the system and conceptually understand the boundaries between different systems and business unites. But it sure adds complexity - complexity that I fortunately do not need to deal with... Yet.
- bryanph_ 3y agoI don't quite understand the mentioning of node at the start of the article as a cause of this. You can write a monolith in node just as well as you can write a web of microservices. That said I agree with the sentiment of this article, it's very frustrating to deal with in any company. Especially when these microservices aren't versioned under the same repo and/or are hosted at different providers causing unnecessary latency.
- bradhe 3y agoNode is just the whipping boy for the old guys who are afraid of 2023. I say this as an old guy.
- rahen 3y agoHow would you sell Node to other old guys? Especially compared to Go. I try to favor simple, efficient software. I used to dislike PHP because it was so messy and inefficient, until newer frameworks like Django made it look like it was slim and snappy. Maybe, in this race to the bottom, Node stands out in a way I hadn't seen, so I'm genuinely interested.
- Cyphase 3y agoDid you mean Python, or did you mean Laravel?
- BackBlast 3y ago> How would you sell Node to other old guys? Especially compared to Go. JavaScript has a huge business case in the front-end. Going another direction is possible, but you're really fighting against the grain to do so. Go node/bun/deno and you can build back-end and front-end with one language. This has pretty significant advantages. Particularly if your goal is small teams (or solo) with "full stack" style devs. There are fewer siloed specialists required in the org. Language concepts, syntax and patterns are a significant part of the cognitive load needed to develop. If you're in a siloed org with specialists anyway, there is minimal draw. I've done things like have a backend I brought into the front end to mock an immature system. Shared code between the back end and front end for offline-first systems. You just can't do that kind of stuff when you don't share a language between front-end/back-end.
- DrDroop 3y agoI also know people that spend 40k euro a month to run the database of their rails app on the biggest instance they can find on aws. The traffic is seasonal and the workload is mostly one way payment traffic. But hey, they are still making money so good for them. I've personally been exploring a more flexible architecture for another project using a combination of cloudflare workers, storage and k/v store. The hardest thing about it currently is that you have to engineer everything yourself to be specific to your problem. Either way, both monolith and microservices have their challenges, I hope to find something that can avoid both but it feels like a stab in the dark.
- sjducb 3y agoI’ve had contracting gigs bringing down the costs of SQL DBs that cost a million per year. You can usually get costs below 200k fairly easily. - Performance tuning - Migrate old data out of the DB - Delete unused indexes - Improve queries so they return less unnecessary data The problem is usually one massive table or 2-3 unoptimised queries. No need to rewrite the application to use NoSQL With seasonal load in AWS it’s really easy to change the DB instance size manually. No need for auto scaling.
- xyst 3y agoI can agree with this sentiment now after working at a handful of companies and many interpretations of micro-services oriented architecture. The one thing I don’t miss about monoliths, especially at low budget/low rent firms, is that the project often exchanges so many hands/owners/teams between bottom bid contractors and “rockstars/ninjas”. This often leads to the usual god classes, half assed abstractions, massive utility classes, and half assed code refactors.
- yoava 3y agoHaving taken part in building the Wix microservices architecture, I have to say that I understand and accept the critique of the article. Microservices is not a magic architecture, it solves some problems with the price of others. When we stared Wix, we stared as a monolith - at 2006. In 2008 we split this monolith into two services due to different SLA - building websites and serving websites. In 2011 we stared splitting the monoliths into micro services to solve software delivery pipeline - ability to move fast and scale with number of developers. Today we have about 20,000 deployments of new software every year, with over 1000 developers. At Wix we are constantly investing a lot to maintain the microservices architecture and make it productive for our developers. We are making tools and utilities to return DRY into microservices architecture (think CDC support, GDPR support, Monitoring support, Scaling, Access Control, etc.). My takeaways - * Microservices do not come for free. You have to invest in making it work for you * When building a startup - build a monolith. Break it down later when you understand what you need. * We as an industry do not understand how to build micro services. There are a lot of fundamental aspects of microservices that are not commonly known / understood or ready as of the shelf solutions.
- chillbill 3y agoI’m aware that this is a bit controversial, but I feel like the current state of affairs when it comes to microservices is as follows: Noobs: microservices can be useful Advanced and cynical: microservices are a complexity nightmare Advanced and experienced: microservices can be useful
- weevil 3y agoThe author would disagree with you; I think they think it's more like: Node engineers: "lEt'S bUiLd SoMe MiCrOsErViCeS!!!!! YAY I'M CODING!!" Chad UNIX architect who won't code in any language that doesn't give you the tools to blow your own foot off just printing a string to stdout: "No let's keep adding functionality to this one codebase until it's as complex as a suite of microservices." (According to the author, at least.)
- bubblydoops 3y ago[dead]
- daitangio 3y agoGold rule, to start with, is 1 Microservices = 1 Team In a multivendor scenario, it could make sense to split a big monolith in say 2 or 3 components, but I have seen dozen of microservices (one of which just managed 3 read-only tables...). But if your 6-guys team ends up deploying 6+ microservices, you are doomed, in my huble opinion.
- RamblingCTO 3y agoWe have exactly two microservices atm: one sends emails, one registers users and creates a backend (one backend per customer with us). Should I hire a team just to adhere to your golden rule? I wrote them myself, no support from anyone needed, they are low maintenance. Do architecture first, have a modular monolith, if you need microservices, use 'em. The rest if this thread is just a waste of time and a bunch of strong opinions. I just hate this whole thread. Full of weird assumptions. People here don't know enough about the scenarios to hate on either solution. Do what's right for your project and don't listen to the internet. Easy as that.
- holoduke 3y agoA good maintainable software solution is always build out of relatively small and simple components with very important: clear inputs and outputs without too much sideeffect behavior. It says nothing about if its a monolith or microservice. I have seen a lot of microservice architectures so complex with 100s of layers and configurations that nobody in the company understood how it really worked. I have also seen the very same thing in large monoliths. Too big. Too complex. The discussion should be about the software component architecture. Not about ifs a monolith or microservice.
- root_axis 3y agoI don't think microservices are as common as often suggested. In my experience with small and medium sized companies, if they go SoA, its typically just "services", almost always sharing the same DB, and pretty much never "microservices". Usually it's something like: a service for the webapp, maybe an api service, a couple services for something like a job queue or sockets, possibly with the a service for compute bound tasks like media processing or reports. I've also worked at places with 50+ services working together in production, but they're rare (at small and medium sized companies).
- bubblydoops 3y ago[dead]
- mojuba 3y ago(God, how I love confirmation bias when it's my own bias.) I've been saying this for years, the microservices insanity it's just an excuse for mediocre engineers to be in demand. It is fueled by mediocrity but it is also what keeps so many tech companies going. There are simply not enough competent engineers who master UNIX and who can build beautiful minimalist systems like StackOverflow's or a bunch of others' mentioned in this article. Therefore microservices as a smoke screen for mediocrity is here to stay, it's not going away any time soon, especially considering that cloud providers like AWS promote themselves via all possible channels and encourage the decision makers to take that route anyway.
- Tade0 3y ago> I've been saying this for years, the microservices insanity it's just an excuse for mediocre engineers to be in demand. Or just inexperienced ones who want to pad their CVs. I think we failed to educate the current generation on what's important in this job.
- dan_mctree 3y agoI don't know why but no one hires or listens to the architect who recommends sticking to safe monolithic-esque systems. If you're not talking cloud and microservices and the newest unproven frameworks, you're an old fogey who needs to get with the times. Even though those types of systems are rarely the most efficient, powerful or safe systems I work for a company that builds software to be used internally by other business. We have like 200 people tops using it simultaneously with no usage spikes, a perfect environment for regular web servers as we'll never have unexpected scaling issues, yet everyone is dying to go to the cloud. Why? I think it's just because our management, programmers and even customers are convinced by cloud provider marketing that the cloud is cool
- misja111 3y agoArchitects that propose pragmatic and boring solutions are usually not hired. It's the emperor's new clothes, companies like the idea of an architect who comes with some revolutionary new concept that will lead to a breakthrough that finally will make everybody rich. If they don't understand the architect's idea, so much the better because then it must be really state of the art.
- hnpxr 3y agoIt's nice to see the trend unwinding, microservices are egregiously overused as a silver bullet for any problem (not just scaling). There are probably dozens (/s) of companies that would benefit from going all-in with microservices. Some companies would benefit from having a few microservices; but most would be more than successful running a monolith. The most significant problems with microservices arise when they're adopted too early and when data separation is not properly handled, resulting of even the simplest requests ended up querying 3-5+ microservices. Latest anecdata point: doing exactly that (unwinding microservices) in a team of 20 engineers (15 swe/5 sre) and 400+ repositories (which isn't a "wrong", but having so many different places to update, for example, Python version is nuts). The whole project is nuts. And persuading management was not an issue, it was enough to show current AWS bills and potential savings from moving from 50+ microservices to smaller numbers of consolidated services and deprecating/refactoring some features. The real challenge was persuading the engineering team to prioritize and work on this issue - which is still ongoing.
- EMM_386 3y agoI was involved in a merger with the platform I architected on one side, and a platform that does the same thing on the other side. We were told the company wanted one platform. I do everything I can to follow KISS. These are important enterprise systems that drive the entire company. I went with a front-end framework in TypeScript, C# APIs, and a relational SQL DB as the gist of it. It turned out great ... performant, reliable and the users were reporting positive feedback (this one was a recent upgrade from an older system). The other side had the same number of users, but had over 100 PHP microservices, Docker containers, queuing frameworks, and all sorts of additional technologies in the mix. It had 5 times the number of engineers on it, but was at the end of the day was functionally equivilant and had the same volume of traffic. When comparing the up-time, it was clear the microservices architecture was the main source of pain. They weren't even comparable. We are always talking about whether we're at "5 nines", and the other system was having major outages every other week. You could argue that it was a poorly architected system, and that microservices weren't the root cause, but that really wasn't the case. The entire system was based around the microservices, and they weren't working as promised. What originally was seen as separation of logic and concerns and everything else that microservices offer eventually over time became a tangled, inter-dependant system of services that were very high in bandwidth, slow in performance, difficult to maintain and bad in reliability. This isn't the first time I've seen this. I've worked with microservice architectures in other companies, and I haven't yet seen it "done right", or at least how I understand it. It always comes across as great in principle but bad in practice.
- bradhe 3y agoI work on a massive monolith that has about 800 contributors and its just as complex to add something as simple as a user’s birthday, just not all the complexity is technological. It requires “organizational alignment” since you’re touching everyone’s code. There will be endless iterations on design and review. Sign off required by at least 2 architects. It will get added to multiple planning iterations. The actual code will take an afternoon or less. We’ll have to ensure we hit out 90% test coverage during code review but because of all the tests, it’ll be too big for one PR so it will need to be broken up into multiple PRs probably landing over multiple weekly releases. To facilitate that, we’ll put it behind a feature flag (of which there are currently 13,000). Once it hits production, and the dashboards/monitoring are put in place, it will get enabled and disabled over and over again as we’re not totally sure why our birthdate feature broke the metering service, but we think that’s the root cause—need to do a few weeks of analysis. Then, finally, in a year the engineer who was tasked with it will get a good performance rating, maybe be up for a promo! Just in time for him to jump into another project that’s failing horribly headed into its 3rd year in development: Allowing the user to set their timezone.
- ramraj07 3y agoThis sounds like you work at a place that’ll bungle any tech stack paradigm.
- deterministic 3y agoThat sounds crazy. Imagine how much worse it would be if it was a microservices system!
- scrlk 3y ago"Why is it so hard to display the birthday date on the settings page? Why can't we get it done this quarter?" "Look...I'm sorry, we've been over this, it's the design of our backend." https://www.youtube.com/watch?v=y8OnoxKotPQ https://www.youtube.com/watch?v=y8OnoxKotPQ
- ris58h 3y agoTotally agree. I don't see how microservices would solve this. Also monorepository doesn't mean that service is monolith.
- fanksid 3y agoIt's always right to start with a monolithic. After all, not everyone knows what they want.
- mihaaly 3y ago“how they did things over at Google” LOL. This is how a former out of academy right into startup CTO position colleague tried to argue his choice of approach to enforce. Those were dire times, luckily I found my new place fast, just in time to avoid the spectacular implosion.
- knallfrosch 3y agoI feel that. At my shop, we have given up on debugging altogether, because the tooling simply doesn't work. To run one service on our local machine would require us to adapt the other 9 to run against this one. And god forbid you build a "feature" for the "customer." Now you have to, of course, touch at least 2 services at the same time to move more data. A breakpoint on one end is a timeout on the other. So every developer is deploying release builds (no hot reload) on a local VM, inserting console.logs, System.PrintLines() and _loggers and then reading the disparate log files. Needless to say, I'm jumping ship.
- masklinn 3y agoSounds like the third paragraph could at least be somewhat improved on by switching everything to structured logging and being able to point them all to a local aggregator. Moving everything to distributed tracing would be even better, but there’s a larger investment as the tracing metadata then has to be unified across the board to properly track requests. Would likely help more with ops than with dev but should help nonetheless, even just getting proper spanning information can provide a lot of insight into a clusterfuck. > A breakpoint on one end is a timeout on the other. No dev mode to increase or disable timeouts?
- mrelectric 3y agoTelepresence!
- angio 3y agoWe use mirrord together with a staging environment to run specific services without the need to bring up the rest of the stack locally (we have ~5 services so it wouldn't even be an issue).
- throwaway2990 3y agoI wish people would stop creating nano services, calling them micro services, then complaining about them.
- RamblingCTO 3y agoITT: people promising exactly one magic bullet for a plethora of scenarios they know nothing about
- Sohcahtoa82 3y agoI have two huge gripes that I've run into when dealing with microservices: 1. They're actually nanoservices. The article touched on this. A single function shouldn't be its own service unless it's something that requires a lot of processing, like a service that converts files from one type to another. But something like handling user registration? You don't need separate services to handle registration, login, and the forgot password flow. 2. The services are poorly named. At a previous job, we had services with names like "Kafka", "Avatar", and "Sophos" and none made sense for what they did, especially Kafka, which I expected to maybe be a wrapper around Apache Kafka? But no. It should have been called the User Preference Service, because it was simply a service for users to get/set their preferences.
- deterministic 3y agoThe worst WTF system I have ever seen in my 30+ years career was a microservices system. The best most maintainable systems I have ever worked on were all 1 million+ line monoliths. Split into N libraries with clean API’s and separate teams working on them. You have a problem so you pick microservices. Now you have N*(N-1) problems.
- beaker52 3y agoI’m currently at a place using microservices, in a monorepo, where business logic is executed in consuming services, and some business logic is in a monolithic graphql layer, that only frontend clients call. Tries all the tricks, fails at all of them. Still, it’s a profitable business. The dirty truth is that the current crop of engineers are the ones paying with their blood, sweat and tears - and I’m not sure about you, but that’s not what I signed up for as a software engineer, so we should demand better.
- bcoughlan 3y agoStarting with a monolith is nearly always great advice. However, monoliths tend towards spaghetti because it's too easy essentially to draw new lines on the architecture diagram by importing from anywhere. To scale a monolith codebase without devolving into spaghetti you need to have a well defined layered structure for modules. The other aspect is being able to hide internal code to prevent it being imported by other modules. I did a write-up a while ago about how we do this on my current project [1], and published the Maven enforcer rule and ArchUnit test example as an open source project [2]. [1] https://bcoughlan.github.io/posts/modulithic-architecture/ https://bcoughlan.github.io/posts/modulithic-architecture/ [2] https://github.com/bcoughlan/base-package-enforcer-rule/ https://github.com/bcoughlan/base-package-enforcer-rule/ https://github.com/bcoughlan/base-package-enforcer-rule/blob/main/ArchUnitExampleTest.java https://github.com/bcoughlan/base-package-enforcer-rule/blob...
- deleted 3y ago[deleted]
- tored 3y agoI wish language designers would spend more time on designing higher abstractions, like modules, rather than only low level stuff like borrow checkers and async.
- mattgreenrocks 3y agoML-style modules are pretty great. Did you have something more powerful in mind?
- simonhamp 3y agoOne of the things this article alluded to (but I didn't see it explicitly stated) as to why microservices is a default go-to architectural choice: Because then a bunch of engineers can stick it on their résumé and try to get a job at a big company I worked in a funded startup where we built a service-oriented architecture out of a few key Laravel monoliths. This was entirely manageable for a team of less than 10 engineers and scalable for the context. Because we built it as a distributed system, each of those core services was ready to handle outages. So it was extremely easy to deploy What's more, it barely cost us $20k PER YEAR to run it all But now I can't say I've worked with microservices so I'll likely not stand a chance at any of those interviews
- switch007 3y agoA common pattern I've seen is: - Current CTO/VPs built/helped build original monolith - Nobody wants to tell the CTO that their code is shit (and/or is from a different era and needs a complete overhaul), unrelated to that fact it's a monolith. CTOs are too busy doing marketing/getting funding to make a decision on microservices vs monotolith, so the newly-hired architects gets to call the shots - Everyone cheers on microservices because it fits within the story of a fast growing, serious, technical company and nobody wants to be that lone dissenting opinion/criticise the CTO. Nobody is seriously and truthfully recommending microservices because they believe them to be the best trade off and superior choice. It's because they like their job, they like hiring people, and it fits within the narrative. And it just so happens during the massive overhaul that you get to rewrite a ton of code and improve it, while just calling it a migration to microservices So it's a way of not hurting the feelings of the CTO, going along with the crowd and a way of rewriting a ton of old bad code with an excuse supported by almost everyone
- hnarayanan 3y agoOh my goodness, I feel like you’ve nailed it.
- ConcernedCoder 3y agoyou just described the last 5 years of stumbleupon...
- Attrecomet 3y agoWait, that's still around?
- crabbone 3y agoI worked there.
- kirse 3y agoNobody wants to tell the CTO that their code is shit It's a pattern because it's a factual inevitability. Whether you're an individual lead engineer or a CTO/Founder, eventually you always look back and conclude things could have been done better and watch in pleasure/horror as you reap the benefits/drawbacks of how you laid down patterns and processes that the team dutifully followed.
- rawbert 3y ago> Micrsoservices are not DRY Tell that my team mates putting all stuff into libraries because "we made that already" and building a huge distributed monolith. We combined sucessfully the worst of both worlds!
- sjducb 3y agoIt’s the whole coupling vs DRY trade off. Coupling is worse than code duplication.
- pulse7 3y agoMicroservices are often used as an excuse to be able to write part of the system (=microservice) in own technology stack and not in the one the rest of the system is already written in...
- CptKriechstrom 3y agoI don't get the hate about Microservices. Use Event Sourcing to eliminate the whole S2S Communication and gRPC to connect the Clients. Done.
- revskill 3y agoTo me, it's mostly skill issues when people couldn't extract the code into indepedent parts. The point is, make everthing as a library. It doesn't matter if microservice or monotholic, just import your library and use it.
- weevil 3y agoThis post reads like a cry for help. I don't really know what they're arguing for. Sure the broad-strokes 'microservices bad monolith good' is something I can get behind in some cases, but the slightly unhinged tirades against Node developers and the 'bloated farce' of the modern tech industry might as well be satire for all the value it contributes to debate.
- renegade-otter 3y agoDamn right it's a cry for help. I am exhausted debugging distributed systems with crap homemade tooling when I could be writing code.
- ConcernedCoder 3y agoI find it weirdly theraputic to read things like this, and reminisce about loudly proclaiming the same a decade ago while being shushed as a non-believer... Please excuse me if the paradigm of "microservices" has left a bad taste in my mouth, but I have real-world experience with the repercussions of whole-heartedly embracing the latest tech-dejour without completely understanding the tradeoffs... Many years ago I was hired at stumbleupon around the time the leading compsci doctor decided to take a working and profitable monolithic php app and turn it into a scala/java microservices architecture... in fact part of the newhire process was a weird one-on-one with said mad-compscientist where he extolled the many merits of microservices and skillfully dodged questions like "why would you build a distributed service that just adds a list of numbers?" with a bunch of "you wouldn't understand why it's so much better..." type hand-waving. Fast-forward to 30+ new hires and 4+ long years of intense development and the no-longer profitable company was left with a new slower, buggier, impossible to debug distributed hellscape... as the main designer/architect of it all decided it was a great time to take a "sabbatical"... it wasn't long after that the Nth round of investor money ran out and we were all looking for work.
- karles 3y agoWell, the idea of microservices would be to build some degree of flexibility into the setup, so that you can handle problems you don't have now, but you might have later. I understand that the Monolith - if done right - is a viable option as well. As a consultant, our customers rarely know what they want, and they can't really describe their vision, no matter how many workshops we throw at them. Microservices give us the opportunity to say "We might not know this now, but with this architecture, we won't be locked into a certain pattern or meet certain technical limitations by a monolithic approach". It seems that what you are really paying for with microservices is flexibility and maneuverability "down the line". Solving only the problems you have "here and now" with the simplest solution will also lead to technical debt.
- geewee 3y agoI don't think I agree with your thoughts. Microservice setups are generally less flexible than monolithic setups. Particularly if you get the boundaries wrong it's notoriously difficult to refactor multiple microservices, particularly if you need full uptime. For monoliths you can refactor the whole thing with editor support, and then deploy a new version. So microservices will cost more, give you less flexibility and maneuverability, at more upfront cost. It seems like the worst of both worlds.
- gehen88 3y agoWhy this is getting blamed on JavaScript / Node.js is beyond me. Microservices were/are all the rage in Java/Scala land, and seemed to initially be pushed by (Dev)Ops engineers' desire to roll their own Kubernetes cluster (or whatever came before). I've been on multiple such project and I always loathed the additional complexity (especially combined with actors/event sourcing and Cassandra). Node.js was limited to some frontend tooling that only ran locally or in CI.
- crabbone 3y agoI think the author meant "Web developers", not specifically "JavaScript developers". There's just a very big overlap between the two. So, Java and friends fits perfectly into this pattern. DevOps (saying as someone who used to be "Ops" w/o the "Dev") is also largely a Web phenomena. If you were exposed to Web development some time in your career, but then moved away from that, Kubernetes will definitely trigger PTSD in you. It's Web developers writing system software, and they don't really know how to do that.
- metalspot 3y agoservice oriented architecture is a disaster even in large companies. without a monolithic database and normalized schemas you always end up with a bespoke ad-hoc never-consistent data store. data and results are unverifiable and continually incorrect and the performance is abysmal. a really large company can waste hundreds of millions of dollars papering over the inherent deficiencies of the architecture but it is an exercise in building additional stories on a house where the ground floor is made out of cardboard that happens to be on fire. soa was created purely for business organization needs. any technical justifications are post hoc rationalization. from a technical perspective it is pure trash. a much better architecture is to keep services but have them all built on top of a single monolithic db. at scale the monolithic db can be a facade and then you disaggregate the database into horizontally scalable services so that you can scale your monolithic db facade to whatever you need.
- lhnz 3y ago> First, a whole army of developers writing Javascript for the browser > started self-identifying as “full-stack”, diving into server development > and asynchronous code. This is gatekeeping--we're all ultimately self-identifying as software engineers. But more importantly it's not correct. Many of the original engineers working with Node had non-UI backgrounds. Node.js made asynchronous programming easy and promised that you could use the same language on the back-end and front-end, which seemed like good bang-for-buck for people that wanted to focus on products. Also, not to point the blame somewhere else, but wasn't it Golang engineers that went really hard on the microservices koolaid?
- chrismsimpson 3y agoThere’s a tendency to throw the baby out with the bath water here. There’s something to be said of well partitioned services optimised for cache locality. For most start ups that may mean a small handful of services. Scale is somewhat automatically built in as you can scale up the parts of your ecosystem that have particularly hot paths. Well architectured software I’ve ever encountered adapts to need and usage over time and tends to always look unique (correspondingly to the uniqueness of the problem domain). Going ‘all in’ on any one architecture strikes me as ideological.
- harshaw 3y agoAt AWS on my service we have lots of microservices (and I think we need them at our scale), but they also share a bunch of the same code. So one problem is reasoning about when your random java library gets merged into some component and it takes a while to wind its way through pipelines and then subtely breaks something unexpected. Take a lot of engineers to deal with this architecture and I certainly wouldn't recommend it for most folks. In fact, one of the slightly hilarious things is that we started out with microservices and end up combining them together because - guess what - when you are building systems level software you really need to make inline calls instead of network calls (without timeouts, retries, circuit breakers, and all the BS). As a manager I really miss monorepos, postgres, and all the other simple stack stuff that makes developers super productive and IMO the work much more fun.
- Sosh101 3y agoPlease don't blame Microservices insanity on JavaScript and Node.
- crabbone 3y agoI'd say JavaScript and Node are responsible for a lot of evil in the world, and they definitely had a role to play in microservices popularity. Nobody was really doing microservices until there was Kubernetes. I mean, maybe some big shots who had a system similar to Kubernetes, but Kubernetes enabled newcomers with small teams to be like the "big guys". So, Kubernetes was the driver, not Node. But... Kubernetes was built by Web developers (unlike Docker for example). Coming from systems background it's painfully obvious that people who built Kubernetes didn't know how to system. And there are a lot of indicators that they, essentially, were building a system to support unwieldy Web site deployments. Kubernetes was the system built by DevOps, who, unsurprisingly are the result of Web development. The whole idea of DevOps was called into existence by growing popularity of services. Instead of selling software, the market started selling service subscription: from financial perspective, subscription is hugely preferable to one-time sale. This drove a lot of products that didn't need to be services into the service space (think Google Docs, followed by Office 360, Adobe Creative Suit and so on). Frequent internal releases fuel the competition between similar services, but also necessitated DevOps. And this is how we also got "shift-left", continuous deployment, X-as-a-service etc. Web, by itself is not the reason these things appeared. It facilitated their appearance. The driver was the financial bonuses of subscription. Web was the convenient mechanism. But, this also means that Web developers were those who made it happen. They were the first and the largest group of programmers who moved into DevOps. They were the people who created Kubernetes and a lot of programs in its immediate environment. Not surprisingly, they also used the tools common in Web for their work. Had Kubernetes being started by system people, Go would've been an unlikely choice for the language (C would be the most likely candidate, followed by C++ or maybe even Python). YAML wouldn't have been the choice of configuration language (it's very common in system world to roll your own, if INI doesn't work). It's because Web developers built Kubernetes it's networking, storage, user permission model... are all super naive and wrong -- they were designed by people who used to consume them, not by people who used to develop them, and they simply didn't know how they work on a more fundamental level. A lot of complexity of Kubernetes (and by extension of the microservice world) can be explained by the lack of experience of people who built it with how system software is usually built. And, yes, Web programmers are the one responsible for it. Although, perhaps, Node specifically had little to do with it.
- deleted 3y ago[deleted]
- jroseattle 3y agoGoodness, we're still arguing about microservices? Microservices are simply another approach to solving a problem. Another tool in the toolbelt. Use it wisely, as you would any other tool in your toolbelt.
- deleted 3y ago[deleted]
- Blackstrat 3y agoMicroservices are oversold. CIOs jump on the bandwagon because they read a couple of articles on line and think magic happens. The last company, a spin off from a larger company in the financial sector, I worked for before retiremnent decided to port their existing monolith to a cloud-based, microservice platform. Did they need it? No. The total customer count was projected to be 25 million or fewer with an average active user count in the low 1000s, about 1800 when I left. But cloud/microservices were "sexier" to the ownership group whose plan was to sell it in a couple of years. Thus far they haven't succeeded and the microservice guru that succeeded me has been fired for failing to delivery a working product after three years. If a company isn't going to be operating at internet scale, e.g., NetFlix, Facebook, Amazon, there are usually better options than going all in on microservices. Then again, I've worked for companies that had no idea how many simultaneous users they had.
- highfrequency 3y agoThe cited article from Ken Kantzer is also very good: https://kenkantzer.com/learnings-from-5-years-of-tech-startup-code-audits/ https://kenkantzer.com/learnings-from-5-years-of-tech-startu... "You don’t need hundreds of engineers to build a great product. I wrote a longer piece about this, but essentially, despite the general stage of startup we audited being pretty similar, the engineering team sizes varied a lot. Surprisingly, sometimes the most impressive products with the broadest scope of features were built by the smaller teams. And it was these same “small but mighty” teams that, years later, are crushing their markets. Simple Outperformed Smart. As a self-admitted elitist, it pains me to say this, but it’s true: the startups we audited that are now doing the best usually had an almost brazenly ‘Keep It Simple’ approach to engineering. Cleverness for cleverness sake was abhorred. On the flip side, the companies where we were like ”woah, these folks are smart as hell” for the most part kind of faded. Generally, the major foot-gun (which I talk about more in a previous post on foot-guns) that got a lot of places in trouble was the premature move to microservices, architectures that relied on distributed computing, and messaging-heavy designs."
- mattgreenrocks 3y agoYup. It is completely insane that some places want 20-30 people for a CRUD website. Yes, there is domain complexity there (that’s what makes the job actually interesting, unlike the tech we have to use) but that much? Really the issue is we continually subvert engineering needs for business wants. Until that is no longer the norm the fractal of WTF will grow deeper.
- Dizzie 3y ago[flagged]
- Dizzie 3y ago[flagged]
- midwit 3y agoMaybe I’m not the ideal reader for this, but the main take away for me is I need to rename master to trunk because it makes a lot more sense.
- renegade-otter 3y agoThat was my original goal, lol.
- vinay_ys 3y agoLet's not throw the baby out with the bathwater. Distributed horizontal scaling is a necessity at any non-trivial scale. Yes, mindless cargo cult excessiveness of anything is bad. The real crime here is forgetting how to organize large codebases effectively. We used to have beautiful software frameworks that allowed things to be developed in neat little modules with interface bindings that can be turned into in-proc method invocation, or IPC invocations or RPC invocations through compile time switches to create one or more deployable binaries with neat little infrastructure for service discovery and routing, end to end tracing and profiling etc. The modules were independently verifiable for correctness and performance. Modules had semantic contracts clearly defined and their implementations could be changed transparently. We had sophisticated distributed persistence layers with MVCC, zero-cost snapshots etc. with remote addressable storage 20 years ago. Instead of scaling these patterns for web-scale with the necessary engineering discipline, we took a lot of cheap shortcuts only to pay for them 10 times over in the form of wasted dev time and hardware.
- kasdi 3y agoI’m curious, not being from this era, what are some examples of better old software than new? And why is the new one worse instead of better?
- soulchild77 3y agoIMHO, blaming the unexperienced Javascript developers is unfair, because in my experience mostly the senior Java developers were the ones jumping on the hypercomplexity infrastructure bandwagon and embracing microservices as the logical next step after wrapping design patterns with design patterns in their code bases.
- gatinsama 3y agoMicroservices = job security for years to come So please stop making these posts lol
- dahwolf 3y agoPicturing a real-world situation here in my recent past... We start with the pinnacle of engineering, a SPA, could be built in React, Vue, whichever. It loads, which on slower smartphones takes a long time as they suck in running JS. When it's booted, there's nothing there. It has to reach out for data. And so it does, to the microservice. Which might start doing something in 20ms or 200ms, it's all very intermittent due to excessive virtualization. It can't just go and return the data, no...it has to take the authentication token that was passed in and authenticate it with yet another service, which is vendor managed and even slower. Then there's rate limiting, logging, all types of overhead. Eventually, it returns 3 product rows. Sadly though, for each of the product items we have to make an individual call to get related data, part of it coming from yet another microservice. All of these calls having their own startup time, authentication and overhead. So for what one might call a classic "join", we're into multi-second territory. Which is fatal territory. Not to mention the shit state of data, as it's all no-sql garbage. Mind you, this is about 1/10th of what users are supposed to see on the initial dashboard. We're talking one tiny part of a small- to midsized "app". It all costs a fortune and it produces garbage that users hate. Old dinosaur me used to code up a CRUD app like this by the dozens. Using LAMP, .NET, whichever. Performance would be near-instant, I wouldn't allow any query response time to go over 10ms. Every part of our stack is "best-practise" and enterprise-grade. And it just doesn't fucking work. It's 10 times more expensive and 100 times slower whilst the very idea of such an app is that it's supposed to be more interactive/responsive compared to the traditional stacks. Luckily though, these services are multi-client. Except they're not, because then the mobile app team needs different data, and it's all just bolted on to the "generic" service. Services teams independence is a problem, not a solution. Plan a UI feature and good luck getting it orchestrated across teams each having their own roadmap. And let's end with comedy gold where Lamda developers now need to calculate the running costs of their logic line by line. Whoops, slightly inefficient loop, that'll be 30$ extra per month on the bill. Now "scale" that problem to dozens of such developers building hundreds of services. What a joke we've become. Distributed computing is an error, not an architecture. The point of computing is to put compute and data as closely together as possible. As the brightest minds on the planet deliver in stunning hardware advances which us software developers piss away. But hey, the God of Complexity pays well and those footing the bill have no idea what we're doing but it does sound impressive.
- weatherlight 3y agoIf you use a language on the BEAM virtual machine, like the article hints at (WhatsApp - Erlang), you get the best of both worlds. Every process is ostensibly a Microservice. So not quite the same a a Rails or Java/Spring monolith.