Type annotations are a workaround for compiler limitations, not a feature—a well-designed language should infer all types automatically, forcing programmers to write smaller, cleaner modules.

Yegor256 Blog offers insights, opinions, and discussions on software development, engineering practices, and technology trends. Covering topics such as object-oriented programming, code simplicity, and software design principles, Yegor256 Blog provides resources for developers and tech enthusiasts. Developers can explore unconventional ideas, challenge conventional wisdom, and broaden their perspectives on software craftsmanship through Yegor's blog posts and essays.

Yegor's Blog

Type annotations in statically typed languages like Java are a workaround for compiler limitations rather than a necessary feature. A well-designed programming language should be able to infer all types automatically by eliminating features like generics, method overloading, and reflection that make type inference undecidable. This approach would result in cleaner, more readable code while forcing developers to write smaller, more modular programs due to compilation constraints.

The End of Type Annotations

maybe I am to narrow minded from statically typed languages but what they describe is full of logical gaps. e.g. how do you define the type of function parameters? do you just assume all the accessed members exist and for each call to that function you check at compile time whether the input type has those members? this would be fundamental flawed because of typos and what if people use different names for the same thing?
also how are generics preventing full type inference? (ok java generics are shitty but C# compiles generics and has absolutely no problem with inferring types from generics). The inferred type of an element of List&lt;?&gt; would simply be object. and for a List&lt;? extends Base&gt; it would be Base. if you need stricter type inference use stricter generics.

At least the author is working on a language project to test his opinion. What’s funny to me is how they are using Java, one of the most verbose languages, to create one of the least ones.

Working without clear types and interface would be a hell, this is not the future. Typescript has been a bless and really was needed on frontend projects.

Static typing is a must for any project larger then one or two scripts and/or more then I engineer working on it. This is exactly why languages like python introduced type hints/annotations. I can’t even imagine the level of confusion if there were no static types in our code base which is a couple of thousand files large. My favorite language is Python and I use type annotations/hints even in small scripts because it will be a lot clearer. And when I return to the script in weeks/months or even years I will have a lot less problems in understanding what I was doing compared to no type annotations.

Bull. Typed languages are simply easier to read and debug. And taking the load of guessing types off of compilers and runtimes will likely help performance in the long run too. It’s not the compilers that are lazy, it’s the devs.