Cross language runtimes

Abstract Interface Types in GNAT: Conversions, Discriminants, and C++

Abstract Interface Types in GNAT: Conversions, Discriminants, and C++. Javier Miranda and Edmond Schonberg.

Ada 2005 Abstract Interface Types provide a limited and practical form of multiple inheritance of specifications. In this paper we cover the following aspects of their implementation in the GNAT compiler: interface type conversions, the layout of variable sized tagged objects with interface progenitors, and the use of the GNAT compiler for interfacing with C++ classes with compatible inheritance trees.

The addition of interface types, of the type found in Java, to Ada2005 presented compiler writers with an implementation challenge. This is a third paper in a series describing the implementation of interfaces in the GNAT Ada compiler (an earlier paper dealt with synchronized interfaces, an interesting special case).

The present paper deals mainly with issues caused by interface type conversions, and the related data layout issues. Of special interest is section 6 which shows how to write a C++/Ada multi-language program, in which method calls can be dispatched across language boundaries. Handling the multiple inheritance in the C++ code in this example is possible because the base classes have only pure virtual functions.

Misc News

I'm back... Going through my RSS feeds, two items caught my attention:

Tim Bray: Charles Nutter and Thomas Enebo, better known as “The JRuby Guys”, are joining Sun this month.

Jon Udell: Why argue about dynamic versus static languages when you can use both? Which discusses, among other things, why the first three versions of the IronPython compiler were written in Python, but today it's written in C#.

eWeek: Sun Digging Deep for Dynamic Language Support

A report on Gilad Bracha's presentation at Lang.NET 2006 entitled "Dynamically Typed Languages on the Java Platform".

We discussed several of the ideas mentioned, but I think we should continue to follow this story.

Gilad Bracha: Will Continuations continue?

There are a variety of reasons why we haven’t implemented continuations in the JVM. High on the list: continuations are costly to implement, and they might reek havoc with Java SE security model. These arguments are pragmatic and a tad unsatisfying. If a feature is really important, shouldn’t we just bite the bullet?

Many here will not like the answer.

This issue was discussed here mnay time, of course, but I think it is of interest to know what the people at Sun are thinking...

Tim Bray's response is also worth checking out, if only for the sake of this sound bite: The worst AJAX apps are like bad Nineties VB.

Lang .NET 2006

The .NET Programming Languages And Compilers Symposium: Lang .NET 2006

Seattle, Washington, United States, August 1-3, 2006

Call for contributions

Lang .NET 2006 is a forum for discussion of programming languages, managed execution environments, compilers, multi-language libraries, and integrated development environments. It provides an excellent opportunity for programming language implementers and researchers from both industry and academia to meet and share their knowledge, experience, and suggestions for future research and development in the area of programming languages.

Lang.NET 2006 will be held from August 1-3 on the Microsoft corporate campus in Redmond immediately after OSCON 2006 in Portland.

The conference program will focus on the pragmatics and experience of designing languages, implementing compilers, and building language tools that target managed execution platforms such as the .NET CLR and other implementations of the ECMA CLI. That is, on how to get real programming tools into the hands of real programmers to solve real problems, and on how researchers and practitioners can learn from each other to make this happen.

If you are a language designer, compiler writer, or tool builder in industry or academia, Lang.NET 2006 is a unique opportunity to directly interact with the architects of Microsoft language platforms. Microsoft language technologist will be very active participants in the conference but at least 50% of the program is reserved for presentations by non-Microsoft employees. Each day is concluded with a panel debate. In the evenings there will be ample opportunity for networking during the social events and dinners.

The program committee invites 1-page abstracts of experience reports, demonstrations and presentations related to programming language and compilers to be given at the symposium. There will be two types of talks:

  • 10 minute lightning talks
  • 30 minute regular talks

We are looking for lively presentations that are provocative, stimulating and educational. Submit your proposals at here.

Areas of interest include but are not limited to:

  • Dynamic languages and scripting
  • AJAX and ATLAS
  • Domain specific languages
  • Functional languages
  • Object-oriented and aspect-oriented programming
  • Web-services and mobile code
  • Libraries
  • Language-Integrated Query (LINQ)
  • Compiler frameworks
  • Garbage collection
  • JIT compilation
  • Visual Programming
  • Success and failure stories
  • Non-standard language features and implementation techniques
  • Tools and IDE support


Submissions dueMay 15, 2006
Notification of acceptanceJune 1, 2006

Conference chair

Thottam Sriram, Microsoft

Program committee

  • Erik Meijer, Microsoft  (program chair)
  • Allen Wirfs-Brock, Microsoft
  • Martin Maly, Microsoft
  • Amanda Silver, Microsoft
  • Brian Tyler, National Instruments
  • Paul Austin, National Instruments
  • Stephen Gennard, Microfocus
  • Robert Sales, Microfocus
  • Rene Rodriguez, ASNA
  • Roger Andrews, Synergex
  • Kasper Osterbye, IT University Copenhagen


I just noticed this project and since we like discussing language-in-a-language projects, I thought I'd mention it.

It seems that they are almost ready to run Rails. Now that's going to be cool!

Class decorators in Python

Guido resisted the few calling for class decorators, because there wasn't a clear use case that wasn't more readable done another way... [but] Guido has conceded, class decorators will make it into some future version of Python.

More + links: here.

Jon Udell: Multi-language runtimes

Not a technical perspective, but one that might be important none the less,

First, will Sun help the Java VM realize its multi-language potential? Second, will the dominant .NET VM for non-Windows platforms be a Microsoft product (WPF/E) or an open source project (Mono)?

An Overview of the Singularity Project

Singularity is a research project in Microsoft Research that started with the question: what would a software platform look like if it was designed from scratch with the primary goal of dependability? Singularity is working to answer this question by building on advances in programming languages and tools to develop a new system architecture and operating system (named Singularity), with the aim of producing a more robust and dependable software platform. Singularity demonstrates the practicality of new technologies and architectural decisions, which should lead to the construction of more robust and dependable systems...
Singularity... starts from a premise of language safety and builds a system architecture that supports and enhances the language guarantees.

An interesting overview of what sounds like an intersting project.

The choice of implementation language is also interesting:

Singularity is written in Sing#, which is an extension to the Spec# language developed in Microsoft Research. Spec# itself is an extension to Microsoft’s C# language that provides constructs (pre- and post-conditions and object invariants) for specifying program behavior. Specifications can be statically verified by the Boogie verifier or checked by compiler-inserted run-time tests. Sing# extends this language with support for channels and low-level constructs necessary for system code....integrating a feature into a language allows more aspects of a program to be verified. Singularity’s constructs allow communication to be statically verified.

An interesting aspect is the support for meta-programming, which is implemented in an unusal manner:

Compile-time reflection (CTR) is a partial substitute for the CLR’s full reflection capability. CTR is similar to techniques such as macros, binary code rewriting, aspects, meta-programming, and multi-stage languages. The basic idea is that programs may contain place-holder elements (classes, methods, fields, etc.) that are subsequently expanded by a generator.

Many other intersting design decisions are discussed in the paper (e.g., various DbC facilities), so do check it out.


Gilad Bracha:

Basically, it will be a lot like invokevirtual (if you don’t know what that is, either open a JVM spec and find out, or stop reading). The big difference is that the verifier won’t insist that the type of the target of the method invocation (the receiver, in Smalltalk speak) be known to support the method being invoked, or that the types of the arguments be known to match the signature of that method. Instead, these checks will be done dynamically.

There will probably be a mechanism for trapping failures (a bit like messageNotUnderstood in Smalltalk).

The goal: Improve the support for dynamically type checked languages on the JVM, of course.

XML feed