SOLID Design Principles in Ruby

In this talk at the Red Dot Ruby Conference 2014, Anil Wadghule presents an in-depth discussion on the SOLID design principles within Ruby, emphasizing how these principles enhance code quality and maintainability. The SOLID principles are critical methodologies that help developers manage software design and dependencies effectively, ensuring code is extensible and reusable. Anil explains each principle in detail, illustrating their significance through various examples:

Single Responsibility Principle: This principle states that a class should have only one reason to change, meaning it should encapsulate a single responsibility or behavior. An example given involves refactoring a class handling multiple methods into separate classes focused on distinct responsibilities.
Open/Closed Principle: Software entities should be open for extension but closed for modification. Anil illustrates this with a parser example, where adding new parsers could be accomplished without modifying existing code, thus adhering to this principle.
Liskov Substitution Principle: This principle mandates that objects of a superclass should be replaceable with objects of a subclass without affecting program correctness. Anil uses a rectangle and square example to explain how breaking this principle can lead to bugs in the code.
Interface Segregation Principle: It is better to have multiple client-specific interfaces than a single general-purpose one. Anil gives examples related to different types of models (like TVs) to clarify that tailored interfaces increase cohesion and reduce unnecessary dependencies.
Dependency Inversion Principle: Higher-level modules should not depend on low-level modules but rather on abstractions. This is illustrated with a coding scenario that shows the importance of inverting dependencies to enhance flexibility in the code.

Anil concludes by emphasizing that following these principles can transform rigid and fragile code into flexible, robust, and maintainable systems. He reinforces that design comprises more than just adhering to practices such as DRY and TDD; it requires thoughtful structuring and management of dependencies for successful software evolution. Overall, the talk motivates programmers to focus on good design practices to ensure code that is clean, understandable, and adaptable for future changes.

SOLID Design Principles in Ruby
Anil Wadghule • June 27, 2014 • Singapore • Talk

This talk covers following SOLID design principles in Ruby with live code examples.

Single responsibility principle: an object should have only a single responsibility. Open/closed principle: an object should be open for extension, but closed for modification. Liskov substitution principle: objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program Interface segregation principle: many client specific interfaces are better than one general purpose interface. Dependency inversion principle: depend upon abstractions, do not depend upon concretions Talk will have live code example which will be evolved step by step to use all SOLID principles. This talk will also answer the question why just following these principles will make your code more clean readable, extensible and better. Also make you better programmer.

Help us caption & translate this video!

http://amara.org/v/FGY2/

Red Dot Ruby Conference 2014