Designing Adaptable Learning Resources with Learning Object Patterns
Constructing courses of study from learning objects is an attractive proposition, but for this to be feasible learning objects need to be designed to be reusable. While considerable work has been done in producing technical standards to promote compatibility in learning objects, more work is required in designing learning objects for reuse. Aspects of cohesion, coupling and freedom from specific contexts can be used in designs to help ensure that learning objects are reusable, and these aspects can be captured as design patterns that may be employed to produce reusable designs for learning objects. However, the requirements for reusability may be in conflict with those for effective learning so the patterns used must ensure that the learning objects constructed are adaptable to different contexts and remain pedagogically sound within those contexts. The paper shows how patterns can be used to create learning resources that are both reusable and adaptable.
Learning objects are potentially reusable components from which courses of study may be constructed. The economic arguments for their reuse in this manner are compelling: instead of many institutions developing their own materials for a common course, materials in the form of reusable learning objects could be shared across institutions, thus saving the cost of many hours of individual development (Downes 2001). Also, intuitively, it seems clear that building a course from prefabricated components must be quicker and cheaper than starting from scratch. Consequently, it seems reasonable that developers of learning materials should consider designing them as learning objects, in order to promote the reuse of their work. This, of course, begs the question "how do you design a learning object for reuse?"
The use of 'learning object patterns' is proposed as a means to promote reuse through design. Learning object patterns are like templates, or blueprints, from which learning objects can be constructed. Learning object patterns can be thought of as being similar to the patterns used in object-oriented software development.
This paper considers requirements for the reuse of learning objects and how this may be in conflict with the requirements for effective learning. It then looks at how the use of learning object patterns can provide a means of promoting reuse through design and how learning objects can be made adaptable to different contexts. Finally, examples of learning object patterns and how they can be implemented to produce reusable, and adaptable, learning objects is considered.
Considerable work has gone into the definition of technical standards for learning objects. In particular, there are now standards for learning object packaging (IMS 2003), and metadata that describes a learning object (IEEE 2002). These go a long way to enabling learning object reuse. Standardised packaging ensures reusability from a technical standpoint and the deployment of learning objects in a virtual learning environment (VLE). Standardised metadata provides a mechanism for describing content and also aids discovery of learning objects. (Undiscovered learning objects are, of course, unlikely to be reused!)
Conformance to technical standards is not sufficient to allow a learning object to be reused, however. As Boyle (2003) points out, while the work on technical standards is valuable, it is not enough, on its own, to ensure the reusability of learning objects. Little work, it seems, has been done on the design of the learning objects themselves and what design principles need to be employed to make learning objects reusable.
Boyle (2003) draws on software engineering principles to identify 'cohesion' and 'coupling' as important factors in the design of a learning object. A cohesive learning object is one that is single-minded: it is concerned with only with one thing (e.g. a single learning objective or aim). Coupling refers to the level of independence of a learning object. A learning object should, ideally, not have dependencies on other learning objects: it should be "an independent and self-standing unit of learning content" (Polsani 2003).
By maximising cohesion and minimising coupling we adhere to the software engineering principles for the modularisation of software (Pressman 2004). We also make a learning object potentially more reusable as a cohesive object is more likely to be identifiable as a component in a course of study while an object which is tightly coupled to, or reliant on, other learning objects or resources is less easy to incorporate.
A further factor to be taken into account is that of context. The reuse of a learning object implies usefulness within different contexts. For example, a learning object that is concerned with statistics may be usable in a number of subject areas. However, to be useful in one subject area it needs to be free of any significant reliance on any other subject area. The resources need to be designed to be context-neutral in order that learners from any subject area can easily engage with it. On the other hand, the contextualisation of a learning object could be beneficial to the learner, as the learning object would then be seen as more relevant to the subject being studied. Thus while a learning designer would like to make a learning object context-free in order to increase the potential for reuse, the learner may well appreciate an orientation towards the topic under study.
We propose the use of learning object design patterns as a means of capturing the nature of a reusable learning object while providing a mechanism for making it adaptable to different contexts. Discovering and applying these design patterns will, we believe, provide a mechanism for incorporating the requirements for reuse into a resulting learning object and, furthermore, provide a higher-level form of reuse (i.e. reusable designs). In the related area of software development, Rossi et al. (1997) claim that the reuse of architectural (i.e. high-level software design) patterns is more valuable than reusing algorithms and data structures (i.e. content). Similarly, one might claim that the ability to reuse the design aspects of a successful learning resource is of more value than reusing learning objects themselves.
Before exploring patterns further, we shall take a brief look at the pedagogical implications of the requirements for reuse.
An object should exhibit three properties to be reusable: they should be cohesive, decoupled and context-free. However, while reuse may be a laudable aim, it should not be at the expense of pedagogical effectiveness. We need to consider, then, what effect learning objects that exhibit these properties may have on learning.
A cohesive learning object that focuses on one particular topic is probably a good thing from the learner's point of view; indeed, it is difficult to imagine a why something that was not cohesive might be better than one that is. We conclude, then, that this requirement for reuse will not detract from effective learning.
Coupling may be used in two ways: as a navigational mechanism and as a way of linking to external resources that are relevant to the learning situation. In the first case, it is generally considered more appropriate to separate navigational links from the content of a resource in order that the content can be better understood (Rossi et al. 1997) and we can, therefore, conclude that decoupling navigational links will not have a negative effect on learning. However, in the second case the links provide contextual information and thus contribute to the decontextualisation requirement for reuse which we shall consider next.
A number of learning theorists emphasise the importance of context in the learning situation (Wiley et al. 2003). By making a learning resource context free, the learner is not given the opportunity to relate the subject of that resource to the particular subject area they are studying and with which they are, therefore, familiar. Laurillard (2002) concludes that teaching should emulate day-to-day learning by situating knowledge in real world activity. In other words, student learning should be contextualised through activities that are relevant to the subject being learned. This is also the position of those who take a constructivist stance (e.g. Cunningham 1993) where effective learning is said to be achieved through engagement with 'authentic tasks', i.e. the ordinary practices of the subject domain or culture (Brown et al. 1989). Indeed, Jonassen et al. (1993) state that "too often learning materials ... are stripped of contextual relevance" and yet this is precisely what we intend to do in order to make learning objects reusable!
We can see, therefore, that the requirements for reuse and those for effective learning appear to be at odds with each other. Thus one of the major aims of this work must be to allow a decontextualised learning object to be adapted to different contexts, that is, to be re-contextualised for different purposes. Only in this way can reusable learning objects be designed to be pedagogically sound.
Expert practitioners (in any field) do not normally reinvent solutions; rather they rely on their experience of problem-solving in similar contexts in the past and build on these to create a new solution in a new situation.
Patterns encapsulate the knowledge gained from past solutions and can then be used to produce new solutions in similar contexts.
"One thing expert designers know not to do is to solve every problem from first principles. Rather, they reuse solutions that have worked for them in the past. When they find a good solution they use it again and again. Such experience is part of what makes them experts." (Gamma et al. 1995)
Here, Alexander was talking about patterns in building and architecture, but others have suggested that the same definition could be applied to software design patterns.
"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice." (Alexander et al. 1977).
Patterns are used over a wide area of software design. Probably most famously, software design patterns were popularised and catalogued by Gamma et al. (1995), and these have had a significant influence on software design since their publication.
Software design patterns address a particular part of software development that is below the level of software system design but above that of program design. Subsequently, patterns have been published that cover the entire scope of software development (e.g. Trowbridge et al. 2003, Alur et al. 2003, Fowler 2002).
Buschmann et al. (1996) describe patterns for software architecture that cover a wide scope, from high-level design right down to patterns that are found in the way program code is written in a particular programming language. These are defined, in part, as describing a particular recurring design problem that arises in particular design contexts and presents a well-proven scheme for its solution. Each pattern is thus described in a consistent and structured manner in terms of its context (the situation that gives rise to the problem), the problem itself and the solution to that problem. Each pattern is also given a name and possibly a categorisation. Buschmann et al. categorise patterns in three groups: software architectural patterns, design patterns, and program code patterns (or 'idioms'). These represent three levels of abstraction in software design and each level can incorporate patterns of the level below it.
We can imagine a breakdown of course designs, similar to that by Buschmann et al., but into four levels. At the highest level would be the Regulatory layer, which would describe the rules by which a particular award (degree, diploma, etc.) is conferred and the set of modules, or units, that a student must undertake. Below this could be the Module layer, which would specify the syllabus for a particular module and, perhaps, the pedagogical approach that is used by a particular module. Next would be the Activity layer that would describe the types of activity that students would undertake as determined by the pedagogical approach and the syllabus. The bottom layer would be the Learning Object or Learning Resource layer. This final layer would describe the content of the resources that support the activities in the layer above.
As patterns encapsulate experience gained over time, it is not strictly possible to invent a new one: patterns are usually discovered in existing practice. However, since the field of learning objects is relatively new, there is little established practice to gain from and thus we shall not be bound by convention here, and will feel free to borrow, and modify, patterns from other fields, or even invent new ones. The patterns that we 'discover' in this work, while possibly conforming to Alexander's definition, above, may not meet Buschmann's view that they should be 'well-proven'. Any patterns described here may therefore be regarded as potential, or prototype, patterns.
Our motivation for using patterns is to encapsulate the requirements for reuse within a pattern definition. Our starting point will be a simple pattern identified in Boyle (2003) that comprises of a page of text with links to other pages. Each of the links is associated with a particular part of the text but is not embedded within the text; they are, instead, listed in a column separate from the main text. While this pattern is similar to the Navigation Context and Information-Interaction Decoupling patterns (Lyardet et al. 1998, Rossi et al. 1997), the motivation is different. For the purposes of this paper, we shall refer to it as the Decoupled Links pattern.
There are two main reasons for the separation of text and links in a learning object. The first is to aid maintenance, and the second is to help in reusing the learning object or adapting it for use in a different context.
Maintenance of Web pages can be a time-consuming task and always has the potential for accidentally inserting errors or other unwanted changes. As it is not uncommon for Web links to change, the separation of links and text will allow the links to be updated without disturbing the main text, thus removing much of the scope for error.
Adaptation to a different context requires the customisation of a learning object for a particular subject area. A typical use of this pattern is to provide a basic text to support a learning activity along with expanded coverage through links to examples or more in-depth explanations. A learning designer might well want to utilise the main part of the resource but would wish to provide additional, more up-to-date, or more localised, expansions or examples. In this case a new, or modified, set of links could be provided to replace the original. Thus if the resource is to be reused in a different context to its original use, the links may be updated without disturbing the text.
Using the Decoupled Links pattern can satisfy the previously identified requirements for reusability: the learning object can be written to be entirely cohesive and it can also be completely decoupled from related resources. Furthermore, while the main part of the learning object can be designed to be entirely context-free, the decoupled expansions can be used to provide contextual information for different subject areas.
We claim this to be a pattern in the same mould as the software patterns referred to above. To demonstrate this is indeed the case we should document it using the structured description used for those patterns. The following description is based on the documentation template described above. We name the pattern, give the context to which it relates, describe the problem it addresses, then outline the solution that the pattern provides, and finally give an example of its potential use.
A topic is common across a number of domains of knowledge and so a common learning resource could be used. However, in any particular knowledge domain, it would be pedagogically advantageous to provide contextual details from the domain being studied.
It is desirable to be able to reuse learning resources across different learning contexts, and in order that the resource supports each of the contexts in which it is to be used, it should be designed to be free of any one of them. On the other hand, within any particular context, it may be helpful from a pedagogical point of view to include context-specific material such as case studies or domain specific examples.
There is, therefore, a tension between the desire to enhance reusability by making the resource context-free and the desirability of making it relevant to the learner within a specific context.
Design the main part of the learning resource to be completely context-free but identify the places within the resource where useful contextual information could be provided. Include within the resource the ability to link to external expansion resources and, for each context in which the main resource is to be used, implement these expansion resources.
The complete resource, therefore, consists of a main context-free part along with optional expansions that provide context-specific content. These expansions can be included with the main resource when it is built for a particular context, or dynamically linked in at runtime.
Mathematical techniques are used in a number of different fields. For example, trigonometry can be studied as a pure subject but is also necessary in the understanding of navigation (through space or on the sea) or in the use of a surveyor's theodolite. A learning resource giving a theoretical explanation of trigonometry could be entirely context-free and might be suitable for use in a pure maths course. However, those learning to navigate, or to be surveyors, might benefit from examples that are specific to their particular discipline. To cater for each of these cases a main context-free resource could be developed along with two sets of expansions that contain examples or further material. One of these would be designed to be suitable for navigators and the other for surveyors.
The learning object pattern discussed above can be readily represented as one or more XML files. The Decoupled Links pattern may be simply represented as two such files: one containing the main content and the other containing links to material that complements the content in a particular learning domain. Within the representation of the data there needs to be some reference that shows the association between the individual parts of the text and the link file. This sort of association can be simply represented in XML through the use of specifically designed tags or attributes. The following listing shows a simple XML representation of the main text in a learning object based on the Decoupled Links pattern.
We can see that the entire content is enclosed in a <topic> tag and the purpose of this tag is simply to keep the rest of the content together as a single unit. Within this tag are two <section> tags that separate the content into two parts and, through the id attribute, label these sections with a name.<topic> <section id="section 1"> This is the text that comprises the content for section 1 </section> <section id="section 2"> This is the text that comprises the content for section 2 </section> </topic>Listing 1. XML representation of the content
The links can be represented equally simply.
Here the entire content is enclosed in a <links> tag and each individual link is represented as a standard HTML anchor tag inside a pair of <link> tags. To make the relationship between the links and the sections of content, the id attribute of the <link> tag is given the same value as the section to which it is related.<links> <link id="section 1"> <a href="someurl">This is the link for section 1</a> </link> <link id="section 2"> <a href="anotherurl">This is the link for section 2</a> </link> </links>Listing 2. XML representation of the links
This is a simple data model that could be easily combined and transformed into an HTML table using an XSL stylesheet or other programmatic means.
|This is the text that comprises the content for section 1||This is the link for section 1|
|This is the text that comprises the content for section 2||This is the link for section 2|
This model meet the aim of being able to maintain the links and the content separately and also enhance adaptability by allowing the possibility of changing either the content or the links for use in a different context. In this example, we suggested that the links would refer to expansions of the core content or provide examples. Changing the link file and recombining would allow this adaptation in a straightforward way.
The Learning Objects for Introductory Programming project (Pickard et al. 2003, Jones et al. 2003) was a blended approach to the teaching of programming in the Java language (Boyle et al. 2003). A major part of the project was the design of learning objects that dealt with specific topics in introductory programming. Two levels of learning object were employed: compound objects that introduced a topic and gave simple examples, and expansion objects that contained explanatory text or animations. The expansion objects were linked to the compound objects using the Information-Interaction Decoupling pattern (Lyardet et al. 1998, Rossi et al. 1997), in that the navigation links to the expansion objects were separated from the main content of the compound object. (It was a design aim that these compound objects should be adaptable to local use through the provision of locally authored expansion objects.) However, this separation of navigational links was implemented only in the user interface; the links were still embedded in the HTML code that implemented the learning object and thus true decoupling was not achieved.
Each of the learning objects from the programming project was designed with a similar structure. We shall first analyse the structure and identify common patterns and then we shall then show how these patterns can be implemented in XML. The result will be a design structure that will help future designers to replicate the structure of the original learning objects and also to easily adapt the existing learning objects to suit a different contexts. To demonstrate the latter we shall produce a resource that can be adapted to support a number of different programming languages.
Title of the topicIntroductory text goes here.
First headingExplanatory text for the first section.
Heading for example
Further headingMore text, more text, more text, more text, more text.
<link>Expansion of introduction</link>
<link>Expansion of example</link>
Figure 1. Format of a compound learning object
One of the aims here is to make the learning objects reusable in different contexts, and we seek to do this by making them cohesive, decoupled and context-free. The compound learning objects are already quite cohesive and we can see clearly that the use of the Decoupled Links pattern would provide properly decoupled expansion objects (thus allowing the customisation of the compound learning object through the provision of different expansion objects). Decoupling the expansion objects also provides a certain freedom from context. However, by incorporating examples in the Java programming language, the learning objects cannot be satisfactorily reused in the context of a different programming language.
One solution that would make the resource completely context-free would be to ensure that the examples were independent of the programming language used. This could be done by using a pseudo-code language and providing language-specific examples in the expansion objects. However a more satisfactory solution would be to arrange for the examples to be adapted to the appropriate programming language for the particular situation.
This is a similar problem to the one solved by the Decoupled Links pattern and an adaptation of that pattern (we propose calling it Decoupled Insertions) will provide a solution. It can be described thus:
On the face of it, this pattern looks extremely similar to the Decoupled Links pattern and appears to solve a similar problem. However, there is a fundamental difference in the resulting learning object. In the case of the Decoupled Links pattern, the result is a compound object that has two clearly separable parts. In the Decoupled Insertions pattern the result is a single entity that is the result of a modification of the original.
A topic is common across a number of similar domains of knowledge and so a common learning resource could be used. However, in any particular domain, it would be pedagogically advantageous to incorporate contextual details in the form of examples or illustrations from the particular domain being studied.
It is desirable to be able to reuse learning resources across different learning contexts, and in order that the resource supports each of the contexts in which it is to be used, it should be designed to be free of any one of them. On the other hand, within any particular context, it may be helpful from a pedagogical point of view to include context-specific material such as examples or illustrations within the material that is to be presented.
There is, therefore, a tension between the desire to enhance reusability by making the resource context-free and the desirability of making it relevant to the learner within a specific context.
Design the main part of the learning resource to be completely context-free but identify the places within the resource where examples or illustration could be incorporated. Include within the resource the ability to insert material from external resources and, for each context in which the main resource is to be used, implement these expansion resources.
The complete resource, therefore, consists of a main context-free part along with insertions from external resources that provide context-specific examples or illustrations. These insertions can be included with the main resource when it is built for a particular context, or dynamically linked in at runtime.
In many resources that are aimed at teaching computer programming the concepts are similar, or the same, no matter which programming language is being used. A resource that explains programming concepts in a language-independent way could have examples in the language of interest inserted at appropriate points.
A foreign language phrase book will contain the same phrases no matter which language they are to be translated into. Using this pattern the main resource would be written in the 'home' language while insertions would be in the particular target language required.
In redesigning the case study object we will keep to the existing presentational style and structure but incorporate the two patterns that have now been identified.
An XML representation of the compound learning object is shown in Listing 3.
The XML in Listing 3 is similar in structure to that of Listing 1. The main difference is the <insert> tag, which is a reference to the content to be inserted from another file. This structure provides the requirements for both reusability and adaptability. The compound learning object is completely cohesive and it is completely decoupled from the links and the example content to be inserted. It can also be written to be entirely free of the context of a particular programming language.<topic> <heading>Title of the topic</heading> <section id="1"> <text> Introductory text goes here. </text> </section><section id="2"> <heading>First heading</heading> <text> Explanatory text for the first section. </text> </section><section> <heading>Heading for example</heading> <insert id="1"/> </section><section id="3"> <heading>Further heading</heading> <text> More text, more text, more text, more text, more text. </text> </section> </topic>Listing 3. XML representation of the proposed compound learning object
An example screenshot is shown in Figure 2. It is a simplified and adapted
version of a compound learning object that is intended to illustrate a particular
form of repetition in a programming language (in this case Java). The text within
the compound object is written to be neutral with respect to the programming
language in question while the example program code that is inserted into the
compound object is written in a particular programming language. The links to
expansion material are in one case general, and would thus be the same no matter
which was the targeted programming language, and in the other case contain more
example program code, and would thus be different depending on each programming
Figure 2. Example adaptable learning object (Java version)
(click on image for larger version)
The example in Figure 2 is adapted for the Java programming language. By changing
the links and the inserts file, a new version is simply produced. Figure 3 shows the
same example for the Visual Basic programming language.
Figure 3. Example adaptable learning object (Visual Basic version)
(click on image for larger version)
In the example given, there is no syntactic requirement for any links at all. If an empty link file were to be supplied this would result in the decoupled learning object being rendered as it stands. On the other hand, a link may be provided for any of the labelled 'sections'; so, for example, where there is a section labelled "2", a link may be provided that has the same identifier.
The main learning object must therefore be properly documented in order that the link affordances are easily identified. Futhermore, guidelines for the design of decoupled learning objects must be adhered to in the design of the main learning object, in order that it is meaningful even if no links or insertions are provided.
This paper has illustrated the potential of design patterns in producing reusable and adaptable learning resources. However, it is envisaged that patterns could be developed into a complete framework that encompasses four levels of use. Patterns could describe, and be used as templates to define, entire courses (Regulatory level); they could encapsulate the structure of a syllabus and the pedagogical approach used to deliver it (Module level); they could be used to define the structure of the particular activities that learners and teachers engage with, such as lectures, laboratory sessions or seminars (Activity level); and, as shown here, they can be used to produce materials that are reusable and adaptable at the Learning Resource level. This framework, and associated patterns, will be developed further.
While learning designers can use such patterns as design concepts, authors will require tools that enable them to construct learning objects in a straightforward and intuitive way. The patterns must be incorporated, as templates, into an e-learning authoring environment such as the high-level Web page authoring tools that are in common use. A fruitful way forward here may be the trend towards using XML as a format for word processor files (e.g. Eisenberg 2004). Using such a tool, it is possible that the format for patterns could be directly represented as word processor templates and the resulting XML output could be easily transformed into the appropriate format for further processing.
Additionally, authors will require guidelines to a much greater level of detail than is provided here, in the design and documentation of pattern-based learning objects and in the relationship between the main object and the additional files that provide the additional contextual content.
Boyle, T., Bradley, C., Chalk, P., Jones, R. and Pickard P. (2003) "Using blended learning to improve student success rates in learning to program". Journal of Educational Media, special edition on Blended Learning, 28 (2-3), 165-178
Eisenberg, J. David (2004) OpenOffice.org XML Essentials (O'��√�Reilly and Associates, Inc.) http://books.evc-cit.info/
IEEE Learning Technology Standards Committee (2002) Learning Object Metadata, Final Draft Standard, IEEE 1484.12.1-2002 http://ltsc.ieee.org/wg12/20020612-Final-LOM-Draft.html
IMS Global Learning Consortium, Inc. (2203) IMS Content Packaging Information Model, Version 1.1.3 Final Specification http://www.imsglobal.org/content/packaging/cpv1p1p3/imscp_infov1p1p3.html
Jonassen, D., Mayes, J. T. and McAleese, R. (1993) "A Manifesto for a Constructivist Approach to Technology in Higher Education". In Designing Constructivist Learning Environments, edited by T. Duffy, D. Jonassen and J. Lowyck (Heidelberg: Springer-Verlag)
Jones, R., Boyle, T. and Pickard, P. (2003) "Objectworld: helping novice programmers to succeed through a graphical objects-first approach". 4th Annual Conference of the LTSN Centre for the Information and Computer Sciences, Galway, 26-28 August http://www.ics.ltsn.ac.uk/pub/conf2003/ray_jones.htm
Lyardet, F., Rossi, G. and Schwabe, D. (1998) "Using design patterns in educational multimedia applications". In EdMedia and EdTelecom '98, Proceedings of the 10th World Conference on Educational Multimedia and Hypermedia, edited by T. Ottman and I. Tomek (AACE)
Pickard, P., Chalk, P. and Jones, R. (2003) "Creating and employing on-line dynamic learning objects for an introductory programming module". 25th Conference on Information Technology Interfaces, Dubrovnik, June 16-19
Polsani, P, (2003) "Use and Abuse of Reusable Learning Objects". Journal of Digital Information, Vol. 3, No. 4, Article No. 164, 19 February http://jodi.tamu.edu/Articles/v03/i04/Polsani/
Wiley, David (2001) "Connecting Learning Objects to Instructional Design Theory: A Definition, a Metaphor and a Taxonomy". In The Instructional Use of Learning Objects, edited by David Wiley (Association for Instructional Technology and the Association for Educational Communications and Technology) http://www.reusability.org/read/
Wiley, David, Padron, Sandie, Lambert, Brent, Dawson, Deonne, Nelson, Laurie, Barclay, Matthew and Wade, David (2003) "Using O2 to Overcome Learning Objects Limitations". Learning Objects 2003 Symposium: Lessons Learned, Questions Asked, Honolulu, Hawaii, 24 June http://www.cs.kuleuven.ac.be/~erikd/PRES/2003/LO2003/Wiley.pdf