Can Ruby really have design issues that the design patterns solve?

Question

I recently started digging into design patterns. Generally speaking, I thought the design issues that most of the design patterns solve do not generally occur in Ruby. Most of the design issues were because of datatypes (No dynamic typing and arrays can hold objects belonging to same class at a time etc. and many more.). Being a ruby and ruby on rails developer, I realized that absence of concepts of interfaces, abstract classes, references, pointers etc and presence of concepts like modules, dynamic typing, array with objects of any class together, features like eval really makes life easier for the developers. I also went through the book by Russ Olsen. I however, thought that the book tried to simulate design patterns instead of actually implementing them, reason being, the design issues just do no generally occur in Ruby. Is it that, the Ruby programming language has evolved with time and takes care of the design issues internally making developers concentrate just on the business logic more?

I would like to know views of other Ruby developers on this. Thanks.

Answer 1

I think you misunderstand design patterns. It is not true that

"Most of the design issues were because of datatypes."

Instead, design patterns usually solve structural problems of object oriented design. For example, in Ruby, you can have the problem that you have to objects of different classes that must be processed by the same code. When they have different interfaces (that means different sets of methods), you probably need the adapter pattern to solve that incompatibility. Likewise, it could be that you want to implement differnt sets of behavior and will use the strategy pattern to do this.

Some patterns like the Null Object may not be relevant because they are integrated in the language directly and are used out of habit without thinking of them in as patterns.

In general, design patterns apply to Ruby as well as to other object oriented languages.

Answer 2

Ruby is a relatively modern language, though not THAT modern, as its been around for about a decade. Because of that many common programming patterns were engineered into the language itself.

On various places, it has been claimed that use of DesignPatterns, especially complex ones like VisitorPattern, are actually indicators that the language being used isn't powerful enough.

Link to Wiki about this topic(the Wiki)

Answer 3

Considering that the MVC and ActiveRecord Ruby on Rails' core, you've picked a poor example for arguing that design patterns are missing language features.

Answer 4

Design patterns are simply a set of "ideas" on how to solve some common specific problems. Some of them are useful... some of them trivial, or even contraproductive (look up antipattern :) Generally if the need arise to follow a workflow predefined to a degree comparable to that as stated in most "design patterns", implies one or both of the following:

1. Language beeing used is flawed, thence solutions to common problems are difficult and require following of rigorous predefined way of thought (design pattern or antipattern), in order to avoid excessive bugs and/or not beeing able to solve the problem at all. Using design anti/patterns as consequence of having chosen a language with poor expressivness often leads to nonsense.

2. Programmer following design pattern or antipattern lacks the skill, knowledge, creativity or simply IQ to understand, analyze and/or solve the problem, thence he/she chooses to follow pattern or antipattern. Following anti/pattern as result of ones inadequate knowledge, rather than acquiring that knowledge prior to attepting solution, often leads to nonsense.

The ruby language is extremely expressive, and thence solving common tasks, especially those outlined in "design patterns" most often doesn't require explicite usage or following of rigid, predefined workflow aka. design pattern.

Answer 5

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem in software design.. Naturally, the problems that commonly occur vary from language to language and system to system. Ruby may indeed solve some of the problems which occur in other languages but it will have commonly occurring problems of its own.