On the shoulders of giants

by Mike Gehard

In the video titled "On the Shoulders of Giants," Mike Gehard from Pivotal Labs discusses the progression and impact of design patterns and refactoring techniques within the software development community, with a focus on Ruby and its frameworks. He expands on the concept introduced by Sandy, emphasizing how the contributions from different programming communities have shaped current practices in design patterns and software development.

Key Points Discussed:
- Historical Context: Gehard traces the evolution of design patterns starting from the 1994 publication of the seminal book on design patterns, highlighting how it categorized patterns into creational, structural, and behavioral types. He asks the audience about their familiarity and usage of these patterns, reflecting on their importance in software design.
- Significant Publications: He mentions key texts like the 1999 "Refactoring" book, which introduces various refactoring techniques, and the 2004 "Refactoring to Patterns," which links refactoring methods to design patterns, thus presenting a more structured approach to improving bad code.
- Practical Examples: Gehard illustrates concepts such as the extract method and the use of a null object with practical examples from previous talks at the event. He acknowledges the influence of the C++ and Java communities in the formulation and spread of these ideas.
- Current State of Ruby: While praising Ruby on Rails as a fantastic framework, he underscores that the Ruby community seems to lag in adopting some of the best practices established in the context of design patterns and refactoring techniques. He invokes discussions from earlier talks to highlight areas where Ruby can improve.
- Call to Action: Gehard encourages the development community to learn from past milestones to better shape the future. He emphasizes the importance of staying updated with significant literature in the field, including works on domain-driven design.
- Audience Engagement: He opens the floor for questions and feedback, indicating his openness to discussions about the topics raised.

00:00:06.720 Hello, my name is Mike Gehard, and I work at Pivotal Labs.

00:00:10.639 Sandy started to talk about the concept of standing on the shoulders of giants. I am going to expand on that idea and maybe ignite some discussions, or perhaps a few rotten vegetables might be thrown. Let's see what happens.

00:00:20.640 Let's go back to 1994 when a book was written about design patterns. How many of you have read the design patterns book? How many people actually use design patterns? And how many of you use design patterns before they are needed? Great!

00:00:31.840 There are 23 patterns: creational patterns, structural patterns, and behavioral patterns. It's quite a comprehensive list. Sandy talked about the factory method in her presentation. In 1994, these concepts were already being discussed.

00:00:41.520 I want to thank the C++ community for coming up with that information and codifying it for us. Fast forward to 1999, and we have another important book. How many of you have read the refactoring book? For those who haven’t, I highly recommend you go and buy a copy. It includes 93 different refactorings!

00:01:07.840 One of the notable techniques in the book is the extract method. For example, as Ben was organizing his class yesterday, he was extracting methods and naming them. We have seen the introduction of the nil object before; Ben mentioned that in one of his talks. This object responds to messages in a null way, which is a concept I thank the Java community for contributing.

00:01:35.439 Jumping to 2004, we see a pattern where every five years there's a milestone in our community. I've noticed this trend based on three data points. There’s another fantastic book titled 'Refactoring to Patterns'. How many of you own this book? I believe it’s even better than the original refactoring book, and I'll explain why.

00:01:53.599 This book offers 27 refactorings linked to two design patterns. Instead of having a design pattern followed by a refactoring, we start with bad code and aim to reach a desired design pattern using these refactorings from Fowler's book.

00:02:21.200 In this book, we introduce several concepts: introducing a null object, implementing polymorphic creation with a factory method, and replacing conditional logic with strategy. When Sandy created her calculator during her talk, she replaced conditional logic with a strategy pattern. I used a similar approach, injecting algorithms through polymorphic creation and then implementing a null object.

00:02:40.720 I want to extend my gratitude to both the C++ and Java communities for these contributions. The collaboration between these communities has allowed design patterns and refactoring techniques to flourish, intertwining their best practices.

00:02:59.360 Now, regarding the Ruby community, we have a fantastic framework in Ruby on Rails, which I adore. However, I feel we are falling behind in certain areas. We’ve been having discussions about design patterns and refactorings, echoing topics from four prominent talks, including those by Sandy, Ben, Justin, and Chiffon.

00:03:15.280 I challenge all of you to learn from the past so that we can shape the future together. I will leave you with that thought for now. Are there any questions, or perhaps concerns? Feel free to voice any feedback.

00:03:39.440 Yes, sir, I understand we’re behind. That was a reference to the year 2004, and it’s actually three years overdue. Nonetheless, all these books I mentioned are valuable resources that you should have. I also highly recommend the domain-driven design book that Von mentioned in his talk, which was also published around 2000.

00:04:12.760 Thank you!