A little lesson

Actually, two.

What I’ve been doing, in English

First, a bit about what I’ve been working on: trees. No, I haven’t become an arborist, but I have become interested in determining how different two programs are. One way to get at this is to look at the source code for the program, and treat it as a string. . . . → Read More: A little lesson

Vanna, the pseudocode, if you please…

I hate it when you spend half a day trying to get something to compile, only to have it “magically” work when you show it to someone else.

To finish off the technical report I’m writing, I really wanted to be able to download a running version of a tree-edit algorithm, and use that in my prototyping. . . . → Read More: Vanna, the pseudocode, if you please…

Suggestions away!

I’ve been working on a (paid) side project for a while, and it was nice to bring a bit of closure to it today.

Now, back to the things that seem to have no closure.

Like my stomach. It’s time to go home . . . → Read More: Suggestions away!

Making transcription easier

I’ve been “distracted” from transcription for a week now by questions surrounding analysis of code between compiles. I don’t think this was a bad distraction, but I need to keep transcribing.

Right now, my data is on Minidisc. This is OK, except it makes it a real pain to do transcription–the MD player I have (an MZ-R700) . . . → Read More: Making transcription easier

NetLOGO

NetLOGO looks to be related to (or the evolution of) StarLOGO. Both are environments for exploring massively parallel, agent-based simulations in LOGO.

I especially like the HubNet feature; many users can participate in a simulation, playing the roles of agents in the system. The example they give is of students controlling traffic lights in a traffic simulation. . . . → Read More: NetLOGO

Scheme->Dot

Not actually a big deal (any Scheme programmer could hack one out), but after finally deciding on what the backend should be, I have a Scheme to Dot translator.

This makes looking at the effects on the parse tree of small (and large) changes in the source code . . . → Read More: Scheme->Dot

Ah. Humor.

The Tau of Programming.

This is . . . → Read More: Ah. Humor.

Graphs Contd.

Consider the program

(define fact
(lambda (n)
(if (zero? n)
(1)
(* n (fact (sub1 n))))))

which has an obvious error (extra parens around the ’1′). How much difference is there between this program and this one?

(define fact
(lambda (n)
. . . → Read More: Graphs Contd.

Code Deltas

We’ve been discussing the nature of student interactions with the compiler. In particular, we know (informally) there are different types of students; we’ve seen them at work (or hacking), and they behave differently. Can we classify this behavior; that is, can we use the student’s pattern of interaction with the compiler as a predictor or a . . . → Read More: Code Deltas

The Rights of the Many

Tim Mullen penned a guest article for The Register a few days back. He’s writing about software that would enable the killing of rogue processes on other people’s machines.

For example, my machine is infected by a worm. The idea is that someone else can, remotely, kill the rogue process without my knowledge or direct participation. This, . . . → Read More: The Rights of the Many