Slashdot Mirror
Organizational Patterns of Agile Software Development
Organizational Patterns of Agile Software Development starts by describing the foundations of the authors' research. There are definitions of a "pattern" (but "your intuition about the meaning of the term will take you far") and of a "pattern language" (read the book), the history of their research, and some information about how the book is laid out. The authors recommend you read this section, and so do I; but if it's too dry for you, by all means move on.
The meat of this book is four pattern languages: how to manage a project, how to grow it over time, what can make up an organization's "style" (I'd use the word "culture"), and how the people fulfill their roles and interact with each other. These are not prescriptions or algorithms; they're elements of how successful organizations have worked.
Each pattern describes one aspect of some effective software development organizations. Some patterns are found in more than one pattern language; "Community of Trust" is common to all. Others are less general; "Moderate Truck Number" applies only to the "piecemeal growth" pattern language.
How valuable are the patterns? Some (such as "Get On With It", proceeding with an effort before the planning is considered complete) are common sense. Others (for example, "Don't Interrupt an Interrupt") are things you probably know, but might need to be reminded of ... or might need to remind your boss of. More than a few (my favorite is "Architect Also Implements") might help you understand how something could or should work. Finally, there are some patterns here (such as the "Day Care" pattern for training new members) that might be new to you.
The rest of the book puts the patterns and pattern languages into perspective. There are chapters on organizational principals and (seriously) anthropological foundations of this work. Then there are two case studies of very successful projects. On one, "[about one] million lines of code were written over a period of 31 months by about eight people (that's about 1,000 lines of code per person per week) -- that doesn't include code in the [two] prototypes." It's easy to crank out code at that rate for small bursts, or on small projects. To stay at that pace constantly for over two and half years is nothing short of astounding. The resulting product was released to great reviews. (It then did poorly in the marketplace when it went head-to-head with a directly competing product from Microsoft. Sound dissatisfying? Consider how very long people waited impatiently for Mozilla and its successors such as Firefox. More directly, look at Robert Glass's assertion of the "disconnect between managers and their programmers" as to what projects are seen as successful; it's Fact 13 in Glass's book reviewed August 30th on Slashdot.)
What's imperfect about this book? A couple of things.
First, sometimes the language gets too academic for easy reading. Example: "We have also seen a lighter though almost equally destructive form of this phenomenon, which we describe as schismogenesis.... Symmetrical schismogenesis occurs when two factions each rise in power (or in fear or distrust of each other) and form cliques or splinter groups that tend to focus inward rather than resolve issues in the dialogue with each other." Clear enough if you work on it, but a little intimidating.
Second, the book is surprisingly partisan on some subjects. The book is not kind either to ISO 9000 or Extreme Programming; it could serve as a sort of litmus test, delighting critics and coming across to supporters as unfairly harsh.
What's good about this book? It's a collection of good information, well presented, with information on how to apply it, on a topic where not much knowledge has been accumulated. For some specific circumstances, this book sometimes points out different likely alternatives, with information on when each is applicable. Don't expect Organizational Patterns for the Complete Dummy; then again, don't expect anything useful to be superficial.
How could Coplien and Harrison's work apply to open source development? For starters, they point out the value of people working physically together, and of individual code ownership; these aren't easily applied to open source, but at least it points out forces that need to be resolved somehow. On the other hand, some patterns here are hugely relevant to open source: "Work Queue," "Informal Labor Plan," "Self-Selecting Team," and "Team Pride" come to mind.
Organizational Patterns of Agile Software Development is no panacea. If your organizational practices are the opposite of what's found to be effective, you may find this book frustrating. A book can't take your organization where it needs to go; but Coplien and Harrison have put up some road signs.
You can purchase Organizational Patterns of Agile Software Development from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
If you're leading a software project and reading books like these your project is already screwed.
I dunno.
Good leaders are constantly trying to learn new things.
Good leaders don't dismiss an idea because it is/isn't associated with a fad, they evaluate the idea on its merit.
Good leaders know the difference between "there" and "their"
A couple points in defense of QA. First, if the developers were pumping out better code, instead of more code, speed of the QA people would not be an issue. Second, your slowbie QA people aren't really slow.
What happens is, Z amount of time is scheduled for a project; X development + Y QA. The developers always go over schedule and take X + a time. (I'm not saying it's our fault--PHB, feature-creep, whatever--but it happens.) This leaves QA with Y - a time to do their job.
Inevitably, especially as a approaches Y, deadline Z is missed and all eyes go to QA since they are the last ones in the chain. As a developer married to a QA person, I get to hear about this stuff all the time. Lucky me =)
The previous ways are still valid - but the areas where they are appropriate disappear over time. One example is structured analysis/structured design with DFD, pseudocode, etc., where you go through analysis of current physical system, derive the current logical system, derive the new logical system and finally derive the new physical system. This is still valid in "green field" areas for document processing, but those fields are vanishing.
Another example is JSP (Jackson Strutured Programming) which is pretty good for traversing non-recursive data structures and transforming them or generating reports. But today you usually have the data in a database and have a nifty GUI report builder; or you use some form of XSLT. So you rarely use JSP today because the areas where it is appropriate are almost gone.
There also methods that can be used at multiple levels, eg. prototyping, which can be used as a strategy, method, or as a tool. XP has that philosophy at its core, although I fail to see how high-availability is magically implemented by interacting with users.
The waterfall model is still valid for larger government projects where they in general insist on detailed specifications and signing that contract. Iterative development involving re-analysis a no-no because that requires re-signing the contract.
One finally interesting area is maintenance. It probably accounts for more than 80% of the development resources, yet I have never seen any formal method/strategy/tool for handling maintenance/change requests/bugfixes. Is this because maintenance is unsexy?
At the core being a better programmer has to begin by being a better human being. The same with being a better manager, CIO, architect or a plumber.
The problem is that there are all kinds of Gurus and books out there which claim to make somebody a better "whatever" without ever once touching on what makes a better human being in the first place.
What makes a better human being? Well the lessons are not new and have been written down thousands of years ago.
Be less selfish, be more humble, help others, be kind, share more, take care of others etc. The golden rule more or less.
Large companies instead of sending their staff to certification classes or management seminars should send their employees to become better human beings. This may mean yoga classes, budhist seminars, philosophy classes or something.
evil is as evil does
Let's not be naïve; obviously, successful programmers -- as is stressed in one of the books I quoted as a reference, Code Complete -- always need to know how to work with others and have a realistic, comprehensive understanding of how the needs of management, and the requirements of the project, work together.
:)) of us live in, management is a necessary shield from inefficiencies of a beaurocracy, and more importantly, is possibly the only way that programmers can get their information about the requirements of the system. The burden is laid upon the manager of really communicating effectively, of communicating requirements, of clearly expressing the company's needs and position on a project, of ensuring that programmers have the correct context available with which to successfully approach a problem.
.
However, it's naive to think that the team of good coders -- and by now it should be obvious that I'm not using a narrow-minded 'creative hacker' definition; I mean good programmers, good architects, good with people, good communicators -- is really better off, in terms of potential, when they have a manager -- even one running interference -- than in an ideal situation where each programmer can know the point of view of the customer, can sit down with the customer and get inside their head and their business and bend their minds to the problem of delivering software that lets their customer take over the world on the one hand, and works within the budget of and accomplishes the goals of their company.
Manifestly, an ideal situation is one where the programmers know the needs of their company -- because they know its state, possibly have some ownership. Where they know the needs of their customer -- really know them inside and out. There is a reason that some of the most successful stories when it comes to programming are those involving companies and teams of very small size. Viaweb (Paul Graham) is an example of an agile product; features were often rolled out within a day of introduction by a competitor.
In the less-than-ideal world that many (but not all
That is a huge burden. And the fact is that most managers of IT professionals do not know how to manage the special case of programmers. The fact that the programmers often have to prod their management, gouge them for any sliver of information that could lead to an actual understanding of the real requirements and goals behind a project -- this fact is not a proof that coders need to know how to "work with" management.
Programmers will often go above and beyond the call of duty to solve the problems of the organization in a very real way -- often, as we have seen in the cases of small, successful, programmer-driven companies, in a real enough way to rocket a company from obscurity. A Manager is not going to do that.
He can, however, try to present a more ideal environment for his problem-solvers to solve problems effectively within. He can communicate ceaselessly, so that he's not excluding what could be data that is crucial to a complete or correct understanding of a problem. He can educate himself by reading the last few chapters of books like Code Complete and Rapid Development (these I picked just because they're on my desk right now; there are plenty others. The Pragmatic Programmer is solid, and there are a good dozen or so more that should be requird reading, including some of Joe Celko's later articles in Intelligent Enterprise, like "The Logic of Failure"). A Manager will likely be surprised -- if he has good coders, he will find that many of them have read all of those books already, and he will be amazed at the amount of practical knowledge they have about the realities of scheduling and organizing software projects. Rapid Development alone . .
Realistically, most programmers with that kind of an understanding of the issues involved -- and, of course, knowledge of the appropriate principles of abstraction -- will probably ha