nikeee

I think a better reasoning is that NaN does not have a single binary representation but in software, one may not be able to distinguish them.

An f32-NaN has 22 bits that can have any value, originally intended to encode error information or other user data. Also, there are two kinds of NaNs: queit NaN (qNaN) and signalling NaNs (sNaN) which behave differently when used in calculations (sNaNs may throw exceptions).

Without looking at the bits, all you can see is NaN, so it makes sense to not equal them in general. Otherwise, some NaN === NaN and some NaN !== NaN, which would be even more confusing.

I tend to lower-case all my HTML because it has less entropy and therefore can be compressed more effectively.

But in case of modern compression algorithms, some of them come with a pre-defined dictionary for websites. These usually contain the common stuff like <!DOCTYPE html> in its most used form. So doing it like everybody else might even make the compression even more effective.

I really dislike it when a turing-complete language is used for configuration. It almost always breaks every possibility to programmatically process or analyze the config. You can't just JSON.parse the file and check it.

Also I've been in projects where I had to debug the config multiple levels deep, tracking side-effects someone made in some constructor trying to DRY out the code. We already have these issues in the application itself. Lets not also do that in configurations.

> Optional key quotes

Why are they optional? Why not just make them mandatory? So I don't need to guess which chars need quotes.

Edit: What most languages also lack: semantics on de-serialization. In the best case, I want to preserve formatting and stuff when the config is changed/re-committed programmatically.

IIRC the CEO(?) of Duolingo was asked what he would choose if he had to choose between a more effective language course and more gamification. His answer was gamification, because the best course doesn't help anyone if noone shows up. So at least they know that it's not the best way of learning a language.

Yeah it might be closer to what's actually happening but it doesn't make it obvious why something doesn't work. The map model doesn't even cover non-unique indices. Or different type of indexes.

I use the mental model of nested maps for "column order matters". For example, an index "published, low_quality_probability, lang" is just a Map<date, Map<number, Map<lang, rowId>>> in my mental model. These maps are ordered by the order the index possesses. That explains why column order matters and why one cannot skip columns and why it stops at range queries.

Just imagine getting a final rowId from these nested maps and you'll see why the index works for some queries and doesn't for others.

I don't like it when non-clickable text isn't selectable either. But this behavior somehow makes it feel more like an actual app (when used in PWAs).

Honestly I'd expect some new Web API built into chrome for this

> alongside features that let you transfer your encrypted message history between Android, iOS, and Desktop devices.

That's actually the feature I've been looking forward to. As I moved vom Android to iOS, I lost _all_ message histories from all messenger apps that use E2EE (Signal, WhatsApp, Threema, etc). The only one that "just worked" was Telegram due to not being encrypted. WhatsApp had a migration app that has to be done when setting up the iPhone, but it failed due to some bug. Signal had backups, but they didn't seem to be compatible between different OS versions.

Why still require write access to public repos if it's only reading?

I use my "blog" as a bookmark list. Every link is its own Markdown file with frontmatter tags. Sometimes I add more context or text, based on what I'm linking to. Some time ago I added a cron job that takes all links and looks for their archive.org entries in a similar time period and puts them in a JSON file. If the original goes down, there is always a permalink available that can be rendered instead. There is also a cron job that checks for link availability. If there is no snapshot, the link gets added to a TODO stack and add I manually create an archive.is entry later.

Hard to find these days, but it remindes me of this [0]:

> "- Google had a plan called "Project NERA" to turn the web into a walled garden they called "Not Owned But Operated". A core component of this was the forced logins to the chrome browser you've probably experienced (surprise!)"

To "not own but operate" seems to go into the direction of the parent comment.

Also this: https://news.ycombinator.com/item?id=28976574

[0]: https://web.archive.org/web/20211024063021/https://twitter.c...

If security and memory-safety is a concern and there is already a polyfill, why remove the API form the standard instead of just using the WASM-based polyfill internally?

Is that being made to make Flutter not being like Flash on the web?

I proposed a primitive for this in TypeScript a couple of years ago [1].

While I'm not entirely convinced myself whether it is worth the effort, it offers the ability to express "a number greater than 0". Using type narrowing and intersection types, open/closed intervals emerge naturally from that. Just check `if (a > 0 && a < 1)` and its type becomes `(>0)&(<1)`, so the interval (0, 1).

I also built a simple playground that has a PoC implementation: https://nikeee.github.io/typescript-intervals/

[1]: https://github.com/microsoft/TypeScript/issues/43505

I wouldn't be that sure if we'd want to exchange that for an ecosystem that consists of many different languages that all have their own ecosystem wich may not be compatible with WASM. Imagine needing nuget, maven and cargo -- all in their specific version -- to build a project.

I use Hurl for some time now and even contributed. What are the current chances for getting some form of includes?

You probably mean RFC3339, which overlaps with ISO 8601 and allows this. But the docs don't mention that RFC and only reference the ISO standard.

You can compare the formats here: https://ijmacd.github.io/rfc3339-iso8601/

`current_timestamp` also returns something like `2025-06-15 19:50:50` while the docs state that it is ISO 8601. Except that this is not ISO 8601 due to the T missing in the middle. This has caused some headaches due to different formats of JS's `.toISOString()` and SQLite's `current_timestamp`. The datetime column is basically only for documentation. I wish they had some timestamptz type which rejects insertions containing invalid datetime formats.

I've built an S3 client with similar goals like TFA, but supports pre-signing:

https://github.com/nikeee/lean-s3

Pre-signing is about 30 times faster than the AWS SDK and is not async.

You can read about why it looks like it does here: https://github.com/nikeee/lean-s3/blob/main/DESIGN_DECISIONS...

> Wirth's law is an adage on computer performance which states that software is getting slower more rapidly than hardware is becoming faster.

https://en.wikipedia.org/wiki/Wirth%27s_law

The lighting is depending on the devices' orientation to which a web site running in safari on iOS has no access to due to fingerprinting protection. Maybe you need to request permissions to the gyroscope, but doing that for a reflection in the UI is a bit overkill.

Depending on the use-case, it might be good to have a file format "diffable", especially when it's going to be checked in in some version control.

ZLinq relies on its own enumerable type called ValueEnumerable, which is a struct. While it would probably work when using this as a drop-in replacement and re-compiling, things will be more complicated in larger applications. There might be some code that depends on the exact signature of the Linq methods. This might not even be detectable in cases involving reflection and could break stuff silently.

Adding another enumerable type would be a very large change that could effectively double the API surface of the entire ecosystem. This could take some time. Some places still don't even support Span<T>. Also there were some design decisions related to Linq where the number of overloads were a consideration.

Adding this API to .NET could probably be done with that extension method that converts to ValueEnumerable. But without support for that enumerable, this would pretty much be a walled garden where you have to convert back and forth between different enumerable types. Not that great if you'd ask me, but possible I guess.

Does it work with some DOM polyfill in Node.js?

You can read her book from ~2014 where she describes the same arguments that she also does on her channel, but in much more depth. She didn't make videos back then. She also has great talks at universities and discussion panels.

How does it handle multi-stage Dockerfiles? I always indent the steps following FROM to make the stages more obvious. I don't get why that isn't a norm because not doing it seems like not indenting function bodies in other languages.

There are also a repository containing some laws in markdown format on GitHub. They even used PRs for actual changes proposed by the parties in the parliament. Also, the commits have their proper date, so you can `git blame` on the laws and even see which president signed-off that change.

Sadly, it is unmaintained.

https://github.com/bundestag/gesetze

One day my YT Premium subscription stopped playback when I was watching something while cooking and at the same time, some music video was playing on a different device. It said something like "you cannot use your premium account in multiple places".

I went back to my PC and immediately cancelled my subscription. That is a restriction that I don't have when I am not paying anything at all.