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.

I believe this is called learned helplessness.

https://en.wikipedia.org/wiki/Learned_helplessness

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.

Back in college (around 15 years ago), I read a few books on eminence by Dean Kieth Simonton. One thing that I remember, and that has always been in the back of my mind, is that certain studies found that (in the USA), children who grow up in bilingual and bicultural households tend to have a much greater chance of achieving some measure of eminence in their adult lives. I am not sure if this is true globally (nor if it is still true in the USA). But I suspect that there is a reason[0] why so many eminent people came from Austria-Hungary for _generations_ (even the generations after the collapse of that particular empire).

[0]: There were 10 distinct languages, making up 98% of all languages in the empire. My understanding is that most citizens had to learn German, even though only 20% of the population spoke German as a mother tongue. Also a few different language branches (Germanic, Ugric, Slavic, Romance), with one of those branches (Ugric) not being Indo-European at all. https://en.wikipedia.org/wiki/Ethnic_and_religious_compositi...

So, I know I am late to this discussion by a week (the coding rarely stops, and I often miss big developments), but, I was at Joyent when it was acquired by Samsung, and their interest was very similar to most Joyent customers: to find a way to shrink their tumorous, ever-growing AWS bill[0]. By acquiring Joyent, they did not have to build their own cloud-software from scratch, and they did not have to Ship-of-Theseus their internal legacy infrastructure. More importantly, they also got a team that knew how to maintain and improve that software stack.

While I practically never agree with the guy, Thiel did say that "every startup is a conspiracy". Which is just another way of saying that every business is a conspiracy. The Oxide "conspiracy"[1] is to divert a chunk of the enormous economic surplus that is being captured by Amazon (and Broadcom, and others), and in the process, put some meaningful amount of that surplus in the pocket of the customer (otherwise, there is no reason to switch).

This is an incredibly ambitious goal, that cannot be achieved without upfront capital. Part of it is certainly hardware (which is getting more expensive, rapidly, and so it might make sense to buy years-worth of it), but another part is the _switching cost_ (which the _challenger/conspirator_ usually has to cover for the customer). That cost can easily be measured in the millions of dollars (Dropbox, famously, migrated off of AWS, via a client-side reupload, because moving the data from AWS to their own DCs was prohibitively expensive[2]).

Also, WW3 is slowly unfolding. The only reason energy prices are not in "brownout territory" is because (IIUC) the world's largest oil consumer is importing half as much oil from the mid-east as it used to. A few of the things that I buy, have _not_ gotten more expensive in euros, but they have gotten more expensive in dollars (by around 5% last I checked). If you need to use dollars to stockpile input-goods, now is the best time to do that, if you anticipate that the dollar will lose value over the next year.

A similar logic applies to selling a company. Amazon, in 2016, was already on the path to _massively_ improving the performance of its VMs and cloud services (via using more SSDs, building custom hardware, etc), and bare-metal performance was one of the Joyent selling points. With the resources of a company like Samsung, Joyent could also (potentially) use faster hardware, etc.

However, even under the aegis of Samsung, some (let's call them) _political asymmetries_ could not be avoided. I cannot talk about _internal_ asymmetries, but _external_ ones are already public knowledge. In particular, in 2017 or 2018, spectre and meltdown CPU-exploits hit the industry. All the major cloud providers had advance knowledge of this (and were able to mitigate via KPTI), except for Joyent (who had to work with the OpenBSD community for a few months to fix this). In those few months, if customers wanted to be completely safe, they would have had to move their instances to a different cloud. It is unclear (to me, because I am an engineer and not an accountant or account manager) if Joyent could have survived that without being part of Samsung.

And by the way, this would not have been as urgent of a problem, if Joyent was selling physical machines (like Oxide is, right now), instead of renting them out to multiple tenants. Imagine if an adversary could just spin up a VM right next to yours on the same exact machine. Even without spectre and meltdown, they could probably impact the performance and latency of your VMs indirectly, if they were willing to spend enough money. I once did this by accident (because I, foolishly, overestimated Google) on GCP, via their lambda-equivalent, and found out when they told us that those workloads were moved to a different DC. So if this is a problem for _Google_, it's a problem for everyone.

For at least the last decade, HN has consistently (but, thankfully, not exclusively) been attacking Joyent (and now Oxide), for various perceived misbehaviors[3], while frequently letting much less ambitious projects off the hook. Engineering any meaningfully new or disruptive technology is a very challenging marathon, and doing so, in business circumstances (which can only be characterized as: circumstances where the other runners are armed and always out to get you, while sometimes, the universe itself decides to send a few lightning bolts and storms in your direction) is almost impossible, without either (1) a monopoly, like MSFT and GOOG and AMZN enjoy, or (2) massive amounts of investment-cash that can only come from a very smart and very keen sugar daddy[4].

[0]: I can't recall who said this, but someone at the time said, they were tired of buying Bezos a BMW every month (via their AWS bill). Sometimes, it wasn't even an issue with the size of the bill: Amazon competes with many, many companies out there.

[1]: Based on various public statements. So basically, the Joyent conspiracy, but this time on-prem (so maybe Joyent + Fishworks = Oxide), and with fewer faulty drives (IIRC, there was a batch of drives, worth a huge amount of money, that had bad firmware, which caused their throughput to drop sporadically -- the exact details escape me, but you can see why there is a distrust of firmware written by others (also worth noting, is that this HDD vendor did not even offer to replace the faulty drives, but instead offered a marginal discount on the next order)).

[2]: Not because of any real, physical cost, but because Amazon bills you for every byte that leaves their datacenter (but not for any byte that enters).

[3]: I think it started when Joyent did not honor the "lifetime storage" promise that it made to its customers from the 2000s.

[4]: If anyone knows any wealthy heiresses that are looking to get married (or for a concubine), in exchange for financing my ambition to build an invention that is simultaneously (1) the last invention humanity will ever need, and (2) the invention that humanity needs most urgently, please hit me up. I have a sense of humor and am hung AF.

The worst part of this, is that projects that present themselves like this, poison the pool for everyone else. I imagine that many people are now disinclined to ever publish a hand-coded project in this genre (retro-computing), because people might assume that this was a trivial project (e.g. what are you so proud of, my baby 12-year-old nephew did something similar two weekends ago, just by yapping at his phone, while waiting for level-loading-screen to finish).

The Haiku project (an OS based on BeOS), is a remarkable achievement. It is sad that we may never see such things again, because people want their achievements to mean something, and, increasingly, intellectual achievements are becoming (unjustly and misleadingly) trivialized by the LLM hype machine.

It feels like humanity is deliberately making itself colorblind.

I've heard someone say that this has been going on since 2012, because that is the year that 60% of all Americans (and probably most industrialized countries), owned a smartphone. This is qualitatively different from 60% of all Americans owning a computer (the smartphone and tablet, IMHO, is one of the greatest embarrassments of the tech industry: it is a practically sci-fi device that does _less_ than the clunky desktop computers, _by design_, even though they could probably do _more_[0]). The tech companies are feeding people misleading, enraging, and toxic content because this creates a strong emotional reaction, which is the first step to selling advertised products. For example, nobody will buy a thing they can't rationally justify, unless they can justify it emotionally[1].

[0]: For example, you can create pretty decent art on the wacom tablets, but that is such a niche use case. There are probably other use cases that are unrealized, because it might distract the precious users from their push notifications and doom-scrolling.

[1]: Which for the most part is _reactive_. It used to be that companies would invest in industrial design (or visual design) to make an aesthetically appealing product. The problem, is that this is very expensive, and difficult to repeat, because there is not exactly a science of aesthetics (nothing beyond philosophy of phenomenology and also some eastern philosophies). And so, companies use the only strategy that can scale: rage-bait, doomerism, etc. Somehow, I do not think that the executives and shareholders of these companies consume the same information diet (how many cigarette company shareholders and executives are chain smokers?). Maybe alignment requires that the people who sell a product are legally required to integrate it into their lifestyle (I wonder how many sex-toy-company executives and shareholders would abandon ship).

This feels very much like a distinction between letter of the law and spirit of the law. I knew a guy who once forked a very popular browser extension (you've definitely heard of it), that was copyleft-licensed. When I asked him where the repo is, he said it was not publicly available, but that the lawyers have assured him that he is not breaking any laws because the source code is available, via the inspect-extension feature of the browser. This answer has always felt problematic, to me.

In part, I feel like these legally-correct strategies and tactics tend be corrosive. In fact, this is exactly the kind of thing that drives projects like Sentry and Mongo to dump open source, and use EULAs instead. Not only is pgrust a license-based fork (which always runs the risk of splitting the community) it is also a language-based fork (which also runs the risk of splitting the community). In fact, the only silver lining here, is that you went straight for the AGPL, instead of MIT (thus preventing a _second_ license based fork).

A project can probably use the EUPL instead of the AGPL (EUPL is to AGPL, as MPLv2[0] is to GPL). Basically, EUPL is file-based, not project based, and so it is not aggressively viral. You can use the EUPL code any way you want, as long as you make the original code available, plus any modification to the original files.

[0]: With Exhibit B, which prevents relicensing to GPL. It is also analogous to CDDL.

My understanding is that they used c2rust, and then told the LLM/Agents to make the code more idiomatic rust, while also using the PG test suite as a feedback mechanism. This is almost certainly a derived work (and thus a fork, and should thus have the original license and copyright preserved).

For example, if I compiled PG into x86-64 assembly, and then decompiled it into C (via, say, IDA), and then polished that decompiled C code into very readable C code, it is still a derived work. For some reason, people think that if you include an LLM or Agent, copyright can be ignored, and plagiarism is now no longer possible.

It is similar to the crypto-folks thinking that if you use crypto, you no longer have to pay taxes, because the internet/computers make all inconvenient realities go away.

Honestly, such flagrant and arrogant copyright violations make it hard for me to take the project seriously, because it seems like a desperate stunt for attention (which itself may be a solid business move, but that is besides the point).

Put differently, if one were to fork pgrust, strip away the new license and copyright, and restore the original PG license and copyright (while also adding malisper+team to that copyright), they would face no legal consequences at all. In fact, they would probably be a less legal risk than the pgrust team.

Yeah, attacking the problem at the root, is even better than treating the symptoms.

This is similar to the arms-race between spammers and spam-filters, just much more capital intensive. The funny thing about the battle between spammer and spammee, is that we already had a very good solution to it: web-of-trust. We also know that empirically, there are at most 6 degrees of separation between any two random people, so it would still be possible to contact pretty much anyone, it would just take more effort and thought.

I do like the _idea_ behind Pangram, but I think that it misrepresents itself. It is a classifier (my understanding is that it uses ML under the hood, but this is not the only way to build a classifier[0]), and, in my opinion, the classification that it is trying to make (AI, not AI), is not a good long-term classification. Part of the problem is that, for now, identifying something as AI is a good[1] proxy-value for spam, but that can change in the future (I can easily see the next generation subconsciously adopting AI-prose in their speech). Another part of the problem is that, by necessity, the functioning of the detector is a secret (otherwise, AI labs can train against it), and so, everyone is trusting a black box that can become corrupted at any time in the future[2][3].

What people really want (okay, what I really want) is better spam filters and better search engines. And I cannot help but think that this involves a more detailed kind of classifier (one that is customizable and based on "lexical facts", instead a crude and opaque AI-not-AI-probability).

I do wonder, if using the AI detectors will itself cause a kind of cognitive atrophy (e.g. people will lose the ability to sniff out AI prose just by reading it, and will be dependent on the detectors).

[0]: For example, you can use fractal-dimensions (from chaos theory) to derive a specific fingerprint for any given author. People use this to see how faithful a translation of a work is, when translated from one language to another completely unrelated language. The reason I bring this up, is because, to my surprise, feeding AI-generated English text to Google Translate, and then feeding the Bengali translation to Pangram, reduces its confidence from high to medium, and its percentage from 100% to 70%. I am not sure if iterated translations would reduce indefinitely, but fractal dimensions _might_ be helpful here.

[1]: Good as in: it flags true spam more than half the time, but there are some unfortunate false positives (mostly for people who write English as a second language, like some of my friends and relatives).

[2]: We know that Windows had backdoors in the kernel, at the request of the NSA, and we know that various government agencies can read your gmail.

[3]: Alternatively, AI-labs can retrain their LLMs to sound like a specific group of people (for example, Bayesian networks can identify, just from IRC logs, whether someone speaks English as a second language, and what their country of origin, most likely, is).

In a way, LLMs have made it much more difficult to be believed. On the one hand, my inner paranoiac feels vindicated -- preparing for the worst case, over a lifetime, feels more prescient than it should. On the other hand, making decisions, specifically about how much faith to put into another unfamiliar human, becomes even less tractable.

The work can no longer speak for the human. A nightmare for the introvert.

The work, even before LLMs, struggled to speak for the introvert (and even the extrovert) -- a unique enough work usually results in puzzlement, a questioning of motives, and sometimes even overt ridicule.

Even for writing, it was a struggle. How many times did pieces of writing get ignored (or rapidly skimmed) because they were "TLDR"?

When I was very young (a teen), I wondered (after seeing the films The Matrix and Fight Club) to what degree other people were a dream-like hallucination (basically, those films made the concept of p-zombies accessible to a kid). That childish daydream, is now a reality. My inner paranoiac squeals with delight. Ah, the perversity. Even skill at deception itself can be faked, now. Even the beautiful can treated as if it were hideous.

I wonder if anyone ever made an episode of Star Trek, where one crew-member pranks another (possibly inebriated) crew-member, by having them wake up in a perfect holodeck reconstruction of their ship and crew. How long before they would notice? Weeks could go by, before a red alert dissolves the illusion.

It's after 3am, and I am not inebriated, but fuck I need to sleep. Sometimes I hope I drift into a coma, so that I can deal with things that are, on the one hand hallucinations, but on the other hand _not_ deceptions. There is a universe out there, where _their_ Matrix (film), is Vanilla Sky (amusingly, its inspiration was the film Abre los Ojos, released one year before The Matrix -- maybe in this universe, the Spanish Armada reached England).

Good night, you doomed, sad people.

This is just the rationalist-empiricist[0] tension, from philosophy. Most empiricists (usually people who are _not_ from continental European cultures), take a position that knowledge and creativity come from observation and imitation, while rationalists believe that knowledge and creativity can be endogenous to the mind.

One could say that, stereotypically and cartoonishly, empiricists believe that invention is a false concept, and a synonym for discovery, while rationalists would oppose this view.

That catch is, if you look at the etymology of words "invention" and "discovery", you will find that they both share the _same_ root: _Ars Inveniendi_.

A natural question arises: does this mean that people from a millennium ago did not have a dyad equivalent to our invention-discovery dyad? And the answer, surprisingly, is _no_. Even a millennium ago, the empiricists and rationalists were going at it. If _Ars Inveniendi_ is art of discovery/invention, then its counterpart is _Ars Demonstrandi_ (the art of demonstration/proof).

So, how do these differ? Is one just observing/creating and the other just math and language-games?

In general, Ars Demonstrandi is about writing down axioms, and then expanding those axioms recursively (similar to rewrite rules in any formal system), until you get to some end-state, or, if there is none, a novel or surprising state. I, personally, call this source-to-sink thinking.

Ars Inveniendi is about taking conclusions (often using observations from the physical world) and trying to figure out what axioms can lead to those conclusions. I, (again) personally, call this sink-to-source thinking.

Put differently, Ars Inveniendi can help one discover starting points for Ars Demonstrandi.

If you read the dialectics (e.g. Plato and friends), you'll find that most of them are just a mutual recursion between Ars Inveniendi and Ars Demonstrandi.

I believe (again, I am not a philosopher, and this is just my intuition), that the thing that we call "creativity" and "invention" _emerges_ from the recursive loop[1]. A favorite example: Esperanto (the conlang). It is a language, which is remarkably elegant and consistent and (in my opinion) beautiful, because it _is_ derived from first principles, which were themselves derived from the various languages spoken in Europe (not all of which are Indo-European -- the agglutinative features have more in common with Finno-Ugric and Turkic languages). There is something about it, that makes it _qualitatively_ different (and thus holistically novel) from all other languages (and I speak, fluently, _two_ national languages, that are very different from each other, so I can attest to the difference personally).

My guess, is that people will not accept that AI/LLMs are creative or inventive, until they can produce an original[2] (non-plagiarized) artifact that feels the way Esperanto feels.

[0]: By Rationalist, I do not mean the "Bay Area Rationalists", who are, in fact, empiricists.

[1]: I am unsure if the loop requires only one human, at least two humans, or if it can be fully automated.

[2]: Note that Centos are poems made completely out of line-numbers (e.g. fragments from the Iliad, or the bible, etc). Every line is borrowed, yet some of them are considered beautiful and original works of art. Similarly, Labatut and Burroughs and Perec, write using a technique called _the cut-up method_, where they take books, magazines, and newspapers, and superimpose page-fragments, and use that as an inspiration -- they are all considered artists, and good ones. It is unclear to me why LLMs (which seem to be built on the cut-up method, and have cut-ups of all of human knowledge) cannot match these artists. What's missing?

I mean, my point is that we would all be better off without any of the KPIs, and stack-ranking, and so on, in large part because they are not reliable metrics, and making them reliable is itself a difficult problem to solve. You need engineers that seek to understand your business, your problem, and are willing to use that understanding and their experience of building software, to solve those problems in as permanent and correct a way as possible.

The reason this is so difficult to manifest, is that only about 2% to 4.6% of the college-educated population are software engineers at any given point, which means that 95% of all the people that we interact with, have no clue what we are talking about, and do not understand why they cannot have more, more, more, now, now, now. For comparison at least 20% of people have a degree in business. And most of those, in non-concrete roles seem to be cargo-culting their way through a career.

Unreliable software is also expensive. Rather, building reliable software is incompatible with a management policy that rewards and punishes people based on KPIs (basically leading indicators). The concept of KPIs is fine, but they should (a) be actual indicators of progress, and (b) be kept secret from employees (so that we can avoid or mitigate Goodhart's Law). Both of those things are difficult, because you need a rigorous statistical model of what correlates, and you need to keep that model a secret, while also changing the KPIs periodically, to prevent employees from intuitively overfitting. That whole process would be very expensive (and if it would not, why is nobody doing it).

Furthermore, software that is reliable, is also software that is done (in the sense that AVL Trees, and ZFS, and DTrace, and ZSTD, and slab allocators are done -- they are very close to perfect, and require minimal changes, related to compilers and kernels and computer architectures). A team that builds reliable software, is a team that cannot be "managed". What exactly is there to manage?

The argument is not just "theft", and to the extent that "theft" is a part of it, it is not the most important part, not by large margin. The reason that "theft" is not a solid argument, is because people creating open-source often distribute it for free themselves. Piracy is not the issue.

The issue is that all attributions get stripped away by the LLM (even in cases where it is trivial to avoid). For example, as a test, I asked DeepSeek to tell me how one can do an exact substring-boolean-test in Common Lisp, and it gave me code that was, character for character, _identical_ to the code that appears in Seibel's Common Lisp Book. It clearly memorized the code. It stands to reason, that it could have also memorized where it saw it, and been trained to tell the user that the code was from that book (which is NOT in the public domain, despite being free to read on the internet)[0].

To give you an analogy, nobody has a problem with someone downloading and distributing the public domain works of Leo Tolstoy or Charles Dickens or Jane Austen or Karl Marx, etc. But to remove their names from those works, and placing your (or someone else's) name on them instead, is plainly malicious behavior. Such behavior needs to shunned.

LLMs (I believe) _can_ be trained to not plagiarize. They do not have to be original, nor to use public domain training-data, they just have to give attribution (which, as far as I can tell, requires little more than a corpus and a stack of similarity-measures).

I suspect that they are not trained this way, because fully automated plagiarism creates an ambiguous situation, where a copyleft license (like GPL or EUPL etc) can be unknowingly violated, and there is hardly any trace of the violation. Plagiarism is the product.

[0]: Such attribution can only make LLMs _more_ useful and _more_ widely and confidently integrated into workflows. The lack of such attributions, risks diluting the value of open source projects, as (1) a high-signal indicator of skill and achievement, and (2) a way to ensure the provenance and quality of the code (both very important, if you are considering to build a business on top of one or more such projects). Just look at all those repos that claim to have "made" Minecraft-like game or Unix-like OS, when all they did was have an LLM plagiarize the code for them. This is a kind of, at best, spam and, at worst, fraud.