The first edition of “Planning Extreme Programming” by Kent Beck and Martin Fowler was published about 18 years (that long) ago, and already it says so much about how planning for software projects can be done well. It talks about programmers and customers, their fears and frustrations, their rights and responsibilities, and putting all those knowledge into a planning style that can work for development teams. It doesn’t have to be labeled XP, but it does need to help people be focused, confident, and hopeful.
Here are some noteworthy lines from the book:
- Planning is not about predicting the future. When you make a plan for developing a piece of software, development is not going to go like that. Not ever. Your customers wouldn’t even be happy if it did, because by the time the software gets there, the customers don’t want what was planned; they want something different.
- We plan to ensure that we are always doing the most important thing left to do, to coordinate effectively with other people, and to respond quickly to unexpected events.
- If you know you have a tight deadline, but you make a plan and the plans says you can make the deadline, then you’ll start on your first task with a sense of urgency but still working as well as possible. After all, you have enough time. This is exactly the behavior that is most likely to cause the plan to come true. Panic leads to fatigue, defects, and communication breakdowns.
- Any software planning technique must try to create visibility, so everyone involved in the project can really see how far along a project is. This means that you need clear milestones, ones that cannot be fudged, and clearly represent progress. Milestones must also be things that everyone involved in the project, including the customer, can understand and learn to trust.
- We need a planning style that
- Preserves the programmer’s confidence that the plan is possible
- Preserves the customer’s confidence that they are getting as much as they can
- Costs as little to execute as possible (because we’ll be planning often, but nobody pays for plans; they pay for results)
- If we are going to develop well, we must create a culture that makes it possible for programmers and customers to acknowledge their fears and accept their rights and responsibilities. Without such guarantees, we cannot be courageous. We huddle in fear behind fortress walls, building them ever stronger, adding ever more weight to the development processes we have adopted. We continually add cannonades and battlements, documents and reviews, procedures and sign-offs, moats with crocodiles, torture chambers, and huge pots of boiling oil. But when our fears are acknowledged and our rights are accepted, then we can be courageous. We can set goals that are hard to reach and collaborate to make those goals. We can tear down the structures that we built out of fear and that impeded us. We will have the courage to do only what is necessary and no more, to spend our time on what’s important rather than on protecting ourselves.
- We use driving as a metaphor for developing software. Driving is not about pointing in one direction and holding to it; driving is about making lots of little course corrections. You don’t drive software development by getting your project pointed in the right direction (The Plan). You drive software development by seeing that you are drifting a little this way and steering a little that way. This way, that way, as long as you develop the software.
- When you don’t have enough time you are out of luck. You can’t make more time. Not having enough time is a position of helplessness. And hopelessness breeds frustration, mistakes, burnout, and failure. Having too much to do, however, is a situation we all know. When you have too much to do you can prioritize and not do some things, reduce the size of some of the things you do, ask someone else to do some things. Having too much to do breeds hope. We may not like being there, but at least we know what to do.
- Focusing on one or two iterations means that the programmers clearly need to know that stories are in the iteration they are currently working on. It’s also useful to know what’s in the next iteration. Beyond that the iteration allocation is not so useful. The real decider for how far in advance you should plan is the cost of keeping the plan up-to-date versus the benefit you get when you know that plans are inherently unstable. You have to honestly asses the value compared to the volatility of the plans.
- Writing the stories is not the point. Communicating is the point. We’ve seen too many requirements documents that are written down but don’t involve communication.
- We want to get a release to the customer as soon as possible. We want this release to be as valuable to the customer as possible. That way the customer will like us and keep feeding us cookies. So we give her the things she wants most. That way we can release quickly and the customer feels the benefit. Should everything go to pot at the end of the schedule, it’s okay, because the stories at risk are less important than the stories we have already completed. Even if we can’t release quickly, the customer will be happier if we do the most valuable things first. It shows we are listening, and really trying to solve her problems. It also may prompt the customer to go for an earlier release once she sees that value of what appears.
- One of the worst things about software bugs is that they come with a strong element of blame (from the customer) and guilt (from the programmer). If only we’d tested more, if only you were competent programmers, there wouldn’t be these bugs. We’ve seen people screaming on news groups and managers banging on tables saying that no bugs are acceptable. All this emotion really screws up the process of dealing with bugs and hurts the key human relationships that are essential if software development is to work well.
- We assume that the programmers are trying to do the most professional job they can. As part of this they will go to great lengths to eliminate bugs. But nobody can eliminate all of them. The customer has to trust that the programmers are working hard to reduce bugs, and can monitor the testing process to see that they are doing as much as they should.
- For most software, however, we don’t actually want zero bugs. (Now there’s a statement that we guarantee will be used against us out of context.) Any defect, once it’s in there, takes time and effort to remove. That time and effort will take away from effort spent putting in features. So you have to decide which to do. Even when you know about a bug, someone has to decide whether you want to eliminate the bug or add another feature. Who decides? In our view it must be the customer. The customer has to make a business decision based on the cost of having the bug versus the value of having another feature – or the value of deploying now instead of waiting to reduce the bug count. (We would argue that this does not hold true for bugs that could be life-threatening. In that case we think the programmers have a duty to public safety that is far greater than their duty to the customer.) There are plenty of cases where the business decision is to have the feature instead.
- All the planning techniques in the world, can’t save you if you forget that software is built by human beings. In the end keep the human beings focused, happy, and motivated and they will deliver.
Do we think we can do that?
Is that a goal worth something for us to reach for, or are we satisfied with weekly, monthly, or yearly project releases?
If we do decide to release to live daily, is it going to take a lot of work?
For what reasons do we have to put in the effort for?
What changes should we have to make so we can push as early and as often as possible?
How does that affect our existing software development process?
Does our team have sufficient expertise to follow through?
Do sprints even matter in that case? What about daily stand ups and retrospectives?
Should we push to live our long-running projects? What happens to feature branches?
How much testing is enough for us to be comfortable with daily releases?
Do we still need as many test environments as we do before?
What happens to our testing when we don’t have plenty of time to manually check everything?
Are our customers supposed to be delighted if we release daily?
Will the team be more pleased with a presumably increased efficiency or are we happy where we are?
If we decide to forego a daily release schedule, where else do we want to focus our attention to?
There’s a lot I don’t know about being a kick-ass boss, or being a great manager. I’m pretty much still a work-in-progress in that area. Thankfully, Kim Scott’s “Radical Candor” points me to the questions I need to ask myself about it, and suggests steps I should consider taking in order to do better.
Some memorable lines from the book:
- Relationships don’t scale. But the relationships you have with the handful of people who report directly to you will have an enormous impact on the results your team achieves.
- You strengthen your relationships by learning the best ways to get, give, and encourage guidance; by putting the right people in the right roles on your team; and by achieving results collectively that you couldn’t dream of individually. When you fail to give people the guidance they need to succeed in their work, or put people into roles they don’t want or aren’t well-suited for, or push people to achieve results that are unrealistic, you erode trust.
- It turns out that when people trust you and believe you care about them, they are much more likely to 1) accept and act on your praise and criticism; 2) tell you what they really think about what you are doing well and, more importantly, not doing so well; 3) engage in this same behavior with one another, meaning less pushing the rock up the hill again and again; 4) embrace their role on the team; and 5) focus on getting results.
- We are all human beings, with human feelings, and, even at work, we need to be seen as such. When that doesn’t happen, when we feel we must repress who we really are to earn a living, we become alienated. That makes us hate going to work. To most bosses, being professional means: show up at work on time, do your job, don’t show feelings unless engaged in motivation or some such end-driven effort. The results is that nobody feels comfortable being who they really are at work.
- It’s about finding time for real conversations; about getting to know each other at a human level; about learning what’s important to people, about sharing with one another what makes us want to get out of bed in the morning and go to work – and what has the opposite effect.
- Challenging others and encouraging them to challenge you helps build trusting relationships because it shows 1) you care enough to point out both the things that aren’t going well and those that are and that 2) you are willing to admit when you’re wrong and that you are committed to fixing mistakes that you or otherwise have made. But challenging people directly takes real energy – not only from the people you’re challenging but from you as well – so do it only for things that really matter.
- If nobody is ever mad at you, you probably aren’t challenging your team enough. The key, as in any relationship, is how you handle the anger. When what you say hurts, acknowledge the other person’s pain. Don’t pretend it doesn’t hurt or say it shouldn’t hurt – just show that you care. Eliminate the phrase “don’t take it personally” from your vocabulary – it’s insulting. Instead, offer to help fix the problem. But don’t pretend it isn’t a problem just to try to make somebody feel better.
- If we have the data about what works, let’s look at the data, but if all we have are opinions, let’s use yours.
- What growth trajectory does each person on my team want to be on right now? or Have I given everybody opportunities that re in line with what they really want? or What growth trajectory do my direct reports believe they are on? Do I agree? And if I don’t, why don’t I? Sometimes people really want to grow and are capable of contributing more than they have allowed to; at other times, they simply want more money or recognition but don’t really want to change the way they work or contribute any more than they do already. As the boss, you’re the one who’s going to have to know your direct reports well enough to make these distinctions and then have some radically candid conversations when you see things differently.
- There’s nothing wrong with working hard to earn a pay check that supports the life you want to lead. That has plenty of meaning. Only about 5% of people have a real vocation in life, and they confuse the hell out of the rest of us. Your job is not to provide purpose but instead to get to know each of your direct reports well enough to understand how each one derives meaning from their work.
- You don’t want to be the absentee manager any more than you want to be a micro-manager. Instead, you want to be a partner – that is, you must take the time to help the people doing the best work overcome obstacles and make their good work even better. This is time-consuming because it requires that you know enough about the details of the person’s work to understand the nuances. It often requires you to help do the work, rather than just advising. It requires that you ask a lot of questions and challenge people – that you roll up your own sleeves.
- It won’t get better all by itself. So stop and ask yourself, how exactly, will it get better? What are you going to do differently? What will the person in question do differently? How might circumstances change? Even if things have gotten a little better, have they improved enough? If you don’t have a pretty precise answer to those questions, it probably won’t get better.
- If you never ask a single question about a person’s life, it’s hard to move up on the “care personally” axis. probably the most important thing you can do to build trust is to spend a little time alone with each of your direct reports on a regular basis. Holding regular 1:1s in which your direct report sets the agenda and you ask questions is a good way to begin building trust.
- The platinum rule says, figure out what makes the other person comfortable, and do that.
Today, here’s a new batch of compelling videos I’d like to share, for the curious:
- What is Shift Left Testing? (by Alan Richardson, about shifting left and its meaning, consultancy speak, testing at all points of the software development process, and finding ways to improve our testing without resorting to consultancy speak)
- How We Work #4: Known and Unknowns (by Basecamp, on creative work, known and unknown tasks and why it’s more important to track them rather than estimates, and using the hill chart)
- A Better Technical Interview: 2018 (by Josh Greenwood, representing Test Double, about the binary hiring process existing in most industries, setting job and interview expectations, thinking about making the life of candidates better including the ones we don’t end up hiring, saying ‘Not Yet’ and providing constructive feedback, and the Bridge Agent)
- How Open Source has Made Me and the Stuff I Make Better (by Kent Dodds, on open source software, remote work, improving technical and interpersonal skills, documentation, and asking better questions and learning from other people)
- Office Politics for the Thin-Skinned Developer (by Justin Searls, about politics in the workplace, crazy organizational growth, building awareness, targeted empathy, being in the same page, how to make a difference, and allowing others to fail)
I’m not inherently a person who likes to travel a lot, although I have been to a few places within the country in recent years because there were specific experiences I’ve never done before and wanted to try, like going on an airplane ride, visiting an interesting museum, or learning how to surf. I enjoyed those experiences, even though those were mostly brief getaways with friends. Rolf Potts, however, in his book titled “Vagabonding: An Uncommon Guide to the Art of Long-Term World Travel“, wants us to consider travelling in the long-term rather than living for hurried weekend trips and why.
Some favorite lines from the book:
- Travel isn’t just for changing what’s outside, it’s for reinventing what’s inside.
- For some reason, we see long-term travel to faraway lands as a recurring dream or an exotic temptation, but not something that applies to the here and now. Instead – out of our insane duty to fear, fashion, and monthly payments on things we don’t really need – we quarantine our travels to short, frenzied bursts. In this way, as we throw our wealth at an abstract notion called lifestyle, travel becomes just another accessory – a smooth-edged, encapsulated experience that we purchase the same way we buy clothing and furniture.
- The more we associate experience with cash value, the more we think that money is what we need to live. And the more we associate money with life, the more we convince ourselves that we’re too poor to buy our freedom.
- No combination of one-week or ten-day vacations will truly take you away from the life you lead at home. Vagabonding involves taking an extended time-out from your normal life – six weeks, four months, two years – travel the world on your own terms.
- Wanting to travel reflects a positive attitude. You want to see, to grow in experience, and presumably to become more whole as a human being. Vagabonding takes this a step further: it promotes the chances of sustaining and strengthening this positive attitude. As a vagabond, you begin to face your fears now and then instead of continuously sidestepping them in the name of convenience. You build an attitude that makes life more rewarding, which in turn makes it easier to keep doing it.
- Vagabonding is not like bulk shopping: the value of your travels does not hinge on how many stamps you have in your passport when you get home – and the slow, nuanced experience of a single country is always better than the hurried, superficial experience of forty countries.
- If there’s one key concept to remember amid the excitement of your first days on the road, it’s this: slow down. You must keep in mind that the whole point of long-term travel is having the time to move deliberately through the world. Vagabonding is about not merely re-allotting a portion of your life for travel but rediscovering the entire concept of time. At home, you’re conditioned to get to the point and get things done, to favor goals and efficiency over moment-by-moment distinction. On the road, you learn to improvise your days, take a second look at everything you see, and not obsess over your schedule.
- When you want to hurry something, that means you no longer care about it and want to get on to other things.
- Shortly after arriving at your initial destination, find a beachhead (be it an actual beach, an urban travelers’ ghetto, or an out-of-the-way town) and spend a few days relaxing ad acclimating yourself. Don’t strike off to hit all the sights or actualize all your travel fantasies from the get-go. Stay organized and interested, but don’t keep a things to do list. Watch and listen to your environment. Take pleasure in small details and differences. Look more and analyze less; take things as they come. Practice your flexibility and patience – and don’t decide in advance how long you’ll stay in one place or another.
- Don’t set limits on what you can or can’t do. Don’t set limits on what is or isn’t worthy of your time. Dare yourself to play games with your day: watch, wait, listen; allow things to happen. Wherever you are, be it the Vatican gift shop, a jungle village in Panama, or downtown Ouagadougou – keep aware of the tiniest tics and details that surround you. Anything that is remarked, even little flowers or leaves picked up off the ground and shown to a child, even a shoeshine or gravel pit, anything is potentially an attraction.
- The greater value is not in what you’ve seen and checked off the list, but in what you’ve learned deeply, the hard way.
- Once you have learned the basics, it becomes clear that having less work is easy. It’s filling the void with more life that is hard. Finding excitement, as it turns out, takes more thought than simple workaholism. But don’t fret. That’s where all the rewards are.
- What I find is that you can do almost anything or go almost anywhere, if you’re not in a hurry.
Recently, I was asked by the Human Capital Management team at work for a list of specific requirements for our scrum master role. I obliged, and at the top of my head wrote the following:
A scrum master is someone who –
- has great written and verbal communication skills
- understands the software development process, has experience working with product managers and programmers; preferably with customers too
- well-versed in the practice of software testing, enjoys exploring systems, thinking in various perspectives, and putting on different sorts of hats
- delights in shouldering a support role to the software development team
- is a self-starter, regularly updates himself/herself on what’s happening in the software development and testing industry
- someone who takes pleasure in a bit of scripting / programming is a plus (Webdriver, Watir, Cypress)
It’s not an extensive list, and I may have gotten some of the details wrong about what skills scrum masters are supposed to have based on the ideal definitions that’s out there in the web, but it’s alright. These are just the things I initially thought would suffice, in the context of what I and my team does and experience most days. Our testers are scrum masters too, and I’m proud that so far we’ve been able to make stuff work on our end.
Scrum masters in other places probably need a dissimilar set of requirements, because those are what allows their systems and processes to be effective, and that’s just fine.
For the past few weeks a number of programmers and myself have been tasked to build an initial prototype for a system rewrite project, handed to us by management. The merit of such project is a matter of discussion for another day; for now it is enough to say that the team has been given a difficult challenge, but at the same time excited about the lessons we knew we will gain from such an adventure.
There’s been several takeaways already in terms of technology know-how – dockerized applications, front-end development with Vue, repositories as application vendor dependency, microservices – just several of the things we’ve never done before.
But the great takeaway so far is the joy of literally working together, inside a room away from distractions, the team working on one task at a time, focused, taking turns writing application or test code on a single machine, continuously discussing options and experimenting until a problem is solved or until it is time to take a break. We instantly become aligned at what we want to achieve, we immediately help teammates move forward, we learn from each other’s skills and mistakes, we have fun. It’s a wonder why we’ve never done much of this before. Perhaps it’s because of working in cubicles. Perhaps it’s because there’s nearly not enough available rooms for such software development practice. Perhaps it’s because we’ve never heard anything about mob programming until recently.
I’m sure it won’t be everyday since we have remote work schedules, but I imagine the team spending more days working together like this from here on.