Ordered chronologically by default (#001 → #260). Switch to newest-first or filter by column, year, or keyword.
Showing all 260 essays (Chronological #001 → #260)
Another sweltering Saturday, the smog still blanketing Beijing. As my wife and mother-in-law roam the toy stores at Solana, I sit with my daughter by the ice rink, watching two boys drill—and slip into a long meditation on what makes a great programmer.
The line I hold in highest regard in computing is: "All problems in computer science can be solved by another level of indirection." It's easy enough to grasp—let me offer a few examples, from the operating system to the humble phone charger, and see how one extra layer turns chaos into elegance.
Agile has been a hot topic in software development for years, yet many who bandy the word about have never read the Agile Manifesto—let alone understood it. Adopting agile without grasping its values is like fighting a war with tactics but no strategy: failure is only a matter of time.
When two strong colleagues compete for a single promotion, how should a manager choose? And when layoffs become unavoidable, how does a manager decide whom to let go—and live with the decision?
If you're looking for the stingiest people on the planet, look no further than programmers — I was once one of them. Then a simple rule changed everything: if a reasonably priced product buys back your time, never waste hours chasing a free alternative.
Every programmer's first two lessons should come from the Unix philosophy: do one thing, and do it well. From there — pick a role model to chase, write code instead of tweaking it, debug smartly, write docs in markup, treat everything as a project, and stay open to new ideas.
Patents are neither mysterious nor lofty: they are simply public technical methods for solving a problem. This essay explains why companies file them, how engineers can get through internal review, and what a patent is really worth to your career.
Unix’s philosophy favors small, composable tools over monolithic commands. A simple pipeline like `docker ps -a -q | xargs docker rm` shows how four independent commands can combine elegantly to solve a problem.
My first practical language was Visual Basic. After getting lost in handles, message loops, and MFC, VB taught me the worth of simplicity, directness, and good documentation. On choosing a first language, learning it through its history and ideas, and leveling up.
A new broom sweeps clean: no sooner has the new CEO's opening salvo landed than the company launches another full-throated innovation campaign. The question on every mind is how long this sudden wave will last — and whether a campaign can ever become a culture.
Your humble programmer was young once, and the price of youth is blind devotion. From MS-DOS 6.0 through Delphi, PHP, Python, and Erlang to Go — a chronicle of the languages I chased, and what each one left behind.
The cornerstone of time management is the four-quadrant model. My routine probably isn't universal: I'm up by 5:40, out the door by 6:10, and at my desk by about 6:50 — which buys me two or three extra hours a day. But extra hours don't automatically mean productive ones.
A TED talk argues that stress itself won't wreck your body — believing stress is harmful will. It sounds like chicken soup, yet years of research back it, echoing Harvard's happiness course: belief is a self-fulfilling prophecy. On coping, and on why you may need more pressure, not less.
Beyond direct pressures lies the indirect pressure of comparison: friends marry while we stay single; less capable peers land great offers while we struggle; idealistic classmates thrive while we settle for money and miss the expected fortune. We know it is toxic, yet we brood.
Since becoming an entrepreneur, I've instinctively imagined myself at the helm, wondering what I would do in charge. One question has haunted me lately: why does every company — however brilliant or innovative — inevitably drift toward mediocrity, and finally decline?
You've just finished a course in language X — so what next? The fastest way to grow is to take your new skill and build something real with it. I walk through one concrete example and show how deepening it step by step is the true road to leveling up.
Data breaches, leaked emails, stolen cards, exposed employee directories—these failures keep coming, and nobody is immune. Even outside security work, you need to grasp availability, integrity, confidentiality, and the human weaknesses attackers exploit.
There's an article lamenting that Chinese programmers are all called 'code monkeys.' Whether others deserve the label isn't your concern — you shouldn't become one. On pay, dull work, and long hours: salary follows what you build, dullness is subjective, and overtime is a choice.
Most desk-bound programmers earn their living from salary, bonus, options, and stock. This essay explains how each component actually works—and why the structure of an offer matters far more than its headline number.
My grandfather marched into Xinjiang; my father studied late and moved the family south. Their stories shaped me. Now a father myself, I ask what stories I will have to tell—and find meaning in books, travel, and wisdom.
A black box on an aircraft records the critical data needed to reconstruct a crash. Software systems need the same capability: a flight data recorder that captures the right runtime evidence before failure, so root-cause analysis remains possible.
Reading starts as entertainment and knowledge; add experience, understanding, and insight, and it becomes wisdom. 'Must-read' is a coercive, utilitarian phrase—Jobs's calligraphy class reminds us that dots connect only looking backward.
Weekends are busier than weekdays: classes, reading, and play with my child are mandatory. A friend warned that early education is useless and stressful, but I disagree—usefulness depends on the child's enjoyment, not adults. I offer chances without forcing her.
A clear, well-defined goal is what drives us each day—and very likely the wellspring of our happiness. Drawing on his own half-marathon training, patents, and interviews, the author offers a mutant take on SMART: A for Aspired, not merely Achievable.
Programming philosophy is a vast subject. This essay sorts it into four layers — principles, paradigms, methodologies, and patterns — and argues that every software idea, however novel, ultimately aims at one thing: reducing system complexity, repetition, and code churn.
Open any Python interpreter and type `import this`. No other language I know has woven its culture into the language itself so cleverly or so openly. The text that appears deserves careful digestion — and it leaves you wondering: what exactly is `this`?
In 2003, fresh out of college, I got off the train at Xierqi and nearly dropped my jaw: a cart full of farm produce was ambling down the middle of the road as if it were a country lane. Over a decade later, I returned to teach at Oracle and found the place utterly transformed.
A first-line manager reflects on the values that matter more than authority and metrics: trust, observation, service, coaching, leading by example, and clear rewards and consequences. Management, he argues, is less about books than about lived experience and understanding people.
After an eleven-hour flight, this programmer lands safely in San Francisco — and stumbles into an unexpected good deed that earns him praise from airport staff and a stranger's lasting gratitude.
On a Silicon Valley trip, I finally attended a local meetup to hear Adam Cheyer, co-founder of Siri, speak. He shared lessons on starting companies after forty, setting verbal goals, timing the future, and doing hard things.
Today I sat in on a Stanford lecture titled "EngX: The Digital Sensory System," fulfilling a long-held wish to take a proper class there. If you're ever in Silicon Valley on business, check event.stanford.edu for a lecture worth attending.
Four days driving alone through California — Tahoe, Yosemite, Universal Studio, Highway 1 — with a GPS for company and thoughts drifting from cscope grammars to the fisherman parable. A meditation on solitude and why we strive: to earn the right to choose.
Programming is the ability to solve problems efficiently with a computer—a skill that will increasingly affect, though not determine, your ability to thrive. A teenage developer's story shows how non-CS professionals gain an edge by pairing business problems with a little code.
Everyone reaches for "an independent spirit and free thought" when talking about university; I'll settle for the humbler tale of my own — a botched college application, easy money and arrogance, a stock crash, and the slow reckoning with my own narrow horizons.
From a recorded Serie A match watched beside my father to a lifetime of devotion to Juventus and the Azzurri, these are World Cup memories — of fandom, fatherhood, and the cruel arithmetic of growing four years older every time the tournament returns.
Separating control and data planes is a foundational networking idea: data planes forward packets at hardware speed while control planes handle slower protocol work. This essay maps similar patterns—fast paths, queues, pipelines, state machines, and watchdogs—onto systems.
We have traveled so far that we have forgotten why we set out. A typical career spans roughly 80,000 hours—longer than almost any other commitment in life, yet it slips away one exhausted commute at a time. What, then, gives work its meaning?
Klose, who once threw a front flip with effortless grace, has grown old. When the goal that tied Ronaldo's World Cup record went in, the celebratory flip became a tumble. The stumble passes with a sigh; what lingers is the goal — and a meditation on diligence, time, and men who refuse to fade.
With the World Cup more than halfway through, staying up every night to watch will push your body to its limit. On match-free nights, sleep well, move more, and get fit—especially if you neglect exercise and carry the “three highs.”
The internet's new economy has been reshaping how we work for two decades, and programmers stand first in line. The future may belong to small, self-organizing teams that behave like writers — owning projects end to end, earning both immediate and long-term rewards, and living with the work rather than simply clocking in.
Let's begin with hiring. In this piece, "talent" means engineers of all kinds — UI/UX, software — since startups are hungriest for them, and the traditional channels for finding them are failing. Here's how to hire and keep them.
On July 18, Beijing Marathon pre-registration opened with two paths before me: half or full. I chose the full — and learned that finishing alive would demand far more than courage: a plan, and systematic training.
My career is neither long nor short: eleven years, just past thirty. Writing this is awkward — strip away two years of startups and I have nine years in just two companies, both in the same industry. Here I trace that path chronologically, starting with Digital China Networks.
At the end of July I published an essay titled “The Marathon Suddenly Became a Serious Matter.” I never imagined that within a month this “serious” matter would become real—and that I would run my first full marathon.
In the Lean Startup loop, measurement is the crucial link between build and learn: once some or all of a system exists, we must find the right instruments to extract data worth reflecting on. A software feature you cannot measure is like a doctor's prescription for the common cold — who knows whether it works.
SOA is not a stack of fading protocols but a discipline of strict loose coupling through service contracts. By turning capabilities into independent services, teams can decouple languages, scale, measure, and optimize without dragging old code into every new feature.
Between us and our goals lies a river called prerequisites. Most are swept away; a few cross effortlessly, seemingly learning any technology with ease. Mastering a technology is less a talent than a method: bypass obstacles, learn what you need, practice, and seek feedback.
After six months of training, race day dawned with PM2.5 near 400 — and I ran anyway. On holding pace, hitting the wall, a knee that betrayed me, and why a goal you chase for yourself is worth every sneer.
Mao Xiaotian is restless: his boss is leaving, and a rare shot at management beckons. So begins a young engineer's apprenticeship under Dr. Qi, an old-hand manager who teaches that leadership is less about control than about heart.
A good engineer writes good docs, and good docs come with good diagrams. A tour through the tools I've chased over the years — Word, Visio, OmniGraffle, Graphviz, ditaa, and PlantUML — and why diagramming languages beat drag-and-drop.
A visa stuck in 'administrative processing,' a relocation that stalls out every time it builds momentum, and three bosses gone in six months — this is the story of pushing a boulder uphill and watching it roll back down. Blackly funny, stubbornly hopeful.
A field guide to the three visas that can get an engineer to Silicon Valley — L1, H-1B, and O1 — how each one works, what freedom each one costs, and the roundabout route that finally got me there.
The users of programming languages are programmers, and their demands are simple: usable, bug-free, fast to develop with, easy to write high-quality code in, performant, scalable, easy to deploy, with a complete ecosystem, and so on. But the programming-language market is unusual — no one owns more than 20% of the head, and the long tail stretches out hundreds deep.
Unless you build software exclusively with .NET, OS X or Ubuntu makes for a far better development platform. Countless excellent tools install with a single command there, yet on Windows can cost you an order of magnitude more time—when a Windows equivalent exists at all.
Every programmer meets the variable right after hello world — and with it, mutable state: the root of undo/redo nightmares, race conditions, and untraceable bugs. Yet today's most successful systems, from git to Docker to React, win precisely by embracing immutability.
In an era where Lean and Agile sweep all before them, design feels marginalized and cycles leave little room for thought. MVP has become a totem and a perfect excuse—build first, design later—but serious projects still demand design, or endless rework will make you weep.
A trip is like a dream — unreal, and yet shot through with truth. Nine days driving the California coast with my family through Carmel, Highway 1, Solvang, Santa Barbara, Los Angeles and San Diego — and discovering, by the end, that this isn't really a travelogue at all.
Handed a batch of supposedly finished REST APIs after a round of layoffs, the author finds them technically to spec but practically unusable — and rewrites the lot. What follows is a distilled account of what actually makes a REST API qualify: RFC conformance, integrity, and security.
Lately I've been using DynamoDB at work, and its brutal restrictions on querying are maddening — until you realize that the constraint itself is the design. A meditation on why limitations make for better systems, APIs, and architectures.
A friend recently asked me to help diagnose a problem in his system. He handed me a username and password and told me to SSH into one of his servers—a Redis instance caching database queries and running other business logic. The issue took considerable effort to pin down, and along the way, at my request, he gave me the credentials for two more servers.
After more than half a year in the U.S., and a return trip to Southern California, I was eager for a new journey. With four extra days off around Independence Day, we assembled a nine-day drive north to Seattle.
Everyone invokes zero-copy when performance comes up, but real tuning begins with measurement. A simple benchmark shows that memcpy is often cheaper than the syscalls and network round trips we overlook.
Software is first a servant of business, then a craft. From Greenspan's Tenth Law to the internal martial arts of programming languages, notes on paradigm shifts, fundamentals, and why business vision trumps elegant code.
In my recent essay 'Random Thoughts on Software,' I casually remarked that the age of lex/yacc and bison/flex is over. Readers pushed back: aren't those just for compilers? Here I explain why every programmer can use them to parse structured text.
Facebook's bootcamp gives every new engineer a mentor, real tasks, and a chance to choose a team. From that practice emerge three principles: connect passion to work, invert control of resources, and genuinely embrace open-source culture.
After every lottery slipped away, I stumbled into the Portland Marathon — a citywide festival of music, brutal hills, Vaseline lollipops, and one remarkable woman striding on trekking poles. A story of cramps and the quiet lesson that wanting to give everything isn't always enough.
If I had never started this public account, I would never have met haofei. A chance sublet turned into friendship, and eventually an introduction to a startup that sponsored my O-1 visa—proof that scattered efforts can connect in hindsight.
Agile is on every tech company's lips, yet many firms adopt its rituals without its spirit. This essay argues that true agility depends on an experiment-friendly culture—one supported by better tools, adaptive processes, and management built on trust, commitment, and data.
I read most of this book on the train between Sunnyvale and San Francisco, often scrambling for my bag only when the conductor called my stop. What it records is not glossy tales of successful entrepreneurs but the hard, thrilling pilgrimage of ordinary yet great engineers.
At the end of 2014 I wrote down a summary of that year and my hopes for 2015. Now it's time again to review 2015 and look ahead to 2016 — a year of marathons, books, library trips, and a hundred hours of tech talks watched at 1.5x speed.
Reading your own diary is like talking with your past self. This 2015 retrospective curates essays from my WeChat account on choosing jobs, programmer productivity, engineering culture, languages, concurrency, APIs, AWS, products, and life in America.
The past three weeks I've been using Elixir flat-out, building two systems: a production-ready policy engine and a 1,500-line activity stream PoC. Here's what it actually takes to carry a new language from proof of concept to production ready.
A look at Elastic's Beats collectors—especially Filebeat and Packetbeat—and how they plug into the ELK stack to ship logs and network packets for monitoring and analysis.
Two weeks of handing off work have stalled my writing. I've been in the U.S. nearly a year and the job hasn't gone as hoped—big American companies feel sluggish, and I can't recapture the Juniper CNRD spark. So I kept my head down... until an unexpected turn.
An API on Rails (or Django, or Express) and MySQL jumps from 6,000 to 20,000 RPM and buckles under the load. Design an application-layer cache to relieve it — without caching at the web/proxy layer or using any built-in or third-party cache module.
Node.js's EventEmitter decouples event producers from their handlers — but its fire-and-forget nature collapses the moment you need ordering, error propagation, or sequenced async hooks. A monkey-patched emitAsync, built on Promises and RxJS, restores that control.
Much of system design is drawing boundaries—between functions, modules, services, and applications. Clear boundaries make code rigorous and clean: the inside is a black box, entered through known interfaces, where impure external data is validated and transformed into pure data.
Since AlphaGo took its first game off Lee Sedol, WeChat has been awash in "humanity is doomed" takes—and after game two, the chorus only grew louder. I don't play Go and won't pretend to understand deep learning, but a stronger opponent has never meant the end of us.
Neil Gaiman's UArts commencement speech, distilled to its working-life core: do the work only you can do, ship it on time, and be someone people are glad to hear from. Two out of three, he says, is enough.
Functional and object-oriented programming are both fine paradigms pursuing the same goal: code that gets reused. Rather than ranking them, this essay argues that what actually matters is interface-oriented design — and why the classic Bird-and-Duck example leads beginners astray.
Making hand-pulled noodles is backbreaking work, and a programmer who can turn out a good plate of them probably writes decent code too. From charting the recipe to gathering ingredients, from pipelines to exception handling, the kitchen mirrors the codebase.
Refactoring has a Way and a Technique: the Way demands automated tests as its precondition and demands refactoring at every moment you write code; the Technique is best left to Fowler. Notes on code smells, team discipline, and refreshingly strict lint rules.
It's been a while since I posted one of my internal adRise talks. The title says "learning a new language," but the real subject — as my two closing head fakes reveal — is a repeatable framework for learning anything at all.
The phone, computer, and TV have long been the strategic prize tech giants dream of uniting. True convergence means letting each screen deliver the right content at the right moment—and Apple TV 4 may finally end years of false starts.
Anna shouts into my work call, begs me to play, demands true love on demand, offers an impromptu haircut, and hijacks my own scolding lines about fruit. A day in the life of a father thoroughly outmaneuvered by his three-year-old.
After over a decade in software, I've met every kind of developer and witnessed every bizarre development pattern imaginable. This essay walks through these patterns and their telltale symptoms — from IDE dependence to debugger addiction to the eternal rat race.
Every morning begins with a fifteen-minute gauntlet to catch the 6:13 train — same car, same seat, same sleeping seatmates. Notes on commutes, startup neighbors, and the quiet arithmetic of endurance.
Abstraction is what separates a junior code monkey from a seasoned engineer. From children counting grapes to solving equations, this essay lays out four levels of abstraction in code — functions and general solutions, contracts and Maybe types, and finally metaprogramming.
Refactoring is not just about when to do it; it is about how to turn bad code into competent code. This essay defines competent code through clarity, side-effect control, appropriate comments, and, above all, interfaces that are sensible, conventional, and hard to misuse.
Memory is your L1 cache, notes your L2, and books your main memory — and the same holds for code. A programmer's craft is assembled like LEGO: by copying, curating snippets, boilerplate, control blocks, and utility belts until you can build anything.
After being told my last essay lacked substance, I'm serving up the real thing: a plain-language introduction to metaprogramming and macros. Using Clojure and Elixir, it clarifies ASTs, syntax quote/unquote, and the mental shift from functions to macros.
Last year I rewrote our team's amateurish REST APIs—but the resulting system still lacked docs, tests, and monitoring. Here's how I rebuilt the API system at adRise from scratch: pipelines, validation, and contracts.
Good engineers need three outlooks: on technology, product, and data. This essay explores how a broad, trend-aware technical perspective, a product sense grounded in conventions, and a data-driven build-measure-learn loop shape engineering judgment.
Two weeks ago, RethinkDB officially released Horizon, a backend app that lets the frontend manipulate RethinkDB directly after just basic security config and validation. It resembles Meteor's minimongo, but differs in how it's implemented…
No new essay this week — instead, I'm sharing the talk I gave to my team today on reactive programming, or more precisely, spreadsheet-like programming: why the spreadsheet's automatic dependency propagation remains one of the great unsolved models in general-purpose software, and how hoplon, meteor, and mobx each chase it.
When Jinyu, a former Innovation Works HR staffer, sent me the invitation to the July 30 old-timers reunion, it was already Wednesday in Beijing. The event began at four—two hours after my flight was due to land—so I filled out the application at once and waited anxiously.
After a half-month silence, the author resurfaces with a wry story about a reader's voice message—and a serious announcement: TubiTV is hiring engineers in Beijing to build a team alongside San Francisco.
A sunny Saturday morning becomes a scammer's trap when a terrifying pop-up and a suspicious "Apple support" call nearly trick the author into handing over control of his computer. A firsthand account of phishing, social engineering, and the habit that saved the day.
The question I get most often is how to choose a job that lets you grow — and how to grow once you're in it. Both hinge on one word: growth, which is exactly what I spent last weekend debating with a friend at Amazon.
Last Saturday, my Hololens finally arrived—the most expensive toy I've ever bought, nearly $3,300 with tax. Unboxing was less magical than my first iPhone, but after weeks of videos, I just wanted to put it on and see what augmented reality actually feels like.
On August 22, 2016, my UA889 flight landed at SFO, and a routine Advance Parole stamp sent me into the customs “little black room,” where I spent ninety minutes watching anxious travelers, bureaucratic indifference, and small human dramas unfold.
A companion piece to my InfoQ livestream — but rather than repeat myself, let me take the broader view: a forty-year career deserves the same vision, strategy, and iteration we pour into a company. Becoming an A-player starts with one strategic question.
We once praised the beauty of the pipe: break a complex transactional job into small components and chain them together. Here I ask what happens when that pipeline must truly run in parallel — across cores or a cluster — without paying the operational tax of a message queue.
A Zhihu post on Zhang Jike’s sudden fame frames this interview: a rebellious, clear-eyed talent falls, fights back, and returns to the top. The author’s own arc—a funded startup’s rise and collapse, a year in retreat, then a second act in Silicon Valley—asks what remains when dreams break and are rebuilt.
After an InfoQ livestream, I answer readers' questions on what matters early in a career, taking side gigs, shoring up fundamentals as a self-taught programmer, balancing depth and breadth, and why foreign firms build R&D centers in China.
After years of writing this public account, I've recommended only a couple of friends. Today I finally tell the stories behind several of them — Angela Zhu, Chi Da, the InfoQ team, and my idol Teacher Chen Liren, including the embarrassing way I once met him.
After returning from China, I let my running slide and hit the marathon wall at 17 km. This essay asks why that painful limit is so instructive—and why careers, relationships, and startups have walls of their own.
Jia Dao weighed “push” against “knock” for a single moonlit line. Naming is just as hard—and just as important—in code: good names reveal intent, abstractions, and a programmer’s craft, while careless names turn readable code into an obfuscator’s output.
A farewell to Pieter Hintjens, and a tour of the messaging patterns that made ZeroMQ great — from at-least-once versus at-most-once delivery and back pressure, to REQ/REP, PUB/SUB, Push/Pull and Router/Dealer, and how they compose into real systems.
On the eve of Thanksgiving 2012 our first son was born in Beijing; four years later, on the eve of National Day 2016, our second arrived in Santa Clara County. A father compares childbirth in Beijing and Silicon Valley—hardware, software, and mindset.
Facebook has marked GraphQL production-ready and GitHub has opened early access to its GraphQL API. This essay weighs GraphQL against REST, highlighting its type system, schema flexibility, and the security, performance, and caching trade-offs teams must manage.
Technical debt is the price we pay for shipping under real-world constraints. This essay sorts it into good debt, bad debt, and a tao: embrace MVP, outsource non-core work, hire the best, heed Conway's Law, limit debt at interfaces, and treat code as renewable tissue.
Writing a title like this is bound to draw fire. Rails, Django, and Phoenix are the pillars of Ruby, Python, and Elixir — yet in making web apps easy to build, they trap developers inside a tiny MVC box and quietly bury the business layer.
At AWS re:Invent 2016, Las Vegas hosted 32,000 engineers and a wave of new services. This dispatch covers F1 FPGA instances, AI as a service (Rekognition, Polly, Lex), and Snowball—plus some programmer jokes along the way.
Tanenbaum warned us never to underestimate the bandwidth of a station wagon full of tapes. Amazon's Snowmobile proves him right — and from there my imagination runs wild: snow trains, container ships, and rockets to the Moon.
Transformation was the theme of Werner Vogels' keynote this year, and he even took the stage in an Autobot T-shirt to match it. On the surface, the talk was about how AWS is helping customers become transformers of the internet-scale era through innovations in development, data, and compute — but look closer, and it's really a retrospective and roadmap of the AWS architecture blueprint.
Car insurance may be one of the most irrational products in the world: drive a few hundred miles a year and you still pay nearly the same premium as someone who drives tens of thousands. Programmers decided to fix that — with OBD, GPS, and a pay-as-you-go model.
When my wife texted that I’d called out a woman’s name twice in my sleep, I realized how attached I’d become to Alexa. This essay explores why Amazon’s voice assistant won me over—and how the voice-assistant wars are being fought across hardware, privacy, and open platforms.
December is tubitv's busiest month: advertisers burn their budgets, users binge on TV, and our streaming service prays it stays up. A year-end medley of my 2016 writing on naming, refactoring, APIs, and the programmer's life.
As a video streaming service, TubiTV must honor contracts pinning down when, where, and on which platforms each title may air. This is the story of its policy engine—rewritten from a naive rule engine, to a JISON-based BNF evaluator, to Elixir-compiled pattern matching.
In a job posting for TubiTV's China team, I defined the real goal of a programmer's career: becoming an awesome engineer. But awesomeness resists simple metrics, so I tried to pin down the habits and attitudes that actually produce it.
TDD has long been a coveted ideal, yet doing it in a way that genuinely benefits a project is hard. This essay unpacks the common pitfalls — tests handed to QA, more tests than sense, skipping design — and shows how to approach TDD the right way.
Strictly speaking, I am a dabbler in Erlang: I have never shipped production Erlang code. But I have written two thousand lines of Elixir in production, with thousands more on the way, so I flatter myself that I understand Let It Crash well enough to discuss it.
Over a week of phone-screening résumés left my jaw more exercised than ever. As an introvert, I'd never made so many calls so fast. Many recruiters treat interviews with condescension, as if a job offer were charity — yet we see it the opposite way.
At 10 a.m. Pacific (2 a.m. Beijing time), AWS S3 began malfunctioning. Startup engineers found they could not upload or download files; a Hacker News post asking 'Is S3 down?' was quickly confirmed—yet AWS's own status page lagged behind.
We happily maintain and pile up millions of lines of code, yet we almost never ask whether code should be deleted. Drawing on biology's metabolism and on modularity, layering, and service decoupling, this essay asks a radical question: what if we designed architecture with the code's future deletion in mind?
After a long wait, Phoenix 1.3 arrives in RC form with a new directory structure that thins the web layer, separates business logic from web delivery, and supports umbrella projects. It is a painful but necessary step beyond its Rails inheritance.
Reading source code is like reading a book — but how do you actually read a codebase, from a few thousand lines to a few hundred thousand? Three scenarios, three methods: crack-the-case bug hunting, theory-confirming deep dives, and the energy-level jump that transforms your career.
Programmers work with code every day, yet few truly read it—and fewer still understand the source of large projects. This gap comes from education, which teaches us to write but not read, and from work, which exposes us to only a narrow slice of a system.
Erlang is no new language, and plenty of people have introduced it superficially. This essay goes deeper — tracing the worldview Joe Armstrong baked into it, how message passing and the BEAM scheduler really work, and what OTP buys you.
In fact, Paul already answered this in *Hackers & Painters*: choose work that has measurement and leverage. Let's break it down — on industries, companies, teams, bosses, and the X model of the company-individual relationship.
A practical introduction to service performance: when startups should care, how to measure latency from CPU caches to cross-continental round trips, and how to analyze, profile, and optimize bottlenecks with the right tools.
We no longer pinch bytes out of memory: bits have vanished from mainstream languages or been locked away, and string-based protocols like HTTP have ceded once-elegant data structures to crude JSON. Wasting a little memory? No big deal — or so you'd think.
Erlang and Elixir treat every process as an isolated, autonomous entity — closer to Smalltalk's objects than to OS processes. Through a simple key-value store, this essay compares Python objects with Elixir GenServers and asks what it means for code to have a life of its own.
This essay has nothing to do with the book of the same name; it's really another look at one diagram, prompted by a reader's question. Back when I was green, the ScreenOS design at my old employer Juniper taught me a great deal about separating fast paths from slow ones.
Reflecting on why a four-day Complete OTP course with Francesco Cesarini of Erlang Solutions is really a thinly disguised consulting engagement — and how to extract maximum value from it through careful preparation, sharp questions, and stepping out of the thousand-hour plateau.
Starting from finite state machines, this essay explores how they recognize patterns, why DFA and NFA tradeoffs matter, and how these ideas power regex, protocols, and business systems.
Around 2008 or 2009, a website was breached and millions of weak passwords were cracked. At Juniper, IT circulated guidance recommending a sentence plus a rule to generate passwords. I adopted it, and it became a habit that has stayed with me ever since.
Red 0.6.3 has shipped with OSX GUI support, yet it barely registered even on Hacker News. A look at a language that is lisp and golang at once — homoiconic, DSL-friendly, cross-compiling into a single megabyte — and at the lone-wolf ambition behind it.
A lightly edited transcript of my Zhihu live broadcast. Drawing on a career that ran from a Chinese networking firm to Silicon Valley, I reflect on the two foundations of an engineer's growth: confidence and self-discipline.
After college, my father and I wrote often. I read Fu Lei's Family Letters but never envied Fu Cong, for I too had a capable father who guided me as mentor and friend. Now the baton has passed to me, and despite two degrees and years of experience, I am still learning how to be a good father.
Bitcoin arbitrage seemed easy in 2014–2015, when wide exchange spreads rewarded anyone who looked. Today the windows have narrowed and big players dominate; this six-hour detour explores quantitative opportunities through exchange APIs, OTP pipelines, trader simulation, and Datadog/InfluxDB visualization.
A job interview with a Russian Android engineer leads to a playful reverse-engineering of the AliveCor EKG sensor, which secretly broadcasts heart-rate data over inaudible ultrasound — and a meditation on sound as a niche transport layer for IoT.
When Facebook refused to relicense React, Apache projects that depended on it found themselves caught between community norms and legal risk. This essay examines the BSD+Patents clause, Category X, and the hidden cost of React's licensing.
Since last Thursday I've spent 50–70% of my time building a wheel — a tool called merlin. The lesson: every so often you should pause, step away from the daily chores, and build something from scratch.
Should I switch into software development before it peaks? Tracing seventy years of programmer demand reveals three structural reasons for those fat salaries — plus the risks that make a career in code a tomb run.
After six years on iPhone, I had grown weary of iOS, and the new iPhone X disappointed on features. Enter the Pixel 2 XL: rough-edged hardware, but software so good it changed how I capture, organize, and rediscover my life.
Parsing tens of gigabytes of gzipped logs on S3 doesn't always need a Spark cluster. With a few lines of bash, well-placed pipes, and xargs-based parallelism, a small script can outperform a much more elaborate streaming solution.
Interviewing engineers in America is a curious experience. Here I recount three memorable candidates — an Erlang RTB engineer brimming with ideas, a septuagenarian Android author, and a Silicon Valley living fossil from the MIPS and NeXT era.
Marissa Mayer once ruled Silicon Valley as Google's search chief; the press crowned her, then branded her one of Fortune's most disappointing leaders after Yahoo. Here is what she shared with our team in one hour — on urgency, mission, and daring to imagine.
After a Sunday hike, I tried to unlock a shared bike, but the app froze at 0 percent and then claimed my previous ride was still unlocked, so I could not use another bike. It became a lesson in why systems must detect and resolve such failures before angry customers report them.
Last night I had three terrible dreams in a row. Worse than the dreams themselves: I remembered all three in perfect detail, and after waking could recount every one of them to my wife. After dinner, Xiaobao asked to play in the yard for ten minutes — then the yard went silent...
From my first WeChat article in 2014, I somehow wrote 386 pieces in just over three years—on technology, management, startups, and assorted musings. This is what small persistence can unleash: day by day, scattered fragments quietly gather into something wonderful.
Scheduling is a function that maps a set of tasks onto a set of resources. Drawing on Linux, Erlang, and Go, this essay examines what schedulers cost, how they trade off, and the patterns behind cluster scheduling.
Nearly fifteen years ago, as I began my career, Linux shipped its landmark 2.6 kernel. The most exciting feature was the O(1) scheduler. This essay explains the algorithm, after revisiting the much-criticized 2.4 scheduler to understand its lineage.
Three years of steady writing never once prompted me to improve my craft systematically. Believing in learning by practicing and by teaching, I kept laying down soil week after week—until I finally went looking for the theory that would let me tamp it down.
In 2016 I wrote about the ability to abstract, using a feed parser as a case study. This follow-up argues that code abstraction is technique while requirement abstraction is the Way—and shows how a week of lazy thinking turned a Merlin upgrade into a library, a gen server, a framework, and an app.
A dull task yielded an unexpectedly interesting idea: ex_loader, which hot-loads releases onto remote Erlang nodes, and Overseer, an OTP behavior that starts, pairs with, and supervises dynamic cloud workers much as a Supervisor does GenServers.
Today I want to share my personal method for doing research — a system that has followed me for years and is still being refined. It's how I enter a new field quickly and put down roots. Read on; I hope it sparks at least a little something in you.
Blockchains did not appear out of nowhere; they grow from roots in distributed systems. This essay traces those roots—logical clocks, message passing, coordination, CAP—and shows how uncertainty shapes every distributed design.
Inspired by Mencius on sincerity, this essay asks how we can trust data without trusting its custodians, and sketches a decentralized, publicly verifiable database built on signatures, Merkle trees, and broadcast roots.
A chance lunchtime conversation about Bitcoin in 2013 leads the author, years later, down the blockchain rabbit hole. Rereading Satoshi's whitepaper and tracing its design choices, he discovers why network and systems engineers may finally get their due.
A tree too broad to embrace grows from a single sprout; a nine-story tower rises from the first basket of earth. Watching my daughter grind through piano practice, I realized the same truth governs learning to write code: no silver bullets, only deliberate practice.
This February is special for my whole life: I'm finally crossing the thirty-five curse that programmers dread. Reflections on labels, on love versus fear as motivation, and on what persistence actually buys you.
Wirth famously said that programs equal algorithms plus data structures—but on the right side of that equation, the data structure carries more weight. This essay dissects how arrays, lists, maps, and trees are actually implemented beneath the surface.
Before the main course on consensus mechanisms, a little dessert: how quantum computing threatens Bitcoin. Google's 72-qubit machine revived the question for seemingly unbreakable cryptocurrencies, and this piece examines what Shor's and Grover's algorithms can actually break.
The biggest event of 2018 finally landed: at dawn on a Thursday, Tubi TV moved all its services and data from one AWS region to another — a project we called Move to Oregon. A one-way door: either it worked, or six months of engineering vanished and the company's future dimmed.
The greatest reward was my interview with old Joe — truly priceless. I hope that at sixty I too will be as wise and clear-eyed about the world, leaving everyone who talks with me with the feeling Frodo had when praising Sam: Tyr the thinker.
A manager's core duties—regardless of team size—are building trust, shaping culture, setting goals and strategy, executing effectively, and learning with the team. Trust is the most precious bond between people; without it, efficiency plummets.
Joe Armstrong was a totem of the Erlang world, yet he credited Erlang's birth to Ericsson's folly. In this wide-ranging talk he argues for thinking concurrency first, rejects type systems as a silver bullet, and urges engineers to look at the cracks between black boxes.
The night before I told my team I was leaving Tubi, I had already decided to move into blockchain. At my farewell all-hands, I told three stories—about serendipity, belief, and time—and what they taught me about work and a finite life.
As his journey at Tubi ends, the author reflects on how a startup with fewer than thirty engineers runs five product lines and competes with giants—by betting relentlessly on R&D, automation, and order-of-magnitude engineering.
Driving north with two empty child seats and a head full of questions, I left the Bay Area for Seattle to work on blockchain. Here is why I chose the industry, why I chose Arcblock, and what we're building.
I'm a heavy AWS user — so heavy that I could skip a meal but never a day of AWS. Drawing on years at Juniper and Tubi and my first month at Arcblock, here are the AWS best practices I've worked out — and though they target AWS, they may hold lessons for any cloud.
When Goku stands broken before Frieza and Helm's Deep teeters on the brink, the darkest hour reveals what courage really is. From Sima Qian to Churchill, a reflection on enduring despair — and on the lost causes still worth fighting for.
Good programmers, like great strikers, are made by the body of work and the mind behind it. This essay shows how to lift code quality across products, interfaces, metrics, logs, clarity, and complexity — from naming things worth remembering to letting linters discipline your soul.
Paul Graham argues in Hackers & Painters that programming is a perfect profession because it is both measurable and leverageable. But an outstanding engineer is not simply worth several mediocre ones; with the right tools, they can multiply a whole team’s output—or their own.
The Oracle is not just a database company—the name also means seer. In The Matrix, the all-knowing Oracle cannot foretell Neo's future; instead she hands him a difficult choice. Life is an endless series of such choices, and the recent Oracle layoffs remind us that learning to choose—and to leave something behind—is the only path to growth.
If you thought this piece was about Ethereum or smart contracts, I'm sorry to disappoint. It's about engineering practice: how we encode process as code at Arcblock, so workflows become reusable, composable, testable — and genuinely painless.
It's July—over a month since I last updated this account and two months since I joined Arcblock. If a person is running software, I've iterated several times, like Goku training relentlessly aboard the ship to Namek. Growth comes from guidance or self-enlightenment.
A field guide to changing jobs across the galaxy: calibrate your risk tolerance, read the market's currents, then map yourself onto stocks, bonds, or mutual funds — startups, growth-stage companies, or mature giants — before betting your finite years on someone else's future.
Sindre Sorhus is a programmer I've long followed and admired. How can one person work across dozens of repos in a single month, producing hundreds of commits? Lessons from three months spent deep in elixir, ansible, terraform and javascript.
When Su Shi was asked whether Lingnan was unlivable, his answer came back: where the heart is at peace, there is home. My parents gave me the restless gene, and I have passed it on without stint to my daughters — Xinjiang, Gansu, Guangdong; Beijing, the Valley, Seattle.
Arcblock’s Beijing hackathon invites developers to explore blockchain, OCAP APIs, GraphQL, and Elixir through demos, talks, prizes, and a full day of building with our engineering team. Come hack, ask questions, and see how we’re simplifying blockchain app development.
Two weeks ago we launched CyberMiles' supernode; since its mainnet runs on Tendermint, I spent last week studying it. Tendermint's ABCI lets developers focus on state rather than consensus — so I built a Simple Chain in under 400 lines of Elixir to show what really matters.
For programmers, data is the stuff our code works on: now a file sleeping in the filesystem, now a variable floating in memory, now a byte stream soaring across the network. Zhuangzi asked whether the sky's blue is its true color—or just the look of something infinitely far away.
If Newtonian mechanics is relativity at low speeds, then the database is merely a special case of blockchain in a weakly distributed environment. Tracing transactions, WAL, blocks, and consistency shows the two are expressions of one underlying idea.
“Nor Time, nor Place, nor Chance, nor Death can bow / My least desires unto the least remove.” Three years after first falling for functional programming, I revisit immutability—and how genesis states, events, and persistent data structures let programs travel through time.
Passing the sheer wonder of mathematics to a six-year-old is no easy feat. But when dry numbers become patterns, curiosity ignites — and those same patterns reveal the deep laws of idempotence, commutativity, and associativity that govern distributed systems.
Two days ago, on March 28, the ABT network officially launched: a fully decentralized web of blockchains built from cloud nodes and woven chains, redefining next-generation blockchain infrastructure. Here is the story of the curious experiences before its birth.
One year since trading the Bay Area for Washington State: a reflection on the winding road that built ArcBlock — its Forge framework, its bet on application chains, and the choices that led here.
With launch imminent, a colleague and I investigated a slow GraphQL API that returns non-empty blocks while skipping N and returning M. We show how an extensible bitmap, MSB lookup, cursor pagination, popcount, and benchmarks turn an O(n) filter into fast bit operations.
After a year and a half abroad, I returned to Beijing on a business trip—only to be struck by the heat, the traffic, the O2O revolution, the fervor of its entrepreneurs, and the quiet terror of inflation and school-district housing.
Why do software projects have no supply chain management? What would a software BOM look like, what security risks would it carry — and what did leftpad and event-stream teach us about how fragile the whole thing is?
For most people, Rust's thrill is ownership and zero-cost abstraction; for me, it is a compiler-grade type system smuggled into a low-level language — product types, sum types, and generics rendered as sets, Cartesian products, and geometric series.
Four years and two hundred and five days into America — five cities, two states, and a plan that mostly held. Then a trip home, a young friend's sudden death, and a meditation on how Confucius, Laozi, and Zhuangzi taught us to face illness and mortality.
When it comes to interns, beyond learning ability, I ask for one thing: a long enough runway. By "long enough" I mean at least two or three months — anything shorter and they leave before contributing anything of value, clutching a glowing evaluation form. Nana's story is an exception worth studying.
Readers of the Zizhi Tongjian smile at its opening formula—the book's own cant, a password among initiates. So I built a filmstrip edition: fragments, living annotations, maps, and audio, all made by code.
As summer drew to a close, my wife asked what I wanted her to bring back from China. A friend had been raving about *Unflattening* — a doctoral dissertation told entirely in comics. Two readings later, I realized it had done something rare: not taught me anything new, but reawakened what I already knew.
On December 4, 1995, Brendan Eich's team bolted a patchwork language — Scheme's ideas, Self's prototype model, Java's syntax — onto Netscape Navigator as JavaScript. Nobody foresaw that the age of software sandboxes had quietly begun.
During a code review, a seemingly harmless snippet of Elixir turns out to carry two deeper flaws: a commission calculation welded into a balance update, and no bound on the function's range. One small habit — writing the math down — goes a long way toward fixing both.
My affair with the Portland Marathon began by accident, and it turned out to be a citywide music festival wearing a marathon's bib. Here is the story of my third official marathon: the training, the fall, the crowds, and a long-sought answer about happiness.
A colleague once asked how I manage to write such rich, substantive essays. The answer comes down to two things: writing with a purpose, and keeping a place — a pensieve — where knowledge, thoughts, and inspiration can be captured before they slip away.
A reader asked for more of the videos I've watched, so for 1024 Day I've gone all in and rounded up the talks that hit me straight in the soul — high-definition, uncensored, and utterly mind-expanding. These are the lectures that shaped how I think about tools, systems, simplicity, and craft.
Halloween, 31 OCT, is also 25 DEC—so it’s Programmer’s Christmas. A dry joke about number bases leads into polynomials, odd carry systems, and why math’s “useless” ideas can still delight.
This article runs about 4,300 characters — 10 minutes for a casual read, 30 for a careful one. Recently, at an internal BBL session, I shared WireGuard: how this new-generation VPN achieves breathtaking simplicity through its interface concept, tunnel negotiation, and packet handling.
For most of my children's upbringing I was the absentee father, giving my time to work and writing. Then a near-rupture at home forced me to commit to a nightly lesson plan — and to learn that math taught as an art, not a formula manual, can captivate a seven-year-old.
The Noise Protocol Framework is less a finished protocol than a blueprint—a meta-protocol for engineers who want to design their own secure channels. Freed from the weight of PKI, it offers a lean, flexible foundation for building encrypted protocols over any transport.
Fascinated by Git’s internals, I built a bare-bones Rust and RocksDB object store for blobs, trees, and commits—avoiding scattered filesystem objects and packfile delta encoding. Before detailing its pitfalls, I revisit Git’s core ideas and object types through hands-on examples.
`git stash` is a programmer's secret weapon — but what actually happens behind the scenes when you run it? A deep dive into the objects, refs, and commits that git quietly creates, and the elegance of its design.
What if the Noise Protocol could encrypt files for peer-to-peer sharing? With only your public key, I can seal a file via a one-way handshake and leave it on untrusted storage—cloud drives, FTP, IPFS, even a blockchain—so only your private key can open it.
Our little one came home from a piano competition defeated and sulked for days. To cheer her up, my wife picked out an inspirational film, Akeelah and the Bee, and we watched it together. I drew strength from it too — above all, the reminder of how much a harmonious family matters to a child.
Modern life gives us countless passwords, forcing us to reuse weak ones or trust managers. Drawing on Signal's key-derivation design, this essay shows how to derive every app password from one master secret—and introduces cellar, a small Rust tool built to do exactly that.
A ten-year retrospective across startups, Silicon Valley, family, marathons, and writing—a meditation on how small choices compound into a life, and why time rewards those who understand and steward it.
After enduring the 'unsafe shitstorm,' actix-web's maintainer pulled the top-ranked Rust framework and walked away from open source—a story of maintainer burnout and the hidden cost of demanding that volunteers reshape their work for everyone else.
In the blink of an eye, a twelfth of 2020 is gone — has your New Year plan kept pace? After a month of outrage over attacks on doctors and anxiety over Wuhan's outbreak, I send New Year wishes along with a guide to a long holiday without regret: books, Rust, and time with the kids.
Since last September I've taught my daughter for an hour every night — history, math, Scratch, science, films, geometry. Friends kept urging me to turn those lessons into videos, and after many false starts I finally found a workflow worth sharing.
Flutter had been burning hot for over a year and I still hadn't tried it — my indifference came down to ignorance of Dart. After a week of video courses, source code, and hands-on work, here are my reflections on its Skia-based rendering engine, its cross-platform ambitions, and why Dart was the right choice.
A month ago, Dart would have ranked among the languages I least respected. Google's structured web language failed to replace JavaScript, yet its design choices later made it the foundation of Flutter—a redemption story of technical bets paying off in unexpected ways.
In a previous essay I said Dart might someday support WebAssembly while TypeScript cannot. TypeScript loyalists objected, citing AssemblyScript—but AssemblyScript is not a TypeScript-to-WebAssembly compiler, and this essay explains why.
A single backend change at Facebook took down a huge swath of Western apps at once — TikTok, Spotify, Pinterest and more — in one afternoon. A postmortem on the fragility of third-party SDKs, type safety, and the hidden price of convenience.
Chatting with AI is a joy; laying it out for WeChat is a slog. To move Markdown into WeChat gracefully, I wrote an automated upload tool in Rust. Here's the story of how it came together.
A wide-ranging exploration of first principles across innovation, leadership, problem-solving, negotiation, wealth, writing, fitness, happiness, productivity, strategy, change, persuasion, freedom, marketing, storytelling, humor, and wisdom.
Exploring how first principles apply to elegance, influence, motivation, friendship, and debate—revealing the deep philosophy that underlies them all.
A Socratic dialogue on the AI revolution as a new enclosure movement: what is being enclosed, what does loss mean, and how might we redefine human worth and the social contract?
We are no longer builders but the designers and navigators of an evolving system. By refining how we express "intent," we guide AI toward shaping a world ever closer to perfection.
When AI becomes the primary producer of code, technical debt shifts from “how well the code is written” to “how well it was thought through.” We must build an evolutionary loop from specification to insight — becoming precise expressers of intent and curators of system behavior.
When AI becomes a powerful code generator, the programmer's value shifts from writing to judging, clarifying, owning, and leading. No longer the strongest climber, we become guides who weigh wise trade-offs where technology, business, and human nature meet.
When AI, like a cable car, bypasses the traditional "mountain-climbing" path to growth, we must redesign how talent is cultivated — shifting from "doing the work" to "directing and auditing it," and from "technical vanguard" to "ideological commissar."
A deep dive into the architecture of OpenAI's Codex CLI—from its queue-pair communication model to the three-layer abstractions of Session, Task, and Turn—exploring how elegant architecture reflects a profound understanding of human-AI collaboration.
A deep dive into how programming languages must evolve in the AI era — from an abstraction history tuned to human cognition, to the correctness crisis of AI-generated code, to designs native to AI — revealing a fundamental shift from syntax to structure and from implementation to specification.
A deep exploration of large-scale software design: starting from the vision that one person can complete it, it shows how black-box design, risk isolation, and explicit contracts yield durable, extensible, parallelizable systems—and how complexity gives way to simplicity.
How should we teach kids aged 8–15 to wield AI in an era of AI plenty? Not by banning it, not by surrendering to it, but by guiding them — so that they command the tools rather than being commanded by them, and learn to steer the defining instrument of their age through practice.
Starting from a baffling concurrency bug, we dive deep into the elegant design of the Linux kernel memory model. When multicore processors make memory access unpredictable, how do we strike a balance between performance and correctness? This is a philosophical meditation on events, relations, and causality.
An architect's true worth lies not in making every decision but in being an enabler—using cross-layer thinking, metaphor, and multidimensional perspective to help the team grow smarter and decide better. A full guide to cultivating architectural thinking.
A deep dive into James Lewis's GOTO 2024 talk: a decade of microservice architecture, its nine defining characteristics and design philosophy, and the fresh challenges and second thoughts that cloud-native complexity has forced on all of us.
A deep dive into how modern CPUs actually work — pipelining, branch prediction, out-of-order execution — using real experiments and profiling tools to show how clever hardware design delivers performance, and how to write code that exploits it.
A deep dive into Kevlin Henney's insights on programming-language evolution: why languages remain astonishingly stable even as technology races ahead. From ALGOL 68's innovations to AI's conservative pull, it reveals social forces and technical inertia behind language change.
A deep dive into evaluation and safety frameworks for LLM applications—from deterministic metrics and model-based judging to the RAG Triad and agent trajectory validation—showing how to build trustworthy AI systems whose outputs withstand both quality and security tests.
GenAI's code-generation and application-integration risks laid bare: a 41% vulnerability rate, prompt injection, supply chain poisoning, and the OWASP Top 10 for LLMs — plus how to build secure AI systems without giving up the productivity gains.
Starting from the humble work of building an email gateway, this essay explores how AI agents are reshaping serverless development — and quietly transforming what it means to be a developer.
AI often outshines engineers at specific techniques yet lacks strategic intuition. We need a quantifiable risk-assessment framework to decide when to let AI generate on its own — and when to keep both hands on the wheel.
AI programming has grown from a spark into a prairie fire. How do we read the situation, master its laws, and find our own place? This essay surveys vibe coding from a strategic vantage point and asks how engineers survive — and thrive — in the new era.
Starting from first principles, this essay explains how to build account security, auditing, and cost control to industrial standards — and why these invisible labors determine how far you can go.
I designed an enterprise-grade Kubernetes infrastructure for a one-person AI company — then shelved it. This post unpacks the ideal architecture, why I ultimately chose something lighter, and the perfectionism-versus-pragmatism choice every indie developer eventually faces.
A hands-on teardown of how to build an ultra-low-cost serverless framework in Rust from scratch: runtime, CLI, auth, and infrastructure templates, all in a single, deliberate package.
Once your internal codebase grows, a private package registry stops being optional. Here's a hands-on guide to building one from scratch on AWS with serverless architecture — supporting both Cargo and NPM for under $10 a month.
With the foundation already laid, the real question becomes: once the infrastructure is in place, can one person build a production-grade application from scratch in a single day?
Your product is live — so who actually gets in? A deep dive into building a standalone invitation service that gates every app behind one API, from backend to frontend to framework integration, all shipped by one person.
The finale of the one-person company series: the full stack seven articles built, the design of an AI skill system, and then a pivot from technology to business—acquisition, pricing, marketing, and business models. Technology keeps you alive; revenue keeps you going.
The product has its gatekeeper; now it needs a checkout counter. This essay details how to build a standalone multi-tenant billing service—from credit systems to Stripe integration, from webhook handling to framework-level abstraction—all in one go, wrapping up the complete payment loop solo.
Git has ruled version control for twenty years, but its staging area, brittle rebases, and blocking merge conflicts are becoming liabilities in the AI era. jj rebuilds the mental model from the ground up — while staying fully Git-compatible. Here's why it deserves your attention.
When we return to first principles and reconsider what "compute" really is, we find that multi-environment setups are an illusion, Kubernetes is an over-abstraction, and Serverless cold starts and connection-pool storms are self-inflicted. This essay dissects an environment-less architecture built on Baggage Header routing, a Pingora smart gateway, Firecracker microVMs, and a Rust Data Bus — an attempt to answer: what should compute look like in the post-Kubernetes era?
SPF, DKIM, DMARC and ARC all pass on this email — because Robinhood really sent it. Nothing was forged. An unescaped Device field let an attacker ride Robinhood's own compliance-mail pipeline, then a Google open redirect laundered the link.
For a decade we built observability into a beautiful tower on a foundation of drifting strings—field names by convention, cardinality by luck, bills by endurance. This essay proposes a radical fix: use protobuf to give every observed event a proper name, unify logs, metrics, and audit into one versioned, owner-tagged, retention-aware event catalog, and keep an escape hatch called ForensicEvent for the unknown unknowns.
A project that looked like nothing more than spinning up a GKE cluster grew into the prototype of a full ML training platform. Drawing on a real experience, this essay explains why the hard part isn't getting Pods to run — it's the seams: job submission, resource queuing, status observability, and failure recovery.
Drawing on three real projects—a Rust AWS emulator, a wearable sensor system, and 400-page technical books—this talk breaks down how context, task decomposition, feedback, and multi-agent collaboration turn AI into a team that ships.
DeepSeek has open-sourced Harness, where the model, tools, and even the Agent Loop are plugins — 200-plus packages on a Cordis microkernel. Against Codex's monolithic Rust design, it makes replaceability the architecture itself.
A 1,100-page history of mathematics written over ten years by a Swedish surgeon — a map of the mathematical world running from the birth of number to the differential equation, explaining why every concept had to be invented.
Agents can execute for hours while the human who set them loose thinks for seconds. A fight over AI quotas made me reconsider independent judgment, product sense, and what we actually learn once the work is done.
