Aaron's Technology Musings

Unit Test Framework for Silverlight: UnitDriven

aarone — Wed, 16 Jul 2008 11:58:00 GMT

Some of my colleagues at Magenic, Justin Chase and Rocky Lhotka, have developed a very nifty framework for unit testing Silverlight apps - UnitDriven.

In particular, it is optimized for testing asynchronous code in Silverlight, which is virtually impossible with existing unit test frameworks - both from Microsoft and elsewhere. More details are available from the CodePlex site.

What the F#? - Role of F# in your Future Development Plans

aarone — Tue, 08 Jul 2008 01:27:00 GMT

Video: What the F#

In this video from TechEd Online, recorded at Teched last month, Amanda Laucher (aka Pandamonial) and I talk about what F# is, why you should care, and why functional programming matters.

In an amazing coincidence, Amanda happened to have printed a F#TW t-shirt (i.e. F# For The Win, for those unaccustomed to the meme) - which is particularly ironic given that is an anagram of our interview :)

9 Questions Series- Chris Williams aka Blogus Maximus

aarone — Wed, 02 Jul 2008 14:04:00 GMT

Chris has done the hard work of compiling a very interesting interview series with some notable, not to mention fairly obscure, people in the .net community. Definitely worth checking out to get a sense for who all those folks are that you meet at TechEd and similar events.

DuckCallLib v0.2, Introducing object.As

aarone — Tue, 01 Jul 2008 19:31:00 GMT

Scratching another itch, and after reading some feedback from mihailik on my previous post - I decided to implement some additional functionality in DuckCallLib to make it more useful. As before, the bits are available on codeplex.

So, again, with great fanfare, I introduce my first cut at an dynamic proxy mechanism that works generally for objects that leverages the duck typing mechanism we previously built. The purpose of this is to allow a consumer of an object to recognize when an object they don't control has certain behavior, and without having to implement a wrapper on your own, simply apply an interface to the object at runtime, whether it explicitly supports the interface or not.

Usage is generally as follows:

interface IEggable { string LayEgg(); }
class Platypus { public string LayEgg { return "egg"; } } //notice it does not implement IEggable

//we don't know for sure if a platypus can lay eggs, since we are dealing with it as an object, but we can try
object someObjectThatMightLayEggs = new Platypus();
var eggLayingPlatypus = someObjectThatMightLayEggs.As<IEggable>();
Assert.IsTrue(eggLayingPlatypus.LayEgg() == "egg");

Still a work in progress. I doubt I handle generics well, and I need to something other than crash on method missing, but the hardest part (for me) - generating the dynamic proxy that implements the interface dynamically using Reflection.Emit (ugh) is done.

Enjoy, and as always, feedback is appreciated.

Update, duh moment, I just realized I started to re-implement this (Jason Bock) and this (Castle Project). Ah well, if nothing else, going through creating one of these has given me a much better sense for how to do nifty stuff with Reflection.Emit.

Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C#

aarone — Thu, 26 Jun 2008 16:38:00 GMT

Scratching an itch today, thinking about code I have written in the past to attempt to do duck calls in C# (that is, call a named method without explicitly knowing that it even supports the method) - I decided, what the heck, why not just write the extension method over object required to do duck calls.

So, with great fanfare (ha!) - I have published DuckCallLib on codeplex (codeplex.com/duckcalllib). This is hardly a big project, more like a handy piece of code that allows you to not have to dig through reflection yourself every time you need to handle a duck typing scenario from C# code.

Let say we have a simple class, such as this:

public class RandomClass
{
    public int AddNumbers(int op1, int op2)
    {
      return (op1 + op2);
    }

    public double AddNumbers(double op1, double op2)
    {
      return (op1 + op2);
    }
}

Now, lets say we want to call "AddNumbers" without knowing anything about RandomClass:

      object rndClass = new RandomClass();
      object two = rndClass.DuckCall("AddNumbers", new object[] { 1, 1 }, null);
      Assert.IsTrue((int)two == 2);

Or, a more complex and meaningful scenario, we want try to make a call, but have a lambda get invoked if the method is missing:

      Func<object,string,object[],object> methodMissingHandler =
        (source, methodName, theParameters) =>
          (decimal)theParameters[0] +
          (decimal)theParameters[1];
      object rndClass = new RandomClass();
      object two = rndClass.DuckCall(
        "AddNumbers",
        new object[] { 1m, 1m },
        methodMissingHandler );
      Assert.IsTrue((decimal)two == 2m);

As you can see, ruby this isn't. It is not nearly as clean syntactically as I would like it to be. However, given the current limitations of the C# language, this is what I have been able to come up with. If anyone has other ideas, I certainly encourage anyone to send em my way.

Enjoy!

The Summer F# Tour

aarone — Thu, 26 Jun 2008 03:28:00 GMT

This Summer, I am very excited to be doing a couple talks on F# around the midwest.

On July 8th, I kick things off in Bloomington Illinois, where I will be covering the overview and the details about not only how to do useful things in F#, but why you should do useful things with F#. It is a talk that, I hope, gets people excited about functional programming in general, and F# in particular.

In August, I visit South Bend, Indiana, where I will hopefully reach another audience to again spread the good word about F#.

Then in early September, I come back to Chicago, where I will be doing a couple sessions at the upcoming Chicago Day of .NET (tentative title), one of which will be about F# :)

In all cases, if you can make it, I very much look forward to meeting you and having not only a talk, but ultimatley a dialog about what functional programming in general, and this language in particular, means to you as a software developer.

BI Presentation is Published

aarone — Tue, 17 Jun 2008 16:33:00 GMT

My talk last April on Business Intelligence is up on the Technology Executives Club website.

Business Intelligence continues to be an enterprise that, in my humble view, tends to be too tied to particular products, and not to specific domains. When people look for BI experts, they look to expertise with some variant of a tool, rather than expertise in a relevant domain. This, and the fact in general that BI is tightly coupled to persistence technology (i.e. databases) I believe is a barrier to doing effective BI, as when the limiting factor becomes technology expertise rather than domain expertise, it limits the talent pool greatly.

Similar to those who see SOA through the lens of product companies that push SOA solutions, rather than as a broader architectural concern that should be technology independent, it seems BI should be seen not in the lens of Oracle, Microsoft, or any other software vendor, but through a more outcome oriented lens. That is, BI solutions should be things that you buy to help you achieve particular functional goals (i.e. increase sales) - with BI technology competing on the basis for efficiency in enabling those goals.

New i4o Release Published - i4o 0.91 Beta 2

aarone — Sun, 08 Jun 2008 21:47:00 GMT

Well, it's about time, but after a hiatus to work on implementing indexing in CSLA.net, I have provided some very badly needed updates to i4o.

Added are the following:

* POCO support

Indexable collections can be done over existing classes. Indexes are added using the AddIndex(string property) method, where by adding the index by naming the property, an index gets created for current items, and all future items. RemoveIndex(string property) is also added.

* Remove fixed

The remove method has been properly implemented.

* Unit test suite

A unit test suite that achieves over 90% code coverage has been added. Future development will be done via Red-->Green-->Refactor. :)

* VB String queries supported

An issue where VB queries that use strings were not being indexed due to VB replacing a standard string compare with it's own string comparison method call. That corner case is now handled.

As always, you can download the new bits by going to codeplex.com/i4o

Safely home after TechEd

aarone — Sat, 07 Jun 2008 04:19:00 GMT

After some flight delays and the normal fun one has while navigating airports, yours truly is back home.

Next on the agenda technology-wise is an refresh with a couple of minor bug fixes for i4o, as well as dynamic indexing capability. I found an issue with i4o in how it handles VB string comparisons and it not recognizing it can take advantage of the index on those (darned conversion of x == y to String.Compare(x,y)) - issue is resolved (had to for the demo) - but given I am already in there again, it is a good occasion to do some other updates as well that I have been putting off for too long.

As well, I am pleased to announce that myself and Amanda Laucher (aka Pandamonial) did a very fun video cast from the TechEd Fishbowl appropriately called "What the F#", that should be published soon and explains some of the reasons that developers and their bosses ought to be interested in this new, exciting technology coming from Microsoft (link will be forthcoming when they publish it).

All in all, an amazing experience as usual.

P.S. If you are ever at Universal Studio, the Simpsons Ride is a must see.

Day #2, Highlights, and why UX matters

aarone — Wed, 04 Jun 2008 12:30:00 GMT

Spent some time at the C# booth, managed to catch Hanselman's talk on MVC, caught David Platt's "Why Software Sucks" talk, which was pretty neat and engaging. The latter was interesting for me as I have been of the same opinion for some time, especially since the reason that it often does is related to very poor user interaction design.

Which really gets me to the biggest development, in my view, that has occurred with .NET this year. No, it's not LINQ, it's not EF, and it's not even F# (that will be next year :p) It is WPF and Silverlight finally giving control of the UI to a user experience person. Platt's talk, which reminds us that people use software as a means to an end, not as the end in itself, reminds you that yes, you need to really think hard about how usable your application is. In the end, unless you are writing Lord of the Rings Online or World of Warcraft, most people want to spend as little time in your application as possible.

A lot of corporate software, frankly, goes unused. And a big reason is that there is a lot of really unusable corporate software (not to mention "shelfware" commercial software). Providing good UX is a critical factor to actually realizing your technology investment. The days where UX is considered "extra fluff" are long gone.

TechEd: Gates Keynote

aarone — Tue, 03 Jun 2008 14:32:00 GMT

A good presentation, very interesting, but especially worthwhile was the "last day at Microsoft" video and the robot version of Steve Ballmer doing a robot version of the "Developers, Developers, Developers" monkey dance.

Evening #1 at TechEd

aarone — Tue, 03 Jun 2008 04:15:00 GMT

Well, no "Technical Education" yet, but...

a.) spent a couple hours practicing my speech for Thursday

b.) networked with some folks from MSFT

c.) avoided recording embarrassing podcasts :)

All in all, mission accomplished!

IEggable? Learn about it on Deep Fried Bytes #2

aarone — Fri, 30 May 2008 22:31:00 GMT

Keith Elder's new podcast is up and rolling, with the second episode featuring a bunch of us that were, ahem, enjoying ourselves quite a bit at the MVP summit last April. Very funny stuff, especially towards the end.

Fixed Bid Projects and Naked Call Options

aarone — Wed, 28 May 2008 21:10:00 GMT

Part of my role at Magenic for the Chicago office is that I am the person who writes the proposal, facilitates getting an estimate from our technical people, and negotiates with clients to determine how the project will be structured. Frequently, we come upon requests from clients that they would like us to bid on the work with a fixed price rather than a time and materials quote that is "open ended".

Of course, having been on the other side of the table in my career, as a buyer of technology services from firms like ours, I completely understand where the impulse comes from. You worry about cost overruns, about a vendor coming in and under-performing while you continue to pay the bill. Indeed, especially when you have real P&L responsibility, it is a scary thought - like getting in a taxi and asking a driver whom you may or may not trust to take you to some ambiguous location that you have only the faintest idea of where it is. Especially knowing that the way they make your budget is that they give you X certain dollars to accomplish Y.

I like analogies to financial services terms because, at least, there is some math that backs them up and allows you to price risks, such as using the Black-Scholes model for option pricing. So here goes. When a client finds they need a software solution, in financial services terms, they are “short” the solution. That is, they have a need, which requires them to go the market and purchase it, just like someone who is “short” a stock has a requirement to go onto the open market and purchase said stock. The same would be true if you are without a house, and needed to buy one, you are considered "short" housing. Generally, it means that you will benefit if the price of housing falls, but you will suffer if the price of housing rises.

There are two ways that the organization that is “short” a software solution can go about purchasing it. One is to simply buy the solution (aka a T&E project) – over the course of a year, which will expose them to market risk (price of solution could rise, just like the price of a share does) - or, in the alternative, they can purchase a “call option” to purchase the solution at a fixed price, which means that they pay a premium for the option, just like you would if you purchase an option to buy a stock at a given price one year out. The premium can often be substantial – even in the world of stock options, where “at the money” options (i.e. option to purchase at today’s price) one year out often sell at 20% or more of the value of the stock itself.

As a solution provider, we are either net sellers of “solutions” – i.e. going short people that we have in inventory – in the case of a T&E project, or we are writers of call options on people in the case of fixed bid projects. In other words, the appropriate term for what we do when we write fixed bid proposals is called “writing naked call options”. This link provides a good explanation of the risks involved with writing naked calls.

How does this relate to clients? Well, it is sobering to realize that when your vendor is writing fixed bid proposals, they are doing the consulting version of writing naked calls. They get a "risk premium" for writing it, with the underlying knowledge that we are taking a huge risk that has undefined boundaries - especially if there is any ambiguity at all in the body of the requirements. All other things being equal, it is much more cost effective to develop a trusted relationship with a partner where you get consistent delivery of software, than to pay the risk premium that all firms that have any premise of surviving in the long term will charge for a fixed bid project.

At Magenic, not only do we have multiple levels of oversight for all fixed bid projects, but we also dictate that we do the project management (to further manage the risk), and as well, agree to a change order process that assures that additional work that is outside the defined scope is separately paid for. So we engage in some traditional risk mitigation that helps us manage the downside risks when we do fixed bid projects.

However, it is all for naught if we write a fixed bid, allow our sponsor to go to a finance committee and get a budget number on the basis of that number, and then have to "change order" them to death, which over the long term can break down the trust between client and vendor, absent expectations from the start that the number should be more flexible (which of course begs the question, why fixed bid then?). While it protects us from the worst consequences of the naked call, it does not protect our sponsor, who often deals with a body that is not going to be interested in how we get to a result, only in the result itself, and the short term bottom line impact of getting there. Therefore, even in a case where our own risk mitigation is perfect, there is a great deal of residual risk left over when we do fixed bid projects.

So, what to do about this? Well, as with all things in life where nuance is required, it depends. Having worked at a major accounting firm myself, I understand the market realities that demand service providers that are willing write call options and "insure" against requirements change. That said, living in the world of technology, I understand that opportunities emerge during the entire course of the project, especially in requirements and envisioning phases. Thus, you have to ask yourself as a buyer what is more important - price certainty or agility? Or a mix of the two that moves to a higher degree of price certainty after a shorter "agile" period that at least gets a good set of requirements. Or better yet - though certainly not always viable, the ability to have some flexibility in the annual budget cycle when opportunities arise so you can prioritize throughout the year as opportunities emerge - i.e. the ability to six months into the year to pull from one project into another if one area looks promising and perhaps another less so.

Regardless, it is important to understand that there is not a company on Earth in the technology services business - at least one you want to deal with (aka one that has financial viability) - that will trade risk for nothing. Price certainty for a good that isn't defined to exact specifications is always going to come at a cost, and while that is sometimes required, having a constructive and trusting relationship with your provider that has transparency about cost, opportunity, and risk on an ongoing basis will save you money and, frankly, lead to greater project success.

See you in Orlando

aarone — Tue, 27 May 2008 19:16:00 GMT

On June 5, early in the morning, I will be doing an updated talk on building indexing capabilities in your Linq-to-Objects queries. Updated because:

* I am including a VB element in my talk, based on some good feedback from Julie Lerman. One of the 3 demos will be in VB.

* I will be debuting ranged query capability, which I now have working in LINQ to CSLA. Once it is debugged, I will be porting it over to i4o as well.

If you are a reader and you happen to be at TechEd, hit me up for a beer - I am always up for a good debate on technology :)

Until then, I am likely to be very much heads down polishing my presentation up as we get ready.