I think this would be awesome if I’m able to do it effectively, but requires a few skills in place

• Jython
• Java Applets implemented in Jython
• Swing programming in Jython

Now, Crunchy already can turn webpages of documentation into interactive tutorials using the python prompt. This would be different, introducing programming concepts (using spaced repetition and other strategies) and python would be an implementation language and introduced later on in the lessons.

One issue is whether I should focus on something else, like a algebra ITS first. I’m not really sure, and will have to do some more investigation into the background really necessary for algebra…Perhaps a ITS to teach linear algebra would be better?

I’ve already done some investigation of LaTeX equation rendering in Java and javascript, so it does have potential.

IE 6 is pure hate. IE7.js and IE7.js are life savers, they add the required features to make full (or almost full) CSS usable with IE 6.

It’s easier to start with a blank slate and grab things from the current web page then shoe-horn the current page into YUI CSS.

Javascript based corner rounding is awesome if you’re lazy.

Upgrading a website in stages is the only sane way to do it.

Spam — disliking non dictionary words. Would it be effective to add information a Bayesian spam filter on whether a word is in the dictionary to determine spamminess?

One difficulty would be figuring out how to do this for more procedurally material and the relationships between topics, not just hierarchal categories or information about what aggregates are made up.

Perhaps creating a having the domain expert create a few scenarios before hand to highlight concepts and operations would also be useful.

Now, the other question is can the pedagagical structure for an ITS be automatically generated from this knowledge tree? Is that task easier to do in any way?

Java applet + Jython + RUR-PLE/Corewar

One of the hardest aspects of these activities is grading/judging the projects. If we can automate this part, it will make the effort involved during the activity a lot less.

Here’s the basic idea: The software consists of two arts an applet and a webserver to keep track of scores and allow for collaboration. This would be done through HTTP with Django or some such. The other part is a java applet run on the local system, this would run the actual activity and interact with the user.

The Activity: Robots

The users program ‘robots’ that have to complete tasks with constraints on their behavior. The robots are then automatically scored and end up in a competition ladder. Similar for core war, (perhaps we have a bracketed competition, multiple rounds)?

The robot game could be anything, solve a maze, pick up cookies, paint the floor. They’d probably end up programming it in a subset language (maybe pascal like?) that could have constraints on, for example, the number of instructions, or conditionals, or loops. We may also be able to use a subset of a language (Ruby, Python, Java?) that is in broad use.

Corewar would just be the classic game with a probably simplified assembly instruction set…possibly MIPS?

After a development period (potentially timed), we could display the runs on a big screen showing each person in the bracket.

Integrate an ITS

A Intelligent Tutoring System could be then added to this applet to guide the user through some preliminary projects. This would be a great way to gather observational data as well.

Python eToys -> pytoys

I’ve been thinking about my pyhton eToys clone idea a bit more. Here’s a basic scenario. A user starts off with a  a blank screen, the user then right clicks on the background and then selects the ‘new…’ menu choice. Then brings up a dialog that has the library of premade object such as text, rectangles, circles, buttons,  etc. The user selects a circle and the cursor is turned into a circle ready to be placed the user clicks on the background and the object is placed. After the object is placed the user right clicks on it and a menu pops up, the user selects ‘edit action’ and a special coding dialog shows up, in it is the code:

def action(self):
    |

where | is the cursor in the dialog. The user types self. and a code-completion pop up appears. The user types x and the code completion box does the usual thing and highlights x and contracts the user hits space and continues, writing

def action(self):

    self.x = 50

The user then clicks the “ok” button on the dialog and is brought back to the main screen. There is a button (probably at the top) that is a toggle, currently it is untoggled and says “Run” on it. The user clicks on it and the ball suddenly pops to position x. The user has run out of time, so they click the save button which pops up a dialog that allows them to select the name that they want to save this environment of. If they open that name later on, all the objects and all the code associated with them will be opened again and usable.

One feature I want to integrate is doctests for the little snippets of code that the user writes. This will be somewhat difficult for the individual methods that the user writes…I don’t know how to get around this problem at the moment. (Perhaps run the doctest in a context where the object exists and is bound to the name ’self’?)

Another problem is that pickles don’t support functions or classes, they have to be importable modules. Two solutions to this are just repeating the steps taken patching the  objects on file load (saving the method defining text in the save file) or using something more like the “Lightning Editor” for python, having all the code in a side window and a run button.

It looks like this part at least is less straightforward than I would’ve hoped…A good approach I just realized is saving the text to create the function (doing syntax checks on it live) and then exec’ing it and adding it to the object manually. I think this would cover everything.

Two pieces of opensource software that I use a lot, LyX and FreeMind, both lack active spell checkers. Currently LyX has a 2000 Euro bounty for active spell checking. There are preexisting spellcheckers for Java, so it would hopefully be relatively easy to add it to FreeMind. Regardless, I don’t really have the time to do this, so I wonder how effective it would be to try to out source this code to rentacoder or a service like it.

This also implies that you can engage in “preparatory activities” that aren’t directly related to the end goal, but put into place skills or habits necessary for the end goal. In the Karate Kid, the main character was taught how to paint the fence and wax the car using very specific muscular movements. These were preparatory activities to learning Karate (specifically hand blocks).

Similarly, the knobbed cylinders in Montessori prepare for learning by habitually going in left-to-right in Roman alphabet languages, and right-to-left in Semitic languages.

These is also true of pure-contour drawing for teaching draftsmanship. The copying of curves and edges is a skill that is practiced over and over in preparation for real drawing.

Which draws me to my little anecdote relating to my Wacom pen tablet. Tablets allow you to draw very quickly on the computer, but they take a slightly different sense of coordination compared both to a mouse and to physical pen and paper. I’m not a especially skilled artist yet, so I often still have difficulty making lines even match what I see. I’ve also be conditioned, through my experience in engineering and formalized schooling, to want to verify things after I’ve built them. So, I have a bit of a bad tendency (like many beginning artists) to be judgmental of my work. I also have a weird aversion (probably from formalized schooling) to not want to erase my work if I make a mistake.

Now keeping in mind that sensorial experience *doesn’t* need to be tested, just be expereinced for skills and knowledge to be learned, there is no reason at all to be critical. This is one of the great benefits of blind contour drawing, since the result generally does not match what you were drawing, you can’t critique the result, only the procedure used to get it (whether you drew to fast or too slow). I’ve discovered a somewhat similar technique when using the wacom tablet. Specifically, I take a source image that I’ll be using for a basis, and then draw lines directly onto it using the wacom tablet and inkscape. Of course, being an amatuer, the first like is usually very shaky and inaccurate, so I simply undo and retry until I get a good line. I can keep track of how I did the line with my muscle memory and spatial memory, and the line on the image gives me direct feedback on the accuracy of my drawing.

Another nice side effect is that in addition gaining a lot of practice without judgement, I also get a nice finished product in the end :). I bet it’s a preparatory for edge detection, accurate edge recording, scaling and understanding feedback on how a drawing looks. Plus the motor skills required for drawing effectively with a wacom tablet.

Cognitive Tutor seems pretty simplistic. The example they run throug with creating a learning card for fractional addition seems flawed. I’d constrain it based on algebraic rules and probable decisions made by children (multiply them together, or do a gcd) rather than enumerating all possible choices. Of course, I tend to be a deductivist, so I’d explain the rules of algebra as they relate to fractions before giving examples.

The other thing that may be interesting is that *making* the notes for a spaced learning system such as mnemosyne may add to understanding…It would be difficult to verify notes that students create, but it’s definitely something to explore (even if it does require grading of the notes for correctness by a competent human.)

Procedural Web Design

An interesting project would be procedurally create web layouts following some basic rules (Stuff in basic design books and “don’t make me think”, along with some color theory). It’d definitely be useful, as well.

Currently python asserts are of the form

assert EXPRESSION, MESSAGE

It’d be really nice if an assert of the form

assert a < b < c

would display display a message equivalent to this (with a = 2, b = 1, c = 3)

AssertaionError: 2 < 1 < 3

I think I can do this for most Boolean expressions by doing an AST transform. So something like

assert a.foo() < g.bar() != f("fizzle")

Would be transformed into:

_1, _2, _3, = a.foo(), g.bar(), f("fizzle")
assert _1 < _2 != _3, "%s < %s != %s" % (_1, _2, _3)

This would happen right before methods/functions were run. Hopefully, by using AST it will be more portable to other python implementations (This is the primary reason cited by Guido for why adding this type of assertion to the CPython implementation wont be supported).

Mutation Testing

Mutation testing plugin for nose. Mutate Boolean expressions and constants akin to Pester, only using an AST transform instead of text substitution. This could potentially increase the types of mutations possible (shuffle orders of statements executed, change parameters, etc.)

Difficulties:

• Determing what’s under test to change (perhaps use coverage/figleaf to figure out what to change?)
• Keeping track and reporting mutation results to tester (should be relatively straightforward)
• Doing this quickly — mutations usually take a long time. (Only mutate files specified by user?)

Genetic programming

AST tree manipulation can also be used to generate syntactically correct statements automatically. Assuming I find or create an acceptable cross-over algorithm (perhaps steal the one from pygp) AST will make this relatively straightforward.

• Freemind needs a: spellchecker, automagically updated file view and clone nodes.

• Use python 2.6 ast module to make pretty asserts that use the assert keyword.
• the ast module could also be used to implement something akin to the Eiffel “old” keyword. But I think a registry of expressions to evaluate before the method and are accessable by name e.g.
  • old(expr1=lambda s: s.attr, expr2=lambda s: s.method()) and accessable by old.expr1, old.expr2
• would be cleaner to implement.
• Cmockery is hugs and cuddles, now all I have to do is add it to our make file for OS, mwahahahah!
• Pythoscope equivalent for C would be interesting, and probably useful. Although really hard to implement…Whoever did it would become really good at C, though.
• Contracts for python need to handle functions as well as classes (perhaps through wrapper class with __call__ or some such?)
• Also looking at automake and autotools, makefiles don’t look as brain melting as they used to.
• Automatically generating Sequence diagrams based on unit test or code execution would be AWESOME, pyumlgraph already does it for class relationship diagrams (generally, at least)