mpartel

Huge spikes over a short period of time are hard to deal with for anyone, and payment processors have their own infra whose scalability Steam can't necessarily control.

Some LLM APIs let you give a schema or regex for the answer. I think it works because LLMs give a probability for every possible next token, and you can filter that list by what the schema/regex allows next.

The design of generics in this one seems rather well balanced in simplicity vs power.

The part about interface-typed values [1] is interesting. They do dynamic dispatch as a fallback when the function is too polymorphic to be be specialized.

In Rust terms it's as if it picks between `dyn` and `impl` automatically. It looks convenient, but also a bit of a non-obvious performance pitfall.

[1] https://shader-slang.com/slang/user-guide/interfaces-generic...

I agree in the sense that answering "what really are qualia" may be as impossible as answering "what really are quantum fields". At some point we may be forced to accept "it just is", but that doesn't mean we can't make meaningful progress first, just like in physics.

For instance, either new physics is involved or it isn't. Finding solid evidence for or against it does not seem impossible, and it would definitely constitute meaningful progress, at the very least by ruling some theories out.

Even after mapping the entire visual cortex to all visual features, it just doesn't get us any closer to understanding that raw experience of "sight" that happens when you look at something. It's not the same thing.

Seems plausible that a detailed enough mapping of correlates one day uncovers a single thing/feature/location/architecure/pattern/whatever that is present only when qualia are, and absent in all other processes. That would at least point us in a concrete direction.

I agree. It's just quite a lot of verbose-looking XML. "I have to write that much XML" is probably not the first impression you want to give. I did scroll down and see that you don't actually have to write such XML by hand, but many will not.

The rather prominent XML on the front page might scare folks off.

To clarify, dependencies significantly affect incremental builds too. Seems loading information about compiled dependencies into the compiler and/or resolving stuff about them can take significant time.

Compilation times depend very heavily on the amount/size/complexity of dependencies.

The linked github page has a link to a paper.

Excellent work, again! Your intros somehow elicit the best out of HN too: the comments are always full of interesting angles and variations.

Wanna do quaternions next? :) Many have tried..

Does it / will it support retractions?

A fanless case would be real nice, and seems theoretically doable.

Several languages have or have had this behaviour. C# made a similar change to its 'foreach' loops a long time ago (but not 'for' loops for some reason).

I suppose it's the natural way to do it when implementing a language and not thinking about it too much. It makes a for-loop equivalent to a simple while loop with the loop vvariable initialized outside of the loop.

https://neon.tech/docs/cloud/compatibility/ says "During technical preview Neon has restrictions on user ability to install PostgreSQL extensions. Following PostgreSQL extensions come pre-installed: [..]"

This is a dynamically typed language. Null makes sense there.

It also makes sense in a statically typed language with union types, think `string | undefined` in TypeScript. The extra layer added by Some/None is not fundamentally necessary for safety.

System76 has done good work on Linux support for (seemingly) similar hardware: https://tech-docs.system76.com/models/lemp10/README.html - some of that might be reusable.

Some examples of high-level decisions: - which web framework? - which database? which ORM? which transaction isolation level by default? - will this game/UI be multiplayer? - what's our testing discipline?

You can't loosely couple around questions like these most of the time, at last not without excessive abstraction.

For "how do I structure this reasonably isolated 0-1kLOC component", I agree, easy to fix later if needed.

This is true for early high-level decisions. For every-day coding of smallish components in a large project, it matters much less.

The more code your design decision will affect, the more up-front planning it deserves.

A good chunk of evidence has been summarized here: https://ledger.humanetech.com/

If enough people find it interesting enough to follow, why not?

Many similarly depressing results: https://ledger.humanetech.com/

Steam and GOG too

Scala and TypeScript have (partial) answers to this.

In your example, Scala 2 would let Int32 and Int64 inherit a trait that Str doesn't. TypeScript would let you write a union type Int32 | Int64 that doesn't include Str (or add ExtraValue), and I think Scala 3 will have something very similar.

Some promising stuff here. My highlights:

- they seem to recognize the problems caused by recommendation engines optimizing for engagement

- they seem to oppose automated content filtering

My main worry is that attacking targeted advertising misses the mark: platforms would still be incentivized to optimize for engagement. Forcing platforms to make algorithmic recommendations optional would be as useless as all these cookie warnings.

The JS code is under 500 lines so this is at least simple and auditable.

I didn't see anything about encryption based on a cursory read. Does WebRTC have some built in or is this unencrypted?

Cross-platform determinism: if the enhanced-determinism feature of Rapier is enabled, it will behave in a bit-level cross-platform deterministic way in all platforms that comply with the IEEE 754-2008 floating point standard.

Impressive! I've understood this to be a hard problem. Unity has promised this for years but still hasn't delivered, last time I looked.

Is there anywhere we could read more about the tradeoffs and challenges involved?

Also, how widely has this been tested?

Perhaps most importantly: how can I extend this determinism to my own code?

Well, what you ask is what's written in the very first prompt screenshotted in the blog post; [..] I don't see how this choice of words is much different from your proposal.

There are nuances about the UI and wording as discussed elsewhere in this thread, but my main objection is about Apple positioning themselves as the only one who decides which apps don't get that warning.

[..] I don't think Apple will ever relinquish the strategic power to force developers to adopt APIs and track their lifecycle, and never again have to deal with the Flash scenario.

I don't see how alternative stores would prevent Apple from breaking backwards-compatibility on an OS they would still control. Even open source projects do BC breaks as they see fit. And I think Microsoft demonstrates that proper BC is something a company the size of Apple could well afford to do if they cared to.

The Flash case could be seen to support my position as well. Wasn't it a case of Adobe getting into a dominant position (for their particular niche) and then "abusing" it by letting Flash stagnate with awful security? It's good that we eventually got rid of Flash, but wouldn't it have all been much easier if Adobe had never become that dominant in the first place?

You can of course say Apple would never let something stagnate in that way, but all companies have their (sometimes shifting) priorities and interests. Often they'll align with you as the user - that's the nice thing about capitalism - but there's no guarantee that they always will (e.g. that Hong Kong example), and a dominant player in the absence of healty competition is always incentivized to charge as much as the market will bear.

If they let the door open to "alternative stores" good luck explaining to the general public how it's not their fault if <insert major app> works like shite and kills hardware performance.

Is this really that big of a problem? Seems like something platforms already deal with by surfacing and by default restricting apps' energy use etc, though this too can be a double-edged sword. I have a few apps on Android that need to constantly show a pointless notification just so they can run in the background, and they have legit reasons to do so, and I'm OK with the battery drain.

Again I'm compelled to draw an analogy to society: freedom indeed requires some degree of responsibility and understanding from everyone. Benevolent dictators are a great place to "outsource" all that. The trouble is that they (or their successors) rarely stay benevolent for long, especially if you're not in their ingroup. I've yet to see power accumulation have good long-term consequences in history.

Heavily sandboxing apps by default is fine, and some Linux distros are, slowly, moving to do this - see e.g. AppArmor and Snap.

Even giving warnings by default about unsigned apps requesting high privileges would be fine if the implied message weren't basically "everything we haven't checked is malware". Something like "We nor any other provider you've chosen to trust have no idea who made this and we haven't checked if it contains malware. This program may steal and delete all your files. Be really sure you trust the author before running this." would be much more honest.

Good security does not require a single entity becoming the sole gatekeeper and taxman for a huge fraction of users.

Why must everyone constantly have to risk their own neck to defend someone else’s perception of freedom. Why should they all pay (in terms of risk and time mitigating against it) for something that benefits someone else alone?

I'm not advocating for Windows-levels of "install anything with access to everything with barely any warnings". And I wouldn't say you're "constantly risking your own neck" if you deliberately ignore warnings.

In computing as in society, I don't see how we can remove all possibility of getting cheated into hurting yourself (by installing malware in this case) without essentially submitting to some form of autocracy. And I think freedom benefits almost everyone, at least indirectly. As a concrete example, in the Apple/Epic case, an alternative game store would likely result in healthier competition i.e. lower prices. As another example, Hong Kong protesters with iPhones would have had an alternative way to coordinate: https://www.bbc.com/news/technology-49919459

That's peanuts. The 30% cut of revenue for app and in-app purchases is the real cash grab.