Category Archives: Object-oriented programming

[Video 457] Reginald Braithwaite: First-Class Commands — An unexpectedly fertile design pattern

Functional programming is well known for, among other things, treating functions as data, allowing us to store, create, pass, and return them within a program. This has led to all sorts of interesting techniques, most having to do with holding onto functions until we need to use them. Object-oriented programming languages offer us a similar idea, as the “command pattern” — but where can and should we use it? What problems can be solved elegantly by incorporating the command pattern into our code? In this talk, Reginald Braithwaite introduces the command pattern in a number of different contexts, giving us insight into where and how we can incorporate it into our own work. While examples are in JavaScript,  these ideas can be used in any object-oriented language.

Time: 33 minutes

[Video 380] Jay McGavren: The (Complete) Story of Method Lookup

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.

[Video 377] Sandi Metz: Nothing is Something

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.

[Video 344] Venkat Subramaniam: Rediscovering JavaScript

JavaScript might be a popular and powerful programming language — but it also has a huge number of inconsistencies and oddities that make it challenging to learn and use. That said, JavaScript is growing in popularity and power, and has capabilities that we can and should respect, and even use, in our production work. In this talk, Venkat Subramaniam demonstrates the power of JavaScript, allowing us to use (and mix) object-oriented and functional styles.


[Video 340] John Cinnamond: Extreme Object-Oriented Ruby

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.

[Video 339] Piotr Solnica: Blending Functional and OO Programming in Ruby

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.

[Video 316] Iwan Vosloo: What’s the point of Object Orientation?

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.

[Video 241] Spike Brehm: Evolution Of Airbnb’s Frontend

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.

[Video 233] Yukihiro ‘Matz’ Matsumoto: Superdry Ruby

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.

[Video 207] Brian Knapp: Message-Oriented Programming

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.