As we begin 2017, we see an exciting year ahead. Software enthusiasts should anticipate changes in software development languages, frameworks and tools, data interchange, infrastructure, and culture.

This is your chance to gaze into our crystal ball for a sneak peek at where PromptWorks sees technology headed in 2017 and beyond.

Software development language trends

A programmer typing at a keyboard

Elixir and Phoenix will mature and become more widely adopted

So far we’ve completed a handful of projects in Elixir, and we’re finding Elixir and Phoenix to be at least as productive as Ruby and Python web frameworks. While the ecosystem hasn’t yet fully matured, we believe that Elixir will surpass competitors soon enough. Ruby and Rails are still great tools and have maintained the productivity advantages over PHP or Java that caused us to adopt them a decade ago, but the future looks brighter for Elixir and Phoenix.

Erlang, and by extension Elixir, reigns supreme when it comes to developing concurrent systems, which means we can handle more requests on the same hardware and serve more satisfying responses without as much optimization. Even up against Node.js, where asynchronous programming is a mainstay, Elixir code comes out cleaner and easier to maintain. The ideas introduced by Phoenix aren’t new: the framework has taken the best concepts from Rails and other MVC frameworks to create a productive and maintainable API.

The quantity and quality of open-source Elixir libraries still leaves something to be desired, but with a rapidly growing community, we expect Elixir will become a top choice for startups. We’ve made a few contributions to help round out the ecosystem and we haven’t yet found any problem we can’t solve with existing tools or by contributing our own.

Swift turns 3, finds uses beyond Apple OSes

Swift was a huge step up from Objective-C and it has been adopted widely for iOS development so far. In June of 2017, Swift will turn 3 years old, which means more maturity and staying-power. React Native has largely eliminated our need for Swift as we develop mobile applications, but we still regard it as a solid language. Swift won first place for Most Loved Programming Language in the Stack Overflow Developer Survey 2015 and second place in 2016. We’re starting to see it cropping up in other places besides just iOS and macOS development. Companies have already put an app in the Android Play Store using Swift and are experimenting with it on .NET and Java platforms. We expect to see more platform diversification for Swift in 2017.

Type checking

We’ve always been partial to dynamically typed programming languages like Ruby, JavaScript, and Python because we found them more productive than type-safe languages like Java, C++, and C#, which require you to explicitly declare whether a variable is an integer, floating-point number, boolean, string, and so forth. Test Driven Development helped make type safety redundant a decade ago and our development velocity improved as a result.

Gradually, though, type checking is working its way back into the ecosystem: React encourages the use of PropTypes. Flow offers gradual typing, and TypeScript provides static typing in a superset language that compiles back to JavaScript. Elixir is dynamically typed but offers pattern matching, guards, and typespecs to prevent type errors and document aspects of code.

With type checking, errors are caught earlier on and the developer doesn’t have to explicitly check input values or rely on unit tests to ensure every type is handled properly. Dynamic typing accelerated our development with simpler and more flexible languages, but if we can have the flexibility and the safety, we’ll take both.

Compiled JavaScript

As JavaScript applications get bigger and more complex, the need for speed increases, especially on processor-constrained devices like mobile phones, watches, and IoT devices. Compiled JavaScript can run faster than “regular” handwritten JavaScript because the LLVM optimizer uses type information to perform many useful optimizations. Asm.js avoids potential slowdowns in JavaScript by sticking to highly-optimized assembly-like computations.

As we do more processor-intensive rendering and client-side applications get more complex, expect to see more compiled JavaScript running in your favorite web and mobile applications.

Frameworks and Tools

The Microsoft logo printed on a brick wall

Big Software will continue to open source their development tools

This past year we saw a continuation of solid contributions like React, React Native, Tensorflow, and Yarn from the likes of Facebook and Google. It used to be that open source lagged behind proprietary products in function and quality, but today, open source is on the cutting edge of innovation in areas such as cloud computing, big data, machine learning, and DevOps. Big companies are choosing to start new projects as open source rather than keeping their code proprietary. Facebook, Google, and even Microsoft (they’re 2016’s organization with the most open source contributors on GitHub!) have hopped on that train as well.

React and React Native will continue to mature and become ubiquitous among startups and innovative development shops

Though React.js and its ecosystem aren’t trivial to learn, more and more developers are finding its one-way data flow and deterministic UI properties liberating. Like most client-side JavaScript frameworks, there are myriad combinations of libraries: flux, redux, immutablejs, mobx, sagas…to name a few. Yet the applications made with React.js keep getting more and more sophisticated.

Even though learning React comes with its difficulties, as it continues to mature it will become the staple of cross-platform development. React Native is already on its way to overtaking Cordova as the top cross-platform mobile development framework.

Data interchange trends

An old door chained up with a lock

Alternate forms of authentication will take hold

We’ve been trying to kill off the password as the means of authentication for ages, but we just can’t seem to kick the habit. Two-factor authentication (2FA) has been around awhile to provide a backstop against humans’ nasty habit of making easy-to-crack passwords and then reusing them across sites, but typing numeric codes from a text message, email, or app is cumbersome and many people still don’t make use of 2FA.

In 2016, Google rolled out a different kind of 2FA that simplifies the process. It just uses a push notification to ask, “Are you trying to sign in?” With a simple “yes” or “no,” the user can verify the login attempt isn’t a hacker on the other side of the planet.

We’ve also seen a rise in the number of apps–including a few of our own this year–that avoid usernames and passwords entirely and send expiring login links through email. Yes, this makes email the single point of failure, but isn’t it already with password recovery?

So, entering a new year with Touch ID on Apple phones and laptops, 1Password integration in more apps than ever, more prevalent passwordless logins, and the recent disclosure of the biggest data breach in history with over a billion accounts compromised, 2017 might finally be the year passwords get canned.

Real-time client-server communication will become more commonplace

Web applications have updated their data in real time for a while now, but it was always difficult enough that it was used sparingly. Client-side javascript frameworks provided standardization and reduced costs to make web applications feel as responsive as their desktop counterparts, but that didn’t guarantee the data they displayed was “live.” In order to handle pushing updates down from the server, developers had to wrangle websockets, channels, and in some cases, separate servers.

Now that there are more standards for server-sent events and it’s more built-in to frameworks like Ruby on Rails (ActionCable) and Phoenix (Channels), it is becoming easier to implement real-time data. This lowers development costs and makes real-time data something more clients will expect.

At first, you probably won’t even notice the prevalence of real-time web applications because they look exactly like before. Only when data changes on the server before you’ve reloaded the page will you see data change or previous page elements be minimized as irrelevant.

Familiar apps like GitHub and Trello have been using real-time client-server communication for a while. When done right, you don’t even notice it, but it’s important for minimizing user frustration and increasing collaboration.


A time-lapse of highway lights at night

Serverless (FaaS) will become easier and more prevalent

We’ll see more tools and services devoted to making the Serverless model of development more accessible.

Serverless is poised to revolutionize the way we develop apps and services. With it, you can develop in smaller, reusable components. It offers increased simplicity and infinite scalability.

In theory, this should simplify development, but in its current manifestation, it actually makes development more complicated (and thus costly) because the tooling and infrastructure aren’t ready for prime time.

The death of BaaS

In early 2016, Facebook announced they were shutting down Parse, the most popular Backend-as-a-Service provider. A huge number of mobile apps used Parse, such as EventBrite, Vevo, and even the White House. But this isn’t the first BaaS provider to be deprecated; StackMob was popular before it was acquired by PayPal and shut down. Firebase is now the front-runner, but since being acquired by Google and folded into Google Cloud Services, it also faces an uncertain future.

In most cases, building a custom backend is going to be safer and cheaper in the long-run than locking your apps into a backend you don’t control. In the few cases where it isn’t, we think serverless platforms will fill the need previously met by BaaS providers.

Containerization continues to take hold

Deploying apps and services via containers has gotten easier and more prevalent in 2016, and we’re going to see this trend continue with new tools and services being released that make this deployment model easier and more attractive for more organizations.

Culture shifts

Pokemon Go being played on an Android phone

Development bootcamp market saturation

Development bootcamps sprung up in response to the high demand–and high salaries–for software developers, but the cracks are starting to show: many coding school graduates find themselves in debt and unprepared for tech jobs. Since bootcamp grads seem to be unqualified for all but entry-level positions, the market is saturated with them and the developer gap remains.

We still think coding bootcamps will continue popping up and young people and career-changers will continue to drop thousands of dollars on the prospect of a lucrative career, but it’s only a matter of time until some schools’ reputations catch up with them and give code schools a bad name, even though there are a number of good ones.

AI becomes more commonplace and accepted

From Amazon Echo to Siri to Facebook, AI is becoming more integrated into our daily activities. In fact, using AI is almost becoming second nature. Asking Siri for help, Amazon Echo solving murders… these trends will continue, and although there may be the occasional backlash, AI in our daily lives will be accepted widely.

Trust issues, news bots

The impact of fake news on the 2016 election and on policy choices in 2017 is going to make trust and the sourcing of information an issue that receives attention and funding. Without the vetting previously done by journalists who had the reputation of their paper or network at stake, artificial intelligence might be employed to check facts, verify sources, and compile information. The question is: who will control those bots and will people embrace them even if they are truthful and accurate?

We expect 2017 will bring an explosion of AI-backed browser extensions, news aggregators, and mobile apps that enrich and scrutinize the information that comes across our devices.

What do you think? Do you disagree or have other software predictions for 2017? Talk to us on Twitter @promptworks.