Ten Years of Writing Software

While sorting through my digital archives, I found scans of several old documents. One was the employment contract I signed when I first arrived in Hangzhou. It ran from 1 July 2016 to 1 July 2019. Before it expired, I changed jobs and joined another large company in the city. Seeing those scans again brought back the time when I moved from Beijing to Hangzhou.

In the spring of 2016, I was busy printing and binding my master’s thesis and preparing for my defense. April in Beijing was not yet too warm. With a borrowed luggage cart, I made trip after trip between my dormitory and the courier depot, sending away my existence in boxes and looking forward to opening them in another city, where I would settle all over again.

Life was simple when I had little money, and years later, those days are surprisingly easy to recall. After graduation and before my job began, I had three free months. What I had saved from working for my supervisor was not enough to live on, and sometimes I relied on Ant Jiebei loans to make ends meet. Travel, shopping and eating out were naturally out of the question. Exploring the city, learning to cook and writing code occupied most of those three months.

Money was scarce. If physical effort could solve a problem, I did not spend money on it.

To explore the city, I used Hangzhou’s public bicycles, free for the first hour. Occasionally I walked or took a bus, but whatever the distance and whether or not it rained, cycling remained my first choice. Later, I gritted my teeth and bought a bicycle of my own. It extended my range and earned me the first traffic fine of my life.

The second was learning to cook. My main goal was to feed myself as cheaply and simply as possible. Mashed potatoes, stir-fried vegetables and fried rice appeared regularly on my menu. Cost and how filling a meal was mattered more than flavor or presentation.

The third was writing code. Into that, I poured most of my time and enthusiasm.

I had not chosen computer science because of its employment prospects. What drew me was the freedom to write software whenever and wherever I wanted. Unlike hardware research, writing software did not require a laboratory or specialized equipment. With a computer, I could begin anywhere and at any time, even if at first I was doing it only for fun.

Even more compelling was the precision and order that software seemed to promise at its best. With sensible abstractions, rigorous design and elegant implementation, a program could run reliably, remain extensible and continue to evolve as its requirements changed. A good system, I thought, should resemble a fine Swiss watch: every part fitting perfectly, keeping time without the slightest error. Careful design and implementation at the beginning, followed by simple maintenance, ought to keep the whole system stable for years.

I was captivated by that sense of ingenuity and completeness. From modular abstraction and coding style to system architecture and algorithms, I studied the practices developed by those who came before me and tried to apply them to my own programs.

With some knowledge and very little experience, I signed my first employment contract, hoping to put everything I had learned to the test. I had worked on a few projects in graduate school, but none approached the scale or demands of a real production environment. To me, the contract meant more than the beginning of a job. It meant that the knowledge I had accumulated might finally be put to work.

The three jobs that followed gradually dismantled my idea of perfect software.

At first, I did not question the idea itself. I assumed only that my first workplace was too small and my own experience too limited for what I had learned to be useful. So I joined a large Chinese software company. In a more mature organization, I thought, better engineers working on more important projects would surely design software with greater care.

Nothing changed. Projects were still driven by constantly shifting requirements, and designs kept yielding to deadlines. We could address only the most immediate needs and leave everything else for later. I began to wonder whether the fault lay not in software development but in the working environment and organizational culture.

I later joined a multinational software company, hoping that more mature engineering practices might mean fewer hurried designs and short-term compromises. The result was much the same. On the teams where I worked, many designs needed to survive only the next few months. Beyond that, the direction might have changed, the person responsible might have left, or the entire department might no longer exist.

First I blamed the size of the companies, then their cultures. Only after working at three of them did I understand that the same problem had not appeared by chance. It was not that one company or another had failed to be good enough. I had misunderstood software development from the beginning.

Software is not a Swiss watch. A watch has a clear function. Its structure is fixed when it leaves the factory, and it does not need to acquire new features while it runs. Software is more like a city under permanent construction, with no predetermined boundary. It must respond to new needs and keep changing even while people are using it.

The old city cannot simply be demolished, yet new districts are urgently needed. Aging cables still lie beneath some roads while fiber runs through newly built towers. Temporary structures may remain for years; carefully planned districts are altered again and again as new demands arise. Software, like a city, is built piece by piece by ordinary people working within limits of time, information, ability and organization.

Patches and compromises are not merely scars left when software falls short of an ideal. They are also how a system is kept alive. Software is never finally complete. It passes through a series of temporarily workable states until the whole system is abandoned or replaced.

Yet software’s problems extend beyond imperfect engineering. Once software is put to use, it is no longer only an engineered system made of code and architecture. It enters people’s lives and is used by companies and individuals to pursue particular ends. Engineering correctness does not guarantee a good social result. Software can be elegant in structure, excellent in performance and perfectly stable, yet still produce terrible consequences.

This does not mean I deny that software can improve people’s lives. What I have begun to doubt is a simpler belief: that well-designed software naturally makes the world better.

Software can still change the world, but those who create it cannot decide alone where that change will lead. Once a system enters society, its effects are shaped by its designers’ intentions, the interests of organizations, the choices of users and the surrounding social conditions.

I once believed that faster networks, more information and easier communication would bring people closer to the truth and make it easier for them to understand one another. Today’s internet looks more like a row of isolated cubicles. We sit inside them believing that the walls contain windows onto the world, only to discover that the windows are endlessly refreshing screens, showing us again and again a world that agrees with what we already think.

More unsettling is the fact that I am inside this system too. I learn about the world through screens, pulled along by an unending stream of information and shifting between anger, surprise, and anxiety. I imagine I am seeing more, while my attention grows increasingly fragmented and my connection with tangible life slowly weakens.

I began to understand that technology was not the only thing I needed to rethink. I needed to rethink myself as well. Ten years ago, I cared about how to build a better system. I believed clear abstractions, precise structures and correct implementations could bring order to complexity. I still admire those things, but I no longer treat them as the only way to understand the world.

I want to do things closer to lived experience: meet real people, enter real places, encounter beauty and preserve memory.

I began to read about places beyond my reach and look for ideas about where to go next. I began to travel, walking those roads, cities and villages myself instead of knowing them only through a screen. I spoke with different people, listened to the stories of their lives and saw the same world through other eyes. With a camera, I recorded the people and places I encountered and the ordinary moments that are easily overlooked. Sometimes I wrote as well, preserving scattered thoughts and experiences I did not want to forget.

Gradually, I understood that the world does not always run according to clear logic. Understanding it requires more than analysis and judgment. It also asks us to look, feel and listen with care. Software taught me to break problems down and solve them. Literature, art and philosophy taught me to accept that some problems cannot be solved completely, and that people must go on living with them.

Ten years ago, because I had no money, I used physical effort wherever it could take the place of spending. Walking, cycling and cooking for myself were choices forced by circumstance. Now I want to return to that way of living, but for different reasons.

Walking, cycling, traveling, speaking with people, lifting my camera and putting thoughts into words may not be efficient. But they bring my body and attention back into the world before me, leaving one less screen between the world and myself.

Perhaps wherever my own strength can carry me is where I can begin speaking with the world again.