Late last December, I woke up and it was freezing in my apartment. I checked the thermostat, and it was already less than 60 degrees! I turned it from hot to cold to hot. And again. I turned it all the way up. The furnace never clicked on. COME ON! I checked, and the pilot light was on, so I had no choice but to call maintenance to get it fixed.

Most days this wouldn’t have been a problem, since it would be fixed while I was at work, but I was in my end-of-year vacation-burning crunch. Maintenance always fix minor problems really fast, so I knew it would take all day to come and fix the heater. Sure enough, help didn’t arrive until 6PM.

I tried lying motionless on the floor under some blankets and played some Assassin’s Creed 2. This worked for an hour or so, but if I’m at home all day and not working on something on the computer, I start to feel like a waste. This was in the middle of trying to get a side project of mine off the ground, and I wanted to get a beta version working before returning to work in January.

Could I use my laptop as a heater? It gets pretty warm when the CPU runs at full blast on one core. If I kept both going for hours, would that be enough?

8 minutes later, I had a C++ program that ran 2 CPUs at full blast. I hate picking C++ for a personal project, but I’ve used it for 10 years and I’m just not familiar enough with any other language’s CPU usage patterns to do the work that quickly. I probably didn’t have to worry, but I was cold!

The program, warmup, runs NUM_CPU copies of this thread:

int fn(bool *go)
{
  double a = 0;
  static mt19937 rng(static_cast<unsigned> (std::time(0)));
  normal_distribution<double> norm_dist(1.0, 1.0);
  variate_generator<mt19937&, normal_distribution<double> >
  normal_sampler(rng, norm_dist);
 
  while(*go){
    double val = normal_sampler();
    a += val;
  }
  return 0;
}

I already had Boost, and I’d never used their pRNGs before, so I decided if it was a copy/paste job, I would give them a test run. Sure enough, it plugged right in.

The main function is even simpler:

int main()
{
  bool go = true;
  boost::scoped_ptr<boost::thread> threads[NUM_THREADS];
 
  for(int i=0; i<NUM_THREADS; ++i)
  threads[i].reset(new boost::thread(fn, &go));
 
  std::string asdf;
  cout<<"enter any input and hit <Enter> to kill"<<endl;
  cin>>asdf;
 
  go = false;
 
  for(int i=0; i<NUM_THREADS; ++i)
    threads[i]->join();
 
  return 0;
}

Within 12 minutes of starting, I was nice and toasty!

I posted the code on Github in case I needed it somewhere else: [code]


• Its data was stored in the same structures as its program.
• It had macros that were powerful and simple. That’s huge coming from C++.
• It was REPL-based, something I never took advantage of with Python.
• You could create new code on-the-fly at runtime from lists.
• Completely dynamic and backed by garbage collection.
• The language itself is very mutable.

The sum of its parts was greater than anything that I had ever used before, and it quickly became my favorite language. I learned quite a bit about functional programming techniques, did some experimentation with image processing and database application programming, and worked through all of Graham’s  ANSI Common Lisp and large swaths of Norvig’s Paradigms of Artificial Intelligence Programming.

Recently, a nagging though started to cross my mind: What if I didn’t go far enough to break out of my box?

That didn’t happen until two weeks ago, when I started porting Genesis, my toy genetic algorithm framework, to Clojure for fun. I wasn’t very aware of the features of Clojure: I knew that it was a Lisp on the JVM and that it supported Software Transactional Memory, but I didn’t think it would be that different from Common Lisp aside from Java interoperability.

To clarify, I expected that the primary method of manipulating Clojure would be list-based, and that it would still mostly turn a blind eye towards mutable data and multithreading issues, with the option of phrasing memory updates in terms of transactions if you were using multithreaded applications.

Clojure turned out to be different than any language that I had ever tried – save my forays into Haskell to grok enough syntax to follow sigfpe‘s easier articles.  If you trust the language and work with the core Clojure data structures, it takes a lot of the worrying about parallel programming out of your hands. Its creator, Rich Hickey, ended up with a language that has a good balance between functional programming and practicality. It is definitely a good Modern Programming Language.

You Said Something About A Box..?

Right, I said I didn’t go far enough outside of my comfort zone when learning Common Lisp. That’s really only half true.

From the perspective of programming, Common Lisp is a great language. Using the functional programming primitives provided on top of lists feels very natural, and I was able to work on complicated problems with relative ease. Even though I don’t use the macro system in Common Lisp very often, it usually provides a great fallback for either refactoring or changing the way the problem can be represented. The REPL is just icing on the cake.

However, not all is flowers and roses. Looking at Common Lisp from perspectives other than single-threaded programming, it begins to look mortal! For instance, the Common Lisp standard was written without a thought to having multiple threads of execution. Although most implementations provide extra support for multithreading, you’re back in the same locking boat that you were with any of the other popular languages once you need to share mutable data. Naturally, the syntax for things like grabbing mutexes is easier with Lisp than with other languages thanks to the “with-” design pattern for macro writing, but you’re not gaining much with respect to avoiding race conditions.

Looking at it from a data-processing perspective, functional programming is easy in Common Lisp, but it isn’t required at all. There’s nothing stopping the programmer from falling back into using local mutable state, functions with side-effects on global variables, and destructive functions. Combined with the single-thread design, that’s fine. You can’t avoid state all of the time, and I don’t go out of my way to be strictly functional. That’s how most other languages are designed. Hell, the Common Lisp standard even offers a whole slew of functions that are destructive for the sake of efficiency!

I’m only really getting at the fact that even the ultra-flexible of Common Lisp wasn’t written to handle all computing scenarios.

Some languages have support for neat automatic threading features: Haskell has extensions where type annotations can allow automatic parallelization, and you can use OpenMP in C++ for automatic parallel processing. For those wondering, Erlang is somewhere on my list of languages to take a look at, but it has to wait its turn! I’m still having too much fun with Lisps.

Axiomization and Language Design

Love him or hate him, Paul Graham has written quite a bit about the design of Arc. I’m not going to talk about it directly, but I will borrow his idea of reaxiomizing the core of a language as a means of producing better code on top of it. He mentions axioms as neither primitives nor library functions, but I will consider primitives as well.

I’ve talked about this a little in the past. For instance, I’ve made the case for operator overloading in Java. It was explicitly verboten in Java, as decreed by the designers. In fact, written in an early Java whitepaper titled “The Java Language Environment“,

2.2.7 No More Operator Overloading

There are no means provided by which programmers can overload the standard arithmetic operators. Once again, the effects of operator overloading can be just as easily achieved by declaring a class, appropriate instance variables, and appropriate methods to manipulate those variables. Eliminating operator overloading leads to great simplification of code.

By the letter of their assertions, they were correct. A lot of programmers would never need operator overloading to produce good code. In fact, if you’re using it just for the sake of expressiveness, you’re going to produce an unintuitive hodgepodge most of the time. However, a small but powerful minority – particularly those who do mathematical work for a living – would absolutely benefit from being able to write inline operators. I mean honestly, have you ever tried to use a BigInteger to implement something more complicated than RSA? The best that will happen is that it will end up… verbose.

Essentially, leaving out operator overloading forced Java to be more verbose and/or less readable than it needed to be. Leaving it in as an ‘axiom’ could measurably produce more compact, readable code for programmers who used it judiciously.

As an aside for those who think I’m just trolling Java, there is definitely a great Java feature for each one that misses the mark. For instance, the enums in Java follow the idea to its logical conclusion.

If you’ve been incensed by my Java discussion or are otherwise unsure that axiomization could lead to a better language, let’s look back at Lisp. Lisp changes quite a bit if you remove utility functions like reduce: it would break a lot of the compactness of the language and ruin some otherwise good functional programming. Now, it doesn’t support operator overloading, per se, but there’s nothing stopping you from changing the language to support it.

Where the Hell is All of This Going?

Back to Clojure! Clojure is based on a much different set of axioms than many of the popular languages. At its core, we see support for thread-safe data structures whose data are immutable and persistent. These were written in as axioms to the language, and you can make some good predictions for the language, assuming people stick with it.

The biggest one is that as libraries are converted to Clojure or abstract away their Java API, Clojure will develop a large set of libraries that could be given a thread-safe guarantee.  For my day job, I work in a C++ shop that uses a bunch of C libraries, and we need to constantly be aware of whether or not our base libraries are thread-safe. My workplace recently developed a non-Clapack fork of our linear algebra abstraction for this reason: using libraries that aren’t designed to be threadsafe in a multithreaded environment builds bombs.

I’m too young to get a sense of what the next 10 years of programming languages might look like – but if you pressed me, it would look a lot like it does today, and we wouldn’t be better off for it. The languages that are currently in the design phase are slowly adding quite a bit of features while remaining mostly the same: for instance, C++ is getting a makeover that includes concepts, lambdas, futures, and a multithreading primitive.  I’ve known C++ for over half of my life (holy shit!), and a lot of the features are sorely needed. However, it’ll be an incremental improvement at the cost of obscure compiler bugs and increased complexity.

These aren’t easy problems: for instance, if you didn’t care a lick about any external concerns like backwards compatibility and wanted to change C++ to support lambdas, how could you without just tacking it on? However, we have new languages that can pick up where the old languages left off, and continuing Fred Brooks’ prediction, there will be no silver bullet, only incremental improvements. Languages like Clojure are a step in the right direction as far as testing new computing ideas.

In my mental model of knowledge, I split skills between three major mastery levels:

• Those we can use professionally. I program professionally, and I practice daily to strive for mastery. I’m getting to the point where I can handle any task that is thrown at me.
• Those we can use. I can cook without killing myself of burning down my apartment complex, even though I can’t make many types of food and wouldn’t recognize a Mother Sauce if it was poured down my shirt.
• Those we couldn’t really use if our life depended on it. I’m not good at drawing. I’ve never spent time on it, and I have no motivation to learn. I can “draw” diagrams and get my point across, and this is enough for me.

All people treat the skills from the first category differently than the other two: we use them with confidence. Some people use them with arrogance. We know these fields well enough to absorb innovations and new ways of thinking. We can confidently discuss them with other people.

In my mental model, starting from scratch in our expert area causes people to reject a change. For instance: an Excel or Word guru would never willingly switch to a completely unrelated product. Relearning things line inserting line-breaks and adding pictures to a text document is completely orthogonal to anything they actually have to do on the job, much less something more complicated like Mail Merge. Instead of using it like it should be used, they would likely try using it like they used their old product, declare that it can’t ramrod the flimjam, and switch back to their old way of doing things, regardless of which is really better.

Interfaces and APIs

Altered interfaces are difficult for the end user. This isn’t just about GUIs or the placement of buttons in a menu; this extends to software APIs as well.

An altered menu causes all users to waste time looking for new ways to do something they could do 5 minutes ago. Changes to an API cause the programmers relearn a library they already knew — not to mention the laundry list of changes that need to happen to the new stuff!

APIs and Interfaces

The interface for a library or class develops massive unavoidable dependencies with use. I’ve called this “code inertia” in the past. Joel and Jeff’s recent discussion of dependencies between unit tests and code is a perfect example of code inertia: making nontrivial changes to an application can force a nontrivial number of changes to your automated testing environment.

This has not only a physical effect on the code, but also a mental effect for programmers! I’ve actually heard arguments from programmers based on the IDEA of possible future change: we shouldn’t use this library because it’s changed significantly in the past, and it might change again! Having to relearn the API combined with the frustration of updating broken code leaves a giant red flag in a programmer’s mind, even though any codebase that is being properly maintained will go through interface changes as new versions are released.

Excel

I was fortunate enough to take a Numerical Methods and Analysis class during my senior year of college.

If you’re not familiar, it’s the mathematics of computation: finding efficient approximations, determining rate of convergence, and knowing the margin of error at each stage.

This was my only college class where a calculator was ever useful. Most of our homework involved finding the values and error in iterative processes, so the professor suggested a “complex math package” for our homework: Excel.

Despite my initial skepticism, Excel is AWESOME with iterative numerical computation: type in a relative formula, highlight 50 rows, and click “fill down.” Voila! You can put a bunch of results in adjacent columns and compare convergence rates visually before you even prove that it converges at a certain rate. It’s quick, it’s interactive, and it supports easy experimentation.

Why is this relevant? My college upgraded to the Microsoft Office 2007 suite the previous summer, toolstrip and all. Every single class was punctuated by my professor loudly complaining that she HATED the new Excel because the interface was WORSE and she couldn’t find anything.

Even though she knew where everything was after 2 weeks of use, we got the same complaint every week. She had already made up her mind: it was worse.

KDE and Linus

A few years ago, Linus Torvalds publicly announced his Linux desktop preference on the GNOME message boards:

I personally just encourage people to switch to KDE.

This “users are idiots, and are confused by functionality” mentality of Gnome is a disease. If you think your users are idiots, only idiots will use it. I don’t use Gnome, because in striving to be simple, it has long since reached the point where it simply doesn’t do what I need it to do.

Please, just tell people to use KDE.

Linus

The different camps typed their representative emoticons — and D: — and then life continued as normal. However, Linus was eventually forced to switch when the next version of KDE changed too much:

Interviewer: Another open source project that underwent a big change was KDE with version 4.0. They released a lot of fundamental architectural changes with 4.0 and it received some negative reviews. As a KDE user how has this impacted you?

Linus: I used to be a KDE user. I thought KDE 4.0 was such a disaster I switched to GNOME. I hate the fact that my right button doesn’t do what I want it to do. But the whole “break everything” model is painful for users and they can choose to use something else.

I realise the reason for the 4.0 release, but I think they did it badly. They did so may[sic] changes it was a half-baked release. It may turn out to be the right decision in the end and I will re-try KDE, but I suspect I’m not the only person they lost.

I got the update through Fedora and there was a mismatch from KDE 3 to KDE 4.0. The desktop was not as functional and it was just a bad experience for me. I’ll revisit it when I reinstall the next machine which tends to be every six to eight months.

The GNOME people are talking about doing major surgery so it could also go the other way.

Linus realizes that it might be the right decision in the long run, but there’s no escaping the fact that even the big guns in the field can’t spend his time relearning the basics every day, even if it’s the right thing to do. He has a mental model of how the desktop is supposed to work, and when KDE broke it, he fixed the problem.

Adult Learning and Malcolm Knowles

To me, a lot of the principles of API and interface design fall under adult learning. To state the obvious, most of the indended clients for interfaces are adults. We’d like them to learn how to use our products with the minimal amount of fuss.

However, if your interface is exactly like every other interface, there would be no reason to use it. You’re trying to solve a problem for yourself, and you’re trying to solve a problem for your intended users. Your users will have to learn how to solve their problems with your interface, and it had better be easy.

Enter the research of Malcolm Knowles. He is one of the big-shots in the field of adult learning, having done a lot of the early theoretical work. This site has a good description of his life’s work with researching, for the interested.

In particular, Knowles attempted to find the theory of what caused adults to best learn. Believe it or not, there hadn’t been extensive research in the field before he started. The closest that he was able to come was his theory of informal learning, through group sessions or other kinds of informal meetings. He also developed his assumptions by which adults learn:

Malcolm Knowle’s Assumptions on Adult Learning

1. Self-concept: As a person matures his self concept moves from one of being a dependent personality toward one of being a self-directed human being.
2. Experience: As a person matures he accumulates a growing reservoir of experience that becomes an increasing resource for learning.
3. Readiness to learn. As a person matures his readiness to learn becomes oriented increasingly to the developmental tasks of his social roles.
4. Orientation to learning. As a person matures his time perspective changes from one of postponed application of knowledge to immediacy of application, and accordingly his orientation toward learning shifts from one of subject-centeredness to one of problem centredness.
5. Motivation to learn: As a person matures the motivation to learn is internal.

The salient bullet point is #2: experience. It’s directly listed as a basis for adult learning. I’m not saying that this is a direct proof of my mental model of knowledge, because quite honestly it’s just not a proper conclusion. However, designers of APIs and GUIs should take this as an indication that experience is something to build on, not disregard.

To use an aforementioned example, I really like the ribbon interface in Office 2007! I was proficient after only a few hours, and I enjoyed using fewer keystrokes to achieve my goals. I thought that it mapped pretty well to the old menu-based methods, and it was pretty obvious when it didn’t. If I could use only keyboard shortcuts to navigate, it would be the ideal control.

However, it’s probably a bad idea releasing it in the same year as Vista, which already scrambled some menus, changed some positions, altered some interfaces, renamed some popular folders, added UAC, etc. It all added up to too much of a change: when people sat down at it for the first time, nobody couldn’t use the darned thing.

Live and learn!

Footnote

I remember a minor fuss when Linux 2.6.0 came out because the device driver interface changed. Linus himself descended from the cloud to state that he makes the right design choices for Linux without regard to compatibility issues. It was going to tie in really nicely with my point, and my Google Fu has failed me. up. The device driver interface changed from 2.4 to 2.6, and that there was a of device driver complaints. At this point, I just want to know if I was making this up.

My girlfriend and I recently went on vacation to Germany. Distant relatives of mine (Wolfgang and Birgit), agreed to host us for a few days, which turned out to be a great break from cheap hostels.

One day, Wolfgang tells us that they are taking us to Öhringen, and town about 16 kilometers away.

He quickly corrects himself for the benefit of the Americans. “That should be about nine miles.”

“It’s closer to 9.6″ I said without skipping a beat.

The speed of my answer surprised him. “Are you a quick multiplier?”

“Well, not exactly. Each kilometer is a little over .6 miles, so I add 1/2 and 1/10 the original number. It’s usually really faster than multiplying or dividing.”

It should be noted that this is an approximate method. The error is around 3.5%, as the conversion factor is closer to .621371. Most of the time, approximation are good enough with respect to distances. Once you have a handle on the distance, you can make all sorts of reasonable estimations, like driving time.

Figuring it out

Last March, I went on a road trip to Canada to compete in the CS Games with my fellow Computer Science majors. Since it’s a long effing way from TCNJ to Sherbrooke in Canada, we needed something to do. My buddy Steve realized that we accidentally printed our return directions in kilometers instead of miles. He read out one of the distances on the map and asked what it was in miles/hour.

We thought for a second, and then I looked at the speedometer and read off the corresponding speed in miles per hour.

“How did you do it so fast?”

“Mental math,” I replied.

“What’s the conversion factor?” somebody asked. I saw that 100km/hr was roughly 60 miles, so I said “about .6.”

Luckily for me, all of the distances Steve read off were under 160km (the limit of my speedometer), so I was able to use the speedometer trick for a while. I figured that charade couldn’t last long, so I broke down the problem (multiplying by ~.6), and saw easy fractions I could use. I continued using this flawlessly.

Going from miles to kilometers is just as easy. Since a mile is ~1.609 kilometers, you can get an even better answer with identical math.

For a distance n, just add together n + n/2 + n/10. This approximation leaves you within .6%!

It’s a piece of cake to develop new methods along these lines. Take the expansion of the multiplicative constant, c, pick the first few digits of c, and break it up however mental arithmetic is easiest. Each digit of c that you use gives you a better approximation.

Determining the relative error is easy: it’s the unused digits of c divided by c.

You probably use this method for calculating tips already. If n is the dollar amount of the tip, it is easy to calculate 10% of the tip: x = .1 * n. The full amount of the tip is x + x/2, giving you 15%. That’s 1/10th + 1/20th, or 10% + 5%. This particular application happens to be exact.

You can even determine a generalization for any affine method, such as temperature conversions, by also adding and subtracting rounded approximations.

Feynman Vs. the Abacus

The above is child’s play! Any kid who has learned division can figure out their own tricks. The real limits of human mental math are accomplished by mental lookup tables. Special numbers are the name of the game; the more special numbers you know, the easier it is to quickly solve a problem.

The best example I have found of this is a story in Surely You’re Joking, Mr. Feynman!, where he is challenged by a Japanese abacus salesman while visiting Portugal. I highly recommend you read the full text of the encounter.

The first challenge is addition. Feynman doesn’t stand a chance against the abacus, even when the numbers are written down and shown to both parties at the same time.

Next comes multiplication. Feynman still loses, but he has started to close the gap.

The next challenge is long division. It is a tie. This bothered the abacus salesman, so he challenges Feynman to cube roots. He writes the number “1729.03″ on a piece of paper and starts working the abacus. Feynman quickly figures out that the first few digits are “12.002″ while the abacus salesman struggles to even determine “12″.

As the book puts it:

How did the customer beat the abacus?

The number was 1729.03. I happened to know that a cubic foot contains 1728 cubic inches, so the answer is a tiny bit more than 12. The excess, 1.03 is only one part in nearly 2000, and I had learned in calculus that for small fractions, the cube root’s excess is one-third of the number’s excess. So all I had to do is find the fraction 1/1728, and multiply by 4 (divide by 3 and multiply by 12). So I was able to pull out a whole lot of digits that way.

Hooray Math!

The Feynman abacus story demonstrates one of the great things about math: every little fact eventually counts for something.

Today happens to be that day.

Much to my amusement, I also happened to run across an article that states that OpenID is too hard for everyday use.

Absolutely! I couldn’t agree more. They still need to jump a gigantic new user hurdle. However, the alternative also sucks: changing your password for every service you use. So far today, I have changed the following passwords:

At Work:

• Two local computer passwords
• Two network passwords (one Unix, one NT).

At Home:

• One Vista machine.
• One Ubuntu laptop.
• One server-edition Ubuntu machine.

On the Web:

• Google
• Reddit
• jakevoytko.com x2
• Dreamhost
• Dreamhost MySQL (different password than the rest, naturally.)
• Facebook
• AOL Instant Messenger
• Amazon
• Windows Live (once I remembered which domain I used to register. This service plunges further onto my shit-list every time I use it).
• Internet provider
• Insurance provider

Special Passwords: (I.E. Don’t allow symbols)

• Verizon
• Digg

And I probably still have more to go! The good news is that a lot of sites seem to be converging on standards for passwords. Probaby 65% of the web-based passwords were in a section marked “Account Information” or “Profile.” Some were hopelessly buried.

OpenID may be hard, but they are taking a big step in the right direction. This is the web usability area that impacts users most

Ironically, one of the passwords I won’t be changing is OpenID, since the only time I used it, I used a throwaway password on a throwaway account that I don’t remember anymore . Doing this for the 5th time in a row is certainly encouraging me to sign up with OpenID and get another password to add to the list!

A week or two ago, he threw me a curveball:

“How’s it going? Do you understand it all yet?”

“No. I’m making progress, though. I’m probably not going to have this down for a while. It’s a completely different way of thinking from the programming I normally do.”

“How is it different?”

I froze. He’s “Mr.-Fix-It,” and understands the rock quarry/asphault business inside and out. He’s very analytical, and it’s almost impossible to stump him with my favorite “Devil’s advocate” questions. However, aside from what I’ve told him, he just doesn’t know much about programming.

“Metaprogramming” and “first-class functions” wouldn’t have meant anything. “It lets you write programs faster” is a cop-out; he’s given me detailed explanations of his business. I wanted him to understand.

I was able to stammer out the fact that the language encourages breaking problems into smaller versions of the same problem (recursion), but that other programming languages also supported it.

I eventually told him that I hadn’t even thought about explaining the difference to a non-programmer.

“Well, if you’re ever able to come up with it, let me know.”

In college, I was a Computer Science tutor. I could explain most CS concepts that students saw in early C++ and Java courses to the layman on the street. However, I had nothing for explaining the difference between Lisp and C++ to him, which was a little scary. I spent some time dreaming up examples.

Functions

All models are wrong, but some are useful.

~George Box

Abstract math notions are boring to most people, so I try to relate programming concepts to real-world items.

A fast-food restaurant is a great example of a function: An order and some money is input, and you get cheeseburgers, fries, a soda, and your change. Whether a person likes math or not, they know what a function is: you put something in, you get something out.

The idea is easily extensible to Object Oriented programming: all Burger Kings have orders, and you can place a specific order at an instance of a Burger King. A Burger King “is-a” fast food restaraunt.

I will use this metaphor to explain why Lisp is different from the programming I usually do (C++/Java/C#/Python).

Lambdas

Any restaraunt probably has a few different ways to order food: over the phone, at a drive-through window, at a counter, through a waiter, etc. However, there might be unofficial ways to order food: Bill Gates might write a letter requesting a buffet with a few hundreds slipped in as proof. Someone might tell the owner on his way to work that he’d like him to come back with a pizza.

The owner can easily define new ways to order food through a restaraunt.

Lisp, through “lambdas”, lets a programmer define new functions as easily as a restaraunt owner can devise new ways to order. The inputs and outputs are the same, but making new functions can have very low overhead compared to other programming languages.

Brevity

“Wiz Wit”.

This is my usual order at Pat’s in Philly. With just two words, I get a cheesesteak with Cheez-Wiz and fried onions in less than 5 seconds. The system is designed to maximize the number of cheesesteaks output per hour: orders are short, and you usually get your cheesesteak before you’re done paying [and sometimes, before you're done speaking!]

This lesson can be applied to writing: It’s easier to convey a short thought. Unless you are Charles Dickens or Neal Stephenson, economy of language should be a goal.

Lisp’s syntax is very simple and short, so you can usually convey a thought in Lisp much quicker than you can convey a thought in most other programming languages.

Macros

An order can come in several different forms: it can be written, it can be gestured, it can be be spoken, and it can be implicit.

A lot of programming languages let you generalize the details of what an order can receive. Most orders are the same, so you can handle the contents the same even though the orders are different. In C++, you could even use “templates” to write code that generates code that handles this idea.

Lisp takes this idea all the way to its logical conclusion through “macros.” You can easily write functions that define orders. The difference is that you can easily do this at any scope!

If you notice that all fast food restaraunts are the same except for color scheme, specials, and slogans, it is easy to write functions that define new fast food chains. If you notice that your functions for defining fast food chains are similar to your functions for defining hardware chains, you can write functions that generate these producers.

Lisp lets you easily do this manufacturing on a level that is unimaginable with any other language. It may be possible, but nothing beats Lisp’s ease-of-use.

Self-Modifying Code

The metaphor breaks down here, and I won’t force it. However, the idea is simple when it is explained.

Most programming languages are designed to modify memory. They all store their information in memory, retrieve it, modify it, and write it to memory again.

Some programming languages try to hide the fact that they’re based on a memory-modification model, but they are extremely similar to languages that don’t hide it.

Lisp, however, is written to modify lists. Lisp is also written using lists, so a Lisp program can be programmed to modify itself.

Conclusion

This is just the tip of the iceberg! There are a lot more ideas that lay beneath the surface here, and you can bet that I’ll think about how to explain them to an educated adult. However, this should get someone with passing familiarity to programming to understand what makes Lisp stand out: ease-of-use and brevity.

On June 26th, ICANN decided that the world needs more top-level domain names. Instead of the big three: .com, .org, and .net, we can now look forward to top-level domains such as .pepsi, .nyc, and .travel.

This plan wasn’t forged from malice. There are quite a few benefits to the proposal. For example, users of non-Roman alphabets will find new support for native-language domain names. However, I found my gut reaction strongly critical the idea, so I ended up putting a little bit of time into thinking through the (negative) consequences of the move.

Expectations and Security

A lot of my initial concerned boiled down to the following question:

Is it wise to change one of the foundations of the internet this late in the game?

I don’t mean this from a technical standpoint, but rather a human standpoint. Unlike most of the technical organization of the internet, people actually interact with top level domains directly in multiple ways.

First is the grouping idea behind the expansion: even though usage is currently very limited, there is a practical difference between google.com and google.cn: without even looking at the sites, I know that I am far more likely to understand the content on the first domain than the second domain. After looking at the sites, I am 100% sure I can’t understand the content at google.cn, and am mystified about the goofy hover-animations at the bottom of the page. Obviously, the proposal aides this human interaction with the internet.

Second is the simple issue of memory: At the moment, I can’t think of a site that I regularly use that has a domain other than .com, .net, .edu, and .org. That really limits the amount that concerns me when I memorize a new location on the web. Is this a big deal? Not really. Is it a factor? Absolutely.

Last is the security of top-level domain names. We all know that we shouldn’t go to www.mybank.com.info. That’s not to say nobody ever goes to phishing sites, but it’s a simple and useful safeguard against the faceless evil on the internet.

The security aspect of the top-level domain switch had me worried for a while. Let’s say that the newly formed .travel domain allows anybody to nab a new travel account. After all, a lot of people like to travel. Why not let them create their own .travel blogs about travelling?

Unfortuantely, this opens up an unfortunate can of worms. Can you trust a visit to orbitz.travel, a seemingly innocuous domain at the nascent .travel top-level domain? Was it account.orbitz.com, account.orbitz.travel, or account.travel.orbitz?

This is not to say that any new top-level domain registrar will actually implement any of these measures. However, this will force a shift for a new mental security model.

What Actually Concerns Me

Soon, I realized that my concern over the proposal was just a defense of my boundless love of keyboard shortcuts! In Firefox, I’ve been using the domain completion keyboard shortcuts for a few years now, so much so that they have grown to be a necessary part of my browsing experience.

As my girlfriend can attest, a normal browsing session is not complete without the following exclamation/keyboard interaction:

“I wonder how the crazies are doing!” <Ctrl>-t, reddit, <Ctrl>-<Enter>.

It takes me literally less than a second to find out why Ron Paul thinks C++ is worse than Haskell’s type system (with benchmarks), and I will be crushed when I am forced to navigate to other websites without my precious keyboard completions. I will either have to <god forbid> type out the whole domain, or find a Firefox plugin that will let me use archaic shortcuts like <Ctrl>-<Alt>-<Shift>-~-<Backflip> in order to properly navigate to the .travel domain.

Keyboard Shortcuts? Are You Serious?

Absolutely not! The above section is triple-underlining my belief that the top-level domain switch will not be a technical issue, but will create extra people problems. Once the new top-level domains are activated, all internet users will have to go through a new adjustment (good and bad) on their conceptual models of organization and security of information on the internet.

We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable Rights, that among these are Life, Liberty and the pursuit of Happiness. — That to secure these rights, Governments are instituted among Men, deriving their just powers from the consent of the governed, — That whenever any Form of Government becomes destructive of these ends, it is the Right of the People to alter or to abolish it, and to institute new Government, laying its foundation on such principles and organizing its powers in such form, as to them shall seem most likely to effect their Safety and Happiness. Prudence, indeed, will dictate that Governments long established should not be changed for light and transient causes; and accordingly all experience hath shewn that mankind are more disposed to suffer, while evils are sufferable than to right themselves by abolishing the forms to which they are accustomed. But when a long train of abuses and usurpations, pursuing invariably the same Object evinces a design to reduce them under absolute Despotism, it is their right, it is their duty, to throw off such Government, and to provide new Guards for their future security. — Such has been the patient sufferance of these Colonies; and such is now the necessity which constrains them to alter their former Systems of Government. The history of the present King of Great Britain is a history of repeated injuries and usurpations, all having in direct object the establishment of an absolute Tyranny over these States. To prove this, let Facts be submitted to a candid world.

He has refused his Assent to Laws, the most wholesome and necessary for the public good.

He has forbidden his Governors to pass Laws of immediate and pressing importance, unless suspended in their operation till his Assent should be obtained; and when so suspended, he has utterly neglected to attend to them.

He has refused to pass other Laws for the accommodation of large districts of people, unless those people would relinquish the right of Representation in the Legislature, a right inestimable to them and formidable to tyrants only.

He has called together legislative bodies at places unusual, uncomfortable, and distant from the depository of their Public Records, for the sole purpose of fatiguing them into compliance with his measures.

He has dissolved Representative Houses repeatedly, for opposing with manly firmness his invasions on the rights of the people.

He has refused for a long time, after such dissolutions, to cause others to be elected, whereby the Legislative Powers, incapable of Annihilation, have returned to the People at large for their exercise; the State remaining in the mean time exposed to all the dangers of invasion from without, and convulsions within.

He has endeavoured to prevent the population of these States; for that purpose obstructing the Laws for Naturalization of Foreigners; refusing to pass others to encourage their migrations hither, and raising the conditions of new Appropriations of Lands.

He has obstructed the Administration of Justice by refusing his Assent to Laws for establishing Judiciary Powers.

He has made Judges dependent on his Will alone for the tenure of their offices, and the amount and payment of their salaries.

He has erected a multitude of New Offices, and sent hither swarms of Officers to harass our people and eat out their substance.

He has kept among us, in times of peace, Standing Armies without the Consent of our legislatures.

He has affected to render the Military independent of and superior to the Civil Power.

He has combined with others to subject us to a jurisdiction foreign to our constitution, and unacknowledged by our laws; giving his Assent to their Acts of pretended Legislation:

For quartering large bodies of armed troops among us:

For protecting them, by a mock Trial from punishment for any Murders which they should commit on the Inhabitants of these States:

For cutting off our Trade with all parts of the world:

For imposing Taxes on us without our Consent:

For depriving us in many cases, of the benefit of Trial by Jury:

For transporting us beyond Seas to be tried for pretended offences:

For abolishing the free System of English Laws in a neighbouring Province, establishing therein an Arbitrary government, and enlarging its Boundaries so as to render it at once an example and fit instrument for introducing the same absolute rule into these Colonies

For taking away our Charters, abolishing our most valuable Laws and altering fundamentally the Forms of our Governments:

For suspending our own Legislatures, and declaring themselves invested with power to legislate for us in all cases whatsoever.

He has abdicated Government here, by declaring us out of his Protection and waging War against us.

He has plundered our seas, ravaged our coasts, burnt our towns, and destroyed the lives of our people.

He is at this time transporting large Armies of foreign Mercenaries to compleat the works of death, desolation, and tyranny, already begun with circumstances of Cruelty & Perfidy scarcely paralleled in the most barbarous ages, and totally unworthy the Head of a civilized nation.

He has constrained our fellow Citizens taken Captive on the high Seas to bear Arms against their Country, to become the executioners of their friends and Brethren, or to fall themselves by their Hands.

He has excited domestic insurrections amongst us, and has endeavoured to bring on the inhabitants of our frontiers, the merciless Indian Savages whose known rule of warfare, is an undistinguished destruction of all ages, sexes and conditions.

In every stage of these Oppressions We have Petitioned for Redress in the most humble terms: Our repeated Petitions have been answered only by repeated injury. A Prince, whose character is thus marked by every act which may define a Tyrant, is unfit to be the ruler of a free people.

Nor have We been wanting in attentions to our British brethren. We have warned them from time to time of attempts by their legislature to extend an unwarrantable jurisdiction over us. We have reminded them of the circumstances of our emigration and settlement here. We have appealed to their native justice and magnanimity, and we have conjured them by the ties of our common kindred to disavow these usurpations, which would inevitably interrupt our connections and correspondence. They too have been deaf to the voice of justice and of consanguinity. We must, therefore, acquiesce in the necessity, which denounces our Separation, and hold them, as we hold the rest of mankind, Enemies in War, in Peace Friends.

We, therefore, the Representatives of the united States of America, in General Congress, Assembled, appealing to the Supreme Judge of the world for the rectitude of our intentions, do, in the Name, and by Authority of the good People of these Colonies, solemnly publish and declare, That these united Colonies are, and of Right ought to be Free and Independent States, that they are Absolved from all Allegiance to the British Crown, and that all political connection between them and the State of Great Britain, is and ought to be totally dissolved; and that as Free and Independent States, they have full Power to levy War, conclude Peace, contract Alliances, establish Commerce, and to do all other Acts and Things which Independent States may of right do. — And for the support of this Declaration, with a firm reliance on the protection of Divine Providence, we mutually pledge to each other our Lives, our Fortunes, and our sacred Honor.

The reason I ask this is that I am currently knee-deep in brötchen in Germany, but my blog posts are updating on schedule. Before I left, I wrote out all of the scheduled posts so that there is no hiccup for my readers. Lucky you.

However, one of my favorite parts of blogging has to fall by the wayside: the comments. You can still write them, but they won’t be approved until I return. I may get some computer time, but I have no desire to plan my trip around my blog.

My blog gets about 35-40 spam comments a day, and that’s what gets through my spam filter. I don’t give a damn about advertising, and I only really hope to pull in enough dough each year to meet my hosting costs. The real value to me is the comments. Don’t get me wrong, you can still write them, and I encourage it! I just don’t see the incentive when I won’t see them for two weeks.

I thought about signing up for a comment filtering service or trying Akismet, but Murphy started to whisper in my ear:

What if it is broken when you are gone? Well, that’s probably not likely to happen. These services have been working for a while, and they probably have a pretty high success rate if people use them.

You’ll be gone for over two weeks. By the time you get back, who knows how many spam comments slipped through the cracks? OK, you got me there Murphy.

Basically, the fact that I could go so long without being able to repair any damage is a deterrent for me. This obviously discourages discussion, because commentors want to tell me how much I suck NOW, not in 2 weeks. However, I feel that the potential risk (posts with a hundred spam comments each) outweighs the reward. It doesn’t sound so bad, but it personally bothers me.

This comes down to a fundamental issue: I don’t trust the accuracy of algorithms that predict the behavior of people. Yet. Even the best service that I have, GMail, still throws some of my valid email into the spam folder! If even the best service can’t do the work 100% right, I don’t see why I should trust one I’ve never used. When I am deciding between the evil and stupidity of the world versus the performance of an algorithm, I still have to give the upper hand to the evil.

I’d ask you what you think, but you have no incentive to comment! Enjoy your day.

“Say you want to watch a movie. To choose, you’ll want to know what movies others liked and, based on what you thought of other movies you’ve seen, if this is a movie you’d like. You’ll be able to browse that information. Then you select and get video on demand. Afterward, you can even share what you thought of the movie.

But thinking of it only in terms of movies on demand trivializes the ultimate impact. The way we find information and make decisions will be changed. Think about how you find people with common interests, how you pick a doctor, how you decide what book to read. Right now, its hard to reach out to a broad range of people. You are tied into the physical community near you. But in the new environment, because of how information is stored and accessed, that community will expand. This tool will be empowering, the infrastructure will be built quickly and the impact will be broad.”

~Bill Gates, Playboy 1994

I love reading old predictions and seeing where people went right, and where people went wrong. Interestingly, we have a dead-on prediction that Microsoft has failed to profit from. The community-driven Web 2.0 phase has come, and Microsoft still has not figured out a great way to make money from the web community, even though they had a 10 year ideological head start on everyone else.

To use his movie example, IMDB, RottenTomatoes, and Amazon pretty much run the market on movie reviews.

Microsoft even had all of the pieces to do AJAX in place six years before anyone else, but nothing came together until it was too late.

The lesson? Predicting the future is hard, even when you get it right.