I’ll have to write a longer post later, but I thought I’d just mention that OSCON is a great conference. Our presentation went well, and we’ve had a lot of great conversations with people about all kinds of things in the open source world.
More later… for now, it’s time to head out the door.
(Related, our parallel programming environment for the Arduino is now available on Ubuntu, Windows, and Mac. Hooray for packaging! And, I need someone to help me work through how to do proper source packages for some of the complexities I’m facing on the Fedora/Ubuntu side. Packaging compilers is not a lot of fun…)
Or, at least, OSCON. I think I’m supposed to put one of these somewhere… for now, I’ll put it on my blag. We’re talking about parallel programming on the Arduino. Tray shwet.
The semester is over, grades are in, and now I hit the road for points east: Syracuse, Boston, DC, and then home again. After that, road-trip to Albuquerque, NM. No, don’t ask.
Then, it’s a flight home, and we dig into research. Very, very exciting.
Yes, Omer’s step-up circuit lets our Atmega328-based board run off a single AA battery. Very, very nice. I have six boards, but no bits and bobs. That must be remedied!
This summer, we have students working on ARM ports (the Fluke) and an autonomous aircraft based on the Arduino. This is, as we like to say in the group, Very, Very Exciting.
I am excited to announce the release of Plumbing, software and documentation to support artists and makers in the programming of low-cost, open-hardware
platforms like the Arduino. The Plumbing libraries are a collection of parallel components written in occam-pi , a small language with a long history.
Last summer, we decided that it was time to bring six years of work regarding runtimes for parallel languages to the Arduino, a popular open platform for exploring the of art, electronics, and computing. In doing so, we decided that documentation would be critical in this effort. Documentation became a focus because we decided as a team that users matter. In designing and documenting Plumbing, we kept our focus on the students, artists, and makers who might do something amazing with our tools.
I think we’ve taken some substantial risks. Many people have contributed many thousands of hours of development time in our software (to say nothing of the years invested in occam-pi), and we will soon be releasing hardware as part of this effort as well. For me, the most substantial is the commitment to publishing our book, Plumbing for the Arduino, under a Creative Commons BY-SA license. That means that anyone can modify, distribute, and sell our work, as long as you give us credit.
Giving our book away is substantial because publishing is part of how academics are evaluated and keep their jobs. By giving away our book, we must now convince our respective institutions that publishing under the Creative Commons will force us to produce a better product (on an ongoing basis) than editorial review would, as well as reach more readers than if we found a publisher (who would then claim copyright over our creation). Or, we must find a publisher who is interested in helping develop and market our text while allowing it to continue to be available under a free and open license. (If you know one, please have them drop me a note to me at matt at concurrency dot cc.)
concurrency.cc and the materials made available from that site have been in development for years. I’m glad to finally see everything settling in place so people can easily download and explore the tools we have spent so many years working on. If you do, let me know how things go. (We’ll have mailing lists up soon, I promise… but for now my job as a professor calls, and it’s going to be a busy few days…)
Thanks to Dave Humphrey, GDK, and the rest of the POSSE crew. For months the encouragement to just release! has been kicking around my head. That message helped keep us on track as we reworked build systems, wrote text, built websites, and generally did all that stuff that no one thinks about when bringing a project together.
And we’ll get a Fedora RPM done as soon as we can. (In the meantime, you can build from source like the rest of us.)
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.
