Lambda the Ultimate - Cross language runtimes

JVM Language Summit report

Sat, 27 Sep 2008 02:12:01 -0400

Tim Bray reports about half of the JVM language summit. Among the things he discusses are Clojure, PHP and JVM/CLR cross-pollination.

Google V8 JavaScript Engine

Tue, 02 Sep 2008 21:25:51 -0400

You can read the docs and download the C++ source here.

V8 is supposedly the main added value of Chrome, the newly announced Google browser.

Our discussion of the Chrome announcement enumerates some of the features of V8.

Proceedings of the 2008 LLVM Developers' Meeting

Fri, 15 Aug 2008 15:03:30 -0400

The proceedings of the 2008 LLVM Developers' Meeting have been posted. The presentations included some overviews of various LLVM subsystems and internals and a few projects targeting the LLVM. Previous meeting's proceedings are also available.

Technometria: Google Web Toolkit

Mon, 29 Oct 2007 00:53:56 -0400

Phil Windley Technometria podcast is dedicated to the Google Web Toolkit. The guest on the show is Bruce Johnson a Tech Lead of GWT.

The show is very good, and more technical than usual. Many themes that are near and dear to LtU are discussed. Here are some pointers:

Bruce talks at length about the advantages of compiling from Java to JS, many of which arise from Java's static typing. He mainly talks about optimizations, but also about how static typing helps with tools in general (IDEs etc.). This was a subject of long and stormy debates here in the past.

The advantages, from a software engineering standpoint, of building in Java vs. JS are discussed. This is directly related to the ongoing discusison here on the new programming-in-the-large features added to JS2. I wonder if someone will write a compiler from Java/GWT to JS2 at some point, which will enable projects to move to JS2 and jump ship on Java all together.

Bruce mentions that since JS isn't class-based, and thus doesn't directly support the OO style many people are used to, there are many ways of translating common OO idioms into JS. This is, of course, the same type of dilemma the Scheme community has about many high level features. Cast as a question on OOP support the questions becomes is it better to provide language constructs that allow various libraries to add OO support in different ways, or to provide language support for a specific style. The same can be asked about a variety of features and programming styles, of course.

Finally, Bruce mentions that as far as he knows no one thought about something like GWT before they did. Well, I for one, and I don't think I was the only one, talked many times (probably on LtU) about Javascript as a VM/assembly language of the browser, clearly thinking about JS as a target language. I admint I wasn't thinking aobut compiling Java... But then, I am not into writing Java, so why would I think about Java as the source language...

JVM Languages group

Thu, 09 Aug 2007 15:24:01 -0400

Charles Nutter:

If you are interested in the future of non-Java languages on the JVM, you should be on this list. Yes, we talk about a lot of JVM lanuage implementation challenges, we discuss compilers and stack frames and call-site optimizations, but we also talk about features peripheral to language implementation like package indexing and retrofitting Java 5+ code. We need your help.

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

Sat, 14 Apr 2007 11:52:31 -0400

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

Sat, 09 Sep 2006 04:48:14 -0400

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

Fri, 04 Aug 2006 09:28:54 -0400

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?

Sat, 20 May 2006 07:57:01 -0400

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

Tue, 18 Apr 2006 14:08:16 -0400

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

Dates

Submissions due	May 15, 2006
Notification of acceptance	June 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

JRuby

Wed, 12 Apr 2006 07:51:34 -0400

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

Thu, 30 Mar 2006 10:48:05 -0500

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

Mon, 27 Feb 2006 10:16:31 -0500

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

Fri, 28 Oct 2005 10:54:33 -0400

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.

Invokedynamic

Thu, 29 Sep 2005 17:06:20 -0400

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.