Notes from a working programmer

Topics

What gets written about here

A short list of the subjects that recur across the archive — from timeline data structures to yearly developer surveys.

• T

  Timeline JS

  Building interactive timelines from JSON, with notes on groups, slides and data conversion.

• C

  CSS frameworks

  Bootstrap, Bulma, Tailwind and Sass, weighed up for working programmers.

• J

  JavaScript ecosystem

  Language features, tooling, and what the yearly JavaScript survey revealed.

• D

  Design tools

  Figma, Sketch, Adobe XD and Axure, and how modern design flows fit together.

• S

  Static site tooling

  Hugo with the Nuo theme, and the craft of running a personal site.

• R

  Resources

  Public APIs, 50 Projects 50 Days, podcasts and reference material worth keeping.

• N

  Newsletters

  Curated round-ups of articles, podcasts, videos and tools.

• H

  Software culture

  Reflections on the industry, licensing and the habits of working developers.

The Humble Programmer is a personal blog written from the perspective of someone who spends much of the working day close to code. Its subject is the everyday practice of programming, with an emphasis on web development tools, durable coding habits, and the wider culture surrounding software. Rather than presenting polished authority, the site adopts a reflective, curious tone, inviting readers to think about how software is made and why certain approaches become popular in the first place.

Notes from a working programmer often begin with a problem that feels small but meaningful: organizing timeline data, shaping a component, or making a set of tools easier to understand. From there, the writing explores practical techniques without losing sight of the human context behind them. Software is treated as craft, and craft benefits from attention, patience, and a willingness to revisit familiar ideas with fresh eyes.

Posts and newsletters appear in both English and Chinese, reflecting the bilingual rhythm of the author's notes. This makes the archive feel like a living notebook rather than a finished publication. Entries can be revisited later, edited, or connected to ideas that emerged from earlier work. The result is a space where learning remains visible and where the boundaries between reading, experimenting, and sharing are deliberately soft.

Topics recur across the archive, ranging from timeline data structures to yearly developer surveys and from CSS frameworks to the tools that support everyday development. Each subject becomes an entry point into broader questions about technology. Trends are useful, but they are best understood alongside the decisions, constraints, and preferences that shape how working programmers actually choose and use their tools.

Timeline JS receives particular attention as a subject for building interactive timelines from structured data, with discussion of groups, slides, and the conversion of information into usable formats. Such a project illustrates a recurring theme in the writing: the careful transformation of raw data into something a person can explore. The focus stays on method and reasoning, encouraging readers to consider the design choices behind the finished interface.

CSS frameworks occupy another familiar corner of the archive. Writing about established frameworks offers a chance to compare conventions, examine trade-offs, and consider how styling approaches affect maintainability and clarity. The tone remains practical rather than promotional, treating frameworks as tools within a larger workflow. Questions about structure, readability, and long-term care matter more than declaring any single approach universally superior.

Yearly developer surveys provide a window into the shifting habits and preferences of the wider software community. Reading surveys can be revealing, but interpretation requires care: preferences describe tendencies rather than universal rules. The Humble Programmer approaches this material as a prompt for reflection, connecting published patterns with the quieter, more personal realities of writing and maintaining code in ordinary working environments.

Behind the writing is a simple intention: to share observations about programming in a way that feels calm, direct, and useful. The phrase Stay Hungry, Stay Foolish captures the spirit of continued learning, while the humble framing keeps the emphasis on practice rather than self-importance. Readers are invited to find something they can apply, question, or carry forward into their own work with code, tools, and collaborative teams.

For readers who are curious about the site itself, the About this site area offers a natural place to understand the purpose behind the collection of notes. It situates the blog as a personal record of a programmer's evolving interests rather than a formal course or corporate resource. The overall impression is editorial and generous: thoughtful, unhurried writing about tools, habits, and the culture that surrounds the craft of software development.

Selected writing

Recent posts

• January 31, 2021 Newsletter 002 — CSS and JavaScript survey results

  Reading the 2020 State of CSS and State of JavaScript reports, with notes on utility-first frameworks, Bootstrap, Sass, Vue.js and React.

• January 10, 2021 Newsletter 001 — design tools and software work

  The first issue: design tool survey results, the shape of a modern design pipeline, and a handful of recommended resources.

• March 15, 2019 Timeline JS usage notes

  Practical follow-up: using events instead of eras, grouping slides by earliest date, keeping timelines lean, and debugging locally.

• January 24, 2019 Introduction to Timeline JS

  Getting started with version 3 of the library — the spreadsheet wizard, JSON data, and how the two approaches differ.

More writing is collected in the blog archive, including a 2008 piece on the Windows black screen controversy.