Limin Fu introduces Dao, a lightweight and optionally typed programming language having a LLVM-based JIT compiler optimized for numeric computation, and a Clang-based tool generating Dao bindings for C/C++ libraries.
Keith Adams examines the strengths that made PHP a dominant language in its niche, highlighting Facebook's attempts at remedying its inconsistencies and misfeatures while maintaining its strengths.
Bob Nystrom attempts to demonstrate that Dart is not boring, covering laziness, higher-order functions, asynchronicity, abstractions and others.
The authors introduce a new language paradigm meant to enhance OOP with multi-dimensional context, providing details on context-based dispatch, and showing a glimpse of their early prototype.
Gilad Bracha presents the motivation behind building Dart, the current state of the Dart platform and where it is heading to.
Walter Wilson introduces Axiomatic, a minimal pure-specification logic language with meta-language capability based on the idea that the external behavior of a program can be defined by an infinite set of symbolic expressions that enumerate all possible inputs, or sequences of inputs, along with the corresponding outputs. The language is just a formal system for defining these symbolic expressions
Andreas Rumpf introduces Nimrod, a statically typed programming language supporting unhygienic/hygienic and declarative/imperative AST-based macros. The talk focuses on metaprogramming capabilities.
Daira Hopwood introduces Noether, an experimental language meant to write more secure, robust and efficient programs, being built on multiple layers satisfying different levels of symmetries.
Gilad Bracha explains how to distinguish FP hype from reality and to apply key ideas of FP in non-FP languages, separating the good parts of FP from its unnecessary cultural baggage.
Clayton Bauman introduces Babel, an open source language implemented in C, targeted for cloud computing. Other features: interpreted, untyped stack-based, postfix, supports arrays, lists and hashes.
Miles Sabin and Edwin Brady exemplify what can be done with a language with dependent types, what are the limitations and what could be done in the future when dependent types reach maturity.
Mike Falanga shows several C# and F# solutions to common programming problems, comparing how well each language enhances the ability to draw accurate conclusions about the code.