e-Literate

Present is Prologue

Category: Academics & Academia

The “Academics and Academia” category covers topics related the ways in which colleges and universities function that are relevant to technology-supported education. One key aspect covered here is pedagogy—how people teach—and how technology impacts teaching and learning.

But this category also includes more institutional aspects that are relevant to technology-supported education, such as how campus leadership supports (or doesn’t support) new initiatives, politics and bureaucracy that impact these efforts, and so on.

Finally, “Academics and Academia” covers commercial and non-profit services that provide support for technology-supported education initiatives, such as Online Program Management (OPM) companies.

  • Re-usable Learning Content Objects or Re-usable Learning Experience Objects?

    Yesterday, Stephen Downes replied to my most recent post on educational pattern languages:

    Michael Feldstein is on the right track, mostly, with his exploration of the applicability of pettern language to learning. In this brief item, he asks, “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?” And I respond – where was it written that language must be composed of building blocks strung together?

    The glib answer would be “Aspects of a Theory of Syntax, Noam Chomsky, 1967.” (I happen to live with a linguist, in addition to having taken more than a few linguistics courses myself.) But as I say, that would be the glib answer, because I’ve read enough of Stephen’s work to know that his position on learning objects is considerably more sophisticated than saying “Sorry, no such thing.” To be honest, I’m not 100% sure what Stephen’s objection is here, but I do have a suspicion, and it has to do with some ideas he laid out in his paper “Design Standards and Re-usability”.

    (more…)

  • 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?

  • Educational Conversation Pattern: Role-Playing Simulation

    Here is another tool that affords a particular educational conversation pattern. This time the pattern is role-playing simulation

    I may have to start a new site theme for this stuff.

    (Found via thee-Learning Centre.)

  • Web Collaborator

    A couple of posts ago I briefly touched on the idea of developing a pattern language of educational conversations and building tools that support particular patterns. Web Collaborator is a good example of what this might look like. Basically, it’s a single discussion thread tied to a single wiki page. The wiki is for collaborative writing of a document and the discussion thread is for editing process conversations about the document. The wiki also logs document changes and has a roll-back feature. As a bonus, it provides a log of who contributed what, so instructors have at least some measure of each member’s contribution to the group product. The educational conversation pattern that it affords might be called something like “Small Group Collaborative Writing.”

    (Found via Weblogg-ed.)

  • digital amalgam :Going Wide or Going Deep? Blogs or Discussion

    Jim Woodel has a thoughtful blog post in response to the Complese class blog that I noted in my own last post.

    Here’s a sample:

    I really, really like the idea of either discussion tools or blog tools that give the instructor some ability to manipulate display based on pedagogy. I’ll have to do some thinking about what this might look like if the instructor wanted, say, problem-based learning to be happening. Could the instructor have the display organize posts by steps in a problem-solving process?

    Right on. What discussion board designers really need is a pattern language of educational conversations. What are the types of interactions that teachers want to have with students and what sorts of affordances support those different conversations?

    Woodel also added an interesting comment to my original post (which is how I found his blog).

    As a side note, I think I’m going to need do something to make posts with comments on them more conspicuous. As far as I’m concerned, the reader responses are at least as important as anything I have to say; and yet the current interface of my blog makes it easy to miss them. Expression Engine probably has a “recent comments” function or plug-in; I’ll look into it.

  • 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.