The previous article covered 2007, when the iPhone tugged the computing entry point away from the desktop and toward the pocket. But the year when programmers really began to understand that “a phone is not just a smaller computer” was 2008.

That year, the App Store launched, and the first native applications entered the iPhone. A few months later, the first Android phone, the T-Mobile G1, was released. Put together, the meaning was clear: the phone was no longer only a terminal device. It was becoming a platform.

The word “platform” sounds a little worn today, but in 2008 it carried real weight. A platform meant developers, distribution, payment, review, user feedback, version upgrades, ecosystem rules, and even the possibility that a programmer no longer had to beg for channels. If you wrote an application, you had a chance to face users directly.

The App Store Changed More Than Downloading

Apple launched the App Store in July 2008 with more than 500 apps. Within a few days, downloads passed 10 million. Those numbers no longer sound shocking today, but at the time they told developers something important: software distribution had been redesigned.

PC-era software distribution was heavy.

You made installers, placed them on download sites, dealt with cracked copies and mirror sites, wrote registration-code systems, built updaters, and faced countless system environments. Enterprise software was even heavier: sales, implementation, training, deployment, operations. Every layer had weight.

The App Store compressed many things into one action: the user tapped.

This does not mean development became simple. On the contrary, platform rules, review, release rhythm, interface guidelines, performance limits, crash rates, retention, and payment conversion all became new problems. But from a developer’s perspective, the biggest change was that the path from software to user became shorter.

In the past, software was like cargo that had to be moved through layers before reaching users. Mobile apps were more like content, directly distributed by the platform.

Many later growth logics in internet products can be traced back here: the platform provides the entry point, developers provide supply, and user behavior reshapes platform rules. Recommendation, charts, search, reviews, payment, subscription, and advertising all grow around this flywheel.

Android Gave Linux Another Way to Win

The other major event in 2008 was the release of the T-Mobile G1, the first Android phone sold to the market.

If you looked only at hardware, the G1 was not elegant. A sliding keyboard, a trackball, a thick body. It was far from later full-screen phones. But the route it represented mattered: Android combined the Linux kernel, Google services, handset manufacturers, carriers, and an app market into a more open mobile ecosystem.

For people working on Linux at the time, this was interesting.

We had spent years debating whether the Linux desktop could defeat the Windows desktop: distributions, desktop environments, fonts, input methods, office software, drivers, localization. Every item was hard. But the way Linux finally entered ordinary people’s daily lives at massive scale was not the traditional desktop. It was the phone.

The more I think about this, the more interesting it becomes: technical routes do not always win in the way technical people hope.

The Linux desktop did not become the mainstream desktop as expected, but the Linux kernel became one of the most important foundations of the mobile era. It did not sit in front of a computer monitor and fight Windows head-on. It hid inside phones, routers, servers, cloud platforms, in-vehicle systems, and all kinds of devices.

Software Moved From Installation to Service

After 2008, the software object facing programmers also changed.

PC software usually emphasized complete functionality, offline use, and stable versions. Mobile apps were naturally networked, naturally collected user behavior, and naturally depended on servers. A small-looking app might need an account system, push notifications, image services, search, recommendation, payment, risk control, and data analysis behind it.

For backend engineers, this was a huge opportunity.

On the surface, the mobile internet made the frontend entry point smaller. In reality, it made backend systems larger. Every refresh, every location update, every like, every download, and every crash became a request and a data point that servers had to handle.

So when I later moved from a Linux company to an internet company, it was not a complete career break. Low-level systems, service governance, performance, data, and reliability were still useful. Their target had changed: from enterprise customers’ servers to hundreds of millions of ordinary users.

I Had Not Boarded the Ship Yet

In 2008, I did not immediately start building mobile apps.

I was still in a Linux company, still writing C++, GTK, cluster management, and system software. My daily work looked far from the App Store and far from Android. But in retrospect, the tide had already risen.

Many technical changes do not knock on your door when they appear. They first show up in news, in other people’s products, and in places that seem to have little to do with you. By the time they truly arrive in front of you, the structure of the industry may already have changed once.

That was 2008.

From desktop to phone, from software packages to app stores, from standalone software to cloud services, from traditional Linux desktop to the Android ecosystem, several directions turned at the same time. The next year, open-source collaboration and social media would push the relationship between people and code, and between people and information, even further.

IT Events of 2008

• The App Store launched. In July 2008, Apple launched the App Store with more than 500 apps. Software distribution, payment, upgrades, and user reviews were centralized by the platform, and the mobile developer ecosystem began to take shape.
• App downloads exploded. App Store downloads passed 10 million in its first weekend. The number showed that mobile apps were no longer only preinstalled vendor features. They were a software market capable of reaching massive numbers of users quickly.
• The first Android phone was released. In September 2008, T-Mobile released the G1. Android began organizing the Linux kernel, handset makers, carriers, and app ecosystems into the same open platform.
• Linux found another way to win. Android brought Linux into the mobile-device ecosystem and changed how many people understood the question of whether the Linux desktop could win. Linux did not enter everyday life as a traditional desktop. It entered billions of devices as the foundation of mobile systems.
• Ele.me was founded. Ele.me began with campus food delivery and later became an important force in local services and instant delivery. The mobile internet changed not only screens, but also offline life such as eating, transportation, and shopping.
• Mobile backend demand rose. Mobile apps looked like frontend products, but behind them were accounts, messages, location, payment, risk control, analytics, and recommendation systems. The mobile internet pushed backend engineering to a new scale.

References

• Apple Newsroom: The App Store turns 10
• Apple Newsroom: iPhone App Store Downloads Top 10 Million in First Weekend
• T-Mobile Newsroom: T-Mobile Unveils the T-Mobile G1
• TechCrunch: Alibaba to buy all remaining outstanding shares of Ele.me

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