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:

There are a bunch of data formats which can store structured data. The most popular seem to be JSON and YAML. A relatively new one is TOML, which is gaining traction in the Python ecosystem. For most of my projects I just use YAML files, but I have tried out the TOML language as well. //

Another downside of JSON is that it doesn't support comments. TOML and YAML do that. However, it is hard to re-write such a file with comments and change values while keeping most of the comments intact. But this just means that commented files are only read by programs, and if programs write the files, one should not comment them.

YAML
The YAML format is my definite favorite. I find it easy to read and write. One negative about YAML is its potential complexity, as one can have references to other part of the file, or even serialize custom types.

TOML
[Tom's Obvious Minimal Language]
A config file format for humans.
TOML aims to be a minimal configuration file format that's easy to read due to obvious semantics. TOML is designed to map unambiguously to a hash table. TOML should be easy to parse into data structures in a wide variety of languages.

We've noticed that some of our automatic tests fail when they run at 00:30 but work fine the rest of the day. They fail with the message

gimme gimme gimme

in stderr, which wasn't expected. Why are we getting this output?

Answer:

Dear @colmmacuait, I think that if you type "man" at 0001 hours it should print "gimme gimme gimme". #abba
@marnanel - 3 November 2011

er, that was my fault, I suggested it. Sorry.

Pretty much the whole story is in the commit. The maintainer of man is a good friend of mine, and one day six years ago I jokingly said to him that if you invoke man after midnight it should print "gimme gimme gimme", because of the Abba song called "Gimme gimme gimme a man after midnight":

Well, he did actually put it in. A few people were amused to discover it, and we mostly forgot about it until today.

I can't speak for Col, obviously, but I didn't expect this to ever cause any problems: what sort of test would break on parsing the output of man with no page specified? I suppose I shouldn't be surprised that one turned up eventually, but it did take six years.

(The commit message calls me Thomas, which is my legal first name though I don't use it online much.)

This issue has been fixed with commit 84bde8: Running man with man -w will no longer trigger this easter egg.

Delphi is still very much with us, but the FOSS world also has its own, largely compatible, GUI-based Object Pascal environment – and it's worth a look.

Valentine's Day 2025 marked the 30th anniversary of the release of Borland's Delphi, which fused Borland's version of Object Pascal, along with a GUI designer and database access, into a powerful whole. Appearing so early in 1995 meant that Delphi itself predated Windows 95 by just over six months: it started out as a 16-bit tool for Windows 3.1. (32-bit Windows was already a thing – the second release of Windows NT, version 3.5, appeared in late 1994, but it was still a bit niche.) The codename, which after much internal debate became the product name, reflected that it was intended as a local rapid-application-delevelopment tool that helped you to talk to Oracle. //

The Reg joined in when Delphi turned 25, setting it in its historical context. One detail from back then does merit clarification, though: "Object Pascal was Borland's own language." Well, it was – Delphi's compiler was inherited from Borland's Turbo Pascal. As The Reg noted when Turbo Pascal turned 40, TP went OOPS with version 5.5, back in 1989. Borland didn't invent Object Pascal, though.

An Apple report [PDF] from almost exactly a decade before the release of Delphi, by the late great Larry Tesler, explains:

Object Pascal is a revision of Lisa Clascal designed by Apple Computer's Macintosh Software Group with the help of Niklaus Wirth.

Clascal was an older language designed for software development on Apple's first GUI computer, the Lisa. Its reference manual [PDF] from 1983 dates it as older than the Macintosh itself. In 1986, BYTE Magazine explained:

The syntax for Object Pascal was jointly designed by Apple's Clascal team and Niklaus Wirth. the designer of Pascal, who was invited to Apple's Cupertino headquarters specifically for this project. In addition to implementing Object Pascal on the Mac, Apple has put the Object Pascal specification in the public domain and encouraged others to implement compilers and interpreters for it.

Even if Delphi's 30 years puts fancy type-safe newbie Rust's mere 13 years into perspective, Object Pascal itself can thus legitimately claim 40 years. //

https://www.freepascal.org/

https://www.lazarus-ide.org/

https://www.embarcadero.com/products/delphi/starter

Years ago, when I read The Mythical Man-Month, I found lots of stuff which I already knew from other sources. However, there were also new things in there, despite the book being from 1975. One of them was:

The Surgical Team

Mills proposes that each segment of a large job be tackled a team, but that the team be organized like a surgical team rather than a hog-butchering team. That is, instead of each member cutting away on the problem, one does the cutting and the others give him every support that will enhance his effectiveness and productivity.

This is a very interesting pattern for organizing a software development team, but I never found it described in any other Software Engineering book, not even mentioned anywhere.

Why is that?

Thursday 2nd April 2020 15:11 GMT
BJC
Millisecond roll-over?
So, what is the probability that the timing for these events is stored as milliseconds in a 32 bit structure?

Reply Icon
Re: Millisecond roll-over?
My first thought too, but that rolls over after 49.7 days.

Still, they could have it wrong again.

Re: Millisecond roll-over?
I suspect that it is a millisecond roll over and someone at the FAA picked 51 days instead of 49.7 because they don't understand software any better than Boeing.

Thursday 2nd April 2020 17:05 GMT
the spectacularly refined chap
Reply Icon
Re: Millisecond roll-over?
Could well be something like that, the earlier 248 day issue is exactly the same duration that older Unix hands will recognise as the 'lbolt issue': a variable holding the number of clock ticks since boot overflows a signed 32 bit int after 248 days assuming clock ticks are at 100Hz as was usual back then and is still quite common.

See e.g. here. The issue has been known about and the mitigation well documented for at least 30 years. Makes you wonder about the monkeys they have coding this stuff. //

bombastic bobSilver badge
Reply Icon
Devil
Re: Millisecond roll-over?
I've run into that problem (32-bit millisecond timer rollover issues) with microcontrollers, solved by doing the math correctly

capturing the tick count

if((uint32_t)(Ticker() - last_time) >= some_interval)

and

last_time=Ticker(); // for when it crosses the threshold

[ alternately last_time += some_interval when you want it to be more accurate ]

using a rollover time

if((int32_t)(Ticker() - schedule_time) >= 0)

and

schedule_time += schedule_interval (for when it crosses the threshold)

(this is how Linux kernel does its scheduled events, internally, as I recall, except it compares to jiffies which are 1/100 of a second if I remember correctly)

(examples in C of course, the programming lingo of choice the gods!)

do the math like this, should work as long as you use uint32_t data types for the 'Ticker()' function and for the 'scheduld_time'; or 'last_time' vars.

If you are an IDIOT and don't do unsigned comparisons "similar to what I just demonstrated", you can predict uptime-related problems at about... 49.71 days [assuming milliseconds].

I think i remember a 'millis()' or similarly named function in VxWorks. It's been over a decade since I've worked with it though. VxWorks itself was pretty robust back then, used in a lot of routers and other devices that "stay on all the time". So its track record is pretty good.

So the most likely scenario is what you suggested - a millisecond timer rolling over (with a 32-bit var storing info) and causing bogus data to accumulate after 49.71 days, which doesn't (for some reason) TRULY manifest itself until about 51 days...

Anyway, good catch.