Conciseness: Reduce the amount of boilerplate code necessary to express certain constructs.
Versatile: Create a language that is suitable for any type of industrial application development, be it web, mobile, desktop, or server-side.
Safe: Let the language handle some of the common pitfalls made with issues such as null reference exceptions.
Interoperable: Permit the language to interoperate with existing Java codebases, libraries, and frameworks, allowing for gradual adoption and leveraging existing investments
Tool-enabled: JetBrains makes tools and it does so out of the belief that many mundane tasks can be automated and lead to more efficient and productive development. As such, the language has to easily allow for tooling.
Kotlin has and will always be about pragmatism—seeing common issues we encounter frequently when writing code and trying to help address these. This surfaces through various language features such as:
Null-safe by default: Kotlin types by default are not nullable, avoiding pesky null reference or pointer exceptions.
First-class delegation: The ability to delegate functionality of a class member to an external function, thus allowing for reuse and better composition.
Conventions: A series of conventions that allow for writing expressive code, giving way to creating a strongly typed domain-specific language that provides better discoverability and easier refactoring.
Crystal is a general-purpose programming language with the motto "Fast as C, slick as Ruby."
It's a high-level, statically typed, compiled, fully object-oriented programming language with advanced type inference and garbage collection.
The design goals of Crystal are:
Have a syntax similar to Ruby (but compatibility with it is not a goal).
Be statically type-checked but without having to specify the type of variables or method arguments.
Be able to call C code by writing bindings to it in Crystal.
Have compile-time evaluation and generation of code, to avoid boilerplate code.
Compile to efficient native code.
Crystal has unique features such as:
Channels: Crystal uses Channels inspired by CSP (just like Go) to achieve concurrency. It has cooperative and lightweight threads called Fibers to achieve this. One can easily create a Fiber with the spawn keyword and make the operation asynchronous/nonblocking.
Macros: Crystal uses macros to avoid boilerplate code and gain metaprogramming abilities. Macros are really powerful and evaluated at compile time, meaning they have no performance penalty.
crystal command: The crystal command itself is really powerful and comes with great built-in tools. It is used for creating a new project, compiling, running the test suite, and much more. There's also a built-in code formatter that you can use with crystal tool format. There's also crystal play, which is an interactive playground for some quick prototyping, just like irb.
First introduced in 2012, Elixir is a general-purpose functional language designed for productivity, scalability, and maintainability. While the language is relatively new, it compiles to bytecode that runs on the Erlang Virtual Machine (BEAM). The Erlang VM was born out of the telecom industry, has been evolving for almost 25 years, and powers many massive, high-availability, and low-latency systems.
Currently, Elixir is primarily used to build web applications using either Cowboy, which is a bare-bones HTTP server, or Phoenix, a full-featured web application framework. It is also building steam in the embedded hardware space with the Nerves framework.
The Elixir syntax and toolchain both draw some inspiration from Ruby. While the syntax similarities are only skin-deep, the toolchain will feel familiar to anyone who knows Ruby. The commands are well thought out, are easy to use, and facilitate great developer productivity.
“Friendly” functional programming: The power and benefits of a functional language, with a clear and approachable syntax.
Highly concurrent and scalable: The language shouldn’t get in the way of tackling big problems for many users.
Excellent development tools: For building, managing dependencies, testing, and deployment.