This world has always been user-driven capital, capital-driven change, and change-driven ecosystems.
Back in the day, DOS programmers looked down on using a mouse to operate a computer, as if visual operation was a betrayal of the relationship between programmers and machines. All programmers took pride in knowing how many interrupt instructions they had memorized, believing this was the key to the future. But as everyone later knew, the visual Windows system took the world by storm. Ordinary people didn't want the hassle and chose it, so programmers had to switch careers, learn Windows programming, and memorize Windows message types instead.
Was the original DOS tech stack bad? I think TC2.0 was quite good, but it didn't matter. A tech stack, or ecosystem, needs a viable vehicle to survive. Unfortunately, the visual operating system killed the first-generation DOS tech stack—or rather, the underlying technology and user choices did. The Tourb series, as a representative, was excellent but quietly fell out of use. This is very reminiscent of Kodak.
The advent of the Windows operating system ushered in the PC era: standalone games, home entertainment, engineering calculations, etc. The demands of the PC era shaped the form of standalone programs. VB, VC, VF, and Delphi shined, competing on standalone performance optimization and development simplicity—judging a program by its own merits. The key was that users cared and liked these things. In that era, if Warcraft took a minute to start, there would have been no World of Warcraft later. Those technologies were the ecosystem of that time. We don't use them now not because they are outdated, but because the user model that carried those application layers became outdated. In other words, it's the PC era that became obsolete, not the technologies. In fact, some underlying research results from back then are still used by big players today, just not by ordinary application developers.
HTML was born in 1990, Java in 1994. Why were these languages lukewarm for the first ten years, with few users? Because they were born for the next generation. Although forward-looking, the underlying era that would determine their status had not yet arrived. Many early users tried them out of novelty, then complained bitterly—poor performance compared to C/C++, not worth much, etc. Looking back, the public's eyes aren't necessarily always sharp.
Fast forward to 2007, smartphones burst onto the scene...
Ordinary people said goodbye to brick phones and suddenly discovered that this thing was great: more advanced than a PC, more convenient, and classy. So, non-technical people once again decided the new era of IT technology—the arrival of the Internet age!
Two major characteristics of the Internet age:
- Diversification and fragmentation of front-end devices;
- Complexification of interactive business and massive server-side business load.
The new demands triggered by these two characteristics directly stunned the tech stacks that had dominated the PC era (VB, VC, Delphi).
On the client side: Those statically compiled programs that seemed capable of instruction-level optimization suddenly had to be compiled into several or even dozens of versions. Deployments often failed due to missing system environments, and users cursed, "What a piece of junk."
On the server side: Areas like interconnection, communication, massive data processing, and cluster correlation were not the focus before, so there was no corresponding research.
Then everyone understood: You are excellent, but we no longer need you. The heroes of that era should bow out.
In contrast, Java and HTML—these two brothers—had cross-platform design from the start and were designed for communication carriers. In the Internet age, many advantages immediately emerged. So, the underdog turned into a king. Back then, no one was praising Java to the skies, and no one blindly worshipped HTML/JS. But big players started researching how to better implement them for the Internet age with usable solutions, and a new ecosystem began to form...
Microsoft seemed a bit slow to react. Although Bill Gates eventually saw the future and started poaching talent frantically in the late 1990s, it wasn't until 2002 that .NET 1.0 was released. The key issue was that Java had already achieved the underlying purpose for this era.
Between competing products, if they are roughly the same, it's not a dimensionality reduction strike. If it's not a dimensionality reduction strike, then it comes down to details!
PK1: For PC, .Net wins over Java. (But irrelevant, because the PC era was ending.)
PK2: Cross-platform: .Net loses badly to Java. (Everyone says .Net's cross-platform was a sin. Actually, it wasn't. Windows' poor performance on network servers was the real sin—paid and unstable, who would use it?)
PK3: For mobile: .Net loses badly to Java (specifically in the 2002–2016 era).
PK4: With the above three points, does the rest even matter...
Thus, the overall environment naturally leaned toward Java. Many people started learning Java, and the king era of Java finally arrived.
So in China, a very strange logic emerged: Java is strong because many people learn it, Java's ecosystem is good, Java has many ready-to-copy solutions...
But in the tech field, discourse power always lies with underlying technologies. Pure application-layer ecosystems, no matter how optimized or enriched, are quantitative changes, not qualitative changes.
Underlying technologies create new user forms, trigger underlying revolutions, and ruthlessly kill application-layer technologies, whether you like it or not. Unfortunately, Java, C#, and later Python and Go are all application-layer languages. In the face of era-level dimensionality reduction strikes, they actually have no say.
In 2008, the cloud concept began to emerge, followed by AI. The outbreak of the pandemic in 2020 triggered a craze for virtualization. Currently, the metaverse concept is in full swing, indicating that this restless world is about to change again.
The future will certainly be a highly AI-driven cloud world!
Why do I say that?
First, don't people like smart machines? The answer is definitely a warm welcome.
Second, don't people like more realistic virtual experiences? The answer is definitely yes—they might even be addicted.
Third, is it realistic for each company to implement their own AI applications with current frameworks? The answer is definitely no. In the future, they can only call cloud interfaces from AI cloud providers.
Fourth, aren't you looking forward to the IoT world supported by AI? I bet you are—I certainly am.
Thus, you'll find that in the future, programming will gradually shift toward calling cloud interfaces to implement functions, and then gradually even calling cloud interfaces, cloud functions, cloud systems...
You might ask: Why are the big players so willing to develop the cloud? Brothers, the cloud charges by usage count and duration. Once your user base grows, it's incredibly lucrative. And with competitive barriers, who wouldn't want to do it? Why wouldn't capital invest?
So now we see domestic and international giants fiercely competing in the cloud and AI fields. It might seem like it has little to do with us right now, but that's only because their positions aren't stable yet, the foundation isn't solid, so they dare not show their fangs too early.
Back to the topic: When the true future world arrives, what language will we need?
The answer is definitely a language that aligns with the intelligent cloud era. Looking back, in the face of the future, are the cross-platform advantages of Java, C#, and HTML5 still important? I think not. These advantages will become like the former performance advantages of static compilation in C/C++—great, but not important.
In 2010, Microsoft started working on the Azure cloud platform. In 2016, they started .NET Core for full cross-platform support. Suddenly, they seemed willing to sacrifice copyright, abandon exclusive Windows support, and became open-source, inclusive, and free, tirelessly optimizing performance version after version. They've now updated to .NET 6 and are already working on .NET 7. Why?
Some say it's Microsoft's attempt to counter Java and capture the developer market.
That's both right and wrong. On the surface, it's correct. But in the current environment, what's the benefit of fighting Java at a loss? Selling at a loss for publicity?
Also, have you noticed that in .NET Core and the new .NET 5, .NET 6... versions, Microsoft's support for cloud development is rapidly increasing and being heavily promoted? At the development tool level, Microsoft seems determined to build the best even at a loss. On the mobile client side, .Net has started to support almost all platforms, including closed systems like iOS. And on the server side, .NET Core's performance continues to improve, and the framework's development is obvious to all...
Clearly, the sudden shift in .Net strategy in recent years has deep reasons. This is Microsoft paving the way for the future cloud and metaverse era. Whether it wins or loses against Java now might not even be Microsoft's primary concern. The key is to lay a solid foundation and stand firm for the future.
When the AI cloud era arrives, what we now call the server side will become the client for calling cloud interfaces. The current web-based 2D client will likely be replaced by a new virtual reality-based 3D browser!
So the front-end and back-end face another revolution. In that era, with myriad clouds converging, virtual and real intertwined, will the thick ecosystems accumulated by HTML5 and Java still matter? Only one line applies again: Yes, excellent, but not important.
Thus, C# and Java are once again at the same starting line. And this time, C# even has some advantages. HTML might suffer the most, because the 2D browser ecosystem it depends on may become marginalized in a 3D world. Without soil, HTML might be completely revolutionized.
And this time, the details have fundamentally changed:
Detail 1: Cross-platform: C# ties with Java.
Detail 2: Simplicity and efficiency: C# beats Java.
Detail 3: Cloud ecosystem: C# beats Java (.NET Core has built-in cloud support).
Detail 4: 3D ecosystem: C# beats Java (During C#'s downturn, it was sustained by Unity 3D development).
With such clear advantages, continuous strategic support from big players, and new practices, the metaverse ecosystem will quietly rise. When this ecosystem trickles down to our side, you might be surprised to find that this time, the king might actually be C#.
Of course, everything evolves, and every technology innovates itself. As we said, who ends up being the so-called king ultimately depends on which technology's underlying layer better serves users and leads the future.
A language's quality is related to the language itself.
A language's success or failure is unrelated to the language itself!
Reposted from:
Original author: 邪恶的二进制
Original title: Bold speculation: The future king may belong to C#
Original link: https://zhuanlan.zhihu.com/p/499713602