As a reviewer I at least skimmed the papers for every reference in every paper that I review. If it isn't useful to furthering the point of the paper then my feedback is to remove the reference. Adding a bunch of junk because it is broadly related in a giant background section is a waste of everyone's time and should be removed. Most of the time you are mostly aware of the papers being cited anyway because that is the whole point of reviewing in your area of expertise.

The implementation of the shared json buffer is nuts

I think it is posted because of the update on Dec 2nd 2025 where Oracle responded with a request to dismiss.

Edit: I read that date shockingly wrong, their response was February of 2025 so this is pretty old.

There was definitely a widely held belief in the late 90s, early 00s that programming was commoditized to the point that it would be fully offshored to the lowest cost of labor. This happened in some areas and failed. It still happens now and then. But I remember hearing some of that based on OO and libraries making it so unskilled people could just put together legos.

I remember that. I studied CS in that period and some professors were convinced that software development was going to become an unskilled job, analogous to bricklaying, and that our goal as future CS graduates should be to become managers, just like someone that studies a university degree about making buildings is intended to become an architect and not a bricklayer.

I never believed it, though (if I had, I would probably have switched degrees, as I hate management). And while the belief was common, my impression is that it was only so among people who didn't code much. The details on how it would happen were always highly handwavy and people defending that view had a tendency to ignore any software beyond standard CRUD apps.

In contrast, if I had to choose a degree right now, I'd probably avoid CS (or at most study it out of passion, like one could study English philology or something, but without much hope of it being a safe choice for my career). I think the prospects for programmers in the LLM era look much scarier, and the threats look much more real, than they ever did in that period.

The bigger issue is that so many people have jumped into CS because programming (not the same thing I know) has become seen as this thing that will earn you big bucks.

Of course, some level of computer skills is important in most professions at this point. But logic suggests that CS (and programming) compensation will level out at a level comparable to similarly skilled technical professions.

It's a bit too generalizing that it failed and happens "now and then", offshoring is a multi-billion industry employing millions of people.

And the "unskilled people putting together legos" is also very much a thing in the form of low/no-code platforms, from my own circles there's Mendix and Tibco, arguably SAP, and probably a heap more. Arguably (my favorite word atm) it's also still true in most software development because outside of coding business logic, most heavy lifting is done by the language's SDK and 3rd party libraries.

The last one wins

I don’t know if they can pull it off but a lot of companies are built on strong enterprise sales being able to sell free stuff with a bow on it to someone who doesn’t know better or doesn’t care.

This whole series of work is quite cool. The use of `word-break: break-word;` makes this really hard to read though.

I actually can’t read it for some reason? My brain just can’t connect the words

so it appears the entire text has been Translated with non-breaking space unicode x00a0 instead of normal spaces x0020, so the web layout is considering all paragraph text as a super-long single word ('the\00a0quick\00a0\brown\00a0fox' instead of 'the quick brown fox') - the non-breaking space character appears identically to breaking-space when rendered but underlying coding breaks the concept of "break at end of word" because there is no end as 00a0 literally means "non-breaking"). per Copilot spending a half hour explaining this to me, apparently this can be fixed by opening web browser developer view, and copy/pasting this code into the console.

function replaceInTextNodes(node) { if (node.nodeType === Node.TEXT_NODE) { node.nodeValue = node.nodeValue .replace(/\u00A0/g, ' '); } else { node.childNodes.forEach(replaceInTextNodes); } }

replaceInTextNodes(document.body);

This is completely fascinating although puzzling how that happens.

The script is great!

That’s why typography matters. You can’t read it because a very basic convention has been broken here and that throws everything off.

There is usually some variant of tee that lets you do that.

I think this is pretty cool but I spend most of my day on a laptop I don’t own and there’s no way I could get this on there.

You have to call defer after initialization so you can’t technically call it RAII. As long as you remember to call it then it is effectively the same. Personally defer makes it so very similar to be a difference without a distinction but the “is initialization” part can’t be true if you need to do a second step.