So you want to add up a bunch of numbers, eh? Fine, but what’s the fastest way in which you can do this? What about if you want to parallelize your solution? What pitfalls will you encounter, and how can you avoid them? In this talk, Guy L. Steele takes us, slowly but surely, though a number of different ideas, strategies, and concepts having to do with parallel programming, and considers the implications of them — regardless of the language you’re using.
Many programmers, when they start to work in Ruby, are surprised to discover the GIL — the Global Interpreter Lock, which ensures that only one thread can run at a time. For people used to working with threads on other systems, it’s hard to come to grips with the GIL. Why does it exist, what can we do to get around it, and how to Ruby developers go about their work when it exists? In this talk, Jerry D’Antonio discusses the GIL, and why many of the things you thought were true about it probably aren’t. He then points to other languages with high-quality concurrency tools, and discusses his efforts to bring these into the Ruby world.
Coroutines are an advanced Python feature that is of growing interest to many Python developers. Coroutines can be hard to get your head around, but they make it possible to simplify certain types of software, and also to increase some software performance. But what are coroutines, how do you create them, how do you use them — and are they really that great? In this talk, A. Jesse Jiryu Davis demonstrates how you can and should use coroutines, and where they fit into the Python ecosystem.
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.
HTTP/2 is here! This new version of the Web’s most popular protocol is optimized for modern Web uses. Our networks are faster, our browsers are smarter, and our requirements are tougher than was the case when the previous version of HTTP was released. But it turns out that HTTP/2’s speed isn’t just a matter of switching out the old servers and switching in the new ones: The best practices that we developed for years, in order to make our Web sites fast and efficient, conflict in some ways with the ways in which HTTP/2 expects us to work. In this talk, Ilya Grigorik describes HTTP/2, and contrasts it with HTTP/1.x — less to understand the protocol itself, than to understand how it works.
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.
Note that the slides and demonstrations are hard to read for much of this presentation; they’re available at http://gotocon.com/dl/goto-chicago-2014/slides/DaveThomas_ElixirThePowerOfErlangTheJoyOfRuby.pdf.
Yesterday’s video described the GIL in Python — its history, current usage, and future. It would seem that Python is destined to have a GIL in the foreseeable future. However, the PyPy alternative implementation of Python was designed to be a sandbox for new ideas, and for trying new ways of doing things in Python. One such idea is to bring software transactional memory (STM) to Python, simultaneously providing for concurrency and safety. How does STM work in PyPy? What does it change in the language? And why is this not already a part of Python? In this talk, Armin Rigo describes his work to integrate STM into PyPy, and what this means for Python developers now and in the future.
I often speak with people who have come to Python from Java or .NET, and really want to use threads. Their excitement decreases dramatically when they discover that Python’s threads are limited by the GIL — the “global interpreter lock,” which ensures that only one thread runs at a given time. Why does the GIL exist, what does it do, how does it affect Python performance, and what can we do about it? In this talk, Larry Hastings describes the GIL’s past, present, and future. If you’re a Python developer who is curious about what threads can and cannot be expected to do, and why the GIL still exists, this talk should be very interesting.
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.
Programmers often talk about “threads,” “processes,” and “concurrency.” But what does that really mean? What does it mean about the programs we write, and how we write them? In this talk, Kerri Miller describes what concurrency means, how we can think about it, and how Ruby programmers can (and should) use concurrency in their programs.