Terraform is proprietary. You want to the use the OpenTofu fork instead: https://opentofu.org/

Yeah, to be honest, I’ve given up on that one. “Language Server Protocol” is a classic case of Microsoft naming things.
The two differentiating words are “language” and “server”. It does not specify what kind of language is being served or what it even means to serve a language. And “server” is entirely redundant with it being a protocol. Not to mention, that “server” is the most overused word in IT and therefore virtually meaningless.
For all we know, it could be a protocol for butlers carrying French dictionaries.

So yeah, I use the acronym as its name, because it is similarly meaningful while being actually recognizable. And when I need to specify whether I’m talking about the “protocol named Language Server Protocol” or a “Language Server Protocol server” or even a “Language Server Protocol client”, I will just slap that behind the acronym and be done with it.

🫠

There’s varying takes on why folks prefer Gemini:

• HTML browsers are too complex. It is virtually impossible to implement a new one. We’ve got 2½ implementations, i.e. Blink/WebKit and Gecko, and that’s it. Yes, you can use Dillo or w3m, links and lynx to view simplistic webpages, but anyone, who actually wants to use the web with these, will quickly run into webpages they cannot view.
  With Gemini, you can use tons of clients, some of them even written in Bash, because it’s so simple, and you will not run into pages you cannot view.
• Burn the web. Some folks hold the opinion that the modern web is beyond saving, because advertisers control many central parts of it. Presumably, these days folks are also glad to be spared from AI-generated garbage. And again, you can create your own webpage that’s all smallweb with pure HTML and whatnot, but anyone who actually wants to browse these pages has an easier time finding them on Gemini.
• An own community. Of course, using a different communication protocol cuts off communication with most of humanity. But as a result, many folks on Gemini know each other and bother reading blogs that they might not have read on the HTTP side of things.
  Well, and through survivorship bias, folks on Gemini tend to be nerds who care about permacomputing and the like, so that also helps with finding folks that have similar interests, even if you might end up reading their gardening blog, due to the aforementioned point.

Lots of simpler editors gained tab completion support over the last few years, thanks to the LSP protocol. I have it in Kate, for example.

Yeah, always found that weird as a junior. I basically never touched the main-function, because well, it set up some fundamentals and then called some other function or created some objects and then I was tweaking things somewhere below that.

Now that I’m a senior and taking over the lead of projects, I’m the person that touches the main-function and others generally do not. 🥴

It was implemented as part of the X11 standard, so the concrete program would’ve been X.org…

I believe, that needs to be turned off in KDE.

I’m not sure, if this actually turns of the copying or if it just turns off the pasting, but you could try turning off this setting:

Yeah, this is probably going to sound like a truism, but to avoid shitty Scrum, you need to resist management trying to alter the processes, but you should absolutely tweak the processes to account for the needs of the devs.

Basically, yet another reporting meeting does not help deliver the software faster. But more (or less) meetings for devs to sync what they’re working on, that can help, depending on your team’s specific needs.

Ah yeah, damn, I put a different one in.

lemmy.ml has an automatic image proxy, which is in theory really cool, because it prevents requests from going out to all kinds of webpages, but sometimes it fails to process the image and I can only check after I’ve hit “Reply”…

I mean, yeah.

Yeah, when the other commenters mentioned consumer protection laws, they meant that it would be a case of false advertising.

There’s also been a similar case before, where Air Canada got sued, because their chatbot promised to a customer that he could apply for one of their bonus programs after the flight, which then got denied by Air Canada: https://www.mccarthy.ca/en/insights/blogs/techlex/moffatt-v-air-canada-misrepresentation-ai-chatbot

In that particular case, it might have helped, if the chatbot had a disclaimer that it’s lying, but only because Air Canada provided the truthful information elsewhere on their webpage. That’s not gonna be the case for such product descriptions…

There’s some “2-in-1 laptops”, which you can fold over fully:

The keyboard disables when you do that, so that you can hold it like a tablet.

But yeah, as someone else said, it still isn’t actually one hinge that goes 360°, but rather two hinges chained together.

Yeah, the latter is certainly a big part of it. The way to make it compile-safe is to use macros to generate code, so that my users can write e.g. Package::my_frontend.version and that gives them the version of their frontend package.
Writing such macros, i.e. writing code to generate code, is certainly something I haven’t done a ton of yet, because you practically cannot justify doing that in an application codebase, only in a library, so it is new stuff that I learn.

But well, you did already call it a “nice abstraction”, which is another big part where my excitement comes from and where I think, the special nerdery is necessary.
Others might build projects which are visually tangible, like a sexy GUI, or which do something tangible, for example a colleague (who I will absolutely not deny his own special nerdery) is currently building a driver for a motor. If that driver works, you can see a motor moving in the real-world. Even non-nerds can at least tell that something is happening.

But with my project, my success is that you can write Package::my_frontend instead of Package::from_str("my_frontend")?. And that if you rename the package to super_duper_frontend, that the compiler will tell you to fix the code rather than it only breaking once you actually run the build code for the frontend.
No chance of explaining to non-coders why this is exciting or even just when you’re successful.

On Monday, one of our students at $DAYJOB asked me what projects I do in my freetime. After I infodumped on her for half an hour, she asked in disbelief “And you do these in your freetime, without being paid?”.

Like, mate, did you not listen how feckin’ excited I got just then? Of course, I do these in my freetime.

To be fair, though, the last project I told her about is very dry. It’s a library to help automate CI builds. And the thing I’m thrilled to build is a compile-safe API for accessing the packages in your workspaces. Like, yeah, it does take a special kind of nerd to get excited about that…

I mean, Rust does have a pretty inclusive community…

Ah, I think, I know what you mean, that the format is supposed to be written with foolish oversimplifications that are borderline incorrect, whereas “secured by TLS” just sounds like a normal statement from an expert…

I’m guessing that was supposed to be “secured by a thin layer of TLS”…

AI slop turned into ASCII art. That’s a new one…

Yeah, I virtually only use --force for moving tags around (which one could definitely argue isn’t really a thing you should be doing regularly either)…

Yeah, we always try to automate as much as possible with generic language build tooling and scripts, so that ideally the call in the runner is just a single command, which can also be triggered locally.

Unfortunately, if you want to be able to re-run intermediate steps, then you do need to inform the runner of what you’re doing and deal with the whole complexity of up-/downloading intermediate results.