Intro to Qwik: A superfast JavaScript framework

Deal Score0
Deal Score0

Qwik is a daring rethink of how reactive UIs work. The core premise is that the framework is constructed from the bottom as much as ship HTML with minimal JavaScript—simply sufficient JavaScript to incrementally introduce interactivity as wanted. 

Qwik makes use of a fine-grained mannequin for isolating the segments of the app which are hydrated on an as-needed foundation. By ranging from first rules, Qwik permits for in any other case unattainable efficiency and represents an alternate path for the evolution of front-end JavaScript.

State of Qwik

Qwik continues to be in early releases, but it surely has come a great distance since we first got a look at it.  There’s now a full-featured instance at StackBlitz, a REPL playground, and a command line instrument. Qwik has additionally developed to assist a extra developer-friendly, React-like syntax. Below the hood continues to be a complicated, one-of-a-kind reactive engine that defines reactive boundaries alongside state, templates, and listeners. 


Qwik makes use of a mix of intelligent server-side and client-side rendering to keep away from the sort of double taxation that modern frameworks endure in performing the hydration work twice, as soon as on the server, and once more on the consumer.

As Qwik creator Misko Hevery writes:

The fundamental thought behind Qwik is that it’s resumable. It could possibly proceed the place the server left off. There’s however the tiniest quantity of code to execute on the consumer.

Or, put one other method: Let the server arrange an HTML web page as totally practical as doable, and permit the consumer to carry out the smallest quantity of labor doable to proceed, or resume, the method for the consumer.

The standard movement in reactive frameworks with SSR (server-side rendering) is to first generate a model of the app on the server, then ship it over to the consumer, which renders the scaffolded app. At that time, the client-side app takes over, principally having to bootstrap the identical app once more with a view to wire collectively a functioning consumer. 

This course of is named hydration. There are a number of intelligent methods to attempt to make hydration extra environment friendly, however Qwik abandons these for a brand new course of referred to as resumability.

Resumability means the consumer can decide up the place the server left off, with out having to rebuild the app on the consumer. 

Time to interactive

The metric that Qwik strives to reinforce is time to interactive (TTI). This refers back to the period of time that elapses between when the consumer makes a request to an internet web page and when the web page turns into aware of the consumer’s interplay.

Whereas time to load (TTL) tracks how lengthy it takes for the consumer to complete receiving all required information (and due to this fact is a metric decided largely by file sizes and community pace), TTI takes under consideration a outstanding truth of recent JS frameworks: As soon as the info is downloaded, the consumer should then unpack and execute the JavaScript code required to make the web page interactive.

There’s quite a lot of work that goes right into a reactive engine. The engine should unravel/parse all that markup (like JSX) shot by with variables and expressions that modify what’s displayed based mostly on altering state, and the way it behaves based mostly on the code.

On the different finish of the spectrum is a straight HTML web page. As soon as the browser has a maintain of it, the web page is able to rock. That is why Google’s PageSpeed Insights offers a web page like a 32 out of 100 rating, whereas uncooked HTML scores 100.

Closures and listeners

The technical hurdle to quick TTI is described by Hevery as “dying by closure.” In brief, the truth that each closure should preserve the enclosing universe of data means the runtime app is a layer cake of eagerly loaded code.

The answer employed by Qwik is to make use of a world occasion listener that interacts with serialized listeners. In different phrases, a common occasion listener is used to orchestrate listeners which are realized on demand, as a substitute of listeners being downloaded and wrapped in closures (no matter whether or not they may ever really execute).

Qwik goals to ship reactivity in-line with the HTML, making all of it serializable. Solely a small executable is required to then manifest the reactivity at runtime, based mostly on the data encapsulated within the markup.

Code splitting, finely tuned

One other method to take a look at that is that Qwik is performing fine-tuned code splitting. It masses the interactive code as required, when the consumer calls for it. Bundlers are then in a position to package deal these chunks into bigger bits if it is smart.

Qwik is constructed from the bottom up with three separate capabilities for creating state, template, and listeners. This enables the framework to load solely what’s required for the duty at hand. You may study extra about this chunking side here.

The three boundaries of state, template, and listener have been at one time immediately coded by builders. Because of a brand new Optimizer tool that converts React-like syntax into these boundaries behind the scenes, you get a reasonably acquainted DX. And the Optimizer does the work of turning the precise code right into a set of tiny stubs that may resume the app in small chunks as essential.

With the optimizer, templates and listeners are denoted with a greenback signal, whereas state is dealt with by the useStore hook. You’ll see this syntax in a second.

The ultimate output of Qwik code seems to be in contrast to that of different frameworks, however utilizing Qwik with the Optimizer brings it into parity with different frameworks. Qwik additionally has launched QwikCity, a set of higher-order options like routing that make it simpler to construct full-scale apps.

Arms-on with Qwik

Now that you’ve got an understanding of the ideas behind Qwik, let’s get a really feel for coding with it. Itemizing 1 reveals a easy part written in Qwik. (This instance is from the Qwik FAQ.)

Itemizing 1. Easy Qwik part

import { part$ } from '';
export const App = part$(() => {
  return <p onClick$={() => console.log('whats up')}>Hi there Qwik</p>;

Itemizing 1 reveals {that a} part in Qwik is outlined as an nameless operate, handed into the part$ operate from the Qwik library. Any time you see a greenback signal $ in Qwik, it’s letting the Optimizer realize it must do some work. The greenback signed parts of the app are the place Qwik will instrument its fine-grained lazy loading boundaries. 

The onClick$ in Itemizing 1 is one other instance of Qwik’s particular syntax. Qwik will use some trickery to load solely the JavaScript essential to assist the performance when it’s really required.

The code in Itemizing 1 will probably be damaged up by the Optimizer into a number of segments, as proven in Itemizing 2.

Itemizing 2. Qwik part after compilation

// The app.js file itself
import { componentQrl, qrl } from "";
const App = /*#__PURE__*/
componentQrl(qrl(()=>import('./app_component_akbu84a8zes.js'), "App_component_AkbU84a8zes"));
export { App };

// app_component_akbu84a8zes.js
import { jsx as _jsx } from "";
import { qrl } from "";
export const App_component_AkbU84a8zes = ()=>{
    return /*#__PURE__*/ _jsx("p", {
        onClick$: qrl(()=>import("./app_component_p_onclick_01pegc10cpw"), "App_component_p_onClick_01pEgC10cpw"),
        kids: "Hi there Qwik"

// app_component_p_onclick_01pegc10cpw.js
export const App_component_p_onClick_01pEgC10cpw = ()=>console.log('whats up');

You may see in Itemizing 2 that as a substitute of together with the precise part performance, Qwik features a reference, utilizing the componentQrl() operate from the library. This operate takes a qrl() operate that makes use of an nameless operate to import the generated part file. This affiliation between elements is all managed beneath the covers by the Optimizer. The developer doesn’t want to consider it immediately.

QRL stands for Qwik URL, which is the way in which Qwik references one thing that will probably be lazy loaded. Mainly, any time the framework must defer loading one thing, it should insert a QRL, wrapped by a QRL-specific shopper (like a part, state, or template operate).

For instance, the componentQRL can load on the proper second within the code discovered within the baby part whereas the mother or father can shortly show its format. Equally with the onClick handler: It is ready to be evaluated when the clicking happens.

Qwik CLI

The command line instrument is obtainable from npm and has the essential options you’ll count on together with creation, dev mode, and manufacturing construct. The Qwik CLI makes use of Vite because the construct instrument. You can begin a brand new app with npm create qwik@newest, which can launch an interactive immediate.

Should you create a easy app and run the manufacturing construct, you’ll get a dist listing the place you’ll be able to see all the separate lazy-loadable chunks of the app we described earlier.

A Qwik adjustment

An attention-grabbing place to get a way of Qwik syntax is the Qwik Cheat Sheet, which provides side-by-side comparisons of Qwik and React code. You’ll see that total it’s not so laborious a transition. Some areas are fairly related, and a few require largely a shift in pondering. The larger takeaway is that reactive system in Qwik is radically totally different from React-like frameworks, regardless of the similarity of syntax achieved with the Optimizer. 

Qwik’s progressive method to code splitting and lazy loading provides a brand new method ahead for front-end JavaScript. Will probably be attention-grabbing to see the place issues go from right here. 

Copyright © 2022 IDG Communications, Inc.

We will be happy to hear your thoughts

Leave a reply
Enable registration in settings - general