I blame it on Jacob. 

There are many project managers in the company, but Jacob is just plain different.  Take Tom for example.  When he needs to kick off a project, its pretty straight forward.

“The requirements have been signed off.  You can find them on the team Sharepoint site.  Let’s start walking through them on Tuesday and get tasks and estimates in the project plan.  I have a templat plan right here.  We will be using the standard development proces…”

Very tactical.  Specific.  As a developer, it’s what I’m used to.  But when Jacob called me to a meeting last week, it was just plain odd.

“We are here to create a distributed system design that allows a new sales program to be inserted and then changed over time.  We are the decision body, but other teams will actually design the components, build, test, and deploy.  We are where escalation comes to first.  So we need to agree on our mission, our strategies, our tactics and our guiding principles.”

I’m not kidding!  Guiding Principles!  I was amazed.  There were 10 other people, all senior, sitting around the table from different development groups in the company.  Our departments had never worked together before, but we knew how to write code and deploy it.  What the heck was he talking about!

So we went through the strawman mission statement and added things to the principles.  I pulled up the statement of principles that my management team sent around a couple of weeks before and added it in.  Jacob asked me to read them to the group and discuss the points that mattered to me personally.  He edited the text right into his team notes and had me approve his edits.  It was all very detailed.

But did it have anything to do with design?  I mean, really.  Ten people.  Four Hours.  That’s forty hours of work for senior people.  What did we get for it?  Three pages of notes, a short list of a few consensus decisions, and a list of open concerns that need to be escalated to management.  And there are more of these meetings to come.  I think we wasted time.

What a fool.  We could have actually done the design in forty hours!  Then we can simply tell our teams what the design should look like, and they will do the work.  Simple.  The dev teams have no reason not to listen to us.  Like I said: Ten senior people, all technical.  Half had the word Architect in their title.

We didn’t have many disagreements.  We went through the whole afternoon, describing our view of how we were planning to use the accounting system, what patterns we wanted to use in messaging, and what ‘attributes’ our designs had to favor (like the ability to change business logic quickly, whether it was through data driven decisions, OO designs, or easily disposable interfaces).  We all shared in our viewpoints and we didn’t have much to disagree about.

Oh, there was that one point when we had to discuss the interfaces and whether we were developing one ‘really flexible’ interface app, or many ‘disposable’ interface apps, all using the services layer.  We talking about that one for forty-five minutes.  One group wanted to be able to put up an app quickly, and replace it quickly, by discarding little apps and replacing them with others.  Workflows, they called them. 

The other team wanted to build a data-driven app that would get display and interface rules from the database, and would leverage Windows Workflow Foundation for the collaboration and workflow. 

Jacob let each team present their vision.  Then he asked,

“What is the principle that you are choosing with this design?”  It was an odd question. 

The first group said “We need to change business interfaces quickly.  They change a lot with our customers and they are frustrated with the pace of change in the past. It needs to go from a new idea in a sales persons’ head to deployed code in three months.”

The other team thought about that for a minute.  We all wanted the same thing.  We all wanted our designs to be agile, rapid, maintainable, flexible.  We had discussed this, like, an hour before.

The consensus decision was “We will build our services layer to support the creation of multiple independent interfaces.  We will build our interface system to be dynamic and drive business rules from data.  However, if a business should find that our interface system is not able to meet their needs, they are free to create another interface, using what they can of our libraries, controls, and portal, as long as it sits on the same services layer.”

Jacob seemed happy with the decision.  He wrote it on the whiteboard and our note-taker entered it into the meeting notes.  That made it “official.”  I guess he got what he wanted.  I just don’t see why that was hard…