E-learning Frameworks = (Design Patterns + Software Components) ... shows how educational software can be developed based on the idea of e-learning ..... components, such as chat, audio, video conferencing, virtual white board, which ...
E-learning Frameworks = (Design Patterns + Software Components) Rafael A. Calvo and Aiman Turani Web Engineering Group, School of Electrical and Information Engineering, The University of Sydney, Australia [rafa, aimant] @ ee.usyd.edu.au
Introduction This chapter shows how educational software can be developed based on the idea of e-learning frameworks that contain educational design patterns and software components to help teachers build effective learning experiences online. We look at how the framework approach has been applied in Beehive, a new pedagogical framework for synchronous collaborative learning and we describe an evaluation in which instructional designers assess the approach and its implementation. Experience shows that high quality architectural designs can only be achieved by very qualified professionals, spending large amounts of time and effort. Software engineers aim to produce high quality software at the lowest cost/effort possible so in their quest they adopted and repurposed Alexander’s (Alexander et al., 1977) ideas about design patterns and pattern languages in urban design. In the 80's, patterns were used by the software engineering community as a way of communicating useful and proven software designs. This work was established as core to the software engineering profession, and the technique, along with common patterns are taught in all undergraduate degrees (Gamma, Helm, Johnson, & Vlissides, 1995). Software (and other digital media) has an attribute that buildings do not: it can be copied at no cost and without loosing its quality. This has created a common understanding that ‘reuse’ is important and valuable. Software engineers aim to improve the reusability of good design as it can be done with design patterns, and the reusability of ‘implementation’, where the source code of computer programs can be used many times over with minimum change. The most commonly used approach to reusing code is very straightforward. A software developer writing a program can use a ‘library’ that provides a set of functionalities (e.g. input/output functionalities). By just inserting the appropriate library into his program, all its functionalities become available to his own code, and can be used as needed. This approach does not prescribe the way in which the developer designs his program. This reuse technique has the advantage of giving freedom to the developer, but does not provide any assurance of consistency or good design as no scaffolding or design advice is provided with the library. As the awareness of the need to reuse, not just functionality, but good design increased, and after a decade of using design patterns, software engineers started developing ‘application frameworks’: tools that combine the two types of reusability. In 1997 Johnson described software application frameworks in a paper entitled ‘Frameworks = (Components + Patterns)’ (Johnson, 1997) from which we borrowed ideas, and the title of this chapter. The quest for higher quality at a lower cost/effort is common to most human endeavours. Learning opportunities provided by E-Learning technologies are encouraging organizations, such as universities and corporations, to systematically invest in them to enhance the learner
experience and reduce the cost of training. However, success depends on teachers and trainers incorporating these technologies effectively into their pedagogical designs, so organizations are also investing in professional development programs. The idea of reuse has generated an interest in reusable learning objects. However the building of large repositories of discrete pieces of learning can be difficult, expensive, and often insufficiently flexible for many types of higher learning. Reusing the content in learning objects can reduce development effort for teachers in the same way that by reusing the source code of a library, programmers reduce their own efforts. This reuse does not prescribe how the teacher actually designs the learning activity. It might give more freedom of choice, but it does not actively promote good learning design. This book and the many research projects on design patterns, show a renewed interest in the reuse of the design of learning activities (McAndrew, Goodyear, & Dalziel, 2006), as separate from any topic-specific content. For example, the structure of collaborative learning activities (such as debate, brainstorming, guided discussion, etc.) can be reproduced online in a variety of ways. However, there are certain design patterns that research has shown to be particularly effective for learning within the online environment. Software tools can be structured in a way that supports these patterns and helps instructors use and apply them to new learning scenarios. In this chapter we present the concept of ‘e-learning frameworks’, systems that, aim to improve the reusability of design and implementation by following the practices originated in software engineering. In Section 2 we introduce the concept of e-learning frameworks as a combination of Learning Design Patterns with the implementation of software (components). We analyse the similarities between the educational and engineering domains, and explore how far the frameworks metaphor can be taken. Section 3 describes current pedagogical models that were used to implement Beehive, an e-learning framework for synchronous collaboration. Section 4 describes Beehive’s implementation. Section 5 concludes.
Framework = (Patterns + Components) Software components are built so they can be reused by a programmer who does not need to know how the component is implemented, and only needs to know how the functionalities the component provides can be accessed. This is done by what engineers call ‘abstractions’. Components must be easily connected to make new systems that are customisable and efficient. In Education, practitioners reuse learning materials in an unstructured / manual way or by using Learning Objects. Learning Management Systems (LMS) also provide tools that allow students to perform common tasks (e.g. a discussion or submitting an assignment), allowing teachers to incorporate these functionalities into their learning designs. In both cases, systems allow teachers to ‘reuse’ objects or activities, without prescribing a design, or even scaffolding the design process. Teachers must redesign the overall learning activity from scratch for every new course. Engineers have brought together both types of reuse (design and implementation) in the form of application frameworks. Although their definition varies, a common definition is “the skeleton of an application that can be customized by the application developer”. Table 1 lists some terms as used in the software engineering literature and what they would correspond to in our e-learning frameworks concept. Using this table, the above statement would translate to ‘the skeleton of a learning activity that can be customized by the instructional designer’. By learning activity here we mean the actual teaching (not just the design). The learning activity is divided in tasks, each of which will be performed by the teachers and/or students.
Table 1: terminology in the Engineering and the Education domains Software Engineering
Education
Developer
Teacher / Instructional Designer
End User
Student / Learner
Application
Learning Activity
Component
Task
The primary benefits of application frameworks are modularity, reusability, and extensibility (M. Fayad, Schmidt, & Johnson, 1999), each of which can be mapped to a simile in our e-learning framework concept: •
Framework modularity helps improve software quality by localizing the impact changes in design and implementation, and therefore reduce the effort required to understand and maintain the software. An e-learning framework that is modular means that if we replace a task (e.g. ‘group students randomly’) for a new way of doing it (e.g. ‘group students by age’), the overall learning activity is not affected.
•
Application frameworks enhance reusability by defining generic components that can be reapplied to create new applications. Also, the framework reusability aims to avoid recreating common design solutions to recurring application requirements and challenges. An e-learning framework that is reusable means that the tasks (e.g. the grouping tool) that make an activity can be reused in other activities.
•
Framework extensibility is one of the most important attributes of a framework. Extensibility is essential to ensure scalability, in which new application services and features can be added easily. An e-learning framework that is extensible means new tasks can be added easily.
In order to promote (or enforce) a particular set of design strategies, software frameworks invert the interaction model by which software traditionally integrates functionalities. The technique is called ‘Inversion of Control’ (IoC) or ‘Hollywood principle’ –“Don’t call us, we’ll call you”. By giving the control flow to the framework, the developer does not need to make some design decisions (e.g. the order of execution of individual components), they are made by the framework. On the other hand, frameworks restrict the way developers do things, each framework requiring different levels of ‘design compliance’. In practice, this makes the development of applications using software frameworks harder to learn, but once a developer becomes proficient with it, the quality of outcomes and the productivity of the developer increase (M. Fayad, D. Schmidt, and Johnson, R, 1999). As mentioned earlier, in the mid 80s’ software engineers started using design patterns as a way of communicating and reusing good architectural designs. Around 10 years later, in 1995, the Pedagogical Pattern Project (PPP) started to encourage the capture and dissemination of successful teaching/learning experiences using the pattern approach. Because educational design patterns take into account both material and social issues, they are closer to Alexander’s notion of design patterns (Baggetun, Rusman, & Poggi, 2004) than software design patterns. The relationship is still there, and is explored in more detail elsewhere in this book. Software application frameworks are also different from our e-learning framework, but we believe that the similarities can be used to build better e-learning software.
Implementation of Collaborative Learning Patterns A key design issue to developing frameworks is how components (tasks) make up applications (learning activities) that are based on one or more design pattern. A two-layered framework, where the top layer refers to the patterns and the lower to components, may combine m patterns that are different configurations of one component (General m-1 model). It may also combine one pattern with one component (specialized 1-1 model) or it may combine many components to achieve one pattern (component-based 1-m). We focus here on analysing the specific case of e-learning frameworks that support Computer Supported Collaborative Learning (CSCL) so the top layer shows the collaborative patterns, while the lower represents CSCL components.
General-based Model (m-1) Instructors are often required to evaluate carefully different activity structures, that would support students’ learning outcomes. They are often also required evaluate the available technologies that would enable each activity structure. Paulsen (Paulsen, 1995) considered the need to test pedagogical inventions that can foster online collaboration. He tried to define a model for implementing various pedagogical patterns using Computer Mediated Communication (CMC) tools. This model (‘m-1’) mainly tries to map more than one (the ‘m’) pedagogical design patterns to a single general communication tool (the ‘1’), as presented in Figure 1. The first layer is the most general layer, as it describes the different collaborative learning patterns. Paulsen (Paulsen, 1995) first defined a model for pedagogical Computer Mediated Communication (CMC) dividing the existing techniques into four groups according to four communication tools categorised as in Figure 2. The first category contains all techniques that can be conducted via one-alone tools, such as retrieving information from online resources without communication with the instructor or other learners. The second category relates to the one-to-one tools like e-mail applications. The third category groups the one-to-many tools (announcement boards). The final is the many-tomany tools (computer-conferencing systems or discussion forums).
Figure 1: The m-1 model
Figure 2: Collaboration technique categories This approach has not been adopted widely, due to the technical difficulties of implementing different techniques using the same tool. This approach requires a high level of expertise by participants on both levels. They need to fully understand the structure of the solution part of the pattern and how to manipulate the general communication tools to perform that pattern. For example, in the following example of a Debate pattern (Paulsen, 1995), participants need to implicitly understand and memorize the pattern’s solution before engaging in a Debate chatting session which significantly increases their cognitive load. The facilitator has an enormous responsibility in making sure that participants are engaging in the right manner and sequence.
•
Name: Debate
•
Problem & Context: This technique is ideal for clarifying a controversial issue by presenting the best argument for or against the proposal. This interaction strategy is used to help learners develop their critical thinking and listening skills.
•
Solution: 1. The proposer proposes the motion. 2. The second proposer seconds the proposer. 3. The opposer opposes the motion. 4. The second opposer seconds the opposer.
5. Speakers participate from the floor. 6. The proposer sums up for the motion. 7. The opposer sums up for the opposition. 8. All participants engage in voting on a particular side. Generic communication tools are also not always appropriate or sufficient to smoothly implement certain learning patterns. In fact, for most collaborative patterns, these individual tools are insufficient. For example, an instructor, who wants his learners to participate in a brainstorming activity, might be forced to restrict his selection to a bulletin board and a text chat, but an online brainstorming activity would probably require more functionality in order to be effective. It might also require, for example, an idea chart to keep track of the ideas that arise during the session, a stopwatch tool to keep track of the time, a chat area for discussing the ideas as they arise, a voting tool for deciding on the best idea, and a tool that enables a group chairperson to post the winning idea to other groups. Moreover, there are instances when only certain participants should be able to access certain tools at certain times. Clearly, it is common for more than one simple tool to be required and integrated, in order to carry out one type of collaborative pattern effectively.
Specialised-based Model (1-1) The second model (‘1-1’) for building software that supports collaborative learning involves providing instructors with a specialised tool for each collaborative learning pattern. In current E-Learning systems, there have been many attempts to develop specific tools for specific pedagogical techniques. The L3 (Wessner & Pfister, 2000) project developed a series of PoCs (Point of Collaboration) tools (such as the Brainstorming tool, Pro/Contra tool, and Group Discussion tool). Other projects have also developed specific pedagogical tools, such as the FACILITATE (FACILITATE), Fablusi (Fablusi), and COLLAGE (Hernández-Leo et al., 2006). This approach to build specific pedagogical tools is difficult to implement and reuse, due to three main reasons: 1- The large number of possible collaborative techniques (over 100 techniques (Baumgartner & Bergner, 2003)). 2- Different instructors might perform the same collaborative technique in different ways. 3- Instructors should be able to design new and customised collaborative learning activities and techniques.
Component-based Model (1-m) The third model (‘1-m) is based on the idea that many (‘m’) components can be used to build a single (‘1’) learning activity. Tools like LAMS ("LAMS Wiki", 2008; McAndrew, Goodyear, & Dalziel, 2006) provide instructors with a set of components that they select to form a sequence to support their collaborative activity designs. Since the design puts together the interactions between learners, their instructors, the tasks they undertake, and the outcomes they deliver, the challenge to this approach is the complexity of collaborative learning designs. LAMS has become a popular tool for providing an easy to use interface. A repository of ‘sequences’ allows teachers to share them, together with their experience of using them, resembling what we define as patterns. But in platforms like this, where the focus of the tool is on the managing the units and not the sequences, teachers still face the challenges related to the particularities of a pedagogical
pattern and of assembling the appropriate CSCL components needed for the implementation of that pattern.
The Beehive e-learning framework We implemented Beehive, an e-learning framework for synchronous collaboration by first modelling some of the research-based pedagogical techniques (brainstorming, debate, and jigsaw). We found out that there are many common tasks embedded within them, such as forming groups, provisioning topic information, voting, group discussion, etc. We have implemented these tasks as software components (Turani, Calvo, & Goodyear, 2005; Turani & Calvo, 2006), and successfully reused them to form many other well-known pedagogical techniques (group nomination, group discussion, round-table discussion, role playing, etc.). Identifying these tasks has helped us in defining software components that can be automatically mapped to these tasks, hiding the technical difficulty from instructional designers. The tasks repository, shown in Figure 3, includes the 29 common tasks and presents them according to five categories. This enables the instructor to identify the desired tasks needed in his design.
Figure 3: Task repository Although tasks are a core component in designing collaboration activities, they are not sufficient to run the activities. A collaboration script (a form of pedagogical language) is needed to organise
these tasks in a certain order according to the activity’s basic scenario. Identifying a collaboration script is not trivial, since pedagogical patterns take into account both material and social issues. Roles and group settings need to be specified, along with their tasks. There is a big potential benefit from applying this new paradigm in the ability of recording successful collaborative activity structures that can be applied to other teaching situations. An example script of the Group Nomination pattern is presented in Table 2. This formal representation enables systems to facilitate Group Nomination sessions in a systematic way.
Scene
Instruction
Actor
Audience
Tool
Timing
1
Read the problem statement
None
Individually
Static Info Viewer
2 min
2
Post your solutions
All
Small Group
Ideas Chart
5 min
3
Discuss the listed solutions
All
Small Group
Group Discussion
10 min
4
Mark the listed solutions from 1-10
All
Small Group
Idea Voting
1 min
5
Report the selected solution
Chair-
Wide Group
Result reporting
1 min
Person
Table 2: The Group Nomination script In order to support the complex and interdisciplinary development of the pedagogical collaboration tools Beehive was built using a multi-layered architecture. The layers are structured to maximise the modularity of the system, and make it easier to extend. For example, if a user wants to use the collaborative learning platform in a business application, the top layer can be adapted to the new desired situation by defining new training design patterns in that discipline. The process of designing and implementing an activity in Beehive is relatively simple. As shown in Figure 4, it starts from the top layer by selecting a collaborative learning pattern from a list of patterns. Second, based on design reuse, the system automatically presents a suggested list of tasks to be performed by the instructor and learners. Third, the system maps each task to a certain CSCL component and then assembles all mapped components in a single CSCL tool. Collaborative learning patterns have internal structures. The structure represents a set of steps for a group to follow. They also specify who will do what in each step. We have used this concept to enhance this framework. The Collaborative Script component is used to formalise the structures of collaborative techniques in a systematic way to present CSCL components in a sequential manner. It enables CSCL systems to present only the specified CSCL components related to the step that is reached in the session. It specifies not only the CSCL components, but also the group setting, the roles, and the timing in that step. It specifies exactly how learners, within their groups, can play certain roles in collaborating towards certain outcomes within specific tools.
The Group Structure component specifies the internal structure of the groups (group size, roles, etc.). The Group Structure component is a dynamic component. There might be more than one group setting during the session. For example, in the Pyramid technique, participants start discussing in a small group and then move to larger groups until they all join in a single large group. Finally, even though Beehive encourages instructors to start their design by reusing existing collaborative learning patterns (starting from the first layer), it still allows instructors to design new techniques by starting their design from the second layer.
Figure 4: Beehive’s 4-layered conceptual model Beehive is a complete e-learning framework divided into two separate applications: the authoring and the runtime environments. In a normal usage scenario a pedagogical design (activity) is first produced in the authoring environment that is embedded in the LMS. When the teacher makes this activity available, students access an Adobe Flash client from within the LMS. We have built authoring environments in two LMS, one within dotLRN ("dotLRN Foundation") and one within the Sakai LMS ("Sakai Project"). Both LMS have administration pages where teachers can include new activities in a course by selecting a pedagogical technique already available in the “techniques repository” or by designing new collaborative learning activities if they prefer. When a teacher finishes his designs, the design information (as defined by the IMS LD schema) is stored in the database to be parsed by the runtime environment. The runtime environment is within a Flash MX application and a Flash Communication Server. The server contains pre-built components, such as chat, audio, video conferencing, virtual white board, which are essential for building standard communication applications quickly and easily. It also allows customizing the
source code of these components to allow a wider variety needed in our application. The Flash player is already pre-installed on most browsers, so students and teachers do not need to install new plug-ins, something not always possible in corporate or university owned machines. The XML schema we use is based on the IMS LD specification maintained by the IMS Consortium. The Learning IMS LD Learning Design is a development of the educational Modelling Language (EML) designed by the Open University in the Netherlands which is focused on the performance of individual and group learning activities (Tattersall & Koper, 2004). We have chosen this specification for its flexibility and the ability to describe most learning designs in a formal way. Its main disadvantage is that IMS LD provides no means to specify how a group would interact inside a collaborative learning session (Leo, Perez, & Dimitriadis, 2004), so we provided two proposed extensions to IMS LD. The first proposed extension is to the IMS LD service, consisting a special type called Collaboration Tool Service that defines more tools needed for the collaborative activities. The second one is to the IMS LD activity definition consisting of a special type called Collaboration Activity that specifies how a group would interact inside a single collaborative activity. A single collaborative learning design might consist of several collaboration activities.
Evaluation and concluding remarks One of the evaluations of Beehive included a group of 12 trainee teachers enrolled in a postgraduate course on Educational Technologies. The subjects had to prepare a 1 hour online lesson about ‘the semantic web’ using Beehive. They had already performed similar design activities using other CSCL systems such as Macromedia Breeze. It consisted of three main phases: - 15-minute lecture - 20-minute collaborative session - 20-minute other collaborative session The groups were divided by the instructor into two (males and females). Each group needed to design plans for that online session. After the activity each group was asked to assess: 1. Are the suggested pedagogical technique(s) appropriate? 2. Can Beehive do it? 3. Can it be achieved by a group of students in 20 minutes? 4. What do students need to know to be able to do it? The subjects discussed the topic and the lesson’s objectives and then which appropriate collaborative techniques to choose by using a general chat tool (not within Beehive). The selection had been developed through steps of discussions. First, they agreed on the session’s topic, which was about “learner centredness”. Second, they agreed that before selecting a technique, they needed to define exactly what learners needed to learn and achieve by the end of the session (defining their objectives): “We need a technique that allows for exchange of ideas but then it is only the ideas coming out of one head.” “We can start by individual read, exchange thoughts in group, and then share responses with entire session.” ”I think I agree, in some pretty complex problems people might be best to start individually.”
In the third stage, participants started to discuss the appropriate techniques to choose. Some of them suggested that they needed to look at Beehive first to see what things Beehive can offer in order to gain a better understanding of what to do next (similar to their traditional approach in learning how to use new software). The real concern in this regard was the time limitation and the fear that Beehive would dictate learning outcomes: “I suspect it would take too long ...” “Why should the system dictate learning outcomes?” Some of them relied on their experience and suggested a technique that they had used in the faceto-face environment: “We want to see a group GENERATE something new. What about using group nomination?” “Is not the brainstorm listing things? In this case it is a list of ways Semantic Web might support learner centredness.” Nevertheless, they were seeking more flexibility. Some participants stated that they need a technique that is appropriate to their objective, which was not among Beehive’s techniques: “You know I can not see a method for the way I would do it manually. If I did it manually, I would give a set of alternatives then get people to vote on it.” “It would have been nice to see the outcomes from the activities and have them be able to translate nicely into inputs into other activities and then we find the techniques to support that process.” “I think brainstorm needs to be followed with some sort of corrective activity, or else some may be left with incorrect assumptions.” The next suggested approach for them was to combine more than one technique to reach their objectives: “How might Semantic Web supports learner-centredness? We want first the group to have a sense of learner-centredness emerging. Then try to post some concrete ‘examples’ (fictional). Then elaborate from examples to form a group discussion. The scenario could be: start with brainstorming to exchange thoughts in group, then move to group discussion, then idea prioritising, and then share responses with entire session.” “I think to do the same with subtopics (for example, challenges).“ At the last session phase, the plan was reported as following: The plan for the 20-minute collaborative activity: presenting a hypothetical case study for Sydney University. Pedagogical Technique: Group Nomination + Pyramid Output: the output should be a document outlining the challenges and issues the collaboration might face, and any recommendations to address these challenges and issues. They successfully implemented the above complex scenario containing 16 different phases via Beehive. The agreed session’s script was as follows: 1- Overview (by the facilitator) – two minutes. 2- Watch the lecture presentation “The Educational Web Semantic” (by presenters) – 30 minutes. 3- Open the floor for any questions – three minutes.
4- Read the text and consider: “The Semantic Web, despite presenting learners with new challenges (such as exposure to too much information), will bring the benefit of greater access to sources of knowledge which could be contextualised and then analszed critically. It will do this by empowering learners with the technological tools to retrieve opposing views on the information that is being sought and encouraging the analysis of both sides of a debate.” – two min 5- Post your individual ideas about how you think the semantic web would achieve this (in small groups) – three minutes. 6- Discuss these ideas – five minutes. 7- Mark these ideas to prioritise them – one minute. 8- Post your ideas on what will change from learners’ perspective – four minutes. 9- Mark what is the most significant change – one minute. 10- Each group leader types in the most significant change – one minute. 11- Read the background case: “The Faculty that you are working for within a large University is commencing a collaboration between like faculties within other universities both nationally and internationally. The desire is to share resources, tools, and learning designs and best-practice teaching strategies. Many of the schools are adopting a learner-centred paradigm and those that are not in the progress of doing so. The collaboration has agreed to look at implementing a semantic web as the basis through which all the universities will collaborate. As a key member of the faculty with an understanding of learning, e-learning and educational technology, you and other key staff members have been tasked to develop strategies to support the implementation of the semantic web for the collaboration.” – two min 12- Identify challenges that the collaboration and the individual faculties may face prior, during, and after – three minutes. 13- Each group leader type in the two most significant challenges – two minutes. 14- Post what might the semantic web offer in term of support training and the day-to-day informational – three minutes. 15- Mark these ideas to prioritise them – one minute. 16- Each group leader types in the highest two ideas – three minutes We questioned the students about the usability of Beehive. Some of the positive comments included ‘It looks like it maps to real-time activities in classrooms rather than documents in a webpage’, ‘I enjoyed this session, I felt more active’. When asked what Beehive was for, they said ‘for developing the skills of students in the group’, ‘to provide patterns for on-line teaching in an accessible way and to provide a tool to manage on-line classes’. The responses can be grouped in two: those who saw the goal of Beehive to transfer face-to-face activity to the online context, and those that saw it as another way to ‘promote student understanding’. The two groups also approached the system in different ways. A number of students from the first group felt that Beehive restricted their freedom. When asked how they approached using Beehive, the first group of teachers responded ‘As a trainee teacher, I sit, watch and do what I am told with the tools in Beehive’, ‘I just pick the tasks I’ll need, set the scenario and information and slides and sequence the rest of the tasks’. The second group of teachers said things like: ‘I prefer to do some preparation of students needs before I use the program. I like to have the script written before I go to Beehive’. The differences between these two groups highlights how the different perceptions and approaches to learning affect the way they use software systems such as this, and conversely, how the systems affect their views. In future, we aim to explore how teachers see the reusability concepts described earlier and how that affects the way they approach using systems such as Beehive.
We have described the Beehive framework, which supports teachers in selecting and employing research-based pedagogical techniques and facilitates the construction of new ones. Beehive includes fourteen well-known pedagogical techniques described as patterns. It also allows designers to store new patterns with minimum effort. A list of the tasks that the teacher and learners take part in before, during and after the collaboration session would drive the construction of the desired tool. For customisation, it is possible for the teacher to change some of these tasks according to needs. This approach prevents loss of the pedagogic structure embodied in the original learning activity. This is the first application that shows how educational design patterns can be combined into a pattern language to describe a specific synchronous collaborative learning design.
References Alexander, C., Ishikawa, S., Silverstein, M., Jacobson, M., Fiksdahl-King, I., & Angel, S. (1977). A Pattern Language: Towns, Buildings, Construction. NY: Oxford University Press. Baggetun, R., Rusman, E., & Poggi, C. (2004). Design Patterns For Collaborative Learning: From Practice To Theory And Back. Paper presented at the World Conference on Educational Multimedia, Hypermedia and Telecommunications, Chesapeake, VA. Baumgartner, P., & Bergner, I. (2003). Categorization of Virtual Learning Activities. Paper presented at the International Workshop ICL2003, Villach, Austria. dotLRN Foundation. Retrieved 29 May, 2008, from http://dotlrn.org Fablusi. The online role-play simulation platform. Retrieved 12 April 2006, from http://www.fablusi.com FACILITATE. Unleash creativity with focused idea generation. Retrieved 18 May 2005, from http://www.facilitate.com/productfunctions_brainstorming.htm Fayad, M., D. Schmidt, and Johnson, R. (1999). Building Application Frameworks : Object-oriented foundations of framework design: John Wiley and Sons. Fayad, M., Schmidt, D., & Johnson, R. (1999). Building Application Frameworks Objectoriented foundations of framework design: Wiley. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1995). Design patterns: elements of reusable object-oriented software. New York: Addison-Wesley. Hernández-Leo, D., Villasclaras-Fernández, E. D., Jorrín-Abellán, I. M., Asensio-Pérez, J. I., Dimitriadis, Y., Ruiz-Requies, I., et al. (2006). Collage, a Collaborative Learning Design Editor Based on Patterns. Special Issue on Learning Design, Educational Technology & Society, 9(1), 58-71. Johnson, R. E. (1997). Frameworks = (Components + Patterns). ACM Communication, 40(10), 39-42. LAMS Wiki. (2008). Retrieved 29 May, 2008, from http://wiki.lamsfoundation.org/display/lamsdocs/Home Leo, D. H., Perez, J. I. A., & Dimitriadis, Y. A. (2004). IMS Learning Design Support for the Formalization of Collaborative Learning Patterns. Retrieved Nov., 2004, from http://dspace.learningnetworks.org/retrieve/462/leoicalt2004.pdf McAndrew, P., Goodyear, P., & Dalziel, J. (2006). Patterns, designs and activities: unifying descriptions of learning structures. International Journal of Learning Technology, 2(2-3), 216-242.
Paulsen, M. F. (1995). The Online Report on Pedagogical Techniques for ComputerMediated Communication. Retrieved May 2006, from http://www.nettskolen.com/forskning/19/cmcped.html Sakai Project. Retrieved 29 May, 2008, from http://sakaiproject.org/ Tattersall, C., & Koper, R. (2004). EML and IMS Learning Design: from LO to LA. 2004, from http://hdl.handle.net/1820/107 Turani, A., Calvo, R., & Goodyear, P. (2005, August). An Application Framework for Collaborative Learning. Paper presented at the International Conference on Web Engineering, Sydney. Turani, A., & Calvo, R. A. (2006). Beehive: A Software Application for Synchronous Collaborative Learning. Campus Wide Information Systems., 23(3), 196-209. Wessner, M., & Pfister, H. R. (2000). Points of cooperation: Integrating cooperative learning into web-based courses. Paper presented at the New Technologies for Collaborative Learning, Awaji-Yumebutai, Japan. Wiki. (2008). Retrieved 29 May, 2008, from http://wiki.lamsfoundation.org
