Single Page Applications: What to Expect in 2022

If you are looking into Single Page Applications (SPAs), it’s likely because you are looking for faster-loading websites, and that makes a lot of sense. With SPAs, you should be able to experience a website page as you would a native app, discover faster transitions, and allow the page to be more interactive with itself without having to frequently refresh the page to load more data. 

In this blog post, we are going to take a look at some emerging trends around SPAs in 2022. If you are mostly unfamiliar with single-page applications, we’ll give you a quick overview of the pros and cons of this approach. If you have experience with SPAs, you can learn more about what to focus your attention on in the coming months.

What are Single Page Applications?

Single-page applications have been changing the way we surf the internet. With SPAs, the page gets almost everything it needs to work as expected in the first load. In comparison to old methods, this way of rendering the page, on the client-side, focuses on speed and consumes less resources. As developers, we don’t have to spend time building a complex layout, overwriting it, and refreshing the page often.

Pros of SPAs:

• SPAs provide a good experience for developers: Developers can focus on building specific components of the job; back-end devs can work separately on building the API and front-end devs can work on UI sections/components.
• SPAs work everywhere: SPAs are adaptive to a lot of platforms, mobile devices, and browsers. You just need JavaScript.
• Converting a SPA into a Progressive Web App (PWA) doesn’t require much effort: If you are thinking of using local cache (and why not let the app work offline?), you should consider the use of PWAs as a must.
• Not many server round trips. With SPAs, the dynamic changes in HTML sections are performed in the browser, so in terms of performance, this “independence” from the server equals speed.

Cons of SPAs:

• Possible lack of SEO optimization: Depending on some framework approaches, content may not be easily crawlable, so you really need to think up-front about the SEO strategy for the app or website that you need to build. Keep in mind that crawlers can easily understand HTML, but they have a harder time understanding JavaScript.
• Sharing: Depending on some factors, at the time of sharing any useful links from your SPA, the preview rendered by Facebook, Twitter, or LinkedIn may be exactly the same for any URL. This can be a pain point for some people and might require a workaround.
• Security aspects: By making use of XSS, a poor-intentioned dev can inject client-side scripts into the application. A strong control of the inputs in the client can secure improper access to confidential data.

Implementing Single Page Applications

If you are considering a SPA implementation, there are many tools and/or frameworks you can use depending on app requirements, documentation, community, team expertise or learning curves, reusable components, development time, and budget.

In essence, the principles are the same for basically all of them: use a well-designed code structure to render a single page that is able to interact with the user with a high performance. 

There are three choices for implementing a SPA:

• Server-Side Rendering (SSR): In the SSR, the server produces the application on the fly.

• Client-Side Rendering (CSR): In the CSR, the browser is the thing that leads everything and gets the basic data from the server, and the application generates the views and introduces it into the DOM.

• Static Site Generators (SSG): With SSG, the server returns a well-organized HTML with almost all the info. This approach is the fastest, but if you need to make a small change, the new page’s generation process will take time. 

Choosing an architecture depends on your requirements. The good thing is that all three of the previously mentioned ones are fast. 

SPA Frameworks:

You’ve likely heard of some SPA frameworks, such as React, Angular.js, and Vue.js. But there are others, like EmberJs and BackBoneJs, that are on the map, too.

Instead of ranking the various SPA frameworks (at this point, the web development community has provided enough perspective on that), we will look at the trends, popularity, and star ratings on the repos in an effort to provide helpful guidance on each.

Following Google Trends over the past three years, it seems that React js is leading the searches:

After a quick look at the Stackoverflow insights (or developer survey), it is easy to see that React, Angular, and Vue technologies are ranked at the top as the most commonly used web frameworks. That means that a lot of developers are working with and learning about them.

Looking deeper into the Stackoverflow insights (in this case, the most loved vs dreaded according to their stats), you can see there is more good feedback on React, Angular, and Vue on the balance.

For the last comparison, after checking the Github stars for each one, the following are the results. From this, we can conclude that Vue is experiencing a really rapid adoption.

What to expect for SPAs in the future

There are new SPA options continuing to emerge. One of them is Mint, which is not an entire library like others, rather a new language designed specifically for single-page app development. The Mint promise is zero runtime errors. If it compiles, you can be sure you will not find errors from undefined values, thanks to exhaustive type checking. Some more interesting features of Mint are the changes to the use of equality operator, the immutability of variables that allows less bugs, the concept of New Functional programming, using or not using all of the parameters in a function call, and other elements like styling and Implicit imports.

 

Another interesting option that is growing in popularity is Rust. It is not a new programming language but appears to be a competitive option to use and/or replace part of the JavaScript ecosystem. We mention this because it is possible to develop SPAs using Rust. If you have the time, start digging into this is a cool idea.

Here is a list of tools with similar SPA uses that are also growing in popularity due to their enticing characteristics and fast adoption rates:

• https://remix.run/
• https://astro.build/
• https://svelte.dev/ 
• https://turborepo.org/
• https://www.solidjs.com/

 

SPAs in Conclusion

Every web developer is familiar with the problems of page navigation inside a web app, high bandwidth, the time it takes to rebuild entire pages, unwanted caching, the use of back buttons and others, etc. These old practices often involve inefficient and repetitive development. SPAs are here to help solve these challenges, so we can presume that they are here to stay.

A majority of developers love SPAs, and the larger community provides all kinds of support and guidance with tutorials and documentation. At the end of the day, the many positive attributes of single-page applications make them worth giving a try. 

Regarding the previously mentioned cons of SPAs, such as challenges with SEO, following best practices like always using and updating a properly-formatted sitemap file, and doing an isomorphic use of Javascript like Next.js, Gatsby (based on React), and Nuxt.js (based on Vue) are great workarounds. These powerful frameworks allow us to deal with CSR and SSR at the same time.

SPAs are used across many different industries. The key to being successful with them is to be careful at the time of the app’s planning and try to shape a team with good general skills. 

Hopefully, this blog post gives you a helpful overview of single-page apps. Talk to you soon!