How many times have you heard that goto is a bad idea? Or more specifically, “GOTO considered harmful?” The odds are that you’ve heard this many times, along with many other statements that have made their way through computer-industry lore. In this talk, Alvaro Videla introduces a number of these myths and statements, describes the circumstances in which they were made, and helps us to understand the reasons why such smart people would make such seemingly dogmatic, inflexible, and unqualified statements. If you’re interested in the history of the computer industry, or the ways in which our programming languages, techniques, and tools have evolved over time, this talk should be quite enjoyable.
How does Ruby work? That is, the Ruby virtual machine — often known as the MRI — is what runs the bytecodes into which our Ruby program is translated. But how does the Ruby VM actually do what it needs? And what does the Ruby VM do to improve the efficiency of our code? In this talk, Aaron Patterson provides a gentle introduction to VMs in general, and the Ruby VM in particular. If you’re a Ruby developer, and have ever wondered how your code is executed, or why Ruby works the way it does, this talk will be of great interest.
What can you do with lots of computers? Cloud computing allows us to scale up (and down) very quickly, but how do we do that? And what do we do with such scale when we can? Well, worry no longer, because Aja Hammerly has come up with many ideas for what you can do with large numbers of computers. Between playing games, solving problems, and building huge regular expressions, this talk is fun and interesting, and shows what you can do with some Ruby, lots of computers, and a playful imagination.
Functions are one of PostgreSQL‘s most powerful and least-used features. You can invoke functions, but you can also write functions in a variety of languages. How do PostgreSQL’s functions work? How are the languages different from one another? How do you create anonymous functions? And what are the best practices for function creation? In this talk, Joe Conway answers all of these questions, and more, providing a deep dive into the functions that we use, and those that we create, providing a great deal of insight into the process for PostgreSQL users old and new alike.
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.
Several years ago, a new proposal made the rounds in the Ruby community. “Refinements” were proposed as a way to modify an existing class, but without the unfortunate (and potentially dangerous) side effects of monkey patching. The Ruby community discussed and debated refinements, and when they were finally included in Ruby … well, it seems that almost nothing happened, because no one really used them. In this talk, James Adam asks why no one is using them. He describes refinements, and then points to reasons why they might be interesting and/or useful, and then discusses why they aren’t in common use.
Developers often talk about the people using our code… but it’s not always in the most positive way. Successful teams think about their users, and the ways in which our users (and customers) will use the products we’re creating. . In this talk, Louisa Barrett talks about how we can and should think creatively, like a designer — not necessarily thinking as an artist, but as someone who wants to help our customers to achieve their needs, and use our products in the most effective ways.
Functional programming is hot. So are Python and data science. So the combination makes for an almost unbeatable combination — using functional programming techniques in Python for data-science work. In this talk, Joel Grus introduces Python’s basic functional techniques and libraries, and then such methods as k-clusters for grouping data. If you have always been interested in how to use Python to analyze data, and/or have always wanted to push your functional programming knowledge to the limits, this talk will most certainly interest you.
How do you deploy your services? A decade ago, the assumption was that you were deploying your application to each of a number of servers, and that you would update the software on each server as you released new versions. But today, a growing number of organizations are making use of containers and virtual machines to deploy in a totally different way, using immutable servers that are deployed a single time. Why have so many companies started to adopt this model, what are the advantages, and (just as importantly) what are the disadvantages? What considerations should you have in mind when you switch to a set of immutable containers? In this talk, John Willis describes the thinking behind immutability, and what you should keep in mind if and when you switch to that approach.
What do you need to know in order to run a PostgreSQL system? This talk, by Simon Riggs, attempts to summarize many of the ideas, tasks, and tools that PostgreSQL administrators need to know in order to do their jobs effectively. How should you think about your job as a PostgreSQL DBA? What sorts of monitors should you put on your system? What settings should you avoid to reduce the chance of disaster? If you’re running one or most PostgreSQL systems, then this talk will give you some ideas for how to ensure they run smoothly — and continue to do so.