sixthDot

That is funny, somewhat works but there's a bias toward the victorian era. https://halupedia.com/the-x128-cpu-architecture. Otherwise I feel sorry for the creator's tokens.

https://github.com/vlang/v

I think Pentium will still be supported. i486 refers to very old 32 bits CPU (80486). The article is not clear but by default I tend to think that i586 and i686 will still be supported.

When a team is so much into its own littke bubble, it does not realize anymore the shit they are doing

This work on system of weight:

For each option and criterion, you assign a rating (0–10). Each criterion has an importance weight (1–5 stars). Decidit multiplies rating × weight and sums the values – the option with the highest score wins.

Is this really made for people who lack self-discipline or maybe just a website made for a portfolio ?

So eventually that would be used to poison communications, just in case of Iranian would use that old channel, which then would also mean that it's been cracked a while ago.

That's absurd but I like this kind of little stories.

When a wealthy artist bought the island [...]

Not an artist. British businessman and Winter Olympian. See https://en.wikipedia.org/wiki/Keith_Schellenberg.

Also the C API is a bit the poor child. Plenty of useful options (or even opt passes !) are not available.

If only that was only about emitting byte code in a file then calling the linker... you also have the problem of debug information, optimizers passes, the amount of tests required to prove the output byte code is valid, etc.

Another one bites the dust

The bigest anoyance nowadays (in the EU at least) is rather the cookie policy agreement. "View the list of our 258 partners", etc.

That remind me of The Ax [0]

[0] https://www.imdb.com/title/tt0422015/

How this was discovered is incredible. An amator satelite was lauched. operators collected data. At some point they had the idea to plot them. That gave a big stain in the south atlantic.

Not into ZIG but for some reasons I monitor new issues that pop in the bug tracker of "new" / "raisins" languages. ZIG has clearly reached the next level, let's say if you compare the issues two years ago (lot of comptime/type system things) VS now.

I've wrote a lot of `xor al,al` in my youth.

related researches

- https://pmc.ncbi.nlm.nih.gov/articles/PMC7264682/

- https://psycnet.apa.org/record/2014-51129-001

I cannot reply on the blog but to answer the author about other languages, here is the D version, using a single template:

    auto ref T max(T)(auto ref T u, auto ref T v) => u > v ? u : v;
    
    void main()
    {
        int a = 1;
        int b = 0;
        int x;

        static assert(__traits(compiles, &max(a,b) == &a),
            "should have selected the lvalue version");
        static assert(__traits(compiles, x = max(1,0)),
            "should have selected the rvalue version");
        static assert(__traits(compiles, x = max(a,0)),
            "should have selected the rvalue version");
        static assert(__traits(compiles, x = max(1,0)),
            "should have selected the rvalue version");
    }

an hygienic way to handle that is often "assert", can be a macro or a built in statement.The main problem with assertions is the side-effects. The verification must be pure...

Bound checks are usually conditionally compiled. That's more a kind of "contract" you'll verify during testing. In the end the software actually used will not check anything.

    #ifdef CONTRACTS
    if (i >= array_length) panic("index out of bounds")
    #endif

What is really mind blowing is that, if understood correctly, bots would be used to check the availability of a product, that sounds so a "hacky" method, like "seriously people are doing that in 2025".

little UX issue: that's a little surprising that knots cannot be moved.

ty giles

Basically any transfert function that is used as interpolator can also be used as "easing". E.g a quadratic Bézier (let's say with empirically determined coeffs). One lesser known I used to like much is the super ellipse, although very costly.

A problem I see with talking exclusively about lexing is that when you separate lexing from parsing you miss the point that is that a lexer is an iterator consumed by the parser.

Halstead complexity ([0]) might interest you. It's a semi-secret sauce based on the count of operators and operands that tells you if your function is "shitty".

[0] https://en.wikipedia.org/wiki/Halstead_complexity_measures

Many languages propose a system of ranges:

    case 'a' .. 'z', 'A' .. 'Z', '0' .. '9', '_': ...;

Despite of the drawback I prefer. Also a Range can be a formal expression which simplifies the grammar of other sub-expressions and statements, not only switches but also array slices, tuple slices, foreach, literal bitsets, etc.

int x = void;

this is what the D programming language does. Every var declaration has a well know value, unless it is initialized with void. This is nice, optimizing compilers are able to drop useless assignments anyway.

Compression reduces the range between the lower and the higher level so your ears are faced to a more or less "constant" pressure. Personally when I was into home production I only dared eating the peaks with a limiter and reasonable settings, e.g to gain one or two db, never more.

On top of that another problem with compression is that it is not neutral, bad compressors, especially in the digital domain can introduce aliasing.

Also search for the "loudness war". This is how we called the problem back in the mid 2000's.

any Machine Interface planned (à la GDB/MI)?

Sure, CTFE can be used to generate strings, then later "mixed-in" as source code, but also can be used to execute normal functions and then the result can be stored in a compile-time constant (in D that's the `enum` storage class), for example generating an array using a function literal called at compile-time:

   enum arr = { return iota(5).map!(i => i * 10).array; }();
   static assert(arr == [0,10,20,30,40]);