Planet PLUG

Tharun Kumar Allu: Set Up an Email Gateway with CentOS Linux�5.4 � Aaron Walrath – Another IT Guy's Meanderings

noreply@blogger.com (Tharun) — Wed, 28 Jul 2010 16:35:19 +0000

A very useful mail gateway setup on Linux to be an edge server for MS Exchange.

Set Up an Email Gateway with CentOS Linux�5.4 � Aaron Walrath – Another IT Guy's Meanderings

Kyle Winfree: 18 miles on 1 watt

Wed, 28 Jul 2010 05:30:10 +0000

I finished a quarter wave dipole antenna yesterday, and had a chance to try it out tonight. I wasn’t able to get a signal report (I tested at 1am), but I definitely was able to get into several Philadelphia 440Mhz repeaters. This is neat to me because the antenna is so simple, yet already is showing better performance than a commercial mag mount antenna I have.

I made the antenna such that it can easily be taken apart. This way, it can be moved without the high probability that it would be damaged. Please see the pictures.

Alex Launi: Anyone want to do a couple early morning pre-guadec rides?

Sun, 25 Jul 2010 09:18:51 +0000

I know there are some other cyclists in the GNOME community who are probably bummed that they’re spending a week away from their bikes, so if anyone else is feeling withdraw symptoms from not riding I am planning to find a bike shop in Den Haag where I can rent a road bike and do some early morning rides before guadec starts. If you’re interested in some early morning pain and suffering grab me at guadec and let’s figure out a route.

Kyle Winfree: Arduino SDWrite

Tue, 20 Jul 2010 21:02:51 +0000

Alright, so it’s been done for 9 days now, and I’m just now getting around to making a blog post about it, but I have a working SD card writer. Basically, I took an existing example (that came from Ryan Owens (Spark Fun) using a library written by Roland Riegel) and modified it to be a log file generator. It works on the MicroSD Shield, http://www.sparkfun.com/commerce/product_info.php?products_id=9802. I hope to roll this into a library set of it’s own soon, so my program will reflect “initialize_log” and “write_to_log” functionality. Fun fun!

Richard Freeman: rich0

Sun, 18 Jul 2010 11:57:21 +0000

One minor issue with EC2 is that they supply the kernel, and that already caused difficulties with my first EC2 tutorial – the image I created doesn’t let you create a new snapshot from a running image since the EC2 kernel lacks loopback support, and I didn’t supply a matching kernel module.

Amazon has a nice guide on how to do it – here is a gentoo-specific one.

These instructions start from a working ami image created using my previous instructions. Go ahead and mount it and chroot into the image.

Install a kernel using emerge xen-sources
Be sure to enable xen support in the kernel config file. Here is a working config.
Build the kernel with make && make modules_install as usual
Copy the kernel image to /boot as usual.
Create /boot/grub/menu.lst, containing:
default 0 timeout 3 title EC2 root (hd0) kernel /boot/kernel root=/dev/sda1
While optional you might want to clean up the kernel source directory, or even remove it – you’re paying by the gb and the sources and object files are large.
Bundle it up with the instructions in the first guide, but on the ec2-bundle-vol command line add –kernel followed by a suitable kernel ID from the pdf linked above. For a 64-bit ami in the US-east region use aki‐427d952b

That’s it – upload, register, and boot it up!

I registered a public ami at ami-bcf11ad5, which you can feel free to take a look at. xen-sources is running a fairly ancient kernel on stable – maybe on a later installment I’ll look to update that.

Additional note: I registered a public ami at ami-8f04efe6 which is running 2.6.34 on a 32-bit gentoo install. It also is running the latest stable udev.

On both images I have an entry in root’s ssh authorized_keys so that I can more conveniently access these instances when I’m using them. If you use this for anything other than experimentation you should remove this before creating your image. I’d host a version with and without this, but that does cost money on S3, so consider yourself warned…

Filed under: gentoo

yonkeltron: Great post about Emacs keyboard macros

Fri, 16 Jul 2010 18:45:41 +0000

I always find great stuff on the emacs-fu blog but today I read a particularly-wonderful post about Emacs keyboard macros. Like the author, I’ve been a long-time Emacs user but never really got into keyboard macros because it’s been quite easy to produce an elisp one-liner in many cases. That being said, this seems like a great time to learn so I look forward to reading more on the topic of keyboard macros as well as learning some new tricks.

Thanks for a great post!

Alex Launi: I need a floor in Amsterdam! Does anyone have a dutch floor??

Tue, 06 Jul 2010 17:52:12 +0000

Dear Dutch foss community,

A friend and I are attending GUADEC this year, but we have plane tickets to fly into Amsterdam on the 24th of July. The problem? GUADEC isn’t until the 26th! Neither of us have ever been to Holland, and while 2 days is certainly not enough time to enjoy Amsterdam, we want to try. If anyone has a bed/couch/floor/stable/etc. that the two of us could sleep in/on/under the night of the 24th we’d be super appreciative, and of course you’d always have a place to stay wherever it is that I’m living when you need a place to stay (at the moment Philadelphia- a really great town if you want to come visit, seriously Philly rules!).

Of course we’ll take you out, or cook you a nice dinner in return for your hospitality, and promise not to make a mess.

If you have a floor or whatever that we can sleep on, feel free to either leave a comment or send me an email alex.launi@gmail.com!

Kyle Winfree: Arduino on Mandriva

Sat, 03 Jul 2010 12:49:10 +0000

The first hit I received when I searched for “Arduino Mandriva” was http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1259672641/2. For some reason, wget failed on me when I followed the listed directions. Instead, I just downloaded arduino-0018 and avr-* from ftp://blogdrake.serveftp.net/mandriva/2010.0/free/i586/ and avr-libc from ftp://blogdrake.serveftp.net/mandriva/2010.0/free/noarch/ to a local directory. I then added that directory to my list of repositories (custom – local file). For some odd reason I need to run it with root permissions to get serial port access, but it works.

I’ll note I tried this because the source from the Arduino website didn’t work out of the box, dependency issues.

Kyle Winfree: 100 downloads in 367 days – it sounds unimpressive, but I’m happy

Fri, 02 Jul 2010 19:47:58 +0000

“A high fidelity ungrounded torque feedback device: The iTorqU 2.0″
15 full-text downloads between 2010-06-10 and 2010-07-02
102 full-text downloads since date of posting (2009-06-29)
Congratulations! This paper has now been downloaded over 100 times!

To encourage readership, simply refer people to the following web address:
http://repository.upenn.edu/ese_papers/497

Kyle Winfree: pgfplots

Fri, 02 Jul 2010 19:40:27 +0000

A friend of mine presented his research from the past few months at the lab’s weekly meeting today. He used Beamer/LaTeX to create his slide show. I’m a fan of TeX, so I was impressed. I was more impressed when I came to learn that he used pgfplots to make his figures, rather than Matlab. Check out pgfplots at http://sourceforge.net/projects/pgfplots/. I want to point out that he simply exported his data (from Matlab, but he could have used Octave) to a csv file. He then made his plots within LaTeX so that he had ultimate control over the plots, and they really did come out nice. I thought eps (vector graphic) figures trumped jpgs (read as LaTeX trumps PowerPoint for science slides), but I’m excited to say that pgfplots trumps eps (which still reads as LaTeX trumps PowerPoint).

I’m starting to think that I might need to do a short presentation on LaTeX for my local LUG; they (we) have been desperately looking for presenters on Linux-ey topics. Maybe in another two or three months, after I get another paper or two at least submitted to a journal/conference.

Kyle Winfree: Arduino and Linux Journal

Fri, 02 Jul 2010 19:28:19 +0000

I can’t post a link to the article, since it’s not yet available at linuxjournal.com, but this month’s LJ issue just happens to cover the Arduino board! They cover plotting data using the Arduino debug serial command and kst. Very cool.

My mentee has just finished the wiring harness for all of our analog sensors (six in total). He’s working on placement of the sensors and plotting some of that data this weekend (though not with kst). I’ve started delving into the mp3 shield we got from sparkfun.com, and hope to get that working with the microsd card shield this weekend. I had to relocate the chip select (CS) pin on the lcd shield we have, as it interfered with the cable select for the mp3 player. It looks as if the MOSI/MISO pins can all be shared between the shields, so long as the cable select is activated before data is sent to the corresponding shield. Neat.

yonkeltron: newhaven.rb hackfest tomorrow!

Wed, 30 Jun 2010 14:00:54 +0000

Tomorrow, in New Haven, CT will be the “Ruby, White and Blue” Hackfest run by newhaven.rb. We’ll be working on a few projects including the group’s site and most likely some Prawn and ScosugBot stuff. Beginners and people interested in learning are more than welcome and we hope to have some excellent projects for people to get started on.

Fill out the RSVP form and we’ll meet at 6pm EST at Blue State Coffee on Thursday, July 1st. Bring a computer and let’s write some code.

View Larger Map

Kam Salisbury: Linked In 404

Sat, 26 Jun 2010 01:45:06 +0000

From 404

I configured my Dreamhost.com custom 404 message to display an image versus an HTML document (I know, it borders on Internet politeness) so I found it funny when that image displayed in a recent post at LinkedIn. The context of the status post and the image matched up in a piculiar way. (You can click the image to see more 404s from the web and real world). If you know what an

.htaccess

file is then your welcome to use mine, grab it via this link...

Kam Salisbury: Rate My Network Diagram

Thu, 24 Jun 2010 14:00:10 +0000

Reviewed over 2900 times, I remember scribbling this network diagram on an old Windows Pocket PC. Click the image or this text to review or upload your network diagram...

Kyle Winfree: Gramian take three!

Thu, 24 Jun 2010 10:18:20 +0000

I really lucked out. The octave-forge developer who has responded to my submission of gramian.m has been really helpful in identifying things I should do to improve the usefulness and robustness of my function. He has given examples of what should be done in some cases, and simply stated what should be done in others. The ball is back in my court now, as several additional changes are requested. This is great though; by the time I submit fftplot.m for review, I should have a very good idea of how to write high standards octave/matlab functions.

JonathanD: fosscon... 2011?

Sun, 20 Jun 2010 10:21:43 +0000

Fosscon ended just over 12 hours ago. I think I probably listened to the first or last 15-20 minutes of at least 10 different talks or workshops... and I loved it. It's 6am the following morning and I'm absolutely exhausted, but I'm also excited about what the future holds.

So, the good, the bad... We didn't get the turnout we'd hoped for, but at the end of the day I think everyone enjoyed themselves. The talks (or at least the parts I actually got to hear) were very good, and more importantly a lot of people from all over talked outside them about ways they could help each others... help their community. I think it says something of our speakers that after hearing just a tidbit here and there, I still felt fulfilled in every instance.

To me, that's probably one of the best things that comes out of this. These disparate groups and people from all over have made the connections that will tie them together in the future. They've learned of new resources, and also who might need the resources they can provide, and as a result the community grows stronger.

It's these connections that move us forward. In the foss world, one person can certainly make a difference, but a handful of people who share what they have and use it to do something new and amazing, they can change the whole world.

There was a lot of talk at fosscon about next year. There will be a next year. Too much good happened for there not to be, and these people, all those who attended, those who sponsored (linode, the Peer Directed Project Center, and of course our attendees themselves!), those who volunteered... they are fosscon's community, and it's going to happen again.

See you in 2011

Kyle Winfree: Arduino

Fri, 18 Jun 2010 10:34:08 +0000

I sent out an email to the Philadelphia Linux Users Group that I am part of, asking for advice related to microprocessors that would be easy to use and yet highly functional. To be honest, I didn’t think I would get much response, though I can’t say why I thought that. Really I should have expected otherwise, as that is exactly what happened.

I received several emails with really good information, and even one email asking what I had decided on using for my mystery project. I also asked a friend of mine from U of Penn, since we had talked about a microprocessor project using the Atmel AVR when I was there. He had more advice to offer than I expected too! I would like to publicly thank all those who helped provide the input that guided me to choosing a platform.

So what did I choose you might ask? Let me start by describing my project. This is a university funded project that will be conducted by a new student to our lab. ( I am his mentor for the summer.) We’re developing a medical device that can deterministically provide analog output to an actuator based on analog input. It was my friend from Penn who helped me to realize that this analog output, which is expected to be a combination of sine waves, is really just audio output. There just so happens to be a “shield” for the Arduino board that is an mp3 player (also plays ogg among others).

I know, I’m not being really descriptive here, but everything will be revealed in due time. We’ll be working with a physical therapist to test our device, after which we expect to publish a paper on the project in an academic journal/proceedings. I will of course post that paper here when it is time. Until then, please stay posted to hear about the progress of our project. Who knows, maybe in the next week we’ll have a “hello world” demo that shows the key features we want to develop in this little device.

Kam Salisbury: Linux UFS

Thu, 17 Jun 2010 23:00:08 +0000

You can mount almost any file system from the Linux command line (bash prompt). Lets say you used to use the excellent Network Attached Storage solution, FreeNAS, which is based on FreeBSD. But now you are using Linux - how do you mount that FreeBSD partition (called slices in the BSD world) so you can copy the data over (because the Linux module for BSD type file systems is usually for Read Only use)?
Assuming you already have made a directory to mount the BSD type file system to and the BSD file system is on /dev/sda...

sudo mount -t ufs -o ro,ufstype=ufs2 /dev/sda1 /mnt/bsd

If you make a syntax mistake typing in the command, be sure to read the command's error message carefully. Usually, the mount command itself will provide feedback similar to "...type dmesg for more information." Even more command usage information is available on most Linux systems from the command line via a command such as... man mount
Take your time, read though the command usage documentation and remember to copy - not move data, so you can always try a different strategy if the operation does not work out the way you had intended.

Kam Salisbury: More website changes (sorry)

Thu, 17 Jun 2010 23:00:08 +0000

My web host (Dreamhost.com) is performing some late spring cleaning and moving my website(s) to another server(s). It is a good time for me to update many literal paths with DNS names and many other things... so... during the next week or so some (hopefully not all) of my web site images, links, content, etc may be broken. No worries OK? I will get it all straightened out.

Kam Salisbury: Add the Virtualbox Yum Repo

Thu, 17 Jun 2010 23:00:08 +0000

Many Open Source applications are adding yum repositories in addition to providing rpm downloads. Starting with revision 3.x.x, Virtualbox now has a repo file provided for easy download. Look at http://www.virtualbox.org/wiki/Linux_Downloads towards the bottom of the page.

Kam Salisbury: Linux UFS

Thu, 17 Jun 2010 16:00:15 +0000

sudo mount -t ufs -o ro,ufstype=ufs2 /dev/sda1 /mnt/bsd

Kam Salisbury: More website changes (sorry)

Thu, 17 Jun 2010 16:00:15 +0000

JonathanD: Heading North to fosscon.

Thu, 17 Jun 2010 12:10:31 +0000

Tomorrow afternoon we'll begin our drive (about 5 hours) up to fosscon along with a few others from Philadelphia. Last time we made such a trip was SELF last year (we went to CPOSC too, but we took the train) and it was quite a bit of fun.

I believe we still have room for one on our return trip only, so if you find a way to get there but not home let me know!

The conference is being opened by members of BaseKamp, located in Philadelphia. BaseKamp presents a completely different view of open source culture, going beyond free software and into free arts and culture. Just the other night they did a great session on free art session.

I'm personally looking forward to the POSSE panel, where a group of educators who have just completed a week long POSSE course (http://teachingopensource.org/index.php/POSSE_RIT) on how to use open source in their classrooms will share with everyone what they learned.

I'm also looking forward to meeting Bryan Østergaard (http://kloeri.livejournal.com/), coming all the way from Denmark to talk about how to build a developer community around a project. All in all it should be great.

If you aren't already coming, take a look at http://fosscon.org/ to see whats what, and maybe to come along.

mjd: A short bibliography of probability monads

Tue, 15 Jun 2010 15:50:00 +0000

Several people helpfully wrote to me to provide references to earlier work on probability distribution monads. Here is a summary:

Material related to Martin Erwig and Steve Kollmansberger's probability library:
- Probabilistic Functional Programming in Haskell, their 2006 paper
- the package, described in the paper, and specifically its probability distribution monad
- Some commentary on this library, by someone who doesn't put their name on their blog.
Some stuff from Dan Piponi's blog:
- "Monads, Vector Spaces and Quantum Mechanics, part I"
- and part II
Eric Kidd's blog: "What would a programming language look like if Bayes’ rule were as simple as an if statement?"

My thanks to Stephen Tetley, Gaal Yahas, and Luke Palmer for these.

I did not imagine that my idea was a new one. I arrived at it by thinking about List as a representation of non-deterministic computation. But if you think of it that way, the natural interpretation is that every list element represents an equally likely outcome, and so annotating the list elements with probabilities is the obvious next step. So the existence of the Erwig library was not a big surprise.

A little more surprising though, were the references in the Erwig paper. Specifically, the idea dates back to at least 1981; Erwig cites a paper that describes the probability monad in a pure-mathematics context.

Nobody responded to my taunting complaint about Haskell's failure to provide support a good monad of sets. It may be that this is because they all agree with me. (For example, the documentation of the Erwig package says "Unfortunately we cannot use a more efficient data structure because the key type must be of class Ord, but the Monad class does not allow constraints for result types.") But a number of years ago I said that the C++ macro processor blows goat dick. I would not have put it so strongly had I not naïvely believed that this was a universally-held opinion. But no, plenty of hapless C++ programmers wrote me indignant messages defending their macro system. So my being right is no guarantee that language partisans will not dispute with me, and the Haskell community's failure to do so in this case reflects well on them, I think.

Alex Launi: GUADEC, an interview in 5 moments

Fri, 11 Jun 2010 16:42:12 +0000

Feeling the crushing need to fit in, here are the answers to five questions from guadec.org.

Who are you and what do you do?

I am Alex Launi, I’m 22, live in South Philadelphia, PA, USA, 5’8″ (172cm) tall, and weigh 157lbs (71.2kg). I’m about to graduate from Temple University with a bachelors of science in computer science. I work on Banshee, Do, and some other random projects here and there. I’m a hardcore cyclist, and I’ll probably be spiraling into a deep depression during guadec from separation anxiety with my bike. I love modern literature, my favorite writer is either Cormac McCarthy, James Joyce, or Thomas Pynchon depending on where and when you ask me. I like philosophy, detest the “Linux is about choice” mantra, and have never successfully done a magic trick.

How did you get into GNOME?

I’ve never been inside of a gnome, I don’t think I ever will. I’ve never had a first hand gnome encounter but my impression is that they’re very short. I don’t think I could ever fit inside of one.

Why are you coming to GUADEC?

To show off my sweet summer of code work, meet people I know from the internet, meet new people who are involved with gnome, network to try and find an awesome job, travel, drink fancy beer.

In 1 sentence, describe what your most favorite recent GNOME project has been. (Doesn’t have to be yours!)

I think Telepathy is the coolest thing there is, I want to see it used everywhere, for everything (do you see this Collabora? you can hire me if you want).

Will this be your fist time visiting the Netherlands?

I’ve been to never-never land, but never the Netherlands. Unless maybe never-never land was renamed to the Netherlands in post-war partitioning.

Kyle Winfree: Response from Octave-Forge

Thu, 10 Jun 2010 11:44:11 +0000

I’ve been meaning to make this post for a few days now, which speaks of how busy I am with qualifying exams and my university research project. I received an email from one of the octave-forge developers. He has asked that I make several changes (all good things I hadn’t thought of with my limited programming experience), and then resubmit. I plan to make an hour or two next week to do just that.

Kyle Winfree: Blogger Relocation Program

Thu, 27 May 2010 14:50:47 +0000

It’s simple really. I figured that I might as well just host my own blog. So thank you to wordpress.com, but I’ll be using your software on my own hardware now.

Richard Freeman: rich0

Wed, 26 May 2010 13:53:06 +0000

I love what Google has been doing, and they’ve made huge contributions to FOSS. However, I have to join the chorus of those who are concerned with their lack of distro-friendliness.

The start of my saga was Gentoo bug 320407. Apparently Google re-bundled swt in their android SDK, and the version they re-bundled breaks sometimes.

So, the solution is to not install swt, and patch their android script so that it uses the system library. I still have to figure out which version of swt they re-bundled so that I can try to match it. Maybe that won’t be much work.

Then I need to look at all those other libraries and see which of those can go. I’ll need to patch in their paths, and I’ll need to figure out which upstream versions they re-bundled so that I can set the correct dependencies. Maybe each of those won’t be much work. Maybe some poor user will get burned when it turns out that they modified one of them and I miss it in testing.

Oh, and every time they do a new release they’re not going to tell me if they upgraded one of those bundled libs to a newer API/etc, so maybe if I’m lucky I’ll spot problems during testing and not burn users. Maybe that isn’t too much work either.

Maybe each of these things won’t be much work, but this is already sounding like a royal pain to me. It is also a recipe for end-user problems.

Let me pick my next favorite Google package – chromium. I have a chromium upgrade pending that I’ve been postponing. Building and installing chromium takes hours on my system (an old Athlon 64 3200+). Actually, building chromium probably isn’t the problem – it is building the other half-gigabyte of re-bundled dependencies that get rebuilt every time I upgrade chromium, even though I already have most of them on my system (and if I didn’t the package manager would take care of that for me – ONCE).

My hat is off to the chromium maintainers because they’ve done a good job managing it, and I understand that they’re trying to strip out the embedded libs. However, the project facing them makes my android headaches seem like a trifle.

Google – just use and list dependencies! If you want to have an alternate all-in-one package for those without package managers, feel free – other projects do it. However, if Mozilla can play nice with distros, you can do it too.

All that said, I have no objections to embedding contributed libraries in the sdk itself – the part used to build and test android apps. In this case app developers need to build and test their apps against the libraries that will be on target devices and not their development workstation. Since no code will run natively (except perhaps on an emulator) there aren’t really the usual compatibility and security issues associated with this.

Filed under: gentoo

Alex Launi: This SOC project is dedicated to Morrissey

Tue, 25 May 2010 00:33:45 +0000

Today is the summer of code start day, and like every other excited summer of code student, I got drunk instead of working! I had a 6 pack of Magic hat, and now I have a mockup of what the now playing source will look like af the end of my project. The biggest difference between the final product and this, is that the final product will actually work.

Notice the buttons in the top right? Clicking will change the now playing source contents to last.fm, wikipedia, or back to your regularly scheduled programming. Pretty nifty right? If you’re interested, you can follow my work in written form here, or here (literally here, because I’ll be blogging about it), or in code form over here. You can actually already check out what I have so far, which is what you see above. It’s not that cool yet so I wouldn’t bother, but it’s going to get cool- so I would bother.

That’s all for today! And happy (belated) birthday Morrissey, you’re a cool 51 this year.

Kyle Winfree: FFT Plot

Sat, 22 May 2010 01:15:29 +0000

I think I have another idea; one for a function near and dear to my heart, fft analysis of audio.

Alex Launi: Im going to GUADEC

Fri, 21 May 2010 19:35:15 +0000

Thanks to the folks on the GNOME travel committee I can now say

Thanks!! I can’t wait!

yonkeltron: Creating a Ruby DSL

Fri, 14 May 2010 13:27:09 +0000

Tons of people in the Ruby community go on and on about domain-specific languages (abbreviated DSL) and how wonderful they are. In most cases, I agree with them. I began to wonder how I could go about leveraging Ruby’s awesomely-flexible syntax to create my own DSL. To illustrate my quest, I have written this article. It assumes you know Ruby. The example details are completely fictitious and just contrived enough to be interesting. I promise, the code will be the main focus and I will link/point to other resources which might be helpful to budding DSL designers like myself.

Problem

The Dream Castle Architectural Firm (D-CAF, among friends) wants a tool which it can use for very high-level prototyping of custom homes. They need it to be understandable by both computers and humans. It only needs to keep track of the following things:

Houses – Each house has a name
Floors – Each house has multiple floors. Each floor has a number
Rooms – Each floor has multiple rooms and each room has a type

The only other requirement is that the DSL be translatable to plain English so that they can show it to customers. No problem.

Solution

The DSL for the high-level specification of custom houses will look like the following:

CustomHouse.build :home do
  floor(1) {
    room :den
    room :kitchen
  }

  floor(2) {
    room :bedroom
    room :bathroom
  }
end

That’s it. You specify that a house should be built, that it has a name, some floors and each floor has some rooms. Simple, easy and 100% pure Ruby. Notice the cunning usage of both do/end and bracket notation for defining blocks. The outer block passed to CustomHouse#build uses do/end syntax while the blocks passed to House#floor use the bracket syntax. These could easily be reversed (or combined or whatever) but it makes it look pretty and helps to visually differentiate things so that you (the developer) and the user (the architect) can things more clearly. Plus, when you print the output (calling to_s on the instance of House which gets returned), you get the following wonderful text:

House named home has 2 floors.
Floor 1 has 2 rooms (den, kitchen)
Floor 2 has 2 rooms (bedroom, bathroom)

It’s a small house, don’t be a wiseacre. So, how can such a DSL be built?

Implementation

Let’s write the implementation for this together. First, we’re going to start of with a module named CustomHouse. In Ruby, modules are just classes so we’ll define a class method called build which will behave like a factory method.

module CustomHouse
  def self.build(name, &block)
    house = House.new(name)
    house.instance_eval(&block)
    return house
  end
end

As you can see, the method takes two params, a name and a block. The first thing that it does is create an instance of the House class (which we have not yet defined) passing in the name parameter. Second it calls instance_eval on the house passing in the block. This ventures into the territory of metaprogramming which is great fun but beyond the scope of this document, though I am sure others have used it for DSL construction (coincidentally, if you are interested in Ruby metaprogramming, buy this book). Suffice it to say that it executes the supplied block in the context of the House instance. Finally, the CustomHouse#build method returns the instance of House.

(There are those who believe that *any* type of eval is fundamentally evil. I have been taught this many times and I try to avoid using eval on an actualy string whenever possible. Still, someone with a better understanding of Ruby internals might be able to better explain if this in any better.)

Next, let’s define what the code for the House class looks like. As a note, it will be defined in the CustomHouse module, technically making the fully-namespaced name of the class CustomHouse::House.

class House
  attr_accessor :name, :floors

  def initialize(name = '')
    @name = name.to_s
    @floors = []
  end

  def floor(number, &block)
    fl = Floor.new(number)
    fl.instance_eval(&block)
    @floors < < fl
  end

  def to_s
    str = "House named #{@name} has #{@floors.length} floors.\n"
    @floors.each do |f|
      str << f.to_s
    end
    str
  end
end

The above code should appear relatively simple. The House class has only a few methods. First, it has a constructor function which takes a name and a block, setting the name as an instance variable and another instance variable, @floors, which is just an empty array. Next, it has a method called floor which takes a number and a block. The guts of this method should look familiar to you because it mimics almost exactly the build factory method defined on CustomHouse. Finally, it has a to_s method because of the requirement that the DSL be translatable to plain English for clients to check out.

If we can just dwell for a moment on the floor method, notice that, it too, takes a block and uses instance_eval. It then adds the newly-constructed instance of Floor to the array in @floor. Let’s look at the Floor class now.

class Floor
  attr_accessor :number, :rooms

  def initialize(number = 0)
    @number = number
    @rooms = []
  end

  def room(type)
    @rooms < < Room.new(type)
  end

  def to_s
    str = "Floor #{@number} has #{@rooms.length} rooms ("
    @rooms.each do |r|
      str += "#{r.type}, "
    end
    str.chop!.chop!
    str += ")\n"
    str
  end
end

There shouldn’t be anything confusing about the above code as it doesn’t use any sort of block eval. In fact, the only thing left to look at is the class for Room which is even less impressive.

class Room
  attr_reader :type

  def initialize(type)
    @type = type
  end
end

That’s it. Seriously, that’s the entire implementation of the DSL. You pass a block to CustomHouse#build which gets executed in the context of a new instance of House. The block calls the House#floor method with a block which in turn gets executed in the context of a new instance of Floor. The Floor#room method adds new Room instances to the class and that’s basically it.

Here’s all the code together with the example:

module CustomHouse

  def self.build(name, &block)
    house = House.new(name)
    house.instance_eval(&block)
    return house
  end

  class House
    attr_accessor :name, :floors

    def initialize(name = '')
      @name = name.to_s
      @floors = []
    end

    def floor(number, &block)
      fl = Floor.new(number)
      fl.instance_eval(&block)
      @floors << fl
    end

    def to_s
      str = "House named #{@name} has #{@floors.length} floors.\n"
      @floors.each do |f|
        str << f.to_s
      end
      str
    end
  end

  class Floor
    attr_accessor :number, :rooms

    def initialize(number = 0)
      @number = number
      @rooms = []
    end

    def room(type)
      @rooms << Room.new(type)
    end

    def to_s
      str = "Floor #{@number} has #{@rooms.length} rooms ("
      @rooms.each do |r|
        str += "#{r.type}, "
      end
      str.chop!.chop!
      str += ")\n"
      str
    end
  end

  class Room
    attr_reader :type

    def initialize(type)
      @type = type
    end
  end
end

h = CustomHouse.build :home do
  floor(1) {
    room :den
    room :kitchen
  }

  floor(2) {
    room :bedroom
    room :bathroom
  }
end

puts h

Try running it and see what happens! Then try writing other definitions for custom houses and experience the theoretical joy of the hypothetical architectural firm.

DSL construction techniques

For clarification and context, I’d like to share some other, smaller examples which build on this technique and demonstrate one more.

Behold, a DSL for feeding Pandas:

Panda.feed {
  nom :bamboo
  nom :chocolate
}

The implementation of this is both simple and straightforward.

class Panda
  def self.feed(&block)
    panda = Panda.new
    panda.instance_eval(&block)
  end

  def nom(food)
    #whatever
  end
end

Since the block is evaluated in the context of the new Panda instance, it has access to the Panda#nom method. For people deathly afraid of eval, there is this alternative syntax:

Panda.feed do |p|
  p.nom :bamboo
  p.nom :chocolate
end

Which is implemented with yield instead of instance_eval like so:

class Panda
  def self.feed
    yield Panda.new
  end

  def nom(food)
    # whatever
  end
end

For a wonderful and inspiring treatment of Ruby DSLs and associated patterns, see the most-excellent talk on the matter given by Jeremy McAnally at the 2009 Mid West Ruby Conference.

Conclusion

DSLs are a fantastic tool which can help to simplify complicated and repetitive tasks. Ruby is very good for creating DSLs but it is not the only good tool out there. I advise you look into the creation of DSLs with Scala and, the best DSL-creation tool there ever was, Lisp Macros.

I am interested in improving this tutorial for the benefit of those programmers who wish to learn about DSL construction but don’t know where to start.

Alex Launi: GSOC Weekly Report Week 1

Wed, 12 May 2010 16:46:28 +0000

No news! Exams at my school aren’t over yet, so I’m still studying and wrapping up loose ends. It turns out I’ll be graduating in August instead of in January like I expected, but I’ll also be taking one class over the summer to finish up my degree. What class am I taking? I’m taking a class about the geology of disaster movies. Sounds awesome, right?

Tomorrow is the last day of exams so 5/13 is GSOC GO DAY. Sweet! We’re in the community bonding period now, and lucky me- I’m already pretty familiar with the Banshee community. Can’t wait to get started and be finished with finals.

yonkeltron: Continuity Control presents at Finovate

Tue, 11 May 2010 21:46:52 +0000

Pleased to say that Continuity Control has gotten some rather positive feedback while presenting at this year’s Finovate! While not the only feedback, some of my favorites here:

Tweets: one – two – three – four – five

Photos: one – two

Truly proud of be part of the team.

Tharun Kumar Allu: Heartbeat on CentOS

noreply@blogger.com (Tharun) — Wed, 05 May 2010 11:33:50 +0000

When you try to install heartbeat using yum when the dependencies are not installed you get the following error.


yum -y install heartbeat

useradd: user hacluster exists
error: %pre(heartbeat-2.1.3-3.el5.centos.x86_64) scriptlet failed, exit status 9
error:   install: %pre scriptlet failed (2), skipping heartbeat-2.1.3-3.el5.centos

Due to this error heartbeat is not installed.

A simple fix is install heartbeat again using yum and that should solve the problem until someone upstream fixes the installer.

Alex Launi: Im a Google Summer of Code Student!

Mon, 26 Apr 2010 21:21:51 +0000

Today Google made the announcement of accepted summer of code proposals! I’m one of them! Looks like I’ll be spending my summer hacking on Banshee instead of driving a forklift, serving coffee, washing dishes, or any of the other jobs I’ve been seeing on craigslist. What will I be doing? Here’s a copy of the proposal I submitted.

The Now Playing source is an underutilized component of the Banshee user interface. The goal of this proposal is to extend that interface to be a source for extended information about the currently playing media. After the completion of this project, the Now Playing source will replace (or augment) the current behavior of the Context Pane, but also be extended to account for other types of media such as podcasts, videos, audio books, and internet radio.

The current implementation of the context pane is cool, but its location is awkward. It’s in the library, but displays information related to the currently playing media, and is only be relevant for music, not video or podcasts so when you’re listening to a podcast it just says “waiting for playback to begin…” Wait what? Playback has begun!

The now playing source as is, is kind of a waste of some really great space. The album art display is beautiful looking, but it’s static. If you’re listening to an album there’s no information there that isn’t available elsewhere more conveniently. The text displayed is the same. This area is perfect for displaying extra information about the currently playing song such as lyrics, last.fm similar artist information, or information from wikipedia, as well as OpenVZ visualizations, all of which should be toggleable.

My project will be to add API to the context sources so that they can be viewed for any media type to which they are relevant, add API to the now playing source to allow context sources to display their content there, create a widget to allow changing what context source is being viewed, and tie it all together into an extremely compelling, and immersive user experience.

Special thanks to Gnome, Google, Banshee, and alexk! I’m really excited, this is going to be a great summer. Stay tuned for updates!

yonkeltron: Debian package state backup and restore

Mon, 19 Apr 2010 16:24:32 +0000

While getting into bundler (which is great, btw), I recalled how often I have longed for a way to do something similar in Debian. What I’d really like to be able to do is something like aptitude backup and get some sort of backup file which contained all of the packages I had asked to be installed so that I could install a new base system and then do an aptitude restore and have those packages be installed. Obviously, this would pull in the required dependencies which is what we wanted anyway. I’ve seen only a few attempts at this and most are pretty hairy. Is there a good way to do this currently? Are there plans for this in the future? Is this an irrational desire?

Tharun Kumar Allu: EPEL - FedoraProject

noreply@blogger.com (Tharun) — Fri, 16 Apr 2010 11:05:43 +0000

EPEL - FedoraProject

Very Good resource for yum based installation of packages not available from the Main repository.

yonkeltron: Building shared libraries

Fri, 09 Apr 2010 14:43:22 +0000

Being a Debian user, I don’t make a habit of compiling things by hand and on those occasions when I do need to do so, I usually use apt-build (good article, though a bit old here). However, today I had to get a particularly odd shared library with a very specific version to match a production environment we have at work. So, I downloaded the tarball, which was quite large, and then compiled it. Which took four and a half minutes on my dual-core (1.83GHz) ThinkPad running make -j 4 which isn’t all that slow, really.

Once it was completed, I looked around (grepped around) for the output file and was dismayed to discover that there weren’t any. After tinkering around for about an hour, I finally figured out that you can request shared libraries be built by providing an option to the configure script:

./configure --enable-shared

Shortly thereafter, I got the shared library version I needed and was on the road again. Just a useful tip which I hope can be of help to someone.

Richard Freeman: rich0

Fri, 02 Apr 2010 14:41:57 +0000

I’ve been beginning to tinker with Amazon EC2 and I figured that many might benefit from a Gentoo-from-scratch recipe. There aren’t too many gotchas. Credit is due to this blog for providing a good non-Gentoo-specific overview.

Before trying any of this, you need to be at least a little familiar with EC2. They have a great getting started walkthrough here. Once you know how to start instances and connect to them you’re halfway there. You’ll also need to set up an S3 account and have an access key and secret key to store your images. On your gentoo box install ec2-ami-tools and ec2-api tools.

The biggest issue we’re going to have to deal with is that you can’t supply your own kernel. The two issues this creates are udev compatibility and kernel modules. The former is dealt with by setting package.mask, and the latter by hunting down module tarballs online. The modules are fairly optional unless you want to bundle a running image (this requires loop support, which isn’t built in the EC2 kernel).

You might be tempted to start from an existing EC2 AMI. If you find a good one, that isn’t a bad idea, but most of them are VERY out of date. Updating a gentoo install with a pre-EAPI portage and glibc/gcc versions that aren’t even in the tree any longer will be painful. Creating one from scratch isn’t actually that hard.

So, without further ado, here is the recipe (the steps generally follow the Gentoo handbook, so be sure to follow along in that):

Get yourself a stage3 and portage snapshot per the handbook. x86 or amd64 is fine, but be sure to check the Amazon EC2 product page to see which of their offerings are 32/64-bit. This guide is written for 64-bit.
Create yourself a disk image with dd if=/dev/zero of=image.fs bs=1M count=5000 – feel free to tailor the size to your needs but mind the EC2 root filesystem limitations unless you want to run it on elastic storage. The uploaded image will be compressed so you won’t be paying for any unused space in your image.
Point a loopback at your image, format it with a supported filesystem of your choice, and mount it.
Extract the stage3 into your mount. Extract your portage snapshot as well.
Tailor your make.conf as desired – set mirrors/etc. Copy your resolv.conf so that you can chroot.
Mount /proc and /dev per the handbook. If you’re going to install screen bind mount /dev/pts as well.
Chroot into your new environment. Env-update and source /etc/profile. Do an emerge –sync.
Select a profile. Honestly, for most EC2 applications you’re going to want the default 10.0 profile, but it is up to you.
Edit your locales and run locale-gen – sooner or later you’re going to have to update glibc so no sense taking all day to do it.
Set your timezone – I believe EC2 uses GMT but let me know if I’m wrong on that.
Set up your fstab (this is for 64-bit – see the EC2 docs for more details):
/dev/sda1 / ext3 defaults 1 1 /dev/sdb /mnt ext3 defaults 0 0 none /dev/pts devpts gid=5,mode=620 0 0 none /dev/shm tmpfs defaults 0 0 none /proc proc defaults 0 0 none /sys sysfs defaults 0 0
Set net.eth0 to start in the default runlevel
Set a root password. Create and properly set permissions on /root/.ssh/authorized_keys and put anything appropriate in there.
Emerge and set to run syslog-ng.
If you need cron install the cron daemon of your choice. Keep in mind that EC2 instances are volatile so cron is probably less useful than it normally would be.
Add >=sys-fs/udev-125 to your package.mask file.
Populate your world file. A dhcp client like dhcpcd is essential, everything else here is optional:
app-admin/ec2-ami-tools app-admin/ec2-api-tools app-admin/syslog-ng app-editors/vim app-misc/screen app-portage/cfg-update net-misc/dhcpcd sys-process/atop
Do an emerge -au world to install your software, it will downgrade udev and this is a good thing.
Update all your .config files
Remove any unnecessary tarballs, configure user accounts if needed, and do any application setup based upon the purpose of your system.
Add the following to your local.start (credits to whoever created the ami I ripped this out of – I’ll be happy to post them if you identify yourself – as far as I can tell ami owners can’t be identified):
[ ! -e /root ] && cp -r /etc/skel /root if [ ! -d /root/.ssh ] ; then mkdir -p /root/.ssh chmod 700 /root/.ssh fi curl http://169.254.169.254/2008-02-01//meta-data/public-keys/0/openssh-key > /tmp/my-key if [ $? -eq 0 ] ; then cat /tmp/my-key >> /root/.ssh/authorized_keys chmod 600 /root/.ssh/authorized_keys rm /tmp/my-key fi killall nash-hotplug
Configure sshd to run at startup, and edit your sshd config to allow root to login.
Exit your chroot, umount anything mounted inside of it.
Clean up tmp, var/tmp, and usr/portage/distfiles, and any other messes you have made. I suspect that to compress the image fully you probably need to zero the free space (dd if=/dev/zero of=file-inside-filesystem BS=1M count=5000 ; rm file-inside-filesystem).
Umount your image and delete any loops you created. Congratulations, you now have a raw image file suitable for EC2. Now we just need to bundle, upload, and register it.
Bundle your image with:
mkdir out ec2-bundle-image --image path-to-image --prefix give-it-a-name --cert path-to-cert-file --privatekey path-to-pk-file --user youramazonaccountnumber --destination out/ --arch x86_64
Upload your image with:
ec2-upload-bundle --manifest out/prefix.manifest.xml --bucket S3-bucket-name --access-key S3accesskeyhere --secret-key S3secretkeyhere
Register your image with:
ec2-register S3-bucket-name/prefix.manifest.xml

Congratulations, you now have what should be a working ami. If you ever need to update it you can just chroot into your image, adjust it, and then re-bundle, upload, and register. If you need to delete an ami there is a command that will do it, but I usually just use s3cmd.

You might want to see my updated guide on building with a custom kernel.

Filed under: gentoo

Alex Launi: Wait, am I nuts? Does anyone else miss the Karmic messaging menu icon?

Fri, 02 Apr 2010 01:56:33 +0000

Am I the only one who thinks that the icon for the messaging menu in its default no messages waiting state was infinitely better looking in Karmic?

Is it just me or does that icon not match the others at all. The colors are off, the weight is different, it even looks like it’s a different size. Now the old default, no-messages icon was so much closer to perfect-

See how the icon is the same fill color as the panel? If it had the same color, but bold lines as the others with this fill style- it would look incredible!

That said, everything else in Lucid rules! Best release ever, I know we say that every time, but it’s always true!

Alex Launi: HELP! Does anyone know how to export properties with python-dbus??

Tue, 30 Mar 2010 20:36:09 +0000

268/365 - Default State (C) Helga Weber 2009

I need help! I need to know if it’s possible to export properties over dbus with python-dbus, and how to do so! I’ve been Googling for hours, emailed dbus-list (which by the way admins LET MY EMAIL THROUGH THE QUEUE!), read the python-dbus tutorial, tried to find applications that do this, asked on irc and have found nothing. There has to be someone out there who knows a) whether or not this is possible and if a: then how to do it! So please, if you’re a python-dbus guru, a neophyte who just happens to know this, or some sort of crystal eating psychic who can tap into a collective consciousness and find this information out, PLEASE leave a comment, email me, find me on irc (lamalex on gimpnet and freenode), come to my house (in south philly- i’ll feed you), call my cellphone, or transmit the information to me telepathically.

Thank you to the prophet who can uncover this age old mystery.

Alex Launi: Bringing Banshees hardware into 2003!

Sat, 27 Mar 2010 06:02:54 +0000

Just wanted to show off this money shot of Banshee loading an Audio CD sans HAL, doing it raw with gio/udev. I don’t have audio players working yet, but I’m fairly confident that it’s just a matter of getting a firmer grasp on some of the more subtle aspects of Banshee’s hardware class hierarchy. If anyone wants to help, the code lives in git at http://gitorious.org/~lamalex/banshee/lamalex-udev in master. I’m a little bit concerned that iPod support will take even longer due to one of the libraries Banshee uses for iPod support, podsleuth, being very HAL dependent. My plan is to at least get everything else working before I attempt open up that can of worms. Less talk, more rock! Pics or gtfo.

mjd: A monad for probability and provenance

Fri, 26 Mar 2010 14:41:00 +0000

I don't quite remember how I arrived at this, but it occurred to me last week that probability distributions form a monad. This is the first time I've invented a new monad that I hadn't seen before; then I implemented it and it behaved pretty much the way I thought it would. So I feel like I've finally arrived, monadwise.

Suppose a monad value represents all the possible outcomes of an event, each with a probability of occurrence. For concreteness, let's suppose all our probability distributions are discrete. Then we might have:

	data ProbDist p a = ProbDist [(a,p)] deriving (Eq, Show)
	unpd (ProbDist ps) = ps

Each a is an outcome, and each p is the probability of that outcome occurring. For example, biased and unbiased coins:

    unbiasedCoin = ProbDist [ ("heads", 0.5),
                              ("tails", 0.5) ];

    biasedCoin   = ProbDist [ ("heads", 0.6),
                              ("tails", 0.4) ];

Or a couple of simple functions for making dice:

    import Data.Ratio

    d sides = ProbDist [(i, 1 % sides) | i - [1 .. sides]]
    die = d 6

d n is an n-sided die.

The Functor instance is straightforward:

    instance Functor (ProbDist p) where
      fmap f (ProbDist pas) = ProbDist $ map (\(a,p) -> (f a, p)) pas

The Monad instance requires return and >>=. The return function merely takes an event and turns it into a distribution where that event occurs with probability 1. I find join easier to think about than >>=. The join function takes a nested distribution, where each outcome of the outer distribution specifies an inner distribution for the actual events, and collapses it into a regular, overall distribution. For example, suppose you put a biased coin and an unbiased coin in a bag, then pull one out and flip it:

	  bag :: ProbDist Double (ProbDist Double String)
	  bag = ProbDist [ (biasedCoin, 0.5),
                           (unbiasedCoin, 0.5) ]

The join operator collapses this into a single ProbDist Double String:

	ProbDist [("heads",0.3),
                  ("tails",0.2),
                  ("heads",0.25),
                  ("tails",0.25)]

It would be nice if join could combine the duplicate heads into a single ("heads", 0.55) entry. But that would force an Eq a constraint on the event type, which isn't allowed, because (>>=) must work for all data types, not just for instances of Eq. This is a problem with Haskell, not with the monad itself. It's the same problem that prevents one from making a good set monad in Haskell, even though categorially sets are a perfectly good monad. (The return function constructs singletons, and the join function is simply set union.) Maybe in the next language.

Perhaps someone else will find the >>= operator easier to understand than join? I don't know. Anyway, it's simple enough to derive once you understand join; here's the code:

	instance (Num p) => Monad (ProbDist p) where
	  return a = ProbDist [(a, 1)]
	  (ProbDist pas) >>= f = ProbDist $ do
				   (a, p) <- pas
				   let (ProbDist pbs) = f a
				   (b, q) <- pbs
				   return (b, p*q)

So now we can do some straightforward experiments:

	liftM2 (+) (d 6) (d 6)

	ProbDist [(2,1 % 36),(3,1 % 36),(4,1 % 36),(5,1 % 36),(6,1 %
	36),(7,1 % 36),(3,1 % 36),(4,1 % 36),(5,1 % 36),(6,1 %
	36),(7,1 % 36),(8,1 % 36),(4,1 % 36),(5,1 % 36),(6,1 %
	36),(7,1 % 36),(8,1 % 36),(9,1 % 36),(5,1 % 36),(6,1 %
	36),(7,1 % 36),(8,1 % 36),(9,1 % 36),(10,1 % 36),(6,1 %
	36),(7,1 % 36),(8,1 % 36),(9,1 % 36),(10,1 % 36),(11,1 %
	36),(7,1 % 36),(8,1 % 36),(9,1 % 36),(10,1 % 36),(11,1 %
	36),(12,1 % 36)]

This is nasty-looking; we really need to merge the multiple listings of the same event. Here is a function to do that:

        agglomerate :: (Num p, Eq b) => (a -> b) -> ProbDist p a -> ProbDist p b
        agglomerate f pd = ProbDist $ foldr insert [] (unpd (fmap f pd)) where
          insert (k, p) [] = [(k, p)]
          insert (k, p) ((k', p'):kps) | k == k' = (k, p+p'):kps
                                       | otherwise = (k', p'):(insert (k,p) kps)


        agg :: (Num p, Eq a) => ProbDist p a -> ProbDist p a
        agg = agglomerate id

Then agg $ liftM2 (+) (d 6) (d 6) produces:

        ProbDist [(12,1 % 36),(11,1 % 18),(10,1 % 12),(9,1 % 9),
                  (8,5 % 36),(7,1 % 6),(6,5 % 36),(5,1 % 9),
                  (4,1 % 12),(3,1 % 18),(2,1 % 36)]

Hey, that's correct.

There must be a shorter way to write insert. It really bothers me, because it looks look it should be possible to do it as a fold. But I couldn't make it look any better.

You are not limited to calculating probabilities. The monad actually will count things. For example, let us throw three dice and count how many ways there are to throw various numbers of sixes:

        eq6 n = if n == 6 then 1 else 0
        agg $ liftM3 (\a b c -> eq6 a + eq6 b + eq6 c) die die die

      ProbDist [(3,1),(2,15),(1,75),(0,125)]

There is one way to throw three sixes, 15 ways to throw two sixes, 75 ways to throw one six, and 125 ways to throw no sixes. So ProbDist is a misnomer.

It's easy to convert counts to probabilities:

	probMap :: (p -> q) -> ProbDist p a -> ProbDist q a
	probMap f (ProbDist pds) = ProbDist $ (map (\(a,p) -> (a, f p))) pds

	normalize :: (Fractional p) => ProbDist p a -> ProbDist p a
	normalize pd@(ProbDist pas) = probMap (/ total) pd where
	    total = sum . (map snd) $ pas

        normalize $ agg $ probMap toRational $ 
               liftM3 (\a b c -> eq6 a + eq6 b + eq6 c) die die die

      ProbDist [(3,1 % 216),(2,5 % 72),(1,25 % 72),(0,125 % 216)]

I think this is the first time I've gotten to write die die die in a computer program.

The do notation is very nice. Here we calculate the distribution where we roll four dice and discard the smallest:

        stat = do
                 a <- d 6
                 b <- d 6
                 c <- d 6
                 d <- d 6
                 return (a+b+c+d - minimum [a,b,c,d])

        probMap fromRational $ agg stat

	ProbDist [(18,1.6203703703703703e-2),
                  (17,4.1666666666666664e-2), (16,7.253086419753087e-2),
                  (15,0.10108024691358025),   (14,0.12345679012345678),
                  (13,0.13271604938271606),   (12,0.12885802469135801),
                  (11,0.11419753086419752),   (10,9.41358024691358e-2),
                   (9,7.021604938271606e-2),   (8,4.7839506172839504e-2),
                   (7,2.9320987654320986e-2),  (6,1.6203703703703703e-2),
                   (5,7.716049382716049e-3),   (4,3.0864197530864196e-3),
                   (3,7.716049382716049e-4)]

One thing I was hoping to get didn't work out. I had this idea that I'd be able to calculate the outcome of a game of craps like this:

	dice = liftM2 (+) (d 6) (d 6)

	point n = do
	  roll <- dice
	  case roll of 7 -> return "lose"
                       _ | roll == n  = "win"
                       _ | otherwise  = point n

        craps = do
          roll <- dice
          case roll of 2 -> return "lose"
                       3 -> return "lose"
                       4 -> point 4
                       5 -> point 5
                       6 -> point 6
                       7 -> return "win"
                       8 -> point 8
                       9 -> point 9
                       10 -> point 10
                       11 -> return "win"
                       12 -> return "lose"

This doesn't work at all; point is an infinite loop because the first value of dice, namely 2, causes a recursive call. I might be able to do something about this, but I'll have to think about it more.

It also occurred to me that the use of * in the definition of >>= / join could be generalized. A couple of years back I mentioned a paper of Green, Karvounarakis, and Tannen that discusses "provenance semirings". The idea is that each item in a database is annotated with some "provenance" information about why it is there, and you want to calculate the provenance for items in tables that are computed from table joins. My earlier explanation is here.

One special case of provenance information is that the provenances are probabilities that the database information is correct, and then the probabilities are calculated correctly for the joins, by multiplication and addition of probabilities. But in the general case the provenances are opaque symbols, and the multiplication and addition construct regular expressions over these symbols. One could generalize ProbDist similarly, and the ProbDist monad (even more of a misnomer this time) would calculate the provenance automatically. It occurs to me now that there's probably a natural way to view a database table join as a sort of Kleisli composition, but this article has gone on too long already.

Happy new year, everyone.

[ Addendum 20100103: unsurprisingly, this is not a new idea. Several readers wrote in with references to previous discussion of this monad, and related monads. It turns out that the idea goes back at least to 1981. ]

My thanks to Graham Hunter for his donation.

mjd: Monads are like burritos

Fri, 26 Mar 2010 14:41:00 +0000

A few months ago Brent Yorgey complained about a certain class of tutorials which present monads by explaining how monads are like burritos.

At first I thought the choice of burritos was only a facetious reference to the peculiar and sometimes strained analogies these tutorials make. But then I realized that monads are like burritos.

I will explain.

A monad is a special kind of a functor. A functor F takes each type T and maps it to a new type FT. A burrito is like a functor: it takes a type, like meat or beans, and turns it into a new type, like beef burrito or bean burrito.

A functor must also be equipped with a map function that lifts functions over the original type into functions over the new type. For example, you can add chopped jalapeños or shredded cheese to any type, like meat or beans; the lifted version of this function adds chopped jalapeños or shredded cheese to the corresponding burrito.

A monad must also possess a unit function that takes a regular value, such as a particular batch of meat, and turns it into a burrito. The unit function for burritos is obviously a tortilla.

Finally, a monad must possess a join function that takes a ridiculous burrito of burritos and turns them into a regular burrito. Here the obvious join function is to remove the outer tortilla, then unwrap the inner burritos and transfer their fillings into the outer tortilla, and throw away the inner wrappings.

The map, join, and unit functions must satisfy certain laws. For example, if B is already a burrito, and not merely a filling for a burrito, then join(unit(B)) must be the same as B. This means says that if you have a burrito, and you wrap it in a second tortilla, and then unwrap the contents into the outer tortilla, the result is the same as what you started with.

This is true because tortillas are indistinguishable.

I know you are going to point out that some tortillas have the face of Jesus. But those have been toasted, and so are unsuitable for burrito-making, and do not concern us here.

So monads are indeed like burritos.

I asked Brent if this was actually what he had in mind when he first suggested the idea of tutorials explaining monads in terms of burritos, and if everyone else had understood this right away.

But he said no, I was the lone genius.

mjd: Another short explanation of Gödel's theorem

Fri, 26 Mar 2010 14:41:00 +0000

In yesterday's article, I said:

A while back I started writing up an article titled "World's shortest explanation of Gödel's theorem". But I didn't finish it...

I went and had a look to see what was wrong with it, and to my surprise, there seemed to be hardly anything wrong with it. Perhaps I just forgot to post it. So if you disliked yesterday's brief explanation of Gödel's theorem—and many people did—you'll probably dislike this one even more. Enjoy!

A reader wrote to question my characterization of Gödel's theorem in the previous article. But I think I characterized it correctly; I said:

The only systems of mathematical axioms strong enough to prove all true statements of arithmetic, are those that are so strong that they also prove all the false statements of arithmetic.

I'm going to explain how this works.

You start by choosing some system of mathematics that has some machinery in it for making statements about things like numbers and for constructing proofs of theorems like 1+1=2. Many such systems exist. Let's call the one we have chosen M, for "mathematics".

Gödel shows that if M has enough mathematical machinery in it to actually do arithmetic, then it is possible to produce a statement S whose meaning is essentially "Statement S cannot be proved in system M."

It is not at all obvious that this is possible, or how it can be done, and I am not going to get into the details here. Gödel's contribution was seeing that it was possible to do this.

So here's S again:

S: Statement S cannot be proved in system M.

Now there are two possibilities. Either S is in fact provable in system M, or it is not. One of these must hold.

If S is provable in system M, then it is false, and so it is a false statement that can be proved in system M. M therefore proves some false statements of arithmetic.

If S is not provable in system M, then it is true, and so it is a true statement that cannot be proved in system M. M therefore fails to prove some true statements of arithmetic.

So something goes wrong with M: either it fails to prove some true statements, or else it succeeds in proving some false statements.

List of topics I deliberately omitted from this article, that mathematicians should not write to me about with corrections: Presburger arithmetic. Dialetheism. Inexhaustibility. ω-incompleteness. Non-RE sets of axioms.

Order
Godel's Theorem: An Incomplete Guide to Its Use and Abuse

with kickback
no kickback

Order
Inexhaustibility: A Non-Exhaustive Treatment

with kickback
no kickback

Well, I see now that left out the step where I go from "M proves a false statement" to "M proves all false statements". Oh well, another topic for another post.

If you liked this post, you may enjoy Torkel Franzén's books Godel's Theorem: An Incomplete Guide to Its Use and Abuse and Inexhaustibility: A Non-Exhaustive Treatment. If you disliked this post, you are even more likely to enjoy them.

Many thanks to Robert Bond for his contribution.

mjd: World's shortest explanation of Gödel's theorem

Fri, 26 Mar 2010 14:41:00 +0000

A while back I started writing up an article titled "World's shortest explanation of Gödel's theorem". But I didn't finish it, and later I encountered Raymond Smullyan's version, which is much shorter anyway. So here, shamelessly stolen from Smullyan, is the World's shortest explanation of Gödel's theorem.

We have some sort of machine that prints out statements in some sort of language. It needn't be a statement-printing machine exactly; it could be some sort of technique for taking statements and deciding if they are true. But let's think of it as a machine that prints out statements.

In particular, some of the statements that the machine might (or might not) print look like these:

`P*`x	(which means that	the machine will print x)
`NP*`x	(which means that	the machine will never print x)
`PR*`x	(which means that	the machine will print xx)
`NPR*`x	(which means that	the machine will never print xx)

For example, NPR*FOO means that the machine will never print FOOFOO. NP*FOOFOO means the same thing. So far, so good.

Now, let's consider the statement NPR*NPR*. This statement asserts that the machine will never print NPR*NPR*.

Either the machine prints NPR*NPR*, or it never prints NPR*NPR*.

If the machine prints NPR*NPR*, it has printed a false statement. But if the machine never prints NPR*NPR*, then NPR*NPR* is a true statement that the machine never prints.

So either the machine sometimes prints false statements, or there are true statements that it never prints.

So any machine that prints only true statements must fail to print some true statements.

Or conversely, any machine that prints every possible true statement must print some false statements too.

Order
5000 B.C. and Other Philosophical Fantasies

with kickback
no kickback

The proof of Gödel's theorem shows that there are statements of pure arithmetic that essentially express NPR*NPR*; the trick is to find some way to express NPR*NPR* as a statement about arithmetic, and most of the technical details (and cleverness!) of Gödel's theorem are concerned with this trick. But once the trick is done, the argument can be applied to any machine or other method for producing statements about arithmetic.

The conclusion then translates directly: any machine or method that produces statements about arithmetic either sometimes produces false statements, or else there are true statements about arithmetic that it never produces. Because if it produces something like NPR*NPR* then it is wrong, but if it fails to produce NPR*NPR*, then that is a true statement that it has failed to produce.

So any machine or other method that produces only true statements about arithmetic must fail to produce some true statements.

Hope this helps!

(This explanation appears in Smullyan's books 5000 BC and Other Philosophical Fantasies, chapter 3, section 65 (which is where I saw it) and also in The Mystery of Scheherezade.)

I gratefully acknowledge Charles Colht for his generous donation to this blog.

[ Addendum 20091214: Another article on the same topic. ]

mjd: On failing open

Fri, 26 Mar 2010 14:41:00 +0000

An axiom of security analysis is that nearly all security mechanisms must fail closed. What this means is that if there is an uncertainty about whether to grant or to deny access, the right choice is nearly always to deny access.

For example, consider a login component that accepts a username and a password and then queries a remote authentication server to find out if the password is correct. If the connection to the authentication server fails, or if the authentication server is down, the login component must decide whether to grant or deny access, in the absence of correct information from the server. The correct design is almost certainly to "fail closed", and to deny access.

I used to teach security classes, and I would point out that programs sometimes have bugs, and do the wrong thing. If your program has failed closed, and if this is a bug, then you have an irate user. The user might call you up and chew you out, or might chew you out to your boss, and they might even miss a crucial deadline because your software denied them access when it should have granted access. But these are relatively small problems. If your program has failed open, and if this is a bug, then the user might abscond with the entire payroll and flee to Brazil.

(I was once teaching one of these classes in Lisbon, and I reached the "flee to Brazil" example without having realized ahead of time that this had greater potential to offend the Portuguese than many other people. So I apologized. But my hosts very kindly told me that they would have put it the same way, and that in fact the Mayor of Lisbon had done precisely what I described a few years before. The moral of the story is to read over the slides ahead of time before giving the talk.)

But I digress. One can find many examples in the history of security that failed the wrong way.

However, the issue is on my mind because I was at a job interview a few weeks ago with giant media corporation XYZ. At the interview, we spent about an hour talking about an architectural problem they were trying to solve. XYZ operates a web site where people can watch movies and TV programs online. Thy would like to extend the service so that people who subscribe to premium cable services, such as HBO, can authenticate themselves to the web site and watch HBO programs there; HBO non-subscribers should get only free TV content. The problem in this case was that the authentication data was held on an underpowered legacy system that could serve only a small fraction of the requests that came in.

The solution was to cache the authentication data on a better system, and gather and merge change information from the slow legacy system as possible.

I observed during the discussion that this was a striking example of the rare situation in which one wants the authentication system to fail open instead of closed. For suppose one grants access that should not be granted. Then someone on the Internet gets to watch a movie or an episode of The Sopranos for free, which is not worth getting excited about and which happens a zillion times a day anyhow.

But suppose the software denies access that should have been granted. Then there is a legitimate paying customer who has paid to watch The Sopranos, and we told them no. Now they are a legitimately irate customer, which is bad, and they may call the support desk, costing XYZ Corp a significant amount of money, which is also bad. So all other things being equal, one should err on the side of lenity: when in doubt, grant access.

I would like to thank Andrew Lenards for his gift.

mjd: You think you're All That, but you're not!

Fri, 26 Mar 2010 14:41:00 +0000

I have long been interested in term rewriting systems, and one of my long-term goals is to implement the Knuth-Bendix completion algorithm, described by Knuth and Bendix in their famous paper "Word Problems in Universal Algebras". This paper grabbed my attention around 1988; I found it in an anthology edited by John Leech (of Leech lattice fame) that I was probably looking into because it also contained an enumeration by J.H. Conway of all knots with at most eleven crossings. I found the Knuth-Bendix paper very hard to read, but the examples at the end were extremely compelling. I still find the paper very hard to read, but fortunately better explanations are now available. (For example, this one by A.J.J. Dick.) One of the also-ran topics for Higher-Order Perl was a structured drawing system based on Wm Leler's "Bertrand" term-rewriting system.

So I was delighted to discover that there was a new book out called Term Rewriting and All That. The "...and All That" suffix is a reference to the tongue-in-cheek classic of British history, 1066 and All That, and promised a casual, accessible, and possibly humorous treatment.

Unfortunately the promise was not kept. The book is very good, but it is not casual or humorous. Nor is it especially accessible. It is a solid slab of term rewriting, one of those books that make me think "I would not want to drop it on my foot." That is not a bad thing; the Barendregt book is superb, an enormous superb slab of lambda calculus that you would not want to drop on your foot. But it is not titled "Lambda Calculus and All That".

So why the title? I don't know. The authors are Germans, so perhaps they don't understand the joke?

[ Addendum: There's exactly one review of this book on Amazon, and it says the same thing I do. It begins: "My main criticism of this book is its title." ]

mjd: Dijkstra was not insane

Fri, 26 Mar 2010 14:41:00 +0000

Recently, a reader on the Higher-Order Perl discussion mailing list made a remark about Edsger Dijkstra and his well-known opposition to the break construction (in Perl, last) that escapes prematurely from a loop. People often use this as an example to show that Dijkstra was excessively doctrinaire, and out of touch with the reality of programming^[1], but usually it's because they don't know what his argument was.

I wrote a response, explaining where Dijkstra was coming from, and I am very happy with how it came out, so I'm reposting it here.

The list subscriber said, in part:

On a side note, I never read anything by Dijkstra that wasn't noticeably out of touch with the reality of programming, which qualifies them as screeds to me.
And I say that as a former Pascal programmer, and as one who has read, and bought into, things like Kernighan's "Why Pascal is Not My Favorite Programming Language" and the valid rants about how some form of breaking out of a loop without having to proceed to the end is very useful, without destroying structure (except by Dijkstra's definition of structure)...

A lot of people bring up the premature-loop-exit prohibition without understanding why Dijkstra suggested it; it wasn't just that he was a tightassed Dutchman.

Dijkstra's idea was this: suppose you want to prove, mathematically, that your program does what it is supposed to do. Please, everyone, suspend your judgment of this issue for a few paragraphs, and bear with me. Let's really suppose that we want to do this.

Dijkstra's idea is that the program is essentially a concatenation of blocks, each of which is trying to accomplish something or other, and each of which does not make sense to run unless some part of the program state is set up for it ahead of time. For example, the program might be to print a sorted list of links from a web page. Then the obvious blocks are:

A: get the web page and store it in a variable
B: extract the links from the text in the variable into an array
C: sort the array
D: print out the array contents

Section C is trying to sort the array; if it is correct then the array will be sorted by the time step D commences. But it doesn't make sense to commence step C unless the array is populated. Garbage in, garbage out, as they used to say when I was in elementary school.

We say that the "precondition" for C is that the array be populated with URLs, and the "postcondition" is that the array be in sorted order. What you would want to prove about C is that if the precondition holds—that is, if the array is properly populated before C begins—then the postcondition will hold too—that is, the array will be in sorted order when C completes.

It occurs to me that calling this a "proof" is probably biasing everyone's thinking. Let's forget about mathematical proofs and just think about ordinary programmers trying to understand if the program is correct. If the intern in the next cubicle handed you his code for this program, and you were looking it over, you would probably think in very much this way: you would identify block C (maybe it's a subroutine, or maybe not) and then you would try to understand if C, given an array of URLs, would produce a properly sorted array by the time it was done.

C itself might depend on some sub-blocks or subroutines that performed sub-parts of the task; you could try to understand them similarly.

Having proved (or convinced yourself) that C will produce the postcondition "array contains sorted list of URLs", you are in an excellent position to prove (or convince yourself) that block D prints out a sorted array of URLs, which is what you want. Without that belief about C, you are building on sand; you have almost nothing to go on, and you can conclude hardly anything useful about the behavior of D.

Now consider a more complex block, one of the form:

        if (q) { E; }
        else { F; }

Suppose you believe that code E, given precondition x, is guaranteed to produce postcondition y. And suppose you believe the same thing about F. Then you can conclude the same thing about the entire if-else block: if x was true before it began executing, then y will be true when it is done.^[2] So you can build up proofs (or beliefs) about small bits of code into proofs (or beliefs) about larger ones.

We can understand while loops similarly. Suppose we know that condition p is true prior to the commencement of some loop, and that if p is true before G executes, then p will also be true when G finishes. Then what can we say about this loop?

        while (q) { G; }

We can conclude that if p was true before the loop began, then p will still be true, and q will be false, when the loop ends.

BUT BUT BUT BUT if your language has break, then that guarantee goes out the window and you can conclude nothing. Or at the very least your conclusions will become much more difficult. You can no longer treat G atomically; you have to understand its contents in detail.

So this is where Dijkstra is coming from: features like break^[3] tend to sabotage the benefits of structured programming, and prevent the programmer from understanding the program as a composition of independent units. The other subscriber made a seemingly disparaging reference to "Dijkstra's idea of structure", but I hope it is clear that it was not an arbitrary idea. Dijkstra's idea of structure is what will allow you to understand a large program as a collection of modules.

Regardless of your opinion about formal verification methods, or correctness proofs, or the practicality of omitting break from your language, it should at least be clear that Dijkstra was not being doctrinaire just for the sake of doctrine.

Some additional notes

Here are some interesting peripheral points that I left out of my main discussion because I wanted to stick to the main point, which was: "Dijkstra was not insane".

I said in an earlier post that "I often find Dijkstra's innumerable screeds very tiresome in their unkind, unforgiving, and unrealistic attitudes toward programmers." But despite this, I believe he was a brilliant thinker, and almost every time he opened his mouth it was to make a carefully-considered argument. You may not like him, and you may not agree with him, but you'll be better off listening to him.

An archive of Dijkstra's miscellaneous notes and essays (a pre-blogging blog, if you like) is maintained at the University of Texas. I recommend it.
I said:
```
                if (q) { E; }
                else { F; }
```
Suppose you believe that code E, given precondition x, is guaranteed to produce postcondition y. And suppose you believe the same thing about F. Then you can conclude the same thing about the entire if-else block.
Actually, your job is slightly easier. Let's write this:

[x] E [y]
to mean that code E, given precondition x, produces postcondition y. That is, if we know that x is true when E begins execution, then we know that y is true when E finishes. Then my quoted paragraph above says that from these:

[x] E [y]
[x] F [y]
we can conclude this:

[x] if (q) {E} else {F} [y]
But actually we can make a somewhat stronger statement. We can make the same conclusion from weaker assumptions. If we believe these:
[x and q] E [y]
[x and not q] F [y]
then we can conclude this:

[x] if (q) {E} else {F} [y]
In fact this precisely expresses the complete semantics of the if-else construction. Why do we use if-else blocks anyway? This is the reason: we want to be able to write code to guarantee something like this:

[x] BLAH [y]
but we only know how to guarantee
[x and q] FOO [y]
and
[x and not q] BAR [y]
for some q. So we write two blocks of code, each of which accomplishes y under some circumstances, and use if-else to make sure that the right one is selected under the right circumstances.
Similar to break (but worse), in the presence of goto you are on very shaky ground in trying to conclude anything about whether the program is correct. Suppose you know that C is correct if its precondition (an array of URLs) is satisfied. And you know that B will set up that precondition (that is, the array) if its precondition is satisfied, so it seems like you are all right. But no, because block W somewhere else might have goto C; and transfer control to C without setting up the precondition, and then C could cause winged demons to fly out of your nose.

mjd: Gray code at the pediatrician's office

Fri, 26 Mar 2010 14:41:00 +0000

Last week we took Iris to the pediatrician for a checkup, during which they weighed, measured, and inoculated her. The measuring device, which I later learned is called a stadiometer, had a bracket on a slider that went up and down on a post. Iris stood against the post and the nurse adjusted the bracket to exactly the top of her head. Then she read off Iris's height from an attached display.

How did the bracket know exactly what height to report? This was done in a way I hadn't seen before. It had a photosensor looking at the post, which was printed with this pattern:

(Click to view the other pictures I took of the post.)

The pattern is binary numerals. Each numeral is a certain fraction of a centimeter high, say 1/4 centimeter. If the sensor reads the number 433, that means that the bracket is 433/4 = 108.25 cm off the ground, and so that Iris is 108.25 cm tall.

The patterned strip in the left margin of this article is a straightforward translation of binary numerals to black and white boxes, with black representing 1 and white representing 0:

0000000000
0000000001
0000000010
0000000011
0000000100
0000000101
0000000101
...
1111101000
1111101001
...
1111111111

If you are paying attention, you will notice that although the strip at left is similar to the pattern in the doctor's office, it is not the same. That is because the numbers on the post are Gray-coded.

Gray codes solve the following problem with raw binary numbers. Suppose Iris is close to 104 = 416/4 cm tall, so that the photosensor is in the following region of the post:

...
0110100001 (417)
0110100000 (416)
0110011111 (415)
0110011110 (414)
...

But suppose that the sensor (or the post) is slightly mis-aligned, so that instead of properly reading the (416) row, it reads the first half of the (416) row and last half of the (415) row. That makes 0110111111, which is 447 = 111.75 cm, an error of almost 7.5%. (That's three inches, for my American and Burmese readers.) Or the error could go the other way: if the sensor reads the first half of the (415) and the second half of the (416) row, it will see 0110000000 = 384 = 96 cm.

Gray code is a method for encoding numbers in binary so that each numeral differs from the adjacent ones in only one position:

0000000000
0000000001
0000000011
0000000010
0000000110
0000000111
0000000101
0000000100
0000001100
...
1000011100
1000011101
...
1000000000

This is the pattern from the post, which you can also see at the right of this article.

Now suppose that the mis-aligned sensor reads part of the (416) line and part of the (417) line. With ordinary binary coding, this could result in an error of up to 7.75 cm. (And worse errors for children of other heights.) But with Gray coding no error results from the misreading:

...
0101110000 (417)
0101010000 (416)
0101010001 (415)
0101010011 (414)
...

No matter what parts of 0101110000 and 0101110001 are stitched together, the result is always either 416 or 417.

Converting from Gray code to standard binary is easy: take the binary expansion, and invert every bit that is immediately to the right of a 1 bit. For example, in 1111101000, each red bit is to the right of a 1, and so is inverted to obtain the Gray code 1000011100.

Converting back is also easy: of the Gray code. Replace every sequence of the form 1000...01 with 1111...10; also replace 1000... with 1111... if it appears at the end of the code. For example, Gray code 1000011100 contains two such sequences, 100001 and 11, which are replaced with 111110 and 10, to give 1111101000.

mjd: Haskell logo fail

Fri, 26 Mar 2010 14:41:00 +0000

The Haskell folks have chosen a new logo.

Ouch.

mjd: A child is bitten by a dog every 0.07 seconds...

Fri, 26 Mar 2010 14:41:00 +0000

I read in the newspaper today that letter carriers were bitten by dogs 3,000 times last year. (Curiously, this is not a round number; it is exact.) The article then continued: "children ... are 900 times more likely to be bitten than letter carriers."

This is obviously nonsense, because suppose the post office employs half a million letter carriers. (The actual number is actually about half that, but we are doing a back-of-the-envelope estimate of plausibility.) Then the bite rate is six bites per thousand letter carriers per year, and if children are 900 times more likely to be bitten, they are getting bitten at a rate of 5,400 bites per thousand children per year, or 5.4 bites per child. Insert your own joke here, or use the prefabricated joke framework in the title of this article.

I wrote to the reporter, who attributed the claim to the Postal Bulletin 22258 of 7 May 2009. It does indeed appear there. I am trying to track down the ultimate source, but I suspect I will not get any farther. I have discovered that the "900 times" figure appears in the Post Office's annual announcements of Dog Bite Prevention Month as far back as 2004, but not as far back as 2002.

Meantime, what are the correct numbers?

The Centers for Disease Control and Prevention have a superb on-line database of injury data. It immediately delivers the correct numbers for dog bite rate among children:

Age	Number of injuries	Population	Rate per 100,000
0	2,302	4,257,020	54.08
1	7,100	4,182,171	169.77
2	10,049	4,110,458	244.47
3	10,355	4,111,354	251.86
4	9,920	4,063,122	244.15
5	7,915	4,031,709	196.32
6	8,829	4,089,126	215.91
7	6,404	3,935,663	162.72
8	8,464	3,891,755	217.48
9	8,090	3,901,375	207.36
10	7,388	3,927,298	188.11
11	6,501	4,010,171	162.11
12	7,640	4,074,587	187.49
13	5,876	4,108,962	142.99
14	4,720	4,193,291	112.56
15	5,477	4,264,883	128.42
16	4,379	4,334,265	101.03
17	4,459	4,414,523	101.01
Total	133,560	82,361,752	162.16

According to the USPS 2008 Annual Report, in 2008 the USPS employed 211,661 city delivery carriers and 68,900 full-time rural delivery carriers, a total of 280,561. Since these 280,561 carriers received 3,000 dog bites, the rate per 100,000 carriers per year is 1069.29 bites.

So the correct statistic is not that children are 900 times more likely than carriers to be bitten, but rather that carriers are 6.6 times as likely as children to be bitten, 5.6 times if you consider only children under 13. Incidentally, your toddler's chance of being bitten in the course of a year is only about a quarter of a percent, ceteris paribus.

Where did 900 come from? I have no idea.

There are 293 times as many children as there are letter carriers, and they received a total of 44.5 times as many bites. The "900" figure is all over the Internet, despite being utterly wrong. Even with extensive searching, I was not able to find this factoid in the brochures or reports of any other reputable organization, including the American Veterinary Medical Association, the American Academy of Pediatrics, the Centers for Disease Control and Prevention, or the Humane Society of the Uniited States. It appears to be the invention of the USPS.

Also in the same newspaper, the new Indian restaurant on Baltimore avenue was advertising that they "specialize in vegetarian and non-vegetarian food". It's just a cornucopia of stupidity today, isn't it?

mjd: Periodicity

Fri, 26 Mar 2010 14:41:00 +0000

The number of crank dissertations

dealing with the effects of sunspots

on political and economic events

peaks every eleven years.

yonkeltron: HTML5 has custom data attributes

Thu, 25 Mar 2010 15:16:35 +0000

So, I know that the Microformats project has has varying degrees of success in their endeavor to embed data in HTML such that it does not violate web standards. As John Resig pointed out, others have used things like XML namespacing in XHTML to achieve similar goals. The most notable usages of this technique are most likely to be found in the applications of RDFa. However, when looking at the new unobtrusive JavaScript helpers in the forthcoming Rails 3, I was tipped off to the huge scope of the new data- attributes in HTML5. The custom data- attributes excite me.

In HTML5, including any arbitrary attribute may be included in any element provided that it is prefixed with data- and doesn’t interfere with the rest of the standard. Anything. So I can do the following and have it be perfectly valid:

<div data-panda="bamboo"> Whatever <div>

How awesome is that?

yonkeltron: Rails + Merb = Rails 3

Wed, 17 Mar 2010 16:39:49 +0000

I’m rather excited about this. Saw this talk right here.

Oh, and then there’s this.

Alex Launi: gudev-sharp is born!

Mon, 15 Mar 2010 04:57:22 +0000

In some of my spare time I’m working on modernizing Banshee’s hardware support (all the while lamenting the death of HAL). With HAL we had a nice (although monolithic) toolkit-agnostic hardware layer that was used through dbus. HAL was deprecated in favor of using udev, which is the the Kernel’s hardware event system. I’m sure udev is much nicer from an engineering point of view, but it’s certainly not as nice for application developers as a big old dbus-interface where any information about hardware could be retrieved was. Regardless of how I feel about HAL, HAL is still gone, so Banshee still needs updated to udev. Since udev is so new, no one had made C# bindings for libgudev yet, so I decided to take a stab at using GAPI to generate C# bindings. After hours of talking to myself in irc, trying to trick RAOF into doing my work for me, gudev-sharp is born! It just successfully ran the (incredibly simple) test code I wrote just to make sure it wouldn’t segfault. If you’re interested in modern hardware support via C#, help write unit tests!

I know some people are going to say “bzr? launchpad? And you want this adopted?”. It can move whenever it needs to, LP and bzr are my tools of choice, but if upstream Mono wants to move this into svn, I’d be happy to see it go.

mikegrb: Task Management with Hiveminder and Perl

Sat, 13 Mar 2010 23:08:25 +0000

This is how I manage my tasks with Hiveminder on a weekly basis and the Perl script that helps me do it. I don’t really expect the Perl script to be useful to anyone as-is but portions of it may be useful to others, as well as the general work flow, so I’ve decided to share them.

At Linode we have a wiki page where we list 5 or more tasks we wish to accomplish during the week. There is a heading for each employee and below the heading we place our tasks. Throughout the week we can add additional tasks or mark existing ones as done.

I’ve used Hiveminder for some time. When we started the weekly task lists at Linode I found that taking a few minutes to figure out which tasks I wish to complete in the coming week works quite well for me. I started marking these tasks with the ‘week’ tag in Hiveminder. I quickly ended up writing a perl script, week.pl, to help me manage hem.

My Weekly Workflow

First thing Monday morning I run:

$ week.pl report

This prints a report with two sections. The first section lists tasks that currently have the ‘week’ tag with a line through the task ID if it is completed. This gives me a nice summary of what I planned on accomplishing the previous week and how I did. The second section lists all of my tasks currently visible in Hiveminder. I hide tasks that I know I’m not going to work on in the next few weeks so this list is usually no more than 20 or 30 items.

I take this report into the Monday morning meeting with me. During the meeting, I’ll glance over this list and select items for the upcoming week. I also use this page to take notes on during the meeting, writing down any new tasks that come up in the meeting.

After the meeting, I add any new tasks generated in the meeting that I won’t be working on this week to Hiveminder.

$ todo.pl braindump

todo.pl comes from App::Todo, a command line Hiveminder interface. The braindump command launches $EDITOR where I add new tasks, one per line. The braindump syntax allows for specifying tags, setting priorities, and other things as well.

Next, I prepare the task list for the upcoming week:

$ week.pl edit
Carry over the following tasks?
bring about world peace (y or n) [default y] y
write some awesome pre
do some other cool stuff
create practical cold fusion (y or n) [default y] n
return library book

The edit command iterates over each task tagged with ‘week’ if the task is not marked completed. It prompts whether or not I wish to carry the task over to this week (leave the tag). Any tasks marked completed have the tag removed automatically.

$ week.pl add
Created:
#YRVK write an awesome report for Tom [week dev]
#YRVL test some new stuff for deployment [week admin]

The add command works the same as todo.pl’s braindump command except the ‘week’ tag is automatically applied to the newly created tasks. The full braindump syntax is available for specifying other properties of the tasks.

$ week.pl update https://path.to.trac/wiki/Tasks/2010-03-15
Sup dawg, I heard you like tasks so I did ur shit for you

The update command grabs my tasks tagged with ‘week’ and formats them one per line started with ‘ * ‘, a wiki bullet list. It grabs the current wiki page, finds my heading, substitutes the formatted task list under the heading, and submits the change. It also stores the path given in the YAML config file.

$week.pl go

This opens the stored URL for this week’s tasks wiki page in my default browser, allowing me to confirm week.pl did what it’s supposed to.

Later in the week once I’ve done something:

$ week.pl done tom
#YH7T bring about world peace [dev week]
#YRVL test some new stuff for deployment [week admin]
[DONE] #YRVK write an awesome report for Tom [week dev]

This retrieves the task(s) tagged ‘week’ that are not marked completed containing the given string. If there was only one match, the script marks it as done and then outputs the current state of tasks tagged ‘week’.

$ week.pl update
Sup dawg, I heard you like tasks so I did ur shit for you

Same as update before, except when no URL is given, the URL is read from the configuration file. This way I only need to worry about the URL once per week, the first time I update for the week.

Conclusion

So there you have it. If you are also using Hiveminder, maybe aspects of my work flow will make sense for you and pieces of the Perl script may be useful. If you aren’t using Hiveminder, maybe you will be inspired to check it out. I use michael@thegrebs.com on Hiveminder in case you feel the need to assign me a task or wish to gift me another year of Hiveminder Pro ;)

week.pl

yonkeltron: Enthusiasts talk shop casually

Mon, 08 Mar 2010 18:22:15 +0000

I spent some time with a few colleagues yesterday and came to the conclusion that true enthusiasts gravitate toward talking shop with one another. This is true even of casual situations. I’ve had plenty of “getting to know you” and “let’s just hang” social situations with other geeks where we might start out talking about any old thing but end up having an enthusiastic exchange about computers. I don’t view this is as negative. On the other hand, plenty of mailing lists and other communication media devoted to discussions of specific topics end up going “off-topic” as people socialize more generally. Fine, so it goes both ways.

It’s good to love what you love and even better to share it.

Alex Launi: Docky has been removed from Do!

Mon, 08 Mar 2010 03:00:10 +0000

Tonight I finally pushed the revisions to bzr that removed Docky from the Do source tree. For a while now Docky has been being developed as a stand alone application separate from Do. The two projects were limiting one another, so a decision was made to split them out. In the future there will be some of docky <–> do integration, but for now Docky is going to be the most kick ass Dock you’ve ever seen, and Do is going to be the most kickass launcher/everything-else-do-does you’ve ever seen.

In Ubuntu Lucid you can install Docky from the software center, otherwise the source is available at http://launchpad.net/docky. Today is the start of a new day in Do, development is going to start rolling again, and there should be a new kick ass release in the coming months. We’ve let things slide, but we’re kicking it back into gear.

Planet PLUG

Tharun Kumar Allu: Set Up an Email Gateway with CentOS Linux�5.4 � Aaron Walrath – Another IT Guy's Meanderings

Kyle Winfree: 18 miles on 1 watt

Alex Launi: Anyone want to do a couple early morning pre-guadec rides?

Kyle Winfree: Arduino SDWrite

Richard Freeman: rich0

yonkeltron: Great post about Emacs keyboard macros

Alex Launi: I need a floor in Amsterdam! Does anyone have a dutch floor??

Kyle Winfree: Arduino on Mandriva

Kyle Winfree: 100 downloads in 367 days – it sounds unimpressive, but I’m happy

Kyle Winfree: pgfplots

Kyle Winfree: Arduino and Linux Journal

yonkeltron: newhaven.rb hackfest tomorrow!

Kam Salisbury: Linked In 404

Kam Salisbury: Rate My Network Diagram

Kyle Winfree: Gramian take three!

JonathanD: fosscon... 2011?

Kyle Winfree: Arduino

Kam Salisbury: Linux UFS

Kam Salisbury: More website changes (sorry)

Kam Salisbury: Add the Virtualbox Yum Repo

Kam Salisbury: Linux UFS

Kam Salisbury: More website changes (sorry)

JonathanD: Heading North to fosscon.

mjd: A short bibliography of probability monads

Alex Launi: GUADEC, an interview in 5 moments

Kyle Winfree: Response from Octave-Forge

Kyle Winfree: Blogger Relocation Program

Richard Freeman: rich0

Alex Launi: This SOC project is dedicated to Morrissey

Kyle Winfree: FFT Plot

Alex Launi: Im going to GUADEC

yonkeltron: Creating a Ruby DSL

Alex Launi: GSOC Weekly Report Week 1

yonkeltron: Continuity Control presents at Finovate

Tharun Kumar Allu: Heartbeat on CentOS

Alex Launi: Im a Google Summer of Code Student!

yonkeltron: Debian package state backup and restore

Tharun Kumar Allu: EPEL - FedoraProject

yonkeltron: Building shared libraries

Richard Freeman: rich0

Alex Launi: Wait, am I nuts? Does anyone else miss the Karmic messaging menu icon?

Alex Launi: HELP! Does anyone know how to export properties with python-dbus??

Alex Launi: Bringing Banshees hardware into 2003!

mjd: A monad for probability and provenance

mjd: Monads are like burritos

mjd: Another short explanation of Gödel's theorem

mjd: World's shortest explanation of Gödel's theorem

mjd: On failing open

mjd: You think you're All That, but you're not!

mjd: Dijkstra was not insane

Some additional notes

Further reading

mjd: Gray code at the pediatrician's office

mjd: Haskell logo fail

mjd: A child is bitten by a dog every 0.07 seconds...

mjd: Periodicity

yonkeltron: HTML5 has custom data attributes

yonkeltron: Rails + Merb = Rails 3

Alex Launi: gudev-sharp is born!

mikegrb: Task Management with Hiveminder and Perl

My Weekly Workflow

Conclusion

yonkeltron: Enthusiasts talk shop casually

Alex Launi: Docky has been removed from Do!