Thoughts on The Lean Startup

 I had the opportunity to get a review copy of The Lean Startup: How Today's Entrepreneurs Use Continuous Innovation to Create Radically Successful Businesses by Eric Ries. I learned a few things from the book, but the most surprising thing was that what, on the surface is a book targeted at business people, entrepreneurs in particular, actually had a lot to offer developers and project and product managers who work at all sorts of companies. In addition to reviewing many of the lean principles and practices familiar to anyone who takes agile software development seriously, this book also makes a case for how practices that work for developers (like testing) also make a great deal of sense at the business level. To be sure the tests are different, but the idea of having measurable expectations is something all agile developers who have written a unit or integration test should be familiar with. Eric Ries shows how this same approach makes sense for determining the direction a business should take.



This book provides guidance on the tools to use to answer the question "are you building the right product" quickly. Even if you are on a team in an established company -- even if your are building tools for internal use -- concepts like the Minimum Viable Product can be useful to you immediately.

In spite of the book's business oriented focus, it makes clear the importance of good engineering practices to build a sustainable product development environment. This book can benefit those who work in startups and anyone who works on a team that wants to have the impact of a startup.

Why SCM Patterns is in Patterns Format

I recently had an opportunity to speak to an undergraduate software engineering class. The professor for that class, Danny Dig has a very interesting practice of asking practitioners to speak to the class over Skype when an appropriate topic presents itself. Danny invited me to join then when they were discussing software configuration management and version control.

During the session Danny asked me why we used pattern form for the material in  Software Configuration Management Patterns: Effective Teamwork, Practical Integration was in pattern format. At the time I might have quickly answered that I was interested in patterns and the book was based on patterns we'd written. But aside from being a too flippant, and not terribly profound. that answer isn't actually right.


There are two aspects of patterns that make them well suited for software configuration management practices, especially those at a team level:

•  Patterns describe things people have done successfully, and we wanted to document the practices that worked well, and which, when they were missing, caused problems. We wanted to catalog the things that we found ourselves explaining again and again in different organizations. If you read the book,  much of what you read will sound obvious. But it's only obvious if you know it, and may people don't.
•  The pattern form makes it very clear than everything fits into a context, which includes other decisions you've made and the environment your working in.  People often get captivated by solutions without really thinking about whether the solution is right for he problem they have, and what else you need to do before and after to ensure success. 

Too often people associate SCM with tools. and techniques without considering what techniques work well for the team. SCM Patterns puts the solutions in context with your organization, process, and architecture and (hopefully) provides you with some guidance on the steps to build an environment where people can code together effectively.

The other thing I realized shorty after writing the book is that, while the book was in it's final stages just as the Agile Manifesto was being worked on, the book had a lot to say about agile collaboration. The SCM Patterns book, to me, is really about how to work together more effectively. SCM is just the means.

Experience and Learning

In the past few months I've heard a couple of stories about (in effect) the disadvantages of experience when it comes to innovation and productivity. A Story on WBUR on July 5, 2011
discussed how venture capitalists tend to favor young entrepreneurs, as having never learned the wrong things in business they don't know what's possible or impossible.  In one quote a VC said:

One thing I love about these people is they don’t know what they don’t know. They don’t fear failure. They don’t mind risk...

A March 6, 2011 story on NPR on the pros and cons of raising the retirement age made reference to to an article in Foreign Policy which asserted that younger workers have advantages in the workforce since they learned more recent technology in school.

While new skills and new perspectives can add a lot to a team, is the best way to get these skills to simply hire people who know only what they learned in school? Is anyone you know who is a successful, productive, software developer only working with skills and perspectives that they had when they graduated school? I suspect that the answer is "no." And do people who are new to a field fall often fall into avoidable traps because they don't have the experience to know that the traps were lurking?

In any field it's important to be continually learning. I've worked with recent grads who seems to now be aware of important, new technical subjects, and with people with 30+ years of experience who were the people I learned many new things from.

The important thing in both of these cases isn't "new-ness or experience" but an ability to keep an open mind, learn, and "embrace change" (to borrow an expression from an agile software development method).

In the book The Cat Who Walks through Walls, the subject of the title could walk through walls because she was too young to know that she could not. While having this mindset is useful, there are ways to achieve it without being inexperienced or ignorant.

As the WBUR story concluded: "In this day and age, forget about age. All you need to start is a fresh idea."

To be a successful agile team you need a mix of perspectives and experiences and a willingness to learn from each other.

Happiness and Agility

Agile development practices at their core, have a common theme of making better use of the time spent developing software. This starts at the project level and continues down to the developer day-to-day-activities. Consider an agile iteration. The team starts the iteration with a clear sense of the priorities for the sprint, and pretty good understanding of the project scope.  Having estimated and committed to getting the work done,  the team also has a sense that the goal is attainable. The team members then collaborate to get the work done as a team.

While we can see how this might make for an efficient delivery process, consider how agile practices relate to enjoyment and morale on the team. In the paper If Money Doesn't Make You Happy, Consider Time,  Jennifer Aaker,  Melanie Rudd, and Cassie Mogilner discuss five principles for spending time in a  happiness-maximizing way. Some of these seem like a bit of as stretch, but there is a lot to be said about the relationship between a workplace using agile practices agile, and the teams being effective and happy. Consider how the 5 principles could map to agile practices:

• Spend your time with the right people. If you on a collaborative, self organizing team,  committed to reaching a common goal, it's hard to argue that you are with the wrong people.
• Spend your time on the right activities. The authors of the paper also use the phrase maximizing the value of the present moment.  If you've done your planning right, you have a good sense of what you are working on both for the sprint and each day. If your team is working on a project with an involved product owner, then you know that you are working on something useful.
• Enjoy the experience without spending the time. The premise here is that one can feel pleasure by thinking of a good result. Activities ranging from planning, to test driven development to retrospectives seem to fit here.
• Expand your time. This principle is about having control over your time. Since the team is self organizing and decides how to get work done, you should have a fair amount of control over what you are working on and when.

Using an agile process can't guarantee happiness, or even that you team does all of these things. You can have a poorly defined product backlog, a less than collaborative team environment, or a micromanaging product owner or manage, for example.

But agile is more  than just a product planning process that increases predictability It can also increase productivity and (as Brian Marick said during an Agile 2008 Keynote) Joy.

Specialization, Generalization, and Effectiveness in Software Teams: Clinical Metaphors

I was thinking about the relative value to a team of a developer with specific skills (say UI development) versus adding someone who was more of an end-to-end developer. Two stories about medical practice that provided some insight into the question.

I recently read Better, Atul Gawande's book about improvement in medical professions. In this book he relates a story of a clinic in rural India that is poorly staffed and funded, and where doctors manage to successfully perform procedures that are outside the realm of their training. They are able to practice these skills effectively and saved lives.

A story on This American Life, discussed a doctor  in Kermit, Texas who practices in areas beyond his stated training, with poor results. In the end nurses who worked with the doctor filed complaints against him for mistreating patients. This doctor worked alone, and collected information from questionable sources, and ignored the availability of better qualified resource near by.

In both situations doctors practiced beyond their training, yet in one case this improved care, in the other it degraded care.  Two of the key differences seemed to be that the doctors in India frequently met to discuss each other's cases and learn from each other, and  the doctors in india worked beyond their area of specialization in order to keep the clinic functioning and performing useful work. There was no way to wait for a specialist to do the work, and still keep the patient alive.  Gawande credits the camaraderie of the group in India as well as their daily discussions of their cases, their decisions, and why they made those decisions, for their ability to improve their range of practice.

Even though the dynamics in software teams differ from those in a hospital, there are lessons from these stories that software teams can apply to better develop teams of generalizing specialists, and more effective agile developers:

• An ethic of continual learning, both from outside resources and each other can help a team of generalizing specialists to be effective; Having the ability to work across a stack isn't as important as a willingness and ability to learn how to fill gaps in knowledge.
• The flow of the project is  important  to consider when deciding who should work on a task, consider the overall flow of the project. If the specialist is available, there you may as well have the "expert" work on the task (after the team agrees on an approach ). But if waiting for the specialist would delay the project, and there are other people on the team who don't have a full backlog of work, consider having someone else work on it. The specialist can provide advice, and perhaps improve on the work later. But you will have functional software sooner.
• It's important to take time to review and discuss decisions as a cross-functional team to understand what you did, and what you can do better next time.

So it seems like it's best add to a person to a team who has a skill that the team might be weak in, but who enjoy working on the whole application when the team thinks it makes sense. Self-organizing, cross-functional teams are a central part of agile practice, and the combination is important. Just having cross functional people doesn't work; they need to work as part of a team working towards a common goal.

Tips, Habits, Customs and Agility

I was listening to a Planet Money Podcast about tipping recently. According to the story, the custom of tipping has persisted even though the reasons that the practice was established no longer apply. According to the Planet Money story both waiters and customers think that tipping is useful, evidence to the contrary aside. The discussion led me to think about practices some teams do in the name of following a process.

Habits and routines are useful because they free you to focus on the important tasks.  Rituals and processes take a somewhat irrelevant decisions out of your hands, and conventions make it easier for others to understand code and other artifacts.  And when you are starting a new approach to work, following the rules by rote can help you understand the method. But circumstances change, and when the reason for the ritual has changed, there are a few possibilities:

• The practice is still useful, for reasons you didn't anticipate when you started it.
• The practice adds less value, but it doesn't add any overhead so there is no harm in continuing.
• The practice leads the team to spend energy addressing a problem that does not exist any more and causes waste.

To avoid instances of the last case that take up too much of you time, it is important to periodically reflect on why you are doing what you are doing, and it it still makes sense in your environment.  As your team adopts new tools, new practices, take time to think about whether what you are doing still makes sense. Periodic retrospectives are one way to capture this, so it's important to set aside time to review how you work. (And even to set aside time to review how you do retrospectives!)

Lots of teams (and individual) follow process  steps with good intentions, yet they end up causing unnecessary overhead. For example coding conventions that made perfect sense in the days of fixed length variable names, and text editors that add overhead when you have refactoring IDEs and follow clear naming conventions.

The podcast also reminded me of  one of of my favorite Gerry Weinberg quotes (which I referenced in Software Configuration Management Patterns):

 Survival Rules are not stupid; they are simply over-generalizations or rules we once needed for survival. We don't don't to simply throw them away. Survival rules can be transformed into less powerful forms so that we ca still use their wisdom without becoming incongruent

 (from Quality Software Management: First-Order Measurement)

Traditions and habits have their place. But if you are doing something simply out of habit you can benefit from acknowledging that fact.

Better: More Parallels between Medicine and Agile Software

I recently finished reading the book Better: A Surgeon's Notes on Performance by Atul Gawande. Having read The Checklist Manifesto: How to Get Things Right  (which I commented on earlier) I expected to learn not just about medical practice, but also about parallels between medicine and software development. Much of what Gawande says about performance in medical environments has can be said to apply to agile software teams, in particular, the need to focus on core practices, the value of retrospectives, and the value of generalists.

A discussion of how hand washing, a simple technique that is vital to infection control but that also requires culture change to implement with the discipline required to be effective, brought to mind how the challenges teams have being agile often center on the challenges of having teams begin to apply basic practices, without customization.

In the discussions of Polio vaccination and malpractice were excellent non-software examples of how we can benefit from retrospective practice, especially the prime directive, which reminds us that to improve we can't focus on blame, but rather on how decisions we made and how to make them better. A discussion of medical practice in war zones provided excellent anecdotes to relate when someone says that they can't gather data to measure performance and thus improve;  Gawande relates how combat doctors, those with the best excuses to not have time to do "paperwork" somehow find time to enter the data needed to track and improve the care of soldiers, while gathering data in hospitals seems to be hard.

In a profession where specialization is valued, Gawande discusses time spent in India, where understaffed hospitals mean that surgeons can't afford to specialize and yet get do well by collaboration, cross-training, and discussion; in short, how "generalizing specialists" help to eliminate roadblocks and help get the most value from a team.

Like all metaphors and comparisons, there are gaps. Doctors and Software Developers do different things, and work under different constraints. But by focusing on the differences you miss an opportunity to learn from those around you. This, to me, is the key lesson in Better.