I want the fact that my collection is lazy to be an implementation detail.

For me the diagrams make it easier to talk about what the tests do without getting bogged down by how they do it.

Conversely, red tests are tests I write after the code is written to lock down some implementation.

The more important point comes from a program design perspective. Here, "programming to an interface" means focusing your design on what the code is doing, not how it does it. This is a vital distinction that pushes your design towards correctness and flexibility.

If the program was important enough, Microsoft might actually go ahead and add some hack to their implementation so the the program would continue to work, but the cost of that is increased complexity (with all the ensuing problems) of the Windows code. It also makes life extra-hard for the Wine people, because they try to implement the WinAPI as well, but they can only refer to the documentation for how to do this, which leads to many programs not working as they should because they (accidentally or intentionally) rely on some implementation detail.

I don't think this is what really matters at the end, since whatever is the implementation the goal should be to provide a library that people actually like to use.

I'm not familiar with Svelte. But the UI itself is handled in a custom canvas on mobile (and probably Desktop?) Though, on the web, it is HTML and CSS.

It causes some implementation complexity just by existing.

However, that in-memory representation is not tied directly to the DOM in the browser (even though it is called Virtual DOM, which is an unfortunate and confusing name for an universal apps framework), and it is just a DOM-like data-structure that represents all the UI components hierarchy and additional meta-data. Virtual DOM is just an implementation detail.

I find this characterization of a value type based on its implementation details rather than its observable characteristics to be both confusing and unfortunate

Surely the most relevant fact about value types is not the implementation detail of how they are allocated, but rather the by-design semantic meaning of “value type”, namely that they are always copied “by value”.

I blogged a while back about how “references” are often described as “addresses” when describing the semantics of the C# memory model. Though that’s arguably correct, it’s also arguably an implementation detail rather than an important eternal truth. Another memory-model implementation detail I often see presented as a fact is “value types are allocated on the stack”. I often see it because of course, that’s what our documentation says.