Lang.NEXT 2012 Sessions (HD)

We are engaged in the design of a new object-oriented educational programming language called Grace.Our motivation is frustration with available languages, none of which seems to be suited to our target audience: students in the first two programming courses who are learning to program in an object-oriented style.Grace aims to be significantly simpler than existing languages, and yet make it possible to write powerful libraries that effectively extend the language. Grace achieves this by using blocks (representing functions) to define all its "built-in" control structures, so each new kind of data object defined in a library can be equipped with the control structures necessary to make it appear "first class".Grace also supports, but does not require, static type checking. This makes it possible to use Grace as a dynamically typed language, to start with dynamic types and add static types later, or to teach static types from the beginning.We will discuss the design principles behind Grace, and the current state of the language design, as well as soliciting your feedback. For more information, see http://www.gracelang.org.

R is a strange, deeply flawed language that nevertheless has an enthusiastic and rapidly growing user base. What about R accounts for its popularity in its niche? What can language designers learn from R's success?

The D Programming Language combines modeling power, modern convenience, and native efficiency into one powerful language. D embodies many new ideas in programming languages along with traditional proven techniques.

The next iteration of the ECMAScript standard, expected to be ECMAScript 6, has been making solid progress since the completion of ES5 in 2009. Targeting standardization in 2013, ES6 is on track to bring significant new runtime and syntax features to one of the world's most broadly used programming languages. The addition of proxies, modules, private names, and weak maps provide runtime capabilities to enable new kinds of libraries. Syntax for block scoped bindings, destructuring, string interpolation and lambdas give simpler syntax to some common JavaScript coding patterns. This talk will quickly survey several of the most significant new areas of addition in ECMAScript 6 and the path forward for the standard.

Julia is a dynamic language in the tradition of Lisp, Perl, Python and Ruby. It aims to advance expressiveness and convenience for scientific and technical computing beyond that of environments like Matlab and NumPy, while simultaneously closing the performance gap with compiled languages like C, C++, Fortran and Java.Most high-performance dynamic language implementations have taken an existing interpreted language and worked to accelerate its execution. In creating Julia, we have reconsidered the basic language design, taking into account the capabilities of modern JIT compilers and the specific needs of technical computing. Our design includes:Multiple dispatch as the core language paradigm. Exposing a sophisticated type system including parametric dependent types. Dynamic type inference to generate fast code from programs with no declarations. Aggressive specialization of generated code for types encountered at run-time. Julia feels light and natural for data exploration and algorithm prototyping, but has performance that lets you deploy your prototypes.

Designing a programming language has a strong subjective component.There are features - such as type and property inference - that many would agree are useful, subject to proper language integration. But then there are features of which utility is not immediately obvious, and that could go either way when it comes to community adoption and scaling up to real, large programs. This talk discusses three such features of D - seemingly unimportant, maybe greeted with a ho-hum by the community, but today ubiquitously used and enjoyed.

What makes ISO C++11 "feel like a new language"? What things that we know about past C++ do we need to unlearn? Why is C++ designed the way it is – historically, and in C++11? Finally, what is the difference between managed and native languages anyway, and when is each applicable? This talk gives an overview and motivation of modern C++ and why it's clean, safe, and fast – as clean to code in and as type-safe as any modern language, and more than ever the king of "fast."

Dart is a new programming language being developed at Google, designed to support web programming. Dart is a purely object-oriented, class-based single inheritance optionally typed language with actor based concurrency. The design of Dart is subject to two challenging constraints: efficient compilation to JavaScript and instant familiarity to mainstream programmers. Dart may be deployed on both client and server, either via compilation to JavaScript or on its own VM.

Until now, the VB and C# compilers have been used as black boxes. You put text in, and you get out a binary file. In our long-lead project, codename "Roslyn," we are changing that dynamic by building an API that exposes our compilers' analysis engines. In this session, we'll go in-depth in exploring the Roslyn project and the powerful set of APIs for building "code aware" tools and extensions. In this information-packed session, we'll explore six major Roslyn APIs in depth, covering parsing, retrieving semantic information, analyzing data and control flow, and scripting. Armed with this knowledge, we'll see how easy it is to leverage the APIs to analyze and generate C# and VB source code, add C# scripting support to an application, or even extend the existing C# and VB language service features in Visual Studio.

Native programming languages panel hosted by Martyn Lovell.

What happens when Anders Hejlsberg, Gilad Bracha, Martin Odersky, and Peter Alvaro get together for an interactive panel moderated by Erik Meijer?Tune in.

Reflection and compilers do tantalizing similar things. Yet, in mainstream, statically typed languages the two have been only loosely coupled, and generally share very little code. In this talk I explore what happens if one sets out to overcome their separation. The first half of the talk addresses the challenge how reflection libraries can share core data structures and algorithms with the language's compiler without having compiler internals leaking into the standard library API. It turns out that a component system based on abstract types and path-dependent types is a good tool to solve this challenge. I'll explain how the "multiple cake pattern" can be fruitfully applied to expose the right kind of information.The second half of the talk explores what one can do when strong, mirror-based reflection is a standard tool. In particular, the compiler itself can use reflection, leading to a particular system of low-level macros that rewrite syntax trees. One core property of these macros is that they can express staging, by rewriting a tree at one stage to code that produces the same tree at the next stage. Staging lets us implement type reification and general LINQ-like functionality. What's more, staging can also be applied to the macro system itself, with the consequence that a simple low-level macro system can produce a high-level hygienic one, without any extra effort from the language or compiler.

Java and .NET are like twins separated at birth, but what if you actually want to run your Java code on .NET? IKVM.NET aims to provide a full Java platform on top of the .NET Framework and in this talk we'll look at how this is accomplished and what the challenges are.

This talk will present updates on Lambda, JSR 292, as well as some other VM- and language-related OpenJDK items.

Modern programming thrives on rich spaces of data, information and services. F# 3.0 brings integrated support for Information Rich Programming to the .NET platform. F# Type Providers and F# Queries greatly simplify data-rich analytical programming, allowing programmers to easily access and manipulate a variety of data sources. In this talk, I'll introduce these exciting new features and how they can be used to leverage technologies such as OData, SQL Server, WSDL services, SharePoint, and Windows Azure Marketplace.

I will present Bloom, a programming language targeted at developers of complex cloud computing and distributed systems. Bloom is a 'disorderly' language: it differentiates itself from most common programming languages by embracing rather than resisting the disorderly realities of distributed computing architectures. Building on recent theoretical results including the CALM Theorem, Bloom supports a powerful new programming analysis framework for analyzing the correctness and consistency of distributed programs. To demonstrate Bloom's utility, I will present examples of distributed system infrastructure and applications, including delivery protocols, a key-value store and a replicated shopping cart application. I will then show how Bloom's analysis tools allow the programmer to compare and evaluate these implementations.

Asynchronous programming is what the doctor usually orders for unresponsive client apps and for services with thread-scaling issues. This usually means a bleak departure from the imperative programming constructs we know and love into a spaghetti hell of callbacks and signups. C# and VB are putting an end to that, reinstating all your tried-and-true control structures on top of a future-based model of asynchrony.

The Windows Runtime is Microsoft's new developer platform. It is designed from the ground up to give developers a wide range of choices, allowing apps to be authored in a broad range of languages—from C++ to JavaScript, as well as Visual Basic and C#. The Runtime also includes standard ways to build hybrid apps, such as those that use a mixture of JavaScript and C++. It includes a broad range of operating system services for everything from user interfaces to networks. Apps based on the Windows Runtime are designed to be fast, fluid and responsive, so the platform includes standard required mechanisms for asynchronous programming.In this talk I'll review the Windows Runtime architecture and foundations, its relationship to programming languages and how diverse languages and the operating system can unite to build compelling apps. I'll also talk about the technical challenges of integrating the Windows Runtime into a new language and describe the attributes of a great Windows Runtime language.

We propose a marriage of probabilistic functional programming with Bayesian reasoning. Infer.NET Fun turns the simple succinct syntax of F# into an executable modeling language – you can code up the conditional probability distributions of Bayes' rule using F# array comprehensions with constraints. Write your model in F#. Run it directly to synthesize test datasets and to debug models. Or compile it with Infer.NET for efficient statistical inference. Hence, efficient algorithms for a range of regression, classification, and specialist learning tasks derive by probabilistic functional programming.

Galois started out using Haskell because it was our first love. This talk will be about why we *still* use it. Yes, we still love Haskell, but as the Beatles said, love don't pay the bills. I'll present some recent projects that show different aspects of our use of Haskell, giving a sense of what Haskell brings to the table, closing with a more nuanced answer to the question of why we still use -- and love -- Haskell.

Go is a statically typed, compiled language with a dynamic and lightweight feel. With Go you get the efficiency benefits of being close to the machine–your programs compile to native code–with the productivity benefits of a scripting language. Go apps tend to run faster and use less memory than equivalent Python or Java apps, and Go's concurrency primitives make it easy to write web applications. This talk presents the key language features that make Go stand out from the crowd.