Programmers often feel like their work is abstract, and not related to real-world, day-to-day problems. At the same time, we know that software is often used in crucial aspects of our society. In this talk, Christian Schafmeister describes the software tool that he and his colleagues wrote to create molecules — and particularly proteins, chains of amino acids that are crucial to all life on Earth. He describes his goal of making it as easy to create molecules as it is to create software, and the molecules that he and his colleagues have created using a version of Lisp on LLVM which creates molecules. If you’re interested in the real-world uses of programming, proteins, or solutions to health-care problems, then this talk will be fascinating for you.
Elm is a new, statically typed, functional programming language that lets you create GUIs inside of your browser. It can communicate with JavaScript (a slightly more popular language used inside of browsers), and compiles into JavaScript, CSS, and HTML. Elm offers a number of new ideas, alongside some old ideas put in a new context. In this talk, Elm creator Evan Czaplicki describes his language, and how it aims to make software easier to maintain.
Go (aka Golang) is a relatively new programming language from Google that bridges the gap, in some ways, between high-level languages (e.g., Python) and low-level languages (e.g., C). It is highly concurrent, cross platform, and compiles into fast-executing code. Now that Go has been used for a while in production, it’s time to ask: What is using it like? Where does it shine? And where does it not? In this talk, Vincent Batts reviews his experience using Golang on a number of projects, and describes what he believes to be the language’s advantages and disadvantages.
We program using computer “languages,” but how similar are programming languages to human languages? How similar is human thought to the way computers operate? In this interesting (and whimsical) talk, Jenna Zeigen helps us to understand computers by comparing them — and JavaScript in particular — with human minds and thought. How do we process language? How do we handle multiple, parallel tasks? And what insights can we gain about the technologies from this?
The Java Virtual Machine (JVM) is an open-source virtual machine used by Java (obviously), and a growing number of other languages. How is the JVM built? What were the design choices that went into its creation, evolution, and maintenance? How do these design choices affect programs running on the JVM? In this fast-paced talk by Cliff Click, we learn what considerations went into the creation of the JVM. Given how many modern languages run within a virtual machine, hearing about the design decisions that went into the creation of one of the most popular modern VMs is especially interesting.
Ruby is a programming language that people love to use: It’s extremely flexible and fluid, and completely object-oriented. But the world is moving — to some degree, at least — away from objects, and in favor of functional programming, with shared, immutable data. Erlang takes this to the extreme, also allowing us to work with any number of processes, with a rock-solid virtual machine. Elixir is a new programming language that tries to marry these two approaches together. It feels like Ruby, but it sits on top of the Erlang virtual machine, providing all of the advantages that it offers. In this talk, Dave Thomas introduces Elixir, and demonstrates how this combination of flexible coding, immutable state, and high levels of concurrency can work together to provide a powerful coding paradigm.
Erlang is not a new programming language; it’s scalable, highly concurrent, reliable, and executes quickly. Given all of these factors, everyone should be using it, right? So why aren’t they? In this talk, Garrett Smith asks why more new applications aren’t being written in Erlang, and explores the issues that Erlang faces when trying to break into the larger world of software development.
Rust is a programming language from Mozilla Labs that has been getting a growing degree of attention. As Rust developer Alex Crichton describes in this talk, Rust aims to provide a systems language, similar to C or C++ in the degree of control that it gives programmers — while providing the reliability and safety of high-level languages such as Python, Ruby, and JavaScript. How does it aim to do this, and why are so many programmers interested in Rust? This talk describes the design goals of Rust, and the ways in which it tries to bridge the gap between control and safety, two goals that other languages would have us believe are mutually exclusive.
People often complain that dynamic languages such as Python execute slowly. Of course, Python (and similar languages) are generally unable to reach the execution speeds that we see and know in other languages. Why is this? What makes Python slow, and what can make it fast — or at least, faster? In this talk, Alex Gaynor provides descriptions and comparisons of Python code with other languages, and talks about strategies that we can and should consider in order to speed up our Python programs.
Dynamic vs. static typing is a debate that programmers, and programming language designers, have had for many years. Is the flexibility of dynamic typing a decent trade-off from the safety of static typing? Is one really more (or less) safe than the other? In this talk, Paul Snively and Amanda Laucher explore the different ways in which languages implement types, and how we can (and should) think about them, their tradeoffs, and how to use them effectively.