Web Development in 2020 - a look forward...
Tags: webdev, javascript, design
Published: 2020-01-09 14:06:42

**This post was taken from [my blog](https://areknawo.com/), so be sure to check it out for more up-to-date content.**

As 2020 is still only getting started, I thought it's a good time to talk about some personal Web Development *predictions*!

First A quick disclaimer before we jump into the actual content. Obviously, I don't know what the actual future will look like, but I also don't have any full-blown analytic data to base my assumptions upon. Everything written here is just my perspective, my *personal thoughts* on where Web Development is going. All of this is based on my experience and observations. If you disagree with something written here - good! Feel free to share your opinion in the *comment section* if you want!

*TL; DR:*

-   JavaScript and top 3 UI frameworks are here to stay;
-   Svelte is on the rise;
-   Cloud computing, and server-side programming and JAMStack are growing;
-   Pre-processing and performance improvements are the future;
-   WASM is bringing a whole lot of computing power to the web;
-   Material Design, rounded corners, gradients and dark mode are the current design trends.

# JavaScript

Some love it, some hate it, but as the member of the first group, I'm happy to say that JavaScript is here to stay. Not only in a basic manner (that's obvious), but in its leading position as one of the most *popular*, and versatile programming languages. Its ubiquity throughout Web, desktop, mobile, server, and even Internet of Things (IoT), together with dominance in [open-source](https://areknawo.com/top-20-github-hosted-projects-of-2019/) is only going to increase.

## TypeScript

But JavaScript isn't alone in this pursuit. Aside from the HTML and CSS, there're tons of [JS-compilable](https://areknawo.com/top-10-js-compilables/) languages. Form all of them, [TypeScript](http://typescriptlang.org/) is the most notable one. It recently blew up in popularity, thanks to all of its *statically-typed* advantages. And while it's not going to become W3C standard anytime soon, its thanks to such inventions that JavaScript thrives. I use TypeScript in literally all of my projects and I expect a lot more people to do the same in 2020.

## Changes

For those with a different attitude to JS than mine - there's also something for you. While JS isn't going anywhere in the foreseeable future, who knows what the whole decade will bring us? For now, I can only say that there might be some slight changes coming to the language's main *focus point*. We'll talk about that later on.

# UI libraries/frameworks

So, I've got [my own open-source JavaScript framework](https://areknawo.com/im-back-and-theres-a-lot-to-discuss/) coming in early 2020 that will crush React, Vue, and Angular and become the new industry standard!

Alright, maybe I'm exaggerating a bit! In all seriousness though, the top trio isn't going anywhere. The sheer size of their respective *ecosystems* and the *communities* alone are just impossible to ignore. They aren't going to be beaten that simple. React is pretty much the jQuery of our time (in the positive, popularity terms), Vue is getting huge new features and improvements with the [v3](https://madewithvuejs.com/blog/vue-3-roundup), and Angular... is just Angular - you know what I mean.

## Svelte

But there's a new player in the field that I'll be unwise to leave without a mention. It's called [Svelte](https://svelte.dev/) and is currently gaining a lot of traction. It's even thought by many to compete with the "top guys" in 2020.

Personally, I think Svelte will have a hard time meeting such high expectations. Hopefully, I'm wrong, cause its approach to creating UIs is very innovative! I'm talking about *pre-processing* the code in an additional *compile step*, to provide smaller, and more performance-efficient client bundles. The rise of JS has led to some severe abuses of its capabilities. If Svelte takes off, we should see more development in the area of pre-processing, which will be good both for the developers and users alike

# Server-side and the cloud

With Svelte in mind, it's a pretty safe bet to say that more and more computing will be moved away from the client. A concept that is already well-known in the form of *the cloud*. We've got cloud computing (e.g. [AWS](https://aws.amazon.com/)), cloud gaming (e.g. [Stadia](https://stadia.dev/)), cloud storage (e.g *Google Drive*) and a whole lot of other services and [tools](https://areknawo.com/vs-code-goes-online/), that build upon this idea. And now, it's making its way to the Web Development!

## Cloud

We're already accustomed to using cloud services and third-party APIs to accelerate the development process and provide certain functionalities. By depending on multiple of such APIs from trusted providers, our software is not only more *secure* but potentially even more *performant* (when compared to doing everything client-side). Thus, I think the overall reliance on cloud services will continue to grow in the coming years.

## Static websites

But I'd also like to touch on something different than the cloud. The concept of pre-processing, and additional compilation step that tools like Svelte are so well-known for. There's a lot of untapped performance benefits to achieve before reaching the client. *SSR* and [JAMStack,](https://jamstack.org/) for example, have been quite popular for a few years now. They provide great client-side performance, SEO and a number of other benefits, without much effort. JavaScript is still used, just to a lesser degree.

## Pre-processing

It's all great, but static websites lack some functionalities that dynamic ones have, and SSR usually requires quite a powerful server to run properly. Adding up to that is the fact that client-side code is still necessary to do a lot of other things and can sometimes become a bottleneck. With that in mind, I think the pre-processing similar to what Svelte is doing but on a "code-wide" scale, will get more attention.

Maybe you've heard of Facebook's open-source project called [Prepack](https://prepack.io/) which is meant to *partially evaluate* JS code? In its final form it should be able to go through your code and pre-process parts of it, leaving you with highly-optimized results. Currently, the project is in its early stages and development has stagnated, but I think it illustrates the overall idea pretty well.

# Performance

Aside from pre-processing and server-side optimizations, there's also some room for improvement on the client-side itself. With its rapid evolvement, JS is now used for some pretty demanding tasks, that it wasn't originally designed for. Surely the language and its syntax are great (although sometimes cumbersome), but I'm want to talk more about the performance and *execution* side of things.

## V8

Google's [V8](http://v8.dev/) certainly leads the JavaScript engine market. Latest features, top-of-the-line performance, and all the good stuff. It was also the first to give us *JIT-compilation* which drastically improved the execution time of JS code. It's thanks to this advancement that JS is currently one of the *fastest scripting languages* on the market!

## WASM

With that said, there are limits to what JS can do. That's why [WebAssembly](https://webassembly.org/) (WASM) has been created. It's basically a highly-efficient format that's meant as a compilation target for languages like *Rust* and *C++*. Depending on the application, it can be [orders of magnitude faster](https://www.smashingmagazine.com/2019/04/webassembly-speed-web-app/) than JS, making it a perfect choice for portable, compute-heavy tasks.

It's important to know that WASM isn't meant to replace JS. Instead, it'll deal with all the heavy tasks and allow JS to focus solely on the UI. With its impressive performance, we'll finally be able to create heavy apps (most notably *games*) that will run everywhere and impress users with their responsiveness!

Since the *Minimal Viable Product* (MVP) introduction in 2017, WASM has been slowly but successfully acquiring new features. On December 5th, 2019 W3C has officially approved WASM as the [4th language](https://www.w3.org/2019/12/pressrelease-wasm-rec.html.en) to be used on the Web. But it's also capable of being used [outside the browser](https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/), as portable modules. With all that, and the support growing, it's easy to say that WASM will get even more traction going forward. And who knows - maybe in a few years, we'll be playing AAA games right in our browsers!

# Design

Lastly, I'd like to conclude these predictions of mine by covering some *design trends*. You should know that even though the code is very interesting and important, it's the design and UI that the user experiences the most.

## Material Design

I don't think there will be any drastic changes in design trends this year. And no - skeuomorphism isn't coming back. Like in the previous years, Google's [Material Design](https://material.io/) (MD) is going to lead the way. However, because of the need for *customizability*, things are going to look a little bit different.

Instead of strictly following guidelines laid down by Google, different brands are going to adopt certain design practices and use them to form their own *unique look* and stand out from the competition. Yet still, things like *rounded corners*, *gradients*, *vivid colors*, and *dark mode* are going to be a common sight. Also, simplicity, *User Experience* (UX) and mobile are going to be the primary focus yet again.

## Accessibility

Aside from the visual stuff, the importance of *accessibility* (a11y) is likely to grow. The Web is becoming increasingly more populated by different kinds of people and providing a good experience for all of them should be the main goal of all designers.

Especially more general-purpose websites like social media and news magazines should provide people with different disabilities ease-of-use. However, a11y goes far beyond that, improving the comfort of even everyday users through subtle details like responding to keyboard buttons, touch gestures and others. The more of such feature a website implements, the more likely it is to be enjoyed by the user.

# Your turn

So, these are my top Web Development predictions for 2020. Whether you agree with them or not, I'd love to see you constructive feedback and personal forecast in the *comment section* below!

If you like this post, consider *following me* on [Twitter](https://twitter.com/areknawo), [Facebook](https://www.facebook.com/areknawoblog) and checking out [my personal blog](https://areknawo.com). You can also check out my [YouTube channel](https://www.youtube.com/channel/UCUw6bg379ONlG1E_oxhwi-A/) to watch some JS-related videos and drop a like or a sub. As always, thank you so much for reading this piece and I wish you a happy day!