kris-s

>The string processing is powerful, but inconvenient when you want to do things like indexing by offsets or ranges, due to Unicode semantics. (This is probably a good thing in general.)

This is being too generous to Swift's poorly designed String API. The author gets into it immediately after the quote with an Array<Character> workaround, regex issues, and later Substring pain. It's not a fatal flaw, a language backed by one of the richest companies in the world can have few fatal flaws, but AoC in particular shines a light on it.

I really like Swift as an application/games language but I think it unlikely it can ever escape that domain.

In absolute terms the number of people with deep knowledge here is probably higher than it’s ever been. The ratio has changed, which is what I think he’s actually lamenting here. He mentions civil engineering; one thing I find myself often bringing up is that software engineering is a brand new discipline. The operating domain of softare is immense, maybe infinite. So I’m less curmudgeonly than Jon is here, we’ve got a barely century or so of software experience as a species, there’s gonna be slop.

If they are competing with each other such that neither are getting done are they really priorities?

I would not have been as kind to FF7 as this author was. By any modern measure it is a bad game. The raw story material and the character design is fantastic. But the gameplay. The gameplay is so tedious the author couldn’t even continue without modifying the game.

Seems like Jonathan Blow, the creator of Jai, releases a game every decade or so. I wonder if the plan is to release his next game in a couple of years. Presumably it is written in this new language? Maybe the compiler will be released at the same time under the guise of “hey this is so production ready we have already shipped a game with it.”

The author mentions the following:

    fn add(x: Option<i32>, y: Option<i32>) -> Option<i32> {
        if x.is_none() || y.is_none() {
            return None;
        }
        return Some(x.unwrap() + y.unwrap());
    }
    The above looks kind of clunky because of the none checks it needs to perform, and it also sucks that we have to extract values out of both options and construct a new option out of that. However, we can much better than this thanks to Option’s special properties! Here’s what we could do

    fn add(x: Option<i32>, y: Option<i32>) -> Option<i32> {
        x.zip(y).map(|(a, b)| a+b)
    }

Do folks really prefer the latter example? The first one is so clear to me and the second looks inscrutable.

Is Elon Musk this century's Howard Hughes?

I think that's how the Hey email service does it.

What a cool project, I bet they learned a ton doing this.