As we step into 2023, two emerging trends in the field of web development demand our attention: Serverless Edge Computing and a combination of WebAssembly and Service/ Web Workers.
The Intersection
At first glance, these two trends seem to exist in parallel universes. But on deeper examination, they intersect at the heart of what promises to be a hyperlocal future of the web.
Diving Deeper: Serverless Edge Computing
Deno, the secure runtime for JavaScript and TypeScript, proclaims that “The Future of the Web is on the Edge”.
In this era of edge computing and serverless functions, we’ve once again returned to allowing servers to carry out most of the work. This system involves delivering predominantly HTML and CSS.
Distinguishing this approach is the presence of globally-distributed ‘edge networks’ significantly reducing the latency when delivering server-rendered content to our web applications. Meanwhile, ‘serverless’ functions have drastically reduced the need for managing resources.
Previously, Amazon Web Services (AWS) reigned supreme in this realm. However, we now see an expansion in the list of vendors for app distribution, including CloudFlare, Vercel, Render, and Deno Deploy.
WebAssembly and Service Workers
WebAssembly, now in its sixth year, constitutes an exciting development. Native to browsers for approximately three years now, and with version 2.0 currently in draft, WebAssembly has revolutionized web development.
At its core, WebAssembly enables compiled binaries of non-JavaScript languages such as Rust to run in the browser at speeds rivaling native application performance. It’s somewhat like integrating a server into your browser, facilitating complex work such as 3D rendering much faster than possible with JavaScript.
When we integrate WebAssembly and service workers, we can develop powerful web applications that offload work from the server to the client by delivering an extensive set of JavaScript codes.
But doesn’t this contradict our first approach: server-first edge network applications?
The Best of Both Worlds
Edge networks paired with serverless compute providers are already offering capabilities to implement WebAssembly on their platforms. It facilitates truly write-once-run-everywhere code packages.
Simultaneously, service workers enable client applications to fetch and cache assets. Edge nodes, located in the vicinity, can significantly hasten the downloading of these assets.
Usually, a serverless function will process an initial app request in the normal app lifecycle, while subsequent requests run natively in the client. This gives developers incredible flexibility in optimizing where their application performs the bulk of its processing.
The Road Ahead
This new paradigm of server-first development coupled with the idea of universally runnable WebAssembly is still developing. The ability to intelligently manage server-client handoffs with service workers is still in its early stages, and it is interesting to observe how it will evolve.
As edge networks multiply and competition intensifies among providers, we’re eager to see what potential unfolds. Services that deploy your app across varied edge networks, ensuring near data-center communications for your users, might soon become commonplace.
The possibility of municipalities investing in this infrastructure opens up an intriguing prospect: instead of private corporations, local governments could host your app, with server compute functionality literally in your users’ backyards.
The combination of hyper-specialized edge networks and the client-side computing power of WebAssembly and service workers could possibly reduce latency and boost app performance significantly, resembling native offline desktop applications. This is the hyperlocal future of the web, and it’s just about to materialize.
Tags: #WebDevelopment, #ServerlessEdgeComputing, #WebAssembly, #ServiceWorkers