Java* is still the dominant Managed Runtime Environment (MRTE), but .NET* is gaining ground.
Managed Runtime Environment (MRTE) technologies such as .NET* and Java* represent a new evolution of the compute model.
Instead of writing directly for a processor, developers now code for a virtual machine that handles many of the tasks that developers formerly had to anticipate and manage. As a result, IT managers now have the freedom to deploy on many different platforms and operating systems instead of being forced to choose.
High-speed secure communications, authentication protocols, message passing, XML parsing, and SOAP encapsulation will soon be a part of all but the simplest applications. Some programming and deployment decisions are new, and some are newly complicated by the technology. It is now more important than ever to choose standards-based solutions and to analyze carefully what to expose as a Web service, and what not to expose.
This new model opens up the potential for interoperable, distributed, and mobile Web applications. On the other hand, it also adds complexity, and Web services can even make it difficult to determine whether an application is on a local server or on the Internet. One critical choice is which MRTE to use to develop and host enterprise Web-service applications.
Industry trends are toward managed environments. Sixty-five to 75 percent of larger enterprises are making primary enterprise-platform commitments to J2EE*, although interest for the future of .NET* is growing. Coexistence of (and interoperability between) the two is a solid bet, and there will continue to be some portion of the market dedicated to CORBA* and various proprietary platforms.
MRTEs Integrate with the OS and Platform to Execute Programs
MRTEs are abstraction layers where programs execute. Java uses the Java Virtual Machine (JVM)*, and .NET uses the Common Language Runtime (CLR)*. Runtimes handle the moment-to-moment tasks of an application, including compilation and interpretation, security and type validation, assignment checking, class loading, and garbage collection. They also provide optional security and exception-handling services.
In other words, the runtime takes on many of the responsibilities that were historically delegated to the operating system and platform, hence the term "virtual machine." In the modern compute model, the runtime and the OS/platform form an integral unit.
Figure 1 roughly describes both the JVM and the CLR. Implementation details vary by platform, but in all cases, a compiler processes the source code, analyzes the syntax, and converts the code into an intermediate code package.
The intermediate language object module includes rich metadata, which is the information the runtime needs to enforce such things as array and bounds or type checking. This is the key difference between this environment and native code: Native code does not have this metadata attached to it, which can lead to both stability and security issues.
Mechanical verification occurs when the code is loaded, ensuring adherence of the byte code to the intermediate language specification, which is then deployed within a .NET or J2EE framework.
Managed Code Resolves Performance, Scalability, and Security Issues
Before the advent of managed code, the developer was responsible for all aspects of program behavior not delegated to the operating system. Those aspects included memory and thread management, construction of security policies, deconstruction of objects, and pointer tracking.
The resulting code base was compiled statically to a machine language understood by a specific operating system and platform. At deployment time, the IT manager could install the application on a single OS and platform. Because it had been translated into native machine code, such applications ran fast, but they were fragile, hard to maintain, and had the potential for serious security problems.
The growth of the Internet and the lure of distributed business models strained these static implementations. They were not portable, nor were they able to handle the demands of distributed computing for networking, security, and interoperability.
In the mid-1990s, IT managers and developers were excited by the new Java Virtual Machine technology, the first managed runtime for the Internet. Unfortunately, its initial implementations were neither fast nor scalable. Those limitations are changing, and modern MRTEs are optimized for scalable performance and security.
In an MRTE, the developer compiles code to an intermediate language, which is dynamically interpreted by a virtual machine at runtime. Typically, such solutions are deployed in conjunction with application servers or similar technologies, which help to regulate and control complex business and management tasks.
The managed runtime layer works in partnership with the platform layer. Platform engineers have worked hand-in-hand with the OS and runtime vendors to develop the new MRTE versions. Many runtimes are available, but one size no longer fits all.
Web Services Complicate Matters Further
The compute model has morphed yet again with Web services, and the importance of the runtime has become even more acute. Take note: an article by Intel Chief Strategist Chris S. Thomas suggests that Web services are likely to become an even more significant factor in the future. Another of his pieces identifies how "putting your applications to work" is the key to increasing workforce efficiency.
Figure 4 shows the increased complexity and abstraction inherent within the Web services compute model.
A dynamic compiler must interpret and optimize code at runtime and meet the extra demands of the Web service infrastructure. The runtime has to manage and maintain complex distributed and mobile applications and handle the parsing and processing the many XML-based SOAP messages at the heart of any Web service deployment.
The next article in this series, "Java and .NET Both Bring Something to the Party," examines the JVM and CLR in more detail. Their similarities and differences shed light on which types of applications benefit from deployment in one or the other, or in some combination of both.
The Intel® Developer Zone provides extensive resources to Java* developers:
- Intel® Developer Zone Java* Resources brings together articles and related resources from the software industry's most qualified developers and analysts.
- The February, 2003 issue of the Intel® Technology Journal is dedicated to managed runtime technologies as they relate to the current topics that developers value most [pdf, 976K]: Managed Runtime Technologies
- The JavaOne Conference is the pre-eminent Java event, with technical presentations on all that is new in the Java sphere: http://java.sun.com/javaone/*
Intel, the world's largest chipmaker, also provides an array of value-added products and information to software developers:
- Intel® Software Partner Home provides software vendors with Intel's latest technologies, helping member companies to improve product lines and grow market share: http://software.intel.com/en-us/partner-home/
- The Intel® Developer Zone offers free articles and training to help software developers maximize code performance and minimize time and effort: http://software.intel.com//
- For information about Intel software development products, including Compilers, Performance Analyzers, Performance Libraries and Threading Tools, visit the Intel Software Development Products home page: http://software.intel.com/en-us/intel-sdp-home
- IT@Intel, through a series of white papers, case studies, and other materials, describes the lessons it has learned in identifying, evaluating, and deploying new technologies: http://www.intel.com/it/