|
SLICE News
December 18, 2010: Plans for Spring
S. Kamin
Lots of stuff going on: Android port; phones; experiments in 242 and 225; probable JavaScript integration. Here's a brief overview:
- 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
away.
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.
Then, Python
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.
So Wade has pretty much convinced me that we should go with JavaScript as our extension language. Its syntax is much like XL, so that port should be pretty easy; its implementations are well developed and much more efficient than XL's (at least on workstations; on the phones there doesn't seem to be much difference); and it has libraries for things like string manipulation. He's found implementations that integrate well with both the Java and C# versions of Slice. So that will probably be our standard scripting language, and indeed we're likely to drop support for everything else.
December 15, 2010: Fall Tablet experiments
S. Kamin
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.
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...)
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.
December 5, 2010: New Tablets for CS 242
S. Kamin
June 10, 2010: XL scripting language
S. Kamin