Today it finally came out in the national news that the Macondo Oil Gusher is pouring an order of magnitude more oil per day than the previous estimate and two orders of magnitude more than BP’s initial statement. The people who have been tracking this disaster obsessively since it first went public were not surprised.

Why? Because at every single level every single part of this disaster has reeked of optimism and under-valuation of risk.

I don’t think I’m unreasonable. I think BPs engineers are probably the most qualified to be dealing with this. I don’t think that BP executives are eating pelican stew and shrugging off the serious ecological, economical, and health-related implications.

I do think that there is a suspicious lack of well warranted hysteria. The estimates of worst-case scenarios are seriously lacking in imagination. An issue we’ll have to deal with for years? Give me a break. Barring some miraculous technological advancement (which I hope for daily) the amount of oil that has *already* been pumped into the gulf will not stop being a problem within our lifetime. What is the real worst case scenario? Well the flow can be far worse than reported…check. It can decimate one of the region’s strongest economies…ah. It can be an especially bad hurricane season…hmm. It might prove impossible to clean oil out of the wetlands…oh. Oh, and what if there’s some horrifying toxic air effects from the giant oil slick…shit. Want more? What if the oil in the wetlands causes their complete and utter disappearance within a year or two? Then New Orleans becomes a barrier reef. What if the relief platform fails? What if (the rest of the US pay attention – this concerns you) it gets in the gulf stream? Let me be clear:

THE EARTH IS SPEWING
HUGE AMOUNTS OF BLACK POISON
MILES FROM WHERE WE LIVE

Hey, that’s a haiku!

How the hell are people not panicing? Is it perhaps that we’re optimistic and underestimating the risk? It’s friggin’ tragic.

And what the hell is BP doing anyways? My understanding is that they’re following along with the stop-a-blowout playbook. I don’t have any problems with this except they’re being too damn optimistic. Why on earth did it take so long to get the first dome into place? It seems because there was a lack of preparation based in poor risk assessment. When it failed and they decided to try a smaller one why the hell was it not already on the way? Because they were so damn sure the first one would work. There are dozens of different high-quality ideas pouring in (my favorite: bunker buster aimed right at the pipe). What are they going to try next? How close are they to pulling that off if the current attempts fail?

Under current law, BP liability is capped at 75 million dollars. This is a number that they have already reached and surpassed. Easily. If I was a cold-hearted, hand-wringingly-evil executive I would tell my engineers to stop trying so hard. Why expend more money and effort? Why take risks and keep the story in the limelight. I would say let ‘er rip until we get that second rig into place. We’re paying the 75 mil already anyways.

I don’t think that anyone at BP is actively this evil. I’m a strong believer in that there is no “they”. Corporations and governments don’t have plots and opinions. I am always the first to point out that “they” are always just people, usually with contrasting motivations, goals and ideas. I think “they” are all concerned and consciencious. But I also think that they have a clear conflict of interest and a poor track record of correctly assessing risk.

So why in the world are “they” still in charge? I’m not saying that everyone should be canned. I do not think that Obama needs to park himself over the pipe and try to figure out how to clog it (chucking executives and regulators at it sounds like a decent enough idea). But I do think that the urgency of the situation warrants new incentives be introduced. I’m a fan of putting the military in charge. They have actual experience running things when lives are on the line. They know that being optimistic is anathema. Give them the keys to the kingdom.

Obama has never expressed much kinship with the Bayou though I do believe that he is trying to make the best decision for the situation. I think eventually he will declare a natuional emergency and command the military to take over. I think he is delaying because he doesn’t want the Federal government to be in charge of an operation that might be doomed to failure. I think he hopes that BP can stop this. I think he’s being optimistic. I do not get a sense of urgency from him.

I think its high time that we all panic.

Right at the top of that list is any time that I am forced by language limitations into redundant code. Notably, casting. Take the following for example:

var dictionary = new Dictionary();
dictionary["name"] = "Snoopy";
dictionary["number"] = 8;
int dictinary["number"] = (int)dictionary["number"]

That last line bothers me a lot. I already told you that I expect an integer on the left hand side, why do I have to cast too?!.

Last night I thought I had it figured out. The get by index handler would return a new “TypedObject” instance which would then contain an implicit converter that would do all the casting for us. However, due to the hopelessly (and stupidly) limited nature of the implicit operator this was a no-starter.

Half an hour after I went to bed defeated, I leaped back out of bed full of vigor and brainy-ness. With hands trembling I made my changes and ran my tests:

[TestClass]
public class When_retrieving_from_TypedDictionary {
  TypedDictionary _dictionary;
  MemoryStream _stream = null;
  [TestInitialize]
  public void Setup() {
    _dictionary = new TypedDictionary();
    _dictionary.Add("DateTime", DateTime.Parse("01/01/2010"));
    _dictionary.Add("String", "hello friends");
    _stream = new MemoryStream();
    _dictionary.Add("MemoryStream", _stream);
  }
  [TestMethod]
  public void can_get_datetime() {
    DateTime dt = _dictionary["DateTime"];
    Assert.AreEqual(DateTime.Parse("01/01/2010"), dt);
  }
  [TestMethod]
  public void can_get_string()  {
    string str = _dictionary["String"];
    Assert.AreEqual("hello friends", str);
  }
  [TestMethod]
  public void can_get_reference_type() {
    MemoryStream stream = _dictionary["MemoryStream"];
    Assert.AreSame(_stream, stream);
  }
  [TestMethod]
  public void dont_need_to_cast_at_all() {
    Assert.AreSame(_stream, _dictionary["MemoryStream"]);
  }
}

They passed!

I’m a genius! I’ve figured out how to do something nobody ever had before!

Well not really, though it is an unexpected application of a C# language feature. You see, at my new job at EPS we’re using C# 4.0 on a project. As we all know the biggest hullabaloo with C# 4.0 is the introduction of the unassuming dynamic keyword. Honestly, as a fan of dynamic languages like javascript and ruby I’ve been concerned that I would abuse it and always abstained – it doesn’t do anything that you couldn’t do with a dictionary after-all.

Well, it can do one thing – implicit type-casting! So presenting, the above mentioned (and dead-simple) TypedDictionary:

public class TypedDictionary {
  readonly Dictionary _storage = new Dictionary();
  public dynamic this[string key] {
  get { return _storage[key]; } }
  public void Add(string key, object obj) {
    _storage[key] = obj;
  }
}

It works, I promise. How awesome is that?

I have put in notice at my current company and starting February 21st I will be working full-time at EPS Software.

For me? That’s a big deal. For anyone else? Not so much. This post is a placeholder for expounding on this later.

Therefore, although I already have 2 articles written, I am holding off on publishing any new ones until I have time to go back and re-write the one that got lost.

Sorry guys, but that’s the way its going to be for now. Hopefully I can get them all up by the end of next week.

Bing image search demands that you appreciate its features. Its annoying annoying featurs.

I will say it proudly. I use lambdas. I use them a lot. I use them everywhere. I think they are an incredible and elegant language feature to the point that I would never go back to a language that does not include them in its basic tool-set. (You hear that Java? I’m not going there.)

At the same time I see far too many developers who are confused by the topic. I am planning a blog series on why I think that lambdas are so great, how I use them and why you should to. The series will be broken down into several parts and will tentatively cover

• Intro, definition and syntax.
• Using lambdas to refactor similar code structures for ultimate DRY.
• Using lambdas to publish and subscribe to events the easy way.  Using them to adapt to method interfaces.
• Using lambdas for defered (and run-time overwritable) execution.
• Strategy pattern with lambdas in a hash.
• Using lambdas for fluent interfaces.

I’m unsure yet how many parts I will be breaking the series into but I feel like most of these can be a medium to long blog post in themselves so I’m sure I’ll be kept busy for a while.

And yes I do realize the available “Give up the Func” pun.