Subject: Re: Design patterns as a weapon From: Erik Naggum <erik@naggum.no> Date: 1999/11/28 Newsgroups: comp.lang.lisp Message-ID: <3152787684905454@naggum.no> * Aaron Gross <aaron+usenet@bfr.co.il> | 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 levels. 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. #:Erik