2016’s top programming trends

by admin December 26, 2016 at 9:20 pm

Last January I wrote a TechCrunch post predicting the major programming trends of 2016.

But in the software development world, things can change very quickly. It can be difficult to see the high-level trends clearly through all the chatter about shiny new development languages, frameworks and tools.

So, as we near the end of 2016, how accurate were my predictions?

Growth of the latest version of JavaScript

JavaScript/ECMAScript version 6 (commonly known as ECMAScript 2015 or ES6) launched in June of 2015, and I predicted that 2016 would see widespread adoption of its new features as web developers adjusted to the new version of this web standard. I was mostly correct. All the major browsers and Node.js (an open-source JavaScript runtime) are more than 90 percent ES6-compliant. Nowadays, we see significantly more ES6 syntax in production and not just internal utilities and smaller low-stakes systems, but the primary customer-facing systems, as well. Companies not dependent on legacy clients, like Airbnb and Google, are enforcing ES6 syntax in their internal style guides.

However, ES6 has not been universally adopted. Some developers need to support the old version of JavaScript for legacy reasons. Developers who want to use ES6 notation but still need to reach customers using legacy browsers can use tools such as transpilers or polyfills to convert modern ES6 code to the older syntax. Also, some ES6 features have not been fully implemented in every JavaScript environment, such as proper tail-recursion (Safari 10 and iOS 10 are happy exceptions). This table is a great resource to see if your target platform is ES6-compliant. The old version of JavaScript isn’t going to disappear overnight, but we saw significant growth in ES6 usage over 2016, and I expect most redeveloped sites in the new year will use it as well. I’d say this prediction was pretty good!

Backend as a service

Backend as a service, or BaaS, increased in 2016, as predicted. BaaS is the practice of using third-party services to perform certain repetitive tasks for a project — tasks like cloud storage or push notification. By using these services, developers can focus on their specialty while these services do what they do best. Backend API services are thriving because frontend frameworks are changing to more easily interact with these services. Developers are also increasingly using a technique called composition, where an overall system is composed of several smaller applications. In such a system, these small applications are easily provided by third-party services.

I’m intrigued to see how software norms will progress in the coming year.

Note: In my last post I mentioned a popular BaaS named Parse. Shortly after the article ran, Facebook (its owner) announced that Parse would soon be shut down. Those using it will need to create their own Parse servers and migrate before January 28, 2017.

Easy image management and deployment

Services like Docker and Packer became a mainstay of many development teams in 2016, as predicted. These services allow engineers to quickly generate and replicate machine images called containers that bundle a piece of software with runtime, system tools and libraries, etc., guaranteeing that it has everything it needs to run in any environment. Developers can rapidly prototype a project on a lightweight virtual environment with pre-built version control, then easily deploy the new version on multiple servers. Server provisioning by hand is inherently tricky and time-consuming, so it’s no surprise that automating this process has caught on quickly.

Related tools that grew in popularity last year include Vagrant (for easily setting up development environments), and Puppet, Chef and Ansible (for configuration management). Working with container-based systems has become an integral part of the standard developer’s toolkit. I see no reason for this to slow down.

Increased reliance on functional programming languages

Functional programming languages like Haskell, Clojure and Scala grew steadily in popularity during 2016. Usage of these server-side languages is driven by explosive growth in the number of smartphones and connected devices in use, and by our increased expectations of a great experience on those devices. As our computers, tablets, smartphones and IoT gadgets become more powerful, servers become the bottlenecks to performance. Increasing a server’s ability to perform concurrent tasks makes it more responsive when interacting with a large number of connected devices. The functional programming model is (mostly) stateless, meaning that sections of software can more easily and efficiently be run in parallel across different CPU cores or machines, without needing complex synchronization. This gives the functional paradigm an inherent edge over the object-oriented approach when doing concurrent processing such as web requests.

Shift toward material design and commonality of patterns

Things were interesting in 2016 on the visual design front. Not surprisingly, Google incorporated an increasing number of material design elements across its entire portfolio — systems (ChromeOS, Android), applications (Chrome, Drive, Google Play Music), websites (YouTube, AdSense) and even web search. We see material design aspects in Android apps from Slack, Twitter, Spotify, Airbnb and Wikipedia, and in websites from Asana, Geekbench and others. That said, we didn’t see adoption in other platforms (iOS, Tizen, Windows, MacOS — only a little with Ubuntu). Developers in these other places pushed forward with styles specific to those platforms, to varying extent.

I give myself only a few points of partial credit on that particular prediction from earlier this year. If I’m allowed to recast my design prediction for 2017, then I’ll move away from traditional design paradigms altogether — toward non-visual interfaces (Amazon Alexa, Siri, Cortana, Google Home) or extra-visual interfaces (augmented reality, virtual reality).


2016 brought many exciting developments in software and 2017 promises to be even better as containers and functional programming languages grow in adoption and JavaScript moves to become even more central parts of standard development practice. I’m intrigued to see how software norms will progress in the coming year and eager to share my thoughts with my fellow developers!

Featured Image: Bernhard Lang/The Image Bank/Getty Images

Source link

more news from the blog

Add Comment