ELearning/Introduction to instructional design models

Introduction

Instructional design models provide explicit guidance for the design of instruction, and are informed by learning and instructional theories. Silvern (1977) defines a model as a “graphic analog representing a real-life situation either as it is or as it should be". Instructional design models presume that, if followed, the resulting instruction will be effective, efficient, and engaging (Merrill, 2013).

Some models are more descriptive in nature, depicting the components of design, while others are prescriptive, advising specific solutions for particular learning needs. While there are dozens of models, we concentrate on prominent models such as ADDIE, the Kemp Model, van Merruënboer’s 4C/ID Model, Merrill’s Pebble-in-the-Pond model and the more recent AGILE approaches adopted from the programming world.

Note that this wiki attempts to provide information and instruction for most of the course design and building tasks advocated for in these models. Therefore, we simply summarize the models and refer you to other web resources for further investigation. Terminology varies to describe the same phenomenon, and we note these differences.

Before looking at the different models, we recommend you watch a TED video that, among other things, points to the importance of prototyping and iteration in designing and building worthy products. Build a Tower, Build a Team

ADDIE

Analyze, design, develop, implement, and evaluate. These are the macro steps prescribed by the original instructional systems design (ISD) model developed in 1975 at Florida State University for the U.S. Army. The model is linear, often described as a waterfall, in that the completion of one step logically feeds into the next. There are many iterations and the illustration below constitutes one.

1. ADDIE Model of instructional design

ADDIE has been criticized as too rigid, too time consuming, and too linear and inadequate for producing instructional products that lead to desired learning outcomes (Gordon & Zemke, 2000). Merrill (2013) attributes these problems to a rigid compliance with the steps and failure to assess the products of each step, assuming instead that following the steps necessarily leads to successful instruction. Another criticism of the model is that it fails to differentiate performance that can be developed or corrected with training from those that cannot. Many also say that ADDIE is adequate for knowledge learning, but fails as a performance training model.

Advocates of ADDIE, generally experienced professionals, counter that slavish adherence to any model without regard to individual circumstances is destined to fail. The key, they say, is to adopt the model to fit the need. Also, they say ADDIE can easily be rendered as a cyclical model:

2. Cyclical ADDIE Model

Kemp Model

Described by some as an adaptation of ADDIE, the Kemp model is articulated in the book Effective Instruction (2011) by Morrison, Ross, Kalman & Kemp. In their words, “This model is circular rather than a traditional linear flowchart. Our experience has shown that projects start and end at different places in the design process. The design model must be flexible to accommodate the demands of the job, yet maintain the logic to produce an effective process.”

3. Kemp Model of instructional design

Advocating the need to separate instructional problems from other sources, this model includes a step to identify the need for instruction. Once the need has been established, the design process flows clockwise within the inner circle from the top, with the outer layers representing larger process issues that need to accompany the inner tasks. The Designing the Message task is equivalent to sequencing in the ADDIE model and Events of Instruction in our heuristic.

A notable feature of the Kemp model is the use of Quality Control measures for each step of the inner circle, essentially formative assessments of the outputs from individual steps. For example, the following questions and reminders are included in the Learner and Contextual Analysis chapter:

“Updating and verifying your learner analysis is an ongoing process as you design the instruction. Initially, you need to confirm that you have identified the correct target audience – the individuals who will receive your instruction. Next, you need to consider how the audience and environmental characteristics can provide opportunities or limitations on the design of the course. For example, discovering that your course cannot run for five continuous days but can be offered only for two hours a day creates opportunities to build in self-reflection time after each class meeting. If you find that many of the students taking a computer course have physical limitations, you can collect additional information on their fine motor skills and determine whether adaptive technologies can be used to enhance the functionality of the computers” (Morrison, et al., p. 73).

Four Component Instructional Design Model (4C/ID)

According to its originators, “the 4C/ID-model addresses at least three deficits in previous instructional design models. First, the model focuses on the integration and coordinated performance of task-specific constituent skills rather than on knowledge types, context or presentation-delivery media. Second, the model makes a critical distinction between supportive information and required just-in-time (JIT) information (the latter specifies the performance required, not only the type of knowledge required). And third, traditional models use either part-task or whole-task practice; the 4C/ID-model recommends a mixture where part-task practice supports very complex, “whole-task” learning (van Merrriënboer, et al., 2002).

4. 4C/ID Model of instructional design

Environments for complex learning can be described in terms of four related components:

1. A sequence of learning tasks forms the backbone of any training program. Ideally, learners confront whole tasks that require working through the entire process, practicing within task classes ranging from simple to complex. Initial simple tasks are highly scaffolded and proceed through similar tasks while scaffolding is reduced and eventually eliminated. The next class of tasks is worked through in the same manner, and so forth until complex tasks are performed without scaffolding. The type and amount of scaffolding is specified for each task class and is reduced as learners complete successive tasks within each class.
2. Supportive information is made available for each task class, but is not coupled to individual learning tasks. This information is an addition to or an elaboration of that provided thorough scaffolding and includes cognitive strategies, mental models, and feedback provided after task completion. It also addresses non-recurrent aspects of learning tasks. The goal is to promote schema construction by helping learners recognize the relationships between new information and prior learning, and build expertise.
3. Just-in-time information pertains to recurrent aspects of task completion, the necessary constituent skills involved, provided in context with task learning. It may include step-by-step instruction and guidance, information displays, demonstrations, and examples. JIT guidance is typically provided during the first one or two tasks within each class then quickly faded. Also part of JIT is corrective feedback provided to the learner in real time as mistakes are made.
4. Part-task practice provides additional practice for selected recurrent constituent skills with the goal of attaining automaticity, error-free performance accomplished without deliberative thought: accuracy and speed. This type of practice strengthens and internalizes the component skills. Learning multiplication facts and playing musical scales are examples of part tasks.

The 4C/ID-model should be used to develop training programs for complex skills and when transfer is the overarching learning outcome. Such training programs have a typical length of weeks, months or even years (van Merrriënboer, et al., 2002). The model is not developed for teaching conceptual knowledge or procedural skills per se. It also is not very useful for designing very short programs that only take an instructional time of hours or a few days.

Pebble-in-the-Pond Model

This design model operationalizes David Merrill’s first principles of instruction (Merrill, 2013):

Learning is promoted when learners . . .

• acquire skill in the context of real-world problems.
• activate existing knowledge and skill as a foundation for new skills.
• observe a demonstration of the skill to be learned.
• apply their newly acquired skill to solve problems.
• reflect on, discuss, and defend their newly acquired skill.

Merrill describes the model as a design model, rather than a development model, involving the construction of a functional prototype. Each ripple in the diagram represents a phase of the instructional design process. The model assumes the designer has already identified an instructional goal and a learner population.

5. Pebble-in-the-Pond Model of instructional design

1. Design a problem. Specify an instance that represents the whole problem that learners should be able to solve following instruction. An instance includes the information provided learners and how they use it to solve a problem, including showing in detail every step required to achieve the end. It is also desirable to design a prototype application, computer or otherwise, that requires learners to solve a problem.
2. Design a progression of problems that gradually increase in complexity, difficulty, or the number of component skills required to complete the task. Each problem in the progression should be completely specified including the givens, the solution, and the necessary steps leading to completion. All problems are scanned and a list of component skills identified. If all necessary knowledge and skills do not appear on the list, additional problems need to be created until all are covered. Be sure all component skills are required at least three times.
3. Design instruction for each component skill, and determine where each is introduced. A demonstration is created for the first encounter of each skill. Application of the skill is designed for the second and subsequent encounters.

The result of the first three steps is a functional prototype of the course. The remaining steps fine tune the prototype to enhance its effectiveness, efficiency, and engagement.

4. Enhancement strategies include a structural framework and peer interaction. The framework is an organization of previously learned information that learners can use to adapt an existing mental model or build a new one. Metaphors are useful in this regard. We remember how the atom was described as a miniature solar system. Building layers on a silicon chip is similar to applying multiple coats of paint on a house. This framework is then used to design guidance and coaching around the central tasks. Peer interaction is built into the course as a learning and motivational tool.
5. Complete the design by finalizing the course navigation and interface, and designing supplemental materials to add instructional support where needed.
6. Conduct a formative evaluation by trying out the prototype and revising as indicated.

Although Merrill suggests that the model can be adapted to any learning situation, its focus is clearly on procedural learning. The model is very prescriptive in that once component skills are typed, a succession of learning tasks is ordained. For example a demonstration includes:

1. Show an instance of the desired consequence for the whole problem (Show-Q).
2. Show instances of conditions that lead to the desired consequence (Show-C).
3. Show instances of the steps that lead to each of the conditions (Show-S).

Learning the model also involves learning its specialized language for common design concepts (e.g., “kind-of” is used in place of “example”; “Do _ex -S” means “execute instances of the step”).

AGILE Approaches


6. Agile Instructional Design (AID) Model

The influence of software engineering methods and practices over instructional design has been ongoing since computer based training became available in the 1980s. Agile programming methods, also referred to as rapid prototyping, involve direct participation by the customer through access to the programming architecture and direct contact with programmers, not via an analyst. Documentation is minimized, programmers work in pairs, development teams are multidisciplinary, and the software is never considered finished (Rawsthorne, 2005). This approach grew out of the need for shortened development cycles, acknowledgement that development teams change over time, that documentation is rarely read, and that customer requirements change as the project progresses. The values inherent in this approach include:

• Individuals and interactions are valued over processes and tools (people oriented over process oriented)
• Working software is valued over comprehensive documentation
• Customer collaboration is valued over contract negotiation
• Responding to change is valued over following a plan (adaptive rather than predictive)

We have two models to demonstrate the agile approach.

Agile Instructional Design (AID)

Rawsthorne (2005) cites the Microsoft Solution Framework as an example of the agile approach (Envision, Plan, Build, Stabilize, and Deploy) and proposes an Agile instructional design (AID) model based on it.

Envision – a planning meeting is used to envision the current and future content, and identify learning modules. Learner roles and context are identified and themes developed to connect modules. This plan is used to create iteration plans for each module.

Plan – More of a development effort than a planning one, a multidisciplinary team of programmers, instructional designers, subject matter experts, and media designers further define module content based on the output of envisioning. Schedules, strategies, an inventory of learning objectives, and research requirements are outcomes.

Build – Building the modules is a twofold effort of building and testing executed by multidisciplinary developer pairs, combining instructional design and software development. Learners are brought in as soon as possible to pilot, evaluate, and potentially improve the modules.

Stabilize – Modules are completed and subjected to quality assurance testing and possibly sent back to the developer pair for bug fixing. Modules are integrated into the learning management system. Modules can also be refactored to fit the learning ecosystem; that is the underlying structure may be altered to fit the system better but without changing the external behavior. Refactoring is more a technical issue than a teaching and learning one. It is intended to increase the long-term maintainability and extensibility of learning assets.

Deploy – The completed course is taken out of the production environment and into general release.

We note two features in this model not used elsewhere. First is the explicit planning step of identifying interdisciplinary opportunities and requirements that can or should be included within the course of study. Second, a systems approach is evident in the explicit effort to integrate learning objects in such a way as to make them easier to maintain and easier to add or change functionality.

Successive Approximation Model (SAM)

The successive approximation model is another specific iteration of the agile approach. Like Merrill and his first principles of instruction, Michael Allen bases the SAM model on a set of criteria for the ideal process (Allen, 2013):

The process must . . .

• Be iterative, done in small steps with frequent evaluation allowing for change at a time when they cost the least.
• Support collaboration within the project team, allowing for the flow of ideas, opinions, experiences, and knowledge of members while avoiding bureaucracy and indecision.
• Be efficient and effective by directing energy and resources where it matters to produce a product as quickly as possible.
• Be manageable, allowing for completion of projects on time and on budget, with a product that meets establish quality criteria.

The process cycles through evaluation/analysis, design, and development allowing teams to create and refine prototypes along the way. Ideas and assumptions are discussed and tested early, thus allowing for relatively quick development of a usable product after only a couple of iterations.

The model is divided into three phases:

7. Successive Approximation Model (SAM) of instructional design

1. Preparation, allowing for the design team to gather background information and a “savvy start” - a brainstorming event bringing the design team and stakeholders together to review gathered information and create initial prototype ideas.
2. Iterative design in which an initial prototype is developed, evaluated, and revised as necessary.
3. Iterative development in which a design proof is developed, implemented and evaluated, followed by alpha and beta cycles until the final gold iteration is rolled out.

Allen offers SAM as an alternative to ADDIE utilizing similar tasks, but without the traditional step-by-step requirements.

The agile approach does seem to fit with the realities of most instructional design professionals in that quick turnaround and adaptability is demanded in today’s fast changing world. It emphasizes collaboration, multidisciplinary approaches, and multiple iterations with frequent testing and feedback cycles. We believe it makes a serious contribution to the profession by making explicit those practices that previous models are missing.

---

#top

⇑ Up to Course development

⇑ ⇑ Up to Home