Welcome back,

Last week I started a new project at work and it has been one of those wonderfully chaotic weeks where one interesting problem keeps leading to three more. I ended up doing a ton of research, and I will admit that I occasionally went a little off the rails into tangents that were not exactly relevant, but were definitely fun.

This issue is very much the result of that kind of week. There is a lot of variety in the selection, and it was genuinely hard to pull together a coherent top 7. Still, I think there is a lot of great stuff in here, and I hope it gives you plenty of ideas and inspiration.

On top of that, I am still spending a significant amount of time learning and building AI-powered web applications and agents. Since AWS is usually my main deployment target, that has also meant spending a lot of time with Amazon Bedrock. Recently I went deep into Structured Outputs, really into the nitty-gritty details, and I found it much more fascinating than I initially expected. So I decided to write an in-depth article with everything I learned: Understanding Amazon Bedrock Structured Outputs. We also recorded a new episode of AWS Bites entirely dedicated to Bedrock and why you might want to use it: 153. LLM Inference with Bedrock.

I hope you will enjoy the full selection and, as always, if anything resonates with you, reply to this email and let me know. I really do read every single one of your emails!

Keep learning, keep shipping!
— Luciano

"The most powerful tool we have as developers is automation"
- Scott Hanselman, Software Developer

An Interactive Intro to CRDTs — If you have ever used Figma, Notion, or Google Docs and wondered how multiple people can edit at the same time without everything falling into conflicting chaos, part of the answer is CRDTs. This is one of those topics that gets referenced a lot, but rarely explained well. I really enjoyed this article because it finally gave me a solid intuitive understanding of how some of these fantastic data structures work, and it turns out they are not that complicated after all. The interactive demos make learning genuinely fun, and much easier to follow. I hope you will enjoy this featured piece as much as I did! Read Article

Proxying fetch requests in server-side JavaScript — This is a very practical piece on something that does not sound glamorous, but absolutely matters in real systems: routing fetch() requests through a standard HTTP proxy. If you ever need outbound traffic control for logging, caching, policy enforcement, debugging, or IP masking, this will quickly become relevant. I liked that the article stays grounded and compares how different runtimes approach the problem, including Node.js, Deno, Bun, and Cloudflare Workers, with a look at the newer Node.js support for proxy-related environment variables. This is definitely one to bookmark for future-you. Read Article

Node.js: Evolving the Node.js Release Schedule — If you have been using Node.js for a while, you probably know the rule of thumb: even-numbered releases are the long-term stable ones, while odd-numbered releases have mostly been short-lived stepping stones toward the next LTS. That is now changing. Starting with 27.x, Node.js is moving from two major releases per year to one. This is a pretty meaningful ecosystem shift, especially if you maintain libraries, CI matrices, or internal platform docs. If your team already follows the LTS cadence, though, this should feel more like simplification than disruption. Versioning gets easier to reason about, odd-numbered releases stop being a strange special case, and the broader release story becomes much more predictable. Read Article

External import maps, today! — Import maps are designed exactly for this kind of problem: managing dependencies in browser apps without needing a full build pipeline. The catch is that, while import maps themselves are already here, one key piece, external import maps, is still not supported natively, so this article shows a very clever workaround you can use today. The trick is to inject an import map dynamically from a classic blocking script before modules load, which gets you much closer to centralized import map management right now. If the problem statement is not fully clear yet, there is also a helpful companion article that explains the broader context. I really like pieces like this because they show how the web platform is already more capable than we often assume. It is also a nice reminder that you can start adopting future-facing techniques today, while browsers catch up, and begin future-proofing your web apps right away. Read Article

Getting Started With The Popover API — And speaking of the web platform, I am always happy when the browser absorbs a whole category of JavaScript workarounds. This article makes a strong case that the Popover API is not just a nice convenience, but a real upgrade in how we build interactive UI. The examples focus mostly on tooltips, but the broader takeaway is that the browser can now handle more of the interaction model for us, including keyboard behavior, dismissal rules, and part of the accessibility wiring. Less code, fewer footguns, better defaults. Very hard to complain about that. And if you enjoy this kind of deep dive, there is also another excellent post that probably does an even better job of showing incremental examples of how to put the Popover API to work. Read Article

Design Systems Checklist — In my career I had the chance to work on a few modernization projects where building and rolling out a corporate design system was one of the key ingredients for success. Creating the system has its own challenges, of course, but in my experience adoption is usually the part that really makes or breaks the whole effort. That is why I liked this resource so much. It is refreshingly concrete and turns a broad, sometimes fuzzy topic into a practical checklist that covers everything from design language and foundations to core components and long-term maintenance. What makes it especially valuable is that you can use it at the beginning of a project like this to shape your strategy, but also later on as a sanity check for your implementation. A complete, clear, and well-executed design system gives you a much better chance of driving real adoption across teams. Read Article

Making keyboard navigation effortless — I admit I am not someone who uses the keyboard that much to navigate the web, and that is probably why, whenever I read about this topic, I feel like I need to pay extra attention to make up for my own bias. Keyboard navigation is such an important part of web accessibility, and we all need to make a more deliberate effort to ensure what we build is usable by everyone. This article is a good reminder of that. It even notes that, according to the Web Almanac, about 50% of websites do not use tabindex, one of the common techniques for enabling keyboard navigation on the web. What I liked here is that the piece frames keyboard support not as a compliance chore, but as a core part of making interfaces genuinely usable. If you build custom widgets, form-heavy flows, or admin UIs, this is well worth your attention. Read Article

📕 Book of the week!

The Art of Computer Programming, Vol. 1: Fundamental Algorithms, 3rd Edition, by Donald Knuth

This first volume in the series begins with basic programming concepts and techniques, then focuses more particularly on information structures-the representation of information inside a computer, the structural relationships between data elements and how to deal with them efficiently. Elementary applications are given to simulation, numerical methods, symbolic computing, software and system design. Dozens of simple and important algorithms and techniques have been added to those of the previous edition. The section on mathematical preliminaries has been extensively revised to match present trends in research.

Buy on Amazon.com - Buy on Amazon.co.uk

More quality content coming your way! ⭐

• MicroGPT explained interactively
• Seven years migrating to TypeScript at Patreon
• AI And The Ship of Theseus
• The Different Ways to Select HTML in CSS
• Responsive Type Doesn't Have to Be Complicated
• Locutus, TypeScript ports of standard library functions from 18 programming languages, with per-function npm imports so you only pull in what you need
• On Adding Homepage Delight
• AI Taxonomy, an operational framework for precision in AI discourse
• Typescale AI, a visual typography scale and design token generator for web UI
• A Complete Guide to Bookmarklets
• Distinguishing Components and Utilities in Tailwind
• Chip Away, a thoughtful essay on designing interfaces that age well by removing rough edges one small improvement at a time
• React is changing the game for streaming apps with the Activity component
• TinyBase, a reactive data store and sync engine with native CRDT support and multiple persistence options
• react-awesome-slider, a lightweight React slider and carousel component focused on smooth media and content transitions
• WarGames Terminal Fonts, faithful recreations of the terminal font from the 1983 film for use on modern computers
• How to supercharge your design system with slots
• Ply, build cross-platform applications for desktop, mobile, and the web using Rust
• Nobody ever got fired for using a struct
• Dinero.js, an immutable JavaScript and TypeScript library to create, calculate, and format money safely
• unbarrelify, a tool to remove barrel files from ESM JavaScript and TypeScript projects
• An Exploit in CSS?!
• The Odometer Effect (without JavaScript)

Show's over, folks! 🎭

Credits are rolling! If this issue sparked joy or ideas, don't be shy, reply and tell us all about it! ✨