Bob Ippolito: What can Python learn from Haskell?

Python is an established, widely used programming language, Haskell, for all of its innovations, is still a fairly niche language — and, unlike Python, it’s also compiled and functional. Nevertheless, in this talk, Bob Ippolito tells Python developers that Haskell has a lot to teach Python — particularly in the area of type checking as a way to ensure that programs won’t encounter surprising runtime errors.

Chris Kelly: String Theory

One of the great things about high-level languages is that you can depend on the existence of strings to work with text. Ruby is no exception; its String class is as flexible as it is useful. It’s hard to imagine a program that doesn’t use String somewhere. But how is Ruby’s String class implemented? And how can knowing this help us to write more efficient programs? In this talk, Chris Kelly (re)-introduces us to the innards of Ruby’s String class, and shows us how many parts of Ruby’s memory system interact when working with strings. If you’re a Ruby developer, you’re no longer to take string allocation for granted after watching this talk.

Reynold Xin and Aaron Davidson: Mining Big Data with Apache Spark

Big data” is big, and tools to work with it are also big — in that they’re both numerous, and are growing in popularity and sophistication. One of the latest technologies aimed at making big data accessible and easier to analyze is Apache Spark — which operates in memory, is highly parallel, working with a number of programming languages (including Java, Scala, and Python), uses a variety of back ends, and can be queried using familiar tools such as SQL. In this talk, Spark developers Reynold Xin and Aaron Davidson introduce Spark, and describe what it can do for you and your organization.

“Uncle Bob” Martin: Functional Programming; What? Why? When?

Functional programming continues to interest programmers, whether they’re using a functional language (e.g., Haskell or Clojure) or one with some functional capabilities (e.g., Python, Ruby, or JavaScript). But what’s the big idea here? Why should functional programming interest developers? In this talk, Robert (“Uncle Bob”) Martin describes the motivation behind functional programming, and how it aims to make software easier to write, understand, test, and maintain.

Bozhidar Batsov: The evolution of the Emacs tooling for Clojure

Emacs has long been a popular editor for programmers of all languages. But given that Emacs is written (and extended) in Lisp, it’s no surprise that Lisp hackers have a particular affinity for Emacs. In the case of Clojure, there have been several generations of Emacs modes and tools over the years. In this talk, Bozhidar Batsov, the current maintainer of the CIDER Emacs development environment for Clojure, describes the history of these tools, why he prefers them, and how the tools and the language have both evolved over time.

Raymond Hettinger: Transforming Code into Beautiful, Idiomatic Python

It used to be hard to get a program to work.  Nowadays, however, it’s easy to get a program to work — but does it work well? Is it maintainable? Python has long emphasized the need for not only working code, but for maintainable, easy to read, and idiomatic code.  In this talk, Raymond Hettinger describes a number of ways in which working (but non-standard) Python code can be turned into something that looks, feels, and acts like the Python that we’re encouraged to write.

Katrina Owen: Overkill

How far should we go in making sure that our programs are robust? What techniques can we employ to make our code more readable? What stories can we tell via our object and method names? In this talk, Katrina Owen creates and evolves a set of programs, describing the trade-offs that we make when we create code, and what object-oriented design principles can teach us about improving our code.

Justin Searls: The Social Coding Contract

Developing programs in Ruby almost certainly means using software developed by other people. This means that your software — and maybe even your business — now depends on the quality of software written by people you don’t know, and who don’t owe you any support. How can we improve this state of affairs? How can we improve the ways in which people within the open-source ecosystem improve their communication, trust, and general interest in working together for everyone’s mutual benefit? In this talk, Justin Searls describes the current state of open source, and describes different ways in which open-source contributors and their users might be able to improve not only the code, but also the ways in which that code is developed.

Nick Coghlan: Nobody Expects the Python Packaging Authority

If you have written a Python program, then you have almost certainly used Python packages. A large number of packages are distributed via PyPI, the Python Package Index. The easiest way to download, install, and use packages from PyPI is “pip,” which is standard in all of the most recent versions of Python. It turns out that behind PyPI and pip is a group of developers known as the “Python Packaging Authority.” In this talk, PPA member and Python core developer Nick Coghlan describes what the PPA does, and how it tries to solve problems that Python developers face now and in the future.

Simon Peyton Jones and Tim Harris: Software Transactional Memory

How can you take advantage of today’s multicore systems? Write concurrent programs, of course. But that requires all sorts of tricks and cleverness, such as locking and mutexes. In this talk, two well-known computer scientists (Simon Peyton-Jones and Tim Harris) outline “software transactional memory” — the idea that as with databases, programs can offer transactional access to data. STM is used in Clojure and Haskell to avoid concurrency problems, and its proponents say that it solves many of the problems associated with traditional threading and locking.