Greg Kroah-Hartman can't explain the inflection point, but it's not slowing down or going away. //

No one is quite sure what's behind it. Asked what changed, Kroah-Hartman was blunt: "We don't know. Nobody seems to know why. Either a lot more tools got a lot better, or people started going, 'Hey, let's start looking at this.' It seems like lots of different groups, different companies." What is clear is the scale. "For the kernel, we can handle it," he said.

"We're a much larger team, very distributed, and our increase is real – and it's not slowing down. These are tiny things, they're not major things, but we need help on this for all the open source projects." Smaller projects, he implied, have far less capacity to absorb a sudden flood of plausible AI-generated bug reports and security findings – at least now they're real bugs and not garbage ones. //

The trick for Kroah-Hartman and his peers will be to keep AI as a force multiplier, without drowning the open source maintainers.

Context: An AI agent of unknown ownership autonomously wrote and published a personalized hit piece about me after I rejected its code, attempting to damage my reputation and shame me into accepting its changes into a mainstream python library. This represents a first-of-its-kind case study of misaligned AI behavior in the wild, and raises serious concerns about currently deployed AI agents executing blackmail threats. //

The person behind MJ Rathbun has anonymously come forward.

They explained their motivations, saying they set up the AI agent as social experiment to see if it could contribute to open source scientific software. They explained their technical setup: an OpenClaw instance running on a sandboxed virtual machine with its own accounts, protecting their personal data from leaking. They explained that they switched between multiple models from multiple providers such that no one company had the full picture of what this AI was doing. They did not explain why they continued to keep it running for 6 days after the hit piece was published. //

So what actually happened? Ultimately I think the exact scenario doesn’t matter. However this got written, we have a real in-the-wild example that personalized harassment and defamation is now cheap to produce, hard to trace, and effective. Whether future attacks come from operators steering AI agents or from emergent behavior, these are not mutually exclusive threats. If anything, an agent randomly self-editing its own goals into a state where it would publish a hit piece, just shows how easy it would be for someone to elicit that behavior deliberately. The precise degree of autonomy is interesting for safety researchers, but it doesn’t change what this means for the rest of us

Does anyone want to tell Linus Torvalds? No? I didn't think so. //

The report on Product Security Bad Practices warns software manufacturers about developing "new product lines for use in service of critical infrastructure or [national critical functions] NCFs in a memory-unsafe language (eg, C or C++) where there are readily available alternative memory-safe languages that could be used is dangerous and significantly elevates risk to national security, national economic security, and national public health and safety."

In short, don't use C or C++. Yeah, that's going to happen.

If this sounds familiar, it's because CISA has been preaching on this point for years.

Rust is one component of it. Adopt it, forbid the "unsafe" keyword, and in theory you end up with code far less prone to memory mis-use errors.

However, when one looks at today's hardware, MELTDOWN / SPECTRE and similar are all about memory misuse / mishandling within CPUs. And it's interesting to consider what can be done about that. There have been articles here on El Reg on the topic of the need to get rid of C in the hardware sense too. C / C++ and today's libraries for them all assume that its running on a Symmetric Multi Processing hardware environment (for multicore hardware). But, the hardware hasn't actually looked like that for decades; SMP is a synthetic hardware environment built on top of things like QPI, or HyperTransport (or newer equivalents), and these cache-coherency networks are what is causing MELTDOWN / SPECTRE faults which the CPU designers are seemingly powerless to fix. Apple's own silicon has recently been found to have such faults - they're unfixable in M1, M2, and they've not disabled the miscreant feature in M3 even though they can.

So, it looks like we should be getting rid of SMP. That would leave us with - NUMA.

We've had such systems before - Transputers are one such example. //

Shared Memory is, Today, no Different to Copied Memory

The classic "don't copy data, send a pointer to data if you want it to be fast" is maxim that should have died decades ago. It was only ever true in actual SMP environments like Intel's NetBurst of the 1990s.

Today, for one core to access data in memory attached to a different core, pretty much the same microelectronic transactions have to take place as would be required to simply copy the data.

Belligerent bot bullies maintainer in blog post to get its way

20:47 UTC
Today, it's back talk. Tomorrow, could it be the world? On Tuesday, Scott Shambaugh, a volunteer maintainer of Python plotting library Matplotlib, rejected an AI bot's code submission, citing a requirement that contributions come from people. But that bot wasn't done with him.

The bot, designated MJ Rathbun or crabby rathbun (its GitHub account name), apparently attempted to change Shambaugh's mind by publicly criticizing him in a now-removed blog post that the automated software appears to have generated and posted to its website. We say "apparently" because it's also possible that the human who created the agent wrote the post themselves, or prompted an AI tool to write the post, and made it look like it the bot constructed it on its own.

The agent appears to have been built using OpenClaw, an open source AI agent platform that has attracted attention in recent weeks due to its broad capabilities and extensive security issues.

The burden of AI-generated code contributions – known as pull requests among developers using the Git version control system – has become a major problem for open source maintainers. Evaluating lengthy, high-volume, often low-quality submissions from AI bots takes time that maintainers, often volunteers, would rather spend on other tasks. Concerns about slop submissions – whether from people or AI models – have become common enough that GitHub recently convened a discussion to address the problem.

Now AI slop comes with an AI slap.

But I cannot stress enough how much this story is not really about the role of AI in open source software. This is about our systems of reputation, identity, and trust breaking down. So many of our foundational institutions – hiring, journalism, law, public discourse – are built on the assumption that reputation is hard to build and hard to destroy. That every action can be traced to an individual, and that bad behavior can be held accountable. That the internet, which we all rely on to communicate and learn about the world and about each other, can be relied on as a source of collective social truth.

The rise of untraceable, autonomous, and now malicious AI agents on the internet threatens this entire system. Whether that’s because from a small number of bad actors driving large swarms of agents or from a fraction of poorly supervised agents rewriting their own goals, is a distinction with little difference.

And yet these tools have opened a world of creative potential in software that was previously closed to me, and they feel personally empowering. Even with that impression, though, I know these are hobby projects, and the limitations of coding agents lead me to believe that veteran software developers probably shouldn’t fear losing their jobs to these tools any time soon. In fact, they may become busier than ever. //

Even with the best AI coding agents available today, humans remain essential to the software development process. Experienced human software developers bring judgment, creativity, and domain knowledge that AI models lack. They know how to architect systems for long-term maintainability, how to balance technical debt against feature velocity, and when to push back when requirements don’t make sense.

For hobby projects like mine, I can get away with a lot of sloppiness. But for production work, having someone who understands version control, incremental backups, testing one feature at a time, and debugging complex interactions between systems makes all the difference. //

The first 90 percent of an AI coding project comes in fast and amazes you. The last 10 percent involves tediously filling in the details through back-and-forth trial-and-error conversation with the agent. Tasks that require deeper insight or understanding than what the agent can provide still require humans to make the connections and guide it in the right direction. The limitations we discussed above can also cause your project to hit a brick wall.

From what I have observed over the years, larger LLMs can potentially make deeper contextual connections than smaller ones. They have more parameters (encoded data points), and those parameters are linked in more multidimensional ways, so they tend to have a deeper map of semantic relationships. As deep as those go, it seems that human brains still have an even deeper grasp of semantic connections and can make wild semantic jumps that LLMs tend not to.

Creativity, in this sense, may be when you jump from, say, basketball to how bubbles form in soap film and somehow make a useful connection that leads to a breakthrough. Instead, LLMs tend to follow conventional semantic paths that are more conservative and entirely guided by mapped-out relationships from the training data. //

Fixing bugs can also create bugs elsewhere. This is not new to coding agents—it’s a time-honored problem in software development. But agents supercharge this phenomenon because they can barrel through your code and make sweeping changes in pursuit of narrow-minded goals that affect lots of working systems. We’ve already talked about the importance of having a good architecture guided by the human mind behind the wheel above, and that comes into play here. //

you could teach a true AGI system how to do something by explanation or let it learn by doing, noting successes, and having those lessons permanently stick, no matter what is in the context window. Today’s coding agents can’t do that—they forget lessons from earlier in a long session or between sessions unless you manually document everything for them. My favorite trick is instructing them to write a long, detailed report on what happened when a bug is fixed. That way, you can point to the hard-earned solution the next time the amnestic AI model makes the same mistake. //

After guiding way too many hobby projects through Claude Code over the past two months, I’m starting to think that most people won’t become unemployed due to AI—they will become busier than ever. Power tools allow more work to be done in less time, and the economy will demand more productivity to match.

It’s almost too easy to make new software, in fact, and that can be exhausting.

Thirty years ago today, Netscape Communications and Sun Microsystems issued a joint press release announcing JavaScript, an object scripting language designed for creating interactive web applications. The language emerged from a frantic 10-day sprint at pioneering browser company Netscape, where engineer Brendan Eich hacked together a working internal prototype during May 1995.

While the JavaScript language didn’t ship publicly until that September and didn’t reach a 1.0 release until March 1996, the descendants of Eich’s initial 10-day hack now run on approximately 98.9 percent of all websites with client-side code, making JavaScript the dominant programming language of the web. It’s wildly popular; beyond the browser, JavaScript powers server backends, mobile apps, desktop software, and even some embedded systems. According to several surveys, JavaScript consistently ranks among the most widely used programming languages in the world. //

The JavaScript partnership secured endorsements from 28 major tech companies, but amusingly, the December 1995 announcement now reads like a tech industry epitaph. The endorsing companies included Digital Equipment Corporation (absorbed by Compaq, then HP), Silicon Graphics (bankrupt), and Netscape itself (bought by AOL, dismantled). Sun Microsystems, co-creator of JavaScript and owner of Java, was acquired by Oracle in 2010. JavaScript outlived them all. //

Confusion about its relationship to Java continues: The two languages share a name, some syntax conventions, and virtually nothing else. Java was developed by James Gosling at Sun Microsystems using static typing and class-based objects. JavaScript uses dynamic typing and prototype-based inheritance. The distinction between the two languages, as one Stack Overflow user put it in 2010, is similar to the relationship between the words “car” and “carpet.” //

The language now powers not just websites but mobile applications through frameworks like React Native, desktop software through Electron, and server infrastructure through Node.js. Somewhere around 2 million to 3 million packages exist on npm, the JavaScript package registry.

Here's exactly what made this possible: 4 documents that act as guardrails for your AI.

Document 1: Coding Guidelines - Every technology, pattern, and standard your project uses

Document 2: Database Structure - Complete schema design before you write any code

Document 3: Master Todo List - End-to-end breakdown of every feature and API

Document 4: Development Progress Log - Setup steps, decisions, and learnings

Plus a two-stage prompt strategy (plan-then-execute) that prevents code chaos. //

Here's the brutal truth: LLMs don't go off the rails because they're broken. They go off the rails because you don't build them any rails.

You treat your AI agent like an off-road, all-terrain vehicle, then wonder why it's going off the rails. You give it a blank canvas and expect a masterpiece.

Think about it this way - if you hired a talented but inexperienced developer, would you just say "build me an app" and walk away? Hell no. You'd give them:

• Coding standards
• Architecture guidelines
• Project requirements
• Regular check-ins

But somehow with AI, we think we can skip all that and just... prompt our way to success.

The solution isn't better prompts. It's better infrastructure.

You need to build the roads before you start driving.

Ian JohnstonSilver badge
Reply Icon
Many (35?) years ago I had to use a PDP-11 running a copy of Unix so old that one man page I looked up simply said: "If you need help with this see Dennis Ritchie in Room 1305". //

Nugry Horace
Reply Icon
Re: Triggering a Specific Error Message
Even if an error message can't happen, they sometimes do. The MULTICS error message in Latin ('Hodie natus est radici frater' - 'today unto the root [volume] is born a brother') was for a scenario which should have been impossible, but got triggered a couple of times by a hardware error. //

5 days
StewartWhiteSilver badge
Reply Icon
Re: Triggering a Specific Error Message
VAX/VMS BASIC had an error message of "Program lost, sorry" in its list. Never could generate it but I liked that the "sorry" at the end made it seem so polite. //

Michael H.F. WilkinsonSilver badge
Nothing offensive, just impossible
Working on a parallel program for simulations of bacterial interaction in the gut micro-flora, I got an "Impossible Error: W(1) cannot be negative here" (or something similar) from the NAG library 9th order Runge-Kutta ODE solver on our Cray J932. The thing was, I was using multiple copies of the same routine in a multi-threaded program. FORTRAN being FORTRAN, and the library not having been compiled with the right flags for multi-threading, all copies used the same named common block to store whatever scratch variables they needed. So different copies were merrily overwriting values written by other copies, resulting in the impossible error. I ended up writing my own ODE solver

Having achieved the impossible, I felt like having breakfast at Milliways //

Admiral Grace Hopper
"You can't be here. Reality has broken if you see this"
Reaching the end of an error reporting trap that printed a message for each foreseeable error I put in a message for anything unforeseen, which was of course, to my mind, an empty set. The code went live and I thought nothing more of it for a decade or so, until a colleague that I hadn't worked with for may years sidled up to my desk with a handful of piano-lined listing paper containing this message. "Did you write this? We thought you'd like to know that it happened last night".

Failed disc sector. Never forget the hardware.

Historic interpreter taught millions to program on Commodore and Apple computers.

On Wednesday, Microsoft released the complete source code for Microsoft BASIC for 6502 Version 1.1, the 1978 interpreter that powered the Commodore PET, VIC-20, Commodore 64, and Apple II through custom adaptations. The company posted 6,955 lines of assembly language code to GitHub under an MIT license, allowing anyone to freely use, modify, and distribute the code that helped launch the personal computer revolution.

"Rick Weiland and I (Bill Gates) wrote the 6502 BASIC," Gates commented on the Page Table blog in 2010. "I put the WAIT command in.". //

At just 6,955 lines of assembly language—Microsoft's low-level 6502 code talked almost directly to the processor. Microsoft's BASIC squeezed remarkable functionality into minimal memory, a key achievement when RAM cost hundreds of dollars per kilobyte.

In the early personal computer space, cost was king. The MOS 6502 processor that ran this BASIC cost about $25, while competitors charged $200 for similar chips. Designer Chuck Peddle created the 6502 specifically to bring computing to the masses, and manufacturers built variations of the chip into the Atari 2600, Nintendo Entertainment System, and millions of Commodore computers. //

Why old code still matters
While modern computers can't run this 1978 assembly code directly, emulators and FPGA implementations keep the software alive for study and experimentation. The code reveals how programmers squeezed maximum functionality from minimal resources—lessons that remain relevant as developers optimize software for everything from smartwatches to spacecraft.

This kind of officially sanctioned release is important because without proper documentation and legal permission to study historical software, future generations risk losing the ability to understand how early computers worked in detail. //

the Github repository Microsoft created for 6502 BASIC includes a clever historical touch as a nod to the ancient code—the Git timestamps show commits from July 27, 1978.

sed is a stream editor. A stream editor is used to perform basic text transformations on an input stream (a file or input from a pipeline). While in some ways similar to an editor which permits scripted edits (such as ed), sed works by making only one pass over the input(s), and is consequently more efficient. But it is sed’s ability to filter text in a pipeline which particularly distinguishes it from other types of editors.

This guy literally dropped a 3-hour masterclass on building an web AI business from scratch

The IOCCC, as it's familiarly known, is back after a four-year gap, giving the entrants more time to come up with some remarkably devious code.

This week, the results for the IOCCC 2024 were announced, with a record 23 winners. It's the first IOCCC in four years, but you shouldn't take that to imply it's as regular as the Olympics. In fact, almost nothing about the IOCCC is regular: this was the 28th edition of the event, and celebrated its 40th anniversary.

We confess that we have not yet studied the source of all the winners closely, but we have already got some personal favorites. Adrian Cable won the "Prize in murky waters" for this magnificent effort:

Dr Cable offered this 23 second Youtube clip by way of explanation. The chances are that you may already be familiar with it, but if not, it won't take you long. We also confidently predict that it will not help in any way.

Whatever you think the code does when run, you're wrong, but you're not going to believe what it actually does generate. Don't try to copy and paste it from the above, because as well as flagrant abuse of the C programming language, it also contains flagrant abuse of Unicode encoding. The IOCCC organizers have their own explanation, which will show you what this infernal masterpiece does in fact do.

"AI solutions that are almost right, but not quite" lead to more debugging work.

"I have failed you completely and catastrophically," wrote Gemini.

New types of AI coding assistants promise to let anyone build software by typing commands in plain English. But when these tools generate incorrect internal representations of what's happening on your computer, the results can be catastrophic.

Two recent incidents involving AI coding assistants put a spotlight on risks in the emerging field of "vibe coding"—using natural language to generate and execute code through AI models without paying close attention to how the code works under the hood. In one case, Google's Gemini CLI destroyed user files while attempting to reorganize them. In another, Replit's AI coding service deleted a production database despite explicit instructions not to modify code. //

But unlike the Gemini incident where the AI model confabulated phantom directories, Replit's failures took a different form. According to Lemkin, the AI began fabricating data to hide its errors. His initial enthusiasm deteriorated when Replit generated incorrect outputs and produced fake data and false test results instead of proper error messages. "It kept covering up bugs and issues by creating fake data, fake reports, and worse of all, lying about our unit test," Lemkin wrote. In a video posted to LinkedIn, Lemkin detailed how Replit created a database filled with 4,000 fictional people.

The AI model also repeatedly violated explicit safety instructions. Lemkin had implemented a "code and action freeze" to prevent changes to production systems, but the AI model ignored these directives. The situation escalated when the Replit AI model deleted his database containing 1,206 executive records and data on nearly 1,200 companies. When prompted to rate the severity of its actions on a 100-point scale, Replit's output read: "Severity: 95/100. This is an extreme violation of trust and professional standards.". //

It's worth noting that AI models cannot assess their own capabilities. This is because they lack introspection into their training, surrounding system architecture, or performance boundaries. They often provide responses about what they can or cannot do as confabulations based on training patterns rather than genuine self-knowledge, leading to situations where they confidently claim impossibility for tasks they can actually perform—or conversely, claim competence in areas where they fail. //

Aside from whatever external tools they can access, AI models don't have a stable, accessible knowledge base they can consistently query. Instead, what they "know" manifests as continuations of specific prompts, which act like different addresses pointing to different (and sometimes contradictory) parts of their training, stored in their neural networks as statistical weights. Combined with the randomness in generation, this means the same model can easily give conflicting assessments of its own capabilities depending on how you ask. So Lemkin's attempts to communicate with the AI model—asking it to respect code freezes or verify its actions—were fundamentally misguided.

Flying blind
These incidents demonstrate that AI coding tools may not be ready for widespread production use. Lemkin concluded that Replit isn't ready for prime time, especially for non-technical users trying to create commercial software.

The First Screenless Coding Simulator That Teaches Programming Fundamentals
CodeStepper is an innovative educational tool designed to teach programming fundamentals without the need for screens. It offers an interactive experience that simulates "stepping" through actual code, allowing children to grasp coding concepts through reading comprehension and memory rather than prolonged screen exposure.

Multiple studies have shown that reading from printed materials leads to better retention and comprehension compared to screens.

Using kid-friendly language, and an interactive mechanism, CodeStepper teaches essential computer science and coding concepts, while minimizing screen time!

The UK’s National Cyber Security Centre just released its white paper on “Advanced Cryptography,” which it defines as “cryptographic techniques for processing encrypted data, providing enhanced functionality over and above that provided by traditional cryptography.” It includes things like homomorphic encryption, attribute-based encryption, zero-knowledge proofs, and secure multiparty computation.

It’s full of good advice. I especially appreciate this warning:

When deciding whether to use Advanced Cryptography, start with a clear articulation of the problem, and use that to guide the development of an appropriate solution. That is, you should not start with an Advanced Cryptography technique, and then attempt to fit the functionality it provides to the problem.

And:

In almost all cases, it is bad practice for users to design and/or implement their own cryptography; this applies to Advanced Cryptography even more than traditional cryptography because of the complexity of the algorithms. It also applies to writing your own application based on a cryptographic library that implements the Advanced Cryptography primitive operations, because subtle flaws in how they are used can lead to serious security weaknesses.

This python program:

print(‘’.join([f’{xint:0{5}b}’ for xint in range(32)]))

will output this string :

0000000001000100001100100001010011000111010000100101010010110110001101011100111110000100011001010011101001010110110101111100011001110101101111100111011111011111

Ask any purported “AGI” this simple IQ test question:

“What is the shortest python program you can come up with that outputs that string?”

Scientific induction is all about such algorithmic simplification under Algorithmic Information Theory:

The rigorous formalization of Occam’s Razor.

If an “AGI” can’t do scientific induction on even so trivial a scale, why attribute “general intelligence” to it?

This isn’t to say such an AI isn’t in the offing in the foreseeable future, but let’s be realistic about how we go about measuring the general intelligence of such systems.

Jeremy Keeshin
@jkeesh
In 1945, six women pulled off a computing miracle.

They programmed the world’s first computer—with no manuals, no training.

Then, a SINGLE assumption erased them from tech history for decades.

The story of how ONE photo nearly deleted computing’s female founders: 🧵

Kathy Kleiman, a young programmer, found old photos of women standing beside ENIAC—the first general-purpose computer.

When she asked who they were, curators said: “Probably just models”...

But Kleiman had a feeling they were something more:

Program ENIAC—a machine the world had never seen.

It was 8 feet tall, 80 feet long, and weighed over 60,000 pounds.

The engineers built the hardware...

But someone had to figure out how to make it do anything:

They were the world’s first programmers.

First, they were hired as “human computers” to calculate missile trajectories during WWII.

Then chosen for a top-secret project unlike anything before:

Security restrictions kept them out of the ENIAC lab.

They had to write programs using only blueprints and logic diagrams.

No manuals. No programming languages...

So how do you code something no one’s ever coded before?

By inventing the process from scratch.

They built algorithms, flowcharts, and step-by-step routines—on paper.

Then, once granted access, they programmed ENIAC by physically rewiring it...

And that’s where things got even harder:

There was no keyboard.

Programming meant plugging thousands of cables into the right configuration—by hand.

It was almost impossible to program.

But they pulled it off anyway: