> 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").