Currently, untyped lives on a virtual machine provided by Bytemark. The service they provide is excellent, and we recommend them highly. While we are building our own server we hope to continue to host with Bytemark, but instead of being on a VM, we’ll be on our own hardware. We’ll see how that goes.

Today, Christian and I spent a few hours working on the most fundamental part of a server: the filesystem. Before I go into any detail about the decisions we made, I’ll give you a sense for what we’re working with:

This server has seen use before, but we’ve replaced all the moving parts; we’re quite pleased with its condition, and think it will provide us with a number of years of good service. And, we hope that we don’t need to do a low-level install again in the next few years.

The first thing we did was to grab a Debian 3.1r1 “testing” net installCD image. We had to boot the 2.4 kernel, as the 2.6 kernel fails to load appropriate CD drivers from the install CD; this didn’t really matter. Then, we came around to our filesystem layout; what we knew was that we wanted to partition off different parts of the directory tree (/, /boot, /var, /usr, /tmp, /home); we didn’t know exactly how much space to give each part of the filesystem, however. Do we makehome 40GB, or 60GB? What about usr? The list goes on and on.

We started by setting up a 4GB swap partition at the end of each drive, a 400MB boot partition at the front of each drive, and setting aside the remaining 245GB or so for the main parts of the filesystem. We then used the Debian installer to turn the 400MB partitions into one RAID set, and the 245GB partition into another. This way, both our boot partition and the main part of the drive are in RAID, but we’re guaranteed that our boot partition is at the front of the disk.

(What is RAID? I’ll stick with the Wikipedia on that one. It keeps our two disk drives in perfect sync; this way, if one of them fails, we might be able to replace it before the second one does, thus keeping our system running with little or no interruption. This is a Good Thing.)

Then, we dove into that big, 245GB space. We used LVM—the Logical Volume Manager–to partition the rest of the disk. LVM is great because it essentially ignores the physical layout of your disks, and allows you to dynamically resize partitions without any great gnashing of teeth. So, we laid out 40GB for /home and /data, 20GB for /usr, and 4GB each for /, /var, and /tmp.

Note that this is only 112GB of space; we had (roughly) 245GB of space in that big RAID set. Our intention is to grow those partitions as we need to. For now, we chose large, but reasonable values for each of these partitions. In time, we may decide to increase the amount of space allocated to /home—perhaps from 40GB to 80GB. The point is, we have around 116GB of space to “grow into”, and we can allocate it to any of the partitions we currently have… or we can create new partitions. In either case, these operations don’t require us to shutdown the machine, or even take it entirely offline—we only need to “stop” the logical volume that the partition is on.

While we could do this more quickly the second time around, this took us between one and two hours; we were careful to check our assumptions, and rehashed and discussed a lot of the decisions in light of how we might want to use the server in the future.

Once the filesystem was set up, the rest of the installation went quickly; things were pulled in automatically over the network, and we rebooted into our new machine. The filesystem looks great, and we expect that the decisions we made will serve us well in the future. Now, we’ll work on upgrading the kernel to a 2.6 series (with SMP support), and then begin replicating those services that currently exist on the VM to the server.

Links that came in handy:

• http://www.die.net/doc/linux/HOWTO/LVM-HOWTO-4.html
• http://www.die.net/doc/linux/HOWTO/LVM-HOWTO-9.html#ss9.9
• http://aplawrence.com/Linux/lvm.html

If you are a civilian like me (an anthropologist, that is, without much technical savvy), it’s a little mystifying. Will Internet 2.0 change everything or just some things? Is this a revolutionary moment or an evolutionary one? Is everything I know wrong, or just this, that and the other thing? Is this 2.0h! or merely 2.0. …

Here are three models that sort out the possibilities for me.

Read it, it’s good stuff.

My take: these changes will take place, but it will take another generation, that grows up with the Internet, for them to be fully realised.

I’ve just discovered my old employer, LShift, have a blog. Lots of good stuff there. As usual, TonyG is producing code like the mad hacking machine he is. Now I just have to get him to put some of it in Planet.

Very encouraging to see this advertisement. The highlights:

Jane Street Capital (http://janestcapital.com) is a proprietary
trading company located in Manhattan. We’re looking for students
interested in internships for the summer of 2006…

One unusual attraction of the job is that the large majority
of our programming is done in OCaml.

It’s great to see industry adopting advanced programming languages. Finance is not an entirely new domain for functional programming. Simon Peyton-Jones wrote a paper some time ago on a combinator library for financial contracts. This work has been commercialised, with the implementation again using O’Caml. In fact there is large literature of domain specific languages for financial applications (for example Risla) so there is certainly a market for applying programming language theory in this area.

From Shriram Krishnamurthi comes a nice phrase to describe the AJAX applications that are emerging: webtop. It captures succinctly the blend between web and desktop that characterises these applications, and points to a future when the distinction is meaningless. It’s early days for the webtop right now: most time is spent just getting the interface to work. My bet for next stop on the road is disconnected functionality. While SF may be always onlinesometime soon, but it will be a long time before that applies to everyone.

I love how everyone and their brother has an opinion, and it always stops there. I’d like to take a moment to rant, and point out that opinions do not a curriculum make.

The question of “what is computer science?” has been around for a while. The question of “what goes in a CS curriculum?” has worked the academic circuit for a few years as well. What’s great is that every Tom, Dick, and Harry will come up with an opinion, but not a lot of people work hard at actually trying to come up with a justifiable answer.

Dan Zabonini is a Tom, Dick, and Harry. Over at O’Reilly’s “Policy Center”, he’s posted his half-baked thoughts online (http://www.onlamp.com/pub/wlg/7757); it isn’t worth an active link. Just before a bulleted list of random thoughts, he qualifies his thinking with this choice quote:

So, what would you include in a modern Computer Science/Software Engineering course? I’ve started jotting some draft notes below (in no particular order, this is just a stream of conciousness…)

“This is just a stream of conciousness…”

If you want some thoughts on the topic that are not just a stream of consciousness, you might start reading the ACM Model Curricula documents; I’ve read them all. They’re complex, they consider a wide variety of issues, and they reflect the state of the discipline at the time they were written. Smart, hard-working people who have given their lives to the study of computing, who spent a lifetime teaching the discipline, crafted these documents.

Curriculum 68 was incredibly math-focused; it proposed a CS curriculum that, among other things, included thermodynamics and quantum mechanics. Curriculum 78 saw a lot of maths drop from the curriculum, much to the dismay of many; this is a theme that can be tracked through the ACM DL from the seventies to today. (Here are afew links to get you started.) The writings of Allen Tucker and Anthony Ralston are both particularly insistent on the role of mathematics in the CS curriculum.

The Joint IEEE/ACM Curricula 91 and CC2001 expand the scope of the discipline; CC2001 is particularly painful, as it defines an incredibly broad disciplinary set, yet sets up evaluation criteria that, 75% of the time, can be met without a student ever learning to program. Granted, in practice, programs are not run this way, but the criteria (as stated) do not explicitly require programming skill. I stress skill, because in most all CS departments, programming is not taught as a scientific practice, but as a skill- or craft-based activity. Again, there’s a literature on these different kinds of knowledge (scientific vs. skill vs. craft), and different theories of teaching and learning associated with each.

The curriculum is under constant revision—often pushed and pulled by industry and technology. Physics isn’t pulled about this way; nor is Mathematics, Chemistry, or Biology. Why is it, for example, that the AP curriculum was switched from Pascal to C/C++, and then (in a just a few short years) to Java? The language was incredibly young, untested, and has a convoluted, involved syntax to do simple things. From a first teaching of programming perspective, it’s an abomination. You don’t think so? Perhaps, then, you’ve never tried to teach 45-year-old returning students how to program in Java then.

If you’re going to walk around suggesting what should or shouldn’t be in a computer science curriculum, then perhaps you should begin by catching up on the arguments that have been made for the last 40 years. While you’re at it, I think it would be good if you understood the fundamental research on reading and writing that’s been done in the last 100 years, the research methodologies that were employed in that exploration, and the significance of the findings made with respect to teaching and learning theory over the last five decades. I don’t claim to have a complete grasp of all of this material, but I’ve made a start—and that’s more than 98% of the people who think, just because they can write some Java to transform XML documents in a servlet container, that they have important insights to offer the world regarding the teaching and learning of programming.

Once you’ve made a start on the literature, then we can have aninformed discussion, which is much more interesting than pissing in the wind.

End of rant.

Untypers keep their eyes on a number of weblogs; one of them isLemondoor, a LISP-related weblog maintained by jjwiseman. In this post, he points us at Fluxus, a very cool looking real-time coding and live-performance engine for sound and visual effects.

http://www.pawfal.org/Software/fluxus/

We don’t like to blow our own horn too hard, but around untyped we do pretty well with a number of languages, and Scheme is a favorite; we have a number of open-source projects written in Scheme, and it drives some of our own research projects as well. Fluxus looks like the kind of platform that we might be able to do some very fun and exciting things with.

On Monday Christian and I went to Those Who Wonder, the degree show for the Graphic and Media Design (Illustration) students from the London College of Communication. In a word: Wow!

There’s something wonderful about degree shows. The students realise they’re on the cusp: they’ve finished their training and soon it will be time to try and make an impact on the world outside the University. In some ways it’s the best of times, when everything is potential and no limitations are set by the disappointments that from time to time life brings. It’s been, well, too many years since I finished my undergraduate eduation, but I recaptured a bit of that feeling by being there.

Ostensibly an illustration course, the show included a variety of work that stretched the definition of illustration to the limit: t-shirts, masks, books, and even videos. I was very impressed. The students had also organised and paid for the whole event, including renting the gallery and organising the drinks and entertainment. I can’t recall Computer Science students ever organising an event to equal this!

We took some photos; they’re on Flickr under the thosewhowonder tag. They don’t really do justice to the vent. There were many cameras at the event so I’m hoping that Nils will be able to get some better photos uploaded.

Of course I have to mention the electronic catalogue we developed for the show. It worked wonderfully!

Untyped recently had the opportunity to work with Nils Porrmann on a piece that is part of the upcoming Those Who Wonder exhibition showing this weekend.

Nils and his conspirators had developed a number of pieces they wanted to present in a book, but did not like the idea of printing dead-tree versions of the book for everyone who came to the show. The brainstorm was to take a video of the book, and have some way for the viewer to turn the pages of the video/book by waving their hands in the air… or some other apparently magical mechanism.

Christian and I were able to make that magic happen, and the end-result is really quite nice (even if we do say so ourselves!). Our first step was to explore an excellent little application calledEvoCam; this program lets you plug in an iSight video camera, drag-and-drop regions on the video, and attach actions to motion detected in those regions.

From there, it was just a hop, skip, and a jump to controlling the video. We wrote a custom application for Nils to easily mark the page-flip points, which we then fed into the AppleScripts for controlling the player. The true genius came from Nils, who realized that the interface to a virtual book should be a real book. So, the viewer turns the page on a real (but blank) book, and the video follows the action. With a little skinning of Quicktime Player, we eliminated the control surfaces, and it looks just great on a black background.

We don’t get to do things like this often enough; we like to think that programming is an art, but how often do we actually get to make art with our programming? When the show goes up, we’ll get some pictures and video of the… video. It will be great to see people interact with it!

If you’re in London this weekend, please feel free to stop in. The whole show looks like it will be great.