Bootstrap computer science in Physics, as well as Algebra

May 18, 2016 at 7:45 am 9 comments

This is a really cool announcement.  I believe that computing helps with all kinds of STEM learning, and admire the work at Northwestern on Agent Based Learning in STEM, Project GUTS, and Bootstrap.  It’s particularly important for getting CS into schools, since so few schools will have dedicated CS teachers for many years yet (as described here for Georgia). I’m excited to see that Bootstrap will be moving into Physics as well as Algebra.

Bootstrap, one of the nation’s leading computer science literacy programs, co-directed by Brown CS faculty members Shriram Krishnamurthi and Kathi Fisler (adjunct), continues to extend its reach. Bootstrap has just announced a partnership to use its approach to building systems to teach modeling in physics, an important component of the Next Generation Science Standards (NGSS). This project is a collaboration with STEMTeachersNYC, the American Association of Physics Teachers, and the American Modeling Teachers Association.

Source: CS Blog: Bootstrap Announces A New STEM Education Model That Combines Computing, Modeling, And Physics

Entry filed under: Uncategorized. Tags: , , , , , .

Implementing Design Studio Pedagogy with an Augmented Reality CS Classroom What’s going on with CS PhD Enrollments: Guest Blog Post from Betsy Bizot

9 Comments Add your own

  • 1. alanone1  |  May 18, 2016 at 10:30 am

    I just tried the Bootstrap hour of code and was dismayed to find that it was in the form of a command line interface rather than in terms of live objects that persist. Yikes! We are in the wrong half century here.

    • 2. shriramkrishnamurthi  |  May 18, 2016 at 4:14 pm

      No, Alan, it means that people have disagreements about whether “live objects that persist” are the right interface for programming or not.

  • 3. gasstationwithoutpumps  |  May 18, 2016 at 5:45 pm

    Is Bootstrap as useful for teaching physics as Vpython, which was developed for teaching physics? Has anyone on the Bootstrap team taught using Vpython?

    • 4. shriramkrishnamurthi  |  May 18, 2016 at 5:59 pm

      I’ve studied the VPython materials in some detail. It’s impressive, for sure. But it’s also pretty focused on simulation and imperative programming, while our approach is more focused on modeling and functional programming. Note also that there’s a bit of a type clash here: Bootstrap is the name of a team/family of curricula, while VPython is a programming language…

      • 5. gasstationwithoutpumps  |  May 19, 2016 at 12:38 am

        OK, to make it a bit more fair, pair Vpython with the textbook Matter and Interactions.

        I’m not convinced that functional programming is as good for teaching physics as imperative programming. Convince me.

        • 6. shriramkrishnamurthi  |  May 19, 2016 at 7:53 am

          I don’t think functional vs imperative is the meaningful distinction here. The real question is what is the computational model you’re trying to teach, and what it corresponds to.

          What we’re trying to teach is how to model reactive systems. That is, long-lived (potentially infinitely so) systems where at each step there is a small process/computation. The computational model for that is a sequence of small executions within the framework of a potentially infinite one. Each small execution is in reaction to some kind of stimulus.

          The outer framework maintains a notion of system state (one of the terms common to physics and computing and actually meaning pretty much the same thing). Each reaction takes the current state and computes the new state, as well as describing any actions that the system emits. It is very natural to think of those reactions as functions: they are essentially state transformers. One can also think of them as difference “equations” (functions, really) describing state transfer.

          Therefore, the emphasis in this approach is on separating and understanding each part: the model (representing the essential “data” of the system), the stimuli, and the transformations. In many other cases where modeling is taught through programming, the state is implicit: it’s just programming language state, and the state corresponding to the model is conflated with state corresponding to visualization with state corresponding to debugging variables and what have you. Achieving a clean encapsulation of that state is, I think, quite important to getting at the heart of modeling, and my collaborators seem to agree.

          Therefore, how those state transfer functions are written is of course reasonable to discuss. One of the virtues of thinking of them as pure functions is that it achieves the above: clearly delineates what is and isn’t the state of the system. Need something else to achieve your model? You have to make it explicit, and show how each step affects that state. You can’t have the implicit modularity of imperative programming provide you with the computational equivalent of “action at a distance”.

          But there’s more. Pure functions also lend themselves well to building up from examples —which are written as tests— and then to also test extensively. We have a whole curriculum (which the other Bootstrap components both provide and exploit) that helps students do exactly this with scaffolding, rather than expecting them to just come up with them on their own. This material is relatively domain-independent, but applies especially well here. In addition, by using this approach, we can hope to either teach or reinforce the algebra skills that are ultimately vital for physics/modeling students, using an approach that has already been seen to work in algebra itself (where Bootstrap has been very successful).

          Separating the event loop that describes the long-running system from the reactions to individual events is thus both elegant and important. These are conflated in many places. To us, it’s quite an essential difference. Furthermore, the understanding they gain through this process in a physical space ought to carry over well into computing as well, where the same notion can be used to understand everything from HTTP servers to network protocols. (Of course, I do not make any claims about transfer, just that we are using a curriculum that _puts us on a path to_ eventually, hopefully, achieving transfer.)

          • 7. gasstationwithoutpumps  |  May 19, 2016 at 11:08 am

            OK, that’s a pretty good argument in favor of the Bootstrap approach to teaching physics modeling.

            Of course, a lot of the pedagogical problems will lie in the details. There are a few problems with Vpython that come from it being embedded in Python (multi-platform support and installation problems were big ones, which lead the developers to GlowScript and now Jupyter-embedded Vpython). How easy Bootstrap is to install, maintain, and use will all be more important than the underlying philosophy of computing for most physics teachers.

            Transferability to other domains is also an interesting question—there are a lot of fields in which Python is a dominant language (bioinformatics, for example), while Bootstrap has not yet achieved widespread use. That’s not an argument against Bootstrap in the long term, but it may affect decisions in the near future.

            There are few (no?) functional languages that have achieved wide-spread use, but I’ve never figured out exactly why. The true believers in functional languages argue that it is because everyone else is backwards, but I’ve never been convinced by that argument. I’ve sometimes thought it was because most programming languages make I/O an awkward afterthought, which sort of works in imperative languages, but fails pretty badly in functional ones.

            • 8. shriramkrishnamurthi  |  May 19, 2016 at 11:34 am

              We’re going to be using Pyret, which runs completely in the browser. Zero install, cloud-based code storage, easy sharing, etc.

              Bootstrap as a project has made this sort of zero-install, painless deployment central, because ultimately teachers pick tools that work in their setting, not just ones that are intellectually exciting. (Given that many schools have locked-down computers, requiring the ability to install something on a desktop —setting aside platform differences— is itself a non-starter at many places. To the best of my knowledge VPython requires a desktop installation though that may have since changed.)

              I first used Python in about 1994. It took nearly two decades for Python to get to where it is now (at least, over a decade-and-a-half). So it will be for other languages and ideas. Patience, grasshopper. It’s a marathon, not a sprint. (When Python gets a quality static type system, we can talk again about how Python’s dominance is unshakeable.)

              Functional programming is in fact extensively used in industry. See for some evidence. See also for the industrial adoption of just one functional language, OCaml. So thoughts on the non-use of FP may be a statement more about not having kept up with what’s happening in the world than about the world itself.

              Nevertheless, that’s irrelevant to me. For me FP is motivated by clear pedagogic justifications (we have a growing body of research that shows various trade-offs between FP and imperative programming), not by pure ideology. I’m not making an “argument”; I’m providing concrete pedagogy and evidence. People can accept or reject that or debate its specific merits, and I’m happy to do that. But internet discussions/flamewars based on pure opinion about FP are so 1990s as far as I’m concerned, and I don’t engage in them.

              Finally, as for state, the event-loop model that I talked about is fully stateful. It would have to be. The question is whether the state is directly in user control or is kept under system control with the user _directing how it should change_ rather than changing it directly. Our event loops take the latter approach. Similarly, I don’t know how anyone who’s studied monadic programming in Haskell could claim that i/o, or state in general, “fails pretty badly” in FP (again, the FP of today looks nothing like that of the late 80s). It’s arguably the most elegant conception of state I’ve seen. It just takes a little practice to get used to doing things that way, but it produces lots of benefits over the “awkward afterthought” of state management in traditional imperative programming (most notably, the absence of its virtualization, which makes it impossible to manipulate as a first-class concern).

            • 9. shriramkrishnamurthi  |  May 20, 2016 at 8:09 pm

              Kevin, the following job ad just happened by my radar:


              It’s a job for functional programming with a knowledge of category theory from TARGET. Not a bank, not fintech, not a fancy research house, but Target.

              Functional programming is like AI. Just because it didn’t work in the 80s doesn’t mean it doesn’t work today. Just like we view AI in a new light, we need to re-adjust our expectations of FP.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Trackback this post  |  Subscribe to the comments via RSS Feed

Recent Posts

May 2016
« Apr   Jun »


Blog Stats

  • 1,269,359 hits

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 4,569 other followers

CS Teaching Tips

%d bloggers like this: