Adventures in Agile

Do I Need Yet Another Reason to Justify "Agility"?

2010-08-19T11:19:00.000-07:00

I haven't blogged in a while, but an email from someone triggered me to put up some Agile thoughts.

Someone emailed me an issue today. I thought I would share it with you and include my response:

"... due to an entirely unnecessary international conference call with a brand new manager-type of a big International customer who suddenly thrust himself into a long-running discussion with their Indian subsidiary. Of course, we now have to dance around and kiss HIS culo, so I have to be in the office at an ungodly hour.

I find that the profitability of successful companies disguises a lot of fatty tissue (i.e. not-very-busy Manager-types). So we get a "suddenly self-appointed stake-holder" who is high enough in the mucky-muck list so you can do nothing about it. Of course, after spending all this time and effort to get him/her involved, they fade away, leaving a giant hole in the team's productivity. Anybody have ideas on how to handle these? Suggestions appreciated."

No solution comes to mind except simply supporting an Agile and transparent process should do the trick. Here is some background on the type of attitude that is at work here:

Eventually, these people end up quitting on their own if it becomes impossible for them to hide their antics. Reasons given for quitting usually are "I've outgrown the company", "I need new challenges", etc.

Watch for behaviours such as forcing themselves to be the point of contact for major customers and purposely leaving people in the dark wrt to these customers so they appear to be more knowledgeable. After the useful people have been fired for ineffectiveness (because now they look like they are the fatty parts of the company that can be trimmed), this person ends up with a raise and higher title due to the amount of responsibility. And because they are the ones in contact with clients, they appear to be the only one to have the tools to calm an irate client. They've now become a bottle neck and productivity starts to crawl as the idea of delegating anything wrt requirements is not possible.

Once they quit because the found a better job, productivity goes through the roof! The higher ups instantly know that the joke was on them for the last 2-4 years since this person was hired. They were able to find a better job because on paper it looks like they were doing so well - including a promotion in a relatively short amount of time.

I've seen this at least a couple of times during my consulting days. I call these people "professional ladder climbers". To them, the only goal is to get promoted, get a raise and has nothing to do with making the organization effective. As long as they satisfy the optics, no one is the wiser until it's too late to do anything about it and they've gone to greener pastures.

This is why I support a transparent process. Agile stuff makes this possible. Now to implement some of these processes in government offices so our tax dollars can go to teachers and charities instead of these narcissistic leaches. I suspect most are not self-aware enough or don't care to know their impact on society or those immediately around them.

Vancouver Tech Fest GIT Presentation

2009-11-21T14:08:00.000-08:00

I did a presentation on GIT for Agility at Vancouver Tech Fest today. Here are the slides for those who wanted them! Let me know if you want more info.

http://drop.io/vantechfest

Here are some links to good GIT sites:

Linus Torvalds on GIT: http://www.youtube.com/watch?v=4XpnKHJAok8
GIT magic book: http://www-cs-students.stanford.edu/~blynn/gitmagic/book.html
MSysGIT: http://code.google.com/p/msysgit/
GIT Extensions project for VS: http://code.google.com/p/gitextensions/

I'm glad people liked the presentation. The organizers will post the actual screen capture and audio later.

ALT.NET Vancouver is on!

2009-11-02T15:59:00.000-08:00

We will have a FREE open spaces event held at the 500 Plaza Hotel (Cambie and 12th) starting at 5:30 pm Thursday, Nov. 5th! Participants will include:

Eric Evans
Michael Feathers
and possibly Martin Fowler and others!

This is your chance to participate in an interactive setting with a lot of the presenters from Agile Vancouver.

Please go and sign up at altnetvancouver.ning.com. Please message Stefan Moser or Scott Muc through that site regarding any details.

Books at Agile Vancouvre Conference

2009-11-02T15:21:00.000-08:00

Since some people couldn't get the time off work or couldn't afford to attend the conference, they won't be able to get the great discount we have on some books that we have at 20% off the cover price. Please look them up online for the price and subtract 20%. We also include the tax in that price. Let me know through twitter:

Refactoring: Ruby Edition Jay Fields / Shane Harvie / Martin Fowler / Kent Beck
Fearless Change: Patterns for Introducing New Ideas Mary Lynn Manns Ph.D./Linda Rising Ph.D.
Working Effectively with Legacy Code Michael Feathers
UML Distilled: A Brief Guide to the Standard Object Modeling Language, 3E Martin Fowler
Domain-Driven Design: Tackling Complexity in the Heart of Software Eric Evans
Lean Software Development: An Agile Toolkit Mary Poppendieck / Tom Poppendieck
Patterns of Enterprise Application Architecture Martin Fowler
Planning Extreme Programming Kent Beck / Martin Fowler
Refactoring: Improving the Design of Existing Code Martin Fowler / Kent Beck / John Brant / William Opdyke / Don Roberts
Analysis Patterns: Reusable Object Models Martin Fowler
Leading Lean Software Development Mary Poppendieck / Tom Poppendieck

Much Ado About Agile 2009 Conference Registration is Open!

2009-09-22T11:00:00.000-07:00

This is the line up:

Martin Fowler,
Eric Evans,
Michael Feathers,
Mary Poppendieck,
and others

The conference is going to sell out quickly as it is a small venue.

To register please visit www.agilevancouver.ca

Event Sourcing and CQS part 1

2009-09-20T21:31:00.000-07:00

Lets start by getting the transaction side of the application going. We're going to have a customer class that will have some simple properties at first.

Here is the project setup:

This is a pretty easy start. We have the test project that will exercise anything that we write. The messages project is where all our messages will reside. The Transaction Service will house our coordination of receiving commands to the Domain. We'll worry about the event publishing in a little bit. The Domain project will house our entities.

Time to get some sleep. More on this tomorrow.

Time Machine Example Implementation

2009-09-20T21:07:00.001-07:00

A little while ago I wrote about a time machine for your application. This based on Greg Young's infamous Event Sourcing strategy. It's time to get a sample application going with this approach. I'll also take it one step further and apply the same strategy to the reporting side of the application. A lot of this hinges on the Open Closed Principle (OCP) so I'll try and enforce that through GIT hooks.

Here is a recap of the steps I'll be taking:

1. Event Sourcing and CQS to the extreme as prescribed by Greg.
2. Event Sourcing for reporting schema changes.
3. OCP application to the versioning of the dB instead of version scripts.
4. Enforcement of the OCP to the pub/sub of the reporting dB.
5. OCP application to the reporting services side through GIT hooks.

This will be hyperlinked as I complete the blog posts.

The Best Certification

2009-09-18T11:56:00.000-07:00

The best "certification" is still community recognition by putting
yourself out there and learning/teaching publicly:

Blogging:

You put up your ideas in front of many eyes. Teach people. They will be better because of you. Learn from people. You will be better because of them.

Twittering:

An optimal conversation is hard to find within your geographical confines. Get the room full of conversations experience on the global scale. What you want to talk about right now is something that others out there want to talk about as well.

Participating in Forums:

To explain something in more than a 140 character-at-a-time conversation, you need a forum. People on forums are there to teach and learn. Participate!

Presenting at User Groups:

Sometimes you just need to talk to people in person and get your ideas out in that manner. Local user groups are great as the attendees are people that you can find common ground with, teach and learn from their critique of what you present.

Presenting at Conferences:

This is an extension of the user group but will connect with a larger group and geographical reach. It will help you develop as a presenter which will make you a better teacher and better learner. The evaluation forms will let you know where you can improve.

Reaching Out to Other User Groups:

Get involved in other user groups. Present there. See what the gap is between the groups. This new dialogue will be very important to learn why the groups exist and why the technologies/methodologies/etc behind each exists.

I resisted that for a long time and only recently bit the bullet to do all of the
above. Your "certification" is the recognition your peers give you.

People right out of school are having a hard time getting work. The
ones that are passionate are the ones that I see getting their career
going in the right direction. They are the ones that are still there
participating in the community. We started an Alt.Net Vancouver group
which is tiny compared to most user groups. But I have a hard time
finding more dedicated people. The inexperienced people are getting
their best "certification".

Hope this will save some people from memorizing index cards and put their time to good use instead!

Layers Talk

2009-09-17T12:46:00.000-07:00

I put together a talk on layers for TechDays. This is part of a new track that Microsoft is piloting in Vancouver and Toronto. Due to the constraints of time, I had to eliminate some of the subjects that I was originally going to cover. One of them was scalability. I've included the original layout at the end here and hopefully I will be going back to this post and adding some links to subsequent posts. Design by Contract was added as the replacement subject.

Cake Please

2009-09-10T03:03:00.001-07:00

I spent the last week and then some preparing a "Layers" presentation. The focus was to try and get away from what's been taught 20 years ago and the 3-tier UI-BL-DL structure.

My first attempt was to concentrate on why software was organized at all. It's to manage growth. You don't need any structure if you have a very simple system. With growth comes a demand that goes beyond the organization of the logic. Most modern architecture topics deal with the growth of data that companies need to manage. On top of that is the other -ilities.

So, scalability and the layers was going to be it. I guess it fell too much on the database at first. The other layers got the raw end of the deal. But wait. That would have been irresponsible.

The truth is that the structure of such companies is really now a system of systems. Each system may be a cake or a few. The trick is now looking at what sits on top of the shards, document dbs, object dbs, etc.

So the presentation really turned into an SOA talk with some Domain Driven Design. By diving deeper, the Domain Driven Design turned out to be a vortex with one idea relying on the other - not unlike mathematics: If you want to learn calculus, you better know basic algebra.

So back to the basics it was: MVP, MVC, MVVM, Transaction Script, Active Record, Domain Model, Data Access and ORM - touching on DbC, DDD and SOA for the second half. I'm happy that I got to use napkin doodles for my diagrams - UML belongs on those things. An MVP diagram looks better next to a coffee cup stain anyway. MS will probably clean all this up :-/

I don't know. Maybe I'm too tired at this point in the night. I didn't manage to work GIT in to the presentation. Next time.

A Rewind Button For Your Application Without the Temporal Object Pattern

2009-09-07T19:28:00.000-07:00

In Ayende's style, I will blog as soon as a thought comes to me.

In the last year or so, I have been working on applying the Event Sourcing pattern. This led to some interesting thoughts. With the fact that the state of any object will be "rewindable", you can do a true audit. Audit logs don't cut it as Greg Young has put forth in his presentations.

That's great for the state of each of the objects. With a bit of work, you can work out anything that might have happened on any reporting that you may need or needed. This may be quite a task to merge your structure and lookup data changes in the reporting db and the actual events that update that data.

To add, the more difficult task is to have the reporting service changes merged as well. This would not be so bad if the Open Closed Principle (OCP) was adhered to - but only for when new events were added. If the reporting service started to act differently as of some arbitrary version, a careful replay of the system through time would be needed with binaries ready for each timespan that they were around for to receive those events.

There is the very explicit Temporal Object Pattern that seems tempting to use. However unless the domain is clearly responsible for knowing it's own contracts, this looks like a very complex solution to put forth as we will want all our objects to be temporal - and our reporting data as well. This is just a wish to have a rewind button on my app to have a truly representative audit.

So now that we've described the problem, let's take a look at a possible solution: Event Sourcing. As stated earlier, this allows us to capture events that the domain publishes and add the ability to reconstruct an objects state using just what has been published in the past. A very good implementation of this pattern was thought up by Greg Young. Martin Fowler writes about it here.

That solves the problem of the rewind button working on the objects themselves. How can we do the same for the rest: reporting services and the reporting schema? The trick is that the state of the objects is write-only via the events they have published so far. To have the same effect for the Reporting Service, we need to adhere to the OCP and publish an event called "CustomerReportService2 will now listen to all CustomerEvents from now on". We keep both versions of the service alive. We can also say that another message is now going to be consumed by the second version from now on at a later point in time.

This simple fact that we are closing the old service functionality from that point on in the event stream is key. It also gives us the same thing for the dB schema. When we add a table or column or lookup item, etc., we publish the schema change as an event. When rewinding the clock, we drop all the tables from the dB and simply replay all events from the beginning of time through the latest binaries. This may take some time, so some snap shot concept can be introduced as is with Greg's Aggregate Root object snapshot idea.

If we adhered to the OCP, the reporting service and schema will have been used as it has before. The slight overhead is the management of which version of the reporting logic is used when. It listens for when to switch directing of the messages to a particular version of the service. Sounds like a job for an Inversion of Control (IoC) Contianer?!

So.. It always comes back to this: GIT hooks that prevent you from changing certain files in certain ways! The db script can only be added to! The reporting service cannot be changed - just ammended! OCP insurance from your source code management is a cool concept.

That's the best accounting system for software I can think of.

Looking forward to critiques of this and questions for clarification since I offered no diagrams. I probably will update this with that info later.

GIT for fun and profit presentation application

2009-09-02T17:50:00.000-07:00

Tired of unreliable source code management? Do you save your source code in 6 different places and put a hard copy of the work you did today under your mattress when you get home? ... then you need to see how GIT's design will allow you to throw off those shackles and become a free person again!

... but wait..

Are you scared of switching to a different source code management tool because the last time it took 3 developers, 2 project managers and all of Accenture's employees in western Canada to deploy your barely functional current one? Well not this time! If you are better at copying a file than your technically challenged mother, you can deploy a git repository! You will be shown how.

and then...

Did you avoid work today because you feared missing your lunch hour break? Because getting the latest version of your solution would take so much time over your 14.4 kB modem? Thinking of switching to AOL? GIT will compress and send only the changes that you need. Take a look at why even on your beautiful dial-up connection, GIT will enable you to contribute to that open source z-modem implementation you're working on.

.. but what about this:

Constantly forgetting to check things in because you're preoccupied by those Britney Spears albums in your iPod? Did your last checkin encapsulate the project from beginning to end? Well wait! With GIT it's not too late to save yourself the horrible embarrassment of this gigantic checkin! Come discover how!

... if you're not convinced yet:

But my mom keeps tripping on and unplugging the interweb cord out of the wall when I'm working on my Dungeons and Dragons program - so I can't checkin my changes! ... And I need the new elf package to be implemented before my D&D Saturday night party! Well, don't fret my nerdy friend. GIT works without a connection too! Find out what else is possible!

.. I'll try to convince you with just one more..

The evil developer from across the office is committing changes to the files I'm working on! He types way faster than me because he uses a Dvorak keyboard and beats me in the check-in race! He gets work done and I spend my day resolving conflicts. GIT, can you help me here as well? Of course GIT can. With 9 different merging strategies to help you, your evil foe will quickly fall to the wayside and you can laugh at him when he's layed off.

Some Reasons I Love GIT

2009-08-27T08:49:00.000-07:00

It's no secret by now that I'm at a "won't turn back" point in terms of SCM. The fundamental ideas that GIT is based on come through in the use of the system:

1. Reliability: Every change is keyed on a SHA of it's contents. You quickly know if there are any integrity issues.
2. Simplicity: It's just a bunch of files organized by a directories comprised of the first 2 characters of the SHA. In those directories exist the serialized blobs of deltas and other items (trees, commits, tags and branches). The files are named by the remainder of the SHA. It's also snapshot-based as opposed to file-based. Moving a method tracks that as exactly that - not 2 separate changes in 2 different files. It's easy to fix a repository if there was some hard disk corruption.
3. Speed: Everything is compressed so the repositories are 1/10th the size of an SVN repository and hence faster. You have a local copy so looking at the log or doing diffs is almost instantaneous.
4. Power: Forgot to add that other little change in your last commit? No problem just amend. Committed 2 changes at once? No problem, tease apart that last commit into 2+ separate ones.
5. Off-line: never need a server. Even at the current gig, no server software installed anywhere for the centralized repositories. It's just some folders on a mapped drive.
6. Merging: It's built for it. SVN's merge tracking is put in as an afterthought. GIT was designed for it.

There's more and more detail, but I needed to answer the question for Steve Bohlen.

GIT shortcuts

2009-08-18T15:57:00.001-07:00

Time to revise the GIT short cuts. I've added these in ~/.bashrc:

alias ls='ls -lAXh --color'
alias gup='git push'
alias gdl='git pull'
alias gc='git commit'
alias gl='git log'
alias gd='git diff'
alias gdc='git diff --cached'
alias gdh='git diff HEAD'
alias gb='git branch'
alias gt='git tag'
alias gm='git merge'
alias gs='git status'
alias gco='git checkout'
alias gcl='git clean'
alias grs='git reset'
alias grb='git rebase'

Get Windows Live Messenger 9.0 Working on 64bit XP and Server 2003

2009-07-06T20:27:00.000-07:00

Microsoft says that these are not supported. But they actually are.

You need to download the MSI version of the installer. It's available here:

http://www.softpedia.com/progDownload/Windows-Live-Messenger-9-Download-89148.html

You may then get the "cannot connect to server" message. In that case, upgrade the communication plumbing by installing this:

http://download.microsoft.com/download/0/F/4/0F4D43A7-8D47-4312-BC35-EC1F888AC156/en/Contacts-ship-neutral.cab

You should be able to connect at that point.

An Interesting Discussion with Robert

2009-04-23T16:14:00.000-07:00

I seem to always get into good conversations with Robert. We thought we should share it and perhaps it will start some more meaningful discussions.

Adam said:
BTW, thanks again for the invite yesterday. Good presentation. I liked the mind map way of displaying the ideas

Robert says:
Thanks Adam. And thanks for the input and clarifications; It was very interesting to see people's reactions to the ideas. Good discussions.
Robert says:
It seems that there is a considerable level of comfort with the idea that the status quo is broken.
Adam says:
yes.. please pass along my contact info to them.. they sound like a bunch of smart guys
Robert says:
I will.
Adam says:
sometime next month we'll have a geek beers again.. I like the presentation idea
Adam says:
I'll try and think of something like that for the next one
Robert says:
Nothing too excessive, I hope . Excessive presentation, I mean - shouldn't distract from the beer too much ...?
Robert says:
Just kidding - good idea.
Adam says:
no.. for sure.. but it's good to give some food for thought to the people
Robert says:
Indeed. If for no other reason than getting a better feel for how jaded, exactly, everybody is. That notion that building apps is broken, but that's just the way it is / will be / makes money.... Eerie.
Adam says:
ya
Robert says:
Not that I'm advocating revolution or anything, but I wonder to what extent that's a self-fulfilling promise and to what extent we actually have the answers and are just not implementing them .....
Robert says:
.... because of resignation - "it'll never work in any other way."?
Adam says:
there are multiple answers
Adam says:
it takes time to implement them all
Adam says:
what's needed is better tools
Adam says:
or larger adoption of good tools
Adam says:
there a few combinations of answers that don't work together
Adam says:
but the people that know the answers, know that anyway
Robert says:
Not sure about that. There seem to be more better tools about than you can shake a stick at. Adoption seems to be key, and it's linked to culture and language, just as was alluded to yesterday.
Adam says:
how many developers do you know practice DRY by using the built in templates in Resharper, for example
Adam says:
or better yet
Adam says:
how many develop their own templates
Adam says:
or macros in VS?
Robert says:
Very few. The interesting question is why that is so.
Adam says:
There is no reason, for example, that developing an ORM w/ MVC app in .NET should be as be as fast as developing in Ruby on Rails
Robert says:
"Insufficiently experienced" is the pat answer, but that doesn't capture it.
Robert says:
I think it has nothing whatsoever to do with tools, frankly.
Adam says:
I think softwareshops are too shortsighted that devoting just 1/2 an hour a day to sharpening the saw would make the difference
Robert says:
Yes, undoubtedly, but why?
Adam says:
Fire those who refuse to learn
Adam says:
Fire those who don't learn for whatever reaso
Adam says:
n
Robert says:
Learn what? Fired by whom? (as in, who makes the decision that they aren't learning) Replace them by whom?
Adam says:
it has to come from the top
Robert says:
The factors which cause the entropy are deep - human nature, culture, etc.
Adam says:
yes
Robert says:
Jawohl mein Fuhrer. Not to be facetious, but if it could be imposed just like this, we'd be as good at it as we are at digging ditches in no time.
Adam says:
but if actively the organization fights entropy, you have a better than the rest scenario. At this point it's worth fighting for
Robert says:
All organizations are actively fighting entropy. That's what an organization IS - a means of shaping reality and staving off entropy.
Adam says:
There was a good saying. "Look at that tractor there. If we got rid of it we could have 50 people shoveling the dirt."
Robert says:
It seems that the problem is agreement on exactly what constitutes order and chaos, and to what end.
Adam says:
The other guy says: "Why not use spoons, you could employ 500 people"
Robert says:
And why not, if the 500 would otherwise turn into antisocial drunks without purpose and happyness in life. Perspective has a lot to do with it.
Robert says:
.. happiness, of course....
Adam says:
yes.. I feel a rush of communism coming over me
Robert says:
How come it's about ideological correctness in software development and not in electrical engineering? What is the difference? That's what I don't understand.
Robert says:
Everybody seems to know what needs to be done whilst at the same time conceeding that it'll never work.
Adam says:
I'll tell you the difference between software and any other engineering
Robert says:
The "fire everybody who won't learn" / "don't work with anyone who isn't competent" theme was fervently supported by one of the guys last night, you, Greg Y, myself in darker moments.
Robert says:
All that knowing full well that that can't be done either.
Adam says:
yup.. so the current concensus now is architectural segregation via SOA done properly, ie, under the guidence of DDD
Robert says:
That's like the current political consensus that it's better to be free than slaves.
Adam says:
it's too easy to build software
Adam says:
mistakes have no harsh consequences
Robert says:
... what does "free" mean, whose "slave", etc.
Robert says:
"mistakes have no harsh" (especially near-term) consequences - that may be closer to the mark ....
Adam says:
if you burnt the wrong circuit on the board, it's toast
Robert says:
Curious that everybody either goes commie (extreme programming, etc.) or totalitarian when looking at the problems....
Adam says:
if you made a syntax error, you type something and recompile
Adam says:
lol
Adam says:
I love that comment
Robert says:
Yes, but that's not the true picture. You just recompile, but .....
Robert says:
.... as we both know the true consequences of a series of suboptimal decisions when building software can ruin companies.
Robert says:
That's why patterns and antipatterns seem like such a good idea. They make consequences more obvious and help to prevent bad choices.
Robert says:
The problem is that that's fairly well understood by now by technicians, but I know of a good number of entrepreneur and PM types who are blissfully unaware of the chain of events which made their stuff unmaintainable/useless/very costly even after everything folded.
Robert says:
It's as if our nice little patterns should each have case studies attached to them which attempt to quantify the effect of the pattern / antipattern in financial terms, for better or worse.
Robert says:
I wonder if that's possible.
Adam says:
too many variables
Robert says:
Not if one could classify the organisations and "cultures" which attempt to apply the pattern/antipattern in some way.
Robert says:
For example, patterns would have a different effect when used in an open source project, a dotcom style entrepreneur shop and Telus.
Adam says:
still lots of variables.. but you're getting closer
Robert says:
We should toss this thread into a blog post.
Adam says:
perhaps it's the quantification of the things we have not been quantifying that's the problem here
Robert says:
Yes. That sounds likely.
Adam says:
So we can explore that..
Adam says:
I'll post this on my blog when we're done
Robert says:
OK.
Adam says:
so, let's have "transiency" as a variable worth measuring
Adam says:
what is the percentage of consultants here
Robert says:
..... "transiency" .... ?
Adam says:
how many do short stints?
Adam says:
how likely is it for a person to leave if they don't like it
Robert says:
No idea, or even particular opinion on what metrics may make sense. I feel that it would need a lot more discussion before touching that one.
Adam says:
"relative compensation" - do the people get paid the average that is out there in town, more, less, by how much?
Adam says:
related to the previous, but imortant
Adam says:
.. to be looked at separately
Adam says:
"implied incentive" - is this a 9-5er or someone that fell in love with the art?
Adam says:
"personality type"
Adam says:
- do we have a bunch of type A personalities comprising the team
Robert says:
It sounds to me as if that's too focussed on the techies who do the coding and not enough on the "culture" of the organization in question.
Adam says:
ok.. you name a few
Adam says:
we'll need combinations of these matrix to throw methodologies and patterns at to see what happens
Robert says:
As I said, I'd have to think about that and would like to hear more opinions. For example: .....
Robert says:
Staff turnover probably plays a role, but do we need to look at it or those factors of which it is a symptom?
Adam says:
yes
Robert says:
I really don't have an opinion about that yet.
Adam says:
I think propensity to leave tied to that rate itself
Adam says:
it's not an easy equasion
Robert says:
Absolutely.
Adam says:
looks more like a y=y`` + y` differencial equation thing
Robert says:
Dave made an interesting observation yesterday, to the effect that the "shared language" would require a culture built in a stable organization with long-term folks who know the shop and each other for years, etc. as a prerequisite and that the perspective of "hired gun" outside consultant architects (or folks with that kind of mindset - admit it - he was describing us.....?) would be entirely...
Robert says:
different from these folks.
Robert says:
That one also had the ring of truth, somewhere.
Adam says:
I don't buy it
Robert says:
There's a lot of stuff here which smells of needing more input from people. It seems too early to narrow down the questions to ask.
Robert says:
The notion that an ubiquitous language has to be embedded into a culture in order to work has a very strong possibility of being true.
Robert says:
Look at languages: They cannot survive without a living culture around it.
Adam says:
yes
Robert says:
In short, a culture must be there which buys into the need to speak the language....
Adam says:
but all you need is a domain expert role and you're good
Adam says:
perhaps one for each context if you're going down the DDD path
Robert says:
... which brings us right back to the crux of the matter: Selling the notion that all this stuff about developers and domain experts need to work together on the ubiquitous language thing and therefore need time, no waterfalls, etc.
Robert says:
It seems to be about acceptance in the "culture" of the company. Otherwise, no management support, etc.
Robert says:
If it weren't so, agile would rule the world.
Adam says:
not sure about that.. agile can't rule the world because of the personality types out ther
Adam says:
there are planners that will, by nature, go against agile
Adam says:
not even intentionally
Adam says:
it's not about "getting it"
Robert says:
No. It' can't rule the world because the principles which make it successful can only be applied by a small percentage of the best and brightest.
Adam says:
it's simply human nature
Adam says:
not even best or brightest
Robert says:
.... whereas a culture needs to include all participants in order to flourish.
Adam says:
yes
Adam says:
so agile is dead in the water
Robert says:
Heck, the stuff is too complicated.
Robert says:
No, not really. Whatever comes will have a lot to do with it.
Adam says:
it's achilie's heel is the way that it forces companies to work
Adam says:
hence lean is a more palatable way of working
Robert says:
Maybe. It's as if we are missing a way of doing things which follows the "natural contours" of how people and companies actually operate.

New Developers Are Just Over-Confident Children

2009-02-09T15:58:00.000-08:00

Having a little one to look after has shed some light into how we get the software in most shops today. This quote is quite good in how it relates to our educational systems:

"For the true significance of Disneyland is that it reflects our notions of children - what they are, what is good for them, and what will please them. Children are a special class of human beings which came into existence with the industrial revolution, at which time we began to invent a closed world for them, a nursery society, wherein their participation in adult life could be delayed increasingly - to keep them off the labor market. Children are, in fact, small adults who want to take part in the adult world as quickly as possible, and to learn by doing. But in the closed nursery society they are supposed to learn by pretending, for which insult to their feelings and intelligence they are propitiated with toys and hypnotized with baby talk. They are thus beguiled into the fantasy of that happy, carefree childhood with its long sunny days through which one may go on “playing” - in the peculiar sense of not working - for always and always." - Alan Watts

QCon's DDD Track Gets an Shot in the Arm

2008-11-28T12:45:00.000-08:00

While I did not formally attend QCon, I was invited to a couple of presentations by Greg Young. I saw some familiar faces there like Martin Fowler, Matthew Podwysocki, Jeff Brown, Jeremy Miller, Rod Paddock and others.

Eric Evans was very happy to see the Domain Driven Design track get some scalability/performance issues addressed. Greg's (at first glance) militant emphasis on Command/Query separation gave a clear and simple answer to avoid scaling issues when concentrating on designing and refactoring to a strong core domain. One key point to take away was the fact that our applications usually have 10X more read operations than write. This distinction is usually haphazardly represented in most designs we see today - and why we have so much money to make helping organizations scale up.

The one point I got from Greg some time earlier this year was to look at the business that you are trying to automate with an IT-free mind. That is, how would this be done (or how was it done long ago) with no computers and, instead, paper, pencils and people? They key information that is gathered out of that is the SLAs. Does that sales report need to have up to the millisecond information?

Greg has a link on his blog to the same presentation. I feel this one was more polished and was made more pleasing to the eye by incorporating some of David Laribee's use of images in stead of words. I'm hoping that the videos to the presentations get published soon. InfoQ, from what I hear, likes to spread out the release of videos over time to keep the site flowing with new material on a consistent basis.

On Saturday, Eric was kind enough to meet up with a handful of us and talk about DDD and life in general. He also toured around with us for a little bit. We saw some great views of San Francisco and a bit of the ocean shore.

It was a San-Fran-tastic trip!

GITting Around

2008-09-16T16:10:00.000-07:00

I've been very busy for the last 3 months or so, but now can start to blog again.

A few things have changed. One of them is source control. GIT is working out really well. I highly recommend people drop SVN in favour of it. You can get an overview and tutorial from many places, so I won't bother repeating any of that. For folks developing in a windows environment, I can help a bit with some specific issues one might run into with the switch.

1. Upon installing MSysGIT, the AutoCRLF setting should be set to false before you do anything unless you are writing a multi-platform app. If you don't, you run into the danger of having your CRLFs changed to LFs in the repository. Then GIT will report file changes where there are none.

2. Stop all that typing (unless you want to strictly use the GUI via git gui):

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.ci commit
git config --global alias.br branch
git config --global alias.me merge
git config --global alias.cl clean
git config --global alias.ps push
git config --global alias.pl pull
git config --global alias.rt reset
git config --global alias.rb rebase

If you want to configure bash on your machine, you could make aliases at that level - such as gci for "git commit".

3. Unless your SVN repo followed a strick trunk, branch, tag structure, don't bother with the standard layout option for cloning SVN with git svn. This leads to more headaches in the end. It's a long running process, so get it right the first time. Use --follow-parent to track moves, copies and renames.

4. Get hosting. Unfuddle is great as a free host environment. Don't get scared about the 200MB limit on the repository. GIT is very efficient and will take 1/30th the space that a SVN repo took. Unfuddle will email you when there are commits. It parses commit messages as well, so you can close an issue (tracked in unfuddle) with something like "closes #435". A commit with that message will close issue 435 in unfuddle. For $9/month you can get more users, 500MB limit and file attachments. The file attachment is a waste. I use www.drop.io to host files.

5. Setup your remote branches so you can simply "git ps" and "git pl" to send commits and receive commits from the remote repo. If you have a remote repo for the remote team over in India, you could set up something like this in the .git/config file for an "india" branch:

[remote "india"]
    url = git@mycompany.unfuddle.com:mycompany/outsourced.git
    fetch = +refs/heads/india:refs/remotes/india/master
    push = india:master
[branch "india"]
    remote = india
    merge = refs/heads/master

6. Read up on GIT. It's quite different from SVN.

Messaging Update

2008-08-19T19:25:00.000-07:00

Seems more multithreading was the culprit.

with on thread one:
lock (dictionary) { dictionary.Add("bum", "a homeless person");}

and seven seconds later on another thread:
lock (dictionary) { if (dictionary.Contains("bum")) C.Out("defined"); }

... Contains returned false!

FTW??

... or was it IIS.

*** UPDATE Sept 16 ***

It was IIS. After adding tons of logging and tracking thread IDs, app domain IDs and process IDs, it was apparent that IIS would load up more than 1 either app domain or process for the app.

The long term solution was to house the app in a windows service that communicated over WCF. It was a quick refactor and opens the door for using WCF to push to clients. The new question is, does WCF hold threads? Or can you have 100,000 seldomly active clients for, say, a chat application?

Don't Give Up on Messaging

2008-08-19T01:58:00.000-07:00

Today at work the dreaded words were uttered: "Well if it's not working by the end of the day lets just go for the pull every 1 second solution."

After implementing all of the long running processes to a pub/sub model, it was not pleasant to hear that. I wasn't going to just give up on that much energy poured into the current (and best) approach.

After adding tons of logging and hammering the server to see where the leaks sprung up, I cornered the culprit. If you are pulling from MSMQ ad nauseum, and you are in a multithreaded environment, you need to protect yourself from the thread unsafe methods "Send" and "Receive" on your MSMQ object - usually done by creating the MSMQ object for just long enough to do 1 operation.

The place where this was being done was not a multithreaded scenario, so I got rid of the creation and disposal of the MSMQ object between receives.

That did it.

The other lesson here is to be careful when you do have a multithreaded app pulling from MSMQ. You may see same messages go missing. I know there are other MSMQ features that guarantee delivery, etc, but I expect this integrity out-of-the-box.

Alt.NET Canada

2008-08-17T21:33:00.000-07:00

Too bad I had to miss this due to work. Here is Greg Young's Domain Driven Design presentation:

Project Management and Command/Query Separation

2008-08-12T20:15:00.000-07:00

Just like we have issues mixing command and query when writing software, we run into similar issues when it comes to project management.

Say you have a project manager that is very technical. You would think that you could do no better. But alas, you will have bottlenecked his potential by requiring him to service the "queries" he has to provide for management (such as status reports, etc).

In the opposite corner, you can have a non-technical PM giving "commands" to the developers without the proper knowledge of the consequences of his actions.

Even in the well balanced scenario, you can overload a PM with a week or more worth of "queries"... or ask for too much direction.

So, can you scale your PM? If the role is clearly defined and we have a separation of command and query, yes you can.

Thoughts?

DDD and the Too Many Aggregate Roots Design Smell

2008-08-11T21:51:00.001-07:00

This usually comes about from forcing a DDD solution where one would really needs a simple forms over data type app with ORM thrown in for speed.

Don't even bother with TDD for the most part.

Thoughts?

Spec# Needs a lot of Love form Microsoft

2008-04-28T23:24:00.000-07:00

I was disappointed at how little $$ was being thrown at something as good as Spec# by Microsoft. Considering the millions that have been flushed down the toilet trying to make drag and drop do what it was not meant to do, it's a crying shame. Hopefully the tide is slowly turning and great endeavors like this will be supported properly by Microsoft in the future.

As a token, I'm adding a little I <3 Spec# on my blog.

Do check out spec#!

Graphical vs Textual DSLs

2008-04-27T22:52:00.000-07:00

At ALT.NET there was a good talk about the merits of graphical DSLs. BizTalk and SSIS come to mind when talking about this. Say we have some data work to do and we do it in SSIS. Once we have constructed our migration or data manipulation, we can save the project.

What we have done in actual fact is saved the graphical representation of what we made. Once this solution is checked into our source repository, it is saved in a non-deterministic fashion. If we modify our solution and commit our changes again, there is no guarantee that everything that was not changed will be in the same place.

To see this directly, you can do a diff on the two versions. Since there is no way to visualize the differences, this information does not tell you anything. One is forced to probe over the details of each property to see what has changed. The best hope is that the person that made the modifications had left some good comments to go on.

So it seems like textual DSLs are the way to go. Once we have changed what we want, the diff between two versions will be very easy to analyze. This is good, but I believe there is a point in between. This is a hybrid solution that will use a textual DSL and a visualization tool to make a graph of what the text describes.

How this can work is the way Visio can make a class diagram for you. If you use the reverse engineering tool to do this, it will place classes in places it's algorithm thinks is best. This of course will not be the ideal most of the time. One will want to move things around so that the information is better conveyed.

These adjustments are what can be cast aside into a secondary file. One would not care what changes this file went through in the repository. The real information is still stored in the textual representation. Hopefully, with more attention to the preference file (storing changes only in an additive way) can help version this too.

A quick analogy can be drawn up to the .suo files that Visual Studio creates. Your solution has the same projects and settings. But the windows that you had open and a number of other preferences are stored in the suo file. These generally do not make it to the source repository.

If there was a way to use a textual DSL to describe your SSIS work, a lot of responsible programmers would be happy. Maintaining an SSIS project would be far easier - or any other drag and drop ridden solution.

Thoughts?

Twittering as well

2008-04-23T00:21:00.001-07:00

For those of you using twitter, you can follow me if you like.

Back from the dead - and back from ALT.NET Seattle!

2008-04-22T23:00:00.000-07:00

I'm finally getting the nerve to blog again. This is probably due to how immersed in work I have been lately. The work I'm doing now is not the same old contract stuff - it's new and therefore exciting. Part of the challenge is seeing how Agile, Scrum and XP play a role in DDD, Messaging Architectures etc.

The tipping point was ALT.NET Seattle. My head is now sufficiently filled to nearly overflowing with information. Not putting "pen to paper" would be a great loss to me. If this helps others along the way then great! But the company at ALT.NET Seattle eclipses most of what I will say. I'll have to update my blog roll soon.

The Conference

The format was open spaces. This was a new experience for me. I was very pleased with it. The participation is something that is missing from the traditional format. There was a lot of video taken. David Laribee posted some as did Jeffery Palermo.

I had a good chat with Scott Hanselman and Martin Fowler in between sessions about being a polyglot programmer. Scott was making the point that "if you want to learn French you start reading books written in French" to draw a parallel of learning a new programming language. Unfortunately the real analogy in the ALT.Net space for some things such as NHibernate and the Castle implementation of Active Record which does your XML mapping via attributes, the analogy is more along the lines of "if you want to learn Rumantsch you should read books written in Rumantsch". I'm not sure if you'll find one in your library. The full discussion is on David Laribee's blog linked above.

At other points I had discussed using GIT instead of SVN, the intricacies of moving to message based architecture, new things coming out of Microsoft Research like Spec# and many other things. I'll leave these things for posts in the very near future. There were many really smart part people there and I was very happy to be a part of the event.

A special thanks goes out to Scott Bellware for pushing this forward from day one of the idea of an "ALT.NET"

Castle Windsor for AOP

2008-01-04T16:45:00.000-08:00

Finally I have an opportunity to use AOP on my current project that I'm working on. So I'll be using MicroKernal/Windsor.

I will use attributes to mark long running methods. When those calls are intercepted, they will generate a status window that will inform the user that something is happening.

Code will be posted soon.

The altnetconf news group on yahoo

2007-12-28T11:23:00.000-08:00

It's too bad it was renamed to cli_dev. To people that are not connected yet, searching out for a discussion group on alt.net has become a bit harder. I prefer Google Groups and set up a group for discussing alternates to MS's tool stack while still being ".NET".

The cli_dev group description makes a very broad and ambitious brush stroke. What the google group does is focus in on people helping each other with the tools in one place. One can ask a question about Subversion, ActiveRecord, Resharper, Cruise Control in one group instead of having to go to the specific mailing list for that particular project.

The link and subscription is in the left hand margin.

DSL Books

2007-12-28T10:34:00.000-08:00

It seems Oren Eini (Ayende.com) is writing a book at the same time that Martin Fowler is writing a book. It should be nice to read both at once and cross reference. Both guys are getting feedback from the community.

Can't wait!

TDD Challenge

2007-12-27T23:07:00.000-08:00

TDD Challenge

See if you can solve it.. post how far you got with your solution....

.... wow. This is the start of a really deep rabbit hole... google around to see what this was designed to do...

Resharper 3.1 is out!

2007-12-27T13:20:00.001-08:00

I'm a big fan of Resharper. In fact, I'm not half as productive with out it.

With this little upgrade, you get solution wide real-time code analysis! Not just the file you are working on, but if anything else is not going to compile, you can get there without having to try recompiling first.

I'm in the process of installing it now and will post more when I finally get to use it.

Team City from JetBrains

2007-12-27T00:38:00.000-08:00

It's free and it's really good. From what others have been saying about the previous versions, 3.0 is excellent.

It takes a few moments to setup. Compared to CruiseControl.NET, it's a breeze. No xml to swim through - just simple configuration through a web page!

Take a look here.

Now You Don't Need To Deal With SQL

2007-12-06T22:53:00.000-08:00

Imagine this: You want to create some new functionality that involves a new entity. You write your test and your entity in 30 seconds using active record and some Resharper templates. When you run your test, a new table is there for you to store your new entity and your test passes.

How is that possible? Code generators do this. More importantly, how is it maintainable? Most code generators start with the DB. I don't even want to look at the db when I'm flying through my solution with Resharper. Here's how to roll your own "maintainable db generation".

Dealing with the database is a pain when you're trying to develop something really fast. Active Record goes a long way for getting rid of 80% of the pain.

There are 3 things to consider in automating this:

1. What tables and columns exist in your schema right now?
2. What entities do you have in your domain right now?
3. How will this change to the db rolled out and then persisted?

1. The answer is obvious by running this query:

select table_name, column_name from INFORMATION_SCHEMA.Columns

This will give you all the columns and the tables they belong to in your schema. For dbs without the ability to query their own schemas, you can parse the version script or another artifact that reflects the schema.

2. The entities in your assembly that you are interested in derive from ActiveRecordBase. You can use reflection to find all of them:

Type[] types = type.Assembly.GetTypes();
foreach(Type type1 in types) {
object[] attributes = type1.GetCustomAttributes(false);
foreach(object attribute in attributes) {
if (attribute is ActiveRecordAttribute) {
Console.Out.WriteLine(type1.Name);
PropertyInfo[] properties = type1.GetProperties();
foreach(PropertyInfo propertyInfo in properties) {
object[] propertyAttributes = propertyInfo.GetCustomAttributes(false);
foreach(object propertyAttribute in propertyAttributes) {
if (propertyAttribute is PropertyAttribute) {
Console.Out.WriteLine("--" + propertyInfo.Name);
break;
} } } } } }

The above code is missing a lot, but it will get you started. You will need to check the types, nullability, BelongsTo, HasMany, many-to-many, nested and others.

3. Comparing the information from 1 and 2 you will get the additions to the entities that don't yet exist in the db yet. The differences can be mapped to the following addition to the version script - which may look something like this:

IF EXISTS (SELECT version from [dbo].[version] where version = 39)
BEGIN

ALTER TABLE [distributors] ADD [accountID] nvarchar(50) NULL
CREATE TABLE [dbo].[config](
[id] [int] IDENTITY(1,1) NOT NULL,
[configName] [varchar](50) NOT NULL,
[configDescription] [varchar](100) NOT NULL,
[configValue] [varchar](100) NOT NULL,
CONSTRAINT [PK_config] PRIMARY KEY CLUSTERED
(
[id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

UPDATE [dbo].[version] SET version = 40 where version = 39
END
GO

The version script runs anytime the test project recompiles (the post compile event in the project properties).

I will have a working prototype in the next couple of days. I want to hit the low hanging fruit first. This will take care of basic additions for now. The alterations and other concerns will have to wait. I'll add them as the needs arise.

Let me know if you have done anything like this or have any comments or suggestions.

ALT.NET Google Maps

2007-12-06T21:18:00.000-08:00

Scott Reynolds has started a google map of where all the ALT.NET folks are located. This is a great resource for if you are wanting to make a regular local tech talk happen, or if you would want to collaborate on a project together. Put yourself on the map!

PS. To add yourself on the map, click edit once you zoomed on your area. In the top left corner of the map you will see the pin.

Joshua Kerievsky's 10 Terrific Transition Tips Presentation

2007-12-06T13:43:00.001-08:00

Here is the link to the presentation slides that Joshua showed last night.

Some highlights are:

Perils of Solo-Programming:
– Tunnel Vision (Frog-In-A-Well) Syndrome
– Less Productivity
– Less Knowledge Transfer
– Longer Times Fixing Defects
– Less Code Re-Use
– Poorer testing

XP/Agile Productivity Improvement
	Previous Performance	Current Performance	Percentage Improvement
Staffing	18	11	39%
Defects	2,270	381	83%
Schedule	18 Months	13.5 Months	24%
Cost	$2.8 Million	$1.1 Million	61%

Active Record and Many to Many Update

2007-12-06T12:55:00.000-08:00

Ok. I've cleaned it up now. In the continuing journey of learning Active Record and NHibernate, the static FindAll method can be overridden and the client code is as clean as you would expect it to be:

Distributor[] all = Distributor.FindAll();
foreach(Distributor distributor in all) {
Console.WriteLine(distributor.Name);
foreach(DeliveryMethod deliveryMethod in distributor.DeliveryMethods)
Console.WriteLine("--" + deliveryMethod.Description);
}

Here is what was added to the Distributor class:

public new static Distributor[] FindAll() { return FindAll(DetachedCriteria.For(typeof(Distributor)).SetResultTransformer(CriteriaUtil.DistinctRootEntity).SetFetchMode("DeliveryMethods", FetchMode.Eager)); }

I'm sure there's a way to include the same attribute on the DeliveryMethod and still get the results you want - I just haven't learned enough of the API yet to know how to do that. Tips are welcome..

Active Record and Many to Many

2007-12-05T23:20:00.001-08:00

I tried to get the following to work:

Distributor[] all = Distributor.FindAll();
foreach(Distributor distributor in all) {
Console.WriteLine(distributor.Name);
foreach(DeliveryMethod deliveryMethod in distributor.DeliveryMethods)
Console.WriteLine("--" + deliveryMethod.Description);
}

The result was multiple queries to the db and multiples of Distributor objects.
It had to be changed to this to actually get what a non-AR user would expect:

Distributor[] all = Distributor.FindAll(DetachedCriteria.For(typeof(Distributor)).SetResultTransformer(CriteriaUtil.DistinctRootEntity).SetFetchMode("DeliveryMethods", FetchMode.Eager));
foreach(Distributor distributor in all) {
Console.WriteLine(distributor.Name);
foreach(DeliveryMethod deliveryMethod in distributor.DeliveryMethods)
Console.WriteLine("--" + deliveryMethod.Description);
}

The attribute on the Distributor class' DeliveryMethods property is as follows:

[HasAndBelongsToMany(typeof(DeliveryMethod), Table="distributorDeliveryMethod", ColumnKey="distributorId", ColumnRef = "deliveryMethodId")]
public ICollection DeliveryMethods { get { return distributorDeliveryMethods; } set { distributorDeliveryMethods = value; } }

While no collection of Distributors exists on the DeliveryMethod class.

Is there an easier way to do the above find? What happens if you want 3 or more joins chained?

Joshua Kerievsky's 10 Terrific Transition Tips

2007-12-05T21:55:00.000-08:00

I attended Joshua's presentation today at Sophos. This was put on by Agile Vancouver. Joshua is the author of Refactoring to Patterns. Here are the points he made:

1. Management and Development Process is Important.

Scrum alone does not work. Eventually it will be frequent releases of buggy code. Saw that one before.

Pair programming can't be sold. From my experience many object to it as they are very anti-social. Their programming skills have been honed by spending late nights in front of the computer alone. It's certainly what I remember doing since I was a kid.

What works better is selling the risks of Solo Programming. Joshua's list was more comprehensive. If anyone has anything to add to this, please feel free to comment.

Frog-in-a-well: The developer has a very small view on what is being worked on. There is no one around to rescue the direction of the code to be in line with what is being worked on. The risk of throwing away what you've written and starting over is real and will happen often.

Productivity not as high: Developer is sitting alone. Goes off on a coding tangent (related to above). Or goes over and above of just enough to work. Or reads a blog, gets entrenched in an email thread, etc. No one there to ensure focus is on building the software.

Low code reuse: Without anyone there to suggest that this was already done somewhere else in the code base, a similar solution is coded. Because it was reinvented, it's harder to refactor the duplication.

There are way more.

2. Removing Risks:
A company goes to agile to mitigate risks better. There was more to this, but I think I was busy finding a plug for my dying laptop at the time. I managed to capture the following:

Technical Debt: It is very hard for business to understand technical debt. At one of the companies that Joshua was consulted to introduce Agile at, there was a method that was 28 printed pages long. He taped them together and rolled the method out on the floor of the hotel lobby. He showed us the video of that. If I get it from him, I'll post it on this blog. The use of endless analogies is needed for them to grasp what the developers have to face.

- credit card: Ask the executives how often they make a payment on their credit card. What would happen if they stopped making payment? This is what developers are faced with.

- driving instructions: Joshua wrote really bad driving directions from a patchwork of old English, pig Latin, etc. He asked the execs if they could use those instructions.

3. Business Trumps Process
Should not happen all the time. See above. Business tends to add features in the fashion of a drug pusher: "Just have another feature..." It is important to be a good debt manager and push back on features before the machine grinds to a halt. "Version 5" software is where this happens. By this time, you are only fixing bugs to the product and don't have enough cycles to push out more features and stay competitive. Like having a maxed out credit card.

4. Engage the Entire Organization
Management, Support, Customers and Development must be involved. The concept of a project community is important. It is usually larger than one would expect.

HR is really important as they usually make dire mistakes such as rewarding cowboy coding. HR should be on board as soon as possible.

A major, big project should be chosen to introduce agile on. A one-off project will always be dismissed as a fluke, or didn't have the high standards that the rest of the company works against.

5. Handle Scaling Problems
Joshua's company's sales pitch. They do eLearing for Agile. DRY on the meta level. It was not productive to repeat themselves over and over because the company is too large to get everyone trained within a reasonable amount of time.

6. Fail fast
Tests will do this nicely. The #1 success factor in agile is automated testing. HTTPParser is an OSS project with tests. They are bad tests as changing one line in the production code will make a slew of tests fail. But this has contributors from all walks of life - should be happy that it's fully regression tested.

7. Gather Metrics
How will you know that the agile practices have helped? Five Core Metrics is a book that outlines how to measure the productivity on your project and other indicators. Agile/XP has proven to eliminate 83% of the defects that are found on large projects.

8. Readiness
This was actually the first point. I'm just remembering it now. The company can have the money, the time, etc. But if the db architects group is a rock that won't budge, agile won't get very far. If that does not change, walk away. Joshua's example was one where the db architects group would take 3-4 weeks to consider adding an extra column in a table.

My question at the end was what specifically was important to report regularly to management - at the end of an itteration. Reporting of risks to management was the number one thing.

I know there was 10 points, but in my notes I may have dropped one or two, or mixed them in with the other points. The Agile Vancouver folks say the power point will be available tomorrow. I'll post a link and update then.