DarkUranium

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.

I like the D approach where arrays are just `struct { size_t length; T* ptr; }` internally --- and strings are just arrays of `immutable(char)`.

It has a big advantage over the Pascal approach in that you can do zero-copy slicing, since the length is separate from the actual data.

And `size_t` makes perfect sense for the length here. If your strings are longer than the address space (which `size_t` technically isn't, but is practically very strongly correlated to it), then you're going to have a problem regardless of the number of bits for the length anyway.

I very commonly see fixed-point libs be slower than floating-point (assuming floating-point hardware is available --- soft-float is slow as hell compared to fixed-point, of course).

Commonly enough that I think it's some fundamental reason (given available/current hardware as opposed to hypothetical).

Two reasons I can think of, though granted, they only apply in certain niches:

1) Floating-point SIMD extensions are far more common than integer ones. This means you can compute N (often N=4 or 8) float operations in one instruction, vs 1 integer operation.

2) For any GPGPU processing: GPUs far prefer floats, to the point where you didn't even use to have integers available (somewhat ironically, the platforms that prefer float much more strongly to int are mobile/embedded ones nowadays --- which is the exact opposite of the CPU situation). To this day, you have a `mul24` intrinsic for integer multiplication in some languages ... which converts two integers to floats, multiplies them as floats, and then converts back to integers. Yes, that was faster than direct multiplication. I'm sure many GPUs do it directly nowadays though.

It's also worth considering that a typical fixed-point multiply (as opposed to integer) is an integer multiply followed by a shift; often to a 2×-bit intermediate, if you want to preserve precision. That's a cost.

If you include Uranium in the oceans, we have about 4.5 billion years of fuel.

It's no less renewable than the Sun.

Coal in the US alone kills one Chernobyl of people each year.

(using estimates for Chernobyl --- so, in coal's advantage, as Chernobyl's confirmed deaths are actually very low)