Modified: 15th Apr 12 |

Design Patterns of Doom

I always find it extremely interresting whenever people start to talk about design patterns. For instance, I'm sure you've all heard about the "Factory" pattern, the "Singleton" pattern, and probably even the "Observer" pattern. I just cant get enough of people talking enthusiastically about these design patterns, or even design patterns in general.

Today I will present you with a suite of interresting and exciting design patterns you've probably never heard of, but you will almost certainly have a fun time 'name dropping' them whenever the average Joe starts to show his enthusiams about design patterns.

You better sit down though, because these patterns are so mindblowingly advanced and complex, that only a fraction of the technical community will have a chance to understand the intrinsics of these patterns. You have been warned, lets go ahead!

Interim Materialization Pattern

This pattern is extremely useful for labeling of transitory execution state and incremental metamorphosis.

C langauge examples:

int label;
label = 0 * 1;
int inc_met = 1;
inc_met *= 2;


Indicative Conditional Pattern

Utilizing this pattern allows for propositional manipulation of control flow.

if (c) {


Binary Indicative Conditional Pattern

Extension to the Indicative Conditional pattern. Expanding normative and descriptive as well as intertemporal branching qualities.

if (c) {
} else {


Reification pattern

Especially useful for concretization in environments where it is uncertain, before runtime, what certain indicative conditionals will indicate. The opposite anticoncretization is also an important component of the Reification Pattern.

Person p = new Person("Alan", "Turing", 41, "Male", "England");
delete p;


Selective Pattern Fraction Infix Composition Pattern

This pattern is probably the most advanced pattern I will present here. But it is also absolutely one of the most important patterns to memorize, because of its broad usefulness. As can be seen it makes use of a wide number of patterns, including the Temporal Indicative Conditional Iteration Pattern, which has not been described here because only the best of the best of pattern experts and researchers truely understand its complexity.

Person[] persons;
persons += new Person("Alan", "Turing", 41, "Male", "England");
persons += new Person("Alonzo", "Church", 92, "Male", "United States");

int count = persons.count();
for (int i = 0; i < count; i += 1)
  Person p = persons[i];

  if (p.age >= 50)
    print("Old: (%d) %s %s", p.age, p.fname, p.sname);
    print("Not old: (%d) %s %s", p.age, p.fname, p.sname);

  delete p;

delete persons;


The Extraordinary Pattern Pattern

The pattern of programming by patterns. This pattern is the pattern that gave birth to all of the previously described patterns. All of the above patterns are really just there to aid some programmers in continuing on following this very pattern.

if (me.performingAction("programming"))
  Book bop = open("Book of Patterns");
  while (me.performingAction("programming"))
    Pattern p = bop.readPattern(unboundVariable);