Computer-based modeling tools have largely grown out of the need to describe, analyze and display the behavior of dynamic systems. During recent decades, there has been a recognition of the importance of understanding the behavior of dynamic systems—how systems of many interacting elements change and evolve over time and how global phenomena can arise from local interactions of these elements. New research projects on chaos, self-organization, adaptive systems, nonlinear dynamics, and artificial life are all part of this growing interest in systems dynamics. The interest has spread from the scientific community to popular culture, with the publication of general-interest books about research into dynamic systems (e.g., Gleick 1987; Waldrop 1992; Gell-Mann 1994; Kelly 1994; Roetzheim 1994; Holland 1995; Kauffman 1995).

StarLogo is one of a new class of object-based parallel modeling languages (OBPML). The Resnick chapter in this book includes a detailed description of StarLogo. In brief, It is an extension of the Logo language in which a user controls a graphical turtle by issuing commands, such as "forward", "back", "left" and "right". In StarLogo, the user can control thousands of graphical turtles. Each turtle is a self-contained "object" with internal local state. Besides the turtles, StarLogo automatically includes a second set of objects, "patches". A grid of patches undergirds the StarLogo graphics window. Each patch is a square or cell that is computationally active. Patches have local state and can act on the "world" much like turtles. Essentially, a patch is just a stationary turtle. For any particular StarLogo model, there can be arbitrarily many turtles (from 0 to 32000 is typical in the StarLogo versions we have used), but there are a fixed number of patches (typically, 10,000 laid out in a 100x100 grid).

An argument on the side of using demonstration models is that the content to be learned is placed immediately and directly to the attention of the learner. In contrast, in the process of constructing a model, the learner is diverted into the intricacies of the modeling language itself and diverted away from the content to be learned. Since there can be quite a bit of overhead associated with learning the modeling language, the model construction approach could be seen as very inefficient. Moreover, there is skepticism as to whether students who are not already mathematically and scientifically sophisticated can acquire the knowledge and skills of model design and construction.

Like most tensions, this tension is not really dichotomous. There are many intermediate states between the two extremes. Demonstration models can be given changeable parameters which users can vary and, thereby, explore the effect on the behavior of the model. If there are large numbers of such parameters, as in the popular Maxis simulation software packages (1992a; 1992b), the parameter space can be quite vast in the possibilities for exploration. This takes demonstration models several steps in the direction of model construction. On the other hand, even the most from "scratch" modeling language must contain primitive elements. These primitive elements remain black boxes, used for their effect but not constructed by the modeler. Not too many constructionist modelers would advocate building the modeling elements from the binary digits, let alone building the hardware that supports the modeling language. The latter can serve as an absurd reductio of the "from scratch" label. So, even the die-hard constructionist modelers concede that not all pieces of the model need be constructed, some can be simply handed off.

I place myself squarely in the constructionist camp; the challenge for us is to construct toolkits that contain just the right level of primitives. In constructing a modeling language, it is critical to design primitives not so large-scale and inflexible that they can only be put together in a few possible ways. If we fail at that task, we have essentially reverted to the demonstration modeling activity. To use a physical analogy, we have not done well in designing a dinosaur modeling kit if we provide the modeler with three pieces, a T-Rex head, body and tail. On the other hand, we must design our primitives so that they are not so "small" that they are perceived by learners as far removed from the objects they want to model. If we fail at that task, learners will be focused at an inappropriate level of detail and so will learn more about the modeling pieces than the content domain to be modeled. To reuse the physical analogy, designing the dinosaur modeling kit to have pieces that are small metal bearings may make constructing many different kinds of dinosaurs possible, but it will be tedious and removed from the functional issues of dinosaur physiology that form the relevant content domain.

Both of these choices, content domain modeling languages and general-purpose modeling languages, can lead to powerful modeling activities for learners. The advantage of the content domain modeling language is that learners can enter more directly into substantive issues of the domain (issues that will seem more familiar to them and to their teachers). The disadvantage is that the primitive elements of the language, which describe important domain content, are opaque to the learner. Another disadvantage is that use of the language is restricted to its specific content domain. That disadvantage may be nullified by designing a sufficiently broad class of such content domain modeling languages, though maintaining such a broad class may be challenging. The advantage of the content-neutral primitives is that all content domain structures, since they are made up of the general purpose elements, are inspectable, constructible and modifiable by the learner. The disadvantage is that the learner must master a general purpose syntax before being able to make headway on the domain content. What is needed is a way for learners to be able to begin at the level of domain content, but not be limited to unmodifiable black-box primitives.

In the Connected Probability project, the solution we have found to this dilemma is to build so-called "extensible models" (Wilensky, 1997). In the spirit of Eisenberg’s programmable applications (Eisenberg, 1991), these models are content-specific models that are built using the general-purpose StarLogoT modeling language. This enables learners to begin their investigations at the level of the content. Like the group of high schoolers described in the earlier section of this chapter, they begin by inspecting a pre-built model such as Gas-in-a-Box. They can adjust parameters of the model such as mass, speed, location of the particles and conduct experiments readily at the level of the content domain of ideal gases. But, since the Gas-in-a-Box model is built in StarLogoT, the students have access to the workings of the model. They can "look under the hood" and see how the particle collisions are modeled. Furthermore, they can modify the primitives, investigating what might happen if, for example, collisions are not elastic. Lastly, students can introduce new concepts, such as pressure, as primitive elements of the model and conduct experiments on these new elements.

This extensible modeling approach allows learners to dive right into the model content, but places neither a ceiling on where they can take the model nor a floor below which they cannot see the content. Mastering the general purpose modeling language is not required at the beginning of the activity, but happens gradually as learners seek to explain their experiments and extend the capabilities of the model.

When engaged in classroom modeling, the pedagogy used in the Connected Probability project has four basic stages: In the first stage, the teacher presents a "seed" model to the whole class. Typically, the seed model is a short piece of StarLogoT code that captures a few simple rules. The model is projected through an LCD panel so the whole class can view it. The teacher engages the class in discussion as to what is going on with the model. Why are they observing that particular behavior? How would it be different if model parameters were changed? Is this a good model of the phenomenon it is meant to simulate? In the second stage, students run the model (either singly or in small groups) on individual computers. They engage in systematic search of the parameter space of the model. In the third stage, each modeler (or group) proposes an extension to the model and implements that extension in the StarLogoT language. Modelers that start with Gas-in-a-Box, for example, might try to build a pressure gauge, a piston, a gravity mechanism or heating/cooling plates. The results of this model extension stage are often quite dramatic. The extended models are added to the project’s library of extensible models and made available for others to work with as seed models. In the final stage, students are asked to propose a phenomenon, and to build a model of it from "scratch", using the StarLogoT modeling primitives.

When learners are engaged in creating their own models, two primary avenues are available. A modeler can choose a phenomenon of interest in the world and attempt to duplicate that phenomenon on the screen. Or, a modeler can start with the primitives of the language and explore the possible effects of different combinations of rules sets. The first kind of modeling, which I call phenomena-based modeling (Wilensky 1997; Resnick & Wilensky 1998) is also sometimes called backwards modeling (Wilensky 1997) because the modeler is engaged in going backwards from the known phenomenon to a set of underlying rules that might generate that phenomenon. In the GasLab example, Harry knew about the Maxwell-Boltzmann distribution and tried creating rules which he hoped would duplicate this distribution. In this specific case, Harry did not have to discover the rules himself because he also knew the fundamental rules of Newtonian mechanics which would lead to the Maxwell-Boltzmann distribution. The group of students who worked on modeling Boyle’s law came closer to pure phenomena-based modeling as they tried to figure out the "rules" for measuring pressure. Phenomena-based modeling can be quite challenging as discovering the underlying rule-sets that might generate a phenomenon is inherently difficult -- a fundamental activity of science practice. In practice, most GasLab modelers mixed some knowledge of what the rules were supposed to be with adjustments to those rules when the desired phenomenon did not appear.

The second kind of modeling, which I call exploratory modeling (Wilensky 1997; Resnick & Wilensky 1998) is sometimes called "forwards" modeling (Wilensky 1997) because modelers start with a set of rules and try to work forwards from these rules to some, as yet, unknown phenomenon.

In a sense, modeling languages are always designed for phenomena-based modeling. However, once such a language exists, it also becomes a medium of expression in its own right. Just as, we might speculate, natural languages originally developed to communicate about real world objects and relations, but, once they were sufficiently mature, were also used for constructing new objects and relations. Similarly, learners can explore sets of rules and primitives of a modeling language to see what kinds of emergent effects may arise from their rules. In some cases, this exploratory modeling may lead to emergent behavior that resembles some real world phenomenon and, then, phenomena-based modeling resumes. In other cases, though the emergent behavior may not strongly connect with real world phenomena, the resulting objects or behaviors can be conceptually interesting or beautiful in themselves. In these latter cases, in effect, the modelers have created new phenomena, objects of study that can be viewed as new kinds of mathematical objects--objects expressed in the new form of symbolization afforded by the modeling language.

In the previous section, we discussed the selection of modeling language primitives in terms of size and content-neutrality. Yet another distinction is in the conceptual description of the fundamental modeling unit. To date, modeling languages can be divided into two kinds: so-called "aggregate" modeling engines (e.g., STELLA (Richmond & Peterson 1990), Link-It (Ogborn 1994), VenSim, 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), and OOTLs (Neumann et al 1997)). Aggregate modeling languages use "accumulations" and "flows" as their fundamental modeling units. 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 flows of water into and out of the sink). Other populations or dynamics -- e.g., the presence of "accumulations" of predators -- could affect these flows. This aggregate based approach essentially borrows the conceptual units, its parsing of the world, from the mathematics of differential equations.

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 has the advantage of being a natural entry point for learners. It is generally 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. In StarLogoT, for example, students think about the actions and interactions of individual objects or creatures. StarLogoT models describe how individual creatures (not overall populations) behave. Thinking in terms of individual creatures seems far more intuitive, particularly for the mathematically uninitiated. Students can imagine themselves as individual rabbits and think about what they might do. In this way, StarLogoT enables learners to "dive into" the model (Ackermann 1996) and make use of what Papert (1980) calls "syntonic" knowledge about their bodies. By observing the dynamics at the level of the individual creatures, rather than at the aggregate level of population densities, students can more easily think about and understand the population dynamics that arise. As one teacher comparing students’ work with both STELLA and StarLogoT models remarked: When students model with STELLA, a great deal of class time is spent on explaining the model, selling it to them as a valid description. When they do StarLogoT modeling, the model is obvious; they do not have to be sold on it."

There are now some very good aggregate computer modeling languages—such as STELLA (Richmond & Peterson 1990) and Model-It (Jackson et al. 1996). These aggregate models are very useful—and superior to object-based models in some contexts, especially when the output of the model needs to be expressed algebraically and analyzed using standard mathematical methods. They eliminate one "burden" of differential equations -- the need to manipulate symbols-- focusing, instead on more qualitative and graphical descriptions of changing dynamics. But, conceptually, they still rely on the differential equation epistemology of aggregate quantities.

Some refer to object-based models as "true computational models," (Wilensky & Resnick, in press) since they use new computational media in a more fundamental way than most computer-based modeling tools. Whereas most tools simply translate traditional mathematical models to the computer (e.g., numerically solving traditional differential-equation representations), object-based languages such as StarLogoT provide new representations that are tailored explicitly for the computer. Too often, scientists and educators see traditional differential-equation models as the only approach to modeling. As a result, many students (particularly students alienated by traditional classroom mathematics) view modeling as a difficult or uninteresting activity. What is needed is a more pluralistic approach, recognizing that there are many different approaches to modeling, each with its own strengths and weaknesses. A major challenge is to develop a better understanding of when to use which approach, and why.

Paradoxically, computer-based modeling has been critiqued both as being too formal and of being not formal enough. On the one hand, some mathematicians and scientists have criticized computer models as insufficiently rigorous. As discussed in the previous section, it is somewhat difficult, for example, to get a hold of the outputs of a StarLogoT model in a form that is readily amenable to symbolic manipulation. Moreover, there is as yet no formal methodology for verifying the results of a model run. Even in highly constrained domains, there is not a formal verification procedure for guaranteeing the results of a computer program; much less any guarantee that the underlying assumptions of the modeler are accurate. Computational models, in general, are subject to numerical inaccuracies dictated by finite precision. Object-based models, in particular, are also vulnerable to assumptions involved in transforming a continuous world into a discrete model. These difficulties lead many formalists to worry about the accuracy, utility and especially the generality of a model-based inquiry approach (Wilensky 1996). These critiques raise valid concerns, concerns that must be reflected upon as an integral part of the modeling activity. As we recall, Harry had to struggle with just such an issue when he was unsure whether the drop in the average speed of the gas particles was due to a bug in his model code or due to a "bug" in his thinking. It is an inherent part of the computer modeling activity to go back and forth between questioning the model’s faithfulness to the modeler’s intent (e.g., code bugs) and questioning the modeler’s expectations for the emergent behavior (e.g., bugs in the model rules). Though the formalist critic may not admit it, these limitations are endemic to modeling -- even using formal methods such as differential equations. Only a small set of the space of differential equations is amenable to analytic solution. Most modifications of those equations lead to equations that can only be solved through numerical techniques. The game for formal modeling, then, becomes trying to find solvable differential equations that can be said to map onto real world phenomena. Needless to say, this usually leads to significant simplifications and idealizations of the situation. The classic Lotka-Volterra equations (Lotka 1925), for example, which purport to describe the oscillations in predator/prey populations assume that birth rates and death rates are numerically constant over time. This assumption, while reasonable to a first approximation, does not hold in real world populations -- and, therefore, the solution to the differential equations is unlikely to yield accurate predictions. A stochastic model of predator/prey dynamics built in an object-based language will not produce a formal equation, but may produce better predictions of real world phenomena. Moreover, since object-based models are capable of refinement at the level of rules, adjusting them is also more clearly an activity of trying to successively refine content-based rules until they yield satisfactory results.

In contrast to the formalist critique, educator critics of computer-based modeling have expressed concern that the activity of modeling on a computer is too much of a formal activity, removing children from the concrete world of real data. While it is undoubtedly true that children need to have varied and rich experiences away from the computer, the fear that computer modeling removes the child from concrete experience with phenomena is overstated. Indeed, the presence of computer modeling environments invites us to reflect on the meaning of such terms as concrete experience (Wilensky 1991). We have come to see that those experiences we label "concrete" acquire that label through mediation by the tools and norms of our culture. As such, which experiences are perceived as concrete is subject to revision by a focused cultural and/or pedagogic effort. This is particularly so with respect to scientific content domains in which categories of experience are in rapid flux and in which tools and instruments mediate all experience. In the GasLab case, it would be quite difficult to give learners "real-world" experience with the gas molecules. A real world GasLab experience would involve apparatus for measuring energy and pressure that would be black-boxes for the students using them. The range of possibilities for experiments that students could conduct would be much more severely restricted and would most probably be limited to the "received" experiments dictated by the curriculum. Indeed, in a significant sense, the computer-based GasLab activity gives students a much more concrete understanding of the gas, seeing it as a macro- object that is emergent from the interactions of large numbers of micro- elements.

The use of model-based inquiry has the potential for significant impact on learning in the next century. We live in an increasingly complex and interconnected society. Simple models will no longer suffice to describe that complexity. Our science, our social policy and the requirements of an engaged citizenry require an understanding of the dynamics of complex systems and the use of sophisticated modeling tools to display and analyze such systems. There is a need for the development of increasingly sophisticated tools that are designed for learning about the dynamics of such systems and a corresponding need for research on how learners, using these tools, begin to make sense of the behavior of dynamic systems. It is not enough to simply give learners modeling tools. Careful thought must be given to the conceptual issues that make it challenging for learners to adopt a systems dynamics perspective. The notion of levels of description, as in the micro- and macro- levels we have explored in this chapter, is central to a systems dynamics perspective, yet is quite foreign to the school curriculum. Behavior such as negative and positive feedback, critical thresholds, dynamic equilibria are endemic to complex dynamic systems. It is important to help learners build intuitions and qualitative understandings of such behaviors. Side by side with modeling activity, there is a need for discussion, writing, reflection activities that encourage students to reexamine some of the basic assumptions embedded in the science and mathematics curriculum: assumptions that systems can be decomposed into isolated sub-systems, that causes add up linearly and have deterministic effects. In the Connected Probability project, we have seen, for example, the ‘deterministic mindset’ (Wilensky 1997; Resnick & Wilensky 1998) prevent students from understanding how stable properties of the world, such as Harry’s Maxwell-Boltzmann distribution, can result from probabilistic underlying rules.

A pedagogy that incorporates the use of object-based modeling tools for sustained inquiry has considerable promise to address such conceptual issues. By providing a substrate in which learners can embed their rules for individual elements and visualize the global effect, it invites them to connect micro-level simulation with macro-level observation. By allowing them to control the behavior of thousands of objects in parallel, it invites them to see probabilism underlying stability and statistical properties as useful summaries of the underlying stochasm. By providing visual descriptions of phenomena that are too small or too large to visualize in the world, they invite a larger segment of society to make sense of such phenomena. By providing a medium in which dynamic simulations can live and which responds to learner conjectures with meaningful feedback, it gives many more learners the experience of doing science and mathematics. A major challenge is to develop tools and pedagogy that will bring this new form of literacy to all.

The preparation of this paper was supported by the National Science Foundation (Grants RED-9552950, REC-9632612), The ideas expressed here do not necessarily reflect the positions of the supporting agency. I would like to thank Seymour Papert for his overall support and inspiration and for his constructive criticism of this research in its early stages. Mitchel Resnick and David Chen gave extensive support in conducting the original GasLab research. I would also like to thank Ed Hazzard and Christopher Smick for extensive discussions of the GasLab models and of the ideas in this paper. Wally Feurzeig, Nora Sabelli, Ron Thornton and Paul Horwitz made valuable suggestions to the project design. Paul Deeds, Ed Hazzard, Rob Froemke, Ken Reisman and Daniel Cozza contributed to the design and implementation of the most recent GasLab models. Josh Mitteldorf has been an insightful critic of the subtle points of thermodynamics. Walter Stroup has been a frequent and invaluable collaborator throughout the GasLab project. Donna Woods gave unflagging support and valuable feedback on drafts of this chapter.