Teach Real Algebra with Code: The Interdisciplinary Program Bootstrap #CSEdWeek

December 10, 2013 at 1:56 am 25 comments

I got a chance to learn more about Bootstrap when Kathi Fisler visited us here at Georgia Tech recently.  This article doesn’t do a good job of selling the program.  Bootstrap is important for showing how programming can be used to teach something else that we agree is important.

“When you hear, ‘This is so amazing! These apps teach kids to program!’ That’s snake oil. Every minute your students spend on empty engagement while they’re failing algebra, you’re assuring that they’re not going to college. Studies show that the grade kids get in Algebra I is the most significant grade to predict future income.”

via GoLocalProv | News | Julia Steiny: Teach Real Algebra Instead of Wasting Time with Apps.

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

President Obama calls on every American to learn to code #CSedWeek Why are English (and lots of other) majors studying computer science? #CSEdWeek

25 Comments Add your own

  • 1. alanone1  |  December 10, 2013 at 8:30 am

    Let’s see here … the pitch in the article and the bootstrap page is that all works “just like ‘real’ functions” in the official algebra curriculum

    … except we find that they are using Scheme with a completely different syntax for expressions, functions, etc.

    If we buy the argument that Algebra I is what is important — and that it’s possible to use a form of programming to teach it (both seem weak but somewhat plausible) — and we look at their main demographic targets (ditto) — then I think I would try to be as 1-for-1 as possible in all ways to reduce confusion.

    The idea that you are not really programming unless you have to worry about semicolons is truly ludicrous.

    I think the pedagogical arguments here need a lot more scrutiny. But perhaps they are outweighed by the simple “get past the barrier in the old existing world” arguments that underly this work.

    • 2. Kathi Fisler  |  December 10, 2013 at 1:57 pm

      Yes, we currently use Scheme in Bootstrap. When we started the project in 2007, we were building on an infrastructure that only existed with PLT Scheme (now Racket); DrScheme also had some pedagogic support features that we wanted to exploit.

      Asking whether the syntactic difference is problematic is entirely reasonable. We are in the midst of our algebra transfer studies, and don’t have data on this question (anecdotal or measured).

      One syntactic challenge we’ve faced is that algebra notation is inconsistent in how it treats primitive operators (+, *, etc) and user-defined ones: primitives are written in infix, while user-defined ones use prefix. Bootstrap works hard to help students understand that both + and f(x) x+1 are functions: we use pedagogic techniques (diagramming expressions) to reinforce those similarities, and anecdotally our teachers believe the curriculum is effective at this. Parenthetical syntax has the advantage of uniformity (all prefix), which makes the process of coding more systematic for students at the beginning.

      Assuming you can’t change standard mathematical notation (an assumption we choose to make), then there is a tradeoff between consistency with math notation and internal consistency across different kinds of functions. Studying the tradeoff between these is on our longer-term todo list (once we have some data on the transfer of concepts in the first place).

      Kathi (Bootstrap team)

      • 3. alanone1  |  December 10, 2013 at 9:24 pm

        See the comments I made on reconciling normal math forms with standard ways to define. (By the way, it is allowable to define new infix forms in standard math, and the students should be given the facilities to do this.)

    • 4. shriramkrishnamurthi  |  December 10, 2013 at 2:05 pm

      alanone1, part of understanding algebra is understanding that there are _many_ representations for functions. One of them is the formula; another is the graph; yet another is the table; and so on. Each has its uses, and each is a different syntax! Students often struggle with switching representations because they are semantically so different, but it’s not something they really have a choice about. So having them switch between different syntaxes actually does them a service.

      Moreover, the pedagogy we use in Bootstrap (called “Circles of Evaluation” — look it up in the materials if you wish) ties amazingly well to parenthetical syntax (circles split open and become parentheses).

      Nevertheless, we have been working on a new language that has traditional infix syntax, and will be plugging it into the Bootstrap curriculum (Pyret — http://pyret.org/). There are many things we’re trying to do with Pyret, but one of them is make the first comment about Bootstrap stop being about syntax. (So, thank you for your comment, because you’re helping me make my case to the others on the Bootstrap team, one of whom is convinced that intelligent readers will look past the syntax instead of commenting on it.)

      • 5. alanone1  |  December 10, 2013 at 9:18 pm

        (I have a degree in pure math) … but I think the conflict in the argument is on the one hand there’s an advocacy for “Algebra I as officially presented” and on the other an advocacy for forms that aren’t as traditionally presented.

        So I think your aim to make a language that looks like the official forms “in the book” is a good idea, given the aims of the project.

        The “book syntax” has operation forms for prefix position (with and without parens), infix, postfix, and what Joe Goguen called “outfix”. One suggestion from the past is just to bold face these, and then there’s no problem having a standard way to define these.

        • 6. shriramkrishnamurthi  |  December 10, 2013 at 9:37 pm

          I don’t think it’s very useful to talk about “Algebra I as officially presented” because there are so many different presentations of it, especially with so many “innovative” math curricula/programs around. So I think we can only speak officially of the body of knowledge, not of its presentation. (Unless by “presentation” you mean the very narrow issue of syntax. For which, even your boldface suggestion is a departure from math textbooks.)

          We have not really _advocated_ for Scheme syntax so much as used it and observed that it even has several advantages. Anecdotally, it has not really been a problem for students, nor even that much for math teachers — and certainly nowhere near as much as it is for commentators about the program.

          Nevertheless, commentators are influential, perhaps even excessively so. Hence the switch to Pyret.

          • 7. alanone1  |  December 10, 2013 at 10:15 pm

            I think the Bootstrap rhetoric needs some work so that the pitch doesn’t distract from the main goals.

            However, I don’t like either the K-12 math curricula or the most standard ways of thinking about programming and computing. Both are enough mired in the past so that considerable relearning is required if a student is to go further.

            For example, as Papert pointed out neither science nor children use preferred coordinate systems, so why lay on the additional difficulties they bring? Instead why not use differential geometry of vectors (Gauss) which is both natural to children and the general way of dealing with directions and magnitudes that science uses?

            (This also makes the mechanics of calculus much easier in many cases.)

            And there’s much more that could be said about why most of the ideas about computing and programming which have been brought forward from the 50s just aren’t a very good way to think about computing in the 21st century.

            But the main point is that there is an opportunity and a need to come up with a better (and combined) conception of math and computing that would be a stronger way to think about representing processes at all levels of scale and type, and also much easier to learn.

          • 8. shriramkrishnamurthi  |  December 10, 2013 at 10:26 pm

            Bootstrap’s programming material looks pretty different from just about any other introductory programming curriculum out there. Inasmuch as it’s “mired”, it’s because its creators are not smart enough to overcome our own sadly blinkered imaginations, which is a difficult problem to solve.

            We’re also trying to create curricula that people will and do use, without compromising our principles. Strong opinions about vector representations just doesn’t happen to be one of them (for now).

            • 9. alanone1  |  December 10, 2013 at 10:44 pm

              This is why Papert and Bruner are two of my heroes — they both realized (and advocated) that we all should try to invent better intellectually honest versions of the subjects we want to teach that more closely fit “where the learners are”, both developmentally and in gained knowledge.

              So what is the next “Compumatical” system that will advance the larger visions?

          • 10. shriramkrishnamurthi  |  December 10, 2013 at 10:54 pm

            Bootstrap is our answer to your question: math and programming in one unified bundle, with each trying to push the other. It may not fit your criteria, but it certainly does ours.

            Unlike an awful lot of other programming curricula, we aren’t just saying “teach Python” or “teach JavaScript” or “teach … technology” (even though — or, just as likely, because — we happen to have considerable expertise in each of those subjects). This confusion between a particular technological vehicle, and a curriculum and universe of ideas, is both profound and widespread in computer science, and partly explains why the subject keeps darting from one fashionable topic to another. Whereas we’ve been doing what we do for about twenty years now (starting with the creation of DrScheme) and expect it’ll take at least as long again to get to some satisfactory point.

          • 12. shriramkrishnamurthi  |  December 10, 2013 at 11:23 pm

            Thanks. I’m familiar with this work and some of its successors, though it’s not particularly to my taste. I’m much more intrigued by the KScript and KSWorld efforts at Viewpoints. (I should declare my bias: KScript is based on a language my team built.)

          • 13. Emmanuel Schanzer  |  December 11, 2013 at 2:42 pm

            I have enormous respect for Papert (and the numerous projects that extend from his work), but one of the sticking points for me as always been the microworld implementation that many of them share. Nearly all of them involve some stateful representation of an actor (a turtle, a cat, a car, etc), with commands being stitched together to modify that state in a meaningful way.

            I think it’s reasonable to wish for a new, pure model while still making adaptations for the imperfection of the present, and I fully grant that a stateful representation is easier for today’s math-challenged students. However, I’ve seen the crutch become a barrier for understanding the “pure math” side of things like functions and variables. Scratch 1.0, for example, requires that all variables be initialized and mutated — making it nearly impossible to introduce the proper algebraic construct. To me, this particular compromise just hasn’t been proven worthwhile.

            Bootstrap takes the opposite approach, enforcing a pure-math behavior for functions and variables. I think Shriram and Kathi have covered our reasons for selecting Scheme’s syntax as a first step here (and the exciting possibilities of Pyret), but I don’t want the notion of mathematical behavior to get lost in the fray.

  • 14. Bonnie  |  December 10, 2013 at 8:40 am

    Variables in a programming language are quite different from the variables used in an algebraic expression. This causes no end of confusion for my CS1 students. Perhaps we computer scientists should be insisting that algebra teachers teach “real variables”, as understood by computer scientists, in algebra :-).

    • 15. alanone1  |  December 10, 2013 at 9:20 am

      Hi Bonnie

      Both sides of the argument seem to be about “we need to teach the way things are now”: (a) we need to teach about how variables and functions work in Algebra I, or (b) we need to teach about how “variables” and “functions” work in “standard programming”.

      I think both (a) and (b) are weak approaches, and that — as educators — we should be thinking about what is best for the learners’ intellectual advancement.

      The Bootstrap approach is aiming at getting children through Algebra I, and into college and into better jobs. The CS approach (generally) has many similarities by aiming at standard programming ideas, most of which have been obsolete or a drag for many decades now. I think a lot of this is also vocationally related (and both perspectives may be “right” from that limited perspective).

      I don’t think either of these goals take in the larger issues of our society and the desperate needs for *real education*.

      (Just to create an alternative example here), a better ploy for both (a) and (b) would be to ask “what could be as helpful as possible for issues small and large here?”

      A personal answer would be that “representing and thinking and reasoning and simulating all kinds of relationships” underlies both mathematics and computing, and understanding and using these ideas better would be good to improve in K-12. Functions are a useful part of relations and it would be nice to have a way to think about them that is both mathematical and computational.

      John McCarthy in the early 60s pointed out that a weakness in both traditional logic and mathematics is the lack of a standard way to handle time (for example, in standard logic if a robot has the property at(Robbie, Philadelphia) it cannot be moved to Trenton).

      However, by adding a parameter for the *time* that a relationship holds (time is now part of the simulation) one creates a logical world of “world-lines” of “snapshots” of that allows perfect reasoning within each snapshot, but which also can compute (without race conditions) the next snapshot.

      This extremely good idea — called “fluents” by McCarthy, and “pseudotime” in other contexts — was quite ignored by mainstream CS (which embraced the much worse idea of “semaphores” to try to deal with race conditions, etc.).

      And there are many other quite bad ideas that are standard practice today, just via history, fads, and the ad hoc nature of our “not really a science yet” field.

      As an educator — post Etoys and Scratch — I think I’d put a lot of effort into trying to come up with a more “reasonable” (in all senses of the term) form of computing that has both pragmatic and mathematical power. This would try to look at all of the last 70 years, today — and most especially at the needed future — without being swayed by fads.

      I believe this can be done with a vehicle that would seem more familiar rather than another stranger thrust onto the scene of an already confused and distracted educational system.



      • 16. Mark Guzdial  |  December 10, 2013 at 11:26 am

        For those searching around on these ideas like me: more on McCarthy’s fluents: http://en.wikipedia.org/wiki/Situation_calculus

        • 17. alanone1  |  December 10, 2013 at 11:58 am

          First written about by McCarthy in “Situations, Actions and Causal Laws” ca 1962 or so.

          The first Simula ca 1965 used “pseudotime” to do scheduling of its processes and had ways to resolve conflicts under program control (one of which was used much later in the Ethernet).

          We used this in the Xerox PARC Smalltalk “Simpula” scheduler.

          Dave Reed used pseudotime in his distributed OS for the Internet (ca 1978).

          Leslie Lamport used the idea in his papers about control and time.

          It was used in Croquet (another massively parallel distributed system — based on Reed’s thesis) in the early 80s.

          But from the standpoint of “orthodox academic and industrial computing” it is very hard to find — partly because of the fad and pop culture nature of the field in those areas, and partly because “thinking and re-thinking” is de-emphasized in favor of following party lines.

          It’s worth pondering just what people propose to teach as “CS” and what narrow kinds of thought and range have gone into many of these decisions (or should I say KOOL-AID?)

          • 18. Mark Guzdial  |  December 10, 2013 at 12:24 pm

            Alan, you just triggered a spark of recognition for me. Is the “Simpula” scheduler the same simulation system described in the Goldberg & Robson “Blue Book” Smalltalk-80: The Language and Its Implementation? Half of my Media Computation data structures class that I teach is informed by that simulation system. Since I used to teach it in Squeak, I was familiar with it, and now use it as a context for teaching data structures. In the MediaComp D/S book that Barb and I wrote, we teach the basic data structures (linked lists, trees, graphs) in the first half of the book (e.g., using scene graphs, trees of sounds, etc.), then we use those data structures to build a Java-version of that simulation system. We spend a good bit of time talking about different random distributions for time. We use events timed with simulation time needing to fit into an ordered event queue to talk about sorting vs. inserting into a sorted list. (Interesting side note: At Georgia Tech, this is a course for non-majors, so our business, architecture, and liberal arts majors learn about building simulations. CS majors don’t necessarily.)

            • 19. alanone1  |  December 10, 2013 at 1:13 pm

              Aimed at Mark: Alan, you just triggered a spark of recognition for me. Is the “Simpula” scheduler the same simulation system described in the Goldberg & Robson “Blue Book” Smalltalk-80: The Language and Its Implementation?

              I had to go to the book to look this up: to see if the “Simpula” idea first used in Smalltalk-72 was carried through to the Smalltalk-80 system. Simple answer is “not really”.

              The basic approaches to simulation in all of the Smalltalk systems were adaptations of the “discrete-event” ideas from the first Simula. In this sense they are all similar.

              With “Simpula” we wanted a scheme that would allow the whole range of these typical simulations to be handled by a scheduler that a child could write. (The half-page code for this is in the “Smalltalk-72 Instruction Manual”).

              The key to this scheduler was to abandon co-routining for “phases” in which an object was scheduled in pseudotime with the message to be sent to it when it was awakened.

              The one in the Blue Book is much more comprehensive and complicated in its presentation of a form — pretty much a DSL or “kit” — within which to create simulations, particularly of the job-shop type. It also uses a more complex notion of suspension (I don’t like it) that does not use pseudotime to resolve (even though the scheduler is in terms of pseudotime). I was out of PARC by then, and would have argued for a different approach if I had been there.

      • 20. shriramkrishnamurthi  |  December 10, 2013 at 1:56 pm

        alanone1, Bootstrap is just the first step in a much bigger program of education.

        Bootstrap actually does cover temporal systems, through a notion of pseudotime. A Bootstrap student is actually writing difference equations to model their physical system, something that I think we can all agree is a perfectly honorable, principled way to think about system modeling that has little to do with the here and now. This isn’t in the article but it’s very much the heart of the curriculum.

        My dream with Bootstrap is to eventually build it up to the point where we can actually teach students calculus, and hence temporal systems (whether programming or mathematical). The one thing Bootstrap takes very seriously is that the functions that represent the difference equations actually be _functions_, in the mathematical sense (ergo the insistence on the terminology of variables) — so the same programs are temporal systems in both the mathematical and programmatic sense. This interdependency is what is lost by Bonnie’s (humorous) suggestion to have the algebra folks “fix” their variables.

    • 21. shriramkrishnamurthi  |  December 10, 2013 at 1:50 pm

      Hi Bonnie — speak for yourself (-:.

      There is no one meaning of “variable” in computer science. If you’re a Java programmer, you mean the “broken variables” notion of variable (aka, what you call “real variables”). If you’re a Haskell or ML or Erlang or … programmer, you mean the algebra notion of variable, and there is no longer any disagreement.

      Therefore, the confusion is entirely on the side of computer science, not of algebra. Unless what you want is to make algebra as confused as programming!

  • 22. alanone1  |  December 10, 2013 at 10:50 am

    Another thought from the past …

    One of the hot topics of discussion in the early LOGO days was whether a good way to match up the old and the new would be for children to learn about arithmetic and algebra — and give themselves a big reward — by making their own programs to do the manipulations.

    So, you learn arithmetic partially by writing programs to do the algorithms (and presumably really now understand the algorithms much better thereby).

    Similarly, you learn algebra partly by writing (and presumably understanding) expression interpreters and simplifiers).

    I bought into this more back then than now, but still think it could be a key part of the many ways one needs to learn mathematics and programming.

    One of the big barriers back then (and now) is that even Lisp and the Lispish LOGO were not well set up for children’s (or beginners’) programs for these tasks.

    This again brings home how paltry and lacking in expression virtually all of the standard programming languages are — and why something much better should be designed to aid learning (and also just do more programming that can be expressed in clearer more understandable ways).

    In some ways, some of the older SNOBOLs were better set up for many of these needs …..

    Making progress in this area would also force some new thinking into other parts of the subject — such as systems design, and what does problem solving now mean?

    • 23. Emmanuel Schanzer  |  December 11, 2013 at 3:04 pm

      “…even Lisp and the Lispish LOGO were not well set up for children’s (or beginners’) programs for these tasks..”

      While I agree that the languages could be improved for use by children (see my previous comment), I think a hallmark of the tech-ed movement has been that it’s a movement *toolbuilders*. There’s no shortage of fascinating tools (ToonTalk, Boxer, etc), but I would argue that the primary bottleneck lies not in the tools or languages, but in the lack of curricula and pedagogy that often accompanies them. I’m looking for not just the new language, but the new curriculum and pedagogy that accompanies it. Here’s hoping that those with the expertise and insight will blow us away with all three!

  • […] love that Bootstrap is building on their great success with algebra to integrate CS into Physics and Social Studies. I’m so looking forward to hearing how this […]

  • […] getting there. The proposals I’m submitting these days are about doing work that looks like Bootstrap. I’d like to do more in applying computing (specifically, programming) as a notation and tool […]


Leave a Reply

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

WordPress.com Logo

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

Google photo

You are commenting using your Google 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 )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Trackback this post  |  Subscribe to the comments via RSS Feed

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

Join 9,026 other followers


Recent Posts

Blog Stats

  • 1,986,881 hits
December 2013

CS Teaching Tips

%d bloggers like this: