Articles on Web
Last updated: 2023/02/27
Top deep-dives on Web
What I wish I had known about single page applications
Not normally a fan of articles with titles that start off "What I wish I had known about...", but in this one, Michael Pratt actually does a good job. Michael talks about the anatomy of a SPA, SEO, sharing, and caching.
Why I Built My Own Shitty Static Site Generator
There isn't always a good reason for doing something. Sometimes, you do it just because you feel like it. That can lead to great, or terrible results, but either way you use usually learn something useful. In this article, Erik Winter discusses why he chose to very much reinvent the wheel from a web development perspective. Erik covers the limitations of available static site generators and the impact choosing an existing tool has on your creativity and design choices. It's a casual article, but I connected with it because I like to build things from scratch, sometimes even when it's not justifiable with anything other than I wanna know how it works :)
The baseline for web development in 2022
Alan Dávalos covers the current state of the web, from market share of different browsers and devices, to baseline performance and framework popularity.
Server-Sent Events: the alternative to WebSockets you should be using
Germano Gabbianelli describes some of the issues with web sockets and presents a solution in the form of server-sent events.
Progressive Rendering for Better Web App Performance
When creating websites or webapps, you conventionally had two major options for rendering; you could either do it client-side, or server-side. Well in this article, Nethmi Wijesinghe presents a third option (to be fair, it's more of an alternative of the second option), which involes progressively loading server-side rendered content. Faster rendering = more conversions, or just less frustration.
Solid.js feels like what I always wanted React to be
Nick Scialli compares solid.js and React, highlighting the positive aspects of the former web framework.
Casey Muratori ponders on why we can't use UDP instead of TCP in the browser.
What’s the best lossless image format? Comparing PNG, WebP, AVIF, and JPEG XL
Johannes Siipola compares file size and encoding time for different lossless image formats. Although the article is a year old, the formats are still relevant.
Chris Garrett takes us on a trip through time for web development, starting with the preframework period, where young JQueriesasauruses crawled the early web, to the modern day proliferation of full-stack frameworks like Reactor and Vueadactyle.
Behind the One-Way Mirror: A Deep Dive Into the Technology of Corporate Surveillance
An old piece, but still very relevant. Bennett Cyphers and Gennie Gebhart thoroughly outline in detail how companies track you across the web.
Jérôme Beau talks about the disadvantages of using a framework for web dev and why going vanilla might not be so bad.
What is Edge Compute? It’s kind of like knitting dog hats
Austin Gil explains the different methods for computation that are available in modern web development.
A blog that is a single executable binary
C and web aren't two tags you normally see together. Andrei Ciobanu presents a blog platform he wrote in C that compiles his blog to a single executable binary.
A look at search engines with their own indexes
Rohan Kumar does a wide-dive on search engines and divulges his findings.
For your next side project, make a browser extension
The last issue's business/tech article was pretty popular, so I thought I'd include this one too. Geoffrey Litt talks about why it's worth trying to make a browser extension and how to make a business around it.
- "making an extension is a fun and efficient way to create useful software"
- Covers how to perfect the extension to make it seem "native" to the platform
- Building an app for a specific platform comes with risks, including platform risks like if the website implements your extension's functionality as a feature
How to leverage HTTP conditional requests to build robust REST APIs
Ilija Eftimov discusses how organizations can use HTTP conditional requests to improve the performance and robustness of their APIs. Ilija provides a brief overview of the basics of conditional requests and then goes into detail about how eight different organizations use conditional requests for their HTTP APIs, as well as the advantages and tradeoffs of each approach.
- Conditional requests are a mechanism native to HTTP with headers that define a precondition the server evaluates before taking action
- Conditional requests have two prominent roles: they can serve as a way to tell the client to use a cached response and to prevent race conditions while mutating data via an API
- REST API requests are nothing more than HTTP requests with additional semantics
A layered approach to content blocking
Rohan Kumar explains how an update to the extension API in Chrome will affect content filtering (ad blockers).
How Mercado Libre optimized for Web Vitals (TBT/FID)
Alex Mackenzie discusses the new WebGPU API for accelerated graphics and compute.
- Compares CPU and GPU
- Alex uses a lot of fancy words I had to google, like "lionise" and "promulgate"
- Presents what trends and applications WebGPU may unlock and popularize
System Design: Domain Name System (DNS), Load Balancing & Clustering.
Nandan Kumar does a deep dive into the titular topics, including what, how, why, and examples.
- DNS is a decentralized naming system that translates human-understandable domain names to machine-understandable Internet Protocol addresses
- Load balancing lets us distribute incoming network traffic across multiple resources, ensuring high availability and reliability by sending requests only to resources that are available and running
- A computer cluster is a group of two or more computers, or nodes, that run in parallel to achieve a common goal
The struggle of using native emoji on the web
Nolan Lawson illuminates emoji support in browsers, how to detect if they're broken for someone, how to replace them if they are, and what an emoji actually is.
The GPU Banana Stand
GPU programming is notorious for not being very practical. This is even more-so the case when you're trying to use it on the web. In this article, Steven Wittens presents some of the functionality and features of his "declarative/reactive WebGPU library", Use.GPU.
Some key takeaways are:
- The React derived runtime, Live, is completely self-hosted and is fully rewindable and memoized
- Compute shaders are fully supported
- All of the elements are just components
- WebGPU has made things that were impractical with WebGL practical
- By sacrificing some performance, the implementation and use of the library has become far simpler
- The library has quality-of-life components out of the box, but you can still "crack them open and use the raw parts if they're not right for you"
- Copying how popular software in one domain (this case React) works to another domain can lead to intuitive and easily adopted interfaces
Reverse-Engineering YouTube: Revisited
Oleksii Holub does a deep-dive on the YouTube API.
- There is currently a lull in updates for the API
- Describes the meaning of different terms specific to the API
- Ultimately it's even easier than before to download videos from YouTube
Server-side vs Client-side Analytics
Dave Rupert explores some of the issues with two different approaches to analytics on the web and how one should approach interpreting the results.
UA gotta be kidding
Brian Kardell illuminates some of the history of the user agent string and how it impacts modern data privacy on the web.
MitM at the Edge: Abusing Cloudflare Workers
Christophe Tafani-Dereeper illuminates how Cloudflare Workers can be used for malicious purposes.
Request coalescing in async Rust
Amos dives very deeply into setting up a custom web server in Rust using the async runtime.
HTTP/3 Prioritization Demystified
Robin Marx does a deep-dive on HTTP resource prioritization.
- HTTP resource prioritization is a concept for HTTP/2 and HTTP/3 that allows for multiple requests to be sent at the same time on one connection
- The priority is determined by the browser and can be tweaked with the new attribute "Priority Hints"
- The importance of prioritization lies in its ability to improve performance by loading resources more efficiently
Devirtualizing Nike.com's Bot Protection (Part 1)
William dissects a script that is responsible for browser fingerprinting.
- Browser fingerprinting is the process of "collecting data about a user's browser, which is then used to create a unique fingerprint for differentiating between genuine users and bots"
- VMs are used to further obfuscate these scripts
- It's all done in the browser
Dialogs and shadow DOM: can we make it accessible?
Nolan Lawson gets into the "nitty-gritty details of accessibility and web standards".
X.520: What’s in a name? (2022)
Ryan Sleevi discusses the incompatibility between the RFC 2459, 3280, and RFC 5280 (often just referred to as “PKIX”) and the ITU.T X.509.
- ETSI, the European Telecommunications Standards Institute, submitted Liaison Statement 1773 to the IETF recently, which raised concerns that there are limits to how many characters certain Subject/Issuer fields can contain within RFC 2459, 3280, and RFC 5280
- The Directory was a competitor to other contemporaneous protocols such as HTTP (1990) and Gopher (1991), but more of a database-style protocol, focused on attributes and objects
- The web's certificate authority system is kind of dated
Performant A/B Testing with Cloudflare Workers
Cloudflare workers are pretty neat; I used them to get OAuth sign up for the newsletter on my site. Philip Walton's article demonstrates how one can use them to do A/B testing with your website, without sacrificing performance.