2009 Speakers
Lars Bak
Lars is a software engineer working for Google in Aarhus Denmark. All he has done the last 23 years is implementing virtual machines for object-oriented languages. Here are some: Beta, Self, Strongtalk, Sun's HotSpot and CLDC HI, OOVM Smalltalk, and V8. Lars joined Google in the fall of 2006 and he has been responsible for V8.
JavaScript - How Fast Can You Go? (video)
Scalability and performance are the big challenges when implementing a JavaScript engine for a web browser. We have addressed this in the V8 engine used in Google Chrome by applying classic object-oriented implementation techniques such as on-the-fly code generation, inline caching, precise generational garbage collection, and snapshotting. This talk will discuss the techniques, the lessons learned, and give an outlook on how far we can push scalability and performance for JavaScript.
Gilad Bracha
Gilad Bracha is the creator of the Newspeak programming language. Previously, he was a Distinguished Engineer at Cadence, and a Computational Theologist and Distinguished Engineer at Sun. He is co-author of the Java Language Specification, and a researcher in the area of object-oriented programming languages. Prior to joining Sun, he worked on Strongtalk, the Animorphic Smalltalk System. He received his B.Sc in Mathematics and Computer Science from Ben Gurion University in Israel and a Ph.D. in Computer Science from the University of Utah.
Newspeak's Hopscotch IDE (video)
Hopscotch is the name of both Newspeak's IDE, and the GUI application framework underlying it. Hopscotch is based on a notion of fragment combinators that provide an internal DSL for GUIs, embedded in Newspeak. The framework supports a navigation paradigm that combines advantages of web based and traditional GUIs. We'll demonstrate all this via the Hopscotch IDE and show\ how it benefits from being implemented in a dynamic language
Keith Curtis
I worked as an SDE at Microsoft for 11 years, left in 2004, accidentally discovered Linux, and just finished a book about the future of software, which ended up talking a lot about tools.
Survey of Tools and Languages (video)
This light talk will start with a brief proof of why C and C++ must be killed, an idea not widespread in the software community. Then it will give a survey of the state of the important languages in the Linux community.
Manuel Fahndrich
Manuel Fahndrich is a senior researcher at Microsoft. He is passionate about code analysis techniques and getting tools onto programmer's desktops. Before working on Code Contracts, he was designing and implementing the Sing# programming language for Singularity. Prior projects include Spec#, the Standard Annotation Language (SAL), Fugue, and Vault.
Code Contracts: Specification and Verification for .NET Developers (video)
Over the last few years Microsoft Research has been working on bringing simple and pragmatic program specification, aka Code Contracts, to programming languages targeting the Microsoft .NET platform. Contracts document programming assumptions in a machine discoverable form. Contracts are targeted at the general developer, not the verification enthusiast. It is thus important to use a single form of specifications that meets three simultaneous goals:
First and foremost, contracts serve as documentation. They must be as readable as possible.
Second, contracts should be executable. This motivates writing specifications for testing and immediate perceived benefit, without consideration of static verification.
Finally, contracts should help in static defect discovery and reduce false positives.
Our specification approach is language-agnostic in that we use idiomatic code written in the developer's source language to express preconditions, postconditions, and object invariants
Joshua Goodman
Joshua Goodman is Group Program Manager for the Common Language Runtime team. Joshua has had a large variety of roles. Before Microsoft he was a software developer, followed by years at Harvard where he earned a Ph.D. in the wrong kind of languages (natural languages). He joined Microsoft Research where he studied everything from language modeling (the wrong kind again) to spam filtering to machine learning. Currently, he manages people who manage people who program manage people who write programs to help people write programs to help people write programs.
What’s New in CLR 4 for Languages (video)
Over 20 different programming languages run on top of the Common Language Runtime (CLR), including recent additions like F#, IronPython and IronRuby. We continue to innovate on this core platform, adding features both for developers, and for language implementers. Our newest release, CLR 4, is our largest release since 2005. There are too many new features to cover in a short talk, so I’ll focus on those that will be most interesting to language designers. First, we added several new types, including Tuple, BigInteger, and Complex. Tuple is a good example of a feature that seems very simple, but becomes interesting when you have to design it to work across different languages that may or may not natively support the type. Fortunately, those few types and a few minor improvements to the runtime were all that we needed to do to support functional languages like F#. We’ve also made changes to our threadpool that make it better at taking advantage of multiple processors – this should help developers of parallel languages. We made a large number of smaller changes, including a new garbage collection mode, Background GC, that reduces latency. There is a new exception type, Corrupted State Exceptions, designed to prevent a common developer mistake. And we’ve added support for type equivalence across libraries; in combination with related work, this makes the experience of deploying COM addins much lower cost.
Peli de Halleux
Pex (video)
Anders Hejlsberg
Co- and Contra-variance (video)
Luke Hoban
Tales from the F# productization (video)
This talk touches on some of the fun, challenging and unexpected experiences we’ve had during the ‘productization’ of F# over the last 18 months.
Roman Ivantsov
Roman Ivantsov is a software developer with Tyler Technologies with more than 20 years of experience in industrial software development. He is a coordinator for Irony open-source project.
Irony - .NET Language Implementation Kit (video)
Irony is an innovative open-source project with the purpose of creating an integrated, “all-in-c#” framework for implementing languages on .NET platform. The presenter will describe core Irony features that can make it a tool of choice for a wide range of tasks - from building industrial-strength compilers to in-house DSL implementations. The speaker will talk about current project status, latest advancements, future plans, and will present other projects that use Irony technology.
Using IronPython 2.0 as a script engine in MS Dynamics AX (video)
Microsoft Dynamics AX is a complete ERP solution for a wide range of commercial industries. Tyler Technologies and Microsoft are collaboratively developing a new version of Dynamics AX specifically geared for the public sector. One important requirement was a flexible and easy-to-use facility for calculating fees and charges for various services provided by local governments. The feature team implemented it using IronPython as an embedded scripting engine, allowing end-users to create simple Python scripts that would be invoked automatically when a user creates an invoice for services. The presenter will discuss his experience during the implementation and demonstrate the feature using the Dynamics AX application.
David Langworthy
Modeling: Transformation and Constraints (video)
This talk introduces all the concepts of the Oslo Modeling Language: M. You will see how to create a language for a domain. Shape the resulting data into a useful form. Send the data to XML, CLR, and SQL. Then write transformations and constraints.
Amanda Laucher
Concurrency in F# (video)
F# is Microsoft’s multi-paradigm language which sets out to solve more functional programming types of problems in the .Net ecosystem. Perhaps you’ve seen some of the basic syntax which although interesting, it’s now time to check out what people will actually be doing with the language. I’ve been working with a client to implement F# for handling more than factorials and Fibonacci numbers. I’ll show how to do concurrent programming in an actual enterprise, with legacy code interaction and all.
Tim McFarlane
Tycho (video)
Erik Meijer
LiveLabs Reactive Framework (video)
According to Wikipedia, “Abstraction is the process or result of generalization by reducing the information content of a concept or an observable phenomenon, typically in order to retain only information which is relevant for a particular purpose.” Unfortunately, in the past 50 years or so of Computer Science, we have abstracted from the wrong details. In particular, the mainstream interactive, imperative sequential computational model takes a deep dependency on strict evaluation order, exemplified by the evil semicolon “;”, thereby ignoring latency and to a large extent the possibility of failure (which can be considered as a form of latency). Now that effectively all computation has become reactive distributed and concurrent, the traditional sequential imperative programming abstraction has run out of steam as a model for the top-level composition of programs and seriously hampers future progress in our field.
Joe Mistachkin
Joe Mistachkin (pronounced "miss-tash-kin") is a software engineer and one of the maintainers of Tcl/Tk. He is also the author of the TclBridge component and the Eagle scripting language. He has been working in the software industry since 1994.
Eagle: Tcl Implementation in C# (video)
Eagle (Extensible Adaptable Generalized Logic Engine) is an implementation of the Tcl scripting language for the Common Language Runtime (CLR). It is designed to be a universal scripting solution for any CLR based language, and is written completely in C#. Superficially, it is similar to Jacl, but it was written from scratch based on the design and implementation of Tcl 8.4. It provides most of the functionality of the Tcl 8.4 interpreter while borrowing selected features from Tcl 8.5 and the upcoming Tcl 8.6 in addition to adding entirely new features.
Wesner Moise
Wesner Moise is a founder of SoftPerson, LLC, which develops desktop applications that employ Symbolic AI. Wesner previously worked as a software developer in the Microsoft Excel group at Microsoft from 1994 to 2000 and writes a blog at wesnerm.blogs.com, before pursuing an MBA in entrepreneurial studies.
Static Analysis (video)
Part research tool and part commercial application, NStatic is a static analysis tool. It uses primarily a computer algebraic approach to checking for errors, but also incorporates ideas from theorem proving, sat-solving, and constraint solving. This talk goes into the details behind the design decisions and implementation of a static analysis tool.
Ted Neward
Ted Neward is a Principal Consultant with ThoughtWorks, an international enterprise consulting firm. He consults, writes, presents and mentors on both the Java and .NET platforms, and has published a number of books in both areas. His current areas of study include languages, virtual machines, and large-scale enterprise systems. He resides in the Pacific Northwest
Objective C# (video)
I want to examine what the symposium members would imagine a language mixing the message-passing nature of Objective-C with the underlying C# language would look like, and (hopefully) present the results the following year, at Lang.NET 2010.
Intro to a Visual Studio Language Service (video)
“Busy Lang.NET Developer’s Intro to a Visual Studio Language Service” In this quick talk, I’ll go over the basic details of creating a Visual Studio Language Service, using a simple example as a backdrop and hopefully inspiring attendees to take that next step around their language by integrating it inside of VS.
Jason Olson
Are modern object-oriented languages actually object-oriented? (video)
There are a lot of modern languages out there like C#, Visual Basic, Java, C++ (and so on) that like to call themselves object-oriented languages. But are they actually object-oriented? Has the concept of an object-oriented language actually been ruined by these modern languages? Or is object-oriented purity only for academia?
F# Parsing (video)
Tomas Petricek
Tomas is a student at Charles University in Prague and author of “Real World Functional Programming” book, which introduces functional approach to programming using F# and C#. He is active in the .NET and F# community, and he has been Microsoft MVP since 2004. Recently, he was involved in the Phalanger project where he worked on Silverlight support and improving C# to PHP interoperability. He also spent three and six months doing internships at Microsoft Research in Cambridge. During the first visit, he was working on a unified and type-checked approach to client/server web application development. More lately, he started working on extending the F# language to simplify concurrent and reactive programming. More information about his projects and his articles can be found at his website: http://tomasp.net.
Reactive pattern matching for F# (video)
The reactivity of an application is the key concern of the user. When writing reactive applications, we need to handle user interaction, but also spawning and completion of asynchronous operations (such as web service requests) and inputs from concurrently executing computations. In this talk, we’ll look at a simple extension for the F# language that adds generalized pattern matching to F# computation expressions. We’ll use this extension for providing easy syntax for many reactive and concurrent programming techniques. In particular, we’ll look how pattern matching on multiple sources of events makes it possible to clearly encode the logic of the application control flow. (This is a project done with Don Syme during an internship at Microsoft Research Cambridge)
Joshua Phillips
Joshua Phillips is a Program Manager on Microsoft’s Parallel Computing Platform. At present, he works on current and incubation technologies concerned with shared-state and safety in parallel computing including the coordination data structures of .NET 4.0 and Axum.
Axum: A .NET Coordination Language for Safe Concurrency (video)
Axum is an incubation project from Microsoft’s Parallel Computing Platform that aims to validate a safe and productive parallel programming model for the .NET framework. It’s a language that builds upon the architecture of the web and the principles of isolation, agents, and message-passing to increase application safety, responsiveness, scalability and developer productivity. Other advanced concepts we are exploring are data flow networks, asynchronous methods, and type annotations for taming side-effects. We currently have a working prototype with basic Visual Studio integration and a few demonstrations of working code.
Jim Purbrick
The Second Life Cloud: Running 10M Untrusted, User Generated Applications On The CLI In A Virtual World the Size Of Denmark (video)
Since we talked about scripting in Second Life at Lang.NET 2006 the world has grown from 900 to 1800 square kilometers, peak concurrency has grown from under 10,000 to over 86,000 and 10M of the 68M running user generated, untrusted scripts have been converted to run on the CLI.
Over the same period plaforms like Google's App Engine have made running sandboxed, untrusted code in the cloud a hot topic. This talk will discuss the issues inherent in building a sandbox for untrusted code using the CLI and the solutions we implemented for Second Life.
Karl Prosser
Building DSLs and language enhancements with PowerShell (video)
Keith Robertson
Mr. Robertson began consulting in 1992 on Smalltalk projects. In 2000 he switched to EAI consulting, using Java with extreme reluctance. He’s always enjoyed developing programmer tools, such as reusable frameworks and compilers, and he hopes to do it for a living when he grows up. Mr. Robertson holds a Master’s Degree in Computer Science.
The SABLE Programming Language (video)
Smalltalk has been praised as the best language expression of OO concepts, and many rank it as a favorite language, but the C-based languages “won.” Notably, Java rode to stardom with its brilliant marketing as “the language of the Internet.” Why didn’t Smalltalk fill that role? Could it have? This talk will briefly discuss the drivers that led to the development of SABLE, a Smalltalk-derived language which supports all features of .NET with C# performance. It will describe the major language features: Smalltalk readability with type safety, Nil tracking, bidirectional type inference, inlined functions, #Symbol usage, and MyType.
John Rose
Method Handles and Interface Injection in the JVM (video)
The Da Vinci Machine Project has been adding new language-neutral features to the Java managed runtime to support user-definable linkage (in the "invokedynamic" instruction), type-safe class extension, tailcalls, and continuations. We will outline these features and their status. Adding invokedynamic required the introduction of something like function pointers, which the JVM calls "method handles". Time permitting, we will detail the design of method handles, discuss their implementation, compare them to C# delegates, and show how they can be used to implement various language features.
Jeffrey Sax
Jeffrey Sax has been writing numerical software for nearly two decades. He is founder and president of Extreme Optimization, a provider of numerical libraries for the .NET platform. He has degrees in numerical computing and theoretical physics.
Numerical Computing with the DLR (video)
Dynamic languages are expressive and need minimal specifications. These advantages make them ideally suited for interactive technical computing environments. The languages in Mathematica®, Matlab®, GNU Octave, R and others are all dynamic. In this talk we will explore M#, an array based language built on top of the Dynamic Language Runtime. We will discuss some of the challenges and pleasant surprises we encountered during its development.
Jeffrey Snover
Jeffrey Snover is a Distinguished Engineer in the Management and Services Division, where he is an Architect for Windows Manageability and Automation. Snover is the inventor of Windows PowerShell, an object-based distributed automation engine, scripting language, and command line shell. Snover joined Microsoft in 1999 as divisional architect for the Management and Services Division, providing technical direction across Microsoft’s management technologies and products.
Prior to Microsoft, Snover has 19 years of industry experience with a focus mainly on management technologies and solutions. He was an architect in the office of the CTO at Tivoli and a development manager at NetView. He has worked also as a consulting engineer and development manager at DEC, where he led various network and systems management projects. Snover held 8 patents prior to joining Microsoft, and has registered 30 patents since. He is a frequent speaker at industry and research conferences on a variety of management and language topics.
PowerShell’s Universal Code Execution Model (video)
Universal Code Execution model – the ability to control where and how lambdas execute, Remoting (fan-out, fan-in, interactive REPL) and a mobile object model, Restricted execution environments and DSLs/DSVs, Advanced functions, stoppable pipelines, splatting and proxies, Transactional scripts Modules
Emmanuel Stapf
Emmanuel Stapf joined Eiffel Software in 1996 and has risen through the ranks to become Eiffel's Lead Engineer. He is responsible for providing direction to the software development team and shaping the future of the Eiffel language. He has been in charge of the design and implementation of a number of major components of the EiffelStudio environment and he has led the work on having .NET as one of the supported platform for the Eiffel compiler. Emmanuel is an active member of the ECMA TC49-TG3 (CLI) and ECMA TC49-TG4 (Eiffel) standardization committee
Eiffel: putting an end to null pointer dereferencing in a .NET language (video)
The major problem threatening the execution of programs in a statically typed object-oriented language is the "void call" (or "null pointer dereferencing"), happening whenever the execution triggers a call x.f (...) where x is void (null). This is a major source of crashes and a grave threat to software reliability. In a recent presentation, Tony Hoare calls the introduction of the void reference his "billion dollar mistake". In recent years, attempts to ban the void call have appeared in research languages, notably Spec#. Over the past four years, a void-safe mechanism has been included in Eiffel and included into the ISO Eiffel Standard. The mechanism integrates void safety (the guarantee of no run-time void calls) into the type system. The challenge was to obtain a total guarantee of void safety while preserving the power of expression of the language, not adding undue complication to the programming task, and retaining compatibility with existing code. In addition, the solution had to work in the .NET implementation of Eiffel. The talk describes the essentials of the solution, based on the concept of "attached type", and particularly explains the pragmatic issues that we had to address, in particular converting libraries to void safety and providing users with a smooth transition from their existing code to the full void safety of current Eiffel.
Jack Tilford
The Visual Studio 2010 Editor (video)
A brief introduction to the new Visual Studio 2010 editor and how it can be extended.
Mads Torgersen
C# 4.0 Dynamic (video)
Herman Venter
Herman Venter is a Research Software Engineer in the Research In Software Engineering (RISE) group in the Microsoft Research Redmond laboratory, where he is the local programming language enthusiast and compiler writer. Prior to joining MSR, Herman worked in the Developer Division, initially on JScript .NET. After completing the JScript .NET project Herman worked in collaboration with MSR on Comega and Spec#. Since joining MSR on a full time basis, Herman has worked on Spec#, the Verifying C compiler, CCI version 2 and lately on JScript again (initially in the context of the Gazelle browser project). Before coming to Microsoft, Herman was a professor of Computer Science at the University of Port Elizabeth in South Africa.
The MSR Common Compiler Infrastructure project (CCI) (video)
CCI is a set of libraries containing code used that compiler front ends tend to have in common. It can also be used for creating post compilation tools operating on CLR assemblies. The first version of CCI was used to create the MSR Spec# compiler, and the ILMerge tool. It is also the library that is at the heart of FxCop. The second version of CCI has been used to create the MSR Verifying C compiler (vcc) and is also used for Managed Code Contracts and various post compilation tools in the CLR. This version of CCI has now become an open source project on CodePlex. This talk gives an overview of what is on CodePlex, what can be done with it as it is now, and how it can grow with the aid of community involvement.
Paul Vick
Modeling: Language and Data (video)
Philip Wadler
Links: Web programming without tiers (video)
Links is a programming language for web applications that generates code for all three tiers of a web application from a single source, compiling into JavaScript to run on the client and into SQL to run on the database. Links supports rich clients running in what has been dubbed Ajax style, and supports concurrent processes with statically-typed message passing. Links is scalable in the sense that session state is preserved in the client rather than the server, in contrast to other approaches such as Java Servlets or PLT Scheme. Client-side concurrency in JavaScript and transfer of computation between client and server are both supported by translation into continuation-passing style.
Frank Wierzbicki
Jython and the JVM (video)
Jython is a Java implementation of the high-level, dynamic, object-oriented Python programming language, which seamlessly integrates with the Java platform, allowing you to run Python on any Java platform. I will give an overview of Jython's implementation, with a focus on the current challenges regarding method dispatch, and how we can use "invokedyanamic" and "method handles" coming in JDK 7 to make the implementation better.
Matthew Wilson
Matthew is a programmer and language enthusiast. He works as a contractor on both .Net and Perl software.
Bootstrapping Perl 6 [on a new language/VM] on .Net (video)
Survey of progress implementing a Perl 6 interpreter targeting .Net. Survey of the (surprise!) new language/VM (running on top of .Net) used to implement the ongoing Perl 6 implementation.