I’m a strong believer in the idea that the software development environment is evolving at such a fast pace that it’s far more practical to learn the fundamentals instead of the next group of cutting edge technologies.

However, beginners will often ask about the future of web development. And it makes sense. With programming, as with any topic, it’s fun to talk about the next big thing. It might not be the most productive conversation in the world, but at times, it can’t hurt to look ahead and make bold predictions for the future. So that’s what we’re going to do here.

It’s never been a more exciting time to be a developer.  As a self sufficient developer, who is capable of learning new technologies as they evolve, there is a limitless amount of new, remarkable technologies that are coming out on a regular basis.

In 1969, the Apollo Guidance Computer could process 41.6 instructions/second. An iPhone 6 processes about 3.36 billion instructions/second.  This means that the technology in your pocket has the computing power to guide 120 million Apollo rockets to the moon at the same time in 1969.

It would be an understatement to say that technology is evolving rapidly. It’s far crazier that. New technologies are emerging that have the potential to revolutionize how we code.

In this post, we’ll talk about some of these new cutting edge technologies. Keep in mind that there are very few open positions for developers working with these technologies. That’s because they’re so new and so popular with senior developers, who want to live on the cutting edge. As a junior dev, it’s much safer to learn more established technologies because there are more jobs to land and more resources to learn them from. And should always make sure that you master the fundamentals of programming before diving in. But it can be fun to look ahead and explore the cutting edge. In fact, these technologies can clue us into the future of programming.

2017

Babel & ES6

When developers began to say things to me like: “I really love JavaScript”, I was confused.

But recently, JavaScript ecosystem has seen a lot of interesting changes. Senior web developers know why this is such a big deal. But before you truly can appreciate the future, you need to understand the past.

So let’s rewind a little bit.

1995: JavaScript was designed and shipped (in 10 days) in 1995.  Developers then used the technology (back then sometimes called DHTML) to craft dynamic websites on places like Geocites and angelfire.com.

via gizmodo

JavaScript was used pretty exclusively by Script Kiddies and went relatively unnoticed at the time, while Java and PHP were taking off. Serious developers didn’t take the language seriously, and honestly, it was pretty unfortunate. JavaScript incorporated a lot of really great ideas, along with some really poor ones.

2005:  In 2005, developers at Google uncovered a cool web browser trick that they leveraged to build Gmail. Web Browsers supported a thing called “Asynchronous JavaScript and XML request,” which web browser manufacturers used to deal with product updates. At the time, web developers weren’t expected to use it.

Google used this technology in a new way, which helped make the GMail web application feel fundamentally different than all other web applications on the Internet. Developers started teaching each other how to use this quirk and pull it into their web applications. Much like a teenage celebrity, JavaScript went from an obscure, impractical programming language to an essential part of a web developer’s toolbelt.

Since most serious web developers weren’t using JavaScript prior to 2005, there was a serious lack of browser consistency and support. It was very difficult to get JavaScript code to work in multiple web browsers. Many smart developers identified the problem, and a series of different solutions were released: jQuery, MooTools, ProtoType, YUI.  

For the next few years, developers used these frameworks. Ruby on Rails used ProtoType initially, but in 2011 it was switched over to jQuery, because most Ruby on Rails developers were using it anyway.  jQuery basically won the battle, and today of all the websites that have JavaScript on them around 96% use jQuery.

Since JavaScript was becoming more relevant, Google began to optimize how JavaScript was running inside their Chrome web browser. They eventually got their JavaScript engine to be pretty fast. In 2009, this implementation was extracted from the web browser. This made it possible to run JavaScript outside of web browsers, in places like embedded devices, web servers with no user interface, and tons of other places too.

Fast forward to 2016: JavaScript is a really odd programming language that combines the sublime with the ridiculous. It has some really good characteristics, as well as a number of really bad ideas that many (employed) JavaScript developers don’t fully understand.

So, with the pervasiveness of JavaScript now dominating the lives of a ton of web developers, the future of JavaScript is quite bright. The committee of standards for JavaScript, Ecma International, spent a lot of time debating changes to the JavaScript language. This “next generation” of JavaScript is called ECMAScript 6, or ES6.

ES6 is a superset of JavaScript, which means old JavaScript code will execute exactly the same in ES6 as it does in regular JavaScript. But ES6 is new, which means that some web browsers don’t support the language.  The Babel Project converts (aka transpiles or rewrites) ES6 code into regular JavaScript code that any older JavaScript engine can execute.

It’s pretty clear that ES6 is the future of the Internet, and it supports a lot of features that make it a really enjoyable programming language to use. It includes a lot of forward-thinking ideas, in addition to concepts that are easy to understand from a traditional object oriented programming background.

Additionally, things like arrow functions and the spread operator change JavaScript from being a language where you can quickly hack together programs to a language that allows developers to feel confident engineering quality programs.

ES6 is clearly the future of web development. And while the cutting edge has some risks associated with it, its future in 2017 and beyond looks very bright.

ES6 is clearly the future of JavaScript. So while learning this is certainly cutting edge, it’s also a pretty safe bet.

ES6’s Success Will Also Change Other Technologies’ Usage Rate

If ES6 becomes as pervasive as it could growth of languages like Microsoft’s TypeScript and CoffeeScript could dwindle.  

TypeScript’s future is tied tightly to how Angular 2 is received and it’s a little too early to tell how it will be adopted.

2018

ReactJS is a technology that everyone is talking about these days.

original via codepen.io

Personally, I learned React because of the fancy buzzwords I encountered in presentations like Virtual DOM,  and the ability to build isomorphic apps (really crazy buzzwords I barely understood, but sounded cool). I like how React deals with the state through something called a Flux, which developers can switch out to use in different implementations.

React and Flux can lock you down and prevent you from doing certain things. But since you need to work within the confines of React and Flux, it actually makes your applications easy to reason about (once you get a handle on how it works, which can take a while).

The current flux implementation that I think is most interesting is Redux. Although, if you really think about it, the implementation that will be most widespread in 2018 probably doesn’t exist yet.

Other tools that React developers are using are exciting too. Technologies like Webpack optimize page loads for an enjoyable user experience. AirBnB’s enzyme technology makes TDD possible (and even enjoyable) in React.

In 2016, learning React is possible but incredibly frustrating. The ecosystem is still learning the right way to do things, and it’s evolving very quickly. But some would say that it might be evolving too quickly at this point in time.

It’s possible that a different framework could prevail

In 2016, the other web frameworks are reinventing themselves. Angular is coming out with Angular 2. Angular 2 is far more than an upgrade to Angular. It’s a complete re-write, and essentially an entirely new framework.  Ember 2 is also making a lot of changes.

Both Angular 2 and Ember 2 are taking cues from React.  

Web Developers are slowly starting to converge onto the idea of components, or small reusable widgets of web applications that are easy to build out.  In the next couple years, developers will experiment with a few different ways to accomplish this componentization, and even if nobody uses React in 2018, the discussions that it catalyzed will have already made a long-term impact.

2019

WebSockets – WebSockets isn’t a new concept.  It’s been around for a while, and services like Firebase and Pusher make it easier than ever to integrate with WebSockets.  

What are WebSockets?

Web Browsers make it easy to trigger custom code when users perform certain actions on the page. For example, you can trigger your custom code for when someone clicks on an item, or when a user starts dragging an HTML element.

But  traditional web browsers don’t do other things well, such as handle situations in which the triggered event happens someplace else.

WebSockets allow very cool real-time updates to the content of the page.  A cool example of WebSockets in action takes place within your Twitter stream. As soon as a new tweet is available in the stream, it prompts you to load the new tweets, then loads them seamlessly once you press the button.

WebSockets are definitely going to be more pervasive, and will go from only exceptionally responsive web applications to the norm. It’s probably the reason why DHH (Ruby on Rails’ creator) is betting on it so heavily with ActionCable. If you’re curious, you can see DHH’s announcement of ActionCable in the RailsConf 2015 keynote, which is one of the core features of Rails’ next generation (Rails 5).

2020

Elixir & Erlang are really exciting technologies. I’ve been bullish on the Elixir programming language, since it takes the scalability of the Erlang virtual machine and readability of the ruby language. The language’s creator, Jose Valim, has a proven track record of building open source that is used.

In 2016, jobs in Elixir are scarce. Senior devs eager to get on the ground floor of Elixir compete against each other for a small number of positions. And because it’s so far from being ready for the mainstream, today’s Elixir developers need to build the infrastructure, packages, libraries, and open source that future developers will take for granted. This is much like today’s ruby developers, who tend to take for granted the wealth of amazing open source projects that make their lives easier than their predecessors’.

I’m only getting more and more bullish on the programming language since I wrote this article.

Why I’m Betting On Elixir

It’s possible that I’m completely wrong.

But I’m expecting a functional programming language that supports real concurrency at scale to be the future. Be that Elixir, Erlang, Golang, Clojure or even a language that doesn’t exist yet. The not-too-distant-future will only see a rise in pure immutable functional programming languages (it’s worth noting that JavaScript is a mutable programming language, meaning it cannot scale to the level of an immutable language).

There are some really exciting changes coming in the future, but it’s important to stay focused on programming in 2016.

Rather than try to jump ahead of the curve and work with a more cutting edge programming language or paradigm, focus your energy on what matters most if you’re trying to break into the industry.

First, become a Self Sufficient Developer, who can learn new things as they arise.  Technology will constantly evolve, but the higher level skill of mastering the art of how to learn new technologies will prepare you for that.  Learning the tools that are currently being used will always be easier to do than learning the cool new thing.

Second, there are some principles in programming that don’t change ever. Learn these timeless programming ideas.

Third, while you’re at it, work on a project you’re genuinely passionate about.

If you follow that pattern, it won’t matter what cool new technology comes around. You’ll be prepared even if the market moves in a drastically different direction. Nobody has all the answers, and predictions in the market are exactly that predictions (or someone’s guesses).  So when learning to code, focus on learning what really matters.

For all we know, the future hip new technology that everyone will bet on is some crazy programming concept, like coding virtual reality experiences with the Oculus Rift. You should understand that as a developer, there are really cool things coming in the next few years. But don’t let that overwhelm you. Instead, let it inspire you to keep learning, keep building, and keep getting better.