That is a concurrency.cc Arduino-compatible board fired up and ready to go. As you can see, the vias aren’t really lined up that well, which may account for some intermittent USB-to-serial weirdness that he is chasing down at the moment.
Awesome job, Omer! If all goes well, I think we’ll have around 40 to 50 students at Allegheny building their own computers next semester in courses I’m teaching or co-teaching, another handful at Kent, and who knows… perhaps I’ll find another place to bring these into my students’ experience next term.
I remain hopeful that our final boards will be purple, and that the ability to expressly direct parallel code for an affordable embedded platform like the Arduino will be of use to many. One step at a time, though: we need to get revisions done on our existing book chapters, write the next five we have outlined, get Windows and Linux distributions done… it seems like a lot, but we’ll get there.
I’ll have to write a longer reflection at some point, but the long and short is that I’m very excited to see our project coming together on multiple fronts for distribution: robust software, source-to-binary builds, hardware that showcases our tools, and a text that provides structure and guidance for non-programmers to get into hardware exploration one small step at a time. When you start a project like this, you want all of these things from the start… but sometimes, it takes lots of small steps, side explorations, and unsure starts to get you to where you want to go.
How is a research group at a small, liberal arts college born? I think you get some students working on related things, and declare them a group. That, and have them over for dinner at least once.
Background (not so important)
My current research focuses on the behavior of novice programmers and the development of tools for parallel programming on small embedded systems. Long term, I am interested in the usability of programming languages—which lies at the intersection of my current lines of research inquiry.
One reason I take a long view on my research because I am at the start of my career. Another is that I am committed to involving students at Allegheny College with diverse backgrounds in my research. For these reasons, I paint my research with a broad brush to better support more students with more interests. In doing so, I can productively move my research forward regardless of what interests my students might have in any given year. It also makes it easier to collaborate across disciplinary boundaries when you keep an open mind regarding where your work can be applied.
The Students (very important)
This semester, I am excited to be working with four students. Stephanie Cost and Sara Doan (both Allegheny ’11) have been learning the foundations of image manipulation using Python, with an eye towards image analysis and transformation. Their work is funded by the Collaborative Research Experiences for Undergraduates programme, and is titled Operation: Stick Figure Army. Their project explores the problem of transforming 2D images into 3D models suitable for printing on the Makerbot Cupcake CNC 3D printer (project overview). The goal is to produce an open source set of tools for supporting blind readers—images are the bane of a blind student’s existence, as they translate poorly using existing printing technologies. Our hope is that low-cost, personal fabrication technologies like the Cupcake CNC (along with usable, open software tools) will create new opportunities for blind readers in this space. Both Sara and Stephanie are doing excellent work, and I’m excited to have the entire year (both semesters plus the summer) to work with them on this project.
Although this is our Fall Break, I spent two hours today catching up with Radu Creanga (Allegheny ’11), who is helping our distributed group bring parallel programming to the Arduino platform. Using the occam-pi programming language and executing on the Transterpreter virtual machine, Radu has quickly learned the joys of checking out an open source project, cross-compiling it from source, and doing hardware-level additions to our library for safe, process-based parallel programming called Plumbing. You can follow his work online (project overview, more posts coming soon), and both his software and documentation will be part of our pending release at concurrency.cc.
Last, but not least, Drew Pirrone-Brusse (Allegheny ’10) is working on Verbing Stories. Drew is pursuing a self-designed major at the intersection of Communication Arts and Computer Science, and this semester we are exploring Kodu (and, time permitting, Scratch) as platforms for interactive storyboarding in the context of game design and creation. While Kodu is not an open platform, we hope that our work will provide inspiration for others interested in the use of novice programming environments for interactively exploring the role of story in game development.
In later posts, I’ll point out where some of our infrastructure (repositories, etc.) live. In the meantime, I wanted to introduce the exciting projects that these students are engaged in. If you’re so inclined, you can also follow their work at planet.baseplate.org; for lack of a better name, we’ve named ourselves the Open Group @ Allegheny College, because we’re open to working with students on a wide range of projects, and we strive to make our work open source wherever and whenever possible.
Blogs: Stephanie/Sara (Operation: Stick Figure Army), Radu (Plumbing for the Arduino), Drew (Verbing Stories)
Omer Kilic (twitter)is now a PhD student at the University of Kent; I had the pleasure of working with him while I was there doing my degree a few years back. (In fact, Omer’s excitement about embedded systems is part of the reason why I finally got over my own fears about real hardware and started playing with small systems like the Arduino.) Adam Sampson has hooked him up with our nascent Plumbing library for the Arduino, and he has some tasty-tasty blinkenlights going on:
I’ll try to get a website and some getting started information up on the web in the near future. Plumbing is a library for handling input and output on the Arduino in a parallel-safe way, using the occam-pi programming language. The code for the above example probably looks something like this:
PROC main ()
PAR
blink (13, 500)
blink (10, 400)
blink (7, 600)
blink (4, 300)
:
How do you do that?
For a number of years, we’ve been working with a language that is fundamentally parallel in nature. More importantly, the Transterpreter was at the core of Christian Jacobsen‘s doctoral work. The Transterpreter (other than having a really cool name) make it possible to run occam-pi programs on really tiny devices. The Arduino is an example of what I mean by a “tiny” device.
While I don’t know exactly how fast Omer is blinking the lights, I know he is blinking them in parallel. This means that they are blinking at the same time. When programming in occam-pi, you pretend that it is possible to do things simultaneously by writing PAR, and then you let the tools take care of everything else for you. I only say “pretend” because the Arduino only has one processor—but, despite this, we write PARallel code in occam-pi and let the tools take care of things, regardless of whether we have one processor or one thousand.
As a result, blinking four LEDs is one of the easiest things in the world to do. As you can see, Omer is blinking four pins at different rates of speed, all underneath one PAR block.
Open-source is Awesome
Everything we work on is open source (GPL/LGPL), and we have the first few chapters of a book drafted to support people learning with these tools. We’ve aimed the book at artists and (people are assuming are) non-programmers. That doesn’t mean we’re talking down—it just means we’re writing lots of tiny chapters that expose just one thing at a time. I’ll work on getting some minimal website up for the materials, get some mailing lists set up, and see if we can’t get a few people playing with the fun stuff. I wasn’t planning on releasing things this soon, but it looks like we’re starting to see a bit of interest. That must mean… it’s time to release!
You see, right now I’m out in Raleigh, NC taking part in POSSE (Professors’ Open Source Software Experience), which is graciously being hosted by Red Hat through the auspices of gdk. As Dr. Panic points out in his blog post about packaging software, I chose to do something other than “Hello, World” yesterday. I decided I’d try and get all the tools we need for the Arduino packaged up as a Red Hat package, so RH users could download things and dive in. That took a long time, and I’m not done yet… but I’m making good progress! Sadly, I can’t run myself under a PAR block… I’d be able to get so much more done…
We’ll get stuff online, and others can join in the fun. That can be part of tonight’s homework… along with everything else the POSSE organizers have us doing.
