nz

To be fair, Open Source has always been a threat to proprietary software. To be concrete, and I don't care what anyone else says, I will always prefer Krita to PhotoShop (because it is free, open, _and_ better, IMHO).

LLMs just make it possible to get a minimum-viable-clone very quickly (whether it is as good as a traditional open-source re-implementation, is a different matter).

The only software that I am happy to pay for is: Mathematica, and a handful of video games.

A big problem with patents is that they are designed to deprive other people of the right to practice an idea. Even if all software was automatically patented (somehow), you almost certainly would not be able to afford to defend your patents. And even if patent-defense-costs became socialized, you would still have to ensure that you are practicing fewer _external_ patents than _internal_ patents (otherwise, your royalty costs will exceed your royalty profits).

Edison industrialized the creation of patents (e.g. he would hire thousands of bright young graduates, and have them invent things, and then patent them in his own name). I once read a book that said Thomas Edison was the "greatest inventor" because he held thousands of patents. The reality is that he invented a tiny fraction of those patents, and he merely put his name on the work of other people.

My point is, if the auto-software-patent scenario becomes true, then wealthy people/organizations/oligopolies will create a patent-factory, made of either people, LLMs, or (more likely) both.

In a sense, OpenAI is already doing this for mathematical theorems (they use both LLMs _and_ a team of world-class mathematicians, much like Edison did in his day).

When I was growing up, patents were explained to us (children) as a means to protect the brilliant, solitary, but underfunded inventor -- a way to even the playing field. This has not been true for the entirety of my lifetime (36 years now), and has probably been untrue for the last century, at least.

The laws are not there to protect you and your interests, but rather they are there to protect the interests of the oligopolists (any protections you receive are _downstream_ of that).

If you want protections, you need to be sitting on top of a giant money-faucet. If you are already sitting on the money-faucet, then you probably don't strictly _need_ the protections.

Making money off of software has been a disappointing business for a while now (e.g. when I started out in the industry, the dominant business model was: turn a free Unix tool into a SaaS, and charge the innocent computer-user extortionary rents, or feed them ads, or both). The current business model is: sell plagiarism as a service.

The only reason that people talk about "moats" is because rent and food and healthcare are not free. The LLM companies are in the business of draining every moat they can find, and use the water to fill their own moat. Relying on the law to protect your moat for you is a fantasy, because every successful company finds a way to avoid or externalize the consequences of breaking the law.

Furthermore, the laws get changed whenever they become inconvenient. For example, the draft-age-limit was 35. When the Iran War started, I was relieved that I would become undraftable in less than a year. But a few months ago, they raised the limit to 42.

My rhetorical question to you (plural) is: if the establishment can change the rules, whenever they deem them inconvenient, why should we not _break_ the rules, whenever _we_ deem them inconvenient?

Who hurt you?

I mean, most of the code is open source. With enough enthusiasm and skill, you could probably make a reasonable home-lab out of that code, and some second hand hardware. And yeah, it would not be _hardware-software-co-design_, but it would be better than nothing, plus you will -- for a brief shining moment -- be the only person on planet earth (who is not formally affiliated with Oxide) who has an Oxide home-lab.

You could be a hero. A legend. The internet might even write poems and sing songs about you.

It's all software in the end. If you plan ahead, it is hard to be completely locked in. I worked for a company, where we had build a data transformation pipeline, and we had GCP and AWS credits, and wanted to use both of them. We built a minimal, high-level library that could be mapped onto both PubSub and SQS (we were transforming the WARC files from the internet archive, in preparation for data analysis). Once we built this, and worked around the near-criminally incompetent design of SQS (e.g. PubSub does compression, batching, and does not send duplicate messages, while you need to all that yourself for SQS), we were able to use both clouds (for free) at the same time, and we were not locked in at all.

In fact, we had a call with some people who worked at GCP, and I (naively, and excitedly) mentioned that our design is simple/minimal and cloud-portable. A miasma of awkwardness fell upon the conversation, and I realized that the reason that the GCP people were so keen to speak to us, was that they were anticipating, that once we used up the credits, that they would then get regular recurring revenue from the company.

Most cloud companies are in the business of locking you in via very convenient APIs, that would be costly to migrate off of, if you did not abstract them away to begin with (naturally, the egress costs cannot be abstracted away, but those were not much of a problem in our case, because our output-data was very small compared to the input-data).

There is an expression in my native language: he who lacks virtue in the head, has virtue in the legs.

Tried to share and explain that paper to a colleague a few months ago (in relation to discussions about agentic coding and whether you should read the code), and they did not really get why the analogy was relevant outside of compiler-design. I think you overestimate the caliber of the typical working programmer.

The LLM companies, like most SV companies, are just betting on dimness, laziness, and impulsiveness. Not so different from tobacco and alcohol companies.

Many languages can compile a subset of their code to FPGA HDLs. Back in the 80s Harel's group had statecharts that were compilable to C, C++, and FPGA HDLs. Not sure that LLMs brings anything substantially new to this.

Someone once told me, any illegal thing can become legal if you add extra steps. This is not _legally_ true, but it is _practically_ true. Evading a tariff is illegal, until you start using a proxy-country. Firing an employee, and not giving them severance is illegal, until you find a way to make their job so miserable, that they quit on their own. Really, if you can turn signal into _noise_, it becomes difficult and expensive for the enforcement organs to actually enforce their own rules.

It is unclear to me just what percentage of tech-companies, are in the business of adding extra steps to an illegal process, of turning signal into noise. For example, the vapes made by Juul are a kind of hack around public health laws. The Amazon marketplace shields merchants who sell counterfeit goods. Uber and Lyft bypassed the local laws that applied to taxi services and the medallion system. Airbnb did something similar with the laws governing hotels, and delineating who owns and who rents.

It is a special kind of disappointment, to be someone who loves technology, and to have to work in the technology industry -- because it appears to be run by people who hate everything that is not money.

People were always able to "instantly use it at the drop of a hat" (paraphrased). What people are objecting to, is instant use without any acknowledgement or attribution (the minimum courtesy). They also object to being mistreated by people who have never actually had to type characters of code into a text-editor, or figure out how to use a build-system and version-control-system. And finally, they object to having their _free_ and _generous_ labor turn millionaires into billionaires (and billionaires into trillionaires), while they themselves still have to pay that one mortgage they have, and medical bills, and tuition, and so on.

They object to the systematized devaluing of their work. They object to becoming a class of invisible laborers (who only become visible when there is need to blame someone).

Funny how, when Aaron Swartz did the exact same thing (in a much narrower and more focused way), he was driven to suicide by the US government, but when Sam and Dario do it, people argue about whether (or not) "IP is real".

Note that society is more about justice than it is about philosophy or logic. Whether you believe that IP makes logical sense or not, is not terribly relevant through the lens of justice. To allow the Altmans and Amodeis of the world to escape the kinds of consequences that Swartz could not (despite having purer intentions than either -- despite being a genuine utilitarian, instead of an aspiring oligarch _pretending_ to be one), would be the height of injustice.

It would be a grotesque and cruel insult to all the people who remember Swartz, and share his values and optimism about the internet and computers.

This site actually reminds of the TUIs that one uses to install an OS from the text-console. It's not so bad. The prose itself is irritating. The site itself also has some bugs (text overlapping with UI borders for no reason). The lime-green color is a little awkward to my eye, but maybe that's just me (I say this as someone who usually likes lime-green -- maybe the problem is that this site needs _more_ lime-green).

I am not calling it GP. I am pointing out that AI-coding systems tend to resemble GP systems in terms of both broad architecture, and in terms of how the code/genome is generated. Also, I already mentioned domain specific languages, in the context of GP, and how (effectively) creating one (i.e. selecting only relevant genes/verbs) that was a better match for the problem domain, made the GP find a solution infinitely faster[0]. Clearly these two things are not contradictory, and are clearly related, to the point that they can be combined. I am not sure what about my comment gave you the impression that I thought one was contradictory with the other. Hope this follow-up clears things up.

[0]: Because, in effect, we are decreasing the size of the search-space. Every programming-language project is basically a set of bets, that the design choices will decrease the size of the search space for the users of that language (most Unix commands fit this pattern, as do most well designed APIs). Mathematics is similar, in that the notation is specialized and sparse (even the named constants and variables have symbolic names, instead of meaningful names). Most system dynamics models could have the names of entities replaced with id-numbers, and they would continue to function. The whole point of (for example) a library is to give a tiny parameterized notation/language, that the user can use to express a solution to their problem, in terms of the problem domain itself. This decreasing of the search-space, is an act of compression. I have to say, I am a little confused by your reply, because it has the tone of a disagreement, but it does not really disagree with anything that I have written. Also, I have given various examples to support my analogies, but you have offered zero examples, and I suspect that there would be less confusion (on my part) if you did.

The various advances in LLM technology tend to rhyme with the advances in computer programming in general. For example, the stunts that involved getting LLMs to create compilers and browsers are really just extremely expensive[0] versions of genetic programming (none of it would have worked without using the test-suite as a fitness-function). The recent news of migrations from one test-framework to another (featuring Asana, I believe), was something that we could always do trivially in a language that was based on S-Expressions (Lisp, Scheme, etc).

In fact, both Cyc and the "AI" Labs have the _same basic thesis_: Intelligence is, primarily, a data entry problem. They just disagree about what kinds of heuristics should be run over that data (logic-programs, neural-nets).

Whenever I read about someone using LLMs to write code, it _very closely_ resembles how Lenat was using Eurisko/Cyc to solve problems: they let the system run continuously, and they "nudge" it in "interesting" directions, "when it gets stuck", or "runs out of steam". (Quotes indicate their phrasing, not mine)

Even Lee Spector noticed something analogous with his genetic programming system. When he tried to get it to discover optimal data structures (or maybe it was sorting algorithms, I forget), the system would quickly "run out of steam", without a solution. But when they added new verbs/opcodes to the system, that were a better fit for that domain (e.g. index-based memory loads + stores), it converged on a solution very quickly (even for GP, domain specific languages keep delivering unreasonable wins). You will note that this rhymes with the "micro-theories" of Cyc, which in turn rhyme with the SLMs of the AI labs.

In my personal experience, most of the "silver bullets" do not work (obviously), but some of them do nudge you towards being a better programmer (by refining your intuition about the problem specifically, and computers more generally).

EDIT: just remembered something. LLMs tend to produce larger and larger programs over time, and most people (IIRC) interpret this as a kind of entropy. This happens to rhyme with a similarly observed behavior in GP. Most genetic programs that do not have a fitness function that rewards smaller size, tend to grow in an unbounded way. The reason for this, is that most of the code/genes are useless, and random mutations do not lobotomize the program under evolution. I suspect that the coding LLMs tend to grow their code for similar reasons.

[0]: I suspect that, this was mostly a triumph of enormous amounts of hardware, more than the actual LLM technology. I further suspect that a traditional GP approach, on the same quantity of hardware, could have gotten there faster (if not better as well).

This is a lesser-of-two-evils situation. Before acquisitions became the new "meta" in Silicon Valley, the old meta was that gigantic quasi-monopolies, like Microsoft, burn money and man-years embracing, extending, and extinguishing your product.

I heard (literally with my ears, during a pseudo-dinner-thing, so this may be apocryphal, so you may have to do some spelunking through sources) that Microsoft "bought" the source code of some browser-project, for a percentage of the revenues that come from Internet Explorer. The catch was that IE was bundled with Windows for free, so a percentage of zero is zero.

A definite fact, is that when Netscape folded, the industry -- and the investors that got burned by the rapaciousness of Microsoft -- finally got in-sync enough to lobby and agitate for the antitrust lawsuit that almost broke Microsoft up. A consequence of that lawsuit is that quasi-monopolies like Meta, Google, etc, started buying promising startups instead of burying them.

I am not sure that a world where Nvidia just out-spends Hugging Face, via its quasi-monopoly-revenues, is better than the one we are currently in.

If I have to choose between two evils, I'd obviously choose the lesser one. But maybe we can do even better, and choose the absence of evil?

Maybe companies should have "weight-classes" the same way that most sports have those, to match opponents. (After all, despite both being remarkable sportists, Koga cannot defeat Ogawa, who is a few weight-classes heavier). Something like this is how France protects (or tries to) its own small business owners (I am told, they still have many small independent bookstores, despite competition from Amazon, and chain-bookstores before that).

The venture-capital does _somewhat_ balance the scales, but not by much, and it encourages the pursuit of _exits_ instead of _excellence_ (not shaming anyone for taking an exit, I am just saying that the alternative is systematically penalized -- only the very lucky or very protected can pursue excellence).

A friend of mine was once tasked with writing a kind of simulation that simulates millions of scenarios per session/run, and searches for a best-so-far solution while doing so. He proposed writing it in Rust (justifying it as: fast, low level, fewer memory bugs, fewer parallelism bugs (so potentially faster than "fast")), and management over-ruled them, and insisted on using raw/plain Python (without even an underlying C library), "because that is the industry standard", and "premature optimization is the root of all evil", and "nobody else knows Rust"[0].

Another friend, worked at a company, that got a new manager (I think as a result of a merger), and that manager halted all work on "yak shaving" projects. These "yak shaving" projects were things like logging, and debugging, and some kind of integrity-verification. When asked why they were being halted, the new manager said: "none of our customers asked for any of these things". When told that these things enable the team to produce a better product for the customers, the manager (I am told) looked at them with confusion and suspicion. Those projects were never improved since, and the product stopped improving as well. I am not sure if it affected their business (the pandemic was much more distortive).

What you call "business logic", is not even logic, and it has little to do with business. It is what Feynman called a "cargo cult". The obvious name for it is "cargo cult business management/logic".

It truly is embarrassing and shameful that after decades of idiotic decisions, it took a _trillion_[1] dollars of investment into a chat-bot technology, to finally crack open _one_[2] door to slightly less idiotic decisions, while opening dozens of new doors to decisions of an unknowable character.

Most companies (and, consequently, their engineering organizations) are simply _cosplaying_ as the things they are supposed to be.

I do not see how an AI assistant (or any kind of assistant or consultant) can save these fools from themselves. The only logical explanation is that most software companies are cursed -- you would have much better luck engaging a witch-doctor.

[0]: Nobody else knew C or C++ either. The fact is, that nobody cared. In fact, even Go would have been a better choice than raw Python, but nobody cared. Even Common Lisp (which is at least as abstract as Python, and has native execution speeds (GC and runtime type-checking can be turned off for compute-heavy workloads that mutate data in-place)), is a better choice, and yet, an _abundance_ of obviously superior options (all implemented and maintained by obviously superior engineers) was not enough to prevent the organization from choosing an inferior one, and using it stupidly (without a fast native-code component).

[1]: I see estimates from hundreds of billions to a trillion, depending on how you count it.

[2]: The performance door, if Luu is correct.