Why .NET is the best thing to happen to software since OOP, Part II
I didn't really finish the discussion of what I began in this blog, so I'll do so today. Why do I think .NET is the best thing to happen to software since OOP? Several reasons:
1. Based on what the market has said, software for the PC and for Windows is obviously where it's at these days. I believe that any fundamental shift in how software is built will have to start with the development of Windows software. Some old-timers may wonder why I'd be so arrogant as to exclude, out of hand, software for other platforms in a discussion such as this. How could something so fundamentally beneficial to the industry as a whole be oriented primarily around one platform? Two answers here: One, it isn't. I believe .NET and the style of development it encourages will eventually be ubiquitous across all major platforms, and it is already making inroads onto platforms such as the PocketPC and the SmartPhone. Witness the use of Java on so many platforms if you doubt this. Two, to the extent that .NET is currently oriented around the PC and Microsoft technologies, it makes complete sense given that those technologies are overwhelmingly more in use than others. Something like this has to be market driven. Eventually, I think .NET will be very popular on lots of platforms, but the market should drive this.
2. The type of development espoused by the .NET Framework must be embraced by a majority of the software development industry in order to be successful. That's the fundamental problem with Java. Microsoft is, all by itself, the majority of the software development industry. Java will never have the acceptance it yearns for without Microsoft's backing. That's a hard thing for the rest of the industry to accept, but I believe it's accurate. Teaming a revolution in how software is built with a company that has the resources to back, grow, and extend it is the chief reason that the .NET Framework will ultimately win out over Java.
Before I get too ahead of myself, let's review what exactly this revolution amounts to. Some of this will necessarily sound like a comparison between Java and the .NET Framework. A revolution of this type requires:
a. A greatly streamlined C-like language that features rich OOP support, but sheds most of the C language's historical baggage. True, VB.NET and many of the other CLR-compliant languages are not C-like. However, an initiative like this requires at least one of its supported languages to be C-like, if, for no other reason, than to attract the legions of C and C++ developers out there and to give them a reasonable way to port their existing development skills and the hordes of existing apps. C is the lingua franca of the computing world. Sun knew that when it came out with Java, and Microsoft knew it when it created C#.
b. A language-independent infrastructure that allows developers of multiple development languages to interoperate, exchange and inherit from objects originally built in other languages, and generally allows developers to leverage the goodness of next-generation software development without giving up the languages they find most productive. While the JVM can be accessed from lots of languages, the .NET Framework was designed to be language-agnostic out of the box. The trade-offs and standardization that have to happen to allow a cadre of languages that vary widely from one another to interoperate have already been thought out by the designers of the Framework, whereas the JVM was obviously designed for use by Java. The claim by some Java supporters that Java is the overwhelming choice for JVM development because it represents the "best of breed" language for this type of development is circular. It's the best tool for JVM development because the JVM is unabashedly oriented toward it, while the .NET Framework is not geared toward any one language. C# is a great language for Framework development, but a capable VB developer can be just as productive with it using VB.NET, and a capable Delphi developer can be just as productive with it using Delphi 8.
c. A rich, homogenous component framework with much of the plumbing of typical applications already created. Rather than expecting developers to navigate an increasingly more complex labyrinth of Win32 APIs, MFC, ATL, COM, VB forms, and others, Microsoft has pulled all the important pieces together into a single, coherent component framework. This makes development for Windows, the overwhelming favorite by the market, easier than it has ever been.
d. A safe runtime sandbox in which to play. Regardless of whether it's the JVM or the CLR, the industry has been ready to leave behind the more common types of resource leaks and program crashes for years now. The technology required to make this happen goes back a couple of decades -- it actually predates Java. It has existed in an odd assortment of smart/auto classes, runtimes, and automatic resource managers since the 80s. Java's VM and the .NET Framework's CLR bring these types of things together into a single environment wherein the developer can focus more on building software rather than building the foundation just about any complex app requires. This sandbox greatly simplifies the software development process for the typical engineer and leads to software products that are more stable, less bug-ridden, and generally more functional.
e. A runtime environment that is easily portable to multiple platforms and development models. If an initiative such as this is to be successful, it must provide at least the promise of easy portability and let the market drive just how much of that happens. IOW, while it might not need to directly support, say, both Windows and Linux development out of the box, it needs to be readily extendible to such things if the market dictates it. Java has long held this ground and has a great portability story. Managed code and the .NET Framework are not yet as ubiquitous on non-Windows platforms as Java, but the promise is there, and if people want a .NET Framework that runs on some odd variant of Linux the world has yet to embrace, the technology is there to make it happen. As I've said, the initial focus on Windows is warranted given its market share and ubiquity, but the Framework has smartly been built such that extending it to other platforms is very doable, even by third parties, as these people have demonstrated.
3. The type of development espoused and encouraged by the Framework represents the same type of fundamental shift in software development that adding objects to C did. Moving from procedural languages to C++ and other object-oriented languages revolutionized how software was built. Moving from native code language tools with their many rough edges, easy to make mistakes, resource leaks, and crashes to a safer, more productive runtime-based development model is a similar paradigm shift. Some language tools have benefited from this shift for years now, but having it made industry-wide thanks to the backing and evolution of it by a player as large as Microsoft could literally revolutionize how software is developed.
I should mention that Java initially held much of the same promise as Microsoft's managed code and .NET Framework initiative, but has failed to unseat VB and C++ as the kings of the software development mountain for numerous reasons ranging from ease of use issues to not being sufficiently grown and evolved over time to being simply unsuccessful in persuading the majority of developers to abandon Microsoft language tools. Many of these things feed off one another. That Java has never been as easy to use as VB is one of the main reasons it has been unsuccessful in getting developers to give up VB for Java. That it has not evolved to have the power and advanced compilers typical of the C++ world is one of the reasons much hardcore development is still done in C++. When Java first came out, a lot of people thought it would quickly relegate C++ to the ashbin of history. That didn't happen. Rather than bringing much of software development under a unified development umbrella, Java has merely taken its place alongside VB, C++, Delphi, and others as one of the many language tools the typical organization uses.
So, I guess the bottom line is, I think the .NET Framework initiative has the potential to revolutionize how we build software because it presents a vastly superior development model and because it is targeted by the largest player in software development industry at the most popular software development platform. With Microsoft's virtually unlimited resources and the revolutionary design tenets evident throughout the Framework, I think the sky is the limit in terms of what managed code development could mean to software development. Far from anything to worry about as Mark's blog posits, managed code represents the dawn of a new era.