Everything

🎅🏻 December 2025

• The Chrome team is showing off all the new CSS features of 2025 in their CSS Wrapped.

• Parse, don’t validate.

• From that same article, the concept of Shotgun parsing:

Shotgun parsing is a programming antipattern whereby parsing and input-validating code is mixed with and spread across processing code. […] Shotgun parsing necessarily deprives the program of the ability to reject invalid input instead of processing it.

• Starting with macOS Tahoe, you can protect SSH keys by storing them in your Mac’s Secure Enclave.

• Learn how to use modern CSS color features for advanced use cases like generating color schemes in part 2 of the Pragmatic Guide to Modern CSS Colors.

• New to the Baseline: the CookieStore API, a simpler way of reading and setting cookies.

• Explore large HTML documents on the web, and find out how to analyze big network payloads, identify performance bottlenecks, and optimize performance of large pages.

• Did you know that you can get most of TypeScript by using JSDoc comments in plain old JavaScript files? Learn more about the nuances of JavaScript typing using JSDoc, and check out Svelte for a case study of why you might want this.

• Woke up to your web service unexpectedly mining Bitcoin? Perhaps you’re affected by the 10/10 vulnerability in React Server Components. If you’re curious about the details, check out the explainer of this “juxtaposition of a glaring omission of a safety check, combined with a stunningly brilliant mechanism to exploit it.”

• On a similar but less serious note, Ordering Pizza with Code is a fun watch covering reverse engineering, AI phone calls, and MCP servers—and a good reminder to secure your APIs on the server-side because clients can’t be trusted.

• What actually makes you senior: reducing ambiguity.

• Don’t design or develop needy programs 🙇‍♂️

Notable releases:

• Try out the preview of TypeScript 7, the native rewrite of the TypeScript compiler, in your editor and projects.

• Oxfmt, a Prettier-compatible formatter by the Vite team, with its first alpha release.

• Oxlint, now supporting type-aware linting in alpha—allowing you to “catch bugs by utilizing TypeScript’s type system.”

• Devstral 2, the latest agentic, open source coding model by Mistral—to my knowledge the only European competitor in the LLM AI space 🥹🇪🇺 accompanied by their own CLI tool.

• Safari 26.2, packed with support for recent web standards such as invoker commands, field sizing, sibling count, the scrollend event, and the Navigation API—all of which are now closer to being universally supported.

• Chrome 144 Beta, adding support for the long-awaited Temporal API 🎉

🚴‍♂️ November 2025

• Pikaday, once a JavaScript date picker component, has been relaunched as “a friendly guide to front-end date pickers”—a great collection of UI patterns and approaches to tackle this notoriously complicated component with relatively simple building blocks.

• CJ follows up on “AI coding sucks”. He shares his thoughts after not using AI for 30 days, what he learned about coding and craft, and how he’s going to integrate AI into his workflow going forward.

• CSS Subgrid is both powerful for layout and at times mystifying. Josh has written an approachable guide with many interactive examples to help you make sense of it.

• Importing JSON is now Baseline Newly Available. Jake explains why you might still want to fetch it instead. Read to learn about caching, memory leaks, and how browsers handle modules.

• URLs are not just technical descriptors, but also UI elements and application state. Here are some considerations to help you design great URLs. (Did you know that our designers in the Portal team are involved in specifying URLs?)

• “The bad news is that your software is rotting. The good news is that there are many simple but powerful things we can do to slow the process to a crawl.”

• Some of my recent tasks made me realize how tricky ARIA landmarks are. Here’s an example: Header and footer elements change their roles when they’re inside of sectioning content 😬

• Use error chaining with the Error.cause property in JavaScript to get more useful stack traces and richer error messages.

• Revert changes made by commit to file without undoing the entire commit: git restore --source [commit]^ [path/to/file]

• It’s rude to show AI output to people

• How to tolerate annoying things

Notable releases:

• Vitest 4.0, featuring stable browser mode and visual regression testing. Learn more about browser mode in this talk from ViteConf.

• Storybook 10, reducing installation size by another 29%, and shipping improved mocking and testing.

• Node 24.11, marking the transition to LTS. This version will receive updates through to April 2028.

• Claude Opus 4.5, the first AI model in a while that feels significantly more useful and capable than the rest.

• Biome 2.3, with support for Vue, Svelte, Astro, and Tailwind.

• GitHub Universe, announcing—unsurprisingly—lots of AI stuff, but also GitHub Code Quality, a competitor to SonarCloud.

• Angular 21, dropping the dreaded zone.js in favor of signals, and shipping Angular Aria, an experimental set of “headless components with accessibility as a priority”.

🎃 October 2025

• Something that’s been on my mind recently is the idea that there are no shortcuts if you want to make progress as an engineer—or at anything in life, really—in the long term. You can vibe code or copy from Stack Overflow if you want, and it might make you productive for a while. But at the end of the day, there is no substitute for putting in the work: reading the docs, asking questions, being curious, and digging until you really understand it. It’s not always fun or exciting, but it works. I like this analogy to magic tricks:

The only “trick” is that this preparation seems so boring, so impossibly tedious, that when we see the effect we can’t imagine that anyone would do something so tedious just for this simple effect. […] I often have people newer to the tech industry ask me for secrets to success. There aren’t many, really, but this secret—being willing to do something so terrifically tedious that it appears to be magic—works in tech too.

• Use the HTML output tag to represent “the result of a calculation performed by the application, or the result of a user action,” and get assistive technology support for free 🎉

• CSS colors have come a long way! Do you know what oklch, relative color, and light-dark do? Or that there’s a better alternative to rgba? Catch up on these topics and many others with the Pragmatic Guide to Modern CSS Colors.

• In TypeScript, the Extract<Type, Union> type is a utility that pulls out from a union type only those members that are assignable to another specified type. Useful for narrowing types! It’s similar to Pick<Type, Keys>, except that it works on the shape of a member instead of its property name.

• ESLint is preparing for another major release, expected to land in early 2026. v10 will drop support for Node 20 and the legacy .eslintrc config format. If you’re still using them, consider upgrading soon.

• AI Coding Sucks is your permission to ignore the AI hype for a while. Conveniently, VS Code now allows you to disable AI-related functionality with a single setting.

• Vite+, the Vite team’s vision of a Go-style all-in-one toolchain for building, testing, linting, and formatting JavaScript projects, is available in early access. It will be a commercial product, albeit “source-available” and with a “generous free tier.” It remains to be seen what that means for licensing and using it in our projects 🤔

• A first look at Remix v3, the successor to… Remix, which is now React Router 🤷‍♂️. There are some interesting approaches here, as well as some I find baffling—such as getting rid of reactivity and relying on a manual call to this.update() instead. Watch the full demo at Remix Jam for more details.

• Overtype, a lightweight Markdown editor component. Had to include it because I 100% subscribe to their guiding principle: “Built with the radical idea that sometimes dumb ideas work.” 💯

• If you automate the setup of macOS, you’ll appreciate this thorough guide for changing macOS user preferences via the command line.

Notable releases:

• React 19.2, bringing new components and hooks for easier pre-rendering and more ergonomic handling of event listeners in useEffect. Here’s a very brief introduction to the changes (“for haters”), and here’s a longer and more in-depth discussion featuring one of the React maintainers.

• React Compiler 1.0, promising to optimize your code for you and largely removing the need for manual useMemos and useCallbacks.

• Node 25.0.0, enabling WebStorage APIs by default and adding --allow-net to the permissions model.

• Firefox 144, shipping View Transitions, meaning they’re available in all browsers. They also published a beginner-friendly guide to get you started.

• GitHub Copilot CLI, joining similar terminal-based AI agents.

• Vite: The Documentary 🍿

💨 September 2025

In light of the recent supply-chain attacks in the NPM and Node world (this one and that one), we’re starting with some food for thought about protecting ourselves from malicious dependencies. Obsidian’s philosophy of Less is safer is the best collection of measures to mitigate the risk of successful supply-chain attacks I’ve seen so far. In short:

• Avoid dependencies if possible
• Re-implement or vendor small to medium dependencies (if licensing allows)
• Update large dependencies only periodically after careful manual review
• Block postinstall scripts
• Pin dependencies to patch versions
• Install strictly what’s in the lockfile (npm ci)
• Delay updates, as malicious packages are usually detected within hours.

This sounds reasonable to me. Yet it’s also quite different from our current practice of mostly immediate, mostly automated updates. Interested in hearing your thoughts 🧠

It can also be tricky to avoid dependencies. In Norms, for example, we have very few client-side dependencies. But our toolchain for linting, formatting, and testing is pretty complex. I don’t see how we can reduce that by much without compromising code quality and consistency. This is one of the reasons I’m excited about Vite+, the Vite team’s attempt at replacing the zoo of linters, formatters, test runners, etc. with a unified toolchain. We’ll learn more at this year’s ViteConf!

• Are package managers evil? An interesting argument against automating dependency management in the first place. I tend to agree. In fact I have started vendoring stuff manually for small, personal projects. But as mentioned above, I don’t have good ideas for making this practical for bigger projects that involve many people.

• A good way of reducing dependencies is using features that the platform already offers. Did you know the browser has an internationalization API? Among other things, you can use it for formatting dates, relative time, and numbers. Similarly, the Temporal API already works in Firefox and can be polyfilled in other browsers, removing the need to use dayjs or similar libraries. The browser also has APIs for client-side form validation that can get you pretty far for many basic use cases.

• In my recent post about Tailwind I argued that CSS is much more dynamic than it used to be. If you had no idea what I was talking about, here are some good examples: subgrid & container queries change how we can create layouts, and a new approach to container and wrapper classes.
  

• What if AI doesn’t get much better than this?

• The Progressive Complexity Manifesto lays out a useful mental model for thinking about server-side rendering and client-side interactivity beyond the static vs. single-page app binary.

• tldr is a project to make man pages more approachable by giving you the most important ways of running commands in an easy to read format. You can use their client to run it in your terminal or try it on the web.

• The new Apple OSes have been released and with them the (controversial) liquid glass design. Be that as it may, people have attempted to recreate it on the web. Always love to see that type of experimentation! Wouldn’t be required though if we had access to Apple’s private CSS property that enables the effect.

• New Apple OSes also come with a new major version of Safari. Recently they’ve been packed with features, and this year is no different. Among others, anchor positioning, scroll-driven animations, and SVG favicons are now supported in Safari, which should get them closer to Baseline availability.

• Java 25 has been released with some nice quality of life features such as more flexible constructors, top-level main methods, and a new way to import things.

⛵️ August 2025

• The results of the State of CSS 2025 survey are out. The usual caveats about diversity of respondents etc. apply. Still a good read to find out how people are writing CSS nowadays, and which new features and trends to keep an eye on. The main takeaway:

It’s clear that CSS is no longer “just” a styling language. It has made a fundamental shift in direction, taking on a larger role when it comes to layouts, motion, compatibility, and of course, accessibility. This shift helps redefine CSS’s identity not as a legacy styling language, but as a modern, expressive toolset that is finally getting the recognition it deserves.

• For a while, I have dreaded debugging Java with VS Code because I assumed it would be very complicated to set up. Turns out it’s really quite simple, and even works for more involved projects with Gradle and Spring Boot (like Normen). My mission to replace IntelliJ with VS Code is now complete 🎉 (everything else is still pretty much the same as I reported last time).

• SmolCSS, a collection of “minimal snippets for modern CSS layouts and components”.

• A while ago, we learned that TypeScript is being rewritten in Go, promising much better performance. Now the roadmap is becoming more concrete: TypeScript v6 is going to be a transition release, introducing a few deprecations and smaller changes in behavior. v7 will be the rewritten version.

• “How I build software quickly”: spoiler—it only involves a small amount of AI, and lots of setting expectations, iterating, and negotiating requirements.

• The latest beta of Vitest adds support for visual regression testing via the toMatchScreenshot assertion.

• You can use Git Worktrees to check out more than one branch at a time. Think of it like cloning the repository multiple times, except that everything will be shared, so it’s faster and consumes less disk space. VS Code recently has added support for Worktrees, too.

• The Zed team is hosting Agentic Engineering, a series of events on making software with AI. While I’m still struggling to find a good workflow for myself personally, their principles sound reasonable to me, and the conversations are interesting.

• Type stripping in Node is now enabled by default from version 22.18.0 onwards. That means we can now run TypeScript directly without any additional configuration! Two caveats: TSX, as well as TypeScript in dependencies, are not supported.

• GitHub’s CEO has resigned. As a result, GitHub, which is owned by Microsoft but has so far operated as an independent organization, is now part of the Core AI team at Microsoft. Will be interesting to see how that’s going to shape GitHub going forward. Interesting discussion on Hacker News, too.

🌞 July 2025

• I’ve heard many good things about JSNation 2025. Recordings of their talks are now available online. My recommendations:

  • Frontend’s lost decade and the performance inequality gap by Alex Russel: a look at the impact of nowadays’ development practices on users, and how to build performant and resilient websites.
  • Vite and the Future of JavaScript Tooling by Evan You: a first look at Vite+, the Vite team’s attempt at building a Go-style all-in-one toolchain for JavaScript, including building, testing, linting, and formatting. Very excited about this!
  • The New Defaults of the Modern Web by Jeremias Menichelli: reviewing defaults and best practices when starting new web projects today.

• Besides the talk he gave at JSNation, Alex Russel also attended React Summit, and reflects about the differences on his blog:

Near as I can tell, the schedule of React Summit mirrors the content of other recent and pending React conferences in that these are not engineering conferences; they are marketing events. […] Conferences crystallise consensus about which problems matter, and React Summit succeeded in projecting a clear perspective—namely that it’s time to party like it’s 2013.

• Vapor Mode, a Svelte-like compiler for Vue components that promises dramatically improved performance, has been merged into Vue core and should land as a preview with the next release.

• Nuxt is joining Vercel. Part of me is slightly nervous about Vercel “owning” so many frameworks (Next, Nuxt, Svelte). But for the Nuxt team it’s a good chance to secure funding, Nuxt UI will be available for free, and Svelte seems to be doing just fine. So I’m cautiously optimistic 🤞

• The CookieStore API, a more modern and ergonomic API for handling cookies, is now available in all browsers.

• JavaScript now natively supports importing JSON as modules. If you’re wondering about the funky syntax, those are called import attributes (and there are more to come).

• CSS is getting an if() function. While I can see how this might be useful, I’m not sold on the syntax. It looks kinda messy, especially if you have more than one rule in a class using it. Early days for now, but this will be coming to all browsers eventually.

• Experimenting with no-build Web Applications as a reminder that the plethora of tools we use in web development are there to solve specific issues, and not actually required. Always a good idea to be conscious about which dependencies we bring into our projects and why.

• Syntax discussing the different browsers and rendering engines that we have in 2025.

• Need a quick favicon?

• HTTP Cats 😻

Notable releases:

• Nuxt 4.0, Vue’s meta-framework, with various stability- and quality-of-life-related updates. Appreciate their approach to releases: “In general, we aim for a hype-free approach to releases.”

• Prettier 3.6, coming with a new, experimental CLI that promises to be much faster.

• Oxlint 1.0, a fast and easy to use linter from the Vite team. Keeping a close eye on this one because it seems to be the best candidate for replacing ESLint eventually 👀

• Vite 7.0, again with performance and stability improvements, as well as changing the default browser target to Baseline Widely Available. Is browserslist still a thing at this point?

• Git 2.50—can’t say I really understand all of the updates here, but merging now uses a different algorithm that is a lot faster, so I’ll take it.

• Deno 2.4, bringing back bundling for frontend and backend code.

• Edit, “a simple text editor for simple needs”, e.g. when you need to edit stuff in the terminal but can’t be bothered with Vim.

🏝️ June 2025

• My AI skeptic friends are all nuts: As an AI-skeptic myself, this post gave me some food for thought. I played around with agent mode and Claude 4 in Zed the other day, and that much I can say already: it’s absolutely a different Hausnummer than Copilot clumsily autocompleting my code a few months ago.

• During WWDC, Apple announced a bunch of features coming to Safari 19 26. My personal favorites: anchor positioning, scroll-driven animations, and the URLPattern API. You can find the full list on the WebKit blog.

• VS Code now shows the baseline support status of CSS features. It is also getting an official PostgreSQL extension for building and exploring databases that integrates with Copilot.

• In the latest episode of React: Tag und Nacht, Remix, the popular React-framework that has recently been merged into React Router, “woke up” to be an entirely different framework based on a fork of Preact. The community is… not excited (Reddit, HN). My personal take: their stated principles sound promising, and I appreciate the experimentation. But I don’t trust the authors to keep this stable for long enough that it would be a good foundation for any project that intends to be around for a while. Thoughts?

• Last month I mentioned that Firefox has shipped the new Temporal API. If you haven’t heard about it before, here’s a good overview of what it does.

• Ever wondered why some types of collections support forEach but not other array methods such as map? That’s because they implement the iterator protocol, which so far hasn’t supported anything else. Fortunately, that has now changed: Iterator helpers have become Baseline Newly Available

• gum is a neat little tool if you write shell scripts but also want ✨fancy✨

• Invoker commands are a declarative way for showing popups, dialogs, and more. You can also register your own commands! This should make handling many common interactions in web UIs simpler. Chrome-only for now, but all other major browsers are actively working on implementing the spec.

• Inner peace 😌

Notable releases:

• Storybook 9.0, with huge improvements in bundle size and installed dependencies, along with better testing tools. They offer a migration tool that worked flawlessly for RIS UI. Here’s an interview with one of the engineers if you want to hear more.

• Angular 20 continues to modernize and improve the framework with signals, reworking their rendering model, improved template syntax, and more. I haven’t worked with Angular in years, but it looks like they’re busy fixing all the things I didn’t like about it back then. Definitely keeping an eye on it!

• You can now try Rolldown Vite, the next generation of Vite with a completely rewritten bundler.

• es-toolkit, a popular alternative to lodash, is now 100% lodash compatible.

• JSPM 4.0, a different take on package management for the frontend that builds on web standards. I haven’t tried it yet, but I’m intrigued.

🌳 May 2025

• I recently set up a new computer and was reminded how great dotfiles are. Feel free to share yours 😊 One thing I already learned from @Christian is that you can configure many macOS settings from the terminal!

• Shellcheck is a linter for shell scripts that helps you write more robust scripts and avoid common mistakes.

• New JavaScript APIs that might make your life easier:

  • RegExp.escape: escapes potential regex syntax characters in a string
  • Error.isError: checks if something is an error without weird edge cases
  • Array.with: copies an array and replaces an item at an index in one go (handy for immutable state updates)
  • Promise.withResolvers: more convenient and modern syntax for creating promises

• Do we still need CSS pre- and post-processors? I don’t think so. I would go as far as saying that I would at least consider not using Tailwind either when starting a new project. Plain CSS, light component-level encapsulation (like Vue’s scoping), and some conventions like CUBE seems more appealing to me than dependencies and breaking changes at this point.

• React Server Confusion formulates some fair criticism of React server components. Fun fact: the first and only time I touched them was my coding assignment for DS. But from my limited experience, this rings true:

The issue is the tradeoffs involved in making it work. It leaks into, or even demands control over layers that are previously not in scope for client-side frameworks. This creates heavy complexity […] React team made a bet that they can work with Next team to polish the DX to the extent that the benefit would essentially be free […]. IMO, that bet has failed.

• “I think the ergonomics of generators is growing on me”—same here, though I rarely use them. This is a good read if you’re curious about iterators and generators.

• After @Dennis recommendation last month, I’ve started using Zed and enjoy it! It’s fast, looks great, and easy to get used to when coming from VS Code. It finds a good balance between supporting AI features but not shoving them in your face. I particularly like the Vim mode, which has many Vim features but aligns better with my expectations for a modern text editor.

• Some people are saying Deno is in decline. Deno, naturally, disagrees. The discussion around it is instructive, because it highlights Deno’s capabilities and community expectations vs. the company’s goals. Personally, I’ve switched back to Node.js + NPM, which have improved a lot thanks to competition from other runtimes.

• Check if a number is even with the power of ✨AI✨

🐰 April 2025

Starting with insights from the State of Vue 2025 report: beyond the usual popularity surveys (Vue continues to thrive) the report includes case studies, core team interviews, and some stats I hadn’t seen before:

• Most Vue developers have 4+ years of experience with the framework, and nearly all would choose it again for future projects—says something about the quality to have such a loyal community ✨
• Single page applications remain the dominant architecture in the Vue ecosystem, despite recent industry shifts away from SPAs. The Vue team is aware of that and say they have no intentions to become opinionated about servers or otherwise changing their scope.
• No plans for a V4 or breaking changes. Instead, the Vue team is focusing on performance improvements and stability through internal refactoring, as well as Vapor Mode.

Other things that caught my attention:

• Experimenting with visual effects in CSS: I love the animated gradient in the footer of the Rocycle website, so I “view source”-ed a bit to learn how it’s implemented. Turns out it’s quite simple: It combines a canvas, two colorful circles and some clever math for a very nice visual effect. I re-created it using CSS, which was a great opportunity to play with some modern CSS features such as @property, sin(), and container queries, in addition to web components and Alpine.js. It only takes 1/4th of the code of the original canvas-based implementation—a great reminder of how powerful CSS has become. You can find the result on GitHub if you’re curious. Please be gentle with the demo, I did not try very hard to make it robust 😬

• Looks like Chrome won’t be removing 3rd party cookies after all.

• Some food for thought: The skill of the future is not ‘AI’, but ‘Focus’ (interesting discussion on HN, too)

• TAC (tags, attributes, classes), a CSS methodology that relies on custom tags and attributes for almost all the styling. I like the idea because it looks clean and more component-y.

• Continuing with cool CSS-based visuals, over-engineering frosted glass is one of my favorite UI styles, and these CSS-only blurred image placeholders blow my mind 🤯

• A negative animation delay will start the animation at the point as if that time has already passed, e.g. an animation of 2s with a delay of -1s starts the animation at 50%. Useful if you have multiple of the same animation on one page and don’t want them all to be in sync.

• The Node.js util promisify turns functions that take callbacks into nice modern promises.

• Eyecons is an icon pack for VS Code that automatically adapts to your color scheme.

• Kill the newsletter, a free service that converts email newsletters into RSS feeds.

• Firefox is the first browser to ship the new Temporal API (a.k.a Date but good). Still a long way to go before this will be usable, but great to see some progress.

🪻 March 2025

• Interop 2025 is the yearly initiative by the major browser vendors to make various new or existing features of the web platform work consistently everywhere. Among other things, this year we’re getting anchor positioning and view transitions 🎉

• Did you know you can reorder commits during interactive rebase by simply reordering the lines in the editor?

• The customizable select is stable in Chrome! No timeline on implementation in Firefox or WebKit yet, but since it degrades gracefully, we should be able to cautiously use it already today.

• Design mode: setting document.designMode = "on" via the console will make any page editable. Useful for quickly testing text manipulations, removing stuff and other small edits.

• Here’s a little cheatsheet for formatting dates with vanilla JavaScript.

• Node.js has added utilities for coloring console logs. Another instance of a thing people commonly installed libraries for being moved to the platform. Did you know you can style console logs in the browser using CSS, too?

• Tailwind Play: there is a fully functioning Tailwind distribution that can be included in a script tag without any build steps. Probably not what you’d want in a production app, but might be useful for prototypes or small projects.

• ESLint is iterating their new config format, including adding a defineConfig helper to get better TypeScript support. Confusingly they’re also re-introducing extends, supposedly one of the worst sources of complexity and a major reason for developing the new format in the first place. Another round on the frontend treadmill I guess. As with anything ESLint does, it made me wonder if Biome or Oxlint have become viable alternatives in the meantime. They don’t seem to be there just yet, but progress has been made.

• Corepack will be removed from Node.js: if you know what Corepack is, this is good to know. If the word Corepack doesn’t mean anything to you, there’s no reason to find out anymore 😄

• Next.js has been getting some bad press lately, including reports on horrible performance outside of Vercel and other vendor lock-in, along with a really bad security flaw that they apparently also handled poorly. Luckily for us we don’t use Next.js anyawy (as far as I’m aware 🤔). So we can add this to the list of reasons to keep it that way.

• A talk about software quality and simplicity (or lack thereof) with lots of fascinating examples about technology knowledge that has been lost over time: Preventing the Collapse of Civilization

• I was looking for a new system to organize my notes and came across Johnny Decimal, which looked interesting and indeed quite organized. I ended up in the other extreme, dumping everything into One Big Text File instead. Let me know if personal knowledge management and productivity are interesting to you—would love to chat! C&C maybe? ☕️

🤧 February 2025

Since I wasn’t in the mood to read a lot of newsletters I wanted to share something else I’ve been tinkering with: finding a good setup for programming Java that doesn’t suck rely on IntelliJ 😇

As we touched on this topic at the Delivery Offsite last year I thought this might be interesting to some of you. If it’s not relevant for you, you might still find some of the tools I mention valuable for other things.

Enjoy! And feel free to leave feedback if you found this helpful. 😊

First, if you’re happy with IntelliJ, great! This might not be for you, and I’m not trying to convince you otherwise. But I prefer to work in a specific way and am apparently too set in my ways to change:

• I prefer lightweight, responsive tools and can’t stand loading spinners or laggy UIs
• I favor small, focused tools over the kitchensink
• I like being “close to the metal” and understanding what’s happening under the hood
• I want sensible defaults with minimal or no configuration
• I prefer dumb and simple for the most part: console.log > debuggers, string find + replace > refactoring

For frontend development, this means using VS Code for editing and a terminal with various CLIs for everything else (running tests, version control, …). This approach is common in the frontend world. However, in the Java ecosystem, IntelliJ seems the default choice. Other options are less obvious. After some experimentation though, here’s my setup:

• Editing & Autocompletions: VS Code with two extensions: Language Support for Java by Red Hat and Spring Boot Tools. These provide autocompletions, inline error messages, auto imports, and decent refactoring out of the box, without bloating VS Code with tons of extensions like some of the Java extension packs.

• Keeping dependencies up to date: ./gradlew build --refresh-dependencies

• Watch Mode Development: Such a normal thing in the frontend world, but surprisingly tricky in Java:

  • ./gradlew build --continuous -x <loooooong list of tasks to exclude>: Recompiles on changes (exclude tests and other checks for speed)
  • ./gradlew bootRun --continuous: Restarts the app when build succeeds
  • Combined, these approximate something like vite dev, but slower 🤷‍♂️

• Test Watch Mode:

  • ./gradlew test --continuous (no build needed!)
  • --tests "*.MyPackage": Runs only specified package tests
  • -i: Provides verbose output with stack traces
  • HTML reports are written to build/reports/tests/. Combine with npx servor --reload for readable, auto-refreshing test output in the browser ✨

• Helpful Tools:

  • Ghostty: My preferred terminal
  • Just: Simplifies long commands or combines frequently used command sequences. As you saw, there are quite a few of these in this approach!
  • Servor: Minimalist static file server
  • Lazygit: For when you need to do more complicated stuff than push, pull, commit -am
  • tmux: For running multiple commands in split view (like continuous build + boot)

• Debugging: Don’t know yet… still reluctantly reaching for IntelliJ when needed (only if I can’t get there with tests and console logs though)

• Database Access: Previously I used IntelliJ’s database tools. I know DBeaver, it’s ugly though 😭 Open to recommendations!

☃️ January 2025

Since it’s still the beginning of the year—and I’m a New Year’s resolutions person—I wanted to start with a reflection. Over the past few years, and especially in 2024, the web platform has evolved dramatically. CSS, in particular, feels almost unrecognizable compared to not so long ago. Features that once required tons of code or additional build tools are now built right into the platform, often as simple one-liners: dialogs, popovers, previously impossible transitions, CSS nesting, and so much more.

To me, this is the perfect time to strip away some of the many layers of abstraction we’ve accumulated—complex build setups, frameworks, and libraries—and get closer to the metal of the web platform again. I want to write simpler, more resilient code and focus on knowledge that remains broadly applicable. That includes a renewed interest in Svelte, which, despite being a compiled framework, aligns closely with the spirit of the web. I also want to dive deeper into new APIs like Temporal and techniques like view transitions.

Because as someone said at a conference I attended last year:

Frameworks come and go, but the web platform and its APIs are knowledge you can rely on for decades.

• Speaking of new APIs and techniques, the results of the State of JS 2024 survey have been published—as always a great source for finding out about the latest trends and developments in the JavaScript world.

• Another interesting source is the JavaScript Rising Stars report, which watches and categorizes new libraries, frameworks, and apps based on their GitHub stars.

• Evan You, creator of Vue, shared an update on Vue 3.6 at Vue.js Nation 2025 (his talk starts at 17 minutes). Vue 3.6 will feature another massive performance boost in the reactivity APIs thanks to alien signals 👽. It will also include a first version of the much-anticipated Vapor Mode, which works similar to Svelte or Solid.js and should also result in vastly better performance and smaller bundle size.

• Pinia, Vue’s recommended state management solution, has now has a data fetching plugin for making working with APIs easier.

• Tailwind v4 has been released with many interesting, but unfortunately also breaking changes: new configuration formats, faster compiler, no more PostCSS requirement,… I tried to upgrade one of our projects the other day, but looks like it’s going to require some work…

• Ghostty is the new trendy terminal emulator. I have been using it as my main terminal for a few weeks now and love how snappy it is, and how well it integrates with whatever platform you’re using.

• Svelte 5 has been released (a while ago actually, but I didn’t pay attention). It’s a complete rewrite and fixed many of the things that I thought were weird in previous versions. Hopefully I’ll find the time to give it a try soon! If you’re feeling the same, here is a tutorial.

• We usually think of web components as a replacement for React/Vue/… components. But here’s a clever pattern for using them for progressive enhancement instead: HTML Web Components

• Old but gold: What is the event loop and how does it work?

• JavaScript classes can have a static initialization block that is run as soon as the class is parsed. Not sure what to use that for but somehow it feels like it could be handy.

🎄 December 2024

• CSS Wrapped 2024! A great rundown of the latest changes in CSS, including things that are widely available, things that will soon be available, and some things that are currently Chrome-only experiments.

• Animating the (previously) impossible with CSS: You can use @starting-style in combination with transition: allow-discrete to animate to and from display: none or dialog[open]. Soon it will also be possible to animate height: auto!

• CSS now has built-in virtualization, a performance optimization for long lists or complex pages that used to be very annoying to implement: content-visibility

• Soon finally possible: Complex customization of the browser-native select component. Currently in Chrome Canary, but expected to be widely supported some time in 2025. Check out this demo to get an idea what to expect. Love to see it! The part about backwards compatibility blew my mind. All the details and a request for feedback are here.

• With all those new features, how do you know what you can already use? Besides the always great Can I use?, there’s now the Web Platform Status Dashboard that specifically tracks new additions to the platform and alignment efforts between browsers. Best served 🍳 with polyfills, @supports and strategies like graceful degradation (remember the select?) so you can start using most of these already today.

• Here’s a little trick that allows you to make pretty callout boxes with Markdown on GitHub.

• I haven’t watched it yet but here is a talk about hexagonal architecture apparently by the guy who invented it? Sounds interesting!

• Speaking of GitHub: not new but also not very well known—press . in any repository on GitHub or change the domain of the URL from .com to .dev to open the repository in an in-browser VS Code. Great for browsing codebases! If you use settings sync, you can even use your extensions, theme, and other settings. Try it!

• Some inspiration for “how to go beyond surface level skills and really dive deep on a topic”.

• The Hype Around Signals: Good explanation of the idea behind “fine-grained reactivity”, i.e. the UI rendering pattern that almost all frameworks—except React—are using.

• Excited about Tailwind 4 already? It’s now in beta. Here’s a deep dive with one of the authors about the new features. (Fair warning: not very structured so you might find yourself skipping quite a bit, but I still found it interesting.)

• Most of the 2024 web almanac is now available: “a comprehensive report on the state of the web, backed by real data and trusted web experts. The 2024 edition is comprised of 21 chapters spanning aspects of page content, user experience, publishing, and distribution.”

• Vite 6 has been released and it’s at the same time rather boring and a huge update. Boring because almost nothing changes for end users (yay!). Huge because it has tons of internal refactoring and improvements, most notably the experimental environment API. This will enable frameworks that build on top of Vite (such as Nuxt, Remix, and SvelteKit) to provide better DX.

• I refer to this all the time, so too this month. Exports in JavaScript are tricky: export default thing is different to export { thing as default }

🍄‍🟫 November 2024

• State of CSS & HTML 2024: The results of the yearly CSS and HTML surveys are out! These are always great to learn about new APIs and tools that are picking up pace. Especially CSS has been on a run recently: ‘Let me make a prediction: we’ll look back at 2024 as the turning point between “CSS Classic” and “New CSS”.’ Agreed!

• This neat gradient blur effect in a few lines of CSS, combining mask + backdrop-filter: Codepen

• Center stuff in a single line of CSS? Now finally possible with align-content: center; 🎉

• Text fragments allow you to link to a specific piece of text on a page and highlight it. It’s similar to #, except that this is a browser feature and does not require the website to implement anything. Try it!

• Lefthook, the Git hooks manager we use in many projects, can also be used for general tasks outside of Git hooks. Might be handy to unify commands across different stacks and setups! It also supports local overrides.

• Vue Dev Tools are getting a huge update (urgently needed tbh). Interestingly it’s in the form of a Vite plugin, not a browser extension, meaning they can be embedded directly on the page. Should be great for debugging across browsers and devices.

• Promise.try: This new API offers an alternative to try/catch. Nothing you couldn’t do before but can help you write more compact or uniform code in some situations. Browser support is currently limited, but should be available everywhere soon.

• System things: Did you know you can use system colors like Canvas and LinkText in CSS? Not incredibly fancy, but adapts automatically to the user’s system and preferences (like dark mode and contrast). I created a small page where you can see all of them. Related: This list of font stacks that work without downloading additional fonts.

• If I got you excited about symbols last time, here is a great explainer: Exploring JavaScript symbols

• Love this idea: Using static websites for tiny archives

• macOS has a built-in internet speed test that you can run from the terminal: networkQuality, along with some other helpful tools.

🍁 October 2024

• If you need a tagged template literal in JavaScript that does nothing, you can use string.raw. Why would you do that, you wonder? Because if you write something like this in your code: html`<div></div>` many editors will highlight it as HTML, and Prettier will format it as HTML. Great e.g. for stories in Storybook or inline-components in unit tests.

• CSS colors received some updates. The other day I played around with OKLCH and color-mix. OKLCH is an alternative to RGB/HSL with the interesting property that the perceived brightness stays the same with different hues. For example in HSL, blue will look darker than yellow when both have the same lightness. In OKLCH, they will be perceived to be the same lightness. Combine that with color-mix and you can easily generate entire color palettes just in CSS! Here is a playground for OKLCH and here is an article with more information.

• Need a random UUID? This used to be something people would install a package for. Nowadays there’s native support for this: randomUUID

• Symbols are actually pretty cool, I never really used them but turns out there are well-known symbols, which you can define on objects to tell the JavaScript runtime how to iterate over the object, what to return when checking with instanceof, and other things. Also did you know that if an object has a toJSON() method, that method will be called when the object is passed to JSON.stringify 🤯

• With WebKit now supporting view transitions, this new feature is available in all major browsers. Rather cutting edge still, but degrades gracefully so time to start looking into it in case you need/want some fancy transitions.

• Hono apparently is “the newest scream” 😅 in JS-based web servers because it’s fast, lightweight, modular, built on web standards, has an intuitive API, and works in all runtimes. I tried it and it is indeed very nice, will keep that in my mind if I ever need a quick, simple server.

• Very early stages but Node.js can now cache compiled JS byte code, which should lead to significant performance gains for CLI tools and short-lived processes. Fun fact: a lot of what makes JS execution on websites fast is that when the browser compiles the JS to bytecode, the result is cached and doesn’t need to be compiled again unless the bundle changed. Node only used to to that per process, and since many processes are short lived (e.g. run a CLI command) you never really get to benefit from that caching. This flag tries to change that.

• Speaking of performance: With the latest Node versions, you can use node --run <some-npm-task> instead of npm run <some-npm-task>. This too should be a lot faster because Node launches immediately, rather than Node launching NPM launching Node…