Happy Friday. Here’s what caught my attention this week.

The mystery of the posted message that was dispatched before reaching the main message loop

“There is no rule that says that posted messages wait for the main message loop to process and dispatch them... Anybody could perform these operations; it doesn’t have to be the main message loop.”

As developers, we often build mental models of operating systems that are completely wrong but work 99% of the time. This classic Raymond Chen post is a great reminder that the OS doesn’t care about your ‘main’ concepts—it just executes the APIs you call, exactly as documented.

Book Review: Katabasis by R. F. Kuang

“What if your University advisor died and the only way to graduate was to descend into hell and bring him back?”

The academia-as-literal-hell metaphor is one that resonates deeply with anyone who has survived grad school. Kuang’s ability to mine the psychotrauma of higher education continues to be incredibly sharp and hilarious.

Remembering the Michelangelo virus

“In 1992, people thought something was wrong with you if you carried floppy disks on you, so few people did. The worst that could have happened would have been those machines losing their boot floppies.”

Reading about the Michelangelo panic from today’s heavily networked perspective is wild. The idea that a virus outbreak could be completely thwarted simply because people didn’t physically carry enough floppy disks feels delightfully quaint.

Package Manager Magic Files

“There’s a footgun here: if an .npmrc ends up inside a published package tarball, npm will silently apply those settings when someone installs your package in their project.”

The implicit magic of configuration files walking up the directory tree or slipping into tarballs is a colossal supply chain risk. Transparency and explicit configuration should always win over developer convenience.

JJ LSP Follow Up

“LSP can now provide virtual documents, which aren’t actually materialized on disk... where highlighting is provided by semantic tokens, things like ‘check out this commit’ are code actions...”

Virtual documents in LSP 3.18 open up entirely new paradigms for tooling. Bringing Magit-level Git UX into any editor via a standard protocol instead of editor-specific plugins is the ultimate decoupled architecture.

AI And The Ship of Theseus

“When the cost of generating code goes down that much, and we can re-implement it from test suites alone, what does that mean for the future of software? Will we see a lot of software re-emerging under more permissive licenses?”

Slopforks—using AI and test suites to clean-room reverse-engineer GPL libraries into MIT—is a fascinating legal gray area. We’re about to see the greatest stress test of copyleft software in history.

Happy Friday. Here’s what caught my attention this week.

Lijstduwer, Felipe Rodriquez Award, BNR, NRC, btw en meer

“Samen met vele anderen hameren we al jaren op digitale autonomie en hoe bezopen afhankelijk we zijn geworden van Amerikaanse clouds.”

The conversation around digital autonomy is finally shifting from niche nerd circles to mainstream policy. When we rely entirely on American clouds, we’re not just making a tech choice—we’re making a geopolitical one. Europe waking up to this reality is long overdue.

Firmware Update for the Treedix TRX5-0816 Cable Tester

“For some reason, lots of Chinese manufacturers don’t like publishing updates on their websites. Instead they supplied me with a link to a Google Drive containing an instruction PDF and an small .exe”

It’s endlessly fascinating how hardware distribution has evolved while firmware updates remain stuck in the early 2000s. Shipping a mystery .exe via Google Drive for a cable tester perfectly encapsulates the chaotic charm—and security nightmare—of modern cheap electronics.

Blue Monday by New Order released, 1983

“Their goal was to create an encore they wouldn’t have to play themselves. They could simply reappear on stage, take a bow, press a button, and slip back off stage.”

The ultimate programmer move: automating your own encore. It’s a great reminder that some of the most iconic innovations—in music or software—are born purely out of a desire to do less work.

Advice for staying in the hospital for a week

“Whatever you’re imagining — ‘oh I’ll catch up on reading’ or ‘maybe I’ll do some light code review’ — no. Stop... Your brain is going to be running on fumes, painkillers, and whatever cursed cocktail of medications they have you on.”

We engineers love to optimize every waking second, even when our bodies are literally shutting down. This is the reality check we all need: sometimes downtime isn’t a problem to be solved, it’s just downtime. Let the brain rest.

Steve Jobs in 2007, on Apple’s Pursuit of PC Market Share: ‘We Just Can’t Ship Junk’

“We Just Can’t Ship Junk”

Even years later, this mantra holds up as the ultimate product strategy. In an era where “move fast and break things” has resulted in a lot of broken things, refusing to compromise on baseline quality is actually a competitive advantage.

Pluralistic: Blowtorching the frog (05 Mar 2026) executive-dysfunction

“It’s not that we’re deliberately committing civilizational suicide, it’s just that slow-moving problems are hard to confront, especially in a world replete with fast-moving, urgent problems.”

Doctorow nails the core issue with both climate emergencies and tech enshittification. Our brains are wired to react to sudden fires, not the gradual warming of the room. Recognizing that cognitive flaw is step one; building systems that account for it is the hard part.

Happy Friday. Here’s what caught my attention this week.

A History of Operation Breakthrough

“While thousands of homes were built as a result of Operation Breakthrough, it ultimately failed in its goals to shift US homebuilding into a regime of industrialized building. Within a few years of the program concluding, most of the systems developed by Breakthrough were no longer in production.”

There’s a recurring pattern in tech and beyond: the assumption that if you just industrialize a fragmented, human-driven process, costs will magically plummet. We see this same thesis play out with software factories, low-code platforms, and AI-generated code. The history of Operation Breakthrough is a reminder that the hard part is never the technology — it’s the web of regulations, local standards, and entrenched practices that resist standardization. Every time someone pitches “we’ll just automate it,” I think about prefab housing still being a smaller share of US homebuilding than it was in the 1960s.

Boy I was wrong about the Fediverse

“I never expected to find my news from strangers on a federated social network that half the internet has never heard of. But there’s something quietly beautiful about a place where people just... share what they know. No brand deals, no engagement metrics, no algorithm nudging you toward rage.”

This piece nails something I’ve been feeling but couldn’t articulate. When every mainstream platform optimizes for engagement over accuracy, the weird, broken, decentralized alternative quietly becomes the most reliable source of information. The Fediverse won not because of protocol superiority, but because it’s the last place where sharing knowledge isn’t a growth hack.

Agentic manual testing

“Just because code passes tests doesn’t mean it works as intended. Anyone who’s worked with automated tests will have seen cases where the tests all pass but the code itself fails in some obvious way.”

Simon nails the gap that every experienced engineer knows exists but rarely talks about: the space between “all tests pass” and “this actually works.” Getting agents to manually test by running curl against their own APIs or executing python -c snippets is such an obvious-in-hindsight pattern. If you’re building with coding agents and not doing this, you’re flying blind with a green CI badge.

Clinejection — Compromising Cline’s Production Releases just by Prompting an Issue Triager

“A successful prompt injection against the issue triage workflow could poison the cache that was then loaded by the nightly release workflow and steal that workflow’s critical NPM publishing secrets.”

This is the supply chain attack that keeps me up at night. An AI-powered issue triager with shell access, tricked by a crafted issue title, leading to a poisoned GitHub Actions cache that compromises production releases. The attack chain is elegant and terrifying — and the fact that Cline was actually exploited before fixing it makes this a concrete wake-up call, not a theoretical exercise. Every team running Claude or GPT in CI pipelines needs to read this.

I don’t know if my job will still exist in ten years

“Why hire a group of engineers to ‘be the hands’ of a handful of very senior folks when you can rent instances of Claude Opus 4.6 for a fraction of the price?”

Sean articulates the uncomfortable truth that most of us are dancing around. The question isn’t whether AI will change software engineering — it’s whether “software engineer” will still be a job title in a decade. The overshooting vs. undershooting framing is particularly sharp: either companies keep hiring too long and we get a slow decline, or they cut too fast and suddenly experienced engineers become scarce commodities. Either way, the work we loved is morphing into something unrecognizable.

Introducing GPT‑5.4

“On an internal benchmark of spreadsheet modeling tasks that a junior investment banking analyst might do, GPT‑5.4 achieves a mean score of 87.3%, compared to 68.4% for GPT‑5.2.”

The real story here isn’t another model release — it’s that GPT-5.4 beats the dedicated coding model (5.3-Codex) on coding benchmarks. The specialist models are getting absorbed back into the generalist line. And the pivot to highlighting spreadsheet and document tasks tells you where OpenAI sees the actual money: not in impressing developers, but in replacing the grunt work of every knowledge worker with a laptop.

Happy Saturday. Here’s what caught my attention this week.

Pluralistic: California can stop Larry Ellison from buying Warners (28 Feb 2026)

“Ellison’s plan was to buy Warners and fold it into the oligarchic media capture project.”

As an engineer, it’s chilling to watch the “full-stack” capture of media by the same figures who control our cloud and social infrastructure. When the people running the pipes also own the content, we lose the neutral platforms required for a healthy ecosystem, replacing merit-based competition with pure rent-seeking.

npm Data Subject Access Request

“Every npm audit you have run (4 times) and every npm audit you chose not to run (approximately 11,200 times), all of which we log.”

This satire hits hard because it highlights how our CLI tools have quietly transitioned from local utilities into pervasive telemetry agents. We obsess over production security while ignoring the fact that our local development environments are constantly leaking behavioral data back to the platforms that own our ecosystems.

Approximation game

“Your job is to approximate it as closely as possible using a rational fraction a / b with a reasonably small denominator.”

In software, we often treat floating-point numbers as “close enough,” but this exploration reminds us that the distance between a rational approximation and a real number is a fundamental constraint, not just a rounding error. Understanding these limits is crucial when building systems where “almost right” can drift into significant precision loss over millions of iterations.

A Cookie for Dario? — Anthropic and selling death

“The bar cannot be set so impossibly low that we celebrate merely refusing to directly, intentionally enable war crimes like the repeated bombing of unknown targets in international waters, in direct violation of both U.S. and international law.”

As engineers, we often frame “safety” in terms of technical guardrails or alignment metrics, but this is a stark reminder of the raw power behind the APIs we build and ship. It’s a sobering reality check that simply refusing to facilitate illegal violence is now seen as a heroic stand rather than the absolute baseline for professional ethics.

ATMs by IBM

“Even Benjamin Franklin’s face on a piece of paper can feel like a mere proxy for a database transaction.”

We often treat physical hardware and digital state as separate domains, but the ATM was really our first massive-scale experiment in building robust edge devices for state synchronization. It’s a reminder that even the most “analog” parts of our lives are often just physical interfaces for a distributed system we’ve been refining for decades.

Did Trump just overplay his hand?

“If anything really bad comes of pushing premature AI too hard and too fast into to the military, he will own it.”

For those of us in the trenches, the idea of political mandates forcing premature AI into high-stakes military systems is the ultimate nightmare scenario. We’re watching the collision of “move fast and break things” culture with actual nuclear security, where the technical debt isn’t just a bug—it’s an existential risk. This shift from ethical debates to hard geopolitical pressure changes everything about how we have to think about our code’s blast radius.

Turn creative prompts into interactive XR experiences with Gemini

“This led to the development of tools that allow you to build complex 3D prototypes and interactive models significantly faster than traditional methods.”

The barrier to entry for XR has always been the sheer cliff of learning 3D modeling tools. If Gemini can bridge the gap from “text description” to “interactive 3D object” effectively, we might finally see that explosion of AR/VR content we’ve been promised for a decade.

Gemini 3 Flash is now available in Gemini CLI

“It delivers Pro-grade coding performance with low latency and a lower cost, matching Gemini 3 Pro’s SWE-bench Verified score of 76%.”

Flash models catching up to Pro performance is the real game changer for agent loops. When you’re running a loop that iterates dozens of times, cost and speed are quality. I need to update my local config to test this out.

Insider Amnesia

“The recent kerfuffle over some bad GitHub Actions code is a good example of this - many people just seemed to have no mental model about how a large tech company can produce bad code.”

A great follow-up to the concept of Gell-Mann Amnesia. We often assume that big tech companies are monolithic hives of competence, but really they’re just collections of people trying to ship things before the deadline, same as the rest of us.

Which web frameworks are most token-efficient for AI agents?

“These days, frameworks tend to matter far more than the language itself... I’d see if I could repeat the previous research by looking at what web frameworks were the most efficient.”

This is a metric I hadn’t explicitly optimized for, but it makes perfect sense. If you’re feeding a whole codebase into a context window, the verbosity of the framework is a direct tax on your agent’s IQ and your wallet. Concise frameworks might become the “AI-native” choice simply by being cheaper to read.

• 3 Virtues of AI-Assisted Programmer

  Good programmers should be lazy, impatient and hubris:

  A programmer should be lazy enough that they go to great effort to automate away manual work, impatient enough to write fast software, and have enough hubris that they believe they can write software other people will love

  But do these still hold true in the era of AI? Sean argues they don't—and instead highlights three new virtues of the AI-assisted programmer:

  the obsession to keep your own mind working at the problem

  the impatience to eject and work it out yourself

  suspicion of what the AI is doing

• Lessons learnt from building Code Reviewer Agent System

  Specialized Micro-Agents Over Generalized Rules

  The author transitioned from using a single, overly complex agent integrated with too many tools to a set of smaller, specialized agents—each focused on a specific aspect of code review, such as security, planning, duplication, editorial feedback, and more. This shift led to a 51% reduction in false positives.

• MCP - “Accidentally” Universal Plugin

  Every great protocol gets used for something its creators never imagined:

  • HTTP was for academic papers. Now it runs civilization.

  • Bluetooth was for hands-free calling. Now it unlocks your front door.

  • USB was for keyboards and mice. Now it charges your emotional support portable fan.

  MCP thinks it's for giving context to AI models.

  But really? It's just a really good protocol for making things talk to other things.

  MCP was designed to allow AI models to communicate with various data sources. It has gained such strong network effects that any agent can now interact with any MCP server out there. The author believes its potential goes far beyond AI—MCP could serve as a universal protocol, enabling anything to call or communicate with anything else.

• Rediscovering the joy of writing software

  In 2025, the beauty and craft of writing software is being eroded. AI is threatening to replace us.... Software development needs more simple joy, and I’ve found that creating toy programs is a great way to remember why I started working with computers again.

  While the world is buzzing about efficiency, productivity, and how AI might replace most human jobs, let’s not forget the roots—and the simple joy—of writing software. There’s something deeply satisfying about building something with our own hands, no matter how small or seemingly useless it may be. Sometimes, it's important to pause, step away from the pressure, and create something purely for the love of coding.

• Point-by-point Arguing is harmful

  “Conversations like that often get derailed into the technical details instead of addressing the core reasons behind the disagreement.”

  This is a common pitfall for many software engineers: design reviews and RFC comments often get bogged down in point-by-point technical feedback without first aligning on the overarching goals or rationale with reviewers.

  spend your time articulating the main reason why you believe what you believe, and give the other engineer space to articulate theirs. Don’t put them on the defensive by giving them a barrage of individual points to respond to.

  Software problems are rarely purely technical; they are often socio-technical in nature. Complex organizational dynamics and the level of trust between departments often play a more critical role than the technical details themselves.

• How to provide feedback on documents

  your goal as a feedback giver is to help the document’s author.

  Related to the previous article, but from reviewer’s perspective, the goal of reviewing a document is to help the author. It might sound obvious, but it’s often forgotten. Reviewers can get caught up in debates or defending their own views, which discourages open sharing.

• Shallow Technical Knowledge

  • Building a shallow understanding about how technologies you use work is very helpful, because it lets you have useful insights (about performance, quality, when the technology is a good fit, and so on)

  As we grow as a software engineer, we should put more focus on technical breadth rather than technical depth. Some technics like 20-minutes rule, or personal tech radar could be helpful on building our tehcnial breadth. And i really like the rule author defines to know when to stop diving too deep:

  When I’m trying to figure out how something works, I aim to be able to explain it to a smart junior engineer.

• Always do Extra

  And it's with this decision that every reasonably happy, veteran developer I know distinguishes themselves. They all choose Extra.

  You’ll never finish all the work—so focus on what adds lasting value. The 80/20 rule shows that a small portion of effort drives most results. Use the rest of your time to do extra things: streamline processes, build tools, or connect across teams. These extras compound and lead to long-term success.

• Uber K8s Migration

  We often complain about Kubernetes’ complexity—but what other container orchestration platform handles large-scale workloads better?
  Microservices are inherently complex. Many of the challenges we face aren’t the tool’s fault—they’re the nature of the architecture itself.

• How to be more curious

  “The internet is making smart people smarter and dumb people dumber.”

  As AI becomes more powerful and accessible, genuine curiosity is becoming increasingly rare. This post offers valuable, practical advice on how to stay curious and use the internet and AI to get smarter.:

  • Build storehourse

    Curiosity compounds with knowledge. The more we know, the more “hooks” we have to hang new information on.

  • Start where you are

    just dig a little deeper into subjects that already fascinate you.

  • surprise youself and others

    When something piques your interest, let yourself go down the rabbit hole.

  • go deeper

    More effort means more retention. More retention means more knowledge. More knowledge means more hooks, connections and curiosity.

  • ask questions

    Asking questions of those you love is one of the kindest and most generous things you can do.

• A faster Python type checker written in Rust

  Type check over 1.85 million lines of code per second

  • A blazing-fast Python type checker developed by Meta. Having started as a .NET developer, I'm more accustomed to strongly and statically typed programming languages. I can see how the speed of a type checker would be crucial for large Python projects.

  • And of course, it's written in Rust—it's not the first time I've seen 'written in Rust' used as a shorthand for speed (like with the uv Python package manager). It makes me wonder why tools built in Rust are often 10x or even 100x faster. One key reason is Rust's ability to lay out data structures in a cache-efficient way. For example (source: reddit)

    struct CandidateVotes { tally: u32 }
    
    struct Poll { results: [CandidateVotes; 64] 

  • To access the vote count of the first candidate, the Rust program simply reads the first word (4 bytes) of the results. In contrast, high-level languages like Java, C#, or Python typically require multiple layers of dereferencing and accessing various fields and pointers.

• Microsoft Build 2025

  • This year’s MSBuild event was all about AI—Agentic Web, Azure AI Foundry, Copilot Studio, and more. I used to follow AI trends casually, but after seeing major tech companies dedicate their entire developer conferences to AI, I realized it’s time to take it more seriously and invest significantly more effort in building my AI skills.

  • Personally, I find AI Agents and MCP the most exciting. In the GPT era, AI has mostly been about predicting the next word based on previous ones. But with AI Agents and MCP, AI can now do things for you—make API calls, read files, write code, and even interact with the operating system. (MCP is natively supported in Windows 11.)

  • The only two things I remember from the event that weren’t about AI—well, one of them still had an AI angle—are:

    • Windows Subsystem for Linux (WSL) is now Open Source.

    • VSCode copilot chat extension is also open-sourced

• Google I/O 2025

  • IIf MSBuild 2025 was all about AI, then Google I/O this year was completely immersed in it—Gemini 2.5, Gemma 3n, the new AI-integrated Firebase Studio, and more. The FOMO is real, hearing about all these exciting advances in AI while my day-to-day work is still mostly limited to GPT prompts and a bit of AI-powered autocompletion.

  • I'm especially excited about the Gemma 3n model that Google just announced. It's a multimodal model that runs smoothly on phones, laptops, and tablets. Maybe it's because I've spent most of my career working on on-prem applications, but the idea of having such a powerful multimodal model running locally on a laptop feels truly amazing.

  • The Stitch demo is also super cool. If AI is ever going to take over developer jobs, I feel frontend developers might be at greater risk than backend developers. Tools like this truly achieve concept-to-code with minimal frontend development knowledge required.

• Spotify’s Incident Report

  • Openness is key to building trust. I really appreciate how Spotify maintains transparency regarding both the issues and their underlying causes. The report is concise and clear.

  • I would love to adopt this format in my own work.:

    • title: Incidate Report: date

    • context: just enough for the reader to understand the issue and cause.

    • what happened: sympthon

    • what caused it: root cause

    • timeline: record down the key moments

    • where to go from there: action item and preventive measures

• Getting things "done"

  What does it mean to get things done in large companies? Most importantly, it means finishing things. How can you finish things in a world where you can keep improving systems indefinitely? It means getting them to a point where the decision-makers at the company are happy. At that point, you have to declare victory and walk away!

  • You might refer to it as the '80/20 rule' or 'move fast and embrace change.' In the context of working in large companies, the focus should be on getting things done rather than clinging to the same task indefinitely. Embracing imperfection, we should define a task as 'done' and move on to the next initiative that delivers real value to the company.

  • So, what exactly is the true definition of 'done'?"

  (a) executives at the company understand what’s happened, and (b) are happy with it

• kubernetes 1.33 brings in-place pod resource resizing!

  • In-place vertical scaling of pods has long been a requested feature for Kubernetes, and it's finally here.

  • It’s extremely important for our on-prem deployment use case. Time to upgrade k3s once again.

• Convert github repo to tutorial

  • This tool is incredibly impressive for converting any GitHub repository into a step-by-step tutorial. I can definitely see how it would be helpful for new members to understand the current project structure.

  • Especially like the system diagrams it automatically generates. Remind me of the documentation system, where “tutorial” is aimed to take reader by hand through a series of steps

    They are wholly learning-oriented, and specifically, they are oriented towards learning how rather than learning what.

• Public company comparables

  • A metric that compares spending on research and development (R&D) with year-over-year (YoY) revenue growth provides valuable insights into how effectively a company invests in innovation and capitalizes on those innovations.

    The best companies are to the bottom and to the right; the worst companies are to the top and to the left.

  • Although drawing definitive conclusions based solely on these short-term metrics can be misleading. Companies that invest heavily in R&D may not achieve immediate profitability or breakthroughs, but this does not necessarily indicate poor long-term potential.

• Reduce Docker image size over 95% with slim

  • A while back, a colleague introduced me to a tool called dive, which helps analyze the layers of a Docker image. It's particularly useful for optimizing image size by highlighting duplicates and layer overhead.

  • This week, I came across an article describing how the tool Slim was used to reduce Docker image size by an impressive 95%. The process is surprisingly straightforward. I looked into how it works: it analyzes the application's exposed service endpoints and aggressively removes any files in the image that don't contribute to serving those endpoints. I'm not sure if it's directly applicable to our use case, but the tool also includes subcommands similar to Dive, which can be used to inspect and analyze Docker image layers.

• Stop Using AWS

  • Can’t agree more on the overkill problem in the software world:

    There is a common trap that builders fall into. You read a few blog posts or see a diagram on Twitter and suddenly you think your tiny project needs the same architecture as Netflix.

    You don’t.

  • It’s not limited to personal projects or MVPs—this problem shows up in nearly every software project. Many of us, myself included, often assume that elegant design must account not just for present needs, but for every possible future scenario. That’s a flawed approach. Good software design focuses on solving today’s problems while remaining flexible enough to change—or even be discarded—when requirements change.

• Write code that is easy to delete, not easy to extend.

  • Another great post about how to write code that’s easy to delete:

    Being able to write new code without dealing with old code makes it far easier to experiment with new ideas.

  • Anyone who has worked on large-scale software projects (10k+ lines of code, teams of 10+ developers) knows that 90% of the time is spent trying to understand the existing codebase, navigating layers of abstraction to avoid breaking current logic, and waiting on slow build pipelines. Only about 10% of the time goes into actually writing business logic. It's such a waste.

  • Now imagine a software design that lets you start implementing what you need immediately—without worrying about breaking existing code. To me, that’s what good software design should enable.

• Vibe Coding on Kubernetes

  • I couldn’t resist clicking when I saw 'vibe coding' plus 'Kubernetes' in the post title. The concept is cool. That said, I don’t fully trust myself when it comes to configuring and deploying Kubernetes clusters—so trusting AI to handle it? Honestly, I’m not sure yet.

• Kubernetes Surgeon’s Handbook

  • I'm always interested in learning reliable ways to back up and restore a Kubernetes cluster's state in case of an emergency.

  • By the way, 'Kubernetes Surgeon' is a pretty cool title.

• PewDiePie installed Linux

  • Last week, I mentioned in my SIR post (“Stuff I Read”=“SIR”) that Linux is becoming increasingly popular in the gaming world. This week, a video of PewDiePie installing Linux went viral. As a legendary gamer and streamer, his influence is expected to have a significant impact on the Linux community. I'm excited to see how this momentum will help Linux continue to grow and thrive.

• Learned 2 unconventional git workflow

  • git worktree: This workflow is really helpful when I need to work on multiple branches at the same time. For instance, I can easily port changes from the release branch to the main branch by having both branches as separate folders in my workspace.

  • git triangular workflow: Simplifying my workflow with a triangular Git flow, which reduces merge pain by separating where I pull and push my local branch.

• How slack speed up their build pipeline

  • I came across a post from Slack on how they reduced their build time by 50%. They achieved this by optimizing conditional builds and caching frontend assets. What's impressive is that even with a build time of just 10 minutes, they're still striving for improvement. It's a bit embarrassing to think about our own build times in comparison.

• A very interesting way of debugging

  • I didn't know test coverage reports could be used for debugging. That's really cool!

• Emotional challenge of debugging

  • I completely understand the emotional struggle of debugging and agree that it's a key skill that sets top programmers apart from the rest. It's in those challenging moments that a programmer's true abilities are revealed.

• Senior engineers should make side bets

  • Another great post by Sean. Being senior, we should always work on what actually creates value to the customer and generate revenue to the company. Don’t be a JIRA ticket Zombie.

• Linux is now the best gaming system

  • Linux has long been the leading platform for production software, but Windows has maintained a strong hold on the gaming market. In fact, many people still use Windows primarily for gaming. However, it's exciting to see that Linux is now gaining ground in the gaming world. With Steam and other platforms becoming available on Linux, Windows' dominance may be threatened. If Linux gaming becomes a viable alternative, it could spell trouble for the future of Windows OS.

• Developer Ecosystem 2024 by Jetbrain

  • I always enjoy Jetbrains' annual infographics. The rise of Python, driven by AI, is no surprise. I predict even more adoption in 2025. Interestingly, Go and Rust are the most adopted languages, likely due to their speed. As the industry shifts towards containers and microservices, performance is becoming more crucial than “clean code”. This may explain why traditional languages like C# and Java are seeing stagnant growth due to their runtime overhead.

  • It's also great to see the report highlighting Developer Experience (DevEx) metrics. Unfortunately, 40% of companies don't measure DevEx at all. Hopefully, more companies will start prioritizing developer experience in the future.

• AWS Architecture Governance

  • Interestingly, last week I questioned the effectiveness of AWS's centralized architecture review board process, suggesting that a more decentralized approach (like the Architecture Advice Process) might be more efficient. This week, AWS published an article that echoes my concerns, arguing against traditional architecture sign-off processes and in favor of a more distributed and self-service governance model.

• Why is updating & managing on-premise software so difficult for enterprises

  • In the last decade or so, the world world is running on cloud. All the latest and greatest frameworks are built for cloud environments, where the complexity of hardwares, host OS system and network infras are all abstacted away. In my day-to-day work dealing with software deployment and upgrade in a on-prem environment, I often feel the world has forgotten about us.

  • Recently, though, there's been a growing trend to reconsider on-premise solutions, perhaps driven in part by the AI boom. It's encouraging to see people starting to think about building software ecosystems that cater to on-premise environments again.

• Spotify Backstage 101

  • We're currently using Backstage for API specification and design documentation, but it has the potential to do much more. Our goal is to make Backstage the central hub for developers, where they can handle everything from onboarding to provisioning, testing, and more. Ideally, it will be the only platform they need to use to get their work done.

• Create and validate JWTs in Go by Luciano Nooijen.

  • I recently started following Luciano's blog after reading his thought-provoking post on giving up AI code editors. His latest post, where he creates a JWT token generator and validator from scratch in Go, is particularly fascinating. I love reading about hands-on, start-from-scratch projects like this.

• k0s introduction at KubeCon 2025

  • I've had extensive experience with k3s, and I'm excited about k0s, which shares a similar goal of simplifying Kubernetes. k0s aims to eliminate complexity altogether, and its name suggests that's the case. With tools like k0smotron making it easy to test, I'm looking forward to giving k0s a try in an existing cluster.

• Another KubeCon 2025 topic attracted my attention: Observability Pipeline

  • The CNCF is working to establish a standard for observability query languages. Currently, using SQL as a standard has limitations due to its complex syntax. A proposed solution is to simplify SQL with a pipe syntax.

• Design software actually works

  • When designing software, it's easy to get bogged down in minor details or stuck in high-level brainstorming. This is post by Sean talked about a very practical way of designing software that actually works. Spoiler: non-AI related.

• AWS architecture review board

  • Read about the process called “Architecture Advice Process” from the book “Facilitating Software Architecture”, which suggested the opposite of the AWS architecture review board process: decentralized vs centralized design decision made. Which one to choose? Answer is always “it depends“.

• Building copilot backend with .net aspire

  • I recently saw a demo of.NET Aspire and was impressed to learn that Microsoft's Copilot backend is built using it.