Tip:
Highlight text to annotate it
X
MALE SPEAKER: Wayne Getz and his team here from the NOVA
modeling system with some very interesting
work simulation modeling.
And tell us about it, Wayne.
WAYNE M. GETZ: Well, thank you, Peter.
We really appreciate having the invitation to come down.
I've never been to the campus before so that's very
interesting for us.
And thank you, Ching, for organizing all the details.
So as you know, we've been involved in this modeling
enterprise which we call NOVA, and the team that we've got
here today basically includes myself, Richard, who is the
architect of the NOVA platform, Nick, who's been
working with NOVA for a long time, John Pataki, who is in
the software business service industry and has had a strong
interest in NOVA for the last several years, and also Andy
is here and he's made fantastic contributions to our
website and done a lot of the video work online.
So if you go to novamodeler.com and you look
at the tutorials, Andy produced all those tutorials.
So the title of the talk is NOVA, an interactive
graphics-scripting platform for education and
computational research.
The structure of this talk is I'm going to do the motivation
and vision part, which shouldn't last too long, and
the heart of the talk will be given by Richard, who will
talk about the architecture, and some of the innovative
aspects of NOVA and how it contributes to computational
thinking, and then Nick has got the exciting part, which
is really to show how we're using NOVA in education and
also as a research tool.
So I'm going to talk first about the vision thing.
So what is NOVA?
NOVA as a platform that is not too specialized, and by that I
mean it's not built for a very specific purpose.
It's built for a general purpose platform, but it's not
going to be too amorphous either because it needs enough
structure to facilitate coding by people who have very few
coding skills and are basically going to be building
their code through a graphical interface.
So in a sense, NOVA is just right for the lawless wilds of
the applied sciences.
So in the applied sciences today, we have a lot of people
interested in using computational tools but who
aren't deep coders and actually can't do anything
very sophisticated without having coders
working with them.
So NOVA is really designed for applied scientists to move
beyond coding, not to be bogged down by this problem of
how to do efficient coding when teaching and developing
what I call canonical teaching models and
also research models.
So NOVA's supposed to take us the whole spectrum from
teaching to research.
We think NOVA is a game changer and I hope you'll come
to the same conclusion after you've seen our
presentation today.
So in the field of intensive computational approaches in
the applied sciences, I always think that this is akin to
riding the tiger.
So computational models can be very, very dangerous if you
don't know what you're doing.
And I think today in a lot of applied fields, certainly in
the field where I am, computational population
biology, there's a lot going on that is very
unsatisfactory.
So we ride the tiger where the law is weak and anything goes.
So the Berkeley philosopher of science Paul Feyarabend wrote
this book "Against Method," a critique of science.
And in a sense, if we have a look at what's happening in
these applied fields that I've listed up there, you have
instead of having a foundation in the laws of physics that
can guide you in your computational thinking and
your computational models, we put together ad hoc
narratives.
And the question is, how are we doing science and how is
this science?
And NOVA is going to help us make it science.
My own area is computational population biology, and one of
the things we're particularly interested in are individuals
moving over landscapes.
So here we have some yellow individuals, maybe herbivores
grazing on the landscape and some red individuals that
would like to eat these herbivores.
And if we build a model of what's going on, we have what
I call the inner world and outer world
dynamics of our agents.
So agents are these individuals, the organisms.
They grow, they have a physiology, in terms of
disease processes they have an immunological system, they
also have brains and they're making decisions about where
to go and what to do.
And in order to make these decisions, they have to
integrate information in their outer world.
So the outer world consists of these circles or kernels that
they integrate information over.
The information may pertain to the resources they need to
live and also there may be a landscape of fear out there.
They have to avoid other individuals.
And the landscape structure becomes very important in
determining how they should move and what they should do.
So this is kind of the level at which I'm interested in
applying computational methods and trying to understand how
these systems work with application to conservation
biology, various ecological questions.
So what struck me very recently was what I call a
symptomatic case study, and in this case study I had a
colleague who's been building models of animal interactions
in the emergence of territoriality.
He's particularly interested in the behavior of foxes in
Europe, but this can apply to many different systems.
And what he's looking at is individuals go around marking
territories and other individuals come in.
And when they detect these marks,
they alter their behavior.
And if you model these individuals moving over
landscapes and analyze the data, then you get the kinds
of territorial structures that you see in this
diagram on the left.
Interestingly, when I said to him, did you
include your code--
which in this case, happened to be MATLAB--
he said, are you crazy?
I'm not giving away my work.
Now, this is very disturbing from a scientific point of
view because science is a social activity.
It's a collaborative activity, certainly at this level, where
you have lots of data, big problems, and you need
expertise of different people to really build a team that
can address these issues.
And we need to build on each other's work rather than
protecting others from getting our software.
And I can really understand why he says that because now
it's actually a huge amount of work to build the kinds of
models that produce this sort of information, and we need to
make that process easier.
So NOVA is our solution to containing this tiger that we
all want to ride.
And part of that solution is to promote a collaborative
community of model builders.
NOVA is a highly expressive visual language, and we think
that this will set new standards
of information exchange.
As Richard will explain, it promotes process thinking,
which we believe will lead to a better trained generation of
applied scientists.
It will also allow rapid prototyping and accurate
coding, which we believe will lead to best modeling
practices and reproducible science.
And finally, efficient development of research
models, which in the context of NOVA will lead to reusable
libraries, pedigreed methods, code sharing.
Those of you who know R and its tool boxes have seen how
this is promoted statistical applications in ecology,
sociology, and other fields.
We think NOVA is going to be able to do all this if it's
the right platform.
We believe it is.
So in promoting a collaborative computational
community of applied scientists, what we're most
interested in doing is first be teaching NOVA in college
courses, and we're already doing this
at Oberlin and Berkeley.
We're also trying to bring NOVA because of its ease to
start building very easy, small models to the high
school classroom, and Nick's going to talk about our
success in this particular area.
At this time, we're planning local and international NOVA
workshops, and we're doing this by forming an
international consortium to enhance all aspects of NOVA.
And Richard will show you the different components--
the IDE interface of the plug-ins and libraries and how
we put these things together.
So at this time, this international consortium
consists of--
it's very informal.
It isn't a formal consortium at this point, but we have
collaborators in South Africa, at UKZN, where I have an
appointment, colleagues in Israel, in Norway.
We hope to develop more partners in India, we have
partners in Germany, and also in Spain.
So NOVA is supposed to be this easy entry platform with
spectacular power, and Richard is going to show us why.
RICHARD M. SALTER: Here we go.
So I'm going to talk a little bit about the structure of
Nova, show you a few examples, and give you a feel for the
approach that we're taking in this platform.
At the risk of being a little bit glib, I like to think that
what we're attempting is a poke at the architecture of
computational thinking.
So the challenge, really, is boiled down into two parts.
First of all, to create a design platform whose
components express the abstract structure of
dynamical systems.
So in other words, we want to create some kind of a visual
metaphor that is appropriate for the kinds of systems that
we're building.
But at the same time, we want to provide the tools that
promote the best practices of programs design.
As somebody who's been involved in programming myself
for the last many, many years, I have a sense that there are
good and there are less good ways to build programs, and
I'm hoping that what we do here is try to provide that
same ethic, in a sense, to this new
milieu, this new area.
So the kinds of models we're talking about really fall into
three categories.
First, there's system dynamics, which was invented
around or formulated around 1956.
It is exemplified by these stock and flow networks.
The stock and flow networks are actually visual
representations of differential equations.
And simulations that use these networks are, in fact, what
they're doing is numerical integration.
But fortunately, the designer doesn't really have
to think that way.
All the designer thinks about is that they have a reservoir,
they have a flow into or possibly out of that
reservoir, that the flow has a certain rate and effectively
although they're doing with derivatives, they don't
necessarily have to be formulating their
thoughts that way.
In particular, things get interesting
when there's feedback.
In fact, let's say they're not interesting at all if there
isn't much feedback.
But most of these systems do have some form of feedback,
and so that is expressed very directly in
terms of the diagrams.
In addition to the system dynamics, we're also talking
about another domain of modeling, and that is the
domain of spatial and agent based models.
Spatial models, if you're familiar with cellular
automata, like the game of life, then you've seen you
seen something of what I'm talking about.
So your automata represent some form of topology, namely
that each of these cells in a cellular automata has some
sort of individual state transition rule.
That rule may depend upon something that's going on in
the neighborhood.
So topological considerations enter in.
Adding to that we have agent based, where we're talking now
about individuals that can similarly have internal
states, but they also interact with each other.
There are births and deaths possibly, and they may
interact with their environment.
So NOVA is a single framework to capture this eclectic set
of systems.
And I'd like to think that the expressive power that we're
seeing as we build NOVA models derives from these properties
of good programming, namely modularity, the ability to
isolate and modularize various parts and interchangeably slip
them in pull them out and so forth, abstraction, and
extensibility.
So here's a quick look at the NOVA architecture.
We start down here with a design platform, a visual
design platform, on which we are able to construct models
using the visual component language.
This design platform supports multiple levels, and as a
result, the component language is able to support various
forms of abstraction and aggregation.
Now, the model that is created visually on this platform is
captured and turned into a script in a language called
NovaScript.
NovaScript is embedded in JavaScript, so that it is a
complete JavaScript language interpreter with additional
object types that represent the abstract
elements of these models.
The running or the simulation, actually, is equivalent to
running the NovaScript program on what I would call the
NovaScript runtime environment, which is
similarly the JavaScript runtime environment with these
additional elements.
At various points in time, there is going to be some kind
of display.
You're going to want to display graphs or you're going
to want to display various possible visualizations.
And so we would then reflect back to the display element,
which we call the dashboard, and which includes various
different kinds of display entities.
So what I want to do now is switch to and go
over to this demo.
This is an example of what a very simple
NOVA model looks like.
This is a model of population growth.
This is kind of the hello, world of the
system dynamics modeling.
And so we have a population that
represented by this stock.
We're only modeling birds, so we have births that represents
the rate of change of the population.
The births are themselves determined by the current
population times a rate factor, and this is what gives
us the exponential growth that we're familiar with.
So if I construct this model this way, we have graphs on
this side, this is the dashboard side.
And when I say to run as the capture load exec, we set up
some time constraints here, we determine a DT for the
numerical itegration and integration method, and we run
the model and we get this graph.
Now, the actual model is contained here in this
NovaScript.
So this is the model that has been captured and turned into
a script and is actually running on this NovaScript.
We present a console here so you can actually interactively
probe the model, you could single step it, you could ask
for different values along the way, and so forth, which I'm
not going to do now.
Now, another interesting thing you can do with this from a
teaching point of view is you can put it into a mode where
if you change the rate, you immediately run the model and
you can see instant feedback on how things change.
So we're thinking in terms of very good educational user
interface aspects.
Now, I'm going to eliminate some parts here.
I'm going to make it do a transformation.
By the way, what I'm showing you here is not new--
Stella, Vensim, Berkeley Madonna, they all implement
systems that are like this.
But what I'm about to show you I think is new.
So let me get rid of this.
I'm going to convert to this rate slide into from a value.
I'm going to convert it into a pin, I'm going to add a pin,
which we'll call pop out.
I'm going to now run an arrow from here to pop out, because
what I'm going to do in pop out is just present the
population.
And so these pins represent input and output
ports to this model.
So think about this model now all by itself.
So the next step is to create a set a new layer, which I do
by clicking here.
And so now we have the lower layer, which contains the
original model.
We now have this upper layer, and I can now pull this out
and create an encapsulated version of the original model
at this higher layer.
The original model is inside, and you'll notice that the
pins that are sticking out here correspond precisely to
the pins that are shown here.
So now, once again, I can add a graph.
We'll just call it pop graph.
And I can connect this graph.
And I think, in the interest of time, I've kind of already
done this in an existing model.
We add this here and we have to add something to control
the rate, so we have that, and we connect that over here.
And now once again, we have the same model we had before
but now the model exists at a different level.
What's interesting about this is that if I want, I can
create two instances of that model, and that's
what I've done here.
So I've got two instances of the same model at this upper
level, and I can change the different rates here and we
see this one only affects the second one.
That's the first one.
So in other words, we can have multiple
instances of the model.
That's not something that's unfamiliar to programmers
because, in fact, we write some programs and we do this
sort of thing all the time.
So when I showed you that we had originally the original
model I call the capsule.
This is a capsule where I've added the pins.
And now you can see that in this situation I've embedded
this capsule into this chip, and the chip represents the
submodel at the higher level.
So another way of looking at this is that we've created a
kind of a third dimension to the design.
So instead of being a flat design, we now have a three
dimensional design.
And just to point out that this, too, can be embedded in
something higher.
And so we can go as high as we want in terms of this kind of
vertical design.
Now, what do you do with that kind of thing?
Well, there might be a number of interesting
things you can do.
In particular, you could represent a spatial grid.
So I could have a bunch of chips and I could line them up
in horizontal and vertical rows and columns and I can
think of those as actually being some sort of positional
thing, or I can also think of them as a set of agents.
Now the people who came up with Stella thought of this
themselves sometime ago.
In Hannon's book from 2001, he proposed spatial modeling in
Stella, and this is the picture that he came up with.
So what we have is a single model where he's done a kind
of cut and paste, and he's cut and paste the same model over
and over again, and then he has to hook
up the various pieces.
It's interesting that he actually had his grad student
do this rather than doing it himself.
And this is what was proposed as a spatial model.
And notice that we only were able to get nine different--
a three by three grid, which isn't very much.
So this is certainly not a particularly good solution.
But, in fact, the chip solution, for this particular
case, would not be a great solution if you wanted to have
say, 10 by 10.
You'd have to manage a grid of 10 by 10 chips.
So in fact, the better thing to do is to think in terms of
more advanced containers.
And I'm going to demonstrate that with some examples.
I think there's probably only time for two of the examples
so I'll just do the first and the last to show you a spatial
model and then a spatial and agent based model.
And by the way, NOVA ships with a whole set of--
a model library, and all the examples I'm showing you are
in that model library.
So let me load up the first example.
This is called the fire spread example, and it's a cellular--
it's kind of like the game of life in a way, but what we're
representing is a forest with trees.
The trees can either be green on fire or burned, and the
transition rules are fairly simple-- namely, that if you
are a tree that's next to a tree that's on fire, then
there's a probability that you might catch fire.
If you catch fire, you burn for one time unit and then you
burn out, and then you can't be burned anymore.
To make it interesting, we also add
in this blue firewall.
But to make the firewall
interesting, we add some holes.
So if I run this-- there we go--
we can ask ourselves how often is the firewall going to hold
and how does that relate to the probability of a burn, and
then we can repeat this.
We haven't gotten through yet--
the fire burned out.
Obviously, if I up the probability, we would expect
worse things will happen.
All right.
So what is this model built out of?
Well, it's built out of a grid of I think 50 by
50, so 2,500 cells.
Each cell is, in fact, a model similar to the original, to
the model that I showed you before.
Namely, we have a state, which is represented by the tree.
The state can be one of four possibilities--
either unburned, burned, burning,
burned, or a firewall.
And now we're at a point where we have to do something that
departs from what system dynamics gives us.
In system dynamics, there are so much semantics built into
the basic structure of the stock and flow-- namely, the
fact that you're using an integrator, that all you have
to do is represent the stock and the flow and the system
kind of takes over at that point.
But for these more advanced models, we're actually going
to have to specify what we want to have happen.
We have to specify that logic, and that's where things get
hard, because specifying logic means programming.
We can make that a somewhat less daunting task if we can
take the pieces of program and represent them visually and
represent them in terms of functionality.
So in here, in this element here, is what is called a
program chip.
And a program chip--
I guess it's a code chip.
And a code chip represents a function, or it can
represent--
actually, you can have fields so it really
represents an object.
It also can represent a higher order function so you can
actually define a function that can then be exported sort
of the way you might do it in [? Lisper's ?] scheme.
And the code chip contains the logic for one definable part
of the model-- namely, in this case it contains
the logic for burning.
So we have input we put the current value of the tree,
what its state is, the probability of burning, and
then something about neighbors.
Now, neighbors is an important part of this-- namely, we're
only going to burn if our neighbors are burning.
So we have to do is compute the neighbors, and that
requires another code chip.
So we create a code chip which simply says here are my
coordinate, who are my neighbors?
I just iterate through a nested loop and I can compute
my own neighbors.
So I compute my neighbors here, the neighbors are stored
here, and then are ready to be consulted over here.
So this model visually presents the
logic of the system.
And the beauty part of this is that if somebody else needs to
compute their neighbors, or your friend, you could take
off this part of the model, export it to them, and they
could just include it.
In fact, all of these things are exportable--
the code chips, the capsules, and so forth, are all
exportable and archivable.
So once the functionality has been defined, it
becomes a black box.
It becomes trustworthy.
Then, in fact, you can use it again and again.
AUDIENCE: Sorry.
Can we look at the container that that submodel is in?
Does that fire spread layer on top, does that actually
contain instances of this thing?
RICHARD M. SALTER: I'm about to talk about the
containers right now.
AUDIENCE: All right, because I see an abstraction violation
here where the bottomless level needs to know what
neighbors, and neighbors needs to know that it's in a
container that has this kind of--
RICHARD M. SALTER: That's right.
AUDIENCE: So are you going to talk about that in a bit?
RICHARD M. SALTER: The neighbors, if you look
closely, what's happening is that they're primitive
operators that are provided.
And those primitive operators are only going to be valid if,
in fact, the capsule is part of the container.
So you're basically making a call to your container to get
that information.
That's a little more in the weeds than I
wanted to get into.
If I showed you the code for neighbors-- let me show you
just quickly to answer your question.
AUDIENCE: I noticed the super dot matrix [INAUDIBLE].
RICHARD M. SALTER: Right.
Yes.
AUDIENCE: But is that a generically--
it seems that that's pretty much assumed that maybe we
have a rectangular layout.
Maybe what if we had a hexagonal grid instead of a--?
RICHARD M. SALTER: Well, then we would possibly abstract
this in a different way.
But this is depending upon the fact that this is going to be
used inside the container.
AUDIENCE: Right.
And more precisely, it seems that it's very dependent on
the container type, which seems to be a bit of a strong
coupling between the model, the piece that's the tree
sensing logic, and the kind of container that
that's embedded in.
So I'm just wondering how it's possible to better abstract
the tree and its sensing of what's going around it?
[INAUDIBLE].
RICHARD M. SALTER: There could very well be.
I mean, this is tailored to this particular model.
For example, one of the things that we're going to be looking
at are more generic containers where the notion of neighbor
becomes a more abstract concept and it doesn't
necessarily depend on the fact that it's a Cartesian grid.
But in this case, we are.
I'm glad you noticed that.
The idea is we have a container, the container
provides services to its constituents, and the
constituents will use those services, and we want to make
those services as abstract as possible.
So that is a goal.
So actually, here is the container.
It's not much to look at.
But this, as you have sort of teased out, the fact is that
we've got these containers that do provide a particular
set of services in a particular topology.
The cell matrix is effectively a two dimensional array, so
the idea of a pair of coordinates is a
natural thing for this.
The agent vector is a one dimensional array, but it adds
additional capability involving position and also
births and deaths.
And then the simulation world combines the two-- it combines
the cell matrix and the agent vector so that the world that
the agents are moving is, in fact, the world that is
defined by the cell matrix and the agents can interact with
their ground.
And I'll show you an example of that right now.
MALE SPEAKER: And if we can do this example in about three
minutes, I think that will give us enough time to get
done what we want to get done.
RICHARD M. SALTER: Well, we had some questions.
So here is the wolf sheep predation.
And what you have here--
the wolves are in red, the sheep are in blue.
We also have grass growing, the sheep eat the grass.
Here we're using a sim world.
This is our grass where we have growth and we have eaten.
And this red point represents a communication point between
the agent that is the agent that might be occupying that
cell and the cell itself.
The agent is the most complicated part, because it
actually impersonates both a wolf and a sheep.
At this point, at this particular point, in NOVA
development, you can only put one type of agent an agent
vector, but we're working on having a multiple flavor type
of representation.
But you can always do it through a mode, which is what
we do here.
You come up with a type and it's either a sheep or it's a
wolf and different functionalities are going to
be swapped in.
So sheep energy--
here's where we deal with sheep eating grass.
Here's where we deal wolves killing sheep.
Here are code chips that compute all of that.
Here is a mover.
This is a generic mover that's used in a lot of different
models that turns polar to rectangular coordinates.
So we talked about code chips.
And then the last thing is plug-ins, and plug-ins are a
way of extending the NOVA platform with actual Java
extensions that talk to an API.
So all of the visualization elements that you saw there
are examples of plug-ins.
Now I have one more example that I think illustrates the
granularity of model structure that NOVA actually sort of
forces you to think about.
So here, this model is a four layer model.
And at the bottom layer, we have one kind of thing
happening-- namely, we have a fission event,
rather, fission or die.
So if I exec this model, we're thinking of an individual that
does one of three possible things.
It either persists the way it is at one or it goes to zero
or it goes to two.
And we identify zero as dying and two as fissioning.
This is an event oriented model.
You take this one layer up and you use what's called a clock
chip, and a clock chip adds to the ordinary chip the ability
to actually have its own clock.
So that one tick at this level then becomes an entire
simulation at the level below.
And now what we're going to do is we're going to look at this
happening, and we're going to repeat the experiment some
number, say, 10 times, and use a histogram to show what
happens over those 10 different simulations.
The histogram is an example of a plug-in, one example of a
plug-in, that does the function of a histogram.
At this level now, we're going to actually take those
elements and create an agent space in which the behavior
plays out so that we're going to, in fact, see a population
trajectory of starting, say, with 100 individuals and going
through this fission and die or die process.
We're going to watch the growth and decay of the
population.
So it goes from 100 up to 130 and so forth, and I think we
have the probability of fissioning and dying as the
same here so, in fact, it's going to be a
fairly random process.
And at the next level up, we're going to do a
statistical analysis.
So what we're going to do now is, once again, using a clock
chip, it's going to repeat the experiment, say, 100 times.
And we're going to accumulate statistics down here, namely
the mean and standard deviation.
We watch, actually, as this is done over and over again and,
in fact, this gets very smooth.
So each of these shows process logic of a different type that
is played on the level below.
Each of them is a different kind of process.
It's certainly clear that one could write a Java program or
a JavaScript program to do this.
It's not a complicated model.
But what really shows up here is how these different layers
actually are distinct and how they interact with each other.
In other words, the actual architectural model is much
clearer here than you would actually see if you were just
coding it up.
You can also take any of these layers and possibly plug
something else in and use them in a different model.
So I'm going to complete my talk with just a little bit
about the future.
So a couple of things--
two very important things we want to do is we want to be
able to interact with other platforms.
We are already interacting the R platform, and in a limited
way we also want to be able to use GIS data to program our
spatial models.
And very important, is we want to be able to create curated
archives and libraries of capsules, code chips, and
plug-ins so that we can create an entire set of tools, say,
for Wayne's domain, for population biology.
We could create another set of tools and create communities
that use these tools and enhance these tools and are
actually interacting over sort of the ecology of NOVA.
Another very important aspect in terms of ramping up is to
be able to use high performance computing, and
NOVA is really quite architecturally appropriate
because, in fact, we have NovaScript and then we also
have the visualizing and design
platforms, and they're separate.
And so for example, the NovaScript could run on a
server and there could be interactions between clients
on a laptop or on a mobile platform.
Now, I haven't had much of a chance to talk about
NovaScript itself, but there's a paper that you can download
that actually gives some details about
the scripting language.
There are some people who've actually just gone and written
NovaScript programs without actually
using the visual domain.
So I'm done.
NICK SIPPL-SWEZEY: So we're going to try to bridge the gap
between education and the research right now, which is
clinical trial simulation to reduce mortality in Africa,
childhood mortality in Africa.
And Rich touched on this-- as a NOVA user, this is how I
think about NOVA in terms of how it's useful for me.
It's a domain specific visual language and the domain is
modeling in all its different capacities.
And not only that, we actually can reach down into some high
level scripting languages and get more expressiveness than
we would have in the visual domain.
And if we really need to or if we have something that we
really like, we can reach on at a lower level language
stuff and develop plug-ins and tools in Java.
But the productivity and the process thinking and the
accessibility happens up here at the domain
specific visual side.
I think that's really where NOVA shines.
So on the education side, there is a new
set of national standards.
The National Research Council of the Academy of Sciences has
released two documents.
One is called "The Framework for K-12 Education." The other
is "The Next Generation Science Standards." These are
designed to inform state standards, and states are
going to use this stuff to figure out what they want to
do in terms of their state school systems.
And what I'm going to show next is a reasonably
complicated articulation of how they view the scientific
process, and I'm going to highlight where NOVA fits in
this framework.
But the notion is that you have the real world where you
have real world data, where you're able to collect data
and test solutions, and then you have theories and models
on the other side.
You use theories and models to help you formulate hypotheses
and proposed solutions.
And what we do in the education setting with NOVA is
we actually allow students to interact with theories and
models in a more intuitive and integrated way.
We allow them to explore and formulate hypotheses using
those computational models.
And the exciting bit is that we actually let them collect
data and test solutions in a simulation environment.
And where NOVA really shines is when we actually introduce
real world components and we actually have the whole
scientific process happening quickly in a computational
form for students.
And that's our approach to this.
We want to link all these things together.
So our objective here was to develop a three day lesson
that an instructor could implement in class that would
teach infectious disease principles--
because that's my background, that's the background of the
funding agency--
and computational modeling principles.
And then we wanted to do engage students in that
intuitive, rapid cycle scientific process and we
wanted to focus on global infectious disease.
So what we've done so far is we did a pilot at Castilleja
in the fall and the pilot was in two biology classrooms at
Castilleja.
We did a second revision of that lesson at the Bay School
in San Francisco.
And just three weeks ago, we did a public pilot at Aptos
High down on the other side of the Santa Cruz Mountains in a
health class.
So, not in a biology class and not in an experimental biology
setting but in a health and how can I use a model to
understand my decisions and health and the health
consequences of the those decisions?
So we're exploring this in a couple different realms and
we're seeing good things.
And we've presented the results that we have at the
California Association of Independent Schools.
[INAUDIBLE] and I did a presentation there, and there
was a lot of enthusiasm for these kinds of tools.
And then we also presented them at the UC San Francisco
Academy of Medical Educators Annual Education Symposium,
and something very interesting happened where people in the
medical education world said if you can introduce
computational modeling tools and data intensive
applications to high school students, it would be great if
we could do that with our medical students because
that's what we need to train our medical students to do in
the future.
So everywhere we go presenting what we do, we get
enthusiastic responses and people really see potential.
And I'm going to go into a little bit of detail on what
we actually do in these classrooms because you can't
just hand students a model, have them play with, and have
them come out with discovery.
You actually need to introduce students in an organic or
intuitive way to what we're doing.
And the way we do that is we start with a very simple
lesson called the circle game, which is an interactive,
intuitive experience where students are all sitting in a
circle and one of them starts sick.
And they have a local contact neighborhood-- we don't
describe it that way.
We say look two neighbors to your left and two neighbors to
your right and count how many people are sick.
And we give them a rule that they execute with a die, and
they essentially execute the algorithm of a computational
model of infectious disease live in class.
And none of this is introduced as computational modeling at
the outset, but they are essentially doing a
computational simulation.
They're the nodes of the simulation.
And we show them that exact same process using the
simulation software.
And all of a sudden, we've mapped a real world experience
that they had, where they were looking at an infectious
disease to the computational model.
And not only that, we can run this multiple times, we can
explore iteratively, and we can see different trajectories
of infection.
In this setup of the game, people are healthy, they get
sick, they never get better.
And so over time, you see that everybody ends up in an
infectious state.
And this is a great moment for students to offer their
alternate interpretations of how infectious disease works.
And they can say well, chicken pox, people get better and
they get resistant and they're immune.
Other diseases, you get sick and then you get better.
And we actually are able to implement those other rules of
the game to see how they change the infectious disease
process, and students are providing the idea.
We're showing them computationally
how that plays out.
So students immediately in that first lesson were just
trying to build a foundation for them to understand what a
computational model is.
And we do it with experience and we do it intuitively.
We send them home with a homework assignment where we
assign them a disease in small groups and they parse out some
of the parameters that you might use for these infectious
diseases, and they go and they realized that the real world
is messy, that you can't necessarily figure out all the
time how many contact somebody is going to have for measles,
for instance, or what the transmission probability is.
But they go out and they get real world data, and they come
back for lesson two.
And this is what the data looks like, and we provide the
instructors with a background on measles.
What would be appropriate parameters for measles?
How are these documented?
So Instructors are in a good place for this.
So we have a foundation, we have real world data, and
that's where we're able to actually do the
computational modeling.
We've cushioned and set students up to succeed and
they do things--
well, they launch it on a web page and they
do things like this.
And what we have here is a simulation of measles where
we're looking at how the frequency and size of the
outbreak changes when
vaccination rates were changed.
And students are given this model.
They have four parameters that they can change and those are
set up in sliders and Rich showed what those look like.
And we're actually starting with a high level of
resistance, so imagine high vaccine
coverage, 95% vaccine coverage.
And instead of being in a static, fixed network, the
agents are actually moving around.
Students are able to map this and realize we're getting
closer to the real world and this is how people might
actually mingle for measles.
And they can change parameters.
And so in this demo, we changed the perimeter of
vaccine coverage from 95% to 70%, and you see
epidemics play out.
And we have good visualizations of what that
looks like.
Students are able to work with this stuff in a couple
different ways and they're able to do it interactively.
They're able to see the animation, they're
able to see the data.
So it's a powerful tool for letting students get an easy
and powerful introduction to what computational modeling is
in infectious disease.
So we scoot on.
And when I was showing this to my partner last night, she
said this is a death by PowerPoint slide.
You have an entire paragraph of text sitting up there.
And the reason why I have this up here is because this is
what a student responded to in our Castilleja lesson.
We said write a concluding paragraph and put in what
parameters you did and what significance it has to the
real world.
Give it your best shot-- this is our pilot lesson.
And you see that the student says that if resistance goes
from 95% to 85% in a town with a population of 100-- so
they're quantifying their simulation.
They have incubation times and infectious times in there.
How does that affect the number of
people who have measles?
In two lessons or three lessons, they're able to
connect their simulation to the real world and they're
able to say something like from the answer to this
question, we learned that if towns had an 85% resistance
rate instead 95%, you could have a mini epidemic.
So I think our lesson is successful for the students
and this is a great indicator of how what we're trying to do
is actually getting through them.
And this was in our pilot lesson.
Things have really improved in a lot of ways since then.
We did a public school pilot and we actually did some
pre-post analysis.
We asked students to define a computational
model on the way in.
We had a couple students have nailed it right on.
We asked them to define one on the way out--
93% percent of students got it.
We had a couple students who just--the whole lesson went by
and they didn't get it and it didn't work for them.
We also asked how this simulation exercise or the
simulation lesson effects their understanding of
infectious disease.
And we had a lot of students reporting that the model
helped them understand something about staying home
when you're sick or getting treatment and antibiotics and
how that might affect infectious disease or
vaccination.
So looks like we have a lesson that's working
really well for students.
Really, what we need to focus on now is a lesson that works
well for teachers.
And our expert instructor we worked within our public pilot
said anytime he's presented with new content, it's a five
minute test.
He needs to know what he's going to do and what his
students are going to do in five minutes.
And if he can figure that out, he'll spend the rest of the
time actually putting the lesson together.
And what we have right now we want to really work towards
executing that five minute test.
So we have something that works for students, we have
something that we need to improve and make better for
instructors, because instructors are the limiting
reagent in the whole reaction.
So we want to pass that five minute test.
Teachers want to use these lessons in the
fall and in the spring.
They want to develop their own lessons in the future, and
we're going to be able to continue doing this and we're
going to put the documentation and the assignment sheets and
all the support materials to pass that
five minute test online.
So I'm going to change gears and thank the
people who we work with.
This is part of something called the Models of
Infectious Disease Agent Study.
That's the NIH group who does this infectious disease
research stuff.
So now I'm going to go to the other end.
We're using NOVA to help understand how we might reduce
child mortality in Africa, and I'm laying this out to sort of
show the scope of what we're doing with this tool.
And what you need to know here is that to reduce mortality in
Africa, what you do is a cluster randomized clinical
trial where you provide treatment to some communities
and you provide a placebo to other communities.
The randomization unit is the community, and you try to
observe if there's a significant effect or
significant difference between some outcome variable in those
randomized communities, and that might be malaria,
pneumococcus, or malnutrition.
So what we do with NOVA is we actually pull spatial
coordinates for where these villages that are in the
trial, and Google Maps is a great tool for this because
you realize that you can actually get very high
resolution on what these communities look like.
You're getting census data on the ground for the villages
and you're able to actually verify that census data with a
high resolution picture.
You're able to say does this look like a 7,000 person
village or a 300 person village and you're able to
verify and validate year data.
And we're able to use that in our simulation.
So this is not the trial area that we're working in, and the
trial that we're working in is in planning stages so I can't
show that stuff.
This is somewhere else and we're using this as a demo,
and these are communities randomized
into control and treatment.
And you can imagine that there are actually different
mortality factors, say, along this cluster here, which is
along a waterway, versus these more sparsely located
populated areas, probably in the highlands and probably
further away from water sources.
And if you're in clinical trials trying to figure out
how you're intervening and what your intervention looks
like in these different environments, that's an
important thing to think about.
And every single one of these communities is actually a
child submodel aggregated at the community level and then
reproductions of those aggregates in especially
relevant context.
And what we get is a simulation that when we
animate it looks something like this.
And what we're looking at in that yellow color is the
incidence of invasive disease.
So this would be the disease state right before a mortality
event happens and this would be the place where an
intervention would reduce mortality.
And what we actually are simulating here is every six
months, some treatment is interjected into the treatment
groups and that treatment doesn't exist
in the control groups.
And you can actually lay out and simulate your whole
clinical trial and test out different hypotheses or
assumptions that you have about the underlying
population region.
And it's a great tool for exploring and making some
simulation based decisions about how you're going to plan
a clinical trial that you want to succeed.
And essentially what we're doing is we're
just trying to map.
Do these control villages here map to reduction
of mortality here?
And NOVA's nice because we aren't actually doing the
statistics in JavaScript, which is the underlying
language and scripting language.
We're actually using R for that.
So we take all the simulation data, NOVA's playing nice with
R, we do our statistical analysis over there, we pipe
it back over.
And you can see this is what we're really trying to get at
with our clinical trial simulations, which is what's
the power of the study.
How often would we see the effect of the treatment if an
actual effect exists?
And to close off, more or less, this is what the model
actually looks like.
There's script involved in here but the components that
we're using for the simulation are really the same components
that Rich was able to show at the beginning.
And we actually have an infectious disease state, here
we have the child here which includes that infectious
disease state.
We're aggregating children at this level, and then we're
aggregating communities here, and we actually have multiple
levels of aggregation.
You're aggregating an aggregate, and we're really
using that hierarchical structure of NOVA to
successfully implement this simulation.
And it's relatively visually intelligible.
If you organize it and if you're able to communicate it
well, you can use the flow and the visual to express what
you're doing.
So, the breath of NOVA--
you can do stuff in K-12 education, you can do stuff to
reduce mortality in Africa.
I think more pertinent than that is actually that we're
trying to introduce tools at the K-12 level that people can
then use to help resolve some of the most complicated issues
that we're faced with today like development and
mortality in Africa.
And you start in high school with an introduction to it,
you're able to use the same tool as you progress through
your higher education, and you're able to take it to
innovation and research.
And it's a tool that works at both ends of spectrum and can
push and accelerate students along their path.
So thanks for giving us the opportunity.
RICHARD M. SALTER: And how much of a programmer were you
before you came to NOVA?
NICK SIPPL-SWEZEY: Yeah.
So if I put myself on this spectrum, I was introduced to
NOVA at the higher education level.
And in two years of working with it, three years of
working with it, I was able to accelerate to that innovation
and research level where we're doing useful things for real
people in practice.
RICHARD M. SALTER: Nick is not a CS guy.
[INTERPOSING VOICES]