A Dynamic Language Runtime (DLR) [reprint]

Today, at mix 07, we announced a new level of support for dynamic versions on. NET that we're calling the DLR.

From the beginning, Microsoft's. NET framework was designed to support a broad range of different programming

AGEs on a Common Language Runtime (CLR). The CLR provides shared services to these programming ages ranging from

World-class GC and JIT to a sandboxed security model to Tools Integration for debugging and profiling. Sharing

These features has two huge benefits for versions on the CLR. First, it's easier to implement a language because

Lots of difficult engineering work is already done for you. Second, and more importantly, these ages can

Seamlessly work together and share libraries and frameworks so that each language can build on the work of

Others.

The CLR has good support for dynamic languages today. IronPython-1.0 demonstrates this. The new dynamic Language

Runtime (DLR) adds a small set of key features to the CLR to make it dramatically better. It adds to the platform

A set of services designed explicitly for the needs of dynamic versions. These include a shared dynamic type

System, standard hosting model and support to make it easy to generate fast dynamic code. With these additional

Features it becomes dramatically easier to build high-quality Dynamic Language implementations on. NET. More

Importantly, these features enable all of the dynamic versions ages which use the DLR to freely share code with other

Dynamic versions as well as with the existing powerful static versions on the platform such as VB. NET and C #.

The DLR is about giving you the best experience for your language-true to the language, excellent tools,

Performance and seamless integration with a wealth of libraries and platforms. The essential benefits of the DLR

Are about sharing. It lets language implementers share standard features rather than rebuilding them from scratch.

This lets them focus on the features that make a given language unique rather than on reinventing yet another GC

System. It lets developers share Code regardless of the language the code is implemented in and to use whatever

Language they prefer regardless of the language preferred by the environment they want to run in. Coupled with

Silverlight 1.1 platform announced today, it even lets versions share a sandboxed security model and browser

Integration. This means that developers building browser-based applications can now use their preferred language

Even for client-side code.

We're re initially building four education ages on top of the DLR-Python, JavaScript (ecmascript 3.0), Visual Basic and

Ruby. we shipped today both Python and JavaScript as part of the Silverlight 1.1alpha1 release today. John Lam and

I will be demoing all four languages, including Vb and Ruby, working together during our talk tomorrow.

In addition to the Silverlight release, we 've also made the full source code for both ironpython and all of the new

DLR platform code available on codeplex under the BSD-style Microsoft Permissive license. All of that code can be

Downloaded today as part of the ironpython project at codeplex.com/ironpython. If you want to know more about

DLR, you shoshould feel free to download the Code. However, you shoshould understand that this is a very early release

Of these bits and we still have significant work left to do including refactoring, design changes, performance

Tuning-not to mention documentation.

For the short term, our focus is on using a small number of versions to drive the first wave of DLR Development

Where we can work closely and face-to-face with the developers in order to iron out the worst kinks in the DLR

Design. After this initial phase, we want to reach out to the broader language community. If you're building

Language on top of. NET and are interested in supporting dynamic language features then we want your feedback on

The DLR. However, I 'd discourage you from trying to implement on top of the DLR today. I don't want you to get

Frustrated trying to work with these really early bits and then not be interested in working with us when we're

Better prepared to engage with the language community. We plan to kick off a broader engagement with language

Implementers at the upcoming lang.net conference in three months-at the end of July. This will be the best place

To really engage with the DLR and let us know what we got wrong.

In the meantime, I'll be using this blog to post our design notes for the DLR as they're written and any feedback

You have on the design is welcomed. Tomorrow I'll talk more about the shared dynamic type system and the "One True

Object ".