Subject: Re: Design patterns as a weapon
From: Erik Naggum <>
Date: 1999/11/28
Newsgroups: comp.lang.lisp
Message-ID: <>

* Aaron Gross <>
| Remember that Gabriel's objection was that the use of MISMATCH was
| actually harder to read (for someone unfamiliar with the function) than
| the corresponding nine-line pattern.  I think that's ridiculous.

  I think the argument has merit.  the reason is simple: if you want
  something to be very popular, you have to _design_ it so you know how the
  distribution of capabilities of your adherents is going to look.  if you
  aim for a normal distribution and a certain number of people, you may
  have to avoid abstractions because there aren't that many people who are
  able to deal with them.  patterns, however, fit much better with how
  people who are weak at abstractions work: cut and paste, modify example
  code, and "reuse" through random proliferation.

  in many ways, modern language design is an attempt to solve the problem
  of how to avoid serious damage by the average programmers.  we can't rely
  on good programmers, anymore, so the people who become programmers for
  the money they need to pay for normal family life expenditures like wife,
  kids, house, cars, etc, quite unlike the dedicated programmers of times
  past, have very different _real_ interests and are unlikely to get really
  involved in their work, just like most other average people are much more
  interested in beer and sports than their work.

  another argument is that abstraction is something you get used to through
  very hard training, and if you don't get used to it, you won't be able to
  pick it up at random, either.  I don't know exactly how some people get
  better at abstractions than others, but I have no problem understanding
  that some forms of abstractions may require immersion into a field for a
  very long time, but maybe it's more than immersion, and maybe it isn't.

  if it is just a matter of immersion and exposing people to more abstract
  ways of thinking so they get used to it, removing abstractions from out
  of reach of average people is doing them a fundamental disservice and
  patterns is a sure-fire way of never improving the lot of mankind.  if
  there is some genetic quality to abstractions (I don't believe there is)
  that makes only a small portion of the population able to deal with them
  successfully, then patterns is a very good solution to having overreached
  the capacity of the human brain.

  that is, given the current tendency to view people are unchangeable and
  more or less genetically predetermined, "patterns" emerges as a solution
  to the problem of the failure of abstraction to get hold in the masses of
  people who want to write software for money, but the core argument is at
  fault: people are able to learn abstraction if they have to and get used
  to it: expose them to it, and they get it in time.  if they can run away,
  however, most will.  letting them run away is no good solution to the
  fundamental problem of programming in society: we need responsible people
  who don't make stupid mistakes in critical software that is already far
  too complex for the human mind to understand in its entirety.

  I don't think the answer to the core problems can be anything but giving
  people more abstract tools and better tools for abstraction.  I don't
  think patterns is anything but a serious deterrent to learn abstraction
  -- mostly because the variation between applications is supposed to be
  more important than the similarities, which only means that people are
  muddling the issues -- and gain popularity out of a form of despair: we
  can't educate people fast enough, and young people just make too much
  money before they have graduated, or at least hope they can, so we have
  to design something that such people can deal with at their abstraction

  where's Lisp in all of this?  I'll repeat something I said at LUGM'99:
  "Common Lisp is a language you graduate into."  I think people will find
  Lisp suitable after they crave something better than they have been bored
  of repeating.  consider the programmer who realizes "why keep repeating
  this nine-line code fragment all over the place when the function is much
  easily expressed as a MISMATCH function call?" -- that's the kind we want
  to graduate into Common Lisp.  but this won't happen if patterns is the
  best solution they can think of, or they don't realize that patterns are
  intended to keep people who can't handle power tools from hurting people.

  put another way: patterns emerge from people solving problems over and
  over in better and better ways.  abstractions emerge from patterns when
  the confusion of elements in the patterns are isolated and crystallized.
  familiarity with patterns is necessary to forming abstractions, but the
  focus on patterns means that people are allowed to _stay_ confused.