Micro Focus is now part of OpenText. Learn more >

You are here

You are here

10 programming languages defining the future of coding

Peter Wayner Freelance writer

Which programming languages will have the biggest impact on coding in the future? It depends on who you ask. Things are changing all the time. Some languages such as Java and R, remain on the forefront. Other languages that were hot on just a few years ago, have cooled just a bit, nudged out of the limelight by emerging alternatives that make it easier to tackle the kinds of problems that confront enterprise programming wizards today. 

Some things have changed—and some haven't. One thing's clear: Automating the workflow continues to be the biggest role for the language creators.  Here's our list of the top programming languages that (for the moment at least) will define the future of coding.

1. Ethereum

Many people think of Ethereum and bitcoin as currencies, something you use to buy coffee or maybe something illicit. But if you peel away the hype and greed, there is a programming language buried inside that can define fairly elaborate computation to take place. The Ethereum language is even Turing complete, at least if you accept that the nodes may put a time limit on how long your code will run.

The Ethereum creators imagined that everyone spending the coins may want to do more than just move wealth from owner A to B. They figured that the parties may want to construct elaborate contracts full of codicils, caveats, and conditions on when the wealth might move or not move, and that these will be expressed in the computer language.

A 30-year mortgage, for instance, might be expressed as code that counts the monthly payments and removes the lien only after 360 payments have been made. These contracts written in code are the future of economics and commerce, and understanding the languages will be essential for crafting transactions from now on.

Highlights: Tightly integrated with the monetary system, which requires a strong emphasis on correctness and authentication.

Headaches: Tightly integrated with the monetary system, which brings regulation and paranoia.

2. React JSX

Technically, React web applications are written in JavaScript, but many of the templates are constructed in JSX, a weird conflation of JavaScript and HTML, no doubt created by someone who was very familiar with both.

Some of the annoying punctuation marks are left out to save time, and other structures have been simplified. But if you're going to be programming in React or in some of its cousins —such as Vue or one of the next generation of web apps that also use JSX—you're going to need to master this mixture.

That means knowing when to speak JavaScript and when to type out HTML. It's different enough that it might as well be another language.

Highlights: The shorthand lets you whip up elaborately interconnected web apps.

Headaches: It's neither HTML nor JavaScript, so you'll be constantly confused.

3. TensorFlow    

Machine learning is everywhere, and TensorFlow is one of the dominant open-source packages for exploring it. Technically, TensorFlow is written in a mixture of C++, Python, and the CUDA language. But the code you write will largely comprise calls to the Tensor Flow APIs, and that can be done with most major languages, including Java and JavaScript.

You can choose your favorite syntax and compiler, but the hard part will be diving into teaching your code to learn from your data. You've got to know how to build your model, and your code will reflect what you expect from the system. Understanding this structure of the API is the first step toward creating a genius.

Highlights: Real power to tackle difficult problems in AI, at your fingertips.

Headaches: The results are often spooky black boxes, and you'll be confused about exactly what they're doing.

4. TypeScript

It looks like JavaScript, and it's designed to do pretty much the same thing as JavaScript in browsers and Node.js applications. It’s even turned into JavaScript by a transpiler during the build phase. So why bother?

TypeScript offers the kind of typed safety, when no operation leads to undefined behavior, that makes many programmers happy, the kind that's kept Java code just a bit cleaner and better defined. The developers didn't change JavaScript much here; they just added an extra layer that ensures that the data types line up so you can catch some of the easiest errors before the code even runs.

It's the basis for the popular Angular framework, and it's growing in popularity because you can usually drop it into any place that wants JavaScript.

Highlights: Transpiles into JavaScript, making it widely applicable.

Headaches: Not everyone sees the beauty in the extra work required to create well-typed code.

5. R

The words "big data" may not generate the same excitement in a sales presentation as they did a few years ago, but the need for statistics continues to dominate many business decisions. If anything, the practices are now more integrated than ever, making R, a language for statistical analysis, more important than ever.

R is a programming language designed by statisticians and scientists to make their work easier. It comes with most of the standard functions used in data analysis, and many of the most useful statistical algorithms are already implemented as freely distributed libraries. It's got most of what data scientists need to do data-driven science.

Although it's a programming language for creating arbitrary functions, many developers use R inside an IDE as a high-powered scratchpad for playing with data. This makes it a sort of a hybrid between a spreadsheet and a graphic calculator.

RStudio and RCommander are two popular front ends that let you load up your data, chew it up, and spit it out as charts and tables. They make it less of a compile-and-run language and more of an interactive world in which to do your work.

Highlights: Clever expressions for selecting a subset of the data and analyzing it.

Headaches: It's mostly aimed at desktops, not the world of big data, where technologies such as Hadoop rule.

6. Java 8

A few years ago, the Java team looked around the Java Virtual Machine (JVM) world and found that many programmers were using JVM to do more than run Java. One of the ways to embrace this trend is by writing code in Scala, which blends all the power and discipline of a functional approach with the option to link in some of the billions of Java archive files floating around the web.

Now Java programmers don't need to switch to a separate language to get all of the advantages of functional solutions. Java 8 is good old Java, but made new again by an extra dose of functional mechanisms that can unlock the parallelism in your code.

You don't have to use parallelism, of course. You could stick with the old Java because it still works. But if you don't use the newer features, you'll be missing the chance to offer JVMs even more structure for optimizing code execution. You'll miss the chance to think functionally and write cleaner, faster, and less buggy code.

Highlights: Lambda expressions and concurrent code.

Headaches: A bolted-on feeling makes developers want to jump in with both feet and use Scala. 

7. Go

Go is tuned for the modern world, where much of the intelligence sits on servers juggling thousands of clients issuing millions of API calls. It's meant to be fast and light, built with just enough features to accomplish this job without too many other options that might get in the way.

There's not much to the language—and that’s the point. Google wanted a solution that was radically basic. It tossed aside many of the more clever ideas found in other languages and kept just enough to be, as one creator said, "simple enough to hold in one programmer's head."

There are no complex abstractions or clever metaprogramming structures in Go—just the most important features specified in a straightforward syntax.

This can make things easier for everyone on a team because no one has to fret when someone else digs up a neat idea from the nether reaches of the language specification.

Highlights: Just a clean, simple language for manipulating data.

Headaches: Sometimes you need a clever feature that's not here.


In the beginning, video cards were just something to generate glitzy imagery for gamers, specialized silicon for juggling millions of triangles so someone could fantasize about cheating death, facing danger, and blasting both death and danger with dozens of elaborate weapons.

But somewhere along the line, some clever programmers looked under the hood and saw a chance to speed up their code by unlocking gaming's elaborate computational firepower.

Today, many video cards simulate elaborate scientific models or run sophisticated AI algorithms. If you’ve got big computational demands, the CUDA language is a good way to open up the power of your graphics processing units (GPUs) to work in ways other than killing zombies or robots. You can even rent racks of them in the cloud to tackle your problem.

The key challenge to using CUDA lies in learning to identify the parallel parts of your algorithm. Once you find them, you can set up the CUDA code to blast through these sections using all the inherent parallel power of the video card.

Some jobs, like mining bitcoins, are pretty simple, but other challenges, such as sorting and molecular dynamics, may take a bit more thinking. Scientists love using CUDA code for their large, multidimensional simulations.

Highlights: Very fast performance, at least for parallel code.

Headaches: Identifying the sections of code that can most easily run in parallel isn't always straightforward.


If you ask most programmers, they’ll say that YAML is not a programming language; it's a markup language, and "yet another" one at that. But you'll find YAML configuration files and their cousins, formatted in JSON, in more places as more layers of code are controlled by the parameters specified in these once trivial files.

They may be the pawns of the programming game, but anyone trying to get their Node.js stack to do the right thing will spend time agonizing over the keystrokes in their YAML files. That work might not be considered full programming, but the placement of those characters can still lead you to pull out just as much hair.

Highlights: The format is relatively punctuation-free, but rich enough to express many layers of parameters.

Headaches: Beyond the basic format, the structures and conventions can be wildly different.

10. DSL  

DSL, the acronym, used to refer to Internet service from a phone company. But for developers it’s come to mean "domain-specific language," a generic, unspecific term that's appearing all over the place. The wrinkle is that the letters don't refer to one particular language to learn and master.

DSL represents a design philosophy that a language should be tailored to the job at hand instead of trying to be a general-purpose language to be used everywhere. So a language for a lighting controller at a theater might include a keyword for turning the lights on and off, but no extras for doing things such as saving data to a file or connecting to the LAN. Another language designed for running a steel plant might interface with the blast furnaces, but not with some API for turning coordinates into maps.

The emergence of these DSLs is a reflection of how designers are realizing that user needs are too complex for a few menus, checkboxes, or command-line parameters. The DSL users want to spell out their needs in multiple lines by stringing together domain-specific keywords while sharing domain-specific data.

Alas, each DSL is different, which is sort of the point. And the shared acronym doesn't make the DSL logic any easier to absorb. You can't study for a general DSL certification, but you should get ready to see them more and more often.

Highlights: Brings real power to many applications.

Headaches: As different as the various domains.

A continued focus on workflow

The same programmers who are finding clever ways for computers to remake stores, hospitals, and cars are also working to redesign their own jobs. They're speeding up the slog of creating software by adding more layers of cleverness so that tools are quicker and smarter about catching mistakes.

The newest computer languages are faster to use, because the built-in intelligence lets them help the programmer do more with fewer keystrokes. They often deliver fewer bugs, too.

The newer approaches include more structure and more abstraction, allowing the guts of the languages to do what programmers used to have to do themselves. These automated features give developers more leverage to concentrate on the bigger issues. In many cases, they also yield better performance because the automated mechanisms are better able to find opportunities for efficiency and parallel computation while eliminating some of the simple mistakes that lead to errors.

Some of this automation is wrapped around architectures and ideas that are emerging from the labs into general use. Programmers working on artificial intelligence (AI) used to write the code in their favorite language. Now some libraries, like TensorFlow, are stable enough to be widely deployed and their API acts almost like a language unto itself.

Programmers specialize in stringing together these API calls in much the same way they used to string together loops or functions. 

Some of the so-called languages on this list might not be considered to be official computer languages. Programmers often distinguish between a full computer language that lets them express any arbitrary algorithm—something often labeled Turing complete—and a lesser collection of characters that lets them spell out just a few parameters or some of the details for configuration.

The distinction can be philosophical, though, and one that may be important only for university discussions and barroom arguments. Because sometimes the only thing stopping you from going home is whether the right characters are in the right place. It doesn't matter whether your keystrokes are expressing some syntax that is worthy of being called a full language when you're pulling out your hair trying to get everything to do the right thing.

These 10 languages are changing how we tell computers what to do. While some of these languages are new, others are already very popular. Some aren't really languages at all, although we sometimes think of them that way.

It's all about doing more with less

The items on this list don't have much in common except, perhaps, the way that programmers are slowly finding ways to make each keystroke do a bit more work on average. They're boiling down the languages and making the resulting code more concise and powerful. In some cases, the languages are acting as the gateway to entirely new options such as AI or massively parallel algorithms.

It's not exactly full automation, but these languages are making it easier for programmers to do more in less time.

Keep learning

Read more articles about: App Dev & TestingApp Dev