I JUST rewatched Gone in Sixty Seconds on a whim, on like Thursday, and spotted that it apparently has a 38% critic rating from Rotten Tomatoes. Fuck that noise, that movie is a materpiece of filmography.

Many of the articles from those platforms are useless noise, but I do still occasionally want to read something that’s posted. When that happens, I just F12 and bypass the paywall, or look for the comment that has the article text, from someone else who has already done that.

Quartz Crystal, Silica, and Crystal Oscillators.

Nope, it’s not an illusion. Taller machines on the top floor means a bigger gap between floors, which means a different angle.

And no, the build is done except for cosmetic detailing.

Nah, they’ve announced recently it’ll be later in the year. But still should be this year.

TBF, it’s definitely not a streak. I’ve skipped a fair few days, recently. But I just keep the number going cause… who’s gonna stop me?

I’m gonna hazard a guess, just cause I’m curious, that you’re coming from JavaScript.

Regardless, the answer’s basically the same across all similar languages where this question makes sense. That is, languages that are largely, if not completely, object-oriented, where memory is managed for you.

Bottom line, object allocation is VERY expensive. Generally, objects are allocated on a heap, so the allocation process itself, in its most basic form, involves walking some portion of a linked list to find an available heap block, updating a header or other info block to track that the block is now in use, maybe sub-dividing the block to avoid wasting space, any making any updates that might be necessary to nodes of the linked list that we traversed.

THEN, we have to run similar operations later for de-allocation. And if we’re talking about a memory-managed language, well, that means running a garbage collector algorithm, periodically, that needs to somehow inspect blocks that are in use to see if they’re still in use, or can be automatically de-allocated. The most common garbage-collector I know of involves tagging all references within other objects, so that the GC can start at the “root” objects and walk the entire tree of references within references, in order to find any that are orphaned, and identify them as collectable.

My bread and butter is C#, so let’s look at an actual example.

public class MyMutableObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }
}

public record MyImmutableObject
{
    public required ulong Id { get; init; }

    public required string Name { get; init; }
}

_immutableInstance = new()
{
    Id      = 1,
    Name    = "First"
};

_mutableInstance = new()
{
    Id      = 1,
    Name    = "First"
};

[Benchmark(Baseline = true)]
public MyMutableObject MutableEdit()
{
    _mutableInstance.Name = "Second";

    return _mutableInstance;
}

[Benchmark]
public MyImmutableObject ImmutableEdit()
    => _immutableInstance with
    {
        Name = "Second"
    };

Even for the most basic edit operation, immutable copying is slower by more than 7 times, and (obviously) allocates more memory, which translates to more cost to be spent on garbage collection later.

Let’s scale it up to a slightly-more realistic immutable data structure.

public class MyMutableParentObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }

    public required MyMutableChildObject Child { get; set; }
}

public class MyMutableChildObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }

    public required MyMutableGrandchildObject FirstGrandchild { get; set; }
            
    public required MyMutableGrandchildObject SecondGrandchild { get; set; }
            
    public required MyMutableGrandchildObject ThirdGrandchild { get; set; }
}

public class MyMutableGrandchildObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }
}

public record MyImmutableParentObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }

    public required MyImmutableChildObject Child { get; set; }
}

public record MyImmutableChildObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }

    public required MyImmutableGrandchildObject FirstGrandchild { get; set; }
            
    public required MyImmutableGrandchildObject SecondGrandchild { get; set; }
            
    public required MyImmutableGrandchildObject ThirdGrandchild { get; set; }
}

public record MyImmutableGrandchildObject
{
    public required ulong Id { get; set; }

    public required string Name { get; set; }
}

_immutableTree = new()
{
    Id      = 1,
    Name    = "Parent",
    Child   = new()
    {
        Id                  = 2,
        Name                = "Child",
        FirstGrandchild     = new()
        {
            Id      = 3,
            Name    = "First Grandchild"
        },
        SecondGrandchild    = new()
        {
            Id      = 4,
            Name    = "Second Grandchild"
        },
        ThirdGrandchild     = new()
        {
            Id      = 5,
            Name    = "Third Grandchild"
        },
    }
};

_mutableTree = new()
{
    Id      = 1,
    Name    = "Parent",
    Child   = new()
    {
        Id                  = 2,
        Name                = "Child",
        FirstGrandchild     = new()
        {
            Id      = 3,
            Name    = "First Grandchild"
        },
        SecondGrandchild    = new()
        {
            Id      = 4,
            Name    = "Second Grandchild"
        },
        ThirdGrandchild     = new()
        {
            Id      = 5,
            Name    = "Third Grandchild"
        },
    }
};

[Benchmark(Baseline = true)]
public MyMutableParentObject MutableEdit()
{
    _mutableTree.Child.SecondGrandchild.Name = "Second Grandchild Edited";

    return _mutableTree;
}

[Benchmark]
public MyImmutableParentObject ImmutableEdit()
    => _immutableTree with
    {
        Child = _immutableTree.Child with
        {
            SecondGrandchild = _immutableTree.Child.SecondGrandchild with
            {
                Name = "Second Grandchild Edited"
            }
        }
    };

Not only is performance worse, but it drops off exponentially, as you scale out the size of your immutable structures.

Now, all this being said, I myself use the immutable object pattern FREQUENTLY, in both C# and JavaScript. There’s a lot of problems you encounter in business logic that it solves really well, and it’s basically the ideal type of data structure for use in reactive programming, which is extremely effective for building GUIs. In other words, I use immutable objects a ton when I’m building out the business layer of a UI, where data is king. If I were writing code within any of the frameworks I use to BUILD those UIs (.NET, WPF, ReactiveExtensions) you can bet I’d be using immutable objects way more sparingly.

Yeah, that’s about 95% a filter cap. Hoghly likely you don’t need one if you’re gonna make your own cables, with short runs.

Can’t really tell what’s going on from just this image. Is there only one lead coming off of the device? Is it just sticking out of the braid, or is it fully-uncovered?

My initial guess would be it’s a high-frequency filter capacitor.

Okay. I remember that plot point, vaguely, but I don’t recall it being about the DPRK, specifically. Maybe I just missed it.

I definitely don’t recall the DPRK being mentioned at all in Squid Game season 1.

For Canada, unfortunately no. Unless Microcenter is available up there, that’s my go-to these days. You could maybe try them out online, I dunno if they’d ship to you.

Newegg lost all credibility with me years ago.

I’m not a big fan of it either. The goal was to duplicate the color of the giant ferns in this biome.

K

Collusion among all the big players in an industry, in order to exclude other players from succeeding in that industry is indeed anti-competitive, and potentially illegal. There’s potential merit here in businesses coordinating with each other on who to blacklist withing the industry, which is why lawyers were willing to take on the case.

Ultimately, it’s a question for a judge whether they’re doing this for the purpose of suppressing competition, somehow, or whether they’re doing it for valid business reasons (like, say, avoiding a company with a history of not paying its bills, or avoiding a company with a history of sabotaging business relationships, or avoiding a company that their own customers actively hate, and would lose them business).

Of course, with the courts the way they are these days, I’m not holding my breath for the obviously-sensible ruling.

I mainly use the one that involves rotating a foundation on top of the corner of another foundation, and nudging it over to line up the corners. Cause it produces perfect corners, and it allows for 5-degree increments, instead of just 10-degrees, like the catwalk method.

This video I covers the technique, and I think pretty much all the others.

Blueprints and hand-building.

Officially, all third-party clients are already against ToS. Only bot accounts are officially allowed to use the public API.

You can have a look at the old posts from that build.

Day 32 Day 74 Day 75 Day 78 Day 79

I assume each of your towers covers building one item (like module frames)?

Sort of. Modular Frames do indeed get their own building. In addition, there’s a Smeltery building, a Constructory building, and a building for the other two Assembler products: Advanced Iron Plate and Encased Industrial Beam. Also, of course, the building I just built, for Heavy Modular Frames.

Do you have the structures themselves as blue prints, or do you build them by hand?

In this case, I did blueprint most of the structural stuff. The machines and all were done by hand.