‘‘Knowledge work is not easily defined in quantitative terms, . . . To make knowledge work productive will be the great management task of this century, just as to make manual work productive was the great management task of the last century.’’ Peter Drucker (1969)
In recent months I have repeatedly been reminded of an argument, or perhaps a hypothesis, I advanced in my 2008 book Changing Software Development. In the introduction chapter I suggested that software developers might be regarded as the prototype of future knowledge workers. I’ve republished “Prototype of Future Knowledge Workers” as a blog post yesterday.
I’ve been reminded of this in a number of casual conversations recently, like the one I had with Laurie Young (@wildfalcon), again when rereading some Peter Drucker and because of media pieces like one in the Financial Times (“Do it like a software developer” by Lisa Pollack) suggesting that companies with successful software development teams might have something to teach other companies, and also by the topics submitted to the Agile on the Beach conference.
Let me explain, firstly let me explain why I make this argument, then let me explain the significance - and with reference to Agile - and finally, for completeness let me quote from the book…
Software Developers - programmers, testers, and everyone else - are what academics would call knowledge workers. We work with our brains rather than our brawn. We generate value because of what we know and what that knowledge allows us to do.
There are lots of other knowledge workers, teachers, lawyers, doctors, and during the twentieth century the number of knowledge work professions and number of knowledge workers grew.
In many ways software developers are no different, but in one very important ways they are very different. Software developers are able to create new tools for machines which allow them to change the way they do knowledge work.
Think about some of the tools your common knowledge worker uses during the typical day:
- E-mail: invented by Ray Tomlinson, a programmer
- Spreadsheets: invented by programmers Dan Bricklin and Bob Frankston
- The Web: invented by programmer Tim Berners-Lee
- Wiki sites: invented by programmer Ward Cunningham
Even if Twitter, FaceBook, Video conferencing, Voice over IP and countless other knowledge sharing and collaboration technologies were not invented by programmers I will bet good money on one common factor: software developers, programmers, had early, if not first access to these technologies. That is very very significant.
Lets be clear:
- Unlike other knowledge workers software developers have the ability to create new tools which can change their work.
- Software developers have early, if not first, access to tools which benefit knowledge work.
One might also add that people working with technology welcome and embrace new tools and technologies (on the whole) so the barriers for technology change are lower.
This means those working in software technology - and particularly those developing software - have more experience and most history of using these tools, and consequently are the likely to be the most adapted to working with these tools.
Thus if you want to see how new technologies, new tools, will change knowledge work look at those who create the tools and those closest to them. This shouldn’t be a surprise, after all knowledge work is about managing and using information, and these technologists create the tools we use to store, retrieve, manage, manipulate, combine, and share information.
(And there is a difference between knowledge and information but I’m not going into that here, its in the book.)
By itself this argument is interesting and perhaps good for developer self-esteem. We could leave it there but…. it also begs a question:
If software developers are the prototype of future knowledge workers what does it suggest will happen next? Specifically, how can this insight help answer the challenge posed by Peter Drucker above?
As a step towards answering those two questions let us rephrase the question:
- What are software developers doing today which might benefit other workers?
- Or to put it in Drucker’s language: what can managers of non-software staff learn from software teams which will make their teams more productive?
One way would be to look at the tools software developers are using today which might benefit other groups.
Version control springs to mind but version control has existed for at least 30 years and hasn’t caught on with the masses. We could continue to examine the toolset, one of my favourites is Markdown. Or we could look at the way software developers are managed. This was the thrust of the FT piece which looked at personnel management (I refuse to say HR) practices.
But there is something else… Agile itself.
One of the reasons I believe Agile came about was that the tools we use changes. Cobol gave way to Java which gave way to Ruby. OS/360 gave way to VMS which gave way to Windows (or was it Unix?) which gave way to Unix derivatives. One might say paper gave way to the web and wiki’s, telephones gave way to VOIP, telegraphs gave way to Twitter.
Our tools changed which allowed - even forced? - our processes to change. As knowledge workers outside of IT embrace these these tools its possible that their working practices will change in a similar way. My favourite example is a presentation given by Kate Sullivan at Agile on the Beach two years ago in which she described how the legal department at Lonely Planet adopted Agile.
There are several Agile practices which area are easier to imagine outside of software than others. For example:
- Visual boards: lots of places!
- Standup meetings: example abound and usually predate Agile, e.g. bar staff, Japanese office workers, NATO commanders (in Bosnia and probably elsewhere)
- Test driven working: consider many of the business examples from Lean Start-Up
- Pair programming: airline pilots and surgeons have been doing this for a long time but Kate added Pair Lawyering
- Iterations: although I’ve yet to get a concrete example most news organizations clearly operate in daily iterations
During the second half of last year I was involved with a client whose project was to write documentation. Specifications to be precision but not specifications for software - there was an element of that but that was not the aim. We used iterations, visual board and other techniques. We even used a walking skeleton. It worked. We delivered to schedule.
We in software have developed something good. Something that is spreading beyond software. Now I wonder, whats next?