Difference between Idiom and Design Pattern?

Question

What is the difference between idiom and design-pattern? It seems that these terminologies overlap somewhere; where exactly, I don't know. Are they interchangeable? When should I use what?

Here is a list of C++ Idioms. Can I call them design patterns?

Wikipedia defines,

Programming Idiom as a low-level Design Pattern

What does it mean? What does "low-level" mean here?

^{This question is inspired from another question : https://stackoverflow.com/questions/7343531/are-the-some-design-patterns-language-dependent}

Answer 1

An idiom is an idea to work around the quirks of a language. Some examples that come to mind are any of the C++ idioms you linked in the original question. They solve a common problem in that language in a canned way.

A design pattern is similar, in that it solves a common problem. But the ideal design pattern is based on common language features, and thus is language agnostic.

There is a continuum between idioms and design patterns, though, just as there is from low-level to high-level languages.

The Visitor pattern is a good example; if there were only one language that only supported single dynamic-dispatch, then we might consider the Visitor pattern an idiom of that language. But there are whole hordes of languages that don't directly support multiple-dispatch. Hence, the Visitor pattern was born.

The Observer pattern also comes to mind - C# directly supports it, so it doesn't need the common work-around form of the pattern.

An example going the other direction is OO features (inheritance, polymorphism, etc). C doesn't directly support them. If more languages were like C, then we might develop design patterns to implement v-tables, type-safety, etc. Since plenty of languages support those feature, we'd call any common solution in C an idiom, rather than calling the generalized solution a design pattern.

Answer 2

Design patterns are not usually language specific. Language idioms tend to depend on particular feature of a language (or class of languages) or work around a specific deficiency in said language(s).

Answer 3

I wouldn't put too much currency in the Wikipedia definition.

At the very least an idiom is language-specific whereas a design pattern strives, or should strive, to be language-agnostic. Going further, idioms are usually conventions for enhancing readability, or are the superior alternative (on some technical merit) when there is more than one way to do something. All of those things are related on how ideas are expressed (clarity, verbosity, conciseness), but not to the ideas themselves.

On the other hand, design patterns are the essence of a recurring idea, an idea that a priori can be expressed in any languages that lends itself to it. The Visitor is an implementation of double-dispatch relying on single-dispatch and overloading and this can be used in any language that has single-dispatch and overloading. Knowing about the pattern doesn't help write more expressive or more readable code, it helps solving the related problem. There is nothing idiomatic about it because for instance there is no canonical form of the Visitor in e.g. C++.

Answer 4

The normal English language definition of Idiom. Is a phrase whose accepted meaning is not contained in the words used. Examples would be "Raining cats and Dogs" or "Where's the Beef?"

In programming languages it usually refers to a syntactical shortcut that does something not immediately obvious from the code itself but which is used often enough that other programmers recognize the meaning instantly.

Perl is perhaps the most idiom rich language. With constructs like:

while (<IN>) {
    print $_
}

Whose meaning is obvious to an experienced perl programmer but a mystery to anyone else

Answer 5

Idioms are language specific. E.g. while (*dest++=*src++); is a C/C++ idiom. It is completely impossible to write something remotely similar in Pascal or Java. Use the word "idiom" as you use it in english. "How do you do?" as a greeting is an idiom. Some languages like german and frensh have the same idiom. But lots of other languages would not "ask" something like this as a greeting. A (object oriented) pattern on the other hand usually can be adapted into any language that supports inheritance and delegation. A idiom might be as simple as one line of code. A design pattern always involves several classes.

Answer 6

I found this post searching for common C++ idioms, as I have been getting fairly deep into it recently and would like my code to not look as amateurish as I feel it is... :-P

Having spent quite a bit of time with Perl, I've found idioms in that language to be much like those found in natural languages, like English or Spanish (only two I know well enough to know some idioms).

I disagree that an idiom is like a "small design pattern". I still disagree, although less so, that an idiom is a way to work around a deficiency in a language.

Perhaps Luc Danton's answer comes closest, but let me explain. I think that an idiom is, well, idiomatic of those who use the language. Usually, a common expression or sequence of expressions that, while perhaps not obvious, performs an operation or expresses intent in a way that makes sense to those who are fluent enough to have seen it before.

Back to Perl, perhaps the best-known idiom is the "Schwartzian Transform", an expression that performs a sort on data in a compact and efficient manner. It is not the most obvious way to perform such an operation, but it is succinct and those who have seen it before know instantly what it is doing.

Another notable example is "The Orcish Maneuver", which takes advantage of perl's notions of true/false, rich operators, and operator precedence.

One that I personally like quite a bit is somewhat related to the Orcish Maneuver, but I know of no name for it:

push @{ $some_hash{$key} ||= [] }, $some_value;

This is indeed not obfuscation, but rather a clear, compact expression of something that would otherwise take several lines to do. If the key is present in the hash and has a true value, de-reference it as an array and push $some_value onto that array. If the hash element is not present or has a false value, assign it an empty array, then dereference that array and do the push.

It's also worth noting that as of Perl 5.14, part of this idiom is obsolete - push can now operate directly on the array reference, no @{} needed! Also, as of Perl 5.10, one can use //= instead of ||= which checks not for truth but for defined-ness.

Answer 7

the point of an Idiom is to be an idea or concept that spans programming languages, it is a way of doing things and a process that works without much conceptual restructuring when you take it from one and stick it in another, like the lowly bubble sort. Design patterns are specific implementations of an idiom, or extentions of the idea to fit into a language, you therefore have the javascript design pattern of the event-listener idiom etc.

Answer 8

I'm not 100% sure, but idioms are simply terms pertaining to a certain field. When you say "design patterns", you think of "Observer Pattern" "Chain of responsability" "Visitor pattern" "factory". These are common patterns used to solve common problems in programming. Look here for a comprehensive list: http://en.wikibooks.org/wiki/C++_Programming/Code/Design_Patterns

Answer 9

What does it mean? What does "low-level" mean here?

I take it to mean that it is not a high level, abstract way to model your application or components of your application, but instead a clever or common use of language semantics.

for example, setting a variable if it evaluates to false (commonly used to set nil variables conditionally):

var ||= some_default_value

Answer 10

Here's an example of an idiom (in C#) for handling an event. You're not allowed to fire an event if it doesn't haven't any handlers attached, so the idiom is to always check this first.

Therefore the general idiom for handling events becomes:

EventHandler handler = this.MyEvent;
if ( null != handler ) { handler( param1, param2 ); }

This idiom is specific (although not exclusive) to the C# language.

More generally however, the C# eventing mechanism is an example of the observer design pattern which could be implemented in any language.