Why Developers Agree More Often Than Disagree

Recently I've seen some interesting blog posts from attendees of No Fluff Just Stuff conferences (nfjs). These posts essentially say this: the speakers agree too much with each other. I'd like to tackle this in a constructive way in this blog post. For some background: I am occasionally on this speaker panel (like this past weekend at the Tampa NFJS show).

To mix it up, I decided I would take a slightly antagonistic approach this time. I would call the other speakers to the mat on issues or at least present an alternative viewpoint during the discuss. It was a little exercise at the expense of the other panelists (sorry Nate, Ken, Jeff and Alex!). The panel had a few fireworks, but no major explosions. The odd thing is this: I was actually expressing a different view that *was* my opinion - regardless of my attempt to shake things up. I think the audience was enjoying it since now I had brought extra emotion into the normally calm discussion.

The entertainment value aside, however, the content of the discussion was typical: the speakers agreed on many things the others speakers agreed on. There were small disagreements, but on most topics it would seem to the some in the audience that the panelists were "on the same page." 

This isn't some kind of Roswellian conspiracy, though. The speakers on the NFJS tour tend to be outspoken and somewhat opinionated - after all, how many folks can stand in front of an audience for 3+ hours a day and deliver technical sessions? While there are differences of opinion on many issues, we are all in the same boat - panelists *and* attendees: we are all developers working in the trenches. We all feel the same pain, feel the same joy, and are always looking to improve professionally.

When we find something interesting, we share it with others, either on the interwebs or in person. When we hear cool and new stuff from others we know and trust, we tend to believe it and take the comments at face value. This doesn't mean we don't form our own opinion - to the contrary, it often means (at least for me) that we'll dive even more deeply into the subject and form our own thoughts on the matter. The suggestive power is at play here, but with a group of outspoken tech geeks, it can quickly be supplanted by personal experience and opinions.

The fact that we often arrive at the same conclusion means one thing - it is often the "right" solution, view point, etc. For example, you will find that every NFJS speaker (and hopefully attendee) hums the mantra of unit testing - we think it is the right thing to do *always*.  For other things which are less clear-cut, an alternative view point will always be voiced in this crowd. So it's no surprise that developers agree more often than disagree on technology, process, or other issues. We share many of the same experiences, and even our different experiences lead us to the same place.

From http://www.jroller.com/prpatel/entry/why_developers_agree_more_often