The Experts below are selected from a list of 2655 Experts worldwide ranked by ideXlab platform

Don Syme - One of the best experts on this subject based on the ideXlab platform.

  • formalization of generics for the net common language runtime
    Symposium on Principles of Programming Languages, 2004
    Co-Authors: Andrew Kennedy, Don Syme
    Abstract:

    We present a formalization of the implementation of generics in the .NET common language runtime (CLR), focusing on two novel aspectsof the implementation: mixed specialization and sharing, and efficient support for run-time types. Some crucial constructs used in the implementation are dictionaries and run-time type representations. We formalize these aspects type-theoretically in a way that corresponds in spirit to the implementation techniques used in practice. Both the techniques and the formalization also help us understand the range of possible implementation techniques for other languages, e.g., ML, especially when additional source language constructs such as run-time types are supported. A useful by-product of this study is a type system for a subset of the polymorphic IL proposed for the .NET CLR.

  • POPL - Formalization of generics for the .NET common language runtime
    Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '04, 2004
    Co-Authors: Andrew Kennedy, Don Syme
    Abstract:

    We present a formalization of the implementation of generics in the .NET common language runtime (CLR), focusing on two novel aspectsof the implementation: mixed specialization and sharing, and efficient support for run-time types. Some crucial constructs used in the implementation are dictionaries and run-time type representations. We formalize these aspects type-theoretically in a way that corresponds in spirit to the implementation techniques used in practice. Both the techniques and the formalization also help us understand the range of possible implementation techniques for other languages, e.g., ML, especially when additional source language constructs such as run-time types are supported. A useful by-product of this study is a type system for a subset of the polymorphic IL proposed for the .NET CLR.

  • Combining Generics, Pre-compilation and Sharing Between Software-Based Processes
    2004
    Co-Authors: Andrew Kennedy, Don Syme
    Abstract:

    We describe problems that have arisen when combining the proposed design for generics for the Microsoft .NET common language runtime (CLR) with two resource-related features supported by the Microsoft CLR implementation: application domains and pre-compilation. Application domains are “software based processes” and the interaction between application domains and generics stems from the fact that code and descriptors are generated on a pergeneric-instantiation basis, and thus instantiations consume resources which are preferably both shareable and recoverable. Pre-compilation runs at install-time to reduce startup overheads. This interacts with application domain unloading: compilation units may contain shareable generated instantiations. The paper describes these interactions and the different approaches that can be used to avoid or ameliorate the problems.

  • LPAR - Automating Type Soundness Proofs via Decision Procedures and Guided Reductions
    Logic for Programming Artificial Intelligence and Reasoning, 2002
    Co-Authors: Don Syme, Andrew D. Gordon
    Abstract:

    Operational models of fragments of the Java Virtual Machine and the .NET common language runtime have been the focus of considerable study in recent years, and of particular interest have been specifications and machine-checked proofs of type soundness. In this paper we aim to increase the level of automation used when checking type soundness for these formalizations. We present a semi-automated technique for reducing a range of type soundness problems to a form that can be automatically checked using a decidable first-order theory. Deciding problems within this fragment is exponential in theory but is often efficient in practice, and the time required for proof checking can be controlled by further hints from the user. We have applied this technique to two case studies, both of which are type soundness properties for subsets of the .NET CLR. These case studies have in turn aided us in our informal analysis of that system.

  • Automating type soundness proofs via decision procedures and guided reductions
    Lecture Notes in Computer Science, 2002
    Co-Authors: Don Syme, Andrew D. Gordon
    Abstract:

    Operational models of fragments of the Java Virtual Machine and the.NET common language runtime have been the focus of considerable study in recent years, and of particular interest have been specifications and machine-checked proofs of type soundness. In this paper we aim to increase the level of automation used when checking type soundness for these formalizations. We present a semi-automated technique for reducing a range of type soundness problems to a form that can be automatically checked using a decidable first-order theory. Deciding problems within this fragment is exponential in theory but is often efficient in practice, and the time required for proof checking can be controlled by further hints from the user. We have applied this technique to two case studies, both of which are type soundness properties for subsets of the.NET CLR. These case studies have in turn aided us in our informal analysis of that system.

James S. Miller - One of the best experts on this subject based on the ideXlab platform.

  • Euro-Par - Evolving a Multi-language Object-Oriented Framework: Lessons from .NET
    Euro-Par 2003 Parallel Processing, 2003
    Co-Authors: James S. Miller
    Abstract:

    In 2001 Microsoft shipped the first public version of its common language runtime (CLR) and the associated object-oriented .NET Framework. This Framework was designed for use by multiple languages through adherence to a common language Specification (CLS). The CLR, the CLS, and the basic level of the .NET Framework are all part of International Standard ISO/IEC 23271. Over 20 programming languages have been implemented on top of the CLR, all providing access to the same .Net Framework, and over 20,000,000 copies have been downloaded since its initial release.

  • JMLC - Evolving a Multi-language Object-Oriented Framework: Lessons from .NET
    Lecture Notes in Computer Science, 2003
    Co-Authors: James S. Miller
    Abstract:

    In 2001 Microsoft shipped the first public version of its common language runtime (CLR) and the associated object-oriented .NET Framework. This Framework was designed for use by multiple languages through adherence to a common language Specification (CLS). The CLR, the CLS, and the basic level of the .NET Framework are all part of International Standard ISO/IEC 23271. Over 20 programming languages have been implemented on top of the CLR, all providing access to the same .Net Framework, and over 20,000,000 copies have been downloaded since its initial release.

  • Technical Overview of the common language runtime (or why the JVM is not my favorite execution environment)
    2001
    Co-Authors: Erik Meijer, James S. Miller
    Abstract:

    In the last few years many language researchers have moved to the JVM as the delivery vehicle for their languages. Although the JVM is a great target for the Java TM programming language, it is not necessarily a good platform for other languages, especially languages that require semantic features that do not appear in Java TM . In this paper we compare the JVM with the new Microsoft .NET common language Infrastructure (CLI), which has been designed from the ground up to be a multi-language platform.

Nicu G. Fruja - One of the best experts on this subject based on the ideXlab platform.

  • Towards proving type safety of .NET CIL
    Science of Computer Programming, 2008
    Co-Authors: Nicu G. Fruja
    Abstract:

    A crucial role in the Microsoft .NET Framework common language runtime (CLR) security model is played by type safety of the common Intermediate language (CIL). In this paper, we formally prove type safety of a large subset of CIL. To do so, we begin by specifying the static and dynamic semantics of CIL by providing an abstract interpreter for CIL programs. We then formalize the bytecode verification algorithm, whose job it is to compute a well-typing for a given method. We then prove type safety of well-typed methods, i.e., the execution according to the semantics model of legal and well-typed methods does not lead to any run-time type violations. Finally, to prove CIL's type safety, we show that the verification algorithm is sound, i.e., the typings it produces are well-typings, and complete, i.e., if a well-typing exists, then the algorithm computes one.

  • ESOP - Type safety of generics for the .NET common language runtime
    Programming Languages and Systems, 2006
    Co-Authors: Nicu G. Fruja
    Abstract:

    The Microsoft .NET common language runtime (CLR) offers support for generic types and methods. We develop a mathematical specification for the generics design through a type system and a model for the semantics of a subset of bytecode instructions with generics. We formalize the type-consistency checks performed for the subset by the CLR bytecode verifier. We then prove that adding support for generics maintains the type safety of the CLR.

  • Type safety of generics for the .NET common language runtime
    Lecture Notes in Computer Science, 2006
    Co-Authors: Nicu G. Fruja
    Abstract:

    The Microsoft.NET common language runtime (CLR) offers support for generic types and methods. We develop a mathematical specification for the generics design through a type system and a model for the semantics of a subset of bytecode instructions with generics. We formalize the type-consistency checks performed for the subset by the CLR bytecode verifier. We then prove that adding support for generics maintains the type safety of the CLR.

  • A Modular Design for the common language runtime (CLR) Architecture
    2005
    Co-Authors: Nicu G. Fruja
    Abstract:

    This paper provides a modular high-level design of the common language runtime (CLR) architecture. Our design is given in terms of Abstract State Machines (ASMs) and takes the form of an interpreter. We describe the CLR as a hierarchy of eight submachines, which correspond to eight submodules into which the common Intermediate language (CIL) instruction set can be decomposed.

  • Analysis of the .NET CLR Exception Handling Mechanism
    2005
    Co-Authors: Nicu G. Fruja, E Börger
    Abstract:

    We provide a complete mathematical model for the exception handling mechanism of the common language runtime (CLR), the virtual machine underlying the interpretation of .NET programs. The goal is to use this rigorous model in the corresponding part of the still-to-be-developed soundness proof for the CLR bytecode verifier.

Andrew D. Gordon - One of the best experts on this subject based on the ideXlab platform.

  • LPAR - Automating Type Soundness Proofs via Decision Procedures and Guided Reductions
    Logic for Programming Artificial Intelligence and Reasoning, 2002
    Co-Authors: Don Syme, Andrew D. Gordon
    Abstract:

    Operational models of fragments of the Java Virtual Machine and the .NET common language runtime have been the focus of considerable study in recent years, and of particular interest have been specifications and machine-checked proofs of type soundness. In this paper we aim to increase the level of automation used when checking type soundness for these formalizations. We present a semi-automated technique for reducing a range of type soundness problems to a form that can be automatically checked using a decidable first-order theory. Deciding problems within this fragment is exponential in theory but is often efficient in practice, and the time required for proof checking can be controlled by further hints from the user. We have applied this technique to two case studies, both of which are type soundness properties for subsets of the .NET CLR. These case studies have in turn aided us in our informal analysis of that system.

  • Automating type soundness proofs via decision procedures and guided reductions
    Lecture Notes in Computer Science, 2002
    Co-Authors: Don Syme, Andrew D. Gordon
    Abstract:

    Operational models of fragments of the Java Virtual Machine and the.NET common language runtime have been the focus of considerable study in recent years, and of particular interest have been specifications and machine-checked proofs of type soundness. In this paper we aim to increase the level of automation used when checking type soundness for these formalizations. We present a semi-automated technique for reducing a range of type soundness problems to a form that can be automatically checked using a decidable first-order theory. Deciding problems within this fragment is exponential in theory but is often efficient in practice, and the time required for proof checking can be controlled by further hints from the user. We have applied this technique to two case studies, both of which are type soundness properties for subsets of the.NET CLR. These case studies have in turn aided us in our informal analysis of that system.

John Gough - One of the best experts on this subject based on the ideXlab platform.

  • Australian Software Engineering Conference - Virtual machines, managed code and component technology
    2005 Australian Software Engineering Conference, 2005
    Co-Authors: John Gough
    Abstract:

    Abstract machines have been used as an implementation mechanism for programming languages for more than thirty years. In their latest incarnation execution engines based on virtual machines offer "managed execution ". The implications of this change go far beyond the superficial advantages of platform portability and go to the heart of software reliability. In this paper it is argued that managed execution platforms such as the .NET common language runtime and the Java virtual machine form the only reasonable basis for trustworthy component software. There is also an overview of current research in this field, including the vexed question of version evolution.

  • Compiling for the .NET common language runtime
    2001
    Co-Authors: John Gough, K. John Gough
    Abstract:

    From the Publisher: Go "under the hood" with .NET's common language runtime! The definitive book for serious software engineers, compiler developers, and language implementers Mapping any language's key features onto .NET's common object model Comprehensive coverage of Microsoft Intermediate language (MSIL) Includes extensive examples drawn from C# The first practical guide to Microsoft's .NET common language runtime! Compiling for the .NET common language runtime (CLR) is the first book to give software engineers all the details and guidance they need to create full-featured .NET compilers or implement programming languages for the .NET environment. Renowned compiler expert John Gough presents an unprecedented "under the hood" inspection of Microsoft's .NET CLR, illuminating the key concepts underlying Microsoft's new technology and demonstrating exactly how CLR maximizes interoperability across multiple programming languages. The book uses a running example to illustrate its key points(Gough's own open source Gardens Point Component Pascal compiler(which can be used as a basis for sophisticated experimentation. Reviews every element of CLR: Virtual Execution Engine, Base Instruction Set, common Type System, and more Shows how to map a language's key features onto the .NET Virtual Object System's common object model Explains how CLR represents programs at compile time Explores the semantic analysis performed by CLR prior to emitting Microsoft Intermediate language (MSIL) code Provides in-depth coverage of MSIL code generation Covers features needed by alanguages Explores advanced topics such as accessing nonlocal variables and supporting multiple inheritance Includes many examples drawn from Microsoft's new C# language If you need absolute mastery over the .NET CLR, only one book delivers what you're looking for: Compiling for the .NET common language runtime (CLR) by John Gough.

  • Technical Overview of the common language runtime
    2001
    Co-Authors: Erik Meijer, John Gough
    Abstract:

    The functionality of the recently announced Microsoft .NET system is founded on the capabilities of the common language Infrastructure (CLI). Unlike some other recent systems based on virtual machines, the CLI was designed from the start to support a wide range of programming languages. It is also expected that ECMA standardization will make the CLI available on a wide range of computing platforms. This combination of multi-language capability and multiplatform implementation make the CLI an important target for future language compilers. In this paper, the technical details of the CLI are briefly described. To motivate some of the discussion a comparison is made with the Java virtual machine (JVM). The JVM was designed under rather different constraints, making it a much more difficult target for languages other than Java . We also briefly discuss the issues involved in mapping various language constructs to the primitives of the CLI.