Daily Meh is an edited stream of consciousness, by Simen.

"†I'm serious.†"

Ideas I get just before going to bed, specimen 2 (part 1):

Village Voice interviews the man behind Hipster Runoff, the blog. The interview contains the highest density of quote marks around things which aren’t quotations I’ve ever seen. It reminds me of that hysterical article about hipsters as a dead end of western civilization, heralds of the apocalypse and more, which was a load of crap but contained one great line: “The dance floor at a hipster party looks like it should be surrounded by quotation marks.”

Now, I’m sure there’s lots of interesting stuff to say about genuine attitudes versus ironic distance and the like, but it’s been said so many times before that I’ve got to come up with a kickass way to say it before I join in. For the moment I’m more interested in a much narrower perspective: that of punctuation. What happens when the amount of text within quote marks exceeds the amount of text outside it?

In programming, it’s customary to use special markers, like we use quote marks in normal text, for comments. What isn’t within the special marks is presumed to be code, and this works great when the amount of code vastly exceeds the amount of comments. Behold, here’s Smalltalk, which — virtually alone among programming languages — actually uses quote marks for comments:

name: aName address: adAddress
         "Set the receiver's name and address
         to the specified values."
         self name: aName.
         self address: anAddress

But sometimes, most of a file is comments. Programmers are lazy when they can get away with it and hate redundancy, so they’ve invented a solution that minimizes all those extra comment markers: literate programming. It’s like normal programming, only with the punctuation reversed. Instead of using a special marker for comments, and everything else being code, a literate programming file uses special punctuation for code, and assumes everything not within the special punctuation is comments. Here’s literate Haskell, which uses > to indicate code:

This is a literate Haskell program. 
Below is a function declaration:
> id :: a -> a
> id x = x

So I got thinking: I assume that using quote marks around text that isn’t a quote is a way of marking ironic distance, half-seriousness, and other ways of less than fully committing to what you’re saying. Suppose the trend exemplified in the Hipster Runoff interview — if it can be called a trend — continues. One day in the near future, there will be more ironic content in faux quotes in a text than there is normal, genuine, heartfelt content outside quotes-for-irony. Being lazy, we want to get away with less punctuation. What if we simply do as literate programmers, and flip it around? Instead of using punctuation to mark what’s not heartfelt and genuine, we’ll start using special punctuation to mark the small portions of our texts that are genuine.

That’s where the daggers come in. In my plan, quote marks are relieved of double duty and returned to being markers of quotes, and I introduce a new sort of punctuation, the dagger ( † ), that will signify serious content. So, when you’re serious, you write, †I’m serious.† When you’re relating your feelings about the death of your mother, you write †in daggers†, and when you’re relating your feelings about the death of some pop singer, which you will probably have ironic distance to, you simply go on outside daggers, and everyone will assume it’s written with an ironic cologne in the air.

I’ve implemented this new ortography in this post. As you can see, I’ve used daggers in the post title to indicate my seriousness and lack of ironic distance. But I’ve enclosed the daggers in old-skool ironic quote marks to negate that, and as we all know a double negative makes a positive, so you can puzzle out the level of seriousness you should read this post with. Hint, outside daggers: very.