... but at least for myself I have quite an impression how such a language could (or should) look like. Here I want to keep a few notes on useful features, obsolete concepts and trade-offs worth the price.
- Possibility for evaluation / scripting
- Transparent abstractions
- Huge compile-time optimizations
- Optional runtime support
- Free memory management
The first point is important. I want a language to be easy to play around, test and incrementally build implement algorithms without needing to re-compile a full application. On the other side I want to have transparent abstractions and other benefits that lead to huge compile-time optimizations. Compiling may take a little bit longer, but the runtime should be as good as it could be.
Finally also two more important points: I love reflection and I think it is highly useful for a variety of applications. I want types to be stored in a kind of meta data repository that can be accessed via some optional runtime lib. What enters this repository is determined explicitly. Now what about memory management? By default the language should be stack based, with a clear ownership model. Nevertheless, it should be possible to allocate or free some memory directly. That way more complex scenarios can be covered as well.
From all the languages on the market I guess Rust is the closest to my personal desire. But I also think C++ is already quite close. What could be improved here?
- Make the preprocessor less powerful by removing macros
#includestatements by a module system
- Let code flow around like Swift does
deleteby ones that return shared / unique pointers (everything else can be done via
freeand similar functions)
- Include vector ranges like Julia / Matlab / Cilk Plus (mainly for SIMD)
- Concurrency features such as
Well, I am curious to see what will happen in the future. I don't give up on compiled languages with a strong static type system.