Coding glut

No problem. Just have a second AI review the code produced by the first AI. For example:

Disclaimer: I are not a programmist and have not tried any automated code review program.

Dunno. I have two colleagues who are making a serious effort to see if AI can reduce their time spent coding and/or yield better code (in less time).

So far, they describe it as comparable to teaching a child. You have to tell it *everything* -- to the point where it would just be easier to write the code yourself!

E.g., "Accept a numerical value from the user constrained to the range of [23,1190]":

Are leading zeroes supported? Are fractional values allowed? What to do if an invalid character is entered (e.g., non-numeric)? How wide is the keystroke accumulator? Can the accumulated value be CLEARED? Keystrokes "undone" (DEL)? Is a current/default value initially displayed? What happens to that as you start typing? What happens to your entry if you completely "undo" it? Is constraint checking done on-the-fly -- or, at termination? What happens if the constraint is violated? How do you abort the operation/restore default? Can (how?) you implement a timeout on the activity? What happens if it is signaled? Is the accumulator displayed left or right -justified? What if something else wants to use the display/keypad at this time?

etc. It's a tiny piece of code that embodies lots of policy... that you have to explicitly specify to the AI.

The concept of using AI to design circuits and PCBs has the same problem: the problem description can be a bigger hassle than designing a board the old way.

And when you design the schematic and PCB yourself, you can see possibilities and problems that the AI would not.

I'm, going to a dinner/meetup tomorrow night where the AI hardware design boys will make their pitches. I'll try to be polite.

John Larkin Highland Tech Glen Canyon Design Center Lunatic Fringe Electronics

Exactly! Designing the PCB yourself having designed the schematic yourself allows backtracking to restructure the schematic to make for a better PCB layout. I do that often.

My spies tell me that AI (Claude, specifically) is super useful in exploring different ways of factoring code. It'll code it up (more or less well) in several approaches, and let you see the level of complication.

Cheers

Phil Hobbs

(Off to help sing the Hymn of Kassiani in the vigil matins for Holy Wednesday. That's magic.)

Typing C, or something worse, never made much sense to me. Something different, vaguely like LabView, makes more sense.

But hardware design is different.

Well, some people like music. And can sing.

John Larkin Highland Tech Glen Canyon Design Center Lunatic Fringe Electronics

Don Y snipped-for-privacy@foo.invalid wrote: |------------------------------------------------------------------------| |"[. . .] I have two colleagues who are making a serious effort to see if| |AI can [. . .] yield better code [. . .] | |[. . .]" | |------------------------------------------------------------------------|

Would they prefer to use formal methods?

|-------------------------------------------------------------------------| |"So far, they describe it as comparable to teaching a child. You have to| |tell it *everything* -- to the point where it would just be easier to | |write the code yourself!" | |-------------------------------------------------------------------------|

They are not the only ones who report so!

|------------------------------------------------------------------------| |"[. . .] | |Is constraint checking done on-the-fly -- or, at termination?" | |------------------------------------------------------------------------|

On-the-fly constraint enforcements can be annoying for a user. (S.

"Hello, World".

I think it's Claude _Code_ that's very good at code review, not plain Claude. This from an article in the New York Times Magazine issue of Sunday 22 March 2026 titled "Coding After Coders", which claims 20:1 coding effort reduction. The cost of computing is significant, but it still may be worth it.

Joe

In a sense, using an AI forces *some* formal methods -- in that you have to provide the AI with a specification of what you seek. This is often more (and more detailed) than what you would provide a human coder.

Depending on choice of programming language, some may be very expressive in "describing" the solution they represent. And, of course, more exacting. So, if you can write the code as quickly and thoroughly as describing it, what value to the imprecise descriptive exercise?

Everything has constraints. They are enforced somehow and somewhere.

E.g., I can type damn near anything I want and call it a "program". And, delude myself into thinking that it *is* -- until it encounters the criticism of a compiler!

My washing machine (clothes) restricts the choices of various options based on the type of wash cycle I have selected. I may *want* to make a particular option selection but the machine simply won't offer it to me -- change the cycle type if you want a different set of options.

My household thermostat won't let me set the heat to 100F nor the cooling to 40F.

I designed a digital emulation of SWMBO's "bookshelf HiFi". Among other things, it supports 40 "presets" for the radio. And, the "virtual CD player" (could have!) supports an unlimited number of CDs ("playlists").

But, the user interface is effectively a 10-key keypad. Accepting a selection as a series of keystrokes -- e.g., '2' '5' for "25" -- would significantly alter the legacy interface! This would actually select "2". And, then a short while later, "5"! Selecting "25" would be done as '+10' '+10' '5'. I.e., any single decimal digit implicitly implies an "ENTER" keystroke -- without having to alter the UX to include such a keystroke! So, you can select "1" through "9" with a single keystroke and "10" through "40" with 2 to 5 keystrokes.

Clumsy but an essential part of the Stakeholders' Specifications!

It appears the code writing AIs expect to process text (effectively). So, "25", "000000000000000000000000000000025", "24^H5" are all identical and none are constrained by the interface. with a single keystroke.

I wonder what language does the most complex Hello World program.

PowerBasic:

Print "Hello World!"

John Larkin Highland Tech Glen Canyon Design Center Lunatic Fringe Electronics

public class HelloWorld implements Runnable {

private static boolean printHello = true;

private final String toPrint; private final boolean iPrintHello; private final Object lock;

public static void main(String[] args) { final Object lock = new Object(); // first thread prints Hello new Thread(new HelloWorld("Hello ", true, lock)).start(); // second one prints World new Thread(new HelloWorld("World ", false, lock)).start(); }

public HelloWorld(String toPrint, boolean iPrintHello, Object lock) { this.toPrint = toPrint; this.iPrintHello = iPrintHello; this.lock = lock; }

@Override public void run() { // don't let it run forever for (int i = 0; i < 1000 && !Thread.currentThread().isInterrupted(); ) { // they need to synchronize on a common, constant object synchronized (lock) { // am I printing or waiting? if (printHello == iPrintHello) { System.out.print(toPrint); // switch the print-hello to the other value printHello = !printHello; // notify the other class that it can run now lock.notify(); i++; } else { try { // wait until we get notified that we can print lock.wait(); } catch (InterruptedException e) { // if thread is interrupted, _immediately_ re-interrupt it Thread.currentThread().interrupt(); return; } } } } } }

John Larkin Highland Tech Glen Canyon Design Center Lunatic Fringe Electronics

It used to be called "intentional programming" the usual idea of natural-language pseudo-code, then along the lines of "literate programming", documentation more or less tracking code.

The "generative programming" has been around for more than four decades.

Since "reflection" and "introspection" then for things like "schema-driven" the "code generation", reminds of things like building UI's automatically from database schemas since the '90's at least. It's pretty much usually so with accounts of "information_schema" schema or "all_tables" and friends.

It's not a bad idea to implement navigation as accessible, even if for just one or two keys, then with regards to input methods and input method editors.

Here the washing machine has a knob and its action is due a ratchet and a spring.

"Coding assistants" after "grand schema frameworks" have been around a long time. I always wrote my own code, which usually includes reading all the code including all the framework code and even all the stack's code. If "programming is the art of naming things", it's a meticulous and informed act.

The resource model and the process model about the distributed systems here is often enough about commodity nodes and units of work according to compilation units which is pretty much about modules then that for "re-using the code" that the library design is a fundamental task for architecture.

Getting from scalars and vectors and arrays to trees is pretty much too involved for many coders.

Brand new "coding glut"? Same old "fire hose".

AI says - Writing in FORTRAN IV (standardized as FORTRAN 66) is a bit of a trip back in time! Unlike modern Fortran, the older versions were designed with punch cards in mind, meaning the layout of your text matters just as much as the code itself.

Here is the classic "Hello World" in FORTRAN IV: Fortran

C THE 'C' IN COLUMN 1 INDICATES A COMMENT LINE WRITE(6, 10) 10 FORMAT(12H HELLO WORLD) STOP END

Not bad , but I'd have put "CALL EXIT" instead of "STOP"

Bad Things™ could happen back in the Iron Age if you used STOP - so I was told anyway.

Brian

Today's Wall Street Journal mentioned that Meta has a competitor to Claude Code. No idea which is best for what. But trillionaires are fighting, so advancement will be rapid.

Joe

'C' has to be in column 6

Adding sequence numbers is a "pro tip" if you've ever dropped a deck! (I've made no effort to count the character positions to ensure they are in columns [73,80])

I think EXIT was an extension to the language (?)

More interesting was stuff like: 1 = 2 And people think writing code *now* is hard...

Dear Don Y:

By formality I mean things such as VHDL with Property-Specification Language (PSL); Spark Ada; and Protoype-Verification System (PVS).

I like constraints and enforcements thereof! I am an Adaist who likes VHDL. I like strong typing. I do not necessarily like on-the-fly constraint checking: an IDE which insists that Line X has a finished statement instead of letting me temporarily tweak Line Z before returning to and finishing Line X could annoy me. Conversely, I of course demand that I must finish Line X's statement by termination - i.e. a compiler which fails to provide a criticism that Line X is unfinished is not a compiler worth using. So I do demand enforcement! I posted a few times to news:alt.law-enforcement

(S.

Constraints go beyond "strong typing". Data can be dynamic and still tightly constrained. E.g., an "A I do not necessarily like on-the-fly