Do you ever have a software idea so horrible that you feel physically sick?

At times like that, you can block out the idea immediately, but I find it's best to follow the idea through to it's logical conclusion.

So here's a repulsive idea I had, which I've since discussed with a bunch of people who helped flesh it out a little more, making it extra terrible.

Introducing 'The ReBuilder'

Ah, yes. It's called 'The ReBuilder'

Here's an example of what happens when you're foolish enough to use it.

So, you open up Visual Studio and choose to create a new console application.

You type the line:

var person = new Person();

Try to compile and see an error, essentially 'Person? No such type!'

"Error 1 The type or namespace name 'Person' could not be found (are you missing a using directive or an assembly reference?)"

Rather than have the programmer waste his or her precious time creating this new class, the Rebuilder does it for you. It goes right ahead and creates a class with the name 'Person'. It doesn't ask you to confirm the action, it just goes ahead and does it. No ifs or buts. Where does it put this new class? Wherever is the most conventional place. It builds the application again, right away. There's no new compilation errors, so it rests.

You type another line of code... you now add:

person.FirstName = "Jim";

The rebuilder picks up on this straight away. (Actually, screw it, you don't need to specifically try and build... this is a background compilation. It's always present.)

Rebuilder notices the resulting error...

"Error 1 'Person' does not contain a definition for 'FirstName' and no extension method 'FirstName' accepting a first argument of type 'Person' could be found (are you missing a using directive or an assembly reference?)"

Clearly you're not after a method called FirstName, you're after a property. So rebuilder adds a property named FirstName of type string. No magic.

Next you try to save your object...

person.Save();

This yields a fresh error:

"Error 1 'Person' does not contain a definition for 'Save' and no extension method 'Save' accepting a first argument of type 'Person' could be found (are you missing a using directive or an assembly reference?)"

This time the missing method is, indeed, a missing method. So ReBuilder gets in builds a method with the appropriate signature.

And it doesn't flesh out the body of the method with some dodgy 'Throw New NotImplementedException()' bullshit like the 'Generate Method Stub' feature in Visual Studio. It analyzes the name of the method, and implements it on your behalf.

"Hmmm, 'Save'," thinks the ReBuilder. "I guess you want to 'save' a person." So rebuilder writes a save method, saving to the most conventional place it knows: the database.

If there's a useful database connection in the application, then it uses that. If not, it creates one.

If the database contains a table named 'person', it will save to there. If not, it will build a table.

If there's no database to begin with -- well the ReBuilder goes ahead and builds it.

Obviously, you wouldn't do all this without any code coverage, so hell, RB churns out a sweet suite of tests to cover all the branches of the save routine.

(If the database, and the person table already exist, then we make sure all the relevant properties exist. This might include creating a migration script for updating any other environments with previous versions of our database)

Next you type:

person.GetByFirstName("Jim");

"Hmmm. Judging by the name GetBy<PropertyName>(<string>)..."

It looks like you expect a well understood pattern to be implemented.

(Yes, this bit is blatantly inspired by Ruby on Rails use of method_missing...

"def method_missing(method_id, *arguments)
   if match = /find_(all_by|by)_([_a-zA-Z]\w*)/.match(method_id.to_s)")