12 New Programming Languages You Should Know

To some people learning a new programming language is an excess best avoided. Why, oh why, they argue, do we need yet another language?

Don’t we have enough already?

Aren’t the existing tools getting the job done?

And then there are those tireless seekers who jump at the opportunity of trying new things and stumbling upon gems. Learning is an end in itself, and they don’t need much convincing to burn away their weekends building a console-based card game in that obscure, new language.

No matter which camp you belong to, there is something beyond debate: we all want to spend time on something that will have a bright future.

For the people in the legacy camp, their favorite existing language already has tons of momentum and will continue to have a bright future. To them, I must remind them that their now-mature preferred development toolchain was once “kool-aid” that many refused to drink. And so it is today; new technologies are added to solve new problems or to ease the pain of development.

If something does this radically enough, chances are it will continue to snatch mindshare and reach the top. When that happens, you don’t want to be left behind. 🙂

And to those who like to run with the shiny stuff, a warning: having fun is essential as a programmer, but we must be careful not to waste our energies aimlessly.

Sure, Brainfuck is an incredibly twisted, puzzle-like, fun little language, but you’re unlikely to benefit by pursuing it seriously. You want something that is new, sensible, and has a solid foundation.

How these languages were selected

Language selection is an intimidating job, especially when new languages are being considered for future benefits in employment and satisfaction. Every language author is firmly convinced they’ve built the perfect language possible and solved all the problems there are to answer. How, then, do you cut?

For this post, I focused on a few parameters to keep my search within reasonable boundaries.

Release Date

I specifically avoided languages that are very, very new.

New, I mean languages less than 5-6 years old as of writing, and especially those that haven’t reached stability (1.0 release, that is). But I do hope to come back to this and write about their success someday. 😀

For me, 5-12 years is the sweet spot, which is when a language has stabilized, and more refinements are being worked out. Now, of course, there are exceptions to this rule, and these will be considered where applicable.

Strong Community Interest

This one is a no-brainer but often gets ignored when we get excited about something new. Now, for many people, the backing of a large company is enough precedent for success, but it’s not always true.

Yes, Apple’s Objective-C and now Swift thrived because these were the only options in a highly controlled ecosystem, but Facebook’s D and Hack (an ugly take on an already ugly language, in my opinion) remain little more than experiments.

The ideal combination would be a language backed by a large, stable company and exploding in popularity (like React).

But the meat of the matter is still the community. If a language is not creating a buzz, and there are not enough devs to educate and popularize, it’s not going to climb out of its GitHub grave.

For me, this rules out mature, fascinating languages like Racket and Erlang, as they’ve remained flat on the growth curve.

Focused, Well-Defined USP

The third thing I’m looking for is a clear-cut goal for the language. For example, a better version of PHP that fixes naming issues and compiles to native PHP doesn’t work for me.

The benefits are just too small to justify the cracks if everyone tries to move to it. By this yardstick, I cannot help but dismiss attempts like CoffeeScript, and many other similar compiles-to-JavaScript languages.

Honestly, I’m bound to dismiss syntax-only improvements immediately. History has shown that usefulness trumps friendliness when it comes to languages, so if all new languages focus on is a more pleasant experience, I’m afraid it won’t make this list.

Clear, Consistent Syntax

Yes, I know. I just said that syntax doesn’t matter. Well, to be precise, I said that “syntax-only improvements” don’t matter. But that said, syntax remains one of the significant factors in programmer productivity and maintainability, so it’s something that’s bound to feature in my calculations here.

Along with syntax comes the idea of consistency. Function naming, module structuring, etc., are key things a language can’t afford to get wrong. It’s 2018, for God’s sake, and another PHP-like language design would be a shame for all of us. So, without further ado, let’s get started with our top five recommendations.

Julia

To the folks at the MIT, the languages available for data science were a compromise at best. Python, for all its clarity and popularity, lacked native constructs for dealing with data objects. Also, being an interpreted language, Python was slow for them (not the libraries, mind you, as they are mostly written in C).

But perhaps the biggest turn-off was the clunky concurrency model, and the lack of a parallel computing model, the latter of which is a staple in super-computing.

As a result, Julia was born.

Julia reached its stable release on 29 September 2018, barely a few days before this article was written (talk about timing!). Here’s what the official website has to say about its capabilities:

Julia excels at numerical computing. Its syntax is great for math, many numeric datatypes are supported, and parallelism is available out of the box. Julia’s multiple dispatch is a natural fit for defining number and array-like datatypes.

Syntax-wise, Julia can be seen as a combination of Python and C. Yes, it’s probably the first time a language has aimed at both these qualities and succeeded.

To keep matters simple, Julia is blazing fast and doesn’t enforce strict typing. Here are some benchmarks:

As you can see, Julia is slightly worse than C but blows Java and Python out of the water. And what sort of eye-candy does Julia offer?

Well, here’s the implementation of a function for calculating the hypotenuse of a right triangle:

Finally, while most of the Julia ecosystem is heavily tilted towards mathematical work, I believe it has a bright general-purpose future.

It’s the first language, to my knowledge, that has first-class support for parallel computing, so it will be no surprise to see it gaining more popularity in the Web and IoT domains.

Rust

If you’ve tried the new Firefox browser releases, you know that finally, after years of working, it’s looking like they might be able to take away some market share from Chrome.

If the browser feels light and snappy and renders quickly, it’s all thanks to the language Mozilla specially developed: Rust.

To say that Rust has a bright future will be a lie; the language is already a massive success, and if you’ve not heard of it yet, it’s because its area of application is specialized, and its goal scary: replacing C++! Yes, we finally have a language that not only is capable of doing this but is already doing it.

For people frustrated with C++’s over-burdened design and memory management challenges, Rust comes as a breath of fresh air.

Here’s what a Rust program looks like:

Concise and elegant, in my opinion. Rust follows the functional programming approach, which makes your code more composable, and there are no object-oriented hierarchies to wrestle with.

So, what gives Rust the courage to go after C++? It’s the new memory model. Rather than relying on the old new()/delete() dance, Rust introduces the idea of Ownership.

Rather than allocating and accessing memory directly, Rust variables “borrow” from each other, with strict restrictions placed by the compiler. The overall concept is too complicated to explain in a few words, so feel free to check out the official docs to learn more.

The point is, that this results in 100% memory safety without the need of a garbage collector, which is a big deal.

Rust has taken the system programming world by storm. It’s already supported on some platforms, powers browsers and rendering engines are quickly replacing C/C++ code on production systems, and is being used to write operating systems.

Sure, it’s not everyone’s cup of tea to create another browser or device driver, but Rust is already spreading itself to other domains. We already have several fully functional, ridiculously fast Web frameworks in Rust, and more and more application libraries are being developed.

Honestly, if you’re interested in an exciting future, Rust is the perfect language, and now is a perfect time. Rust is a plane that has taken off, but there’s still time to get on board as it heads for the stars!

Learn Rust from Dmitri Nesteruk.

Elixir

Among languages that focus on developer happiness, the first place has been permanently reserved for Ruby. It’s a language that reads like poetry and has enough shortcuts to reduce mental friction by order of magnitude.

No wonder, then, that the Rails framework continues to dominate full stack development for serious developers and startups. But not everyone was happy with Rails, especially one of its core developers – José Valim. I think the creator himself best explains the genesis of this language in an interview:

It is a long story, but I will try to make it short and sweet. Back in 2010, I was working on improving Rails performance when working with multi-core systems, as our machines and production systems are shipping with more and more cores. However, the whole experience was quite frustrating as Ruby does not provide the proper tool for solving concurrency problems. That’s when I started to look at other technologies and I eventually fell in love with the Erlang Virtual Machine.

I started using Erlang more and more and, with experience, I noticed that I was missing some constructs available in many other languages, including functional ones. That’s when I decided to create Elixir, as an attempt to bring different constructs and excellent tooling on top of the Erlang VM.

And behold, Elixir was born!

Just like Scala improves upon the Java language but targets the same virtual machine underneath (the JVM), Elixir to takes advantage of the decades-old, battle-proven Erlang virtual machine.

Now, a discussion on Erlang is beyond the scope of this article, but the minimum you should know is that it’s the telecom industry’s best-kept secret: if our phone networks are much more reliable than our Web-based systems, it’s all thanks to Erlang.

In even simpler terms, what it means is this. If you’re building a real-time system like chat, Elixir is much less RAM hungry and stable than Ruby (or PHP, Python, and Java, for that matter).

A machine that runs Ruby and maxes out at 10,000 concurrent connections can easily handle 200,000 when using Elixir and still have enough RAM to run 2D games!

Syntax-wise, Elixir shamelessly copies Ruby, and its dominant Web framework, Phoenix, shamelessly copies Rails. I’d say that’s a good thing, too, because along with Laravel, Grails, Masonite, etc., we are reaching a point where all languages have Rails-like frameworks which can ease the transition. Some might scoff at the “lack of originality,” but at least I’m not complaining.

Finally, Elixir is one of those technologies that are refreshing, pleasant, and damned practical. Several Ruby (and even non-Ruby) shops are moving to Elixir, and big companies like Pinterest are using it in production with extremely satisfying results.

Many people think that Node.js was a makeshift attempt at concurrency and would soon be replaced by Elixir. I have to say I agree with them. 🙂

Kotlin

In 2017 I/O, Google unleashed a bomb upon the unsuspecting crowd. The company formally announced Kotlin as the primary language for Android development, sending shock waves through the industry.

Now, that Google has been actively looking to replace Java comes as no surprise after being bitten by an Oracle lawsuit; however, the adoption of Kotlin was somewhat unexpected, and there’s still a good chance Google will come out with its virtual machine soon. For the time being, though, Kotlin is enjoying a surge.

Kotlin was developed by JetBrains, a company better known for its suite of insanely good code editors. One of them, IntelliJ IDEA, forms the bedrock of the Android Studio. The design goals of Kotlin are safety, conciseness, and 100% interoperability with Java.

More than anything else, the Kotlin compiler works extra hard to eliminate any null-pointer exceptions that are so common in the Java world. It also takes down the proverbial Java verbosity quite a bit, which will come as a relief to many.

Here’s a wonderful code comparison between Java and Kotlin:

The Kotlin code is significantly shorter and has much less cognitive overload to plow through.

But let’s get one thing clear: Kotlin is extremely unlikely to replace Java, though it is rapidly becoming a quick favorite. I believe that ten years down the road, small- to medium-sized teams will look no further than Kotlin, while large groups will continue using Java purely because of legacy reasons.

That said, Kotlin has an extremely bright future as it does everything that Java does, can merge with Java code without anyone noticing, and is much more pleasant!

TypeScript

God knows I had to restrain myself for this spot! Everything inside me was screaming “Elm! Elm!”, but no matter how revolutionary its ideas are or how divine the syntax, Elm is yet to be seen as a mainstream alternative for front-end work. 🙁 Anyway, let’s move on to what is mainstream: TypeScript.

JavaScript is like wild berries: ugly and distasteful, but you have to stomach it if you wish to survive the jungle of front-end development. Many attempts were made at replacing it (and most likely, the new WebAssembly standard will succeed), but what truly caught everyone’s attention was the superset developed by Microsoft.

There are excellent chances that you’ve heard of TypeScript: Angular was the first framework to embrace it from version 2 onward, and people were quick to take note. That’s because TypeScript adds some much-needed and fantastic superpowers to the most famous programming language in the world.

Yes, it’s finally possible to write native JavaScript code without suffering and cursing one’s birth!

Here are the enhancements that TypeScript brings to the table:

✓ Strong typing: Finally, a string is not a number, and a number is not an object, which is not an empty array!

✓ Compile-time type checking: If your code compiles correctly, it is more or less guaranteed to be free from the warts of the JavaScript runtime.

✓ Classes and Modules: Yes, classes are standard in ES6, but they’re included in TypeScript as well, besides a neat module system.

✓ Type inference: For complex types, the type can be figured out easily by the compiler, saving you some headache.

✓ Async/await: The async/await keywords and patterns are fundamental, so no more messing around with Promises and Callbacks!

Namespaces, generics, tuples . . . I could go on and on, but it should be sufficient to say that TypeScript converts one of the worst development experiences into one of the best.

The impact of TypeScript cannot be denied. It pushed similar attempts like Google’s Dart out of the field (though it’s attempting a comeback through Flutter, a mobile development framework), and opened the eyes of JS developers to the benefits of stronger types.

As a result, significant libraries like React, D3, Vue (even jQuery!) now have a TypeScript version, and in the best software shops around the world, all JavaScript code is being written as TypeScript code. TypeScript headers are now available for Node.js as well (honestly, if a node can improve its concurrency story and patch its lousy memory management, it will last forever).

You might be surprised to know that the creator of Node.js, after publicly regretting his creation, is working on a new runtime (there’s no official website at this time; just the GitHub repo) that has TypeScript as its primary language.

The best news? TypeScript is a small language to learn with considerable benefits in the future. If you’re an intermediate JavaScript developer, you’ll pick up enough TypeScript within two days to port over all your existing code!

Elm

Elm is as quick as its name can be pronounced and is used for front-end applications, graphics, and games. It is a functional programming language created by Evan Czaplicki in 2012.

Elm is said to have no runtime exceptions – that’s where it shines. As a statically typed language, the compiler validates all the errors at compile-time (wow!) with friendly messages (the messages are full texts and not weirdly thrown codes).

What a sigh of relief for developers (de-buggers)! You’d be able to learn to code in Elm as you keep getting more errors – the compiler tells you what’s wrong and suggests what you should do to correct it!

Elm boasts of being speedier than React and more strongly typed than even TypeScript. Elm code is very organized and neat and will make you a better developer.

Since Elm is module based, you can easily create reusable components. Elm compiles to JavaScript that you can run on the browser. So, all you need for Elm to work is node and npm, and you can simply get Elm by using the command:

npm install -g elm@<version> 

You can put the version you want to install, for example, 0.19.1.

You can then check if Elm is adequately installed by using the –version command. If you don’t wish to do all the installation and setup yet – just go to their official website and use the online editor to play around.

So, let’s play around a little bit, then!

If you are not using the online compiler, you will have to install all the dependencies for the program we’ll be writing now (it’s pretty easy, though).

Let’s ask a user to type his name inside a text box and print the same on the page with a hello.

import Browser

import Html exposing (Html, Attribute, div, input, text)

import Html.Attributes exposing (..)

import Html.Events exposing (onInput)

-- MAIN

main =

  Browser.sandbox { init = init, update = update, view = view }

-- MODEL

type alias Model =

  { content : String

  }

init : Model

init =

  { content = "" }

-- UPDATE

type Msg

  = Change String

update : Msg -> Model -> Model

update msg model =

  case msg of

    Change newContent ->

      { model | content = String.append "Hello..." newContent }

-- VIEW

view : Model -> Html Msg

view model =

  div []

    [ input [ placeholder "Type your name", onInput Change ] []

    , div [] [ text (model.content) ]

    ]

Here is the initial screen when you build the program:

Type a name, and this is what you get on the screen:

Although this program might seem overkill for its purpose, as the program complexity increases, you will appreciate how easy it becomes to debug and maintain.

You can see a clear separation between the model, view, and controller (update). Similar to how we use HTML tags, we can create forms in Elm using the model div tags.

On the ‘on input’ event (i.e., the user enters a text), the program calls’ Change’, and the program prints the user name along with ‘Hello’ using the String.append function.

Pony

Pony is compiled and follows an actor model of computation designed for asynchronous behavior – i.e., highly concurrent applications.

Traditional programming languages provide a ‘lock’ feature to handle concurrency, which impacts performance. Pony doesn’t have a lock, thereby avoiding any blocking operations or deadlock scenarios. Each actor is single-threaded.

Pony also provides capability-based security, where users must use a ‘reference capability’ to access a particular object, ensuring safe data handling. For example, the capabilities describe what other aliases are denied rather than what they are allowed.

Notions like mutability and isolation are based on these capabilities. This ‘deny’ capability feature makes Pony free from the data race.

Pony is safe, fast, and accurate and saves development time, making it a good choice for banking and finance applications.

Pony ensures type safety for data handling. It doesn’t have any exceptions – only errors need to be handled to compile the code. The main reason for this is that Pony is statically typed. You need to explicitly specify the type (like Java, and unlike Python) of a variable before using it

let name: String

Similar to Java, you can create constructors. Suppose you have an employee class with name and age:

class Employee

  let name: String

  let age: U64

  new create(name': String) =>

    name = name'

Java developers might note that there are subtle differences in the syntax (no curly braces, wow!). There is also a ‘’’ at the end of the class attributes. You can also create functions:

fun get_emp_name(): String => name

Fun to write functions, eh?

Now, the main part – of actors and promises.

Pony actors have Behaviours – similar to functions – but only asynchronous – they are executed at some time in the near future but not necessarily immediately when called. But they ‘promise’ that the behaviours will be executed for sure.

actor Employee
  // actor has fields, similar to class
  let name: String

  // and of course, constructor
  new create(name': String) =>
    name = name'

  // Note the behaviour 'be' instead of the fun function
  be get_emp_name(promise: Promise[String]) => promise(name)

Well, promises can be rejected, too – if the actor cannot fulfill the asynchronous request being sent. You can create a promise:

// Create a new promise

let promise = Promise[String]

And invoke the actor’s behaviour by passing the promise to be fulfilled (in our case, getting the employee’s name).

employee.emp_get_name(promise)

Do you think this code will compile?

Another great feature of Pony is that it is memory safe – no NULL or buffer overruns. Any code that might return null will never compile unless fixed.

Well, we haven’t yet told the program what ’employee’ (our actor) is:

let employee = Employee(“J K Rowling”)

Unlike any other programming language, Pony allows division by zero, and the result is zero. There are mathematical proofs for all the features in Pony.  

To write Pony programs, you need to install the Pony compiler. Since Pony is a compiled language, you must compile the program using ‘ponyc’ before running it.

Once you install the compiler, try the hello world program.

Vyper

Vyper is a smart contract programming language based on Python. Like Python, it is human-readable, easy to code, and secure. Vyper compiles down to the Ethereum Virtual Machine (EVM) bytecode. EVM identifies the state of Ethereum for each block on the blockchain.

To understand why Vyper is special, let’s understand smart contracts.

Smart contracts are programs stored in a blockchain that define and execute an agreement between the seller and buyer when the contract requirements are met.

These are self-executing automated contracts that do not need human intervention. However, smart contracts are prone to vulnerabilities.

For example, smart contracts might be made to release ether to arbitrary addresses or killed by arbitrary addresses, or they may not be able to release ether. These vulnerabilities are usually introduced via the code – unintentionally or intentionally.

Vyper eliminates this issue by providing secure code, making it difficult to introduce vulnerable or misleading code. Although Vyper is based on Python, it doesn’t follow many OOP paradigms, like inheritance, overloading, recursion, etc. This avoids code complexity (having multiple files, making it difficult for auditing purposes).

Vyper also doesn’t support inline assembly, which means programs cannot perform any actions directly on the EVM, thus avoiding attacks.

These features make Vyper quite secure for writing code for smart contracts used in blockchains.

To practice writing programs in Vyper, you can use the remix online compiler.

You can also install Vyper using docker or pip (if you have Python) by following the instructions on the Vyper documentation page.

R

R is one of the most popular programming languages for data analysis and machine learning. It has APIs for all the complex mathematics, statistics and scientific calculations, machine learning algorithms, and visual representations.

R is open source and widely popular for its rich graphical user interface. It has a vibrant and stable community and can easily integrate with other languages like C, C++, etc.

We get all the above features through CRAN (Comprehensive R Archive Network), which contains more than 10000 packages for statistics, probability, data analysis, computing, graphics, and many more.

To see the magic of R, let’s try a simple program to find the average (mean) of 11 numbers. To find the mean, we take the sum of the numbers and divide it by the total number of values (11 in our case). R has a function called ‘mean’ that does all this calculation for us.

mynums <- c(51, 52, 53, 94, 88, 61, 31, 34, 76, 20, 10)

mean(mynums)

The output is:

[1] 51.81818

We can plot these using the plot method:

boxplot(mynums)

There are many advanced packages, like ggplot2, dplyr, and many more, to display rich graphics in R.

We can also view a quick histogram with the above values to see the range where the values fit.

hist(mynums, breaks = 10, col = "sky blue", main = "Histogram of marks", xlab = "Height Bin")

Note that we have given a break of 10; we can change this to any number depending on the divisions we want.

The above variable, mynum was a vector that contained a list of numbers. Similar to Python, we create a data frame in R to work with more dimensions.

This is most useful for analytics. For example, we can combine multiple vectors, create a data frame, and manipulate the same depending on the number of variables and the type of analysis we need.

Let us say we have employee name, skill, and age vectors. We can create a dataframe and display the data together:

employees = data.frame(Name = c("John","Mac","April","Ron","Matt"),

                        Age = c(23,28,30,43,31), Skill = c("Java", "Python", "C++", "R", "PHP"))

print(employees)

> print(employees)

    Name Age  Skill

1   John  23   Java

2    Mac  28 Python

3  April  30    C++

4 Ron  43      R

5 Matt  31    PHP

Another interesting feature of R is the ease of matrix manipulation using arrays. R will blow you away by performing complex matrix calculations with a breeze. All you have to do is create the matrix and give it to the R program.

M1 <- matrix(c(1, 2, 1, 2), ncol=2)

M2 <- matrix(c(3, 4, 3, 4), ncol=2)

print(M1*M2)

>print(M1*M2)

     [,1] [,2]

[1,]    3    3

[2,]    8    8

Apache Groovy

After careful consideration and evaluation, I have included Groovy in my list of top programming languages. This language is like the butter on top of a delicious cake, providing additional flavor and enhancement to any project.

One of the main reasons Groovy deserves a spot on the list is its wide range of features, which have contributed to its growing popularity in the tech world. As an agile and dynamic language for the Java Virtual Machine (JVM), it enables modern programming features for Java developers with a minimal learning curve.

It’s worth noting that the JVM is an abbreviation for Java Virtual Machine. JVM is an integral part of Java, providing a platform for running Java bytecode on any device. Groovy, built on top of the JVM, offers a wide range of features that improve its performance and make it an attractive choice for developers. 

In simple terms, it provides a platform for running Java bytecode, making it possible to use Java on any device. From a performance perspective, Groovy can statically type-check and compile your code for improved robustness and performance.

Groovy’s seamless integration with existing Java classes and libraries sets it apart from other programming languages. It can also compile straight to Java bytecode, making it easy to use anywhere you can use Java. This feature adds to the flexibility and versatility of Groovy and makes it a top choice for developers looking to create efficient and reliable software.

Groovy’s dynamic nature may make type-checking problematic and debugging code more challenging, which is one potential disadvantage. However, many programmers believe that the flexibility and simplicity of Groovy outweigh any potential disadvantages.

As a developer, it’s essential to recognize the unique value that Groovy brings to the table. To illustrate this point, I would like to share an example that showcases how Groovy’s powerful features can enhance your code.

def greeting = "Hello, World!"
println greeting

// Define a list of numbers
def numbers = [1, 2, 3, 4, 5]

// Use a closure to map the list to its squares
def squares = numbers.collect { it * it }

println squares

In this example, we illustrate the versatility and expressiveness of the Groovy language by defining a string variable and printing it to the console using the println function. 

Additionally, we showcase how Groovy simplifies complex operations, such as transforming a list of numbers using a closure to create a new list containing the squares of each number. This demonstrates how Groovy can enhance your productivity as a developer by providing concise, readable syntax for everyday programming tasks.

Hence, it is evident why Groovy deserves the attention of every developer.

Crystal

After extensive research, we couldn’t help but add Crystal to our list. And no, we’re not talking about minerals! Crystal is a general-purpose, object-oriented programming language released in 2014. It was designed to have a syntax closely resembling Ruby while being fast and efficient. With its static type system and ahead-of-time compilation, Crystal offers developers C’s speed and Ruby’s simplicity.

Crystal is a relatively new programming language gaining popularity among developers due to its impressive speed and ease of use. It is often described as “Fast as C, slick as Ruby,” highlighting its ability to provide lightning-fast performance while maintaining Ruby’s user-friendly syntax and readability. 

However, Crystal achieves its impressive speed by sacrificing some of the dynamic aspects of Ruby and restricting certain programming constructs. Nevertheless, this tradeoff has made Crystal an attractive option for building high-performance applications in a more developer-friendly language.

# Define a class for a person with name and age attributes
class Person
  getter name : String
  getter age : Int32

  def initialize(@name : String, @age : Int32)
  end
end

# Create an array of Person objects
people = [Person.new("Alice", 25), Person.new("Bob", 30), Person.new("Charlie", 35)]

# Use a block to filter the array by age and map the names to uppercase
names = people.select { |person| person.age >= 30 }.map { |person| person.name.upcase }

# Print the resulting array of uppercase names
puts names.inspect

This code demonstrates Crystal’s benefits in syntax, performance, and type safety. Crystal’s syntax is similar to Ruby’s, making it easy to read and write. However, Crystal compiles to native code, resulting in faster execution than interpreted languages like Ruby. 

Additionally, Crystal is statically typed, which provides type safety at compile-time and improves performance. In this example, the code uses a block to filter an array of Person objects by age and map the names to uppercase, demonstrating the flexibility and expressiveness of Crystal’s syntax.

Reason

Reason is a contemporary programming language with a syntax similar to JavaScript or other C-family languages with the robust type system of OCaml. Because of its strong type-checking capabilities, developers can find problems earlier and write more robust and dependable code. 

Reason’s user-friendly interface and straightforward design make it a fantastic choice for various programming jobs, regardless of your level of programming experience.

Reason and OCaml are highly versatile programming languages that can be used across various environments thanks to numerous projects that support them. One way to use them is to build native executables that can run directly on your machine using the standard compiler. In addition, several tools like “dune” and “esy” that aid in this process. 

Another option is compiling Reason to JavaScript code compatible with browsers, which can be achieved through projects like ReScript (formerly BuckleScript) and Js_of_ocaml. These versatile options make Reason and OCaml appealing to developers across various industries.

Reason is a contemporary programming language with a user-friendly interface and syntax similar to JavaScript. It’s versatility and straightforward design make it a popular choice for developers in various industries.

Conclusion and Disclaimer

Well, we all have different favorites, but the above languages are worth trying as they come with all new features and solve many of the problems left by earlier languages.

Elm is great for neater code separation and modular programming. Pony is one of the best for asynchronous programming.

While Vyper is quite new in the smart-contract language world, it provides a promising alternative to Solidity. Vyper particularly scores well when it comes to contract definition and error handling. R, on the other hand, is considered one of the best languages for analytics and has a great community already in place.

Specific languages are gaining as much popularity as the ones in this article but have not been included in the list for various reasons. Here’s a quick look:

• Golang: Already established as a mainstream, if not very popular, language. I do believe at this point, Golang has several competitors that will keep its market share low.
• Swift: Apple has an iron grip on its ecosystem, and Swift is the only language available there. Earlier, Objective C was the rage, as Swift is now. I consider it cheating and so refuse to include it here. 😀

The future is always uncertain, and one way to go about your career is to stick to what’s already working and refuse to get “distracted.” If you do that, Java, PHP, Python, Ruby, etc., are all excellent languages to stick with. However, for some of us, the norm isn’t enough. They want to go out and explore and bet big on the future. If you fall in the latter camp, one of these five languages should be on the top of your to-do list.

Finally, when trying to assess a language, don’t let the effort overwhelm you because it’s not that much. If you already know a few programming languages, you can learn any of these within two months max, spending 5-6 hours a week. Whereas the happiness and monetary returns that can be generated in the future will be several times more.

Next, you can check out programming languages to use in data science.