Julia and Cython are just two of the languages that already achieve this (albeit with their own warts and bumps) and from what I see at the Ritchie page, I thin

Julia and Cython are just two of the languages that already achieve this (albeit with their own warts and bumps) and from what I see at the Ritchie page, I think I'll stick with those. BTW -- speaking as someone who first learned to program in a dynamically typed language and only later saw the beauty of static typing, I would strongly debate the idea that type inference everywhere is a good thing. The benefit of strict static typing is not so much that it allows a compiler to produce fast code -- there are lots of ways to achieve that. The benefit is that by forcing the programmer to type out the type signatures of functions in advance, you force a level of thought clarity and appreciation for the way that different pieces of code have to pass off data or state to other parts. I find it leads to better software not because of the compiler (although a compiler catching your mistakes is great for productivity), but because it makes you think much more clearly. It's sort of like the habit of writing down your moves in chess. The benefit is that it creates a ritual of thought and reflection, and potentially makes you more careful. These days, I see code with enforced type declarations and typed signatures as so much more elegant than similar code that, while having fewer characters, conveys significantly less about the programming intention. Those extra characters for type info are not clutter, not by a long shot.