sine

I have a few things in my reading backlog about bullshit. I think that it tends to be trivialized in social discurse. It honestly feels like the patterns of bullshit exploit built in biases we have.

This is my future starting point for when I leave some room to this topic: https://en.wikipedia.org/wiki/On_Bullshit

LLMs in particular seem well fitted to extracting semantically correct insights from unstructured data. When it comes to observability we're in a better spot; since we have discrete structured data, which makes it easy to build rules and logic on top of it. I don't think this kind of tooling will benefit much from recent advances. If anybody has anything worth being shown I'd love to check it out.

On the contrary, I think that the left piece of code is not building constrains prematurely and actually enables you to modularize it away when needed.

Sure, if the logic grows, if it needs to scale, if the team increases in size... then it makes sense to modularize it. But building something from the very beginning to achieve that is going to impose constraints that make it harder to reason about and harder to refactor; you'll have to break down the previous structures and boundaries built by the function heavy example, which will probably introduce needless indirections.

I get nothing. So after a while I told my bosses I would simply stop doing it, since the work to compensate us was still "in progress". It helped the rest of the team get a free day per on call week, which I guess is something, but still not enough for me personally.

I told them I wasn't even sure it was legal in my country (Spain) which I guess they didn't even discuss with legal, or legal didn't even blink.

Is this "experienced devs" or "incoherent ramblings from a teenager"?

Aaaahh so libuv actually runs a thread pool, TIL. I'm another victim of internet propaganda I guess 😅 . You know, I never actually checked libuv docs until now and they seem quite welt built.

The silliest thing I've just realized is that I knew that the first implementation of a web server in dotnet core was using libuv, and I still didn't think twice about the single threaded meme.

To make things worse consulting companies live of cheap developers (like interns) and Microsoft and their platform makes things easier for anyone to code and deploy

You're saying this as it is a bad thing when it is not though; better defined APIs and ecosystems that lift cognitive load from you is always a good thing, there is no way to spin that as a negative.

I think dotnet offers an incredibly good ecosystem for development, and I say this as someone that wants to jump ship and change the stack. What pains me the most about the stack is nothing technical. It's not even the past predatory moves of microsoft, but the developer culture that surrounds it. Most dotnet devs I've worked with and talked to seem to be people that simply use visual studio as a window to the rest of the world. They tend to have very poor knowledge about almost everything with barely any fundamentals.

Regarding your open source point I'm not sure I follow, I think everything we use at work is open source already. Everything is on github and there are quite a lot of discussions in how to steer the language and ecosystem being made in the wide open. It reminds me of the openjdk and python ecosystems.

Thousands of requests per minute can mean many things so maybe you're referring to several hundred requests per minute, but one of our services at work gets 300 requests/second which is ~18K requests per minute and it's really not that much. We're using pretty cheap cloud services. Even thrice the traffic is pretty much a slow walk for your average production-grade web framework.

Web frameworks are built to support an insane amount of incoming requests, including node. The issue with node is the single threading and having to scale with worker threads AFAIK.