Dane checking in. You know when you read a newspaper article on something you happen to know about and it's just hilariously wrong? Like, to the point of making you wonder if they're confusing your thing with something else entirely. That's your comment.

Leo Africanus by Amin Maalouf -- I was approached in an airport by a lovely old gentleman who essentially told me to read this book and insisted I take a photo of it so I wouldn't forget. Half a year later, I'm out of things to read and looking for a change (I never read historical fiction before) and gave it a shot. It has opened a world of a completely new genre for me.

Thank you, I had never heard of Leo Africanus.

But I would rather read his original work Cosmographia, rather than a fictionalized biography (same for Ibn Battuta).

Oh cool! I need help curing my addiction and I'm optimistic that this would do it for me.

I'm only half joking.

Not GP, but same story for me (except it's been more than a year now for me). I'm coding 90% in Rust. The remaining 10% is a good mix of OCaml, TS, Python, Shell. It doesn't really matter what I touch. Helix is my editor :)

You can? Imperative, strong type system (no null, adts), reasonably fast, compiles to a single binary. I'm genuinely interested.

Kotlin has null safety, and there are plenty of ways to turn jvm into a binary

It has no adts at all. Like I'm reading blog posts right now about how to do what should be the simplest thing

    enum Foo {
        A(String),
        B(i32),
    }

And it's.. not simple. And even if you manage to do it, it'll never be how Kotlin was meant to be written.

Its pretty simple:

    sealed interface Foo
    class A(val s: String): Foo
    class B(val b: Int): Foo

I agree with you 100%. It's the thing I miss most when not writing Rust. I will say that it as a feature alone isn't a good enough reason for me to write Rust, though!

Go fits all of those, so does Ada.

I've used Go for almost two years on a side project and its type system is exactly why I'm doing Rust now. In my book, it is not okay that I add a new field to a struct and then nothing happens. No compile warnings, nothing. It's just assumed that I then wanted the zeroth value whenever it's created. ... And no adts. You just can't make something as simple as

    enum Foo {
        Bar(String),
        Baz(i32),
    }

Why? It's such a fundamental thing to be able to say "this piece of data is either this or that.. and then have the compiler tell you if you missed a case.

Ada is on my list of languages to look at. I'm cautiously optimistic about that one. But would you pick that over Rust as the simpler alternative? "Look guys! We're not moving fast enough with Rust because nobody seems to be proficient in it. Let's go with Ada instead!" .. I jest, but I will check it out and I really hope it hits the sweet spot for me

go doesn't have null safety or adts though? (sum types)

I think you can have null safety in Go and you certainly can have adts.

But even then, what about Ada?

I’m also not an expert, but I assume between C#/Typescript/haskell/swift that you can find all those things in many GC/safer languages.

Go does not have compile-time null safety or sum types :)

    foo := Foo{"hello"}
    fooPointer := &foo
    fooPointer = nil
    fmt.Println(fooPointer.Bar)
    > panic: runtime error: invalid memory address or nil pointer dereference

In a language like Kotlin a compile time error would prevent `fooPointer.Bar`, and in Rust `nil` does not exist. Go also does not have sum types, see for instance https://making.pusher.com/alternatives-to-sum-types-in-go/

Yes, Ada. Maybe. I will have to look at it.

The rest all are missing basic things. Like, I love TS, but it's absolutely bonkers because js is js. I once worked on a 250k loc project of js/ts, and we had nothing but trouble

I'm in a fourth category. I just want a simple imperative language with a solid type system that is reasonably fast.

While Rust isn't simple, I don't know any other languages that fill this space.

I can. I work on a ~20k loc Python service as well as a ~10k loc Rust service. The Rust service is only half the size, but the problem space is many times more complex.

Whenever I work on the Python service I feel like I'm working in clay. Like, everything kind of sort of works. It won't at first, but then you just poke at it with a stick until it does. In Rust, it works or you're told exactly why it doesn't and then you fix it.

I change a struct and the compiler provides me with a list of places that need updating.

I have many reasons (mypy, type system, testing, venv, python 2), but really the big one is rust's superior type system as well as general tooling (lsp is way better, cargo and clippy are phenomenal).

I don't necessarily agree that Python overall is difficult to read, but one thing that seems to get my every time is the

    foo = x if y else z

I see where you're coming from.

Many languages support the ternary operator, where it would be:

  foo = y ? x : z

Which "feels better" but I think that's because I learned ternaries first.

Some languages like Rust and Kotlin do support assignment of an if statement like

  foo = if (y) { x } else { z }

And I think that's a good step, as it doesn't need to introduce new syntax, just allows assignment of "blocks"

Yes. It requires that `if else` can be used as expressions, which for some reason in most languages that can not.

In the beginning of doing Rust I was missing the ternary operator, but now I couldn't care less.

    foo = if y { x } else { y }

Works well :-)

Mine does. Still picked Rust, and so happy I did. The type system alone does it for me.

Helix is awesome. Thank you for doing this!