Programming Languages Every Developer Should Watch Out For
Tags: programming, tutorial, coding, beginners
Published: 2023-10-02 18:31:44

In the ever-changing field of programming, staying updated with the trends of new programming languages, frameworks, and other required tools is a necessity for every developer who seeks to thrive in this field. Remember `Ada` and `COBOL`? These were two dominant languages in the '90s, but today? Not so much. `TypeScript` was released in `2012`, and it is a requirement for most full-stack developer jobs out there today. `Dart` first appeared in 2011 and has become a global phenomenon in the field of mobile app development. These are a few examples to illustrate how dynamic the field of computer programming is. New programming languages are released all the time, and it's better to stay updated and have a good knowledge of them now before they become a requirement for every job opportunity out there.

In this article, we will be looking at some of these "new" programming languages that every developer should keep an eye on, to keep it simple, we will be giving you reasons why you should care and to top it off, we will write "Hello, World" in each of them. 

So buckle up, and let's dive in because it's going to be an exciting journey 🚀.


![Let's go](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w3ubrn1pzzocggopudai.gif)


## 1. [Carbon](https://github.com/carbon-language/carbon-lang)

Imagine if C++ is easy to read, write, understand, and had a smooth learning curve. It would be every developer's number one choice when it comes to building performance-critical applications. However, it's evident that C++ is not.

![C++ Meme](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vzgv3586se6unt3yn52v.png)

There are other programming languages out there, like Rust, that have relatively simple syntax and can be used to build performance-critical applications. The problem, though, is that these languages are not interoperable with C++. C++ has been used to build numerous applications across various industries, and no developer wants to undertake the daunting task of converting an entire C++ codebase to a different programming language. 

This is the problem that Carbon seeks to solve. Carbon was first announced by Google in 2022 and is meant to be the successor to C++. Carbon is C++ interoperable, with a simple syntax, while also providing the performance of C++. The language is still a work in progress, and the official release date for Carbon 1.0 is set for either 2024 or 2025. Want to

**Hello World Program in Carbon**

```Carbon
fn Main() -> i32 {
 var s: auto = "Hello, World!";
 Print(s); 
 return 0; 
}

```

Similar to C++, every program begins with a main function, serving as the entry point. It's declared using the `fn` keyword, and specifying `i32` indicates that the program will return a 32-bit integer.

To declare a variable, we utilize the `var` keyword and place a colon before the variable's identifier to specify its type. In this particular case, we've assigned the type `auto` to our variable, indicating that its type will be determined based on its initializer. The `Print` keyword is employed to display the value of `s` on the screen.

## 2. [Rust](https://www.rust-lang.org/)

Rust is used in building systems where performance is critical, such as game engines, databases and operating systems. It is an excellent choice for WebAssembly. It offers relatively simple syntax and delivers with the speed of languages like C and C++. 

Traditionally, high-level languages like Python use garbage collection for automatic memory management, while low-level languages like C++ provide functions like `new`, `delete`, and `free` to allocate and release memory spaces when needed. However, Rust takes a different approach, using the concepts of borrowing and ownership to ensure memory safety and proper management.

![Rust is memory safe](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3byy6sqb2mbx82y1umku.png)

By default, all variables in Rust are immutable, meaning that attempting to assign a different value to a variable after it has already been given one will result in a compilation error. Instead of multiple variables, values are assigned to a single variable called the owner. When the program goes out of the scope of the owner, the memory space assigned to the variable is released using a special function known as `drop` in Rust.

Rust includes a standard library that provides various functionalities such multithreading, file systems, and input and output operations, among others.

It's also accompanied by a package manager and build tool called Rust Cargo. You don't have to concern yourself with programming dependencies and setups; all you need to do is specify the library, and Cargo will take care of the rest.

```rust
fn main() {
    println!("Hello, World!");
}

```
`main()` function is the entry point to the program, and it is declared using the `fn` keyword. `println` is used to display "Hello, World!" to the console. The `!` in front of the `println` indicates it no regular function call but a [macro in rust](https://doc.rust-lang.org/book/ch19-06-macros.html)

## 3. [Mojo](https://docs.modular.com/mojo/)

While Python is an excellent choice for productive programming, it does tend to lag behind other languages such as C++ and Rust when it comes to raw performance. This is where Mojo enters the scene, it's a superset of Python, and it boasts the remarkable ability to accelerate your code to speeds up to 35,000 times faster than standard Python.

![Python is slow](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ya9go5r0nx4dwpngch25.png)

Mojo, released in May 2023, comes from Modular, a company founded by the creator of Swift, which, replaced Objective-C. What sets Mojo apart is its full compatibility with Python, meaning you can still use your favorite python libraries with Mojo

Mojo also enhances Python with strong type checking, which can optimize your code. Dynamic programming, just like in Python, remains fully supported in Mojo.
Just like Rust, Mojo uses the concept of Ownership and Borrowing for memory safety and management. Just like python—Mojo is designed with a focus on programming for AI hardware GPUs. It comes equipped with built-in auto-tuning capabilities to optimize your code specifically for your target device.

[Mojo](https://docs.modular.com/mojo/) truly unlocks a world of possibilities in high-performance computing. 

**Hello World Program in Mojo**

```mojo
fn main():
   print("Hello, world!")
```

This is so simple and requires no explanation. Enjoy 🚀


## 4. [Elixir](https://elixir-lang.org/)

Elixir is a dynamic and general purpose functional programming language with a straightforward syntax, similar to Ruby. It was released in 2012 by Jose Valim. Elixir runs on the Beam Erlang virtual machine, making applications created with Elixir very concurrent, resilient at runtime, and fault-tolerant—qualities that many applications built with programming languages like Python and Ruby often lack. Elixir consistently ranks among the most beloved languages by developers with a growing ecosystem, characterized by a welcoming community eager to share resources and valuable libraries with beginners.

![Elixir meme](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ls5jpwsvlyvreow46xc4.png)

These capabilities and Elixir tooling enable developers to be productive across a wide range of industries in fields such as web development, embedded software, machine learning, data pipelines, and multimedia processing.

It is used by discord to handle a massive amount of concurrent users. It is also used by Pinterest, Heroku and other notable applications. 

Elixir comes with the Phoenix web framework, which offers most of what you need for web development tasks. It provides features that help developers easily keep track of multiple users connected to their applications. The LiveView feature of Phoenix makes it much easier for developers to build rich and interactive user interfaces without having to introduce a separate frontend tool to handle interactivity.
With simple syntax but efficient and concurrent performance, Elixir will take over the programming industry in no time.

**Hello World Program in Elixir**

```elixir
IO.puts("Hello world from Elixir")
```

`IO.puts` just like in Ruby, is the responsible for displaying the "Hello world from Elixir" to the console. The parenthesis is optional in writing this program. 

## Conclusion
Hey Devs, In this field, just like you already know, you never stop learning; you have to gain the required knowledge the programming market expects you to, and it is quite a dynamic market. I hope this article gives you a fair idea of how the programming market will be in the years to come.

g.elvis here and Peace Out✌️


![Happy Hacking](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gs6530ho6dpxzcp5bjoz.gif)