RE: https://mastodon.social/@glyph/115827646863388901

@glyph i love it when i come across some line of reasoning where i do learn something new, and i feel like this thread qualifies as that.

some stray thoughts:
- the thread asks us to take a very good-faith angle on investors here, and i think i does so in a good way that can explain some parts of how this investment dynamic works. still, i also think greed, and many (big) investors being super out of touch with the general population is still a major part of how the AI hype bubble grew so big, and is going on for this long, alongside the more systemic pressures the thread highlights.
- i wonder if and how much this also plays into how easily DHH can secure large amounts of funding; afterall, he's (aside from a fascist) also long-time programming microcelebrity with good business connections. but it also kind of raises the question, what the *fuck* did this guy tell these CEOs he has direct access to what omarchy is? (not that it negates or changes the fact that these companies *are* massively funding a fascist who just happens to have the privilege of being on their contact list)

i feel like a big takeaway is that systemic issues play just as much a role in this stuff as personal failures, and in fact, the two can easily amplify each other. hm.

Margaret Hamilton, computing pioneer who led the software behind the Apollo program, passed away last week. She advocated for high-assurance software and introduced the term software engineering.

https://news.mit.edu/2026/margaret-hamilton-computing-pioneer-dies-1007

#nasa #vintagecomputing #retrocomputing #apollo

hey, does anybody know what's the current status with #nim and #LLM usage? it looks cool and modern (unlike C, which is cool but not modern, and unlike rust, which is modern but obnoxious), and has reached stable version numbers (unlike zig). how much disappointment do i need to prepare for?

it at least doesn't have *the mark* in it's github repo, as far as i can see. (btw it looks like it's also one of the projects that is going to have it's web hosting 'sunset' by the DHH industrial complex)

hm, i had this idea the other day about a puzzle-solving rouge-lite (puzzle := sudoku, minesweeper, other deduction-y fill-in-type puzzles), where the game autodetects if you are making a move you do not currently have (derived) the information to know this is a correct move without guessing, and ends your run when it does. like the challenge is to only make moves you 100% *know* are correct.
(or even simpler, make every move you make permanent, so making a mistake renders the puzzle unsolvable.)

would anyone wanna play something like that?

Description:
'lyssanetic' rhymes with 'cybernetic', and describes the property/tendency of LLMs to induce (metaphorical) madness in their users. effects range from things like mild addiction, anxiety, to decreased self-worth, social withdrawal, depression up to falling into conspiracy theories and complete disconnect from reality. broadly, any kind of psychological change that is directly due to LLM usage counts here.

this sometimes also gets talked about under the name "AI psychosis", but that term overly emphasizes only the upper end of what lyssanetic effects can look like, and it can give the inappropriate impression that they are an individual moral failure rather than something LLMs are capable of doing to you.

not everyone appears to be equally susceptible to it, but especially milder lyssanetic effects are incredibly common. people *do not* become mindless drones when under lyssanetic influence, but it can cause subtle shifts perception and judgement, like having something in the back of your mind that puts a finger on the scales of your decision-making. lyssanetic effects may uncover or amplify personal flaws and biases.

Questions:
are you a former or current LLM user? i would like to hear from you if you have experienced or are experciencing lyssanetic effects, and if yes, which; if you have recovered from more severe lyssanetic effects, what helped you recover?

(to anyone else: please withold any judgement you may have; this aspect of LLMs doesn't really receive enough attention, and we need to hear from those affected if we want to learn more about it, and what we might be able to do to help people out of it)

I was looking at this picture of brown long eared bat (credit: Amy Schwartz @lizardschwartz on social media)

And they’re so absurd??? Like what fits in that head…

RE: https://hachyderm.io/@nirbheek/117352141654374344

bit of a callout, where callout := "I want to call attention to something to have a conversation about it, do not dogpile these people and drown out the conversation as a result".

leaving out alt text to make a point is pretty crummy. blaming it on mastodon not having an LLM integration to deliver that image desription to you on a silver platter is nonsensical: if you really wanna use an LLM for this, just tab over to it. we do not need to become more like the humans from wall-e just because we theoretically could.

there is also something asinine in wanting to use an LLM for something when the right tool for the job is clearly OCR. y'know, also AI, but AI specifically made for this specific task, and from an older era that the #LLM industry would like us to collectively forget existed. remember how a very primitive form of OCR was in that slightly cringe nintendo DS game from over a decade ago, and unlike todays AI companies they mysteriously managed to stay clear of becoming a giant controversy for some reason?

most images aren't difficult or tedious to write descriptions for that are relevant to the specific context you are using them in. large amounts of text are one of the few places this actually becomes tedious, and we had the technology to deal with that (admittedly still with some hickups) since forever ago. and: if you don't like that mastodon doesn't have OCR integration, you *do* have the option of creating one and contributing it. from a glance, tesseractocr looks good, i guess you could also make a browser extension that makes it convenient to access. and i didn't look, but my gut feeling says chances are good someone somewhere even already has put in the effort to do these things.

keep in mind that css tricks is much more of an actual community resource than omarchy ever was, and has an AI statement that is, in short, "we don't use it".

even if we entirely set DHH's fascism aside for a moment, then omarchy is the kind of distro more or less anybody could run on a low budget: heavily piggy-backing off of another distro (in this case arch), with some super special customizations to set it apart. the fact that someone can easily get multi-million funding for this with relatively short negotiations while something like css tricks gets defunded (and other FOSS projects going largely un- or underfunded) leaves a bad taste in my mouth. not because this kind of piggy-back distro doesn't have value, but because it's such a crass and bizarre misallocation of resources.

DHH is throwing other projects under the bus here; he could also use his good connections to convince CEOs that other projects are worth funding as well, and he isn't doing that. DHH is the epitomy of "got mine, fuck you".

hm. hmm-hm. in case anybody is wondering how big of an asshole the digital ocean people really are:

https://www.youtube.com/watch?v=9_upvxCAUzM

The Golden Rule of Dependent Types #PLramble

in some programming languages, types can take other types as parameters. this is particularly helpful for making data structures more reusable.

some languages go a step further, and allow values to be passed as parameters as well. this is what is called a *dependent type* (because it "depends" on a value). these introduce, however, and additional challange: what it the value some type depends on is not just only known at compile time, but *produced by a computation that doesn't halt*?

there isn't a good way to interpret a situation like this; what does it mean to have a type depending on the result of an endless loop? should the program try to compute (and get stuck on) the dependee value the moment they type gets in scope? or only when that types gets used? what if the program only uses parts of the type that don't change depending on the bad value? should the compiler not halt? or otherwise attempt to detect this?

because of this, the golden rule of dependent types is thus:
✨ dependent types shall use some kind of mechanism to ensure the computation of value parameters is always halting. ✨

the easiest way of doing this, is demanding that value parameters to types are constants known at compile time. the most complicated way of doing this is including some kind of totality checker in the language.

(one could also simply forgo the rule: i'm not convinced this has much merit, as it solves the problem by simply deciding it does not need solving. but since much of the appeal of dependent types with arbitrary values (to me, at least) is as a tool for better static reasoning, that seems counter-productive)

RE: https://tech.lgbt/@monoidmusician/115685033457854645

@monoidmusician looking at this post, i'm (with my small and finite knowledge) noticing that you've effectively rediscovered vector clocks for representing posets, see https://en.wikipedia.org/wiki/Vector_clock

if i was asked to write an algorithm for this, i'd immediately think of topological orders and topological sorting algorithms, but adapting that for non-strict constraints, as well as for making it an *incremental* algorithm might still be a challenge.

what might also make any algorithm for this costly is if we collect all constraints across the entire program, and prove that "big" relation consistant; ideally, we would want to use something like module boundaries to prove each module internally/locally consistant, discard everything not visible outside of the module, and then ensure module interdependencies don't introduce inconsistancies.

i'm making a mental note to more closely examine the algorithms you've come up with when i get around to it (could take a long time).

one thing this era of #genAI keeps showing us, is that often, the thing we care about isn't *just* the literal end product, but also in the process of how we get there.

with art, turns out we do care about things like context, and what it has to say, and not just about the physical presence of something nice to look at or listen to. and while the creation of individual pieces of art can, to a degree, successfully be imitated (often with some artifacts, but it isn't always easy to tell), the larger cultural conversation that takes place through art can't.

with coding, even if LLMs produced flawless code, having humans write code (aside from personal satisfaction etc) produces humans understanding the codebase, institutional knowledge becomes an incredibly important resource when things break, or the software needs to be adapted to changing requirements. and because code produced by LLMs is not any more flawless than organic human code, things *will* break, and we *will* need that institutional knowledge.

with mathematics, a significant part of the value in solving major problems has often not just been the solution itself, but also the techniques and insights gained from trying. group theory mainly exists as a byproduct from the effort of proving that the quintic is unsolvable. lie theory came from an attempt to solve differential equations, but is now largely applied elsewhere. even failed or incomplete attempts can go on to have a second life with a different purpose.

and while AI companies advocate for us to simply consume more end product, they are also deliberately insulating us from how incredibly resource-hungry LLMs are, as if that *didn't* drive the scale of the hype entirely ad absurdum.