I was very nearly in the same boat. The initial box dialogue was written by and for angry 14-year-old boys. It gets massively better; the characterisation is broad and engaging, and the central-european fairy-rail feel is really quite strong. The two pieces of DLC have great stories themselves.

Unfortunately high. It's the same reason there's a "space force". He didn't know about the coastguard and guessed something else, then doubled down.

They haven't been charged.

That's a good point. You can get away with that with a new language, but adding nullability as a non-default option would break existing code much like making things const by default in C++ would, I suppose.

Lombok had a bunch of great things that should've been part of the java language to begin with. They've slowly been folded in (so now you have to work out which @NotNull annotation you want) but the language does still improve.

At least the potential sentence is long enough to get a jury.

It's one reason the government is so keen to reduce jury trials. Because nobody is going to send granny down for holding a piece of cardboard.

More like "I am the wellspring from which you flow," which is, let's face it, infinitely cooler.

Haskell, part 2

I broke down the outline into a set of boxes by scanning over them.

type Box = (C, C) -- inclusive coordinates
makeBoxes :: [C] -> [Box]
makeBoxes cs =
    let cs' = sort cs -- left-to-right first, top-to-bottom second
        scanLines = cs' & groupOn fst
     in scanOver 0 [] scanLines
  where
    scanOver lastX currentYs [] = []
    scanOver lastX currentYs (new : rest) =
        let newX = new & head & fst
            closedBoxes = do
                [y1, y2] <- currentYs & chunksOf 2
                pure ((lastX, y1), (newX, y2))
            newYs =
                -- Take the new column and remove anything that
                -- corresponds to a y value that appears in both
                merge currentYs (map snd new)
         in -- Close the current boxes
            closedBoxes ++ scanOver newX newYs rest
    merge [] ns = ns
    merge ms [] = ms
    merge (m : ms) (n : ns)
        | m < n = m : merge ms (n : ns)
        | m > n = n : merge (m : ms) ns
        | otherwise = merge ms ns

The fiddly bit was handling all the cases for shape subtraction. I don't give it here because it's just a slog, but the gist is this:

type Shape = [Box]
subtractBox :: Box -> Box -> Shape -- returns whatever's left

subtractShape :: Shape -> Shape -> Shape -- this is just a fold.

The idea: take a bounding box that's just large enough to cover all coordinates. From that, subtract the set of boxes above. You get a set of boxes that are in the "outside", ie, illegal region. [I did it this way because managing shape subtraction from the set of "inside" boxes is just more work.]

Then for each candidate rectangle, if it overlaps with any of the "out-of-bounds" boxes, it's not a solution.

Spooks (governmental, NGO or the companies who have convenient offices nearby) are always interested in hiring mathematicians.

Downvoted for clickbait headline editing, which was actually:

The (successful) end of the kernel Rust experiment

Let's be a little less breathless and a little more considered. please.

Upvote for mentioning union-find. It's the little algorithm that could, and almost nobody has heard about it.