Coding for the Classroom with Meteor Series: ImageShare

When I visited Meteor headquarters for their monthly DevShop, I gave a lightning talk on my use of the Meteor framework for developing tools that helped me do my job as a teacher. Both during and after my talk, I was asked how I thought I could help other teachers learn to do what I had done. I pledged at the time that it was my goal to make some videos and tutorials about how to use it for classroom specific applications. Since then, I’ve had some ideas for what I might do.

When I asked idea-man Dan Meyer what he thought the first project should be, the response came back surprisingly quick:

As usual, Dan’s expectations were high. I was waiting for Meteor to release its 1.0 version before getting started, so when that happened this week, I hit the books interwebs hard to figure out how to make the response viewer a reality with Meteor.

Thankfully, it actually came together quite quickly. This is an amazing testament to the power that the Meteor framework has for minimizing the idea-to-app lifecycle, and making it easy to get these tools in the hands of teachers.

You can check out my 26 minute tutorial video below. I made it almost real-time (minus some edited video flubs) to show how quick it is to get started.

I have also included the files that I made in the tutorial on Github here:
https://github.com/emwdx/image-share

Take a look and let me know what you think. I would like to do others if there are requests for teaching-related apps out there. Keep me posted on what you would like to see.

Computational Thinking in Teaching and Learning (Re-post)

A modified version of this post appeared on the Techsmith Blog here and in their quarterly newsletter, the Learning lounge. I appreciate their interest in my perspective. I hope to continue this important discussion here with my readers.

The idea of computational thinking has radically changed my approach to teaching over the past few years. This term, first coined by Jeanette Wing, a professor of computer science at Carnegie Mellon University, refers to several key ideas of thinking that are essential to computer science. The paper clearly identifies the reality that there are some tasks that computers do extremely well, and others that are better suited to the human brain. Traditionally, computer scientists have worked to outsource the calculating, organizing, searching, and processing work for task X to a computer so that they can focus on the more complex, challenging, and engaging aspects of the same task. According to Wing, one of the most essential skills we should develop in students is sorting tasks into these two groups.

My classroom, at its best, is a place where maximum time is spent with students wrestling with an engaging task. They should be working together to develop both intuition and understanding for required content. I can read the smiles or frowns and know whether I should step in. I can use my skills to nudge students in the right direction when I think they need it. Knowing precisely when they need it can’t easily be determined by an algorithm. For some students, this moment comes early on after encountering a new concept. Others require just one more minute of struggle before the idea clicks and it’s in their brains for good. Knowing the difference comes from the very human experience of time in classrooms with learners.

This is the human side of teaching. It is easy to imitate and approximate using technology, but difficult to produce authentically. Ideally, we want to maximize these personal opportunities for learning, and minimize the obstacles. For me, the computer has been essential to doing both, specifically, identifying the characteristics of tasks that a computer does better. If a computer can perform a task better than me or my students alone, I’m willing to explore that potential.

The most consistent application of this principle has been in the reduction of what I call ‘dead time’. I used to define this as time spent on tasks required for learning to be possible, but not actually a learning task itself. Displaying information on the board, collecting student answers, figuring out maximum and minimum guesses for an estimation problem – these take time. These sorts of tasks – displaying, collecting, processing – also happen to be the sort at which computers excel. I wrote a small web application that runs from my classroom computer that allows students to snap a picture of their work and upload it to my computer, anonymously if they choose. We can then browse student answers as a class and have discussions about what we see. The end result is equivalent to the idea of students writing their work on the board. The increased efficiency of sharing this work, archiving it, and freeing up class time to build richer activities on top of it makes it that much more valuable to let the computer step in.

I’ve also dabbled in making videos of direct instruction, but I have students watch and interact with them while they are in the classroom. During whole class instruction, I can’t really keep track of what each student is and isn’t writing down because I am typically in a static location in the classroom. With videos simultaneously going throughout the classroom, I can see what students write down, or what they might be breezing through too quickly. I get a much better sense of what students are not understanding because I can read their faces. I can ask individualized questions of students to assess comprehension. The computer distributes and displays what I’ve put together or curated for my students – one of its strengths. My own processing power and observation skills are free to scan the room and figure out what the next step should be.

Letting the computer manage calculation (another of its strengths) enables students to focus on the significance of calculations, not the details of the calculations themselves. This means that students can truly explore and gain intuition on a concept through use of software such as Geogebra or a spreadsheet before they are required to manage the calculations themselves. For students that struggle with arithmetic operations, this enables them to still make observations of mathematical objects, and observe how one quantity affects another. This involvement has the potential to inspire these same students to then make the connections that underlie their skill deficiencies.

Full disclosure though: I don’t have a 100% success rate in doing this correctly. I’ve invested time in programming applications that required much more effort than an analog solution. For instance, I spent a week writing all of my class handouts in HTML because the web browser seemed like a solution that was more platform independent than a PDF. That ended when I realized the technology was getting in the way of my students making notes on paper, a process I respect for its role in helping students make their own learning tools. There are some tasks that work much more smoothly (or are just more fun) using paper and a marker.

I value my student’s time. I value their thoughts. I want to spend as much class time as is possible building a community that values them as well. Where technology gets in the way of this, or adds too much friction to the process, I set it aside. I sit with students and tell stories. I push them to see how unique it is to be in a room for no other reason but to learn from each other. When I can write a program to randomize groups or roll a pair of dice a thousand times to prove a point about probability, I do so.

Knowing which choice is better is the one I wish I could write an algorithm to solve. That would take a lot of the fun out of figuring it out for myself.

Sensors First – Progress Report

I wrote previously about my plans to change how I teach programming to my LEGO robotics students. By including sensor use as a starting point, my hope is to equip students with the experience to know when sensors can do a better job than simply aiming the robot toward the target and hoping for the best.

IMG_0071-0.JPG
Yesterday was my first open ended challenge after beginning this approach. Students needed to build and program their robots to retrieve the loops located at the ends of the black line paths. The time available for them to do so was kept short. As one more way to advantage sensors over a trial and error approach, I told them that I might tell them to start their robot anywhere along the line, and that they could only pick up their robot once while retrieving the two loops.

I really didn’t need that final requirement. Students quickly figured out how to adapt the line following tricks I taught them to this task. In a forty minute period, all of the teams made progress and were able to make contact with the loop using a collection mechanism.

The most satisfying result? Not a single group spent significant time aiming their robot. They clearly didn’t feel the need, which is a step in the right direction.

IMG_0073-1.JPG

Standards Based Grading(SBG) and The SUMPRODUCT Command

I could be very late to the party finding this out. If so, excuse my excitement.

I gave a multiple choice test for my IB Physics course last week. Since I am using standards based grading (SBG), I wanted a quick way to see how students did on each standard. I made a manually coded spreadsheet eight years or so ago to do this. It involved multiple columns comparing answers, multiple logical expressions, and then a final column that could be tallied for one standard. Multiply that by the total number of standards…you get the drill.

I was about to start piecing together an updated one together using that same exhausting methodology when I asked myself that same question that always gets me going: is there a better way?

Of course there is. There pretty much always is, folks.

For those of you that don’t know, the SUMPRODUCT command in Excel does exactly what I was looking for here. It allows you to add together quantities in one range that match a set of criteria in another. Check out the example below:

Screen Shot 2014-10-14 at 3.28.09 PM

The column labeled ‘Response Code’ contains the formula ‘=1*(B6=E6)’, which tests to see if the answer is correct. I wanted to add together the cells in F6 to F25 that were correct (Response Code = 1) and had the same standard as the cell in H6. The command in cell I6 is ‘=SUMPRODUCT((F6:F25)*(E6:E25=H6))’. This command is equivalent to the sum F6*(E6=H6) + F7*(E7=H6)+F8*(E8=H6)+…and so on.

If I had known about this before, I would’ve been doing this in some way for all of my classes in some way since moving to standards based grading. I’ve evaluated students for SBG after unit exams in the past by looking at a student’s paper, and then one-by-one looking at questions related to each standard and evaluating them. The problem has been in communicating my rationale to students.

This doesn’t solve the problem for the really great problems that are combinations of different standards, but for students that need a bit more to go on, I think this is a nice tool that (now) doesn’t require much clerical work on my part. I gave a print out of this page (with column F hidden) to each student today.

Here is a sample spreadsheet with the formulas all built in so you can see how it works. Let me know what you think.
Exam Results Calculator

Graduated Assessment & Web Design

I decided to try teaching programming this year as a class, specifically HTML, CSS, and Javascript. My hope is to get students to the point that they can put together a basic Meteor app by the end of the year, along with a good set of skills for building web pages from scratch.

My assessment scheme for the class is through a series of projects. Some are small, some are bigger and more open ended. I noticed during class on Tuesday that students are cutting corners by copying HTML from files we used in earlier classes. I admittedly do this all the time, but I pay the price for doing so in time spent cleaning up fragments of code that I really could have written from scratch in less time. In the general series of trying to teach good habits, I decided to give a graduated assignment that went through the series of HTML concepts we have learned over the past two weeks.

The requirement is that students need to make one HTML file for each of the ten steps in this file. They have to start from a blank HTML template that has nothing more than the basic head and body elements. I also had students write out the code for the first three steps by hand.

Screen Shot 2014-08-28 at 7.44.02 PM

The effect today in class was a clear measurement of where each student stands in understanding how to piece together HTML from scratch. I collected the folders of files from students at the end of class and can see precisely where their difficulties are. Some of this comes from just knowing what step they were on at the end of class, but I also had some good conversations with students throughout the period today. My class, thankfully, was pretty honest in showing what they do and don’t understand how to do. While there has been some code sharing in the class before, they seemed to appreciate this opportunity to step their way through the progression of what we’ve learned so far.

I think there’s an analogue in math and science here – I’ve given leveled practice sheets before in various mathematics topics. The willingness to push through misunderstanding and admit difficulties seems to be a lot more substantial in a programming context.

Here’s the full exercise:
day5-Step Instructions

Curated review for finals

I really don’t like reviewing for exams. I don’t think I’m the only one that thinks this, by far.

If I create a the review sheet, I’m the one going through all of the content of the unit and identifying what might be important. It would be much more valuable to have students do this. I’ve also been filling the school server with notes and handouts of what we do each day, so they could be the ones deciding which problems are representative of the unit.

Suppose I do make a new set of review problems available to students. If students have this set of problems to work through during class, I spend my time circulating and answering questions and giving feedback, which is the best use of my time with students. Better yet, students answer each other questions, and give each other feedback. They lose the opportunity to see the scope of the entire semester themselves because, outside of the set of problems I prepare for them, they don’t actually take the time to see that scope on their own. They only see my curated sample and interpret it according to their own understanding of the relationship between review problems I select and problems I select for an exam.

I’ve had students themselves create review sheets, but this always has its own set of issues. Is it on paper or online? If on paper, how does this sheet efficiently get shared with other students? The benefit of an online resource is the ease of sharing. The difficulty comes from (1) the difficulty of communicating mathematics on a computer and (2) compiling that resource in one place. It’s a lot of work to scan student work and paste it into a document. Unless I am meticulous in making sure that all students are using the same program (which is a lot of work for a class of twenty-four students all with their own laptops) this becomes a lot of work (again) for me. I’ll do it if I really believe it is worth the effort for students, but I’m always looking to be efficient in that effort. I also don’t want to put this effort on the shoulders of a student to together. And before someone tells me to use Google Docs and its amazing collaborative tools, I’ll bring up the governmental disruption of Google services and leave it to you to figure out why that isn’t an option for me and my students.

In the end, I have to decide which is the most valuable for students relative to a review. Is it getting feedback on what a student does and does not understand? Is it going back over the entire semester’s material and figuring out what is important relative to a cumulative final?

If I have to pick a theme of my online experiments this year, it has been the search for effective ways to leverage social pressure and student use of technology to improve the quality of the time we spend in the classroom together. In the past, I have been the one collecting student work and putting it in one place when I’ve tried doing things differently for exam review. That organization is precisely something computers do well if we design a scheme for them to use.

Here’s what I have had students do this year:
Screen Shot 2014-06-10 at 4.35.37 PM

Each student has a blog where they post their own review sheet for one standard. They submit the URL of their post and their standard number through the same site through which they sign up for SBG reassessments. They see a list of the pages submitted by other students:
Screen Shot 2014-06-10 at 1.09.08 PM

This serves as a central portal through which students can access each other’s pages. Each student controls their own page and URL information, which saves me the effort to collect it all.

Why am I really excited about this list?

  • I curate the list. I decide whether a page has met the requirements of the assignment, and students can see those pages with a checkmark and a WB for my initials. If a student needs to improve something, I can tell them specifically what isn’t meeting the requirements and help them fix it. Everyone doesn’t have to wait for everyone else to be finished for the review process to begin. I don’t decide what goes into each page generally, but I do help students decide what should be there. Beyond that, I don’t have to do any compilation myself.
  • Students (ideally) vote on a page if they think it meets the requirements. Students can each vote once for each page, and see a checkmark once they have voted. This gets them thinking about the quality of what they see in the work of other students. I have been largely impressed with what students have put together for this project, and students are being fairly generous with this. I’m ok with that at this point because of the next point:
  • Students have an incentive to actually visit each other’s pages. I have no idea how many students actually use the review sheets we’ve produced together in the past. I doubt it is very many. There’s some aspect of game theory involved here, but if a student sees that others are visiting his or her own pages, that student might feel more compelled to visit the pages of other students. Everyone benefits from seeing what everyone else is doing. If some review happens as a result, that’s a major bonus. They love seeing the numbers adjust real time as votes come in. There is a requirement that each vote include a code that is embedded in the post they are voting for, just so someone isn’t voting for them all without visiting the page.
  • Students were actually using the pages to review today. Students were answering each other’s questions and getting feedback sometimes from the authors themselves.
  • I get to have valuable conversations about citing resources online.

Right now, students can vote as much as they want, but I plan to introduce one more voting option before this is entirely done which allows students to vote on their top three favorites in terms of usefulness. I am not sure how I would do this without it turning into a popularity contest, but I might try it and see how their sense of quality relates to mine. I would also love to use this next year as a Reddit style resource where students are posting problems and solutions potentially for specific standards and can vote on what is particularly helpful to them. Again, just an experiment.

I really loved how engaged students were today in either developing their pages or working on each other’s review problems. It was one of the most productive review days I’ve had, particularly in light of the fact that I didn’t have to write a single problem of my own. I did have to write the code, of course, but that was a lot more interesting to me today than thinking of interesting assessment items that I’d rather just put on an exam.

Testing probability theories with students

One of the things that has excited me after building computational tools for my students is using those tools to facilitate play. I really enjoyed, for example, doing Dan Meyer’s money duck lesson with my 10th grade students as the opener for the probability unit. My experiences doing it weren’t substantially different that what others have written about it, so I won’t comment too much on that here.

The big thing that hampered the hook of the lesson (which motivated the need for knowing how to calculate expected value) was that about a third of the class took AP statistics this year, so they already knew how to do this. This knowledge spread quickly as the students taught the rest how to do it. It was a beautiful thing to watch.

I modified the sequel. I’ll explain, but first some back story.

My students have been using a tool I created for them to sign up for reassessments. Since they are all logged in there, I can also use those unique logins to track pretty much anything else I am interested in doing with them.

After learning a bit about crypto currency a couple of months ago, I found myself on this site related to gambling Doge coins. Doge coins is a virtual currency that isn’t in the news as much as Bitcoin and seems to have a more wholesome usage pattern since inception. What is interesting to me is not making money this way through speculation – that’s the unfortunate downside of any attempt to develop virtual currency. What I’ve been amazed by is the multitude of sites dedicated to gambling this virtual currency away. People have fun getting this currency and playing with it. You can get Dogecoins for free from different online faucets that will just give them away, and then gamble them to try to get more.

Long story short, I created my own currency called WeinbergCash. I gave all of my students $100 of WeinbergCash (after making clear written and verbal disclaimers that there is no real world value to this currency). More on this later.

After the Money Duck lesson, I gave my students the following options with which to manage their new fortune in WeinbergCash:

Screen Shot 2014-05-21 at 5.17.26 PM

Then I waited.

After more than 3,000 clicks later, I had quite a bit of data to play with. I can see which wagers individual students are making. I can track the rise and fall of a user’s balance over time. More importantly, I can notice the fact that just over 50% of the students are choosing the 4x option, 30% chose 2x, and the remaining 20% chose 3x. Is this related to knowledge about expected value? I haven’t looked into it yet, but it’s there. To foster discussion today, I threw up a sample of WeinbergCash balance graphs like this:

Screen Shot 2014-05-21 at 5.24.49 PM

Clearly most people are converging to the same result over time.

My interests in continuing this experiment are buzzing with two separate questions:

  • To what extent are students actually using expected value to play this game intelligently? If you make the calculations yourself, you might have an answer to this question. I haven’t parsed the data yet to see the relationship between balances and grade level, but I will say that most students are closer to zero than they are their starting balance. How do I best use this to discuss probability, uncertainty, predictions, volatility?
  • To what extent do students assign value to this currency? I briefly posted a realtime list of WeinbergCash totals in the classroom when I first showed them this activity. Students saw this and scrambled to click their little hearts away hoping to see their ranking rise (though it usually did the opposite). Does one student see value in this number merely because it reflects their performance relative to others? Is it merely having something (even though it is value-less by definition) and wanting more of it, knowing that such a possibility is potentially a click away?

I had a few students ask this afternoon if I could give them more so they could continue to play. One proposed that I give them an allowance every week or every day. Another said there should be a way to trade reassessment credits for WeinbergCash (which I will never do, by the way). Clearly they have fun doing this. The perplexing parts of this for me is first, why, and second, how do I use this to push students toward mastery of learning objectives?

I keep the real-time list open during the day, so if students are doing it during any of their academic classes, I just deactivate them from the gambling system. For me, it was more of an experiment and a way to gather data. I’d like to use this data as a way to teach students some basic database queries for the purposes of calculating experimental probability and statistics about people’s tendencies here. I think the potential for using this to generate conversation starters is pretty high, and definitely underutilized at this point. It might require a summer away from teaching duties to think about using this potential for good.

Reassessment Web-App Update

I wrote last May about the difficulties I was having with doing reassessments efficiently. The short story – collecting reassessment requests, printing them, and distributing them to students was not scaling well. I had shared my progress on making a web application using Python to do this and was really excited to continue working on it.

After a summer of work and putting it into action this fall, Phases 1 and 2 are pretty much complete. I’m really happy with how it has been working for me. I host it on my personal laptop in the classroom and share its IP address with students so they can access their quizzes.


You can check out a mildly sandboxed version here:
http://quiz.evanweinberg.org/main/

UPDATE Mar. 2016: I’ve taken down the application to save memory on my hosting server. Write me if you are interested in learning more.

and the code is posted at Github:
https://github.com/emwdx/reassess

I took out a number of my questions (since students do occasionally read my blog) and made it so images can’t be uploaded. I hear that might be a security risk.

Some highlights:

  • Questions (with or without images) can be added, edited, and browsed all through a web interface.
  • Students can be assigned quizzes individually or through a page for the class they are in. They can also all be given different questions, which helps in my class that has students fairly close together.
  • Students each have their own url that can be bookmarked for easy access later.
  • The teacher view of the entire class has a link for each student that shows the quiz questions (and answers, if they are in the database) for easy grading.

What hasn’t been done:

  • Authentication for students and the admin side. Right now it’s all open, which bothers me a little, but my access log doesn’t show that this is being abused.
  • A way to capture their work digitally for each retake. I still have a pile of half-size A4 papers on my desk, and have to grade them while also having the answer page open. That isn’t the end of the world, but after my recent obsession with collecting as much student work as I can through a web interface, it’s something I’d like to have as an option. Students tend to lose these papers, and these are the formative assessment moments I’d love for them to include in their portfolios. Digital is clearly the way to go.
  • Randomization (phase 3 of my master plan), but in two different ways. I’m still manually choosing questions for students. I kind of want to keep it that way, since some students I do want to give different questions. But then I sometimes don’t – I’d rather it just choose questions from specific standards and students get the luck of the draw. I need an option that lets me waffle on this.
  • Question history – i.e. knowing which questions a student has been assigned, and integrating this into the program smoothly. This function is built into the database already, and won’t require a lot of work to make it happen, but I haven’t done it. Sorry.

There are a number of bugs features that still need to be worked out, but I’m aware of them all and know how to work through them when I have a bunch of students taking quizzes.

The most powerful aspect of having this working is that I can easily assess the whole class at the whole time on different questions if I want them to be different. I’ve been doing this at the beginning of the class this semester, and it increases the amount of time I spend talking to each student about their work regularly. Since student initiated reassessment still isn’t as widespread as I want it to be, I’ve started having students request which quiz they want to have in class the night before. They know it’s coming, and can get help or prepare in advance, rather than using their valuable lunch or after school time. More on that later.

Let me know if you’re interested in using this with your own class – it’s pretty portable and can be adapted without too much of a headache to different situations.

Programming and Making Use of Structure in Math

A tweet from James Tanton caught my eye last night:

Frequent readers likely know about my obsession with playing around the borders of computational thinking and mathematical reasoning. This question from James has some richness that I think brings out the strengths of considering both approaches quite nicely. For one of the few times I can remember since starting my teaching career, I went to a computational solution before analyzing it analytically.

A computational approach is pretty simple. In Python:


sum = 0
for i in range(1,11):
for j in range(1,11):
sum += i*j
print(sum)

…and in Javascript:

sum = 0
for(i=1;i<=10;i++) { for(j = 1;j<=10;j++) { sum+=i*j } } console.log(sum)

The basic idea is the same in both languages. We iterate over each number in the first row and column of the multiplication table and add them up. From a first look, one could call this a brute force way to a solution, and therefore not elegant from a mathematical standpoint.

Taking this approach does, however, reveal some of the underlying mathematical structure that is needed to resolve this using other techniques. The sequence below is exactly how I analyzed the problem once I had written the program to solve it:

  • For a single row of the table, we are adding together the elements of that row. Instead of adding the individual elements together one by one, we could instead think about finding the sum of the elements of a single row, and then add together all of the rows. For example: \(1 + 2 + 3 + ... + 10 = 55\). This is a simple arithmetic series.
  • Each row is the same as the row before it, aside from each element being multiplied by the first element in the row. Every row's sum therefore is being multiplied by the numbers in the first column of the table. \(1(1+2+3...+10)+2(1+2+3...+10)+3(1+2+3+...+10)+...+10(1+2+3+...+10)\).
  • Taking this one step further, this is equivalent to the sum of that first row multiplying the sum of the first column: \((1 + 2 + 3 + ... + 10)(1 + 2 + 3 + ... + 10)\). In other words, the answer to our problem is really the square of the sum of that first row (or column), or 55*55.

I bring up this problem because I think it suggests a useful connection between a practical method of solving a problem, and what we often expect in the world of classroom mathematics. This is clearly a great application of concepts behind a traditional presentation of arithmetic series, and a teacher might give this as part of such a unit to see if students are able to see the structure of the arithmetic series formulas within it.

My question is what a teacher does if he or she presents this problem and the students don't make that connection. Is the next step a whole class discussion about how to proceed? Is it a leading question asking how arithmetic series applies here? This, by the way, zaps the whole point of the activity if the goal was to see if students see that underlying structure based on what they already know. Once this happens, it becomes yet another 'example' presented to the class.

I wonder what happens if a computer/spreadsheet solution is consistently recognized throughout the class as a viable tool to investigate problems like this. A computer solution is really nothing more than an abstraction of the process of adding the numbers together one by one. If a student did actually do this by hand, we'd groan and ask if they thought there was a better way, and the response inevitably is 'yes, but I don't know a better way'. In the way I found myself thinking about this problem last night, I started from the computational method, discovered the structure from those computations, and then found a path toward a more elegant solution using algebraic techniques.

In other words, I made use of the structure of my program to identify an analytical approach. Contrast this with a more traditional approach where we start with an abstract definition of an arithmetic series (by hand), do practice problems (by hand) and once we understand how it works, use computational shortcuts.

The consistent power that I see in approaching and developing ideas with students from a computational standpoint first is not that it often makes it easier to find an answer, though that can be a good thing when the goal is to find an answer. Computational methods can make it easy to change things around and generalize a problem - what Polya termed generalization. It's easy to change the Javascript program to this and ask what multiplication table it models:


sum = 0
for(i=5;i<=10;i++) { for(j = 5;j<=10;j++) { sum+=i*j } } console.log(sum)

Computation makes the process of finding a more elegant way seems much more natural - in the best situations, it builds intellectual need for an easier way. It is arbitrary to say that a student should be able to do a problem without a calculator. Computational tools demand that we find a more compelling reason to solve problems by hand if computers are able to do them rapidly once they are set up to solve them through programming. It is a realistic motivation to show that an easier way speeds up finding a solution to a problem by a factor of 10. It means less waiting for a web page to load or an image to post.

The language of mathematics is difficult enough to throw in the additional complications of computer language syntax. I fully acknowledge that this is a hurdle. I also think, however, that this syntax is more closely related to the concepts that we are trying to teach our students (3*x is three times x) than we sometimes think. The power of computer programming to be a bridge between the hand calculations that our students do and the abstractions of the mathematical content we teach is too great to ignore.