Tired of this trope. Learning data structures and algorithms is not about memorizing the specifics of some particular algorithm. That’s like thinking that learning math is about memorizing formulas.

DS&A is about learning *algorithmic thinking" and how common data structures actually work, so you can begin to build a toolbox of things you can use when making your own data structures. Software engineers that are actually good know this shit backwards and forwards, because it does actually come up all over the place (and these are the kind of people that actually write libraries). Even the basic things you learn in school are actually incredibly useful for understanding the implementation details of databases and how query planners and indexes work, for example (very helpful when trying to understand query performance).

And don’t get me started on just how fucking much directed acyclic graphs come up in the real world. Git? DAG. Any package manager? DAGs. Nix? DAGs. Open Telemetry? DAGs (the main data structure is a tree which is a special case of DAGs, but if you use linked spans, it would form a DAG). Hell, I’m working on something right now that needs to be modeled as a DAG. It’s almost comical how useful they are.

We should be encouraging people to learn and grow more, not less.

No, the author is not confusing them. It’s everyone else that has been confused insofar as they use “REST” to describe APIs that are not actually REST. True REST is a way of architecting networked applications according to a set of constraints, as defined by Roy Fielding in his original dissertation. Here’s an excerpt that sums it up:

In order to obtain a uniform interface, multiple architectural constraints are needed to guide the behavior of components. REST is defined by four interface constraints: identification of resources; manipulation of resources through representations; self-descriptive messages; and, hypermedia as the engine of application state.

Many “REST” APIs do not adhere to these constraints, especially self-descriptive messages and hypermedia as the engine of application state (also known as HATEOAS). Note that this says nothing about HTML: HTML is but one representation of hypermedia, but far from the only one. Hypermedia is something that allows discovery of additional, related resources by way of links between resources. There are a number of ways of doing this, such as RFC 8288 Link Headers or embedding links within one of a resource’s representations (such as a JSON representation).

It’s a much larger topic than I can fully explain here, but I highly recommend reading Roy Fielding’s dissertation, especially Chapter 5 which talks about REST and what it is.

I also highly recommend this blog post from Google Cloud’s engineering team, which talks about why you should use links instead of keys to represent relationships in API design: https://cloud.google.com/blog/products/application-development/api-design-why-you-should-use-links-not-keys-to-represent-relationships-in-apis.

From what I remember, Vscode has quite a fair bit of native code in various areas to make it perform better. So it may not be the representative Electron app for comparison.

That’s what Open Telemetry is for, honestly, specifically tracing. I’m in the process of adding tracing for all of our web handlers, http client calls, database transactions/individual queries, and asynchronous jobs. Should give us a pretty good view into the performance of the system, and allow us to monitor for things like performance regressions without any dedicated profiling needed (though we certainly could add additional profiling information through Otel down the road). Since I know you’re a Haskeller (recognize your handle), the hs-opentelemetryecosystem is quite solid and has integrations with a lot of libraries in the wider ecosystem, like wai, persistent, postgresql-simple, conduit, and a bunch more. I haven’t needed to write too much of our own instrumentation, aside from our job system since that’s a bespoke system.

It’s not, they are correct. There are so many telltale signs of AI code it’s not even funny. The most obvious being the absolutely garbage comments that people invariably leave in. And the god awful naming of things.

But it’s more than that. If you’re in this industry long enough, you get pretty good at reconstructing a real author’s thought process when they wrote the code. Part of understanding code is understanding why it was written the way that it was, which means understanding how the author thought. Sure, there was plenty of garbage code and stupid thinking, but it was still thought and usually had its own kind of internal consistency. AI code has no thought process, no reason. It is pure mimicry, an amalgamation of millions of authors all at once. It has no internal consistency. It produces code no human ever would, because it doesn’t make any fucking sense. It’s like reading an alien language, where the constructs it produces are so aberrant to how any human would ever think that it could be nothing but an LLM.

I definitely can’t tell you everything about a piece of code by reading it, but I sure as hell can smell an LLM in it, because it fucking stinks.

I work remote, so no.

Hmm, every company monitors their web traffic. That’s standard operating procedure.

He has certainly revealed himself to be a shitty person, but Shape of You is actually a pretty good concept for a song. It’s essentially a song about body acceptance created in an era where people (especially women) face constant, coercive pressure to meet impossible, idealized beauty standards. That’s why it was such a popular song. I know a lot of people who struggle with that topic, and the song really resonated with them.

It’s not like he even wrote the song, either. Pop stars almost never write their own music, and Shape of You is no exception.

Slop commenting. The litany of AI slop websites that have popped up, polluting search results. The absolute flood of AI slop pull requests being submitted to open source projects, to the point at which many open source maintainers are buckling under the weight of garbage being thrown their way. Bots everywhere. The list goes on and on and on.

The internet is already a dessicated husk of what it once was.

Like when my toddler says he hates a food that he has never tried.

I’m sorry to hear about your condition.

I’m saying that AI companies have repeatedly shown a flagrant disregard for licenses, contracts, and the law, and have engaged in massive theft. Why should we expect that any contract would actually be honored? The whole thing is a huge fucking grift.

I was not talking about your specific lawsuit, or TLS.

Companies trust other companies all the time, and it’s foundational to most all SLA/SLOs. Any time I’ve voiced concerns around how AI companies are using the data we are giving them (like giving them access to our codebase), it’s brushed off as “we have an agreement with them”. It’s just a load of hogwash. They can and will abuse all data they have access to, just as they have done thus far.

In this particular case, we are talking about a data center, and it is not at all reasonable to assume that the data that flows to said data center is in any way protected, especially one run by Musk.

Still means jack shit. Companies will lie through their teeth and violate any and all they can get away with.

They are not to be trusted.

I’m worried about nix, honestly. An absolute truckload of nix packages pull their source from GitHub. It’s the primary way to distribute flakes, too.

I suppose it depends on what kind of AI we’re talking about. If you mean LLMs, then I certainly hope no one is trying to do something as foolish as that.

A lot of the stuff from James Webb is truly novel, as well, which no AI technology would be useful in understanding.

What the actual fuck, Guardian.

Did the headline change? The current headline is Torvalds: “100% of Their Code is Written by Compilers” Too

The title of this post makes for a dumb headline, at any rate. Linus, in response to claims in the industry that projects are now “99% written by AI”, drew an analogy to compilers by saying that all machine code for projects are written by compilers, yet no one says their project was 100% written by a compiler. It’s just talking about stupid hype, which is valid.

That being said, it’s still quite unfortunate that Linus has fallen into the trap of LLMs.

Seriously. My argument against “LLMs are good at generating boilerplate” has always been “why are you putting up with needing to write boilerplate in the first place?”

I really do think that it’s emblematic of a problem that existed long before LLMs: a lot of developers were/are deeply uncomfortable with stepping outside the confines of their IDE, and thus would basically never fix workflow/DX issues unless said fix came packaged as a feature by whichever megacorp was feeding them tooling. Scripting is all but unheard of outside of things like builds or CI.

I see this divide in my own organization, actually. Our mobile developers aren’t really all that comfortable with stepping outside of what Android Studio/XCode can do and the workflows deined by Google/Apple.

Our backend team is very different. No one uses IDEa, and we’re all Unix terminal folk for the most part. Lots of scripting and tooling we’ve created over time to streamline our development.

So when me and few other backend engineers decided to write a small Caddy file to set up a reverse proxy to enable the mobile emulators to talk to our locally-running backend (rather than a shared non-prod backend that the mobile teams always use, in order to facilitate more efficient end-to-end testing for features), we may as well have been talking an entirely different language when describing it. The very idea of creating your own tooling to solve a problem with your job is just entirely alien to them.

This is what happens when you don’t take a stand against this shit. He brought it on himself.