nickb.dev

follow: @[email protected]

Posts

Are SIMD gather instructions underrated?

The DuckDB and Arrow rabbit hole: data modeling adventures

A Bevy app entirely off the main thread

Wasm's curious word size and the SWAR advantage

Default musl allocator considered harmful (to performance)

The right tool for the job: positioned IO for Zip archives

Keeping up with the fronted Joneses: streaming server side rendering

Cloudflare's forbidden Steam

The hidden nuance of the JavaScript File API

SQL reduction: ask for forgiveness

Next.js on Cloudflare: a gem with rough edges

The accidental journey to TrueNAS Scale

Dot or Not? A type safety story about file extensions

Practical responsive image sprites for the web

Pitfalls of React Query

You might not need a React animation library: transitions

The composition king: compound components

The WebAssembly value proposition is write once, not performance

The dark side of inlining and monomorphization

Split Next.js across hosting providers and advocate for direct S3 uploads

MySQL text ID collation: tread carefully

Decapitation: a migration from antd to headless story

Advantages of opaque types over value objects

Too edgy, a serverless search

There and back again with zstd zips

New browser APIs unlock new possibilities

CycleList: a cyclical activity tracker

Designing Responsive React Components for 2023

Wasm compression benchmarks and the cost of missing compression APIs

Rethinking web workers and edge compute with Wasm

Cloudflare Tunnel saved my home server when my apartment got a new ISP

Avoiding allocations in Rust to shrink Wasm modules

Favoring SQL over Redis for an evergreen leaderboard

DEFLATE yourself for faster Rust ZIPs

Avoiding dynamic CSS-in-JS styles in React

The footgun with Docker Compose shared configurations

The subjective nature of JS libraries exposing an off the main thread API

Recommendations when publishing a Wasm library

Don't freak, but our Rust web server is now Node.js

Accessing public and private B2 S3 buckets in Rust

Authoring a SIMD enhanced Wasm library with Rust

Replacing an unavailable ZFS drive

A workaround for Rust's lack of structural subtyping

Reality check for Cloudflare Wasm Workers and Rust

Simulating the EU4 map in the browser with WebGL

Git Rebase to Squash Commits to Most Recent Message

Wasm and Native Node Module Performance Comparison

Stumbling with WebGL Image Processing

Cargo Workspace and the Feature Unification Pitfall

Leveraging Rust to Bundle Node Native Modules and Wasm into an Isomorphic NPM Package

Writing a Secure Systemd Service with Sandboxing and Dynamic Users

A Quick Tour of Trade-offs Embedding Data in Rust

Designing a Decaying Leaderboard with Redis

Results of Authoring a JS Library with Rust and Wasm

Migrating a 160k Word Jekyll Blog to Hugo

Backblaze B2 as a Cheaper Alternative to Github's Git LFS

My Bet on Rust has been Vindicated

Reasons to Migrate away from Gatsby

Opinionated Guide for Web Development with Rust Web Workers

Parsing Performance Improvement with Tapes and Spatial Locality

Monitoring Remote Sites with Traefik and Prometheus

Downsampling Timescale Data with Continuous Aggregations

SQLite: Dropping an index for a 300x speedup

Azure Pipelines for Rust Projects

Guidelines on Benchmarking and Rust

Quick investment advice for the smart and lazy

Leaning on Algo to route Docker traffic through Wireguard

Exploring TimescaleDB as a replacement for Graphite

Hashing strings bytewise in C#

IPv6 only networking not viable in 2018

Satisfying NAS share and backup solution

Migrating to Actix Web from Rocket for Stability

Viewing WireGuard Traffic with Tcpdump

Lessons learned: ZFS, databases, and backups

Routing Select Docker Containers through Wireguard VPN

Integrating Kotlin with a Dropwizard App

Dropwizard 1.3 Upcoming TLS Improvements

Fighting Instability and Rust

Replacing Elasticsearch with Rust and SQLite

Back to the Register: Distilling the Federal Register for All

WireGuard VPN Walkthrough

Robust systemd Script to Store Pi-hole Metrics in Graphite

Building a Home Server

Investigation into the Inefficiencies of Node.js Http Streams

Writing a high performance TLS terminating proxy in Rust

Creating a parallel AMP site with Jekyll

Introduction to Journald and Structured Logging

Migrating to the new NET SDK MSBuild Project Files

The Difficulty of Performance Evaluation of HikariCP in Dropwizard

First Impressions of the Google Pixel

The Last Hooray, Bye Windows Phone

The Cost of TLS in Java and Solutions

Exporting Open Hardware Data into Graphite

Monitoring Windows system metrics with Grafana

Exploring Data: Michigan Traffic Accidents

Another Year, Another Site Refresh

Waning F#

Dropwizard 1.1 and Let's Encrypt with no Downtime

Dropwizard Multipart Form Quickstart

Boxcars: an Example Rocket League Replay Parser Using Rust and Nom

Know Thy Threadpool: A Worked Example with Dropwizard

Dropwizard 1.0 TLS Checklist

Fun with Pfarah: a Paradox Clausewitz Parser

ISO 8601 and Nanosecond Precision Across Languages

Visualizing Ann Arbor Incidents

Introduction to IMAP

Initial Impressions of a Website with Modern Build Tools

A Java Result Algebraic Data Type Worth Using

Turning Dropwizard Performance up to Eleven

Federal Register Data Exploration with R

Modern Website over HTTP 2 and SSL with Nginx and Let's Encrypt

Trading Beauty for Performance: F# active patterns vs Nullable