A lot of people, when presented with this, intuitively think that the balloon will move towards the back, just like the ball. If they’re physics-minded, they might say that the inertia of the balloon keeps it from wanting to change its velocity unless it’s forced to, and the only thing that can force it to do so is the back of the car. But if this were true, then general relativity would be wrong! Because according to general relativity, if you don’t look outside the car window or cheat in some other way, there’s no way to tell between a uniform acceleration of 9.8 meters per second per second in the forward direction and an additional gravitational force of one G pulling you back. And when we think about it in terms of gravity, the answer becomes clear: balloons in air will move against gravitational fields, so it will move to the front of the car.

Hopefully, this has left you at least somewhat unsatisfied; the question of where the balloon moves has been answered, but not why it moves. For that question, consider why balloons move against gravitational fields. They move because of buoyancy, which is a result of the fact that pressure is greater when you go ‘deeper’ into a fluid (liquid or gas) in a gravitational field. So the upwards force as a result of pressure is greater than the downwards force, and the balloon rises until something stops it or the atmosphere gets so rarefied that it reaches zero buoyancy (or, more likely, the decreased atmospheric pressure causes it to pop!) But when you have an accelerating car, the air molecules, much like the rolling ball, will tend to ‘pile up’ in the back, causing greater pressure in the rear than in the front. And in general, this pressure gradient will be enough to cause a forward force on the balloon all the way to the front of the car.

I store my passwords in a KeePass password database, encrypted using AES using a reasonably long passphrase; I have it set to require the passphrase if the window loses focus for more than 30 seconds. I then synchronize it using Dropbox between various computers, as well as so I can download it if I’m on a new computer that I trust enough to log into stuff on. I also have my PGP private key on my laptop. Noticeably, there are several password I have that are not written down anywhere: my MIT Kerberos password, my Gmail password (most of my password reset e-mails would be sent there, so if it was compromised everything else would be too), the KeePass database password, and my Dropbox password. And of course there’s a password on my laptop, but I wouldn’t rely on that for anything beyond keeping someone from looking at my stuff while I’m temporarily out.

So what does that mean in case the laptop’s stolen? Step one is to go everywhere I know of that I can sign into using public key cryptography on this machine and delete the keys; fortunately, the only such machine at the moment is the Github remotes and my VM; I’d also force-disconnect any ssh sessions that I left open by killing the processes. After that’s done, I change my Gmail password in case I left myself logged in or cookied or something, and forcibly sign out all my other accounts using the link on the bottom. If the password’s been changed or it’s been more than a day or so since I last saw the laptop, I assume all my accounts are compromised. The third step is to backup the password database and then delete it from Dropbox; if the person who stole it isn’t smart, the next time it connects to the internet it’ll delete the local copy. Interestingly, even if I change the Dropbox password, the computer will still have access to my files; if I want to disable syncing, I have to unlink the computer it on the website (which does tell me when the last sync occurred). Then I change the password for my AOL and MSN accounts; MSN only lets you sign on from one place at a time, but AOL doesn’t, and I don’t know if it’s possible to force a logout. Finally, I’d probably revoke my public key; I know enough people who can get it signed that are in the strong set that it’s not terribly difficult to get back in there. I have a printout of my revocation certificate for just this occasion.

But Perl is old now, and I’ve mostly moved on to other languages, like Python. I like the object-orientation, the support for functional paradigms and other nice things like list comprehensions and lambda functions. I like not having to sigil all of my variables with $ or @ or %, I like being able to supply keyword arguments to my functions so that I don’t have to remember which weird order I decided to use, I like the sheer amount of fun things that you can do with object orientation combined with reflection, metaprogramming, and everything being a first-class object. And yet, I still think it’ll stick around for a while.

Why do I say that? Simple. I was talking with someone who had left in the middle of an online IRC-based role-playing game, and they had asked for chatlogs of what had happened after they left. I had them, since I run weechat in tmux (like irssi in screen, but better!) and so am in every IRC channel I’m in 24/7. But the question was: how could I pull out just the lines that were said when he left? And the answer was Perl. It turns out that the .. operator, which in a for loop or other situations where a list is expected produces a range (so (1..9) as a list produces the list (1,2,3,4,5,6,7,8,9)), does something completely different in a scalar context, like in the conditional of an if statement. Take the statement print if (/Person.*has quit/ .. /Person.*has joined/). Each time this statement is run, the conditional will evaluate to false, until the left-hand side evaluates to true. Then it’ll start evaluating to true, until the right-hand side evaluates to false, and then it’ll stop being true (but it’ll still be true until it’s evaluated again!), etc., etc. So if this is in an implicit while loop running through the lines of a file, it’ll start printing when it sees a line saying Person has quit, including that line, then stop when they rejoin, but still print that line, and then it’ll keep going until it sees another quit line, etc. And the best part is, if you call perl with -n, you automatically get a while loop that assigns the current line of the file it’s reading from to $_, the implicit variable in the matching and print.

If I wanted to do that in something like Python, I’d have to manually set up the read loop, write a function to trawl through, build up regexp objects to match on, etc. And that’s fine for a piece of code I intend to maintain. But for a quick one-line script like this? Too much effort. All I need is perl -ne.

First, it’s 16-color only, and there’s no way to change the colors. While the former can’t be helped, the latter can: if you install SIMBL, then download TerminalColors (either the Leopard version or the Snow Leopard version, whichever is appropriate), then unzip and move the resulting directory into /Library/Application Support/SIMBL/Plugins, then restart, you’ll be able to modify colors under Settings -> Text by clicking the new ‘More’ button.

Second, the Home and End keys, to put it bluntly, suck. They don’t work in most programs. The fix for this is to go to Settings -> Keyboard, then creating/editing the entry for the home key. Select ‘send string to shell’, and in the text entry field, press escape, then capital O, then capital H, so it reads \033OH. Then do the same for the end key, only this time insert \033OF. It should work pretty much everywhere. Page up is \033[5~  and page down is \033[6~.

There are a couple other things: add
alias grep="grep --color=auto"
alias rgrep="grep -r --color=auto"
alias grip="grep -i --color=auto"
alias rgrip="grep -ir --color=auto"
alias ls="ls -G"
to colorize ls and grep by default, as well as add some convenient aliases (grip for case-insensitivity, rgrep for recursive grep).

Now, one of the more little-known features of CGI is that if you pass a query string that does not contain any = signs to a CGI script, the httpd may pass the string along as command-line arguments. This is specified in section 4.4 of RFC 3875, and it specifies how the query string SHOULD be turned into arguments (although it does not say anything about whether the httpd should behave this way, only that some do). This is an example script that only outputs its arguments in a comma-separated list; the link gives it some sample arguments. Note that by URL-escaping, you can send arbitrary strings through… including +RTS. So if that were, say, a Haskell script, I could pass the query string ?%2BRTS+-tindex.html+-RTS and overwrite index.html.

There are three ways to get around this: first, GHC 6.12.2 has the -no-rtsopts option, which will obviously disable RTS options. So if you just recompile your script with that, it’ll be safe. Note that 6.14 will disable the RTS options by default; the 6.12.2 patch didn’t for backwards-compatibility reasons. Second, if you don’t want to use 6.12.2 for whatever reason, you can wrap it in a shell script that calls it with no options. For example, replace the Haskell script with a shell script called, say, hscript.cgi (if your Haskell program is called hscript) that calls it with no arguments, e.g.

and rename the Haskell script to hscript.real, so that it doesn’t get run as CGI (I’m assuming that .real files don’t get run as CGI on your machine!) Another thing you can do is to add the following to your .htaccess, which will give 403 Forbidden errors to anybody passing RTS arguments in the URL:

This will solve it for every Haskell script you use, but relies on the regex being correct, which isn’t something I can guarantee.

Second, I ignored the axes of the work you envision. So start small, and think about the free group on two generators, which is obviously highly undesirable behavior. However, it does have the web interface, I’ll have it up by last week, but that obviously didnt happen. Taking into account the fact that I’m using. The central thing that makes MS Paint Adventures unique to the point where it’s my go-to language for random programs (I still use Python for that), but if we pick two of them and rotate one of the set of all rotations that you have some custom function you want soup or salad, both is not a valid answer.

It’s my first medium-scale project written in Haskell (even though there isn’t a lot of code, what little was there was not trivial to write), and I’ve learned several lessons from it:

• The Haskell wiki is an excellent resource. When I was trying to learn how to use HXT, the Haskell XML Toolbox, I found the provided documentation somewhat inadequate. But the HXT article on the Haskell wiki is an excellent introduction to the filter abstraction, which is all that I need for the basic stuff that I’m using.
• Read the Haddock documentation. The HXT article, as useful as it was, didn’t cover a couple essential things I needed to know (such as how to pull all elements with type “application/rss+xml”). So I look at the documentation for Text.XML.HXT.Arrow.XmlArrow (the module containing the arrows that HXT uses to filter XML), and saw that hasAttrValue :: String -> (String -> Bool) -> a XmlTree XmlTree looks about right; from the type, I can guess (correctly) that I need to pass it the attribute and a prediate on the value of the attribute (i.e., hasAttrValue "href" (== "application/rss+xml")).
• One goal at a time. This isn’t specific to Haskell. When I started on this, I meant for it to require you to provide the RSS feed. Then, I realized that having a larger corpus might be better, so I added the ability to pull from multiple feeds. Then I decided that expecting people to find the RSS feed by hand might be a bit much, so I rewrote it to pull the RSS feed from the site. And I eventually plan to write a CGI frontend so that you can just run it online. If I had decided from the start to do all these things, I probably never would’ve gotten started. As Linus Torvalds said:
  

  Nobody should start to undertake a large project. You start with a small trivial project, and you should never expect it to get large. If you do, you’ll just overdesign and generally think it is more important than it likely is at that stage. Or worse, you might be scared away by the sheer size of the work you envision. So start small, and think about the details. Don’t think about some big picture and fancy design. If it doesn’t solve some fairly immediate need, it’s almost certainly over-designed.

• Strip and gzip your executables if you’re going to distribute them. Due to the fact that I’m statically linking in HXT, which is a sizeable library, the compiled, non-stripped version of dissociated-blogosphere is a whopping 12 megabytes. This isn’t due to inefficiencies in my own code, but due to the sheer size of the HXT library. Running the Unix command line utility strip (which only removes internal debugging information) cuts it down to about 5 MB, and then gzipping the binaries takes it down to a little over a megabyte.
• Split things into libraries where it’s appropriate. Part of the problem with using HXT is that it makes recompilation slow; if I could do it all over again, I might have used HaXml, but HXT has the advantage of having nontrivial amounts of documentation written about it (on the Haskell wiki). If I had instead split the RSS parsing code into its own library, I could have only recompiled those parts whenever I touched them, which wasn’t nearly as often as I touched the code frontend. Plus, it’s just good programming practice.

So what do I have planned for dissociated-blogosphere? First off, I plan to make it faster by caching RSS lookups; by storing a map from page URLs to RSS feed, I can cut the number of network requests in half. Second, I plan to implement actual error handling; right now if you give it a bad URL it fails and doesn’t produce any useful output, regardless of whether other URLs are good. Third, I’m going to split out the RSS part into its own library, which I might make its own package on hackage. Fourth, I intend to eventually write a web interface (either in Haskell or in Python) so that you don’t have to download and install it. I originally intended to have the web interface up by last week, but that obviously didn’t happen. Taking into account the fact that it’ll take longer than I think it does, I’m guessing I’ll have it up by two weeks from now (so, a month). And finally, when/if I do the web interface, I’ll have it color the text according to which blog it’s from, or maybe even output xterm color codes if I don’t write the web interface.

One class is image-recognition CAPTCHA: you present the user with ten distorted images (to prevent random guessing by bots) and ask them which ones contain a cat, or which ones have been rotated upside-down, or which ones are people. This is essentially a generalization of text-based CAPTCHAS, but it has several problems. First and foremost, you need a large source of images to show the user. This is one of the huge advantages of text-based CAPTCHAs: they can be procedurally generated. If the image database for a CAPTCHA service is small, then it’ll be passed around by spam bots; since recognizing whether two images are the same is a fairly solved problem, all they have to do is answer your question for each of the images once. (The distortion’s purpose is to make image comparison harder in case spammers do get a hold of your database, not to make it impossible). One method would be to browse Flickr for photos tagged with an object and assume that each such photo contains an object, but you’re running into copyright issues as well as essentially relying on the fact that someone won’t tag a photo ‘cat’ just because it has a kitten in the distant background.

One other idea that I’ve seen a couple sites use is knowledge-based, relying on the fact that machines can’t yet parse natural language. So it asks a question like “what is 2 plus 2?”. The fundamental problem I see with this is that, again, you’re going to have a very small repertoire of questions; a CAPTCHA has to be able to be generated by a computer. Not to mention the fact that whatever question-generating algorithm you use could just be reverse-engineered to extract content, then passed to Google or Wolfram Alpha to get the answer. Unlike images, there’s no way to ‘distort’ a question.

A third possibility, orthogonal to trying to tell real people from computers, is to look at the content of the message, rather than require the message sender to pass some arbitrary test. This is the approach Akismet (which comes by default on WordPress) uses, and is similar to the way e-mail clients detect spam. This has the downside of having a higher false positive rate than CAPTCHA-based methods. A short comment saying ‘Hey, I read your article and liked it; check out this link’ can either be legitimate or spam, and determining which one it is would require knowing the contents of the link. So your CAPTCHA system would have to visit links posted by users, which is obviously highly undesirable behavior. However, it does have the advantage of not relying on some problem being ‘hard’ to solve, and it also removes the (admittedly small) barrier to commenting that CAPTCHAs produce.

For now, reCAPTCHA will remain good enough; it’s easy to solve, and the word combinations that I can’t easily read can be dismissed with a click of the refresh button. And since I have very low traffic, I can afford to have an e-mail sent to me for every comment I get here; if it does wind up being spam (apparently, either reCAPTCHA isn’t completely impervious to computer solving or there’s some sweatshop worker whose job is to spam sites with cheap Viagra ads) I can just delete it.

For simplicity, we’ll start by only looking at the surface of the sphere, . Let refer to rotation by (that is, pi degrees) about the -axis and let refer to rotation by about the -axis. The exact degree of the rotation isn’t important, only that it should be impossible via any combination of and to go back to the origin. Let be the set of all rotations that you can get by combining , , and their inverses. Then and form what’s known as the ”free group on two generators“, which is composed of all strings using , , , and as symbols, with the provision that and cannot appear together for . The multiplication for this group is just writing the strings together, subject to the rule that and cancel, as do and . So, for example, . The name arises from the fact that there are two ‘fundamental’ symbols, and , and it is ‘free’, since they don’t commute (that is, ).

Now, one very weird fact about the free group on two generators (written ) is that you can break it into four pieces, rearrange those four pieces, and then reassemble them into two copies of it. To elaborate, let denote the set of strings in that start with , and similarly for the other three symbols; let denote the empty string. Then obviously

How is that relevant? Well, partitions into orbits, where an orbit is a collection of points such that each element of moves points from the orbit into the orbit, and points not in the orbit into another point not in the orbit. For each orbit, we can pick a point inside it; let the set of all these points be . Then we can turn the decomposition of into a decomposition of ; using to indicate the set of all rotations in that start with , we have

Now, there are two omissions in this proof: first off, I ignored the origin. It turns out that you can cut the sphere without the origin up, rearrange it, and then put it back together so that you have the origin. Second, I ignored the axes of the rotations in ; they are the fixed points of these rotations, and so might cause problems; it turns out that if we call those points ; we can again cut up and rearrange it into .

So what does this mean? If we want to have any reasonable definition of volume, then we want translations and rotations to leave it the same. Then, we must have that some of these sets don’t have a well-defined volume; much like how you can construct a subset of the real line that doesn’t have one. We break the sphere down into a number of sets, some of which don’t have a defined volume; then we move them around and reassemble them. There’s no contradiction here, since two sets that don’t have a well-defined volume (or non-measurable sets, as they’re known) might have a union that has a volume. Of course, this is physically meaningless, since you can’t actually perform the required divisions; atoms are not infinitely small, after all.

The phenomenon of the webcomic is not exactly new by any means; Sluggy Freelance, one of the oldest still-running webcomics, is 12 years old, only slightly older than widespread availability of the Internet. So what do I mean when I say that MS Paint Adventures is one of the first first few webcomics? It’s one of the few (that I’m aware of, of course) that actually uses the full potential of a comic that takes place online.

The central thing that makes MS Paint Adventures unique to the best of my knowledge among comics is that the story is in large part driven by the fans. Andrew Hussie, the author, has stated in an interview that he does not plan out the direction the plot will take in advance; although he has some overall ideas of the direction he wants it to go, he lets the reader suggestions dictate it to a larger extent than essentially any other webcomic, or indeed any other form of serial storytelling. The only reason that this is possible is because of the MSPA forum; while it would be possible for this to happen in a world without the Internet, an online forum allows for other users to voice their approval for options that they might otherwise not have thought of, giving Hussie the ability to judge what the readers want. But even elements of discussion that are not necessarily suggestions can generate plot points; the apocalyptic nature of the story was originally unplanned and came about at least partly as a result of discussion on the forums about the posters on the walls of one of the main characters for apocalypse-themed movies.

The various Flash animations and other non-static content that AH occasionally uses to enhance the story are another element of MSPA that fundamentally would not work in a traditional print comic. Although they do not necessarily advance the story any better than a series of corresponding still images would, they make the story more enjoyable and immersive; the end-act flashes are probably the quintessential example of this, reminding the reader of the various active story threads, while providing a bit of progression in each of them; it’s far more effective than a series of still panels could ever hope to be. And the Flash animation/game not only could not be executed without the internet, it positively requires the high-bandwidth connections of today’s modern Internet infrastructure. The soundtracks to the Flash animations are also a key part of the overall ‘experience’, even though Andrew Hussie himself does not compose them; the collaboration between artist and composer is only possible through the Internet.

Although MSPA is certainly not the first comic to use the internet, or even the first one to use it beyond as a medium for publishing images (other comics have certainly had associated discussion forums), I believe that it’s the first one to truly use the full potential of the Internet. And while that doesn’t necessarily make it better than other ones, it definitely moves it from the realm of good to that of great.

Note that I have said that it is one of the few true webcomics, not the only one. The only other one that comes to mind is Kid Radd, which makes extensive use of animation, especially in the later strips, where almost every ‘panel’ is a three-second animation. But it didn’t use Flash, or user suggestions, so as good as it is, I don’t consider it to use the Internet in the same way that MS Paint Adventures does.