Why are authors of highly performant code allergic to readability?

Could there be a "greater" GPL which explicitly declares that the constraint extends to use of the code as statistical data, such as in machine learning models?

I love Rust's error messages, but I think they were trying to be a little too smart with the error reporting here and ended up relying too much on properties of the medium.
How the fuck do I tell which is which?

My hypothesis is that because #3 can only be a lower bound based on the phrasing of the sentence, and because #2 is an upper bound, the correct order is 2;4;1;3. But why do I have to do intermediate level English grammar exercises to read my error message?

[Rust]
I have a bunch of computational steps in a Rust program, all very expensive. They all depend on each other, forming a cycle-free and rather small graph of dependencies which is not a tree. The results of each of them for a given input are likely used tens of times by the others, so I would like to cache the subresults dynamically.

How would I go about doing this, considering that caching (rightfully) requires mutable access to the cache and multiple operations often refer to the same subresult?

I can't ask SO because they'd just tell me to use another language or recalculate everything every time, fully convinced that difficult questions can only emerge from design mistakes.

The moment I turn off my laptop in anticipation of an hour or two of recreational YouTube binging and then rest

- my Bluetooth headphones run out of juice, courtesy of over 12 hours of semi-constant usage and the fact that I didn't think to charge them overnight

- In a moment of perspective change I instantly realize how to solve the problem I've been struggling with for the past 3 hours, ensuring that I'll keep thinking of work for the following 5 too.

What's your idea of a perfect number?
Mine is:

default decimal, prefix for binary, octal, hex

Integers in natural notation with strictly positive exponent

All bases allow natural notation, where the exponent is always a decimal number and represents the power of the base (0b101e3 = 0b101000)

Floats in all bases allow a combination of natural notation and dot notation

Underscores allowed anywhere except the beginning and end for easier reading

I'm mostly self-taught, but there are a couple people who defined my understanding of computing

- My amazing elementary school friend whose father worked at IBM and who initially turned my interest from astrophysics towards computing. I don't know whether physics would've been fruitful but I know computing is.

- My high school friend, who taught me the basics of OOP. Though we agree on almost nothing today, his explanations about code quality defined my understanding of the matter which I then used to draw completely different conclusions

- My high school mathematics teachers, who tolerated the way I abused every tool at my disposal to construct proofs that resembled a rollercoaster, and helped me develop my own understanding of mathematics

- 3blue1brown for producing replayable videos in a similar quality to my high school maths lectures with additional stunning visuals. No content on the internet fits the way I think quite as much as that channel.

Is there anything like React Context or Unix envvars in any functional language?

Not global mutable state, but variables with a global identity that I can set to a value for the duration of a function call to influence the behavior of all deeply nested functions that reference the same variable without having to acknowledge them.

I'm learning Rust as a case study for my own programming language. It's funny how many approaches exist to the humble loop.

- In classic procedural languages, a loop's job is to repeat actions, and as such it provides a multitude of tools to control this repetition.

- In all languages with iterators, a for-in loop is a construct that does something with every element of a collection. In languages with both iterators and generator functions, this can even be used to define a sequence in terms of another.

- In Rust, a loop is an expression that obtains its value through repeated execution. It can also be used like a classic loop, of course, but this is the interesting part.

- My little language is a functional language, so "loop" is the Y combinator. To loop means to define the value of an expression in terms of itself. It's the only looping construct, gets special treatment from the type checker and it's also used in recursive type definitions.

OBS is advertised as the expert's screen recording and streaming tool, every list on the internet makes it out to be some incredibly difficult program not recommended for newbies.

It's also the only linux screen recorder that works out of the box on Pipewire, records both microphone and system sounds and all configuration was to
1. select recording as my main use case in the setup wizard which is a very verbose English popup, then accept all defaults
2. add a new source, following the instructions written in the box which are also the only instructions on screen after application launch
3. set the output directory (optional) by going to File > Settings > Output > Recording Path, all of which were the first items I guessed. If I had not done this, it would've written everything to my home folder which is a bit dumb but not confusing at all
4. click Start Recording
5. click Stop Recording when done

Some newbie-oriented screen recorders have a more complicated setup procedure than this super advanced experts' tool don't touch without safety gloves and a degree in video engineering.

Customized browser start pages?
I use Booky for bookmarks so my startpage is booky.io, but I have a userscript to remove a bunch of unnecessary padding and hide the header and footer. They're toggleable by clicking on the collection name.

I lost 2TB of family photos and videos a few years ago by dropping a single hard drive. Nearly all of it was later found on people's computers who forgot to clean them up when we got the NAS. I'm not so eager to delete data once it's backed up ever since.

Notifs got fixed!

Recently I've had a lot of realistic dreams and it's awful. For example, yesterday I dreamed that I have a SoftEng lecture on Monday at 9am. The day before I dreamed that Russia defeated Ukraine and are now neighbors with Hungary. On both occasions I was later convinced that the memory fragments were true until I either received conflicting news or some unrelated trigger reminded me of the later, unrealistic parts of the dream.

I can sort of deal with the possibility that my current life is a dream and I'll eventually wake up and start over from an unspecified morning, but the possibility that while living in reality an arbitrary subset of my memories comes from dreams is much worse

Hitting every. single. fucking. dead end on my unstoppable march to introduce a nice feature.

I'm trying to embed interactive svg maps in a Wordpress page in such a way that the areas can be edited intuitively using Inkscape and all the page does is inline the xml markup, but also there's a JPG background embedded in the picture which Wordpress finds too big for markup (unsurprisingly) but which is a pain in the ass to reference externally.

Is ± read from left to right or right to left?
So if I write 1m ± 1% ± 1% does that mean 1m ± 2.01% (1% applied twice) or 1m ± 1.01% (1% applied to 1%)?

[LANGUAGE DESIGN]

What are some interesting / unique approaches you've seen to representing generics in syntax? The only one I know is the Java/C#/Typescript way of using a separate set of parentheses and either specifying all of them or none, and I've already experimented a bit with passing them as regular arguments which works great with autocurry but every syntax option for inference adds visual noise.

I'm finally realising my long time dream and making a programming language. It's a functional language resemblent in both appearance and usage to lambda calculus. I'll mostly be making plans down to the finest details until the end of summer, at which point if I can gauge the challenge I can hopefully submit this as a graduate project.

This is the first in a series of articles documenting my progress:
https://lbfalvy.github.io/blog/...

Omg why are social cards so hard to debug? Did no one think of such obscure techniques as local debugging? And why doesn't Twitter show me the error message? It's the same code for fuck sake! It works with one article but not with another. There MUST be some very exact problem with one of my images, but Twitter just doesn't fucking give me a proper log.

I can't google jargon, what do you call it when you "flip" a function call, such that the call becomes an event in some dispatch system and return becomes a call on the event? I had to implement five such APIs this week with surface level differences and I'm starting to feel like it has to have a name if it's this popular.

For the pedantic, I mean async calls in JS in particular, I know you can't just invert a synchronous function call that uses a stack without peek.

Sometimes while working I find a subproblem that is isolated from the original problem domain, for example token renewal in an RTR authentication system. I take note of what I've been working on, clear my head of the broader problem write an exact specification of the subproblem. Then I code to that specification. The result is usually a self-contained open-source module which continues to improve my pace of work for years to come.

Best of luck to all Ukrainian ranters. Buffer states are awful places to be.

I had to explain lambda calculus to some maths majors so here's an interactive lambda shell:
https://lbfalvy.github.io/lambda
I still need explanations about Church-numerals, conslists and the Y combinator.

Update Polkit!
https://blog.qualys.com/vulnerabili...

XFCE keeps crashing in the weirdest way when I boot, 50% of the time it works, the other 50% the startup applications launch like normal but the window frames and the bars are gone and none of the positioning shortcuts work. It's like an issue specifically with xfwm but I have no idea how the wm in particular could be fucked. I already know that the compositor can fail without taking the wm with it.

I keep forgetting to design for the failure path, so my product is an accurate depiction of society, where everybody has a convenient excuse to not handle issues and the slightest problem ends up collapsing everything.

My two main grudges against Typescript:
1) Union types can't be passed as arguments if there is a variant for every element of the union
2) No tuple polymorphism, i.e. [T, U] isn't assignable to [T]. This is not a mistake because the length of the arrays differs and therefore they may be interpreted in a different way, but IMO there should be a tuple type which is actually an array but length is unavailable and it supports polymorphism. This sounds stupid, but since function parameter lists work well with tuples it would actually enable a lot of functional tricks that are currently inaccessible.

Any non-tech hobby usually helps my coding, because relaxing breaks are far more efficient if I'm not just laying in a bean bag trying not to think about work but rather engaged in something unrelated. During the summer I was storing a really good electric guitar because the owner emigrated, so when I felt stuck I played some music. I used to play the cello in middle school but I was never really good at it nor did I care to practice properly because it felt a lot like yet another class to attend. Apparently music practice works whether you do it in one long or several short rounds as long as the total time is enough.

What's with people displaying their pronouns in SM but failing to put their family name in all caps? I'm glad you're so progressive, but as a person with an Indian name in London, have you considered enabling English people in talking to you first?

Anyone know why calling the "memo" function on a React component or using the "useMemo" hook is widely accepted to be called "memoization", when the name itself derives from an existing English verb which actually means what the function does? Why are we artificially creating jargon?