As far as Lisp programmers go, Joe is quite elite, though I suspect he’s got a twinkle in his eye when he says this, applying a bit of sarcasm. He’s been a Lisp programmer longer than most programmers have been alive.
The models generate Clojure just fine, with the exception of mismatching parens/brackets/braces pretty frequently. There is a tool which can correct that after every edit.
Unfortunately, I missed the Lisp machine era by a whisker. AI winter was just hitting as I graduated college (1989), and I got hired working on RISC systems, which were pretty much the opposite of Lisp machines at the hardware level. I have yet to get the emulated Genera environment running, but the repl does look wild.
Fun fact: symbolics.com was the first-ever domain name registered by IANA.
Yea, this seems to be a consistent issue. The models don’t know when to think strategically and often make local edits that keep growing individual functions with more and more conditional logic.
In the Clojure world, there is a small utility that is pretty popular called clj_paren_repair (part of clojure-mcp-light: https://github.com/bhauman/clojure-mcp-light/blob/main/src/c...) that uses parinfer’s indentation algorithm to help repair out of whack Lisp parens (and brackets and braces for Clojure). It’s easy to expose this as a skill or tool. I had Pi create me a tool in 60 seconds. I have to say that before I discovered it, I had no time for parinfer (paredit all the way, baby), but this really does the trick as often the model gets the indentation correct (from being trained on so much Python??).
There is a herd of companies all running a race. The technology is known. They all have roughly the same resources. It’s not unexpected that they have similar cycle times for model development and that those models will be of roughly the same quality. Then layer in corporate PR demands and you see all these models landing within weeks, sometimes days, of each other to keep the model developer’s name associated with “frontier” development.
Given local AI requirements, I expect minimum configurations for higher end machines to accelerate quickly. Yes, an entry level MacBook Air might be at 32 GB, but the entry MacBook Pro should quickly have 128 GB as a baseline. All this assumes we can actually make all the RAM we need. Until then, we’re going to be artificially capped.
That dynamic was exactly why I moved from Scheme to CL many years ago (full disclosure, Clojure is my daily driver, now). I loved the minimalism of the RxRS documents, but they really only covered the small core of the language, and then all the implementations were completely different when it came to libraries. And those differences always needed to be understood in order to write real-world programs. SRFIs helped, but adoption was spotty. Every multi-implementation language has some of that, but Scheme had more than most. For me, the choices were to use a very full-featured Scheme like Racket (which is great) or go to CL and then use something like SBCL. I went with CL and later jumped to Clojure (which, IMO, is a better, more modern Lisp that fits better with today’s multi-core hardware than either Scheme or CL).
I think you’re spot on here. OpenAI and Anthropic are burning cash at a phenomenal rate (clearly unsustainable in the long run), but it isn’t clear what the exit ramp is for them. If they stop training and just focus on inference (which they claim is profitable), they immediately fall off the list of frontier models. I’m sure China also sees this and is using state subsidies to fund industry and challenging the West to keep up. This is similar to the way that Reagan outspent the USSR in the 1980s, only now the Chinese are funding it. That said, it’s also not clear what happens if the Chinese models “win” (is that bad?), particularly when all the models get so good as to meet the needs of most applications. Anyway, AI lies at this interesting intersection of both standard technology competition and geopolitical competition.
Thanks. Yea, I’m sure there are corp strategies at play here. Zuckerberg didn’t just roll out of bed and decide to do this one day. Ever since the Llama 4 fiasco, I’m sure they’ve been trying to restart everything, but for whatever reason they can’t seem to deliver something on the frontier. So, when you’re behind, play the “open” card and accuse your competitors of being bad people. I’ve been a part of running this same play multiple times at multiple companies over decades.
In some aspect, yes, or they fear they will. For instance, Anthropic may fear that Chinese models will become “better” because they won’t put as many guardrails up, so they want everyone to agree to the guardrails such that if a model comes out showing better scores than Fable they can say “But it’s a dangerous model that doesn’t conform to our Pacing agreement.”
Or, they may be worried about government regulation that would really hurt their ability to move fast, so they want to get ahead of it with some “regulatory body” that they control. The motion picture, TV and gaming industries did this with self-imposed rating systems. The comic book folks did it with the “Comics Code Authority” back in 1954.
I made no value judgment about it. I merely note that it’s a game. Meta is not being altruistic or doing anything for the “good” of humanity or whatever. To be clear, I like competition with companies releasing open weight models.
It’s a long term pattern. When you’re winning (Anthropic), you keep the tech closed and try to monetize it as much as possible. When you’re losing (Meta), you open it up or drag it into a standards committee to either devalue it or slow the leader down while you prepare a “standard” version of it. You also highlight how altruistic and morally good you are for having done so. There is nothing new under the sun. It’s all a game.
I’m waiting for the bubble to pop. I suspect we’re 12-18 months away. We’re at the point where manufacturers are going out of business because the tech market is contracting so much. That’s not sustainable.
I was about a week away from buying a very tricked out MacBook Pro with 128 GB RAM, but was on vacation and worried about it arriving while I was away, and then the price hikes went into effect. Grumble. Oh, well. Serves me right.
That’s part of it. There’s also just a natural back-and-forth between what I call “time sharing” and “personal.” When the thing you want is expensive, you share it remotely, but as soon as costs fall, everyone wants it under their desk.
Any company working in a competitive industry is generally aware of what their competitors are doing. PR is an important aspect to market success, so it factors into release schedule. It may not be the dominant factor given engineering constraints, but yea, it’s certainly a factor, and a large one at that.
Yea, there were things like shift and add to do multiplication more efficiently, but they were all one-cycle instructions. It was very regular that way, all designed around a clean pipeline without a stalls or bypassing. But, consequently, it originally didn’t even have integer multiplication or division, just shift and add and a “divide step” that you could repeat/loop. Looking at the instruction set just now, I chuckled at how simple it was. It makes RISC-V look complex.
See: ftp.parisc-linux.org/docs/arch/pa11_acd.pdf
Edit: actually, it did have fixed point multiply via the floating point unit (opcode XMPYU). No fixed point divide, though.
This tells me we’re getting close to “peak bubble.” We saw these same sort of stupid headlines just before the dot-com bubble popped, too. When companies are distorting regular business to do the new thing, they’ve gone past the point of reasonableness on the new thing and we’re ready for a snap-back.
I worked on the first PA-RISC workstations (“snakes”, 1989-1991). PA-RISC started as a fairly pure RISC design and was consequently very simple and predictable (short pipeline, 1 delay slot, no complex instructions). The philosophy of the design team was to make the system fast with high clock speeds, short pipelines, and big caches, all big fundamental variables in the performance equation.
Alpha was much more sophisticated but also a lot more complex. The Alpha memory model, in particular, was quite complex with lots of cache control and barrier primitives, IIRC. But it could fly when you got the stars to align.
Edit: Alpha also came out later and PA-RISC also got more complex in later generations.
Yep, exactly. Engineers always think these sorts of “ask the user what to do” mitigations will be effective, but they forget that users have no clue and the repetition causes users to tune them out. And I say that as an engineer.