DarkUranium

I'm curious, why are they an accessibility nightmare for page layout? I don't use them for that, mind, but I am curious.

Plus making a webapp with accessibility in mind, and I'd like to be aware of footguns.

Apparently, one of the very first proposals for a CSS enhancement was to use Cassowary-esque constraints for layout[1,2].

Think Apple's AutoLayout and similar, but in CSS. I don't recall why it went nowhere (though I do remember the reasons were more political than technical), but imagine CSS without all of the float/flexbox/grid/subgrid/etc crap, but just: `#table-a[width] == #table-b[width];` and so on. And no need for hacks involving deep `<div>` trees just to get the HTML to cooperate with CSS --- it breaks the whole "HTML is for content, CSS is for styling" premise anyway, when HTML needs to adapt structurally to CSS.

The proposal even had `@import` and `@media` (the latter named `@precondition`) all the way in 1999!

There were some attempts at revivals (e.g. [3]), but they kind of went nowhere. Personally, I'm strongly considering using it for my own (non-web-related) UI library. CSS' base syntax is okayish (the way you define classes, reference elements, etc), and the basic rules like colors or text-related things have warts, but are ultimately okay --- but anything to do with layout is an absolute mess.

[1]: https://web.archive.org/web/20140911231410/http://www.cs.was... [2]: https://web.archive.org/web/20140911231410/http://gridstyles... [3]: https://web.archive.org/web/20140907130017/http://gridstyles...

I also made a tabbed control a while back, with pure HTML + CSS (by [ab]using radio buttons & IIRC, `display: none`).

The rest of that page needed JS (it included a collaborative editor, CRDT-based --- can't avoid JS when you need it for the core thing), but since doing tabs without JS was trivial, I figured "why not".

IRCv3 gives you all of that, and I'm working on an ircd that has builtin support for multi-device access & chat history (which covers mobile between the two --- there are improvements you can do on top of that, but those two are kind of the foundation).

I'm also extending it with support for Discord/Matrix/etc-esque communities (in a 100% standard-client-compatible way).

I'm pretty sure that's impossible nowadays, at least avoiding everything that runs on AWS.

They absolutely do accept then discard when it's flagged as spam above a certain confidence threshold (below that it "only" ends up in the spam folder).

I suspect because it's hard to differentiate between ones that actually respect the consumer vs ones that only say so, but are actually lying to your face.

That and not respecting the consumer is more profitable in the short term (only!), which means more marketing money, buying out other brands, lobbying to increase the barrier for entry, et cetera.

The UK has the same system with the same problems.

It always converges to a two-party system eventually, the US just speedran the process.

Little did they know that the UK effectively already had Norway's status and then some, what with all the special privileges they were granted in the EU.

Vectors & multidimesional arrays are something I'm 100% adding to my language's core.

It kind of started with vectors as the very first feature (I was sick & tired of libraries reinventing their own `Point`/`VectorN` in incompatible ways).

... I can't believe I typo'd that as "LobreWolf". OH WELL.

It's a big part of why I'm strongly opposed to common-law systems (as opposed to civil law). All the case law, all of it becomes, well, law. And then you get the whole "legislating from the bench" critique, which, while valid critique, is only a big problem because it's a common-law system.

Yes, I realize many (most?) legal systems are actually hybrid, but they do tend to err pretty strongly into one direction or another.

Yes, and it's a surprising good part about PHP (a language that otherwise has an enormous collection of warts, to put it mildly).

I feel like the more dynamic and/or weakly-typed the language is, the more important it is to have a separate concat operator.

The worst ones being weakly-typed and dynamic. Consider `'5' + '10'` in JavaScript vs `'5' - '10'`. I also very much dislike Python's `+` for concat, but at least it's more strongly typed.

PHP, Lua, and Erlang are three examples of dynamically-typed languages with separate concat operators (`.`, `..`, `++`; respectively), and they all are better for it.

That said, even statically-typed languages benefit greatly from it. Maybe if C++ had a concat operator, it'd never end up abusing `<<` for writing to a stream (yes, there's no opposite for reading, but maybe they wouldn't end up doing that in this case).

For example, D uses `~` in infix for concat. Even UnrealScript, a 1990s game-engine-specific language (which tend to be a mess in general) did this right (it uses `$` or `@` --- with `a @ b` being equivalent to `a $ " " $ b`, IIRC).

LobreWolf is a good recommendation, though if you want something with more "usual" defaults --- I love WaterFox, myself.

I know it's not the only problem (but it is IMO the main one), but this is why I'm a proponent of allowing operator overloading in languages.

Yes, you can't tell at a glance if `+` really still does what it should, but I find that problem no different from a library mis-naming a function and/or said function having strange side-effects.

`+` should do addition, period. No, not even concatenation if possible (I do find the lack of a separate concatenation operator to be a language flaw --- that said, I understand the use of `+` for concat in libraries targeting languages that offer no alternative).

I think the abuse (especially in C++ ... seriously, allowing overloading of the comma operator? --- and <iostream> working via bit-shifting streams by ${some_string} bits) gave everyone a bad taste and they kind of threw out the baby with the bathwater.

TIL that TLS (before 1.3) was designed by non-cryptographers. What the hell.

I really hate the whole thing about companies promoting using LLMs to change one-liner emails into this long multi-paragraph thing that ends up saying almost nothing ... just wasting everyone's time in reading them (with an extra sprinkling of hallucinations).

I'm confused, how can I see it, for example?

I feel like this should be treated as, and have consequences similar to, plagiarism.

Alas, it's probably just wishful thinking on my part.

My #1 complaint by far is that it --- pretty much silently --- depends on systemd to work correctly.

Try having a docker-compose with a service that waits until a dependency is healthy --- in a host that has no systemd (such as Alpine Linux).

The service will never start because Podman relies on systemd (and only systemd) to do the periodic healthchecks which it needs to do in order to handle such dependencies.

And of course, this fact isn't adequately documented anywhere. And Red Hat says they'll never, ever drop this dependency.

---

But I don't know if there are any tools compatible with the Docker ecosystem other than Podman. I'd love to find one.

That gives me an idea for an icon pack. TL;DR path-traced voxel art, isometric render.

Alas, I'm no designer.

You can't rip it, or even make backups in the US (you can in most, if not all, of Europe; dunno about the rest of the world). It's illegal, and constitutes piracy.

A rip & copy is a breach of the DMCA (because it involves circumvention of DRM, among other things) in the US, which makes it software piracy.

And then they wonder why so many advocate for just skipping the "purchase" step when the end result is legally the same.

Where could one find resources about implementing such GCs in their own language?

Yes, copying strings is definitely cheap, but allocating memory for the copy is absolutely not.

And I have my doubts w.r.t. 0-terminated strings being more efficient, with maybe the exception of some very specific niches.

In the other, you say "xy, yz, zx" (or whatnot), which makes it much clearer as to what's what.

What exactly does `i` correspond to in a quaternion? They always rely on implicit assumptions/conventions.

Also, I really think we'd all be better off if we stopped using quaternions entirely and started using rotors instead.

I still like the idea that Han Solo was --- quite simply --- bullshitting, talking out of his ass.

It fits the character and it resolves the filming/script mistake with a good explanation that doesn't take mental gymnastics.

> Proxmox comes close but doesn't offer proper enterprise support contracts

... but then again, neither does VMware, apparently.

By that logic, no natively-compiled language has a type system.

Though I should note that in a way, even some ISAs have one, what with e.g. separate float vs integer registers.