adamddev1

I wrote something original in a language learning grammar online. I coined a term to describe something about how a certain language with negative language functions.

I tried talking to an LLM about it and sure and enough, it had scraped it and learned to use that terminology and explanation that I made up. I asked the LLM, "Where did that concept/term come from, who made it up?" It did a bunch of searching and tried to site a whole bunch of other sources which did NOT contain the terms of the explanation I had written. It simply would not cite or mention my source. It kept parroting my material semi-correctly and hiding the source. By any other actor that would be an egregious act of sloppiness, dishonesty, and plagiarism.

Generative AI is speed-running a widespread corruption of truth. I do not believe any of the gains are worth this.

Or like the difference between chemistry and alchemy? Understanding and reasoning with the building blocks as opposed to throwing random stuff together, trying different things and hoping it somehow produces gold.

I like the name `fold` as used by Haskell, Racket, et al. It gives me an image of folding up a long list into a ball, one chunk at a time.

I just pulled a PWA app off the app store and I am going to keep it a pure PWA. It's installable, offline-first. I know I feel like I'm swimming against the current but I would love people to try to push for awareness of PWA installs more.

LLMs are probabilistic, not deterministic.

Yes of course, but you also understand that as Dijkstra said "tests cannot show the absence of bugs."

Tests can show you problems, if you can find them, but they cannot show that there are no problems. Property based testing or fuzzing gets your more coverage, and is a good step, but it is still nothing compared to proving things or understanding how something is built and that it is solid. Testing works towards checking for reliability and robustness, but often it's only 10% (?) of the job.

Compilers are deterministic.

Testing is an extremely inadequate measure of reliability and robustness.

Would I be wrong to assume that you are building end-user applications?

If people use AI for libraries, OSs, and mission critical software, the apparent productivity gains would have to be weighed against the reliability and performance hits that bubble up to the things that are built on them and rely on them.

A similar line of thought is used to justify corruption:

"Corruption is not going away so people will have to get used to it. The alternative is making less money than people who are happy to take bribes."

The first thing I notice is an AGENTS.md in the repo.

There's also often the obligatory "well, we still have to use these tools so perhaps we could use them better like this." As if just not using them wasn't an option.

Reminds me of the good 'ol Apple II BASIC. You can name your variables whatever you want, but only the first two letters matter.

It was a joke if you read the article.

Right, programmers also use randomly generated info from property based testing for example? But I was referencing the analogy to the abacus, calculator, logarithms, analysis, and higher level languages.

> Have mathematicians become "less savvy" since the invention of the abacus or calculator? The invention of logarithms or analysis?

This is not a fair analogy. Those things are like compilers, languages, and type-checkers. They are deterministic, carefully proven, hand-crafted tools, that allow people to go safely to a higher level of abstraction and still make things in a deterministic way. The jump into the fuzzy world of LLMs is a completely different thing. It's different than the jump from assembly to a higher-level language.

> “I’ve told four separate therapists about Typebase. Two stopped taking me as a client. The other two are now shipping an app with it.”

So good. I laughed out loud at this.

It would be amazing if everyone would boycott the app stores as much as possible and normalize PWAs. People would learn if they got common enough. But alas, I doubt this will happen.

I love having auto-generated subtitles available, but I am still skeptical that we can call them "accurate" yet. For many languages the models are quite weak, and even for English and German on YouTube I see errors all the time.

> it will also unlock pretty insane scaling and productivity

Insane scaling of bloat, bugs, and technical debt I'd say.

> We will manage it on either end via requirements and tests

It is so crazy that this is being touted as a sane strategy. When I was a much worse programmer, I tried to write a big complicated string manipulation function to take two types of scripts in a language and add diacritics. I had the requirements very clear. I had the tests very clearly with all the edge cases. But I didn't have a good and clear picture of how to attack the problem which was quite novel for me. As I got closer to passing all the tests it got exponentially more unruly and confusing. And nearing the end I was frantically changing little bits here and there wincing and praying and hoping the tests would pass. "Please work! Come on!" Then when I got close enough, I could never ever think about touching that mess again.

I was a below average programmer then throwing myself at some novel problem I didn't understand. Throwing LLMs that produce below average code at novel problems and relying on tests and requirements is not where we want to go to make real progress.

(Years later after much learning and coding myself I was able to redo the function in a totally different way. This time I actually understood how to attack the strange problem and made something clean, clear, and robust that just worked. The tests then become a secondary guardrail, not the main force of correction.)

We are seeing such a massive regression from what we've learned over the years of CS.

It is self-serving to say "the code base is no longer important" for companies that want to sell you LLM tokens for swarms of agents to have to constantly burn away at a pile of increasingly messy and broken code.

If they can convince people to never look at the code, the people will have no choice but to keep throwing more and more piles of their product at mysterious blobs of codebases that become increasingly difficult and expensive to manage.

The graph of the engine efficiency vs number of horses per person at the end doesn't fit IMO. I am tired of people trying to make these analogies between the following transitions:

- Horses to Engines

(non-deterministic to deterministic)

- Assembly to Higher-Level Language

(deterministic to deterministic)

- Higher-Level Language to LLM Prompts

(deterministic to non-deterministic)

These things are not the same. They are all fundamentally different transitions.

I don't understand how people talk about how Python is "easy to learn for beginners" or "easy to understand." To me it's so hard to remember and follow all the weirdness. Racket / Scheme / I dare say even Haskell would just be so much simpler for learners.

I'm with Conal Elliot when he said on Type Theory for All that it is sooo much harder to understand a program in Python.

ASM to a higher level language is a jump to a clearly defined higher level language through a deterministic compile step. The jump away to LLMs is something completely different.

We are spending sooo much for our intellectual time and energy on discussions about alchemy-like experiments with different models, agents, harnesses, orchestrations.

And there are huge amounts of time, energy, and writing sunk into arguing about AI or trying to convince people of the danger or problems.

Sadly all of this is taking time away that could be spent on real progress and learning about coding/FP/PL/algorithms/type theory/etc.

Tests do not prove the absence of bugs.

I just SSH into the servers when I need to. I don't have any VPNs with these servers. I just try to follow normal server security setup practices, disabling password authentication etc.

Furiously prompting Claude, "please, please fix this!!!!"

I was in a very similar situation and this is what I did:

- put Forgejo on a little $5 Vultr VPS (I share the VPS with other things, Forgejo doesn't need much resources. I also added some block storage to host my Docker containers in the Forgejo Docker registry)

- got a 8GB ram cheaper Hetzner VPS (you have to wait for their availability) for around 8 EUR and used that to install the CI runner

- Use Netlify for hosting static sites and PWA

It takes a bit to set up but everything works snappy, clean, and flawlessly. I have unlimited CI minutes. As a bonus I get free Docker image and registry hosting because it's included with Foregejo. I am so, so happy with it all.

Also with Forgejo you just feel like you're using something clean and solid. GitHub started to feel more and more bloated, slow, and unstable.

This looks like a really cool idea. But since it's a new project and has all the Claude stuff I immediately feel unsure about the solidity and reliability of a security-critical piece for software like that. I wish I could go back to my pre-LLM levels of skepticism.