skydhash

> Combinatorial complexity. It's the essential problem with software systems

After using OpenBSD for a while, I fully adopted the “write less code” approach. Create the simplest solution and leave “features” out until you need them. Nice to have should be practically banned.

But code is the mean to get an idea across to someone. It’s the difference between “I think this can work” and “I’ve worked on this and it does work”. I’m part of the OpenBSD mailing list and it quite nice someone sharing a diff for an idea or experiment. It may not get merged, but it’s better than realm of deliberations.

The issue is with the people sending code for reviews, not people reading the slop commit message.

> as someone coming from software I find learning electronics pretty hard as it requires a completely different mental model and way to approach systems

I went from electronics to software and one thing that has puzzled me is how much people dislike reading docs as in reference manuals. People can get by with sloppy code full of hidden bugs and when those bugs arise they’re like deers frozen by headlights.

Imagine building a circuit without any ideas how it operates. I’ve encountered web devs that don’t understand how http works.

> Open source programs could be more like motivated explanations of computation.

It is already that. Every time a method/function is created, a structure is defined, a variable is added, a file is created or renamed,… It’s all for the purpose of human communication. The computer only need binary in a single file.

But people feels like they should be able to jumpninto curl code without any understanding of networking, or linux code with no knowlede of computer architecture. Few code are meant for total beginners.

We have good engineers that gave us curl, ffmpeg, the 4.4BSD, tmux, vim and emacs, x11,… To this day, no one can show any particular important software that comes from LLM assistance at scale. It’s all slop.

The thing is a text generator. It generates text. You can couple that with any code that gives rhe ikkusion of a normal decision workflow, but it does not make any decision more than a software like latex. According to your definition, the latter would “decide” the amount of words to put on a sheet of paper.

> I’m not saying gradient descent was empirically discovered, I’m saying that its use in machine learning is itself a form of empiricism. A repeated observe/adjust-based-on-data cycle

The data is the input, the output is to generally find the lowest amount of a loss function. It’s a greedy approach because brute forcing is inefficient.

It’s no more empirical than a greedy algorithm for scheduling.

> In contrast, we do not understand LLMs in the same way

From my point of view, (not a ML researcher), it’s due to the magic of numbers. The same thing happens with computer vision and neural networks. There’s a bunch of magic weights that get created which has no meaning by themselves, but computing them does help with detecting objects.

So if you take words, derives them into tokens, use the attention techniques to extract the “coherency” aspect, it’s no wonder you can replicate “coherency”. Add reinforcement learning to that to increase towards certain aspects like correct code syntax and you have heavily loaded the dice again.

We have used maths to model chemistry, biology, and physics, as well as economics and sociologic phenomena. Then we use maths (more specifically logic and set theory) to usher in the age of information and computing. Now you want us to act surprised that maths, through ML, can model language.

Maybe further down the line, we can have a simpler set of formulas for language coherency, but for now we have to make to with using the whole internet and a bazillion watts of power to guess the weights for the generic ML model.

> The best moments of these is even when they are confusing on purpose, because imprecise language is a gateway to deeper levels of meaning through fourth-wall breaks, metaphor, analogy, and humor.

I don't agree. Because those metaphors and other word plays reach deep into the human mind (at least for the purported audience), while most technical writing try to be more explicit.

Here is the introduction for Laravel Socialite

  In addition to typical, form based authentication, Laravel also provides a simple, convenient way to authenticate with OAuth providers using Laravel Socialite. Socialite currently supports authentication via Facebook, X, LinkedIn, Google, GitHub, GitLab, Bitbucket, and Slack.

And this is the marketing blug of Shadows of the Gods by John Gwyne

  A century has passed since the gods fought and drove themselves to extinction. Now only their bones remain, promising great power to those brave enough to seek them out. 
  As whispers of war echo across the land of Vigrid, fate follows in the footsteps of three warriors: a huntress on a dangerous quest, a noblewoman pursuing battle fame, and a thrall seeking vengeance among the mercenaries known as the Bloodsworn. 
  All three will shape the fate of the world as it once more falls under the shadow of the gods.

One is direct, with not a lot of imagery, but rather use specific concepts which has precise meaning. The other is just as clear, but use concepts that ties to bigger ones. They are not imprecise, they just let you be aware there's a bigger canvas than the literal interpretation.

I was reading the manual of a car head unit, and it was better quality than 99% of AI flavored content.

If you use a loaded dice, you can be pretty confident about where it will lands. It may not be 100% accurate, but can be quite close to certain. Without training the weight are pure noises. After training, it leans towards coherent sentences and particular statements.

Sometimes the end result is good, but the means aren’t. With the “give me something” approach of most LLM usage, often you won’t realize you have bad code full of hidden bugs. Often, the steps are “it works on my machine” follows by an error in prod.

> but they probably did just that because I never heard a human being say "load-bearing" before but now it's all over the place

I have but it was a house construction worker explaining its practice on youtube.

> without safety protocols

That is always the key. There’s no need for AI in that mix. Imagine a gun without any safety, a blade with no handle, a car with no brakes, a fan with no guard, no fuse for an electrical installation,…

You evaluate the risks and you take proper measures to ensure mitigate them. Not doing them and then complain that a technology is dangerous is like doing 150 km/hr in a school zone to show that cars are dangerous.

My coding by hand is always exploratory. Either I’m getting familiar with a new library/platform or I’m sizing up the architecture of the software. Then it’s a heavy dose of copy/pasting, snippets, and emacs-fu. What I spend most time on is reading docs. Apart from that, it’s thinking (mostly away from the computer).

> find myself trusting the LLM better than I ever trusted a development team to deliver accurate work

That’s the main issue. You’re talking about the development side guarante, while the most important is the user side guarantee. There’s a lot of talk about liking LLM interaction, but no comments about the software quality, which for a lot of SaaS has gone downhill. It’s why they emphasized LoC and number of PRs but hide the number of bug tickets.

Which is why the most enthusiastic comments are about projects not released yet. Greenfield and released projects are different.

I’m sure that in every case where there such non deterministic abstraction, it’s been always statistically or with a lot of hand waving. So with a heavy dose of expected errors.

Pro LLM users don’t want to talk about the error margins of whatever practice or product they’re putting out.

Building software for me has always been about creatin a set of concepts (data structures, basic behaviors) out of the primitives of the platform (language, libraries,…) and then coordinate their behavior according to the requirements.

Based on comments here, LLM users belong in two categories: Those that don’t understand the previous paragraph and those that believe they can get the concepts and coordination out of prompts and specs.

But for both of them, there’s a common trait, which is not caring about maintenance. And you can observe this today where most AI projects either don’t survive the public release or have to revert to more traditional methods.

That’s the power of abstraction when there’s a good API around something to hide the internal that doesn’t matter much at an higher level. You only need ‘open’ and ‘read’ instead of dealing with disk access and file system trasversal.

But those abstraction are deterministic in nature, so there’s a very good guarantee of their behavior. Someone using LLM and not caring about the generated code is just asking for trouble. The code may work, but there’s no guarantee about its behavior (including error handling and edge cases).

> the food you buy at the store or restaurant is heavily regulated, provenance established, safety checks in place. When there’s a widespread issue, we have systems in place for recalls

I live in a country where those things are not regulated and you have to be really careful to not buy something that would send you to the hospital.

> The overall point is that you learn through observation and lots of trial and error

That’s the most inefficient way and people usually avoid doing that. Instead they find someone that knows how to do the thing and ask him to be a teacher. Or use a proxy like a book or videos.

> It feels like you're trying to say that humans never make illegal moves while learning chess, which doesn't match with my experience. I'm trying to understand your overall point

There’s learning the basic stuff (which is done after a few games) and there’s mastery. The thread started with the observation that even with all that knowledge (through content ingested in training), LLMs still makes illegal moves. Humans can be erratic, but they can constrain themselves to the rules for the task at hand after learning them.

> The only way you get better at chess is by playing a lot of games and learning from mistakes

How can you play without being aware of the rules and how can you learn from your mistakes without knowing they are mistakes? That’s what I said about reading a book of two. It is to kickstart the process. Then mastery is gained over time through practice.

This kickstarting then gradual refinement is how most people learn. And the foundational knowledge stays. Even a basic player knows to not do illegal moves.

> There are probably fewer fields where you can verify rewards than one might hope.

2 tasks I've done today that I believe robots are nowhere near being able to do: Cleaning my wardrobe and draining bad fuel out of my generator. As in generic use cases.

Pretty much this. Feed it a book or two on chess, and you should have a decent (or good) player. That's the generic intelligence people have. The aims is not to be supremely talented at something, but being able to read a manual and figure how to use/play something. Mastery can be gained overtime.

It’s called incremental search and it’s useful, but only when there’s some debouncing involved and the search results is presented at once or the items are sorted by the order they are found.

It would be a skill issue if someone would show they’re able to use it to produce good software while showcasing that it’s due to their mastery. Till this day, I don’t think there’s any such demonstration. Any defects of the technology is always blamed on skill issue.

> "ooh it would be cool if" had to answer to "yeah but it'll take too long". Now, it's more like, "how important is that really?" to stupid ideas that never would have seen the light of day before.

My answer was it to "ooh it would be cool if" has always to build a PoC of the thing or a MVP, then I can flesh it out when I need more features. Sometimes a web app can be a single PHP script, and a cli command can be as simple as a single file C program. Or using tkinter with python for GUI.

The answer to "ooh it would be cool if I can travel fast" is not "yeah but it'll take too long to build a car". It's "let's build a kick scooter first".

> yes, being able to bang out leetcode hard from head on an interview on paper matters so much... oh wait. it does not.

That's about reciting standard data structures like stack and queues. I think parent is talking more about the design of primitives for the domain of the software. That requires creativity and insight.

That reminds me of something on my last job. Before AI, we had not so good communication, but if we had a question, the person on the other end will try to give you a passable answer. After AI, everyone seems to be a proxy for the LLM tools they're using and any misleading statement you point out is answered by "Why don't you use $llm_tool to check it out?".