That's why I love the Readex Pro font. It also has glyphs for Arabic and a lot more languages in the same file, so I can use one font file for everything.
I'm trying to build a native postman alternative using Rust + Iced. I want it to use .http files as its collections and .env files as its environments. So that data is stored in plain text and easily editable by AI and usable by other apps like VSCode rest client.
Whenever I'm filling a long form on an official website, I feel like I'm racing against an invisible clock because of this session time out thing that happened to me countless times.
It's already quite popular. I'm less convinced there's a large pile of people wishing for a fairly high performance garbage collected language that are not using Go because of this. There just aren't many viable alternatives.
Java and C# being the obvious (and more performant) alternatives. And compared to them, Go already wins because of not being, well, "enterprisey". And with that I mean less the languages itself, but also the whole ecosystem around them.
There are definitely lots, I'm one of them. I use Scala, which is very powerful and imho much nicer language than golang. But the tooling and other support is slow and subpar. But I just can't go back to a brain-dead language(!) like golang because it hurts to program in such languages to me. So I hope that either golang catches up with Scala's features, or that Scala catches up with golangs tooling.
And I think there are many similar people like me.
Scala is overcomplicated esoteric programming language. It is great for obfuscation contests. It is awful for production code, since Scala code lacks maintainability, readability and simplicity properties.
Perhaps, but other languages that look a lot like Go with these additions (e.g. OCaml) have not gained much popularity, despite getting much more love on forums like HN. It's important to remember that the people expressing strong opinions about sum types on the internet are a tiny and non-representative fraction of working programmers.
I blame C# for the confusion. Think of it this way: the ability to explicitly express a type Foo|null implies the existence of a non-nullable Foo as well. IOW it’s shorthand for “nullable and non-nullable types”.
I'm surprised nobody mentioned types or type systems as one of the best solutions for eliminating fear. Out of all the systems that worked on, the ones that were changed fearlessly were stuff written in Haskell and Purescript. That was before Rust became so popular. These systems were changed fearlessly and we had very minimal tests. The code reviews were much easier to perform as you don't tend to check if the code might throw exceptions but you just need to think about business logic.
These days I'd argue that Rust is at the same level of Haskell and Purescript in fearlessness.
Some languages that removes certain fears:
- Kotlin: removes the fear of null exceptions
- Go: removes the fear of forgetting about an error that this function throws
- Languages with ADT (Haskell, Rust ... etc): remove the fear of missing a case
I'd claim that this is a logic that comes from rich, first world countries where you don't need to prioritize things in life much, as you can mostly afford everything. Poor people have to think thoroughly about everything they spend money on.
