e-Literate

Present is Prologue

Tag: Christopher-Alexander

  • Pattern Languages as Human Languages

    Here is the text of a speech that pattern language inventor Christopher Alexander gave in 1996 to The 1996 ACM Conference on Object-Oriented Programs, Systems, Languages and Applications (OOPSLA). There is a lot –a lot— in this speech that makes it interesting and fulfilling reading (and entirely applicable to online learning and knowledge sharing). I’ll give just one example here:

    What, now, of my evaluation of what you are doing with patterns in computer science. (Bear in mind, as you hear my comments, that they need to be taken with a grain of salt; I’m ignorant; I’m not in your field.) When I look at the object-oriented work on patterns that I’ve seen, I see the format of a pattern (context, problem, solution, and so forth). It is a nice and useful format. It allows you to write down good ideas about software design in a way that can be discussed, shared, modified, and so forth. So, it is a really useful vehicle of communication. And, I think that insofar as patterns have become useful tools in the design of software, it helps the task of programming in that way. It is a nice, neat format and that is fine.

    However, that is not all that pattern languages are supposed to do. The pattern language that we began creating in the 1970s had other essential features. First, it has a moral component. Second, it has the aim of creating coherence, morphological coherence in the things which are made with it. And third, it is generative: it allows people to create coherence, morally sound objects, and encourages and enables this process because of its emphasis on the coherence of the created whole.

    I don’t know whether these features of pattern language have yet been translated into your discipline. Take the moral component, for example. In the architectural pattern language there is, at root, behind the whole thing, a constant preoccupation with the question, Under what circumstances is the environment good? In architecture that means something. It means something important and vital that goes, ultimately, to the nature of human life. Of course, there are plenty of people who will debate whether the question is objective. Some architects are still going around saying, It is all a matter of opinion. But that is a dying breed. The moral preoccupation with the need for a good environment, and for the living structure of built environment, and the objective nature of that question, is largely accepted. I do not know whether that sort of moral component exists in computer science, or in software engineering, or in the way in which you do things

    Under what circumstances is an educational experience good? What are the signature characteristics of a useful, fulfilling, and above all, morally enriching educational conversation? Can we decompose that conversation into fundamental building blocks? Can we deduce sort of generative grammar of educational experience that enables us to string together these building blocks into “sentences” of educational experience that are complete in both the functional and the humanistic sense?

  • Pattern Languages and Learning Objects

    It took me a while to find it on my shelves, but I finally dug out Patterns of Software: Tales from the Software Community, which is a book on applying Christopher Alexander’s ideas to software engineering. For a good chunk of this book, you could take out words like “software,” “code,” and “objects,” and substitute “courses,” “content,” and “learning objects” without too much problem.

    Here’s a good example:

    What gets in the way of software [courseware] habitability is overdesign, overabstraction, and the beautiful, taught monument of software [the Course]. Alexander calls this large lump development:

    Large lump development hinges on a view of the environment which is static and discontinuous; piecemeal growth hinges on a view of the environment which is dynamic and continuous….According to the large lump point of view, each act of design or construction is an isolated event which creates an isolated building–“perfect” at the time of its construction, and then abandoned by its builders and designers forever. According to the piecemeal point of view, every environment is changing and growing all the time, in order to keep its use in balance; and the quality of the environment is a kind of semi-stable equilibrium in the flux of time….Large lump development is based on the idea of replacement. Piecemeal growth is based on the idea of repair.

    Recall that one of the tenets of encapsulation is that the interface [content] be separate from the implementation [context] because this permits the implementation [context] to be replaced when needed.

    The problem with traditional approaches to abstraction and encapsulation is that they aim at complete information [context] hiding. This characteristic anticipates being able to eliminate programming [rewriting] from parts of the software development [instructional design] process, those parts contained within module boundaries. As we’ve seen, though, the need to program [design] is never eliminated because customization, modification, and maintenance are always required–that is, piecemeal growth.

    Good stuff!

  • Let's All Live In Jay's House

    I’m insanely jealous. It turns out that Jay Cross lives in a house built by the great architect Christopher Alexander. I’m a huge fan of Alexander’s work. Furthermore, I think anyone who does instructional design should read Alexander’s book. No, I don’t mean The Nature of Order, which is the book that Jay is apparently reading now; I haven’t read that one yet (though I intend to). I mean A Pattern Language: Towns, Buildings, Construction.

    To begin with, if ever there was a book that prefigured hypertext, this is it. Written in 1977, it is a honeycomb of short, cross-referenced entries. You can’t really read it cover-to-cover; instead, you browse. You scan. You jump around. You…surf.

    But the real value is in the way Alexander changes your thinking about design. In stark contrast to the whole idea of architect as designer and architecture as engineering, Alexander sees the architect as an ecologist and architectural design as the product of natural selection. He points to the distinctive qualities of old buildings throughout the world that have stood for hundreds or thousands of years while other buildings around them were torn down. What qualities do they have in common? What features can we deduce as natural, as creating a pleasurable and healthy living environment? What remains useful to people generation after generation? And what remains beautiful? What are the patterns that emerge?

    Then notice how these things fit together. Certain patterns will fit together nicely while others will not. There is a grammar for stringing together architectural elements, Alexander argues. A natural language. A pattern language. If you surf his book and see the pictures, I’ll bet money that you’ll become convinced he’s right. I did.

    We should be thinking about our instructional design, our information architecture, and our software user interfaces in the same ways. Despite the newness of computers, there are going to emerge more or less natural ways of interacting with it. The only way to find out what the more natural ways are is to let people build their own systems, move the furniture around, tear things down, and start over again. That’s hard to do with software, though HTML makes it somewhat easier by lowering the knowledge requirements. (Hypercard was probably the first step in this direction.) Likewise, we need course management systems that are highly configurable, allowing instructors to experiment with plugging in new pieces and arranging them in different ways. And above all, we need a pattern language for learning objects.

    Perhaps this sounds like a stretch. If so, then it’s not the furthest stretch that anyone has made with Alexander’s work. Software engineers have taken to pattern languages big-time.