I think, people who say that believe that we’re close to actually-intelligent AI (or artificial general intelligence, AGI). And when we get there, it’s possible that we might suddenly be able to automate lots of complex tasks, possibly even shove it onto robots and have it take on physical labor and things like that.

It’s the wet dream of capitalists, because they don’t need to employ anyone anymore. And I guess, folks are also afraid that such AI could be used for war.

Well, they’re not actually open-source. The models are freely available, but the training data is not, so it’s not actually possible for competitors to reproduce the same result.

It’s only really Windows that doesn’t use LF these days. All the Unix-based ones (Linux, BSD, macOS, iOS, Android etc.) use LF…

I mean, stock price rarely correlates with actual need and more with just hype. If you expect many people to buy a given stock, it makes sense for you to buy before them. If you expect many people to sell a given stock, it makes sense for you to sell before them. The actual need kind of just provides a baseline, i.e. even if the hype dies off completely, it’ll still make some profit and pay out some fraction from that to anyone who’s willing to park their money there.

Alternatively, the less proper tool: Record your screen, cropped to the SVG.

GIF, MP4 and such, they’re just a bunch of pixel grids. They don’t care where those pixels came from.

I was kind of thinking that yesterday when looking at a Rust library. Rust is competent with line numbers, so you don’t really have an incentive for splitting files from that angle, but sometimes, folks just seem to keep adding to their files ad infinitum.

Well, specifically that library has a few files with more than 1k lines. And I hope this one’s the largest at 4k lines: https://docs.rs/git2/latest/src/git2/repo.rs.html

What also needs to be said, is that this library is actually maintained by the Rust language team. Really makes me want to open an issue to tell them that Rust has a pretty cool module system. 🙃

Damn, this guy looks like he’s about to sing an 80s power ballad.

Apparently, a dev on the customer side estimated that he’d need two weeks to implement the whole project (which thankfully our customer representative also laughed at).

Man, I’m currently in a project which started out with 2 major goals. Pretty early on, we got told that one of the goals is practically impossible, so we decided to ignore that. And we realized the other goal needs to be simplified significantly to be achievable in the slightest, although we still weren’t sure, if it violates the laws of physics.

Now we’re a year into development, we’ve only figured out that it might be physically possible in certain situations. And yesterday, we talked to a guy with domain knowledge, who told us like ten different bigger challenges we’d still have to solve.

The browser has an internal model for representing the HTML document, called the Document Object Model (DOM). This DOM happens to be tree-shaped, because HTML is tree-shaped. And certain logic in a browser gets applied to subtrees, like e.g. most CSS rules.

Sometimes, however, you want a subtree to not get affected by what’s going on in the main tree, for example when including an SVG into that tree, or if you’re offering JavaScript library with a pre-built component.
And yeah, that is what the Shadow DOM does. It also shields the rest of the DOM from what you’re doing inside the Shadow DOM. And there’s certain mechanisms to selectively allow interaction across the shadow boundary, e.g. when providing a pre-built component, you might still want the user to be able to style parts of it.

It is very much real: https://developer.mozilla.org/en-US/docs/Glossary/Shadow_tree

Both of those are sweet and fruit…?

And here I would argue that the Rust library is strictly better, specifically because it will come with an automated or precompiled build of the C library. Compiling C is such a pain.

Emoji log levels: 🔍 ⚙️ ℹ️ ⚠️ 💥

Tangentially related rant: We had a new contributor open up a pull request today and I gave their changes an initial look to make sure no malicious code is included.
I couldn’t see anything wrong with it. The PR was certainly a bit short, but the task they tackled was pretty much a matter of either it works or it doesn’t. And I figured, if they open a PR, they’ll have a working solution.

…well, I tell the CI/CD runner to get going and it immediately runs into a compile error. Not an exotic compile error, the person who submitted the PR had never even tried to compile it.

Then it dawned on me. They had included a link to a GitHub Copilot workspace, supposedly just for context.
In reality, they had asked the dumbass LLM to do the change described in the ticket and figured, it would produce a working PR right off the bat. No need to even check it, just let the maintainer do the validation.

In an attempt to give them constructive feedback, I tried to figure out, if this GitHub Copilot workspace thingamabob had a Compile-button that they just forgot to click, so I actually watched Microsoft’s ad video for it.
And sure enough, I saw right then and there, who really was at fault for this abomination of a PR.

The ad showed exactly that. Just chat a bit with the LLM and then directly create a PR. Which, yes, there is a theoretical chance of this possibly making sense, like when rewording the documentation. But for any actual code changes? Fuck no.

So, most sincerely: Fuck you, Microsoft.