Sub Ubi

What would happen if you had to conceive of a CS1 curriculum that was language agnostic?

I was reflecting on Papert and Turkle’s

Epistemological Pluralism, a paper I read

some years ago and reread recently. I found myself writing the following:

These students wanted to learn differently. However, the knowledge and experience they brought to their first experience in programming was disrespected and disregarded.

Perhaps strong, but not untrue of many things in the CS1 experience—we do not

allow for the individual. We expect rigid commenting styles, particular solutions,

and even impose problem solving methods on them, because “it’s better this

way, really–trust us.”

Perhaps unrelated completely, but what happens if you eliminate the requirement

of working in a particular language from the CS1 curriculum? What if students

could work in any one of four languages in their first course, choosing from

(say) Java, Smalltalk, Scheme, and C? What would change? What would break?

What would be new and different? How would you evaluate success? Why is this

any different than what happens around the world every fall anyway (many classes

with many students learning many languages)?

Just a “what if” kind of question. However, it is something that may jar us out of some

complacency we have in our conceptualization of what a first course in

computing is or should be.

I’m going to be even more infrequent during the next two months, as we leave Indiana

next Friday (the 2ndish) and will leave country the 26th of August. Between those

two dates, I’m all over the place.

The topic for discussion is, I think, how we can get CS-ED moving more. On one front,

providing a tool that aids more free-form discussion would be good

(I’ve been meaning to do this for a while, and would like to do that before

I leave the fast, local connection). However, there seem to be a few other points

that can be made:

• Most of our writing (Pete and I) has been “Hey, I did this” kinds of stuff. There is no

  real room for discussion when someone writes that way. Lisa commented on this

  at some point.

• We don’t have a critical mass.

That is all my tired brain can come up with right now, but they seem to be two

large factors. The former is able to be overcome, but requires us starting to

dig more into the why and how (theory and methodology)

of our work, online. This takes time, and the assumption is that it is profitable

for us to do so.

The second requires us to launch this thing and go live. Now, before the semester starts

in ernest, might be a good time to do it. Without more bodies,

this is going to come close to a failed experiment, when there isn’t a good

reason for it. I think this is a good idea, and I think the tool is suitable for the

journal/targeted discussion/dissemination of ideas. A general discussion tool

would help, as would some more docs re: things like on-line resources, etc.

Thoughts?

We have success!

I’ve been mentoring a high school student this summer; he developed a small language for representing state machines, and then laid out how we would transform this language into Scheme. We wrote a small transformer pass that sits at the front of the compiler, and his little language can drive the Mindstorm. Quite cool.

After pulling an all-nighter last night (well, I slept for an hour), I managed to overcome some of the big challenges remaining. For example, we couldn’t exit from a running Forth session (problem), and also couldn’t handle input from the buttons (like ON/OFF), and couldn’t interact with the sensors or the display. These seem like big problems, but they are secondary to the problem of compiling Scheme to Forth…

The state machine code

(starts-with on-line)
    (state on-line
           (do (begin
                 (display (get-light-value ‘PORT2))
                 (go-forward ‘A)
                 (go-forward ‘C))
             (then-look-for
              [( 39 (get-light-value 'PORT2)) (then on-line)])))

expands into Scheme

(define *state* ‘on-line)
(define (on-line-proc)
  (set! *state* ‘on-line)
  (begin 
    (display (get-light-value ‘PORT2)) 
    (go-forward ‘A) 
    (go-forward ‘C)))
(define (off-line-proc)
  (set! *state* ‘off-line)
  (begin (display (get-light-value ‘PORT2)) (stop ‘A)))
(define (infinite-loop)
  (cond
    ((power-button-held?) (exit))
    ((and ( 39 (get-light-value ‘PORT2)) 
          (eq? *state* ‘off-line)) (on-line-proc)))
  (infinite-loop))
(on-line-proc)
(infinite-loop)

which then expands into 750 lines of Forth. All of it highly unreadable.

However, what is amazing is that the stuff works. After working out small kinks (for example, Forth lacks the >= comparison operator; so, when I assumed it did, it produced code that … worked? … but really didn’t. This accounted for a few hours of bug chasing, I think…). I think it’s done to the point that we can release it onto the world and call it an Alpha version of the Scorth compiler.

I’m so tired…