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. 

Lang.NEXT 2012 Sessions (HD)

Teaching with Grace

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? 

John Cook: Why and How People Use R

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. 

Walter Bright: The D Programming Language

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. 

Luke Hoban: ECMAScript 6

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. 

Julia

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. 

Andrei Alexandrescu: Three Unlikely Successful Features of D

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." 

Herb Sutter: (Not Your Father’s) C++

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.  

Gilad Bracha: Dart - A Well Structured Web Programming Language

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. 

Going Deeper with Project Roslyn: Exposing the C# and VB compiler’s code analysis

Native programming languages panel hosted by Martyn Lovell. 

Lang.NEXT 2012 Expert Panel: Native Languages

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

Lang.NEXT 2012 Expert Panel: Web and Cloud Programming (and more)

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. 

Keynote - Martin Odersky: Reflection and Compilers

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. 

IKVM.NET: Building a Java VM on the .NET Framework

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

hubhopper

Lang.NEXT 2012 Sessions (HD)

hubhopper