When you send a message to an object in Ruby, which method is really invoked? This seemingly innocent and simple question lies at the heart of Ruby development; if you understand the difference between objects, classes, and singleton classes, then you’re doing quite well. However, understanding the relationships among these various objects can be difficult and/or challenging. In this talk, Jay McGavren explains what happens when you invoke a method in Ruby — who receives it, what they do with it, and where that message might go. If you’re a Ruby developer but are struggling to understand the object model, including such things as “include” and “extend,” then this talk will help to bring some order to your mental model.
Programming languages include lots of abstractions — many ideas that sit on top of other ideas, allowing us to work at a high level. But there are many cases in it’s important to understand what our code is not doing, or where there are values that represent nothingness, or the absence of something. In this talk, Sandi Metz reminds us that even the things that “seem like nothing” our code are actually important, worth thinking about and understanding. While the talk uses Ruby, the ideas are easily transferred to other object-oriented languages, and are food for thought for any programmer using object-oriented techniques.
Ruby is, of course, an object-oriented language. But there are parts of its syntax that aren’t quite object-oriented, such as the “if” statement. In this talk, John Cinnamond tries to push Ruby to its limits, removing and re-implementing parts of the language that we often take for granted. Perhaps this isn’t a way in which we would want to program every day, but it is certainly thought provoking, and gives us greater insight into what it means to describe programming as object-oriented.
Functional programming and object-oriented programming are two well-known and powerful techniques for organizing code and providing programmers with flexibility and power. Each has its own strengths and weaknesses, and each has supporters who feel that their technique is far superior than the other. But instead of seeing these two techniques as being opposites and incompatible, many programmers see them as complementary. In languages such as Ruby, you can work in both styles at the same time, enjoying the best of both worlds. In this talk, Piotr Solnica describes his experiences mixing these two techniques, and how doing so in Ruby helps him to be more effective and expressive in his programs.
Object-oriented programming has grown from a new and interesting idea to a pervasive concept and paradigm in the programming world. But what is object-oriented programming all about? What problems was it intended to solve? How does Python‘s implementation of objects differ from the original ideas that were proposed decades ago? What is subclassing supposed to do for us? And how is all of this supposed to help programmers get things done? In this talk, Iwan Vosloo introduces these ideas, and compares this theory with how Python does things. If you are new to object-oriented programming, or to Python’s view of objects, then this talk should help to answer some of the questions you might have.
AirBNB is a well-known Web application and business. They’re known not only for their business, but for a high-quality Web experience. How did AirBNB go from a small, simple, Web application with almost no serious front-end technologies to one that is using many of them, including some home-grown systems? In this talk, Spike Brehm describes the ways in which AirBNB’s front end has changed over time, in order to handle scaling, usability, and maintenance.
Where is the Ruby programming language headed? In this keynote address, Ruby inventor Yukihiro ‘Matz’ Matsumoto describes the past, present, and future of Ruby. What programming models have influenced Ruby to date, and what models are influencing it as the language evolves and improves? If you’re a Ruby developer, or are just interested in understanding how a programming language changes over time, then this talk will likely be of great interest to you.
Many of us program with object-oriented languages, such as Ruby. But what does “object-oriented programming” really mean? The emphasis in Smalltalk, the original OO language, wasn’t on objects so much as on messages — the communication that took place between the objects. In this talk, Brian Knapp explores what messages are, and how thinking in terms of them can change (and improve) the way in which you write object-oriented code — not just in Ruby, but in other languages, too.