FYI Pi can do RPC over stdio (though of course it's a bespoke thing, rather than standardised). I use Pi every day; never used the TUI (I forgot it even had one).
7,950 karma · joined June 28, 2013
Thankfully user-chrome still seems to work, so these things can be overridden (and LLMs make those overrides easier to write & maintain).
Why would non-technical users be looking at raw URLs? Surely links "look like" blue underlined text; or a button; or whatever?
IPFS is not "blockchain" or "crypto"(currency).
It's much closer to git-over-bittorrent. Note that both of those things were decentralised long before "blockchain" and "crypto" existed.
The makers of IPFS also made a crypto thing called Filecoin; but that's a different project. Avoiding IPFS because of crypto is like avoiding the Web because of social media.
Unfortunately that hasn't panned out; but it still feels more feasible than getting Microsoft and Apple to add it to their OS network stacks.
There is already a perfectly good incentive mechanism: if someone wants to host some data, they can; and if nobody wants to host it, it doesn't get hosted.
That's worked perfectly well for HTTP, without any shitcoin needed. The advantage of IPFS is that its URLs resolve to anybody who cares enough to host that data; so links will only 404 when nobody cares (unlike HTTP, which relies on a single point of failure).
> a libertarian decentralized P2P E2EE communication project
Your argument makes sense for Freenet (though I'd personally defend that project too); but not so much for IPFS.
Firstly, IPFS doesn't have any encryption (E2E or otherwise).
Also, Freenet spreads data around the network (for robustness and plausible-deniability), so the peers providing a file are not the peers which inserted it. IPFS does no such thing: if you want your content to remain available, you'd better be running an IPFS node that provides it.
Either way, it feels like a pretty bad idea to host dodgy stuff on IPFS.
IPFS is much closer to HTTP. The difference is that content is immutable, and can be re-hosted by anyone that happens to have a copy (e.g. no need for mirrors, etc.).
(Note that HTTP was invented to disseminate physics research; not CSAM)
> Protocol Labs is an innovation network driving breakthroughs in computing to push humanity forward. PL connects more than 750 tech startups, funds, accelerators, foundations, open source projects, service providers, and other organizations.
What happened to them? Seems like they drank their own "Web3" Fla-Vor-Aid.
Regarding an "update path", GNS has support for that built-in; though I've not been able to try it myself, since I can't get GNUNet to bootstrap :-(
I've found https://github.com/shcv/parenmedic to be somewhat helpful, which diagnoses parentheses issues based on when they disagree with indentation, rather than simply counting. The fact this works indicates that LLMs are paying more attention to whitespace than "actual structure".
"Total Wormage" was on the Amiga, which became the original Worms. It was ported to other machines after:
https://en.wikipedia.org/wiki/Worms_(series)#Development
https://worms2d.info/Total_Wormage
> an expansion to the original
Not sure about DOS versions, but Worms: The Director's Cut is a heavily-expanded version of the original: more weapons, custom levels (allowing 16 colours instead of 8, IIRC), etc. Highly recommended!
I agree they're not as capable as Claude Sonnet, but they're much cheaper.
Apologies, I've not written Scala for many years; I just recalled that there was a way to annotate tail calls which the compiler checks. I didn't realise it was so limited!
I personally use the phrase "tail call elimination" when it's a requirement that can be relied on; and "tail call optimisation" when it might be implementation-dependent, context-dependent, limited (e.g. to immediate self-calls), etc.
Yes, trivially. Just look at the opposite end of each metric. Pareto optimality doesn't know/care what each metrics means, since it keeps them all separate.
Some thing is "pareto optimal" when there isn't another thing that's AT LEAST AS GOOD in ALL measures, and BETTER in at least one way. For example, if we say there are no ties (for simplicity), then the cheapest language model is pareto optimal; the fastest model is pareto optimal; those which score highest on each benchmark are pareto optimal; and so on.
Tradeoffs can also be pareto optimal: for example, if the cheapest model is also slow, then there will be more pareto optimal models which are "cheapest for their speed"; and so on for other tradeoffs (e.g. fastest that achieves a certain benchmark score; cheapest model with open weights; etc.).
If you're making a decision about which thing to choose, you only need to care about those in the pareto front (since, by definition, anything that's not pareto optimal is objectively worse on at least one measure).
Pareto optimality does not compare one measure against another: something that's 10000x slower can still be pareto optimal, if it's 1% cheaper than the alternatives. To pick a "best" thing, you could give a weight/importance to each measure, and combine them into an overall score: but that's subjective, and might vary between people and tasks. In contrast, focusing on the pareto front is a way to ignore those things that will never be the best, regardless of weighting.
PS: Majutsu provides this too (a magit-like tool for jj)
Toilets are useful immediately (speaking from experience!)
Tables are useful even on short trips of a few minutes; e.g. I usually have a notebook and pen in my pocket, and writing much easier on a table (even the little fold-out ones, if I can't get a seat at the proper tables).
I often eat on trains; though I admittedly tend to avoid the dining options, since it's much cheaper to bring my own food and eat my seat's table (fold-out or otherwise). If I'm with others, we can also drink alcohol together, without a "designated driver" having to abstain.
For example, many pagers don't work well when stdin is line-buffered (they assume they'll see individual key presses as they happen)
Pagers can also conflict with keys that the terminal emulator is using for a different purpose. This is especially annoying when the terminal emulator is using those keys for pager-like functionality in the first place!
An example of both of these is Emacs `shell-mode`.
(I personally set `PAGER=cat` in my Bash profile, which avoids most of these shenanigans)
Source: I work on such code. We don't allow devs to use (cloud-based) LLMs.
I'd imagine there would be a lag between the initial efficiency increase, and the subsequent usage increase; since drivers (current and potential) would have to actually notice the change and adjust for it (consciously or otherwise).
So you agree that most cars are far larger and heavier than required? First search result for "average car occupancy"[1]:
> In 2022 the Average Number of Occupants Per Trip for Household Vehicles in the United States Was 1.5
This discrepancy is the reason for car pooling, ride-sharing, etc. (Note that Uber, Lyft, etc. are taxi services, not "ride sharing"; since the drivers themselves are not typically intending to travel the routes they drive)
> roads also carry buses
Yes, which is why cars should be removed from such roads, to avoid slowing down buses.
> ambulances
Emergency vehicles can drive in places where cars are forbidden (cycle paths, pedestrianised roads, etc.)
> trucks that carry every single product* in the economy.
Again, you're undermining your own argument: the subsidies given to private car infrastructure are so large, that freight companies exploiting that infrastructure can end up more cost-effective than those which use rail; despite rail being more efficient not only in terms of fuel, but also in terms of labour (since so many trucks would be required to do the job of a single freight train, and each of those trucks require a separate driver). Also note that heavier vehicles degrade the road infrastructure disproportionately; which is even more reason to reduce the number of trucks as far as possible.
[1] https://www.energy.gov/cmei/vehicles/articles/fotw-1333-marc...
Cars don't even have tables; let alone toilets, dining areas, sleeping cabins, etc. Even those which do (e.g. RVs) would require a solo traveller to stop in order to use them.
No thanks, I'll stick to the train.
> if our universe is undecidable
My point is, there would be no way to empirically test this; and therefore, it would make no observable difference, there would be no way to exploit/utilise such effects, etc.
In essence: there's no way to tell the difference between a real halting oracle (which would imply an undecidable universe), versus a computable approximation which just-so-happens to be more powerful/sophisticated than the approximations we compare it against.
Sure, we can prove that some abstract systems are undecidable and that others aren't. Yet that distinction is inherently unfalsifiable, and hence physically "useless".
The nice thing about metric/SI prefixes is that they're generic multipliers, which can be used with any units we like. If you want to use them with day as the unit, you can just do that; nothing extra is required, and the meaning is clear (though unfamiliar!).
There is an alternative approach though: we could use prefixes for sexagesimal multiples (base 60). This has precedence, since we have a system of binary prefixes like "kibi" and "mibi".
For divisions, we can use the standard progression of "minute", "second", "third", "fourth", etc. to say there are 60 minutehours in an hour (or more generally, 60 minutefoo in a foo); that there are 3600 secondhours in an hour; and so on. Abbreviating "minutehour" to "minute" and "secondhour" to "second" when we're talking informally about time would be similar to abbreviating "kilogram" to "kilo" when talking informally about mass.
I'm not aware of any standard names for multiples (rather than divisions). My proposal[1] is “prota” for 60x, “defter” for 60x60x, “trito” for 60x60x60x, and so on; as Greek alternatives to the Latin "minuta", "secundus", "tertia", etc. (which "minute", "second", "third", etc. are derived from[2]). This Greek/Latin combo would match the multiply/divide naming of decimal, e.g. kilo (x1000, Greek) vs milli (/1000, Latin), hecto (x100, Greek) vs centi (/100, Latin), etc.
That would make an hour equal to protaminute, or one deftersecond.
[1] http://www.chriswarbo.net/projects/units/prefix_factors.html
[2] AFAIK the naming comes from "pars minuta" meaning "small part", with further divisions being "second small part", "third small part" and hence giving us "seconds", "thirds", etc. For consistency, we should really use "firsts" instead of minutes (or maybe "primes" from the Latin "prima").