I’ll be posting everything over here from now on.

Update: the lesson has been accepted for KDP Select. If you have Amazon Prime, you’ll be able to borrow it for free. By all means feel free to do so.

Unit I Cover

Update: I see that WordPress (or at least this theme) eats indentation even if you wrap the code in <code></code> tags. Fail. Oh, well. If you have a use for this, I’d bet money that your editor will handle reindenting the code for you. Heh.


# Font downloader for Google Web Fonts.
# Puts the fonts in a file called "Fontname.ttf" (spaces in the font name are removed)
# and outputs the CSS code to load the fonts.
# Run with something like ruby snagfonts.rb > fontloader.css to get the CSS font directives in a nice file.
# Copyright 2012 by Contraterrene eLearning Group, LLC
# MIT License or Ruby License, your choice.

This little script will download all the fonts you’ve listed in the array, and output the correct CSS to load them. As written, the fonts will be saved in the fonts/ directory (which you must create ahead of time), while the CSS goes to standard output (which you can redirect to a file). It should be simple enough to mod if you want something else.

Sample CSS output:

@font-face {
font-family: 'Aclonica';
font-style: normal;
font-weight: normal;
src: local('Aclonica'), local('Aclonica-Regular'), url('fonts/Aclonica.ttf') format('truetype');
}
@font-face {
font-family: 'Annie Use Your Telescope';
font-style: normal;
font-weight: normal;
src: local('Annie Use Your Telescope'), local('AnnieUseYourTelescope'), url('fonts/AnnieUseYourTelescope.ttf') format('truetype');
}
@font-face {
font-family: 'Anonymous Pro';
font-style: normal;
font-weight: normal;
src: local('Anonymous Pro'), local('AnonymousPro'), url('fonts/AnonymousPro.ttf') format('truetype');
}
@font-face {
font-family: 'Allerta Stencil';
font-style: normal;
font-weight: normal;
src: local('Allerta Stencil Regular'), local('AllertaStencil-Regular'), url('fonts/AllertaStencil.ttf') format('truetype');
}
@font-face {
font-family: 'Allerta';
font-style: normal;
font-weight: normal;
src: local('Allerta Regular'), local('Allerta-Regular'), url('fonts/Allerta.ttf') format('truetype');
}
@font-face {
font-family: 'Amaranth';
font-style: normal;
font-weight: normal;
src: local('Amaranth'), url('fonts/Amaranth.ttf') format('truetype');
}

Enjoy.

Note that you DON’T need to be a programmer to build one of these — that was the design goal. If you can use Google Reader or set up a Google Calendar or Flickr album you can use this. Conversely, if you are a programmer you can use the External Code block and go as far as your imagination and skills can take you.

I’ve been working on this stuff for about a month, and I think it’s time to let other people start beating on it. It definitely needs more extensive testing on Android — works fine on my cheapie Android phone and on my Kindle Fire, but there are about a billion different configurations of Android out there. Let me know if something breaks. Note that there are two links on that page — the first goes to a sample app that needs to run on a mobile device to be fully functional. The second is to the self-service app builder, which needs to run on a desktop or notebook using Google Chrome or Safari (no Firefox or IE support, sorry).

Supported resource types at present: Web feed (RSS and Atom), Twitter feed, Flickr photo sets, podcasts (both audio and video), YouTube channels, Google Maps, user-entered HTML (includes a WYSIWYG editor), external code, external site, phone dialer, SMS text message, iTunes store, email, Google Calendar, and Facebook.

Next steps: performance optimization, more themes, and better docs. I also have some ideas for cool new blocks, and want to make Facebook an internal resource (like Twitter) rather than an external link.

Now, no one would argue that BASIC is a great language. It was, however, free and ubiquitous – there were problems if you wanted to share your Atari BASIC program with someone who had an Apple II, but often you could make the code work with a little bit of ingenuity.

Where do modern kids get that experience?  Are we creating a generation of appliance users who (if they’re exposed to programming at all) get their first experience in a behemoth like Java?

So there’s no confusion here: I like Java (well, I like the JVM anyway ), and have written more than my share of it. However, it doesn’t exactly lend itself to casual tinkering.  Compare:

10 PRINT "Hello, world!"

1 line, 11 characters of overhead, what the code does is obvious at a glance, even to someone who doesn’t know programming (they might wonder about the 10, but that’s about it).

to:

public class HelloWorld {

     public static void main(String[] args) {
          System.out.println("Hello, World!");
     }

}

6 lines, 112 characters of overhead — plus you have to compile it, maybe set up your CLASSPATH, and perhaps perform other chores that stand in the way of instant gratification. Also, the code is largely opaque to a programming-naive reader. “public class”? “static”? “void”? Say what?

There have been many attempts to fix this. Scratch from MIT, Alice from Carnegie Mellon, indie projects such as Hackety Hack from why the lucky stiff (please come back, _why! We miss you!), special purpose scripting languages such as LSL, and several others.

With the exception of LSL, most of them are excellent (Cory Ondrejka, author of LSL:  “[N]ote to self, next time spend more than one night designing language.” ).  I’ve had good luck teaching this type of language to an audience of K-12 teachers, most of whom had no background in programming.

Where they come up short is ubiquity. They’re almost all free, which is great, but they have to be installed, which is not so great. Most school computers are locked down extremely tightly (an interesting topic its own right). In fact, one of my students was reprimanded for installing Scratch on her classroom machines.

Even if you are permitted to install the software, the installation step still creates a barrier for sharing your creation with your friends, since they in turn have to install something before they can run your code.

MIT has worked around this to some degree with their Java (and now Flash) web-based Scratch players, but Java and Flash present their own issues (school firewalls or other security software may block Java and Flash, Windows machines, and starting with OS X Lion, Macs, no longer come with Java installed, Flash doesn’t work at all on iPhone/iPad, and doesn’t work very well on Android).

So… what to do?

I would argue that JavaScript is the modern equivalent of BASIC; it’s free, ubiquitous, and has the requisite nasty, nasty syntax.   Any kid with a web browser and a text editor can write and run JavaScript without installing anything. HTML 5 opens up the possibility for impressive visual and sound effects that can be shared with anyone else on the planet who has a modern browser.

Even with the ugly syntax, JavaScript is a much better language than old-school BASIC. Closures, anonymous functions, objects — there are a lot of Big Ideas in there.

Besides the syntax, the other drawbacks of JavaScript include performance and the sandbox model (sandboxing is essential when you’re running arbitrary code from random web sites, but extremely inconvenient when you’re running your own trusted code).

There are workarounds. There are new packages that let you use better syntax (e.g., CoffeeScript, which gives you Ruby-like syntax, the experimental ClojureScript, which gives you Lisp, and many others).

With respect to speed, Google has invested major effort in their V8 JavaScript compiler, which gives you near-native code performance. It’s much, much faster than classic JavaScript.

There are also several options for those who chafe at the sandbox.

Node.js lets you access the file system, write servers, and similar stuff.

Packages such as PhoneGap and Appcelerator Titanium let you write JavaScript applications that run on phones and other mobile platforms. In both cases, the code has direct access to phone features such as the camera, microphone, contact list, geolocation, accelerometers, and so on. PhoneGap works by calling native routines from interpreted JavaScript, while  Titanium precompiles the JavaScript to native code.

While I have no data, I would wager that the ability to do cool things on their phones, and share those cool things with their friends*, would be an extremely powerful motivator for today’s students.

* The biggest barriers to doing phone stuff are bureaucratic rather than technical — there are some issues involved with distributing your creation.  For iOS,  the best option right now (on a school level)  appears to be Apple’s Enterprise Distribution mechanism, which isn’t particularly transparent, cheap, or low-friction. For individuals (or if you want wider distribution through the App Store) you’ll need to buy a seat in the standard iOS developer program. I’d really like to see Apple set up some kind of low-cost student program — perhaps it could include the standard developer package’s ability to distribute to a limited number of devices on an ad hoc basis,  but not include the commercial features (e.g., distribution through the App Store). Android is much more lenient in this respect.

It’s always been mystifying to me why some equate a constructivist/constructionist/project-based/inquiry-based approach to education with “teacher doesn’t have to do any work” (actually, I’m pretty sure why some people are fond of that idea, but we won’t go there).  Some years ago, Kirschner, Sweller, and Clark stirred the pot with their article Why Minimal Guidance During Instruction Does Not Work: An Analysis of the Failure of Constructivist, Discovery, Problem-Based, Experiential, and Inquiry-Based Teaching.

Those of us who have advocated (and practiced) this style of teaching with success immediately recognized some of the serious problems with this paper.  It’s pretty clear  that doing truly original work without any scaffolding from a knowledgeable other is hard. Really hard. They give you PhDs for that. In the entire history of the human race, only two people (that we know of) have invented calculus. Odds that a student is going to discover calculus by him- or herself? Not very good.

That’s not to say that students can’t learn from unstructured exploration — I’m a big advocate of tinkering (bricolage, if you want it to sound impressive), and have learned many useful things from it.  But, you know, students don’t really need to pay you tuition to do that. If they aren’t getting any  (or “minimal”) guidance from the instructor, why are they even in school? Why is there even a “teacher”?

(there are some who would argue that school as we know it is a bad idea altogether, but that’s a separate discussion).

The best response to Kirschner, et al, that I’ve seen is Hmelo-Silver, Duncan, and Chinn’s Scaffolding and Achievement in Problem-Based and Inquiry Learning: A Response to Kirschner, Sweller, and Clark (2006).  Their discussion matches closely with my own experience. Correct application of these methods doesn’t mean that the teacher provides no guidance, as Kirschner, et al would have it.  On the contrary, I would argue that doing a good job in this respect requires more work, not less. It’s really much easier for the teacher to make every student perform exactly the same task, which can be graded with a check-off rubric. Giving  students the freedom to pursue their own interests means (or should mean) that the instructor gives each and every student individual attention and careful guidance to prevent them from wandering off into the weeds.