skysight-inc/HackerNews huggingface dataset:
The Violent Shootout That Led to Daryl Hall and John Oates Joining Forces
Security alert: Impersonation of Robert Half employees
...not if you live and breathe shell scripts, no. But most people coming from other programming languages first need to understand the concept of whitespace being significant, and even if they do, it's easy to insert a space accidentally. In this case, if you get this error message, you would probably first look at the part in the "$(...)" (which, you think, is the only thing resembling a "command" on that line) and wonder why on earth it doesn't work, overlooking the problem slightly to the left of it.
I think there's a deeper problem with development tools in general:

There is no tool that goes from 0 to 100.

The tools you listed (I'd also add Excel) were great for people starting out, people who had an itch to scratch, people solving a problem. But inevitably, the programs they made worked too well, they got adopted, got added features, became mission-critical, and now outgrow the tool they were written in. And that's when you get the "nerds asking for complexity". Those people didn't start out nerds, they started out as users solving a problem, but now their little "make a formatted report out of this Excel sheet" tool is running the whole companies realtime sales forecasting and they scaled up along with the project.

I think the plan with VB.NET was that ("start out with VB and if you need it you can seamlessly graduate to C#!"), and Chris Lattner planned the same thing with Swift ("it will replace Python!") but none of those plans were ever carried out properly.
This is a usage of the term "localhost" with which I was previously unfamiliar.
A lot of microservices introduce unnecessary complexity.

Erlang and Elixir are unusual in that you can have independent “microservices” running within a monolith.
I moved from backend to frontend years ago, when "hype-driven mess" was a much more accurate description of the field than it is today. There's simply many more interesting challenges in web application front-ends than backends, especially if you need spacial design- things where canvas or webgl excel.

Comparatively, there are far fewer backend positions available that are more than basic CRUD, even if it those CRUD operations are gussied up with a bunch of needless complexity juggling sources of truth across a bunch of different services.

There's plenty of drudgery out there, and some interesting work in every field, but on the whole I personally have found frontend product development- product configurators for engineering / manufacturing, network visualization, visual design tool development, and data driven interfaces to be more fulfilling work.

To each their own, but maybe you might want to be a little more aware of the people that you work with when you feel like saying something condescending.

Edit: FWIW, you'd have to be blind to not see hype driven development in backend, especially in HN. "Rewrite it in rust" is the meme that continues to keep on giving.
The real problem was worse than that: it was not a technical, but a legal one: Licensing!

You need to buy CALs for every concurrent user (yes, not only SMB/terminal services users) was the way to go according to some MS license experts, and the licensing was totally incomprehensible, as is today. No wonder most didn't want to risk building a business on these maybe not so solid foundations.

Still I only dare using asp.net for serving public webpages from Linux.

Of course the technical problems were also present, but many didn't even get to think of that as the BSA bullying was keeping them away already.
Elizabeth Warren demands probes of Elon Musk, SpaceX after Ukraine revelations
I dunno, weather modification has been going on since at least the 80s and it’s pretty unnoticeable. I don’t see how we can peacefully stop China and Africa from burning coal, so I’m more interested in unilateral, noncoercive solutions.
Each service is authoritative on its own data, and it works neatly. Any medium to large size system is going to have natural places to separate that, or else will buckle under complexity or even hardware constraints if you try to keep it all in one DB. I've seen it repeatedly.
i 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.
What if the fire is in the hallway, or your kids are in the room?
Robinson Crusoe Walks Into a Bar: A literary scholar and an improbable lawsuit
I tried it out and followed the entire tutorial, but the compulsory 'anvil' branding on every free published app kinda killed it for me.

VB never had that.
i mean we still have nuclear bombs. maybe nuclear bombs are our generation's nuclear bomb
> the most recent decision that it was in fact unconstitutional.

This is not really what the decision states. The government can request all it wants but it cannot partake in "threatening, pressuring, or coercing social-media companies in any manner to remove, delete, suppress, or reduce posted content of postings containing protected free speech".

I'm personally OK with the government requesting things to be moderated; I'm not OK with the aforementioned methods if the request isn't backed by law.
The 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...
You would get more possibilities if you allowed "eighteen" instead of "one, eight"
Maybe it’s something I picked up from AnandTech. Yes, I meant the ROB size.
If that's the experience then you're doing services wrong. Each service should have its own datastore and a single API. The interface between services should be a single connection.

There should be maybe one meeting where the caller defines what they need the service to return to them.
which is the main step on the pathway to hell

At the point where you have to write an API call instead of simply joining to a table, you have introduced orders of magnitude more complexity, failure points, testing challenges, race conditions, coherency issues, code duplication etc into your system.

I don't mind stateless microservices too much. This forms more of a hub and spoke model (many services talking to 1 database). But the minute you bring separate state into the equation it's a chaos factory.
It 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 =)
Dutch Consumers' association takes Google to court for violating privacy law
Shouldn't it be n(n-1)/2 coordination. Assuming you mean communication channels?
any specifics that you can provide? in general I'm pretty skeptical of this idea that only medical professionals are useful for such information, but I'd like to hear concrete examples you have
An Apollo inspired web viewer for Reddit
Add data complexity to that (consistency)
"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.
Yep, I work in a large org that used to be a monolith (which means single DB really). Was a mess for the reasons you'd expect. Even our subteam of 10 needs to split things up more.
There'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?"
I started with that approach actually. It turned untenable after a while. It's just much nicer to have the documentation just a part of your normal test suite without any preprocessing. That also means you get coverage in the normal way too.
A 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.
Microservices 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.
If you have centralized data then you have broken the abstraction and are in for a world of hurt. You shouldn't need centralized data, just a service front door where that service is the master of that part of the data.
This 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.
If 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.
Could you name one concretely and show how a suite will do this?
I thought that general warrants were illegal and what we fought a revolution to abolish?
> I'm particularly a fan of the PGP word list

As a New Zealander, the PGP list is unfriendly because there are plenty of words that are hard to spell, or are too US centric.

dogsled (contains silent d, and sleigh might be a British spelling)

Galveston (I've never heard of the place)

Geiger (easy to type i before e - unobvious)

Wichita (I would have guessed the spelling began with which or witch)

And why did the designers not make the words have some connection to the numbers e.g. there are 12 even and 12 odd words beginning with E - add 16 more E words and you could use E words for E0 to EF. Redundant encoding like that helps humans (and would help when scanning for errors or matches too)

I imagine it is even harder for ESOL people from other countries! I am sure the UI has completion to help - but I wouldn't recommend using that list for anything except a pure US audience.
While Star Trek releasing new series every year including cartoons, Stargate didn't release anything. It has so much potential and large fanbase (myself included).
But we don’t have the Cold War. Anyway I think the chipsets are/will be our generation nuclear bombs but the fast fashion is a serious issue!
I did when I was broke and depressed and trying out new games. Got so hooked on it, that I ended up buying myself and a few copies for friends. But the quality of the game is what converted from being a pirate, but it didn’t stop me from being a pirate in the first place.

The difference is the value adding behaviour added by factorio vs the rent-seeking behaviour from every other game.
WSJ interviews Elon Musk biographer Walter Isaacson Sep 11, 2023 (10:29)[video]
One of our projects has ~15 backend engineers and ~30 microservices. It also requires a separate platform team. A k8s cluster with several nodes. It has incidents like every week because the whole thing is like a house of cards. A small feature requires changes in ~5 microservices and a lot of coordination between the teams. They always need to think about things like circuit breakers, timeouts, APIs (schema synchronization, versioning), event queues, distributed transactions, sagas, distributed locking, k8s configs, Git repository management, distributed tracing etc. etc.

On the other hand, there's another project, which is a monolith. Around ~15 engineers. Incidents happen very rarely. The infrastructure is simple: just one beefy server without k8s (but there's a standby replica of course), so the team often does maintenance of the server on their own instead of a separate SRE/production team. The monolith is modular so it enjoys same advantages as microservices when it comes to module isolation etc. Highload functionality is moved to separate Go services only when needed (currently 2 or 3 satellite microservices). All changes happen in the same codebase so features are released faster and it's easier to reason about.

I'm currently on the second project and whenever I attend architecture reviews of the first project, I'm shocked how overcomplicated the first project has become. A simple addition of a new object property can end up in 5-10 engineers arguing for hours whose microservices are affected and how they should best communicate.
I've been tooting this horn for months now and it still comes up in just about every PR review, despite trying to explain how log messages being static strings allow you to easily aggregate them so you can do further filtering based on separate fields containing runtime calculated values. It seems the allure of just shoving everything into a single message string is too strong.
I 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. :\
As 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...
Any real benchmarks with version 1.0?

Has anybody replaced everything with Bun in their 100 dependency project with a loose scaffolding of a deprecated node version due to some crucial dependency

This is the kind of thing I want to see even before using bun in a greenfield project
Now you have a pretty good idea how blind people must feel. Yes, a good audiobook should be read by a human. But if you dont have that, speech synthesis is the best or even only thing you can get. And then, many years later, you read a post like yours. And you realize that man is spoiled.

Signed, a blind man
After having spent a ridiculous amount of effort to get LLMs to work, I am certain they are simply predicting the next token.

If LLMs actually could reason, there is a much much wider set of applications where they would be actively used.

The term “hallucination” does us all an injustice by propagating the idea of an anthropomorphized LLMs.

Everything an LLM does is a hallucination.

You and me can make out valid patterns from invalid patterns, because we have an idea of some reality.

(Incidentally there are some very weird implications/ perspectives deriving from these 2 positions.
Eg - If you had infinite data, would a LLM ever need to calculate?)

Point being - the more intimate the use with an LLM, the more its emergent properties are non-emergent.
Me too. But it just was never enjoyable creating those UIs. I have tried almost all of them. The closest Python had to VB was Boa Constructor. It never really took off.

https://boa-constructor.sourceforge.net/Screenshots/

Python is light years ahead of VB6 in productivity in scripting, except when it comes to putting together a quick database frontend or just any other GUI app. My favorite was Delphi over VB. Nothing ever came close in Python in GUI building, even 25 years later.
Oh, that's evil.

In some places my tooling only shows 7 digits of the git SHA. I wonder how hard it would be to write something to tweak my commits until those are all the same. And I wonder how long it would take until someone noticed...
Ah, it’s you!

You’ve got a hell of a resume. And been accidentally incredibly convincing in getting many people into many early messes.

Jokes aside, thanks for at least coming around to advise startups sanely.

I’d personally never advocate for microservices until at the scale of Netflix or Amazon or Reddit, and even then only with in-house expertise at your level. Otherwise it’s a nightmare.

Thanks for everything, especially your contributions of sanity.
Can I suggest a simple fix that doesn't involve changing behavior at all but probably improves the lives of the many users who hit this?

Just add an additional line to the error message for lines that look like this pattern:

sh: 107: command not found
Did you mean "AVAR=$(... | wc -l)"?
> And then, when you start growing, that's when you break out an independently scalable part of the system into a microservice

Respectfully disagree. At this point you start refactoring your monolith into components and actually look at performance measurements via tracing.

Do not do microservices when you're growing (or ever, most of the time).

And by the love of god, don't split your data. Data is much more complex to manage than code.
> Firefox containers are great for keeping different sites, especially those notorious for tracking (e.g. Amazon, Google, LinkedIn) completely isolated from each other or from general browsing.

That was exactly my point; you're using Firefox's containers for privacy, and it actually doesn't help, at least since they deployed "Total Cookie Protection" by default:

https://blog.mozilla.org/en/products/firefox/firefox-rolls-o...

Note that other browsers have implemented similar strategies, notably Safari and Brave:

https://brave.com/privacy-updates/7-ephemeral-storage/

Also, blocking 3rd party cookies in Chrome is decent enough, as Chrome also does cache and network partitioning. The problem with blocking 3rd party cookies is that it breaks some websites, which is why something like "Total Cookie Protection" is a better strategy.
Nah but there are real instances where you have to use a different database for performance profiles.

The biggest one in web is regular entity databases vs. timeseries databases designed for analytics.

For this case entity data is just synced to to time series database every so often. Not super chaotic. It does make sense to divide services along those lines.

Though I would argue a folder still works for the web app part.
I got out in part because of this. I weathered the EJB craze somehow and microservices plus the JavaScript framework du jour was too much...
VB 5 and 6 were where things worked. They both had native compilers.
I picked up a random book in the science section of the city library today and opening it to a random page I started reading about an exciting "goldilocks" exoplanet discovery from 2015. Apparently this was the first exo-planet which had a positive spectroscopic identification of water in the atmosphere. It was a rocky world, 2 billion years old, 8 times Earth's size (mass?), on a 33 day orbit around a red dwarf. K-something-or-other. The book said the really exciting discoveries will happen when Webb comes online in 2021. The link is down, but someone mentions this planet is 8 x Earth size down thread. I wonder if it's the same planet?
Agreed. 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.
So here we are. A rapidly closing actionable window before the chain effects eat up all the budget remaining. And at the helm a paßt generation frozen in fear.
Been 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.
huh, I didn't know about this! thanks!
Having worked for 10 years on both Delphi and VS, I understand the experience you are talking about. Having the ability to draw UI is amazing, and super productive. For business applications, it is amazing.

However, I still remember at around 2002 that we where asked to build specific custom user experiences, I think it was around reports, and using VB or Delphi was a lot of programming using draw commands... while using HTML and CSS it was fairly easy, even with the browser differences of CSS.

Any custom component in VS or Delphi (I am talking atomic components, not composite) requires using basic draw commands, and a lot of them.

The end result was that both platforms are not as expressive in terms of UI as the web, you cannot compare basic draw commands to structured CSS.
Open-source web Gaussian Viewer
Code: https://github.com/dylanebert/gaussian-viewer
Demo: https://huggingface.co/spaces/dylanebert/gaussian-viewer
> there has to be a "cross-functional" meeting between teams and a complicated communication layer between the systems

Of all the things wrong with micro-services this isn't one of them.

The "complicated" communication layer is always either REST/JSON or GRPC.

Both of which are simple, easy to debug, proven and require nothing more than a simple discussion over an API contract.
It is fairly good for interactive usage, there are aliases for common commands, case-insensitivity, tab completion etc.