The Common Language Infrastructure Annotated Standard - Softcover

Miller, James S; Ragsdale, Susann

Softcover

ISBN 10: 0321154932 ISBN 13: 9780321154934

Publisher: Addison-Wesley Professional, 2003

Synopsis

The Common Language Infrastructure Annotated Standard is the definitive guide to understanding the annotated specification for the Common Language Infrastructure (CLI) standard. With annotations and code samples from both the ECMA standards committee and the Microsoft Common Language Runtime (CLR) team, this book goes beyond the online documentation to clarify and amplify the original standard and describe its implementation.The core of this book is the international CLI standard. The text describes the CLI and its parts and provides all the information needed to implement a Virtual Execution System (VES) or design a compiler that runs on top of a VES and generates portable code. Author Jim Miller draws upon his experience as editor of the CLI standard and lead of the Microsoft CLR team to guide readers through the CLI blueprint and to a complete understanding of the CLR.Features of this book include: A heavily annotated architectural overview of the standardA description of the semantics of metadata A complete specification of the Portable Executable (PE) file formatCoverage of file format and metadata layoutAn overview of the CLI librariesA detailed description of the Common Inte

About this title

About the Author

James S. Miller serves as software architect of the Microsoft team that developed the CLR and as the editor of the ECMA and ISO Common Language Infrastructure (CLI) Standards. Prior to joining Microsoft he was part of the World Wide Web Consortium’s senior management team and served on the research staffs of the Massachusetts Institute of Technology (MIT) Artificial Intelligence Lab, the MIT Lab for Computer Science, Digital Equipment Corporation, and the Open Software Foundation. He earned his Ph.D. in computer science from MIT and has been a member of the Brandeis University faculty.

Susann Ragsdale was the original documentation manager for the CLR team, and currently is a consulting technical writer. Before the CLR, she was a lead writer for COM (Microsoft’s Component Object Model). This followed a long and diverse career in consulting on multiprocessor supercomputers, simulation systems, test systems, and integrated circuits.

0321154932AB09182003

Excerpt. © Reprinted by permission. All rights reserved.

This book, The Common Language Infrastructure Annotated Standard , annotates and amplifies the Common Language Infrastructure (CLI) Standard. It describes the CLI and its parts, and contains all of the information required to understand and implement a Virtual Execution System (VES) or design a compiler that generates portable code and runs on top of a VES.

This book is indispensable for anyone who wants to understand the CLI Standard. By necessity, standards follow a specific set of guidelines, including non-repetition of information. The result is a good standard, but it can be difficult to read and easily understand.

The annotations in this book came directly from the authors of the original specification (primarily Jim Miller) and from the highly talented ECMA technical committee that is responsible for standardizing that specification. The many annotations explain and expand on the original standard, clarifying it, connecting the dots, and supplying many more cross-references to make the system understandable.

This book is intended for four audiences:

• Language and tool designers
• Developers of libraries
• Those interested in developing or understanding a Virtual Execution System
• Programmers, who will use primarily the Base Class Libraries, published in companion volumes to this one, and entitled the .NET Framework Standard Library Annotated Reference

About This Book

Along with the complete text of the CLI Standard, except for the portion describing the class libraries, this book contains some other information that may be of help.

Chapter 1 is an overview of CLI and describes, in context, where to go in this book to find specific technical areas.

Chapter 2 contains the annotated Partition I of this standard, an architectural overview and recommended to anyone who needs to understand the CLI. It also contains the specifications for the Common Language Specification (CLS), the restrictions on the CLI for anyone writing code that may be used across languages.

Chapter 3 is the part of the standard describing the semantics of metadata, with annotations. It contains the first 20 sections of Partition II, and uses an assembly language, ilasm, to describe these semantics.

Chapter 4 contains information that is not in the standard. It is an overview of the second half of Partition II, and describes how to find different areas of information. It also provides some information on the PE (Portable Executable) file format for managed files and its relation to the layout of metadata.

Chapter 5 contains the annotated second half of Partition II of the standard, sections 21-24, which describes the file format as it relates to managed files, and the physical metadata layout.

Chapter 6 is Partition III of the standard, which consists primarily of a detailed description of the Common Intermediate Language (CIL) instruction set. In addition, this chapter includes an annotated section important to both language designers and developers of Virtual Execution Systems that describes the effect of various numeric operations between types.

Chapter 7 is the annotated Partition IV, which is an overview of the CLI libraries, also describing what is, and is not, required for a conforming CLI implementation. In the International Standard, this Partition contains the Base Class Libraries in XML format. In this series, however, these are published in companion volumes entitled the .NET Framework Standard Library Annotated Reference.

Chapter 8 is the annotated Partition V, which is a set of annexes to the standard. These include sample programs in ilasm with corresponding annotations containing approximate high-level language examples for the same programs, implementation information for a version of ilasm, library design guidelines, and other information of interest to CLI implementers.

The Appendix in this book reprints the Microsoft Portable Executable and Object File Format Specification. This specification includes a good deal of information on the file format that is specific to Microsoft products and hence not standardized. This information allows you to see how the file format for managed code, described in Chapter 5, relates to the existing Microsoft Windows file format. It also helps clarify why the file format for managed code is more complicated than would be necessary if one were designing a portable format strictly for CIL. For those designing a Microsoft Windows-compatible implementation of the VES, it describes how to handle unmanaged code.

Goals of the Standard and of This Book

The goal of any standard is to set out what must be done to comply with the standard, not to tell you how to implement it. The information makes it possible to guarantee that if you write a program and compile it on one implementation of the VES, it will also run on another implementation, unless the program violates the rules. It specifies both what is needed for portability and the limits of portability. It also specifies the rules for creating a Virtual Execution System (VES).

It was not a goal of this standard to describe why decisions were made. However, many of the annotations in this book attempt to provide some of that context, to make the system more coherent.

Another important part of the International Standard is an implementation of a set of libraries that work on all compliant implementations and are language-independent, called the Base Class Libraries. These libraries are described in detail in companion volumes to this one, entitled the .NET Framework Standard Library Annotated Reference.

Where Did the Standard Come From?

This standard started with a band of troublemakers (as most big ideas do), this time at Microsoft. They had a vision of a multi-language standard that would allow programmers to use whichever language best fit the programming task for any module. Furthermore, they believed that these modules should not only work together correctly, but it should be possible to run them on any operating system without rewriting or recompiling.

This idea faced a lot of opposition in a company whose different divisions had invested huge amounts of time and effort in different programming models; no group wanted to give up its special model. Good technology finally prevailed, however, and the .NET concept, with the development of the Common Language Runtime, gained acceptance.

Language groups within Microsoft were involved in early design talks, and by 1999 the talks had expanded to include language developers from outside Microsoft. Many of these discussions were contentious, but they resulted, eventually, in the CTS and the CLS. More significantly, all of Microsoft’s Visual Studio languages did what was necessary to comply with the rules. All of the languages had to make significant changes to their initial designs. The Visual Basic team, in fact, did a complete redesign of the language. Another thing that laid the foundation for creating a standard is that the group at Microsoft started partnerships very early in the process with language and system developers around the world, to ensure that it would really work as a standard, not just an in-house flash in the pan.

Early on, the development team recognized that the concept of the CLI made sense only if it was in wide use, and the best way to do that was to turn it into a standard that was freely available. So, in 2000, long before the release of Microsoft’s Common Language Runtime, Jim Miller, a senior architect of the CLI, went to a meeting of ECMA International, an international industry association for the standardization of information and communications systems, to talk about creating a standard. At that time, it was informally agreed that the CLI should be submitted.

About a year later, after Hewlett-Packard and Intel had joined Microsoft as co-sponsors, a meeting of the ECMA Technical Committee TC39 in Bristol, England, was presented with three documents—(1) what is now Partition I of this book, (2) a document containing information for compiler designers (now the first half of Partition II), and (3) an XML version of the documentation of the Base Class Libraries. Other companies, such as Fujitsu, who was interested in developing a compliant COBOL, had also joined the effort. The copyright was turned over to ECMA, and standardization really began.

At this writing, Microsoft has shipped as product five implementations of the CLI (or a large subset thereof). Of those, three are completely independent implementations, sharing no code at all. These are:

1. The Common Language Runtime, and derived from that is the Shared Source CLI (commonly known as Rotor).
2. The .NET Compact Framework, and derived from that code base is a CLI being used for the Microsoft TV platform, called the Microsoft .NET Compact Framework TV Edition.
3. A minimal CLI, called the Smart Personal Objects Technology (SPOT), being used for very small devices, like watches.

Other CLIs are under development by other companies, such as the Mono project by Ximian, an open-source project called the DotGNU Portable.NET, and one developed as a research project at Intel Corporation.

Where Is the Standard Headed?

This book is based on these ECMA and ISO standards:

• ECMA: Standard ECMA-335, 2nd Edition, December 2002.
• ISO: ISO/IEC 23271:2003(E), Information Technology—Common Language Infrastructure (CLI).

But standards are living documents. The ECMA technical committee that is responsible for the technical content of the CLI standard is working to refine and improve the standard. The committee’s plan is to create an ECMA edition 3, and then submit it to ISO. Some of the topics under discussion for possible inclusion in a future standard are the following:

• Generics
• Extended threading
• Exception reordering/runtime check disablement
• Debugging enhancements
• Extensible metadata

Generics seem to be the next step in the object-oriented community, and they are likely to be included in a future version of the standard. In the current version, it is not possible to transmit debug information to another debugger, and this change is currently under discussion. Also under discussion are some enhancements that would make it easier to extend the metadata.

Although the CLI standard does not embrace all one might expect in a platform (such as the inclusion of a windowing library or a graphics library), it is felt that these still evolve too rapidly to be standardized. The standard permits anyone to develop these because it lays out the basis for library development.

0321154932P10202003

Edition details

• Publisher: Addison-Wesley Professional
• Publication date: 2003
• ISBN 10: 0321154932
• ISBN 13: 9780321154934
• Binding: Paperback
• Language: English
• Number of pages: 928