Did I end up putting way too much faith in the salesperson’s opinion of how the frames looked? Should I have brought along a helper to select my frames? Should I have just worn contacts and avoided this problem? Did I buy lady’s frames?

I think there’s a simple way to modify this process and I’m hoping some eyeglasses store has done or will do the following:

1. buy a Mac with an iSight camera
2. start PhotoBooth
3. let customers take potential glasses to the Mac and collect photos of themselves trying on frames
4. review photos while wearing your old glasses

I think this process would be beneficial even if your vision is good enough to see yourself in the mirror. It’s nice to be able to quickly compare different frames in succession without having a pile of frames in front of you and swapping back and forth between frames.

There is also an opportunity to build a piece of software that would be a bit more specific than PhotoBooth and allow notes to be associated with photos (such as the model of the frame) and to organize photos by customer. I’ll put this idea on my list of software that seems interesting but will never be built.

Next time I buy glasses I think I’ll take along my laptop.

One interesting thing that he mentioned was how innovative technologies can be derived by simplifying existing technologies. This was the case in the derivation of XML from SGML. SGML predates the rise of the Internet but SGML was not widely adopted as a general markup language for the Internet due to its complexity. XML was created as a simple profile of SGML and its simplicity caused it to become so prolific.

This immediately reminded me of an ACM article I read by former Googler Adam Bosworth. He mentioned the problems of scaling traditional databases:

1. Have databases enabled people to harness Moore’s law in parallel? This would mean that databases could scale more or less linearly to handle both the volume of the requests coming in and even the complexity. The answer is no. Things like ORDER BY, joins, subqueries, and many others make it almost impossible to push the query logic down to an arbitrary number of leaf nodes and simply sort/merge/aggregate the results. The easier way to limit queries to avoid this would be to limit all predicates to ones that can be computed against a single row at a time, at least where efficiency and scale are paramount.

As I consider all of the available alternatives to relational databases (CouchDB, SimpleDB, BigTable/AppEngine, HBase, Cassandra) I’m struck by how we could benefit from a simplified SQL dialect that would be more suitable for scaling across multiple machines (ie ‘horizontal scaling’). I’m hoping a standards body takes this on in the near future but I fear that the problem will get worse before that happens.

This is all true but hides the role of the federal government in creating this problem. The federal government has kept interest rates artificially low since 2001 and this factor played a large role in inflating the real estate bubble. The free market is not solely to blame: it was propped up by the Federal Reserve. It appears that the Fed has played a large role in creating this mess and they are now struggling to clean it up. I have doubts that they’ll be successful.

The Fed intervened during the collapse of Bear Stearns. It’s not clear what caused the run on Bear Stearns but when it happened, the Fed stepped in to rescue the company (at a great loss to Stearns shareholders). The concern was that if Bear Stearns would fall, others would follow. I generally agreed with this action as many economist’s statements indicated that panic was spreading and could bring down more securities firms.

Now, we come to the collapse of Fannie Mae and Freddie Mac; a case where the government’s role in the ‘industry’ has been disastrous. The government may have temporarily saved the two companies, but it’s clear that the current system of government subsidized mortgage companies should not continue to exist the way it does now.

Today, I heard Jim Rodgers reaction to the Fed intervention:

I don’t know where these guys get the audacity to take our money, taxpayer money, and buy stock in Fannie Mae,” Rogers, 65, said in an interview from Singapore. “So we’re going to bail out everybody else in the world. And it ruins the Federal Reserve’s balance sheet and it makes the dollar more vulnerable and it increases inflation.

I agree. The Fed’s interventionist ways cannot continue; something’s got to give. Who’s next? Washington Mutual, Lehman, or Citigroup, or something else?

Java adopted C’s convention for arrays:

    int[] x = {1,2,3}

which work fine if I want to use arrays; but I rarely use arrays because I like OOP and I usually want to do things with my data structures like call methods on them. So, I typically use a list which I could declare like this:

    List l = new ArrayList();
    l.add(1);
    l.add(2);
    l.add(3);

… but I don’t do that because I don’t like warning about not using generics properly so I usually declare the list in this even more verbose way:

    List<Integer> l = new ArrayList<Integer>();
    l.add(1);
    l.add(2);
    l.add(3);

The problem with both of these alternatives is that you really can’t “see” a list. You just see an allocation of a list container followed by three method calls. This really obscures the data structure in unnecessary logic.

Sometimes, in an effort to make my data structures less obscure, i create a list like this:

    List<Integer> l = Arrays.asList(new Integer[]{1,2,3});

Of course, this isn’t really a good idea because that list is immutable but it looks like it’s mutable which is kind of scary and weird to anyone who might expect this list to support operations like ‘add’ or ‘remove’ defined in the List interface.

To get around that problem, I’ve seen code that looks like this:

    List<Integer> l = new ArrayList<Integer>(Arrays.asList(new Integer[]{1,2,3}));

which is, well, ridiculously awful.

This problem only gets worse when I want to do something outrageous like define a map for which I have no primitive like an array to help me out. This leads to a long series of put() invocations which makes me a little nauseated.

The fundamental problem is that Java has no literal representation for basic data structures. I’d argue that this deficiency led to the proliferation of XML in Java projects for defining data. I can’t think of another language whose users get so much pleasure out of something like Spring. Ruby users wouldn’t understand why you’d want to model parts of your application in a markup language: why not just use Ruby?