2006 Invited Speakers (non-Microsoft)

Gilad Bracha (Sun Microsystems), video

Dynamically Typed Languages on the Java Platform

The Java platform is evolving to better support dynamic programming languages. In this talk, we discuss this evolution, and why and how it is taking place. In particular, we discuss two key issues:

The design of a new byte code, invokedynamic, that would enable more natural and performant mappings of dynamic languages onto the Java virtual machine.

Hotswapping, the ability to modify programs on the fly, and how it may be better suported on the Java platform.

William Cook (UT Austin) video

AppleScript and the Effect of Latency on Programming Languages

One of the recurring themes in my work in industry and academia has been the effect of latency on the design of software systems and programming languages. In the early 90's I designed AppleScript and its environment. It pioneered using a single scripting language with many applications: the language could automate the functionality of applications, and also be embedded within any application. It provided "programming language services" to applications and users who needed them. AppleScript had to deal with the high latency of Mac OS 7, where each interprocess communication took 1/60th of a second. To cope with this situation, we created a model in which a single message could contain a description of a complex operation to be performed by the remote application -- for example, to find all images in a PowerPoint presentation. In this model, applications act like database servers with a fixed schema and lots of custom functionality around that schema. AppleScript isn't object-oriented, so it languished as distributed object models (like CORBA, COM, and RMI) took over. But with the resurgence of service-oriented computing, AppleScript provides useful lessons for how to integrate services into programming languages. More recently I have been working on integration of programming languages and relational databases, inspired by role as architect at Allegis, an enterprise software company. The driving force in this area is also latency: the cost of communicating with the database. User-perceived performance of transactional applications is directly related to the number of queries performed. One of the challenges in design of enterprise applications is supporting modular application development, including modular definition of security policies, while at the same time optimizing database access. I'll discuss the general problem and outline a range of solutions, including some points that could be improved in DLINQ. Finally, I'll describe an even more tightly integrated solution that is the focus of my current work

John Gough (Queensland University of Technology), video

Dealing with Ruby on the CLR

After a career dealing with strongly typed language John Gough has entered the slippery world of dynamic languages with an implementation of Ruby on .NET.

Ruby is a dynamic language with some unusual features. The problem of compiling it for the CLR pose some interesting new issues, as well as the challenges of dynamic languages generally. Ruby is an object oriented language, and allows singleton methods to be attached to individual objects. It also supports a sort of iterator construct and has continuations.

In this talk John will discuss these issues, and describe the implementation strategies that map these constructs to the CLR in the Ruby.NET compiler.

Miguel de Icaza (Novel) video

Shriram Krishnamurthi (Brown University) video

Server-side Web applications have grown increasingly common, sometimes even replacing brick and mortar as the principal interface of corporations. Correspondingly, Web browsers grow ever more powerful, empowering users to attach bookmarks, switch between pages, clone windows, and so forth. As a result, Web interactions are not straight-line dialogs but complex nets of interaction steps.

In practice, programmers are unaware of or are unable to handle these nets of interaction, making the Web interfaces of even major organizations buggy and thus unreliable. Even when programmers do address these constraints, the resulting programs have a seemingly mangled structure, making them difficult to develop and hard to maintain.

These problems are compounded by the need for the robust management of data. Depending on context, both the availability and security of data become paramount. This creates problems of access control, whose policies can themselves be quite subtle and difficult to author correctly.

In this talk, I will discuss the use of ideas from programming languages to improve the expression and robustness of Web applications. I will also allude to the access control and other problems that arise in this context. Most of this work has been done in the context of the PLT Scheme Web server and the Continue conference management application.

2006 Invited Speakers (Microsoft)

Mike Barnett video

Spec#: Why Every Language Should (Will) Have Contracts

Spec# is a programming system that aims to provide programmers with a higher degree of rigor than in common languages today. The Spec# language extends the object-oriented .NET language C#, adding features like non-null types, pre- and postconditions, and object invariants. In addition to static type checking and compiler-emitted runtime checks for specifications, Spec# has a static program verifier. The program verifier translates Spec# programs into verification conditions, which are then analyzed by an automatic theorem prover. In this talk, I will give a demo and overview of Spec#. I will then discuss some aspects of its design and implementation in more detail.

Gary Flake video

How I Learned to Stop Worrying and Love the Imminent Internet Singularity (PPT file)

Anders Hejlsberg video

Language Integrated Query (LINQ) and C# 3.0

Jim Hugunin video

Dynamically Typed Languages on the Common Language Runtime

Bradley Millington video

BLINQ

Don Syme video

Type-safe, scalable, efficient scripting on .NET and beyond

Paul Vick video

Visual Basic 9

With its third version on the .NET Framework, Visual Basic has largely completed the process of moving from its previous home in COM to its new home in the CLR. As a full-fledged language on a premier runtime platform, the inevitable next question is: Now what? This talk will discuss future directions for the Visual Basic language, both from a short-term and long-term perspective. Integrating data access and XML directly into the language is the next major challenge on the horizon, and we will cover some of the interesting insights and challenges that have arisen from this work. We'll also take a look back at Visual Basic's dynamic language and scripting roots to see what lessons from the past might be brought into future versions and look ahead at where the language might be headed in the long run.

2006 Additional Speakers

Bruce Payette (Microsoft) video

Windows PowerShell

Danny Thorpe (Microsoft) video

Paradoxes in Web App Development

Dr. James Purbrick and Cory Ondrejka (Second Life) video

User Creation and Scripting in Second Life

John Lam (ObjectSharp) video

Just Do It - On Being Pragmatic

2006 Accepted Papers

PageXML: An XML based domain specific language for developing web applications video

Mark Cooper

As the internet grows and develops, users are demanding a more interactive and personalised experience. Where once static web pages would have been acceptable, users now expect to actively contribute and take control. These new energetic types of Internet systems are referred to as web applications. Web applications are typically combinations of dynamically generated HTML pages, XML content like RSS, and web services. The increasing complexity of these systems has challenged existing development processes and prompted the development of new languages. Page XML is a new domain specific language that is designed solely for developing web applications. Unlike a general purpose language, a domain specific language is not intended for other tasks. In the same way, Page XML's function is to generate dynamic web content. The highly focused design of Page XML has facilitated the implementation of several powerful features that improve productivity and security. Because the language is small it is easy to learn and use. Page XML is programmed using C# 2.0 and the .NET framework. The runtime is implemented as an HttpHandler web server extension. Several successful commercial websites have been developed in Page XML. These deployments have helped to mature the implementation by streamlining the language and ironing out bugs. The next version will implement features requested by the web application developers who use Page XML.

Cat Programming Language: A Functional Optimization Framework for the MSIL video

Christopher Diggins

Cat is a stack-based pure functional language, inspired by the Joy programming language, which targets the Microsoft Intermediate Language (MSIL). Cat, like Joy, differs from mainstream functional languages in that it is based on the composition of functions rather than the application of functions. This design makes algebraic manipulation of programs trivial, and thus facilitates optimization. This goal of the presentation (http://www.cdiggins.com/cat.ppt ) is to introduce the semantics and syntax of Cat, demonstrate rewriting rules for high-level functional optimizations, and show preliminary performance results for a simple IL Code generator written in C#.

C21.1: Versioning in the TwentyFirst Century video

Chris Sadler, Susan Eisenbach and Alex Buckley

Remember DLL Hell? Your runtime system could only accommodate one version of any given DLL at a time, and which version it was had been chosen by the developer of the last package you downloaded. This doesn't happen in .NET because the GAC lets you keep every assembly version you need. Furthermore, each assembly has been practically hardwired to work only with the service assemblies it was built against. So you won't get your system trashed by those demons of DLL Hell - the careless, the lazy and the maverick developers. On the other hand your component, or application, won't benefit from upgrades or improvements that those service assemblies undergo, so it cannot evolve. Fortunately the hardwiring is not as 'hard' as it seems. Firstly, at loadtime, the CLR consults configuration files associated with the application, the service assemblies and the host machine, to see if any redirection might be indicated. Secondly, the CLR 2.0 implements Type Forwarding whereby whole classes can be migrated from old to new assemblies, leaving behind a pointer for old, unrecompiled apps to follow. All these arrangements seemed a bit 'manual' to us, so our group has been working on tools to utilise these mechanisms automatically and in secure and consistent ways. To push their upgrades out to the client base, developers need to be able to indicate alternative (compatible) versions which the client's app can exploit, an operation we have named 'flexible (dynamic) linking'. Founded on our 2004 Rotor RFP project where metadata typenames could be rendered as variables, our new tool "Flagstaff" achieves flexibility with managed Phoenix plug-ins that generate constraints on these variables in the form of custom attributes. Member constraints - i.e. indications of alternative assemblies and classes from those with which the component was built, but wherein compatible members may be found - are generated by a plug-in that a CLS-compliant compiler can call. Subtype constraints - i.e. indications of alternative assemblies wherein compatible superclasses may be found - require prior data flow analysis because they cannot typically be deduced from a single IR statement. These features in a managed EXECUTION platform help a developer to perform managed EVOLUTION - to ship component upgrades capable of executing in client environments substantially unlike the developer's build environment. These differences could be evolutionary - so the component will execute in a less up-to-date environment, and will 'know' which available service assemblies it can bind to; or they can be exotic - so the component can run on a different 'species' of framework, for example, .NET CF or Mono. At the other end of the supply chain, deployers need to be able to manage the evolution of their applications (and runtimes) rationally and systematically. This could include integrating a component into an environment of assemblies not known to the component's developer. Without requiring the deployer to modify (i.e. hack) the component's metadata, our (client-side) tool grants access to the embedded constraints to search for candidate assemblies in the environment, and, selectively, generate appropriate redirections in the local Application Configuration file. Our group would like to explore the functionality of our existing utilities both with the Microsoft architects and with programmers working on the .NET platform. We would greatly value the opportunity to learn about new evolutionary and exotic deployment issues and hence gather new requirements for our tools.

Zonnon: A New Language and Compiler For .NET

Jurg Gutknecht, Roman Mitin, Eugene Zueff

Zonnon is the name of an ambitious programming language and compiler project carried out at ETH Zurich as a follow-up to their participation with Oberon in the Academic Languages group in the context of Project 7/ 7+. The result is a programming language in the Pascal-Modula-Oberon tradition that is a) close enough to the .NET CLI model to be implementable on top of .NET and b) far enough from the .NET CLI model to be interesting from a compiler integrator's perspective. The language and compiler in their current state are actively used by several educational institutions in Switzerland and in Russia. A number of applications written in Zonnon including educational programs, mathematical libraries, and games are available on http://zonnon.ethz.ch .

Separating Modeling and Simulation Aspects In Framework-Based Modeling of Hardware/Software Systems video

James Lapalme, El Mostapha Aboulhamid

As transistor integration reaches the order of billions, the already significant productivity gap which plagues the Electronic Design Automation (EDA) industry will only widen further. Many are working on the problem from different angles:

Some are working on design flows based on dedicate modeling languages and domain specific modeling languages in order to aid designers model complex systems effectively and at higher levels of abstracts then was previously possible.

Others have taken the path of library/framework-based solutions, which rely on existing mainstream programming languages; these solutions enable the leveraging of existing tools/technologies as well as the possibility to integrate new ones in order to achieve novel design flows.

Others still are looking towards sophisticated EDA/Tools based on proprietary technology in order to offer design-flow out-off-the-box solutions.

None of the current paths seems to be a silver bullet. However, object-oriented framework-based solutions such as SystemC are gaining a great deal of momentum and acceptance by industry. Given this, we started, in late 2003, working on a new .Net based methodology enabling fast and efficient creation of EDA tools for complex systems design. This methodology enabled the design of a new tool called ESys.Net (Embedded system design with .Net). This tool: (1) provides most of the concepts of the presented high-level modeling and simulation solutions, (2) inherits the .Net features such as less error prone modeling, interoperability between tools, annotation for different purposes ((e.g. directing synthesis or hooking to verification tools, creating user friendly HDL syntax, etc.) and (3) preserves comparative performances with existing environments. Despite all the efforts which have been spent on the development of framework-based solutions, as well as the numerous satellite tools which add value to the approach by enabling sophisticated design flow, very few efforts have been spent on the cornerstone task of investigating which software design techniques and technologies should be used to develop effective solutions. Software frameworks are quite difficult to build for their design has tremendous impact on:

their effectiveness,

their ease of use,

their ability to promote good designs,

their capability to be extended easily

The software community, over the past decade, has invested a great deal of effort in the domain of software design; pattern-oriented designs are a fruits of these efforts. Moreover, the opposite needs of the software industry for software which is rapid to design/implement but which is also capable to evolve easily, in order to support unforeseen future needs, has caused the emergence of container-based approach and 3GL programming language which support rapid development. Software design principals such as separation of concerns have also been maturing becoming more present with technologies such as software containers, aspect-oriented programming and strategic programming. By combining the power and advanced capabilities of a modern object-oriented programming language such as C#/.Net, and the flexibility and elegance of modern software design patterns such as Inversion of Control and Proxy, it is possible to create a novel framework-based solution for hardware/software system modeling and simulation. We will present such a solution which permits a clear and unambiguous separation between the modeling, the verification, and the simulation aspects creating perfect separation of concern. The level of separation of concern offered by the solution permits the elaboration and refinement of various simulation engine such as software, distributed and emulation without any modification to system models which were previously created. The main objective of the article is to present how new software engineering technologies may be used to create better framework-based modeling solution. In this work we will present (1) interesting software engineering technologies, (2) show how current solutions lack "separation of concerns" in their design and the discuss the impact, (3) present a novel modeling framework based on the technologies presented earlier, (4) present a simulation framework for the modeling framework and (6) discuss the benefits of the solution regarding simulation, synthesis, and verification of the modeled hardware/software systems.

On Integration of the Classbox Concept in the .NET Framework video

Andre Lokasari, Hua Ming, Markus Lumpe

Bergel et al. have recently proposed classboxes, a new module system that defines a packaging and scoping mechanism for controlling the visibility of isolated extensions to portions of class-based systems. Besides the "traditional" operation of subclassing, classboxes also support the local refinement of imported classes by adding or modifying their features without affecting the originating classbox. Consequently, the classbox concept provides an attractive and powerful framework to develop, maintain, and evolve large-scale software systems and can significantly reduce the risk for introducing design and implementation anomalies in software systems.

Hydra: Translating Source Code from a Unified Code Foundation into Different Target Languages video

Markus Lorez, Alain Schneble

A world leading company for PDF (Adobe Portable Document Format) programming technology delivers reliable PDF products to international customers in virtually all market segments. Their products are currently written in portable C++ and based on their own base class library to fulfil highest security demands. Although interoperability wrappers for other platforms such as .Net and Java are available, customers are increasingly demanding native implementations on these platforms. Due to the size of their applications - millions of lines of code - porting the existing code base is not feasible as it would require maintenance of separate code sets, one for each target programming language / platform. Hence the idea of porting their code foundation once to a new programming language from which native code for different platforms can be generated automatically and repeatedly.