Software Socialism?

Working with the patterns & practices group has been a really interesting way to spend the last few years of my life (three years this week!). When I got here, we were just “PAG”, the team that worked on the first MSA and the Reference Architecture for Commerce. Soon came a new focus on application architects and developers and new deliverables like application blocks, design patters, the security tomes. Eventually, we got the p&p moniker and started to really boost our reputaton. We are no longer Redbooks—in my mind, we’re something much better. The popularity explosion has been great. I’m amazed by the statistics of my blog, although I’d love more people <shameless plug> so tell your friends </shameless plug>. Of course, I have no delusions that I am a great writer—it’s all about the great content on the /practices site. But there’s the ultimate unanswered question: who’s it for?

 

I had a great conversation with a colleague on the way back from TechEd where we spent 4+ hours discussing this very issue. At the center of the discussion is the “opportunistic developer” vs. the “agile developer”. You know the opportunistic developer. No CS degree and little to no formal training, but certainly capable of creating great apps. Probably grew up on VB. In many cases, they are self-taught and anxious to learn more, but more from a “get the job done” standpoint instead of the academic perspective. Essentially, it’s the type of developer the snobby Unix guys mock endlessly, but they made the Windows platform the most popular one on the platform with their VB magic and Microsoft owes them plenty. They’re also the ones that may be having the problems going from VB6 to the OO world and VB.NET. They love the app blocks because we've eased the burned by abstracting a lot of stuff they didn't want to learn on their own. But we don't completely hit the mark with them and they find patterns and aspects hard. Given our limited resources, should p&p focus on helping these people get over the hump?

 

Or, as my colleague suggested, given our expertise and some of the notable players we have on the team (Ward Cunningham, Jim Newkirk, David Trowbridge), should we focus on the agile developer that often gets lost amidst all the love given to the VB6 guy? The agile developer is the new wave, throwing conventional wisdom out the window in favor of XP (eXtreme programming, not Windows XP), test-driven development, etc. They’ve already bought into the patterns mantra and they believe the world revolves around architectural models. The Java world has embraced them, but Microsoft hasn't done as much in this area. patterns & practices has probably done more for this audience than most groups at MS, but we can only do so much. The opportunists identify these guys as “academic” and “impractical”. They’re often lost in the MS culture where we’ve been built on the opporunitists.

 

So, when making decisions on what to do or what level to do it at, the question becomes who do we focus on? If you ask the agile developer, he’ll say “it’s about time Microsoft noticed we exist, but you still haven’t done enough to help me. I don't know if .NET is a option unless you guys step up.” If you ask the VB6 guy, he’ll say “Microsoft shows me all the love? What love? You deserted me and all you care about is C#!” I’ve heard customers from both sides shoot me with both criticisms. In fact, I received this e-mail from one opportunist customer that I think was very interesting.

The Patterns and Practices Guides are terrible. Most developers do not have Masters in Computer Science. While some theory is nice, we need quick, targeted information on how to implement applications. Employers barely provide training, let alone time to contemplate design theories. Microsoft is evolving development practices way faster than developers can learn about them and implement the practices, which leads to confusion and anxiety of using Microsoft products. Please put your self in the shoes of the average developer and make it easier for them to create new solutions based on the latest Microsoft technology.

 

Angry words indeed. I’d like to think our guides aren’t “terrible”, but he clearly identifies a need for us to better recognize the issues our customers face. So what’s the right answer? It’d be nice to say both and I think we try to do that. But our current approach attempts to achieve some “separate but equal“ policy (which, for the non-US contingent, was a term used to describe racial segreagation in America before the civil rights movement of the 60s). But that spreads us thin when we dedicate half our library to each audience. Plus, people don't know what to expect for each release. My colleague believes that the only way to compete against other platforms is to accept some of their solutions are better and try to woo that audience by embracing the trends that are increasing in popularity over there. His is that if we don't do it, no one at Microsoft will. Therefore, p&p really needs to shift our primary focus to the agile guy. I agree that we need to embrace those trends if we're gonna win over a lot of Java developers/architects, but my contention is that we have a responsibility to usher the opportunistic developer into this new age with us. Saying we don’t care about him/her sends the wrong message. I think the dream is where we make the opportunists more productive and, in the process, try to expose them to the agile aspects (not those aspects) of development. My internal soapbox is to NOT ignore the opportunist, but rather to make him more capable in addition to the increased productivity he craves. Give a man a fish and he eats for a day. Teach a man how to go fishing and he eats for a lifetime. We shouldn't underestimate the ability of the opportunist to adopt some of the agile principles, but we need them to overcome any biases of it being “academic“. An example is some of the cases where we've released unit tests with application blocks. What a great way to evangelize an awesome approach to development while providing an assets that makes a developer more productive. Having written my first two test-driven apps in the last few weeks, I am hooked. However, I wouldn't have even tried if it weren't for the fact that Jim Newkirk sits across the hall from me and gave me a free copy of his book, which is really good. <shameless plug#2> If you wanna know more, go to amazon.com and tell 'em Sandy send you ;-)</shamless plug#2>. I knew about JUnit and NUnit for years, but never bothered to try it until I had a good reason to do so. My point, a lot of opportunists would love this stuff if only they saw it. We just need to recognize that we are not necessarily preaching to the choir when we include this stuff and there we should do all we can to make sure the opportunist gets this stuff (part of what makes Jim's book so good is that it is a demystification rather than a thesis). So I have no problem investing more in the agile developer, but when we build “agile assets“, make sure there is an on-ramp for the opportunist. I guess this is my version of “software welfare“. My hope is that we strengthen the quality and capability of opportunistic developers--some hybrid know as “the agile opportunist“? Just imagine, together the opportunists and agile C# guys can unit as one and laugh at the Unix dinosaurs that once seemed so superior. Is that too much to ask?

 

{Velvet Revolver – Contraband}

Comments

• Anonymous
  July 12, 2004
  While I'm definitely in the Agile camp we have run introductory sessions at the user group on topics like TDD, refactoring, and patterns for the oportunists and had some great attendance. It's arrogance to assume these guys can't get it, they do. What they want is someone to point them in the right direction and try to distill it out key facts for them to get started with.
  
  Let's not get snobbish like some of the Java/Linux camp. Inclusivity should be our strenght not our weakness. But let's still raise the bar, and encourage folks to reach for it.
• Anonymous
  July 12, 2004
  I agree with the comments that Ian makes.
  
  Most of the Agile practices are rooted in pragmatism and have been created (I should say distilled) by developers (practitioners) developing software. Most techniques may not be obvious because of that probably ignored. But once the techniques are applied the benefits are imminent and the implication is that you are Hooked.
  As we develop more P&P deliverables exposing the end products of some of these techniques and show casing the value they add to the deliverable - would not only help bring them to our (MS) developer community but also give them a concrete point of reference.
  
• Anonymous
  July 12, 2004
  I completely agree with both of you and I hope I didn't come off as insinuating that the opportunists weren't capable of adopting the practices (I wasn't positive if you guys were agreeing or disagreeing :>). In fact, to be clear, my point is exactly what you guys say: the opportunists are more than capable and p&p (and MSFT for that matter) should do all it can to point them in the right direction and, in the process, raise the bar for them. As Naveen says, seeing the end results in the form of p&p can help showcase the fruits of agile labor, so to speak...
• Anonymous
  July 14, 2004
  Coming from the Agile camp, I'd say that its very much the case that the Java community caters to us and Microsoft does not. A cursory googling reveals that there's thousands of "A Million and One Things To Do With DataGrid" tutorials, but precious little in the way of real architectural guidance.
  
  There's a huge amount of developer inertia that must be overcome by the Patterns & Practices group. A quick glance around the web at ASP.NET tutorials reveals an awful lot of SQL code and SqlConnection objects being instantiated in Page_Load().
  
  
  P.S. Test-Driven Development in Microsoft .NET is cool, and by cool, I mean totally sweet!
• Anonymous
  July 15, 2004
  (link)
• Anonymous
  July 15, 2004
  Upgrading myself from 'opportunistic' to 'agile'