| Participatory Simulations |
Understanding
Structure and Change Through Reflective
Participation
 |
What is a Participatory Simulation?
Students engaged in participatory simulations act out the
roles of the individual system elements and then see how the
behavior of the system as a whole can emerge from these
individual behaviors. The emergent behavior of the system
and its relation to individual participant actions and
strategies can then become the object of collective
discussion. |
|
What's New Now?
For many decades there has been interest in simulations in
which individuals act out the roles of the elements in a
dynamic system (e.g., Forrester, 1968; Senge, 1990; Meadows,
(1986); Resnick & Wilensky, 1998). These participatory
simulations allow learners to enact their intuitive modes of
reasoning. Students engaged in these participatory
simulations act out the roles of the individual system
elements and then see how the behavior of the system as a
whole can emerge from these individual behaviors. The
emergent behavior of the system and its relation to
individual participant actions and strategies can then
become the object of collective discussion. Participatory
simulations like the Beer Game &emdash;first introduced in
the 60's by Jay Forrester and recently revitalized as a
result of its appearance in Senge's widely read Fifth
Discipline (1990)&emdash; do much to highlight the ways in
which costly unintended behaviors of a system (in this case
beer inventory in a distribution system) can emerge from
participants attempting to act rationally in their localized
role (e.g., as beer retailer, wholesaler, distributor, or
producer).
This kind of participatory model is effective in dramatically
bringing home the ways in which structure and well intended
local actions can sum together to create unintended and
undesirable system behavior. However, the simulation process
associated with implementing the model has proven
sufficiently cumbersome so as to present a real barrier to
its successful implementation in classrooms. The beer game
simulation, like most of the simulations developed by
systems dynamics groups, relies on participants relaying
their decisions through paper and pencil messages that
propagate through the gaming "system." This laborious,
repetitive and error-prone process "begs" for a
computer-based implementation to free the participants to
focus on the consequences of their decisions and strategies.
More
recently, new classes of so-called "object-based" simulation
activities have been developed (Resnick & Wilensky,
1998). In these activities, participants typically play the
role of "ants" in an anthill simulation, moving around the
room and exchanging "messages." In contrast to the
finite-difference computer modeling used to analyze
simulations like the beer game, these simulation activities
have been designed to be further explored using object-based
parallel computer modeling languages such as StarLogo
(Resnick, 1994; Wilensky, 1995). Absent a HubNet-like
design, however, the intuitive strategies of the players are
not analyzable or capturable in the StarLogo modeling
environment. As was true for the beer game above, the
role-play and the computer model can shed light on each
other but they cannot share data or interact dynamically.
The role-play cannot be saved, re-analyzed, or compared with
other role-plays except through a laborious hand-coded
process.
What
we have, then, are powerful computer-based modeling tools
for displaying and analyzing the dynamics of systems and
powerful role-play pedagogies for connecting students'
direct experience with the systemic and global consequences
of that experience. The HubNet architecture we propose ties
these two powerful methodologies together and makes
practical a curriculum that allows students to deeply engage
the issues of systems changing over time.
|
|
|
Exploring Three Kinds of Systems Learning Environments
To date, tools for making sense of dynamic systems can be
divided into two kinds: so-called "aggregate" modeling
engines (e.g., STELLA [Richmond & Peterson,
1990], Link-It [Ogborn, 1994]), VenSim, ProSim,
Model-It [Jackson et al., 1996]) and "object-based"
modeling languages (e.g., StarLogo [Resnick, 1994;
Wilensky, 1995a], Agentsheets [Repenning, 1993],
Cocoa [Smith et al., 1994], Swarm [Langton &
Burkhardt, 1997]). Through participatory simulations,
this project will explore both aggregate and object-based
modeling environments as well as the extended-object-based,
hybrid-architecture environment of HubNet itself.
Aggregate
Modeling
The
first kind of tool enables the user to conceptualize the
system as "flows" and "accumulations." For example, a
changing population of rabbits might be modeled as an
"accumulation" (like water accumulated in a sink) with
rabbit birth rates as a "flow" into the population and
rabbit death rates as a flow out (like the flow of water
into and out of the sink). Other populations or
dynamics&emdash; e.g., the presence of "accumulations" of
predators&emdash; could affect these flows. In the limit of
the continuous case, this means dynamic systems are written
in the language of differential equations. [EXAMPLE TO
BE POSTED SOON].
Object-Based
Modeling
The
second kind of tool enables the user to model systems
directly at the level of the individual elements of the
system. For example, our rabbit population could be rendered
as a collection of individual rabbits each of which has
associated probabilities of reproducing or dying. The
object-based approach, while perhaps less efficient at
certain kinds of analysis (e.g., translating its results
into algebraic form), has the advantage of being a natural
entry point for learners. It may well be easier to generate
rules for individual rabbits than to describe the flows of
rabbit populations. This is because the learners can
literally see the rabbits and can control the individual
rabbit's behavior. New computational media make this
object-based approach practical as a tool for modeling
population dynamics and other forms of highly interactive
emergent phenomena. [EXAMPLE TO BE POSTED
SOON].
HubNet
as Modeling Environment
HubNet
can itself be a powerful modeling tool. In particular,
HubNet can be used as a new kind of object-based modeling
environment. In contrast to languages such as StarLogo,
Hubnet, as a modeling engine, depends on each of its nodes
-- each calculator can be a turtle. While for very large
numbers of turtles, StarLogo would be much more efficient,
for smaller numbers (classroom-size) the advantage of
students being able to test their intuitive behavior and to
participate directly in the simulations has powerful
learning possibilities. Because HubNet allows the user
flexibility about what to pass from the calculators to the
Hub, many hybrid architectures are possible as well. If the
calculators pass average or aggregate quantities to the Hub,
then a new mixed object-based hybrid architecture results.
These new architectures open doors to many new kinds of
simple classroom activitivities. [EXAMPLES TO BE POSTED
SOON]. |
|