Fast compilation is nice and I believe stuff like incremental compilation are essential.
But at the end of the day I'll prefer slower compilation every time if it means advanced checking.
And speaking of the zone I prefer writing Scala code for like 1h while fixing compiler errors and then you run and it just works TM vs Java where you'll waste your time tracking NPE ...
> But at the end of the day I'll prefer slower compilation every time if it means advanced checking.
I don't think that's a large issue in Rust. Type checking is quite fast in comparison to code generation.
Generics, traits, macros etc. seem to be the culprit. Turning complex language features into code and not runtime safety lead to these slow compile times.
I'm a nobody of course, but I do. Ugly is subjective, and by "ugly" a lot of people probably think "alien", as not what they are used to. Less syntax cruft is good for cognitive load and more common syntax is good for adoption.
But I'm sure the problem fades away with practice.
> The rationale seems to be: fast compilation leads to more productivity, which leads to more bugfixes.
Sure, but add LLVM to the mix and you get a slow ass compilation time even in Zig (See Zig filing divorce from LLVM https://github.com/ziglang/zig/issues/16270). Granted, LLVM isn't the only thing to blame. Rust has its own share of problems stemming from monomorphisation, and macros, type check seems to be not as big of a culprit. Although, that depends on the project.
Being fast to compile, versus being efficient to optimize seems to be the trade-off here.
Code is meant to be read, so a lot of people care actually.
Sure it's not the only thing that contributes to the usefulness and appeal of a language, but reading code is still one of the two main things we do with it so it's quite important to nail the syntax right.
What stood out to me:
> In other words, if compilation is fast, the tooling is easy.
Andrew Kelley said something similar in a recent talk. Compiler performance seems to be the number one priority at the moment for Zig.
The rationale seems to be: fast compilation leads to more productivity, which leads to more bugfixes.
This claim seems almost bruteish, but it makes sense.
Tight feedback loops (think things like devops, REPL, TDD, light processes etc.) can help us to iterate more and stay in the zone.
To be fair a sophisticated type checker like Rust‘s also helps with that.
But of course any added friction and sluggishness can be an indirect hindrance to the overall correctness and even performance of a program.