March 20, 2013: WIPTTE 2013
Wade and I are here in Los Angeles to present another aspect of our study of the Programming Studio class. This time we're talking about the results of the student surveys. The response of the students was quite positive. Out of over one hundred separate question responses, only one was actually negative; the others were neutral or, more often, positive. The paper, and the presentation slides, are on our pubs page.
March 8, 2013: SIGCSE 2013
Wade presented our paper on the audio analysis of the 242 discussions. We think this is the first time that this kind of analysis was used to measure ``liveliness'' of a class. The results were kind of startling: we measured how many different students spoke during each minute of the meetings, and every tablet section showed more students speaking, on average, than every non-tablet section, by about 20%. The paper is on our pubs page.
December 18, 2010: Plans for Spring
- Wade has been working on the Java port for Android and Swing,
and it works. We'll release it after a bit more development and testing.
- Following that port, Wade wants to experiment with using Android
phones in classrooms. They fall between clickers and tablets in terms
of price and functionality, and of course have the advantage that many
students have them (not Android phones, but phones, usually
"smart" ones). Not sure what we're going to do exactly; probably
get some TAs in CS or elsewhere to give their discussion sections in
the experimental classroom (1129).
- We mentioned the fall experiments earlier.
With the IRB in place, we can get started on the 225 experiment right
Cinda wants to do it, and we think this will provide a fuller test,
as she adjusts to having the dashboard there.
In 242, we have an exciting idea to test whether the Tablets are having the intended effect of making the discussions livelier. If you read the short paper on the Fall experiment, you saw that we postulated, and found some evidence, that using the tablets increased the amount of oral communication in the discussions. We want to test this by recording the students in some sections, while the class switches (every two or three weeks) between using and not using tablets. We'll analyze the recordings to see how many "turns" students take. (This is similar to what Karrie does with her Conversation Clock, except that we don't need to do it in real time.) The plan is to get a bunch of personal digital audio recording devices (they're about $50 each) and mike each student. What's cool about this is that it provides an objective measure of student engagement, which is otherwise hard to get.
We've been playing around with scripting languages for a while.
I've never liked Python much (okay, shoot me, but I happen to think
that indentation-based syntax is one of the dumbest ideas ever),
and I've always felt that a custom-built scripting language would
offer the opportunity to include language features and debugging
facilities to make scripting Slice apps easier.
became a particular problem with the Android port, because
we couldn't find a Python that integrated well with Android.
That's actually the reason I developed XL.
However, it turns out that implementing a programming language is a lot of work (who knew?). XL works fine at this point (the entire 225 is implemented using it), but it is quite inefficient, and lacks many features of a better developed language like Python.
December 15, 2010: Fall Tablet experiments
We ran two small experiments this past semester - planning to run larger versions in the spring. One was in Programming Studio (CS 242, TA Charlie Meyer), the other in Data Structures (CS 225, Prof. Cinda Heeren). For the most part, these experiments were just to test the systems we developed, but we got some encouraging preliminary results, especially for the Studio experiment.
Read more in the technical note, "Fall 2010 Tablet PC Experiments," on the pubs page.
December 5, 2010: New Tablets for CS 242
I've been meaning to write a news item on our small experiments this past semester, but this is breaking news: The College of Engineering approved the department's request for new tablets, including enough to equip every section of the Programming Studio. I'll report on what we've been doing, but basically it's using the code review app for the Studio discussions. The TA who tried them, Charlie Meyer, thought they worked really well (we'll do student surveys soon). In the meantime, the College asked departments for educational technology requests, so we put in for these and got them. Still deciding exactly what to get - the machines we used for the experiment are about five years old, so we figure any Tablet will do the trick. We want a full-size screens, but beyond that we're just looking for what's cheapest.
You can read more about it here. Bottom line is that the machines worked well - not perfectly, but no serious complaints. (My main worry in having students use Slice in regular classes is that the system will crash and they will lose their notes for that day. In 225 this semester, only one student lost notes, and it was their own fault: despite repeated encouragement, this student failed to save their work before exiting Slice.) More encouraging, in 242 we have some evidence of a synergistic effect on the tablets on the discussions - that their use results in an increase in the amount of oral communication. In the spring, we're hoping to do an experiment to see if the effect is real.
The request also included money for smaller, cheaper tablets - especially, Android tablets - so that we could experiment with these machines. The downside of these is that they are smaller (bad) and don't have active digitizers (really bad), but the upside is that they're a lot less expensive. If we can make them work, we can save some money on future purchases. (Oh, not really ready to announce this, but Wade has been building a Slice port in Java for both regular browsers - using Swing - and Android...)
June 10, 2010: XL scripting language
The new distribution of Slice includes our own scripting language, which may be used alongside Python. XL is a Java-like language with dynamic typing and heterogeneous lists - in effect, a Python with braces and semicolons. (It also lacks objects; these are never used in our Python scripts, and somewhat violate the spirit of Slice, in which all data are, by intent, placed in the state tree.) Our hope is that, because we own XL and it is specifically designed for Slice scripting, it will be developed to make Slice scripting significantly simpler. In its current state, it is at least straightforward to port Python scripts to it, and we believe its error messages are more helpful and easier to read than Python's. As of this writing, only the lecture app has been ported; in the distribution folder, its XML can be found in Lecturer/Code/lecturerxl.xml and the scripts in the scripts folder (with xl suffix). Documentation can be found on the framework page.