I can’t thank the contributors enough for their help, and also the people who stick it out with me on the Issues list at Github. It takes me a while sometimes – but I’ll get there!

Here are the fixes:

• FIXED: Issue with ActiveRecord where pre-setting the PK was overwritten by attempt to read from DB
  FIXED: SimpleRepo sample site errored out when posting new post
  FIXED: PK not set to non-nullable and AutoIncrement when declaring explicit PK using attributes on class property. AutoIncrement is now set for numerics
  ADDED: If you declare a Guid as your PK using SimpleRepo, we will be default add a constraint (SQL Server only) which defaults to NEWID()
  FIXED: StoredProcedure command parameters were not passing propery DbType, resulting in a sql_variant error
  FIXED: == null operation using Linq was creating invalid SQL (I think I got this right this time)
  ADDED: Setters for ActiveRecord properties now see if value has changed before firing OnChanged and making column dirty
  ADDED: Core Load<T> routine now checks to see if the class implements IActiveRecord and if so, will set IsLoaded to true (and call OnLoad())
  ADDED: Fork from HaakonL which deals with nullable strings (SubSonicNulLString)
  REMOVED: Removed sample sites from source

You can get the lastest drop here.

The only way that seems to capture the main elements of Git is that it’s peer-to-peer source control with a heavy dose of Social Networking.  There is no centralized source – everyone has their own disconnected “repository” (which is called a “branch” in Git parlance) that you merge when it makes sense to. When you do run a merge, your version history is merged as well – making a very weird “Facebook meets Source Control” kind of experience.

Git as Source Control Management
I got a tweet tonite from Mohammed Meligy that I really want to address:

@robconery why (in an organization) would I choose Git over SVN ?

And the answer is: I have no idea. Git has its strengths for Open Source, to be sure, but for the Enterprise I just don’t know and I would say you should probably be afraid. I have a lot of opinions about this as both developer and Lead Geek, but I think I’ll summarize it here for you:

• Developer: I love shiney stuff!
• Lead Geek: Do what works!

Source Control is something you don’t want to mess with and if your system is working for you – that’s a perfect, irrefutable argument. TFS is light years ahead of anything Git can provide in terms of workflow and process management – and if these things are important and working for you – then you have no reason at all to change; in fact you have many reasons not to.

Subversion is a good system to – it just happened that in our case I needed more than one repository and Github fit exactly what I wanted.

Working With Github and SubSonic
If you want to know how to work with Github (as far as SubSonic is concerned), I made a quick (10 minute) screencast on how to get up and running on Git, and then how to fork/push our source. This is a really bare-bones intro, and I’ve also added it to our wiki.

Download here

Double-click for full screen

Here’s the quick list of fixes and adds:

• FIXED: Issue 2 – Out of date Classes.tt file for ActiveRecord. I fixed this within an hour of issuing the 3.0 download and reset the download.
• FIXED: Issue 3 – “!=null” results in incorrect SQL
• ADDED:  Issue 4 – SubSonicRepository should set PK on Add
• CHANGED: Issue 5 – SPs should accept nullable type arguments by default
• CHANGED: Issue 10 – Reset foreign key columns to use “CleanUp” method to avoid naming issues in ActiveRecord
• ADDED: Issue 11- SimpleRepository.All<T>() and Exists<T>() now run migrations
• FIXED: Issue 12 – There was a view error in the SimpleRepo example on Create.aspx.
• FIXED: Issue 13 – Add() was not properly setting IsNew to false on Save/Add (ActiveRecord templates)
• ADDED: Issue 14 – Merged fork from MBP to address a better way to handle Logical Delete column with Settings.tt (thank you!)
• FIXED: Issue 15 – Migrations for SQLite were not setting “integer” for PK so AUTOINCREMENT was not being honored.
• FIXED: Issue 20 – ActiveRecord templates were incorrectly setting “string” as system type for integer fields with MySQL. I also fixed issues with small and tinyint
• ADDED: Merged fork from BlackMael which added VB Templates. Thanks!

Many, many thank you’s to the people who’ve helped with the issues and contributed code (Troels Thompson, John Sheehan, and Martin Harris).

GitHub is Awesome
I’m sure you’ve read this before about Git and Github with respect to Open Source projects and source control – but this system is really on fire. Within 2 days I was merging various forks and bug fixes – leveraging all that is good about Git – and it’s helped beyond measure.

For instance – John Sheehan merged one of his forks and I didn’t need to open a diff tool to figure out what he did – Github showed me precisely what was changed, and where. In addition I can leave comments on his stuff if I like – or change it right there if needed!

I’m working up a wiki page to show people how to fork/pull to help us fight bugs so if you want to know more about Git – hang tight I’ll have something in the next few days.

The download has been updated on our project site so if you’d like to grab these changes – they are ready to go.

A Note About The Wiki Being Down
As many may know, the wiki went down a few times over the last few days. MySQL is timing out on me – the service is just flat crashing. I’ve set it to restart when it crashes (after a wait of a minute or so) so this should stop happening. However I’m looking into alternatives to make it run a bit smoother. I’m on it – sorry for the problems.

So, what’s new? Well…

• A nice Linq engine which parses IQueryable “stuff” into SQL (thanks to Matt Warren’s excellent work with the IQToolkit, which we stole mercilessly).
• A templating system which allows you to use ActiveRecord, good old Linq in Linq to SQL style, or whatever floats your boat.
• A SimpleRepository which is just about zero-drag and even builds your database for you
• A brand-new project site that will hopefully answer the question “is SubSonic dead”? Or probably not
• A new docs site that has permanently crushed my ability to type. It’s a wiki so if you feel like being helpful and like SubSonic and want to help… nudge… nudge

Should You Care?
That’s a tough question – so it’s the first I’ll address.

• If you like Linq and you’re not working with SQL Server and EF is a bit much for you – yes.
• If you like Linq and you are working with SQL Server… well nobody ever got fired for using Microsoft so “maybe”. Linq to SQL is awesome and it’s not dead .
• If you like a “low-friction” approach from a helper framework – then yes. You can’t get much lower-friction then SimpleRepository.
• If you like SubSonic to begin with, then yes. There’s still the same grooviness here.

Should You Be Afraid?
Hopefully not – I’ve really tried to test the tar out of this thing before letting it go (that’s why this took me so long). I’ve had a lot of help with this (many thanks to Eric, Paul, George Capnias, and Jim Zimmerman) and a lot folks reporting bugs (and a TON) of patches so hopefully it’s solid. That said – this is a major release and it’s also Open Source. You will need to be a bit flexible and hopefully you won’t mind helping us out. Which brings me to my final point…

Our Repo Has Moved. Yes, Again
All was going very well until 3 things happened:

1. I needed to put the 3.0 repo together with the 2.0 repo. It’s not a branch – it’s its own repo for sure. 2.2 is not a “tag” so… what to do? The only thing to do is to have the trunk split into versions which is ALL kinds of messy. I needed another repo for my project, and Google doesn’t let you do that.
2. I needed a really cool, collaborative system for our template sharing, which also should have its own repo.
3. Google SVN began to crumble and crash on me, causing me to drop/reload every week or so.

I’ve been using GitHub for a while and I absolutely LOVE it (more on that later) so with this release, we’ve moved to GitHub. I’ve kept the Google site open so we can work on existing issues, etc but I’ll be closing it in the coming month or so.

The Goods

• The new project site is here
• The new docs site is here
• The new Source site is here.

I’m going to go have a beer or five and then go blow stuff up for the 4th like a good Amrrrcan.

I think, in general, the .NET crowd overthinks and over-engineers just about everything

I said as much in my MIX presentation, where I basically challenged ASP.NET developers to “embrace their inner scripter” and stop building rockets. I have a fairly strong opinion on this – and I’ll save that for another time – but I think it’s high time to remind folks that there’s a lot more to an application then how you get your app gets it’s freak on with your database.

Good Morning!
I remember watching Fight Club for the very first time back in the thick of the very first DotCom bubble. I was feeling pretty ill that day so I stayed home and watched the DVD, and was pulled in pretty dramatically. One line still resonates with me:

You’re not your job. You’re not how much money you have in the bank. You’re not the car you drive. You’re not the contents of your wallet. You’re not your f******* khakis.

I feel the same way about building software: You’re Not Your Data Access.

When I watched that movie I had just bought a nice pair of $180 Kenneth Cole shoes to wear to a client’s VC meeting, to go with my groovy business-casual Cornflower Blue button down shirt. I clearly remember looking over at my closet – the feeling of fashion sobriety coming over me – wondering what I had turned into (if you knew me then you’d know I don’t like wearing that kind of stuff. I’m happy in a white t-shirt and shorts).

I had this same feeling when I popped my head out of the .NET community just 4 years ago (before I worked at Microsoft) to see what this “Rails thing” was all about. I remember the feeling well – and it was very, very sobering and inspiring at the same time. I remember creating an application in fairly short order with all the requisite pieces put where they needed to be put, with every tutorial urging me to “stop thinking – just build”.

Camaro Programming
The .NET platform is pretty dang powerful. It lets you build your own personal Tower of Babel if you so choose, and it can abstract away the very fabric of space-time if you let it. In short it’s a killer set of tools that any mechanically-inclined person would love to use. So naturally it can be very easily abused!

Consider my good friend Eric. I’ve written about Eric a few times before – but in summary he’s my token wrench-head friend that loves his engines and American cars. I lived with this guy for years and he rapidly filled up our garage with parts and *crap* from every car he’d ever owned. And he could dutifully tell you which part went to which car and what that part did – no matter if it was useless.

Eric built and maintained a hunk of junk 1968 Capri which we used to call “The Crappy”. This thing could drive – and I mean really drive – I think Eric pushed it to 180 mph once on a closed race course. It had that sound that all muscle cars make – the sound that makes your ribs shake and your inner 16 yr old say “coooooolll!”.

The problem was that no one ever wanted to drive in it. It smelled, it was ugly, and it absolutely sucked the gas down. Eric would steadfastly defend his Crappy because “it was the easiest car in the world to work on” and “could blow doors on any production car from any country”.

“Yah but when do you really need to go 180 miles an hour man?”

“When I race dammit”

I don’t need to draw the parallels here. I think you get it.

Let it Go Already
I want to be perfectly clear about what it is I’m saying here, and that is that it’s very, very easy for the geek inside us to whisper sweetly in our ears, saying “this Super Massive Paradigm Shifter will be the biggest application EVAR… don’t mess it up!”. I felt this very sensation when starting … well every app that I ever made.

I don’t like being wrong – no one does. So defensively I’ll be sure to include patterning where I can, making sure to separate out my projects whenever it … seems like I’ll crap for not separating out what I’m doing into another project.

I’ll use enums instead of boolean parameters.

Oh wait, no I won’t.

I’ll be sure to avoid Singletons

I’ll absolutely never use Stored Procedures, I mean seriously never, ever, ever (unless Rob Howard tells me to). Or maybe unless my boss tells me to. I’ll let Jeff decide.

I’ll always use Stored Procedures.

I won’t use NHibernate

I won’t use any ORM for that matter. Seriously – Never.

Well I might use both…

I won’t use Code-coverage to tell me anything.

I’ll be sure to use Code-coverage data to tell me everything.

I’ll make sure my method and variables are named properly on Fridays.

Reflection? Not a chance. Unless Rick says it’s OK.

I won’t use Extreme Programming (I’ll be sure to use Lean… whatever that is)

I’ll be sure not to have scrums.

I’ll also be sure not to multi-task.

I won’t use configuration either – hard-coding FTW!

I won’t use static methods

I won’t use extension methods

I’ll keep Native American stereotypes out of my code.

I’ll make sure that all my methods are public and never sealed or internal

I’ll check twice before I use any of these evil keywords.

I’ll also make double damn sure not to use regions in my code – ever.

I won’t use VB (who would?) and I’ll be sure to use C# with great care.

I won’t use Composite Keys in my database

And I’ll be very, very sure to keep away from Norway.

You wake up at Seatac, SFO, LAX. You wake up at O’Hare, Dallas-Fort Worth, BWI. Pacific, mountain, central. Lose an hour, gain an hour. This is your life, and it’s ending one minute at a time. You wake up at Air Harbor International. If you wake up at a different time, in a different place, could you wake up as a different person

Let.

It.

Go.

Summary
Simplicity is beautiful. Simple doesn’t mean hard-coding, it doesn’t mean cutting corners or being sloppy – it means building what you’ve been asked to build, not a rocket to Saturn and most of the time it’s a skateboard to the corner store.

Not every application needs to be stitched together from Codebetter posts and Twitter rants. Focus on what’s important – the experience, not what’s under the hood. You’ll change that quite a few times no matter what you think .

Elevator Summary
ActiveRecord is for people who want the biggest bang for their buck in terms of working with their data. It raises the database implementation right into the application as each object represents, literally, a row in the database.

Ruby on Rails uses the ActiveRecord pattern to great success – essentially telling people to “get over it”. Well, actually they say “F*** You” – but this is a family blog and it would be nice to keep this above board.

ActiveRecord is extremely intuitive and simple to use, but it does have its drawbacks – one of which is testability. But, as you’ll see, SubSonic has some magic here for you. Currently ActiveRecord works with SQL Server, MySQL, and SQLite.

Setting Up ActiveRecord
As with all things SubSonic 3.0 – ActiveRecord is implemented using a set of T4 Templates, which automatically generate the code you need within Visual Studio:

These templates are divided into 4 parts:

• SQLServer.ttinclude talks to SQLServer to get information about your tables
• Settings.ttinclude sets your connection string, database name, namespace, and other goodies (like the names of your classes, etc)
• Context.tt is an IQueryable layer and is akin to the DataContext in Linq to Sql
• ActiveRecord.tt is the class generator

You just set the connection string name in Settings.ttinclude, as well as the namespace, and you’re off to the races.

Working With ActiveRecord
This is designed to be brain-dead simple with no configuration or contexts to set, etc:

var product = Product.SingleOrDefault(x => x.ProductID == 1);

In the old days getting a record from ActiveRecord meant passing the key in through the constructor – but we’ve replaced that with a factory call so you can get a nice null back if the product doesn’t exist.

Each object is created with an IQueryable<T> reference to it’s foreign-key friends. These are two-way references, so you’ll get all objects that reference your main table.

You can grab a list like this:

var products = Product.Find(x => x.ProductID <= 10);

If you want your list paged, you can do that too:

var products = Product.GetPaged(1,10);
Assert.Equal(10, products.Count);
Assert.Equal(100, products.TotalCount);

Finally – if you want to work with LINQ you can using the factory method “All()”:

var products = from p in Product.All()
          join od in OrderDetail.All() on p.ProductID equals od.ProductID
          select p;

Assert.Equal(500, products.Count());

The factory methods are pretty complete and are pretty much sugar for a very Linq-y type of interaction:

The methods at the bottom there – “Setup()” and “ResetTestRepo()” are the goodness which I’ll go into now.

ActiveRecord Is Was Hard To Test

One of the things that people asked for when we rolled out SubSonic 2.0 was better testability. I remember asking Phil about this one day and said “isn’t about time we build this crap in?” and he agreed – but we couldn’t figure out the best way to do it. I thought I’d take a stab at it anyway – so here goes.

Let’s say you have a nice ASP.NET MVC application you’re working up, and you’re a being a Good Person and you’ve created a nice Test Project as well. Now you want to test your ProductController but you have plugged in SubSonic’s ActiveRecord and you don’t want to hit the database because it might make your test fail due to issues not under test (like bad data, for instance).

The good news is you can intercept the call to the database and effectively “Auto-Fake” the ActiveRecord repository, and how you do it is the funnest part. This is the App.Config in a sample Test Application:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <connectionStrings>
        <add name="Site" connectionString="Test"/>
    </connectionStrings>
</configuration>

If SubSonic sees that the the connectionString is “Test”, it will automatically work with an in-memory repository, not use a database. You can test this out by writing a test:

Product.Setup(100);
var products= Product.All().Count();
Assert.AreEqual(100,products);

By using the “Setup()” method, you’re filling the TestRepository that SubSonic uses under the covers – which is basically an IList<Product>. You can tell it how many items you want created or you can pass in your own list.

CRUD operations work as well:

Product.Setup(10);
Assert.AreEqual(10, Product.All().Count());

var newProduct = new Product();
newProduct.ProductID = 1000;
newProduct.Save();
Assert.AreEqual(11, Product.All().Count());

Album.Delete(x=>x.ProductID==1000);
Assert.AreEqual(10, Product.All().Count());

The interception will work 90% of the time for your application – however there are some circumstances where we can’t intercept the DB call – primarly because we don’t know, at the level, that you’re using ActiveRecord.

One of these places is our Linq implementation. It doesn’t know what’s calling it or why – so it won’t know it’s ActiveRecord and moreover won’t know if it’s under test – so we can’t intercept it. It should be a simple matter to test at the execution level of the connection string is “Test”, but the way we work with connections doesn’t allow for this – an Exception is thrown if a connection string can’t be parsed by the DbFactory.

Summary

One thing that I hope will become clear as we launch SubSonic 3.0 is that it’s really a core framework for you to build your DAL on using T4 templates. This is approach #2 to working with your data – tomorrow I’ll go into George Capnias’ excellent “Advanced Templates” which flex the Repository Pattern to present a very Linq to Sql-style experience.

I’ll also have a lot more to say about these on our forthcoming docs site (which I’m 70% of the way through).

It’s Rev 1, Be Gentle! I’ve put peddle to metal with this feature, using it as the backbone of my entire test suite – I think it’s pretty close to being “good to go”. That said – this is Open Source, if you find a bug I’d love your help with a patch. This is not Big Software and we won’t think of every scenario – but hopefully most of them.

Elevator Summary
The SimpleRepository is for people who don’t want a bunch of “fluff and object noise” in their application and who want their objects “to just be persisted somewhere” without having to design a DB to create an object model. It’s all about POCOs first – sort of an Object Database feel where your object is “just saved”.

This Repository is bare-knuckles, get it going quick, ZERO CONFIGURATION “just gimme my damn data and get out of my way and no don’t ask me which DB I’m using” kinda deal. I should have called it “BareKnuckleRepository”… hmmm.

It works with SQL 2005, 2008, MySQL, and SQLite. Oracle drives me crazy and if someone’s inclined the fix to put it in takes all of 30 minutes. Same with PostGres.

How It Works
The first thing is to create a simple object – I’ll use the ubiquitous Product here:

    public class Product {
        public int ProductID { get; set; }
        public Guid Sku { get; set; }
        public int CategoryID { get; set; }
        public string ProductName { get; set; }
        public decimal UnitPrice { get; set; }
        public bool Discontinued { get; set; }
    }

Next, you need to tell SubSonic about your database. You do this by using our ProviderFactory and passing in a connection string, or not:

var provider=ProviderFactory.GetProvider("SubSonicTest");

UPDATE: I just checked in a change so you don’t need to declare the Provider – it will do it for you. You can just pass in the connection string name, or nothing at all and we’ll try and guess what it is.

You can pass in a connection string name, the full connection string, or nothing at all and we’ll do our best to pull it from your config. This is basically a glorified wrapper to your database.

Then you create a SimpleRepository, passing in the provider you just created:

var repo=new SimpleRepository(provider,true);

The boolean argument there is the magic button – I’ll talk more about this in a second. This repository is very, very simple and has things like “Single, Find, Add, Update, Delete” etc. and can save bunches of items in a transaction.

For this example let’s use an empty DB I just created (the connection string above points to it):

Next, work up your Product object:

var newProduct=new Product();
newProduct.Sku=Guid.NewGuid();
newProduct.CategoryID=5;
newProduct.ProductName="Pretzel";
newProduct.UnitPrice=100;
newProduct.Discontinued=false;

And then save it using the Repo:

repo.Add<Product>(newProduct);

This is where the magic happens . By setting “true” in the SimpleRepository constructor, you’re telling it to run Migrations for you – automatically – creating your table if it’s not there.

If you refresh your DB…

Yes – if you change your model then your DB will be synchronized. No, you will not lose data (unless you’re using SQLite , which doesn’t support ALTER of anything). You can change names, types, lengths, add/remove columns etc – all without dropping the table.

Notice that the Primary Key was created for you, and the columns defaulted to nice lengths etc. It also made sure the data was added…

And yes, the Add() method returns the newly inserted key – for all providers.

SimpleRepo Convention

It’s not easy to make decisions as to how to store certain columns – and I had to do something I normally don’t like, and that is create a set of very, very small Attributes to help out.

• Primary Keys: If you call a column “ID” or “Key” or “[ClassName]ID” – no matter it’s type – that will be your Primary Key. If you have other things in mind you can use a primary key attribute (“SubSonicPrimaryKey”) and we’ll use that column.
• String length: there are two ways to tell SubSonic how to handle this – both using attributes. The first is “SubSonicStringLength(int length)” and the second is “SubSonicLongString” which sets to nvarchar(MAX) or LONGTEXT – depending on your provider.
• Nullability: The default is not null, but you can change this by making your propery a nullable type.
• Numeric Precision: the default is a Precision of 10 and a scale of 2 but you can change that with the “SubSonicNumericPrecision(int precision, int scale)” attribute.
• Ignoring a property: you can ignore generation of a property by using “SubSonicIgnore” attribute.

This is my test class:

    public class SubSonicTest {

        public Guid Key { get; set; }
        public int Thinger { get; set; }
        public string Name { get; set; }
        [SubSonic.SubSonicStringLength(500)]
        public string UserName { get; set; }
        public DateTime CreatedOn { get; set; }
        public decimal Price { get; set; }
        public double Discount { get; set; }

        [SubSonic.SubSonicNumericPrecision(10,3)]
        public float? Lat { get; set; }
        [SubSonic.SubSonicNumericPrecision(10, 3)]
        public float? Long { get; set; }

        public bool SomeFlag { get; set; }
        public bool? SomeNullableFlag { get; set; }
        [SubSonic.SubSonicLongString]
        public string LongText { get; set; }
        [SubSonic.SubSonicStringLength(800)]
        public string MediumText { get; set; }
        [SubSonic.SubSonicIgnore]
        public int IgnoreMe { get; set; }
    }

And if you have a look here at our source testing, you can see how this class is used in my unit tests (not an easy thing to do!).

You can also have a look here to see how the SimpleRepository works under test.

Summary Summary

I’m working on perf tweaks right now, and still adding things to the docs so it will be a bit yet until I release this. If you want to have at our source – it’s here.

I’m not going to release 3.0 until I feel that people can get up and going – and there is a TON of stuff going on with 3.0 that people should know about. I’ll have more on this in the coming weeks.

There are a lot of reasons why projects don’t “pop” – but in some ways I think people can tell if they are “gazing wantonly in the pond’s reflection” by constantly asking a set of simple questions:

• What are we doing?
• Why are we doing it?
• What do we hope to get out of it?

A lot of people would say “sure – that’s what ya call a Mission Statement Rob!” and in some ways, I spose it is. But the next part is the hardest:

Does it motivate you?

The Hard Truth
In every human endeavor the 80/20 rule (aka Pareto principle) cruelly applies – which is effort/payoff are inversely related. This principle is at the core of the just about any time/management book/philosophy – and these things usually boil down to constantly shifting your focus to “what’s important” (aka the 20%).

It seems the 80/20 thing is built in to the fabric of the universe, along with some other groovy numbers. Most large software companies have come to realize this – including Microsoft:

"One really exciting thing we learned is how … a relatively small proportion [of bugs] causes most of the errors," Ballmer wrote in his three-page memo. "About 20 percent of the bugs causes 80 percent of all errors, and–this is stunning to me–1 percent of bugs caused half of all errors."

If we apply logic here then the opposite of this statement must be true as well:

80 percent of the bug-free functionality is produced by 20% of the code.

If that’s true – we’re writing way too much crappy code. Let me reword that – 80% of the code we write does 20% of the work and contains the bulk of the bugs (my math skills got lost there). Which side of the 80/20 code pool are you swimming in?

Sherman, Set the Wayback Machine
It’s 2000 and I’ve just ordered a tin of Pringles and The Fragile (Right and Left) from Kozmo. It’s 11pm and I should be at home, but I’m hammering away on my client’s app, trying to get a demo ready for Yet Another VC Who Wants To See Stuff Spin. I’m cranky, tired, and my wife is getting tired of this constant circus of late nights.

The phone rings as the speakers are blaring in our Live/Work Loft/Office on 2nd and Brannan and I’m listening to Trent growl his way through “The Wretched” and I see the area code – it’s New York. My client. Crap.

After 10 minutes of telling him everything’s on pace, he recaps what he wants to see. Amazing – he added 4 new requirements! How very … like him.

I ask him the question:

“What are we doing again? I mean what’s your goal here anyway once all of these demos are done and you’re really rich.”

I hear gasps on the other end of the phone, some choice swear words that involve an ice-pick and my retina, and then *click*.

The phone rings 5 minutes later and it’s The Client. “Do you mind telling me just what the **** you’re asking me these questions for you ****in moron?”. I’m used to “the East Coast” thing by now and I reassure him I know his requirements – I understand the specs and priorities – we’ve been through it a ton. I know about the demo.

I want to know about the day after the demo.

His answer was simple: “We’ll be millionaires. Who gives a **** what else – we’ll be the next tech IPO and you can buy your wife a maserati so **** off and build my ******* app!” (the East Coast thing gets annoying at times – but you get used to it. Don’t get me wrong – I like the other side of the country and all, but they can get pretty spun up over there).

We got the funding – a lot of it. And the company still managed to fail – I think it’s when investors figured out my client was full of crap. I should have figured it out too – but back then everyone was involved in an IPO or buyout. It was a “Craigslist Party” of geeks and power money and you just didn’t ask questions. Or so I thought.

What’s Your Answer?
Twice I’ve worked on a winning application – and it feels great. And by “winning” I mean the client and their clients were stoked, and it literally made people cry. One of my very first applications – an info portal for Ameritech (now PacBell) was one such application. It was so very, very simple that it had to work – it was a classic ASP app (I wrote this in 1998) that used IndexServer to crawl over 12,200 documents scraped from their mainframe.

Their existing app was a terminal-based app and it was all paging and CTRL- shortcuts the user had to memorize. I made a web interface (we called it the “Yahoo UI”) that worked on fuzzy search and BAM – scraped 30 seconds off the average “satisfaction timer”. This meant the call center reps could answer people 30 seconds faster than before without the carpal-tunnel and by using the “new web thing”. I’m not kidding you – one of our User Acceptance participants (an actual rep) started to cry.

If you asked me or any member of that team what we were doing we would have said the following (with minor variations):

• We’re building a web app to reduce the time to answer for call centers
• We’re doing it because our existing app sucks and it’s too hard to learn. Turnover is killing us.
• We hope to have happier call center folks and happier customers

These answers are all kinds of win because they’re grounded in something real: making a job easier/better/faster. They don’t involve greed and aren’t out to change the way the Earth spins – simple and direct and dare I say truthful.

Smelly Answers
I’ve asked these questions various times over the years and aside from my client from hell above, I’ve received some real winners:

• “We’re going to be the Premier [WHATEVER] and direct all buyers of [X] to use our service and we’ll make wads of cash”
• “We’re going to Change the Game with this app, and in doing so make wads of cash”
• “We’re going to dominate the [BLAH BLAH] space – we’ll actually become the internet. We’ll make wads of cash”
• “Right now there’s a massive void out there and we’re going to fill it. We don’t know how we’re going to make money – but we’ll get there soon enough”
• “I don’t know really – I’ve been told to build this thing so I called you. I need a beer.”

People and technology are funny and scary at the same time. Sort of like clowns. When I tell people what I do they get a really weird look in their eye (you know the look I mean) and sometimes I don’t know if I’ll be “fixing their internet” or hearing their great new idea to make tons of money. I, evidently, am a bit like Willy Wonka:

“We are the music makers, and we are the dreamers of dreams”

Mr. Wonka also offered a followup – which I hold to very tightly:

“You should never doubt what no one is sure about”

If we agree, by now, that this 80/20 thing has some merit, then it stands to reason that there’s an 80% chance you’re working on a project with a smelly set of directives. You ended up here by the various laws of the universe that sprinkle geeks across projects like salt and pepper – but you don’t have to be the 80% tripe!

You can change this: you can jump the 20% fence. You just have to help your team face the problem plaguing them – which is usually a weird direction that has to do with wads of cash, changing the game, or shifting some paradigm.

Get their heads back in the game and make sure you’re kicking ass for humanity – and you can figure this out pretty quickly by asking some simple questions and listening for:

1. Delusions of grandeur
2. “Wads of cash”
3. “I don’t know yet” spoken 2 or more times
4. The solution isn’t a win/win (you, client, end-user)
5. Frustration at the question

If you hear these answers or feel like you’re drifting – change things for the better by asking if you can open up conversations about the endgame – about the value for the end user.

If you don’t get concrete answers point to YouTube: a really dead-simple app that makes people really happy. Just like a puppy or a kitten – without the poop. Or Twitter – one of the silliest, most relevant applications ever made (that has yet to make a dime… but anyway).

You can change things – you really can. As long as your team is willing to listen and engage and if they’re not, well maybe it’s time to look for the golden 20% out there.

The Start of BDD
It all started – or so I’ve read – with a guy named Dan North:

I had a problem. While using and teaching agile practices like test-driven development (TDD) on projects in different environments, I kept coming across the same confusion and misunderstandings. Programmers wanted to know where to start, what to test and what not to test, how much to test in one go, what to call their tests, and how to understand why a test fails.

The deeper I got into TDD, the more I felt that my own journey had been less of a wax-on, wax-off process of gradual mastery than a series of blind alleys. I remember thinking “If only someone had told me that!” far more often than I thought “Wow, a door has opened.” I decided it must be possible to present TDD in a way that gets straight to the good stuff and avoids all the pitfalls.

I felt this exact way when learning up on TDD:

1. where do I start?
2. what do I do next?
3. how do I know when I get there?

Things like that. I still don’t know those answers, but I feel like BDD has helped me see some very interesting ways to address these issues. Moreover, it will help me get along with my PM better – maybe .

The Usual Caveats 
No – I’m not an expert. Please don’t take any of what you’re about to say as guidance. Do take it as  queue to find out more. Do ask a lot of questions and Do challenge yourself to see what some people love to use.

Download it here

Double-click for full screen