So without further ado, here’s ob’s complex guide to simplifying complexity theory.

First of all let’s get the definitions out of the way.

Turing machine: An idealized computer, with infinite memory, an infinitely fast cpu, and unlimited bandwidth. It’s a mathematical model of computer so it can kick your Core 2 Duo’s sorry little ass faster than you can say Pentium. (update: I originally wanted to make the point that bandwidth and cpu speed are irrelevant, but it seems to have confused more than clarified.)

Problem: In complexity theory, a problem is really a decision problem. It has a simple yes/no answer. You don’t ask “take this list and sort it and print the last ten items” that’s not a decision problem. You do ask “does this program, given this input, produce the last ten items of the sorted input?”.

(update: Although the sort problem as outlined here would be a valid decision problem, it is confusing since just changing my “last ten items” to “last C items” where C is a function of n would make it not be a decision problem. Better to use some other example, like “is the number given prime?“)

n: Size of the input for the turing machine. E.g. if your turing machine is sorting strings, like in the example above, n is the number of symbols that it takes as input.

T(n): Number of steps (i.e. instructions) that a turing machine must execute to solve a problem with input of size n.

Polynomial Time: When T(n) can be expressed as an equation of n, and possibly some constants, using only addition, subtraction, multiplication, and constant non-negative whole number exponents. E.g. n² is a polynomial while 2ⁿ is not.

Non-deterministic turing machine: A turing machine that can, at every branch point, take all possible branches in parallel. We call this guessing the optimal answer because, since the turing machine takes all branches, it must take the optimal branch too. If any of the parallel turing machines finds an answer, the non-deterministic turing machine stops and gives that answer (this means that it’s ok for some branches to never end).

So take your already idealized computer from above and make it able to reproduce itself on every branch point. I.e. it can follow all possible decisions in parallel.

P: The class of problems that can be solved by a turing machine in polynomial time.

NP: The class of problems that can be solved by a non-deterministic turing machine in polynomial time.

Reducing a problem to another: Imagine you have two problems, P1 and P2. You know something about P1 (e.g. that it belongs to NP). Now you want to prove some property of P2, for instance, that it belongs to NP as well.

One technique is to show that if we could solve P2 in polynomial time (i.e. P2 belongs to P), we could use that answer to solve P1 in polynomial time. This would mean that P1 belongs to P which is a contradiction. This technique is called reductio ad absurdum. (update: I completely botched this and commenter Bibi correctly called me on it. Here’s an attempt to clarify a reduction: if you want to solve an instance of P2, you convert it to an instance of P1, and then solve P1 to get an answer. Thus, you’ve reduced P2 to P1. How’s that?)

NP-complete: We say a problem is NP-complete if it satisfies two properties: 1) it belongs to NP, and 2) every other problem that belogs to NP can be reduced, in polynomial time, to it.

This means that if we come up with a solution for an NP-complete problem that runs in polynomial time in a deterministic turing machine (i.e. belongs to P), any other problem in NP can be solved in polynomial time by first reducing it (again, in polynomial time) to this problem, and using our solution. We would have proved that P = NP and we would have also won (pinky to corner of mouth) one million dollars.

NP-hard: A problem P1, that is so hard, that even though we can prove number two above, we can’t prove number one. This means we know P1 to be just as hard as anything in NP and possibly harder, but we don’t know if P1 is in NP or not. P1 is very likely to require exponential time.

(update: I stand by my definition of NP-hard. Although not being able to prove #1 is a sufficient condition, it is not necessary. All problems in P are in NP, and yet we call them P, not NP. Thus, even if all problems that are NP-complete are also NP-hard, it’s uninteresting to call an NP-complete problem NP-hard. The point of calling a problem NP-hard is that, it’s really hard! Even if it turned out that P = NP, an NP-hard problem might still be hard!)

So there you have it, go impress your friends. I hear that “hey, baby! your love is NP-hard to get” is a very successful pickup line at pubs around M.I.T.

After using TextMate for a while I became addicted to snippets. The basic idea of a snippet is that you can write a few characters and they expand to whatever you want. For example, you can type: ‘fl’, hit Tab and TextMate will write:

  for(int i = 0; i < ... ; i++) {
    ...		     
  }

Where ... is where the insertion point will be each time you hit tab. You can do the same with Emacs in many different ways: Emacs skeletons, the snippet.el plugging, hand-coded elisp, etc. The point of this post, however, is not to show all the different ways that you can get snippets. The point is to ask whether it’s worth using snippets at all.

Snippets eliminate the need to type recurrent idioms. If you have to write accessors, it’s very pleasant to type ’set’, hit tab and watch the screen fill with 20 lines of code that just wrap a field in a class with a setter function. But this is fixing the problem in the wrong place.

The fundamental problem is that the language is too damn verbose.

Imagine English had no pronouns so if I wanted to tell you a story about my friend Tim and me, I had to write:

Tim had called Oscar to ask Oscar if Oscar could lend Tim the book that Oscar had bought the day before. Oscar told Tim that Oscar was still reading it, but that Oscar would be happy to lend Tim Oscar’s book when Oscar was done with the book so that Tim could read it.

The above paragraph is too verbose. It’s hard to write. Snippets would help me write it by automatically filling all the appropriate places with “Tim” and “Oscar”.

If the language you are using is so verbose that you need snippets, how about fixing the language?

Even on languages that don’t allow fixing the syntax you can still do something.

For example, in C, if you find yourself typing a for loop to access a list over and over again:

  for (int i = 0; i < length(list); i++) {
 
  }

Make a small pre-processor macro that abstracts that:

  #define EACH(list) for (int i = 0; i < length(list); i++)

And now you can write:

  EACH(list) printf("%s\n", list[i]);

And since code is usually read many more times than it is written, you have helped make the source base a little better.

All occurrences in a source file of the following sequences of three characters (called trigraph sequences) are replaced with the corresponding single character.

??= #    ??( [     ??/ \
??) ]      ??' ^     ??< {
??! |      ??> }    ??- ~

No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed above is not changed.

Ok, so take the following C program:

??=include <stdio.h>
int
main(int argc, char *argv??(??))
??<
	printf("hello world\n");
??>

And compile it with the -trigraphs switch to gcc:

dirac src $ gcc -trigraphs -o trigraphs trigraphs.c
dirac src $ ./trigraphs
hello world

Combined with this you could seriously obfuscate your C code.

On page 64 of the C99 standard it says:

In all aspects of the language, the six tokens

<: :> <% %> %: %:%:

behave,respectively,the same as the six tokens

[ ] { } # ##

except for their spelling.

Really? Then let’s try this program:

%:include <stdio .h>
int
main(int argc, char *argv<::>)
<%
	printf("hello world\n");
%>

Compile it an run it:

dirac src $ gcc main.c
dirac src $ ./a.out
hello world

Whaddaya know… I know, I know… useless. Wait for the next post then.

We show that disk encryption, the standard approach to protecting sensitive data on laptops, can be defeated by relatively simple methods. We demonstrate our methods by using them to defeat three popular disk encryption products: BitLocker, which comes with Windows Vista; FileVault, which comes with MacOS X; and dm-crypt, which is used with Linux.

[...]

The root of the problem lies in an unexpected property of today’s DRAM memories. DRAMs are the main memory chips used to store data while the system is running. Virtually everybody, including experts, will tell you that DRAM contents are lost when you turn off the power. But this isn’t so. Our research shows that data in DRAM actually fades out gradually over a period of seconds to minutes, enabling an attacker to read the full contents of memory by cutting power and then rebooting into a malicious operating system.

Interestingly, if you cool the DRAM chips, for example by spraying inverted cans of “canned air” dusting spray on them, the chips will retain their contents for much longer. At these temperatures (around -50 °C) you can remove the chips from the computer and let them sit on the table for ten minutes or more, without appreciable loss of data. Cool the chips in liquid nitrogen (-196 °C) and they hold their state for hours at least, without any power. Just put the chips back into a machine and you can read out their contents.

This is deadly for disk encryption products because they rely on keeping master decryption keys in DRAM. This was thought to be safe because the operating system would keep any malicious programs from accessing the keys in memory, and there was no way to get rid of the operating system without cutting power to the machine, which “everybody knew” would cause the keys to be erased.

Our results show that an attacker can cut power to the computer, then power it back up and boot a malicious operating system (from, say, a thumb drive) that copies the contents of memory. Having done that, the attacker can search through the captured memory contents, find any crypto keys that might be there, and use them to start decrypting hard disk contents. We show very effective methods for finding and extracting keys from memory, even if the contents of memory have faded somewhat (i.e., even if some bits of memory were flipped during the power-off interval). If the attacker is worried that memory will fade too quickly, he can chill the DRAM chips before cutting power.

There seems to be no easy fix for these problems. Fundamentally, disk encryption programs now have nowhere safe to store their keys. Today’s Trusted Computing hardware does not seem to help; for example, we can defeat BitLocker despite its use of a Trusted Platform Module.

Notice that this attack is particularly dangerous because it can be trivially automated. All you need is a USB drive or CD with the malicious operating system already set up. If you have access to a system (e.g. a laptop), all you need to do is shut it down and boot it up from your malicious OS and you have a copy of the DRAM and thus the encryption keys.

A little known fact from Apple hardware is that it supports setting a password in the Open Firmware which will prevent the machine from booting from any device other than the built-in hard drive. I highly recommend using this option. I believe it could help in defeating even this new sophisticated attack.

Unless the attacker is careful to freeze the DRAM and pull it out of the laptop and transfer it to another machine to read it from there, the contents will be erased while he figures out that the machine can’t boot from a different drive. It’s a simple countermeasure that is available today. It won’t work in all cases, but it certainly will defeat a fair number of them.

Unfortunately, I couldn’t find any Zopf to eat my cheese with. If anyone knows of a Swiss bakery in the bay area, I’d like to know. At any rate, the bread you see in the picture is actually a Challah, which doesn’t have milk and has honey, so it’s not quite the same flavor. However, it was ok for having the Tête de Moine.

I’ve also found Tête de Moine at iGourmet, so I’ll be able to get some more once I finish this one. Is there a place in the bay area where they sell Tête de Moine?

This is what a default installation of EmacsW32 looks like.

Oh horror! You guys are kidding, right? Courier? Seriously?

Naturally, my first inclination was to use Inconsolata again. Just like in Mac OS X. However, this is what Inconsolata looks like.

WTF? What’s with all the blurred text? Well, it turns out that anti-aliasing and text rasterization differ significantly between Mac OS X and Windows. Oh well. Scratch that plan.

Then I remembered that Incosolata is actually based on Consolas, which is a font Microsoft created specifically for programming.

I downloaded and installed Consolas, and voilà! Beautiful Emacs once again.

Now it was just a matter of figuring out what the font was called. I had changed the font by clicking on the Emacs frame and pressing the shift key. In order to see what that does, I ran the describe-key function by typing C-h k, then clicking on the frame while holding the shift key. That told me the function that is called is mouse-set-font and it’s defined in c:/Program Files/Emacs/emacs/lisp/term/w32-win.elc. You can click on the file link and Emacs will take you to the function definition.

(defun mouse-set-font (&rest fonts)
  "Select an Emacs font from a list of known good fonts and fontsets.
 
If `w32-use-w32-font-dialog' is non-nil (the default), use the Windows
font dialog to display the list of possible fonts.  Otherwise use a
pop-up menu (like Emacs does on other platforms) initialized with
the fonts in `w32-fixed-font-alist'.
If `w32-list-proportional-fonts' is non-nil, add proportional fonts
to the list in the font selection dialog (the fonts listed by the
pop-up menu are unaffected by `w32-list-proportional-fonts')."
  (interactive
   (if w32-use-w32-font-dialog
       (let ((chosen-font (w32-select-font (selected-frame)
					   w32-list-proportional-fonts)))
	 (and chosen-font (list chosen-font)))
     (x-popup-menu
      last-nonmenu-event
      ;; Append list of fontsets currently defined.
      ;; Conditional on new-fontset so bootstrapping works on non-GUI compiles
      (if (fboundp 'new-fontset)
      (append w32-fixed-font-alist (list (generate-fontset-menu)))))))
  (if fonts
      (let (font)
	(while fonts
	  (condition-case nil
	      (progn
                (setq font (car fonts))
		(set-default-font font)
                (setq fonts nil))
	    (error (setq fonts (cdr fonts)))))
	(if (null font)
	    (error "Font not found")))))

Now, I don’t know what all of that does, but it seems like (set-default-font font) is the one function that actually sets the font. In order to figure out what the font is called, I copied all of the function to the good old *scratch* buffer, and added a call to (message font) right after the call to (set-default-font font). Then I redefined the function by typing C-x C-e at the end of it. After shift clicking on the frame again and selecting the Consolas font I had all the information I needed.

Now it was just a matter of putting the following snippet in my .emacs file:

    (set-default-font
     "-outline-Consolas-normal-r-normal-normal-14-97-96-96-c-*-iso8859-1")

Ahh… I feel so much better now… now what was I doing in Windows again?

A quick glance at the file told me I was loading a lot of modules that I seldom use. For instance, I occasionally write some code in Common Lisp or Haskell, so naturally I was loading slime and the haskell environment. I commented those out.

However, after commenting them out, I quickly realized that not loading them was problematic. When I wanted to use them, I had to open my .emacs file, uncomment the relevant portion, and M-x eval-region the code.

Then it occurred to me that I had a clear entry point for some of these modules. When I write Common Lisp, I usually start by loading SLIME’s REPL by running M-x slime. I came up with the following code:

(defun slime ()
  (interactive)
  (add-to-list 'load-path "~/emacs/slime")
  (setq inferior-lisp-program "/usr/local/bin/sbcl")
  (require 'slime)
  (slime-setup)
  (slime))

Which basically sets up my slime environment and then loads slime. Note that the slime function itself is redefined as part of the evaluation of (require 'slime), so although this looks like a recursive call, it’s not.

I’ve used this trick in several other cases and I think it’s kind of neat. It helps me keep Emacs loading fast, but I still have all the bells and whistles available.

Today is John Lennon’s death anniversary. He was shot to death on December 8th, 1980. I always commemorate this day by listening to John Lennon’s music, smoking unfiltered Gitanes, playing guitar, and letting my hair grow long… for a day… ok, not really, but I do try to listen to Imagine, at least once.

At any rate, there is a website now to commemorate John. It has a letter from Yoko Ono and a video from John Lennon.

The goal of an artist is to elicit some kind of emotion from the audience through his art. You cannot see the video and feel nothing. I left it running in the background while doing other things as I’ve seen Lennon interviews thousands of times and can usually remember how they go, but the imagery at the end, after John stops talking, pulled my eyes and engaged me like nothing has for a long while. I literally couldn’t stop watching.

At any rate, here’s to you John Lennon. You were the Walrus.

One way I commonly use it, is to see what I’ve changed in a file or a set of files. Let me clarify. I put everything in version control. Even tiny little programs that I’m tempted to throw away are in version control. Being able to use diff between my modified file and the previous version is a major reason for doing so.

Now, if I told you to quit your editor and run diff in a terminal, I wouldn’t be surprised if you decided to beat me with a clue stick. You should NEVER leave your editor. If you do, you don’t know how to use your editor, or your editor is not powerful enough. If your problem is the latter, you should switch to Emacs right now. Otherwise, keep reading, I can help you.

Depending on what version control system you use, you should modify the commands given below. I use BitKeeper (well, duh!), so all my examples will use that one.

To start with, stick this in your .emacs:

(defun bk-diffs ()
  "Get diffs between current edited buffer and checked in revision"
  (interactive)
  (let* ((filename (buffer-file-name (current-buffer)))
	(newbuf (get-buffer-create
		 (format "%s diffs"
			 (if filename (buffer-name) default-directory)))))
    (set-buffer newbuf)
    (if buffer-read-only
	(toggle-read-only))
    (erase-buffer)
    (insert
     (shell-command-to-string
      (if filename (format "bk diffs -uph %s" filename) "bk -r diffs -uph")))
    (switch-to-buffer-other-window newbuf)
    (diff-mode)
    (beginning-of-buffer)
    (diff-hunk-next)
    (toggle-read-only)
    newbuf))

Now, whenever you are in a file and want to modify it, all you need to do is run the command bk-diffs and you’ll get something like this:

Cool, eh?

The command is also context sensitive, so if you run it from a buffer where you’re not editing a file, e.g. a dired buffer or a shell buffer, it will run a recursive diff and give you diffs for all the files. I use this all the time when I go back to repositories I haven’t touched in a while. It’s my “what the hell was I doing?” command. The output looks something like this:

That’s not all. I have more tricks for you. First of all, navigation:

If you are an old school hacker and would rather see context diffs than unified diffs, you can hit C-c C-d while in the diffs buffer. To go back to unified diffs, hit C-c C-u.

There are also key strokes for going back to the source file from the diff buffer. Pressing Enter or M-o or C-c C-c will take you to the equivalent line (or thereabouts) in the source file from which the diff was taken.

Ok, that is useful, but I see you’re not blown away. The truth is, I saved the best part for last. Once you’re walking the diffs one by one, you can also press C-c C-a to either apply, or revert a hunk! How cool is that eh?

This last feature is something I use all the time to clean up a file before checking it in. E.g. I sometimes have a bunch of debug code or comments to myself that need to be removed before checking the file in. Rather than review the file by hand, I can go through the diffs and use the quick navigation that emacs provides for doing the clean up.

Finally, if you are a CVS user (I’m sorry, really. You should switch to something else), you can probably still use it inside vc-mode, hit C-x v = to get the diffs and try the keystrokes I mentioned.

Take a look at the following image. Click on it, and pick your favorite of the four fonts.

These are the fonts in the image, clockwise from the top left corner: Bitstream Vera Sans Mono, Andale Mono, Monaco, and Inconsolata.

Bitstream Vera Sans Mono is my second favorite. It’s the font I use on my web browser. However, for editing code, I find it a bit too heavy. This probably has more to do with my color scheme than the font per se, so your millage might vary.

Andale Mono is very readable, but I find the spacing all wrong and somewhat distracting. Look at the word “String”, the letters seem too far apart.

Inconsolata is my personal favorite. You need to crank up the font size because it seems to be a smaller font than the rest. I thought that point sizes were supposed to be standard, but apparently I was wrong.

Monaco is the default in Mac OS X, but it looks kind of silly. I used to use whatever was the default, so I’ve used this font quite a while. I never did mind it, but once I made the switch to Inconsolata, I can’t stand it anymore.

If you want to play with different fonts in Carbon Emacs, you can enable mac keys by running the (mac-key-mode) function, and then pressing ⌘T, which will open a standard font dialog.

However, if you want to use Inconsolata as your default font, put this in your .emacs

(require 'carbon-font)
(fixed-width-set-default-fontset
       "-apple-inconsolata-medium-r-normal--14-*-*-*-*-*-iso10646-1")

It took me a while to figure out how to change the font on Carbon Emacs, so I hope that even if you don’t choose Inconsolata as your preferred font, this information might prove useful.

Part 1:

and part 2:

If I used Windows, I’d buy norton antivirus just because of this ad.

A short time ago, Facebook introduced a new feature called “Beacon” that lets websites send status to your mini-feed. It immediately drew a lot of criticism because of its invasion to privacy, to the point that many people figured out ways to block it. Facebook’s CEO apologized for it today and made beacon opt-out.

Now, I was going to write a detailed article about why this bothers me and how insincere the apology sounded, but our good old friend Fake Steve Jobs did a much better job in this blog post. Money quote:

These guys are like Google, only their slogan isn’t “Don’t be evil” — it’s “Don’t get caught.”

And later:

The smarmy fake apology is not at all reassuring and seems to have been written by PR people who were trying to imitate a 23-year-old kid who’s speaking from the heart and trying to sound all sheepish and aw-shucks — except the flacks can’t do it because they’re as insincere and stage-managed as as the Facebook guys. Plus, let’s face it, the flacks are getting paid in Facebook equity, right?

I couldn’t have said it better myself. You should go read the whole post.

Apple is an “experience” company. They do hardware because it’s the only way to have the software under control. They do software because without good software, the hardware is useless. What they ultimately worry about is the user experience.

They partnered with AT&T because they needed to add the cellular network to the experience and they couldn’t build their own (they would have loved to). If they look like control freaks from the outside it’s because, well, they are.

On that note, in this piece, Saul Hansell argues that AT&T allows applications on other phones, except the iPhone. Saul claims that Mark Bercow, senior vice president of business development for Palm, encourages developers to do pretty much as they please with the Palm Treo:

Indeed, some developers have made video streaming applications, a particularly big bandwidth hog. (Of course, the cellular companies are free to charge whatever they wish for bandwidth use.)

Now go to the AT&T website and try to find their data rates. I could find a $24.99 data rate that was limited to 10MB, and an unlimited plan (with some fine print about per-kilobyte charges) for $69.99. That is in addition to the cost of the plan. The iPhone unlimited data plan is $20 per month. So while developers can create apps for any other AT&T phone, customers get charged per kilobyte. Now consider again what Steve Jobs said about third-party apps:

You need it to work when you need it to work. Cingular doesn’t want to see their West Coast network go down because some application messed up.

My take on that is that AT&T doesn’t want to see their network swamped with data transfers without being able to charge for them. However, a per-kilobyte service plan would have totally ruined the iPhone experience for the users. Apple wanted users to experience having a device that is always connected to the Internet. That experience is ruined if you’re worrying about how much you’re accessing the net because your service provider charges you per-kilobyte.

The reason Apple is so successful is because using their products is a pleasurable experience. That’s their trick, they think about the “experience”.