snthpy

Why do need a licence to drive but not to vote? Except non-birth citizens effectively had to acquire a licence.

Philosophers have probably thought about this and can provide an answer. Unfortunately I'm not familiar with their literature.

I like Rawls' Veil of Ignorance as a principle for thinking about issues of fairness. Would I choose to live in a society where only informed citizens could vote even if that might preclude me? Probably. Hard to honestly put oneself behind that veil though.

Initially I recoiled at the thought of the stiffness of the CD, but of course your absolutely right, at least for 2d manifolds.

Why is Hackernews news for hackers?

The following stood out to me:

"Exit and voice themselves represent a union between economic and political action. Exit is associated with Adam Smith's invisible hand, in which buyers and sellers are free to move silently through the market, constantly forming and destroying relationships. Voice, on the other hand, is by nature political and at times confrontational."

In national and international politics we see a lot of "Voice" (in these terms) but I feel they are often ineffective because they are blunted by threshold effects, i.e. the resultant change is a softmax with temperature near zero.

People don't realise and utilise the power they hold by means of "Exit", especially as wealthy consumers who engage in these debates, who have more consumption and hence more influence as it's a "one dollar, one vote" system rather "one person, one vote". See for example how effective the response to Jimmy Kimmel was. The same thing was effective against Apartheid in the 1980s and can be applied through things like the BDS Movement.

Exit applies a much more continuous pressure where the effect of each actor is cumulative whereas Voice is more discontinous and requires a critical mass.

I haven't thought about DML too much but what I could envision is an approach like the Elm or React architecture where you specify a new state for a table as a PRQL query and then the compiler computes the diff and issues an efficient update.

For example

    DELETE FROM table_name WHERE id = 1;

    table_name = from table_name | filter id != 1

    INSERT INTO table_name (id, name) VALUES (1, 'Jane');

   table_name = from table_name | append [{id=1, name='Jane'}]

SQL:

    UPDATE table_name SET name = 'John' WHERE id = 1;

Any ideas?

I guess for Google this will be a treasure trove of real developer interactions to train on.

I might try this once Gemini 3 comes out. Until then, if you're running tmux or zellij, this seems like a worse user experience since you're in a subwindow and have less screen real estate to work with.

> Pond party later. Too many ducks, too many voices, too many rules. None written down.

Still a good duck, always a good duck!

Lol, I still used to notice him before covid when he was railing against Bengio, Hinton, and LeCun. Can't believe he's still going.

So PRQL (prql-lang.org) is kind of like that, with the limitation that control flow is limited to the List Monad bind, i.e. the tuples from one step are piped to the function call in the next step one at a time producing 0..* result tuples and the resulting multiset is flatmapped. At the moment it just transpiles to SQL but a couple of months ago I was exploring different Lambda Calculi and how to extend this to a more general PL. Alas, that won't take shape until AI is at the level that it can write that code for me. I guess LINQ and similar Language Integrated Query Languages already provide this functionality.

P.S. Writing the above made me think that it's not quite what you asked for; in the PRQL case each function receives an implicit `this` argument which is the tuple I was thinking of. However the function can also take other arguments, including keyword arguments. Those are arbitrary. I guess they are implicitly ordered and could be represented as a tuple as well. What would you see as the benefit of that?

> (and so you could use all the tuple manipulation library goodies)

Other than indexing into tuples, I can't really think of anything else, at least for single tuples. I initially thought of something like `zip(*args)` but that's only really useful when you have list of tuples or tuple of lists and then you're back in PRQL land. Indexing into tuples is also brittle and does not produce self-documenting code so I prefer the PRQL and SQL namedtuples/structs where fields are referenceable by name.

I have this suspicion that PRQL functions are parameterised natural transformations but my Category Theory at that level is too rusty to check without extra work. If that's the case though then having the explicit function arguments be simple values feels justified to me since they're just indexing families of related transformations and are not the primary data being transformed (if that makes sense?).

I learned recently that tldr also has separate pages for subcommands.

So the issue is that you need a git pull or something like it to prevent branching. Chat etc... achieves this through real-time state management. In an async setting you need something else.

Can you explain the meme please because I didn't understand the hits I got when I just googled it.

[1] covers the first 40 years of databases. [2] fills in the gap of the last 20 years and gives their thoughts on the future.

My apologies, the first one was actually Stonebraker & Hellerstein and didn't involve Pavlo. They're both excellent papers though for anyone working with data.

Stonebraker, for those who don't know, is the creator of Postgres, a database you might have heard of.

1: Stonebraker & Hellerstein, "What Goes Around Comes Around", 2005, https://people.csail.mit.edu/tdanford/6830papers/stonebraker...

2: Stonebraker & Pavlo, "What Goes Around Comes Around... And Around...", 2024, https://db.cs.cmu.edu/papers/2024/whatgoesaround-sigmodrec20...

My apologies to the Chinese coauthors who I'm not familiar with.

Bookmarked for thorough reading!

That said, now let me see what F3 is actually about (and yes, your comment is what actually made me want to click through to the link) ...

What we got was AI producing slop on greenfield projects which we have to debug and maintain.

I found OpenHashTab to be a good tool for this in the meantime: https://github.com/namazso/OpenHashTab

That said, PowerToys was the first thing I installed on the new laptop.

Here's an example of what a USV looks like:

Folio1␟␞ Sheet1␟␞ a␟b␟␞ c␟d␟␞ ␝ Sheet2␟␞ e␟f␟␞ g␟h␟␞ ␝␜ Folio2␟␞ Sheet3␟␞ a␟b␟␞ c␟d␟␞ ␝ Sheet4␟␞ e␟f␟␞ g␟h␟␞ ␝␜

Unicode has rendered analogs, U+241C-U+241F, but they take more bytes to encode, which can significantly increase file size in large USV files.

So my ideal would be to use ASV files rendered as USV in editors.

https://github.com/SixArm/usv