For many years, Perl was one of the best known, and beloved, programming languages. It was at the forefront of high-level “scripting” languages, of Web development, of textual analysis with regular expressions, and of cross-platform languages. And then, Larry Wall announced Perl 6 … and the world waited, with many Perl developers moving onto other languages. Well, Perl 6 is about to be released — and many people who haven’t thought about Perl is years are at least interested in hearing what Larry and others have been working on for more than 15 years. In this talk, Larry Wall unveils Perl 6, describing not only the technical features, but also the thinking behind those features, and what led them to be included.
The Go language continues to rise in popularity. What is it about Go that makes it popular? And why should you consider it for your upcoming projects? In this talk, Thomas Wilde introduces the language, starting with its origins and motivations, and moving into basic syntax and some of Go’s most famous features, such as goroutines. If you have always been curious about Go, but haven’t had a chance to learn it, this talk is a good introduction to the language, and where it might be useful in your projects.
Julia is a relatively new programming language, one meant for use with data analysis (aka “data science”). Julia aims to simultaneously provide a low threshold for entry (so that non-programmers can analyze their data without learning too much about programming) and high-performance execution. How does Julia manage to do this, and how do the results compare with a language such as Python‘s NumPy and SciPy? In this talk, Leah Hanson describes Julia’s aims, the differences between Julia and other languages (such as Python), and what how these design decisions have affected the resulting language.
Python‘s speed is often good enough for many purposes. But in some cases, you really wish that you could run your Python code at C-language speed. You could always write a Python extension in C, but if you’re not a fluent C programmers, then that’s not really an option. Plus, you’d lose all of the Python expressiveness that you already enjoy. Enter Cython, which translates your Python into C — and then provides you with a Python library that you can import into your Python code. In this talk, Stefan Behnel introduces Cython, demonstrates what it can do, and describes how it can fit into a Python development shop aiming to increase execution performance while working in a Python (and Python-like) environment.
Many programming languages include a “lambda” keyword, allowing you to create an anonymous function. But how far can you go with lambda? In this talk, Corey Haines explores what’s possible with lambda — not as a practical exercise, but as a thought experiment turns into actual code. If you’ve wondered what lambda can do, or what the lambda calculus was trying to demonstrate, or just how far you can go with a very small language-creation toolkit, this talk will help you to understand all of these better.
We use the term “language” to describe a programming language, but we normally assume that there is a world of difference between human languages and programming languages. But what if there were a human language that could be described similarly to how we describe a programming language? That might provide us with some insights into the structures of both! In this talk, David Branner introduces us to classical Chinese, a language whose structure can be analyzed similarly to programming languages. Even if you don’t know any Chinese, this talk provides useful insights into the way that we people communicate with one another, and with our machines.
Python is a dynamic language, which basically means that data has types (but identifiers don’t). So s can point to a string, an int, a dict, or a function. But there has been some movement in the last year or two to introduce some form of strong typing, or type hints, into Python. What does this mean, and how does it work? One way to think about it is by looking at a similar idea that was implemented in JavaScript, known as TypeScript. In this talk, Christopher Neugebauer describes TypeScript, what it did for JavaScript, and how Python developers can (and should) look at the introduction of type hints in future versions of Python.
C# is a highly popular language, used by many coders on the .NET platform. C# might have begun as a Microsoft clone (or version) or Java, but it has long since become a powerful and flexible language, beloved by many programmers. Like all programming languages, C# has evolved over the years, both in its internal architecture and implementation, and in the features it offers to developers. In this talk, Mads Torgersen describes many of the features we can expect to see in upcoming versions, and the reasons why those were added to the language.
“Connascence” is a way of describing the ways in which parts of software are interdependent, and can thus force changes upon other parts when they themselves are changed. In other words: Connascence lets us understand the degree to which changes in A will force changes in B. In this talk, Thomi Richards introduces the idea of connascence, describing and demonstrating different types of coupling and connascence in Python code. Understanding the types and degrees of connascence present in your software will make it easier to understand the impact of change, and will help you to reason more carefully about the software you write.
Does the world need yet another Lisp? And in particular, does the world need a Lisp that sits on top of the Erlang VM? In this talk, Robert Virding introduces us to LFE, or “Lisp-flavored Erlang,” a new version of Lisp built on the Erlang VM. It’s thus functional and concurrent, but with many of the aspects of Lisp that developers have grown to love over the years. How is it different from other Lisps, including Clojure? And what advantages does it bring over Lisp and/or Erlang itself? Even if you never use LFE, this talk will introduce you to the ideas of language design, and the use cases for a new language.