In the 2006 article, I wrote that servers were beginning to change. S3, EC2, Hadoop, jQuery, Twitter, and open-sourced Java were pushing software away from “installed on one machine” and toward “running inside a full set of infrastructure”.

By 2007, another direction also began to loosen: the desktop was no longer the only center of the computing world.

On January 9, Steve Jobs introduced the iPhone at Macworld. On June 29, the first iPhone officially went on sale. Looking back today, many details of that keynote have been repeated countless times: multitouch, a full-screen browser, “an iPod, a phone, and an internet communicator”, and Jobs saying he would introduce three products before revealing that they were one.

But if you place it back inside the programmer’s world of 2007, the real shock was not merely that “the phone looked better”. It changed the center of gravity for software execution.

For a long time, the main battlefield of software was the desktop. Windows desktop, Linux desktop, browsers, Delphi, MFC, GTK, Qt, enterprise clients: all revolved around the assumption that “the user sits in front of a computer”. Servers were important, of course, but the user interface of many business applications still assumed a computer, a screen, a mouse, and a keyboard.

After the iPhone appeared, that assumption began to shake.

That year, I did not immediately move into mobile development. I was still inside the Linux-company world, doing work closer to low-level systems, servers, and management software. Precisely because of that, 2007 has two parallel lines in my memory: one line is the phone pulling computing into the pocket; the other is me still moving between Linux servers and desktop management tools.

A Phone Was Not a Small Computer. It Was a New Entry Point.

Early smartphones did not begin with the iPhone. Palm, BlackBerry, Symbian, and Windows Mobile already existed. Many technical people even felt that the iPhone was not “professional” enough at first because it did not open native apps and lacked many functions. But what it changed was not the specification sheet. It changed the relationship between people and software.

The phone stopped being a telephone plus some features. It began to become a personal computing entry point.

In the desktop era, users usually “sat down to use” software. In the mobile era, users “took it out at any moment”. Those two actions are very different. Sitting down implies longer time, more stable context, and complete input devices. Taking it out implies fragmentation, location awareness, unstable networks, and attention that can be interrupted at any moment.

Software that adapts to this entry point cannot simply shrink a desktop interface. It needs new interaction, new state management, new synchronization, new network fault tolerance, new notification mechanisms, and a new understanding of user behavior.

In 2007, the app ecosystem was not yet mature. The App Store would not appear until 2008. But the first iPhone had already placed the question in front of everyone: if users spend more time away from the desktop in the future, how long can desktop software remain the center?

For someone like me, still working in the Linux desktop and server world, the change felt both far away and close. Far away because we were still writing C++, GTK, system services, and management tools every day. Close because everyone could sense that the center of computing devices had begun to move.

Android Appeared, and Linux Took Another Direction

In November 2007, the Open Handset Alliance was announced, and Android was publicly revealed. Later, Android would become one of the most important mobile operating systems in the world. For people in the Linux world, this carried a subtle irony.

Many people had once hoped that the Linux desktop could challenge the Windows desktop head-on. Domestic Linux companies also put huge effort into that direction: desktop environments, localization, input methods, office software, education and government markets, and industry-specific customization.

But the way Linux truly entered ordinary users’ hands at massive scale was not through traditional desktop distributions. It was through Android phones.

This shows that technical routes do not always win in the way practitioners know best. The Linux kernel, open-source components, hardware vendors, mobile terminals, carriers, and app ecosystems combined into a completely different path. It did not move the PC desktop onto a phone. It rebuilt an ecosystem around the phone as a new entry point.

In 2007, I could not yet see Android’s later scale, but I could feel that the operating-system story was branching. Desktop Linux remained important. Server Linux was even more important. Mobile Linux would explode in another form.

This also made me increasingly wary of the idea that “technical correctness guarantees victory”. Technical correctness is only one condition. Ecosystem position, business model, distribution channel, hardware timing, and user experience can all change the final result.

After the Acquisition, I Started Writing C++ and GTK

Around 2007, the company was acquired by an American company. I began using C++ and GTK to build Linux-based cluster-management software.

This was different from the file-system work of the previous years. File systems, synchronization, and snapshots were closer to the bottom. Cluster-management software stood higher: it needed to organize a group of servers, service states, configurations, tasks, alerts, and resource relationships into an interface that users could understand and operate.

It still belonged to the Linux world, but it was no longer as simple as “install a distribution”. You were facing a cluster.

A cluster means multiple machines, multiple roles, and multiple states. Which machine is online? Which service is abnormal? Where is the task running? Are configurations consistent? What are the relationships between nodes? How does the system recover after failure? How can an administrator judge the problem quickly? All of these must be organized by the interface and backend logic.

Most management software at the time still followed a desktop-client mentality. We used GTK for the interface and C++ for business logic and framework code. Looking back today, many people would instinctively ask: why not a web management interface? Why not a browser? The reason was simple: the technology stack, team experience, customer environments, performance expectations, and deployment habits had not fully shifted to the browser.

That is one subtle thing about 2007. The frontend entry point had already been shaken by the iPhone, and the web was also getting stronger, but a large amount of enterprise software was still living inside desktop clients and local management tools.

That C++ Framework Let Me See a Modern Flavor Early

That C++ framework left a deep impression on me.

It was not the kind of domestic engineering code that merely aimed to “run somehow”. It had been built by very strong overseas researchers. Looking back today, it already contained many ideas that later became more common in modern C++: smart pointers, resource-lifetime management, object composition, abstraction boundaries, event mechanisms, and constraints over complex state.

C++11 had not yet been released, so many things were not readily available in the standard library. But excellent C++ engineers had already been solving memory, ownership, exception safety, and object-lifetime problems in their own ways.

This affected me a lot.

Before that, I had written C, Perl, PHP, Java, Shell, Python, and some C++. But seeing how a large C++ framework organized a complex system felt different. The trouble with C++ is not merely syntax complexity. It hands many engineering responsibilities directly to the programmer: when resources are released, who owns an object, how errors propagate, how threads and events cooperate, and how interface boundaries remain stable.

Written badly, it is painful. Written well, it is powerful.

It also made me more sensitive later to the difference between “a simple language” and “a simple system”. Some languages look simple, but system complexity does not disappear. Some languages look complex, but with good frameworks and constraints, they can carry heavier systems.

Virtualization Went Public, and Servers Kept Being Abstracted

In the same year, VMware went public. It represented another line connected to the cloud-computing changes of 2006: virtualization.

Virtualization was not as visible to end users as cloud computing, and it did not have the stage effect of the iPhone, but its influence on infrastructure was deep. It allowed one physical server to host multiple virtual environments and moved resource isolation, migration, backup, testing, and deployment into a new layer.

If S3 and EC2 in 2006 pushed infrastructure toward APIs, then the virtualization heat of 2007 showed that the relationship between physical machines and software runtime environments was being pulled apart.

This was actually the same kind of problem as the cluster-management software I was building. A machine was no longer just a machine. It had roles, services, resources, state, and dependencies. What administrators needed to see was not the shell of one server, but a set of manageable capabilities.

Our company had originally worked on storage-related products. Around the acquisition by the American company, many colleagues later went to large foreign companies such as EMC, VMware, and Sun. Looking back, this flow was natural: storage, virtualization, servers, and system software belonged to the same infrastructure industry chain. In those years, if one continued along that line, joining a foreign company to work on system software, storage, or virtualization was a very natural choice.

I later did not continue into a foreign company. I went to Baidu and entered the internet industry. That turn had a major impact on my career path over the next decade. I should record one thing here: I need to thank the leader who hired me at the time, Liancheng. He was a very good person and gave me the opportunity to enter a large internet company. Before I left Baidu, he moved to Silicon Valley and became an early employee at Databricks. This story does not belong fully in 2007. It is better saved for the later articles about joining Baidu in 2010 and leaving in 2012.

Later, cloud platforms, containers, Kubernetes, and service mesh would push this line even further. Today, many developers rarely log into physical machines directly. Infrastructure has been abstracted to a much higher layer.

Technology Companies Also Hit Political Boundaries

Later, the company could not continue and once planned to sell itself to Huawei, but the deal was blocked by the U.S. government.

If this is treated only as company gossip, it is too light. It reminded me that infrastructure technology is never only technology.

Operating systems, file systems, cluster management, server software, virtualization, network protocols: these things may seem far from ordinary users, but they often sit on the boundary of industrial chains and national security. Who controls low-level systems, who controls key infrastructure, who can serve which customers, and who can sell to whom are often not decisions engineers can make.

Many years later, Huawei was placed under continuous U.S. pressure. In 2019, it was added to the Entity List by the Bureau of Industry and Security under the U.S. Department of Commerce, followed by more affiliated companies and more complex export-control rules. At that time, many people strongly felt for the first time that chips, operating systems, EDA, communications equipment, servers, and cloud infrastructure could really be placed inside the framework of national security and technology control.

But for me, that feeling did not begin in 2019. Much earlier, the U.S. government already had many restrictions on technology export and corporate acquisition. I personally experienced one case at that storage and system-software company: a technology company that was not in the public spotlight could still hit external regulatory boundaries because of its low-level technology, customer structure, and potential buyer.

When you are young, it is easy to believe that if the technology is good and the product is good, the company will naturally find a way forward. Later, you learn that technology companies also live inside markets, capital, policy, international relations, and customer structures. Companies working on low-level systems and infrastructure are especially likely to hit these invisible boundaries.

This experience did not reduce my interest in technology, but it changed how I understood technology companies. Code is only part of a company’s fate. Sometimes it is not even the most decisive part.

The Desktop Was Still There, but the Center Had Shifted

“Shift” is a good word for 2007.

The desktop was still there. Servers were still there. Linux companies were still there. C++ and GTK management software were still there. But the center had begun to move. The phone became a new entry point. Android gave Linux a path into the mobile ecosystem. Virtualization and cloud computing kept abstracting servers. Web management interfaces would also become more common.

I was still writing desktop management software, but the world was already telling us that future users would not necessarily sit at a desktop, future servers would not necessarily be managed by hand, and future systems would not necessarily be presented through a thick client.

This does not mean desktop software suddenly failed. Many professional applications, enterprise applications, and development tools still need the desktop today. But the desktop was no longer the only center. It began to become one entry point among phones, browsers, cloud platforms, and backend services inside larger systems.

The next year, Android and the App Store would make this change clearer. Software distribution, platform ecosystems, and developer business models would be reshuffled. For me, the Linux-company story would also continue until this chapter gradually closed around 2009.

IT Events of 2007

• The first iPhone was introduced. On January 9, 2007, Apple introduced the iPhone. It combined a phone, a music player, and an internet communicator, redefining mobile-terminal interaction.
• The iPhone went on sale. On June 29, 2007, the first iPhone went on sale. The phone began moving from communication device to personal computing entry point, and the software industry entered the eve of the mobile-app era.
• Android was revealed. In November 2007, the Open Handset Alliance was formed and Android was publicly revealed. The Linux kernel would gain a user scale on mobile devices far beyond traditional desktop Linux.
• VMware went public. VMware went public in 2007, and virtualization attracted strong attention from the capital market as an infrastructure capability. Servers, storage, testing environments, and data-center management were reorganized by virtualization.
• Infrastructure kept being abstracted. Linux servers, cluster management, virtualization, cloud computing, and mobile terminals together pushed software from the single-machine era toward an era of multiple entry points, multiple resources, and multiple layers of abstraction.
• Technology-export boundaries became visible. Low-level systems, storage, virtualization, and communications infrastructure had long sat near export-control and international-regulatory boundaries. Many years later, Huawei’s addition to the Entity List made this line visible to more people.

References

• Apple Newsroom: Apple Reinvents the Phone with iPhone
• Apple Newsroom: iPhone available June 29
• Open Handset Alliance: Industry Leaders Announce Open Platform for Mobile Devices
• VMware News Release: VMware IPO
• Federal Register: Addition of Entities to the Entity List
• Bureau of Industry and Security: Huawei Entity List Frequently Asked Questions

WeChat

Follow ZiCode on WeChat

If this post was useful, you can follow later updates on WeChat as well.

X / Twitter

Follow @ax2_zicode

Faster technical notes, short thoughts, and new-post alerts are posted on X.

X Open X Profile @ax2_zicode