CMMI and Agile Blog

January 26, 2017

Is Upside Down the key to Moving Forward?

Last week I promised in my next video and blog to explain two specific ways projects often get into trouble and give you some simple tips related to Essence that can help mitigate the risk of both.  I have had a busy week and so I am putting off that video and blog, but it will still be coming soon!

This week I was interviewed by Bill Fox from Container13; Exploring Forward-Thinking Workplaces

https://container13.com/exploring-forward-thinking-workplaces/

Bill asked me some very interesting questions.  One thing I loved about this interview was that I was able to tie in a strategy that may seem “upside down” that is used by the coaches of the 2016 Little League Baseball World Series Champions from Endwell, NY– which is just 6 miles from where I live.

Check out the interview at

https://container13.com/is-upside-down-the-key/

I’ll try to get back on track soon!

January 8, 2017

Helping Coaches Everywhere

In my last blog I highlighted how far a team can go to solve challenges on their own when given just a few simple principles and a clear goal.  But this doesn’t mean that teams don’t need coaching, tips, best practices and a structure that provides clear limits to how the team operates. This leads to the subject of this blog.

Besides the upside down principles, I also highlight in Part I of the book 18 coaching tips.  If you are wondering if a book that highlights coaching tips is for you, it is.  I believe everyone should view themselves as a coach.  But a big challenge most organizations face is how to communicate the right coaching tips to project personnel who need it, right when they need it.

Let me step back here, and tell you a little about my background.

I’ve been involved in the software business for over 40 years—the first 20 years as a software practitioner and the last 20 years as an independent consultant/coach.  And during the second half of my career as a coach I have often been called in to assist troubled projects.  One observation I have made about these troubled projects is that most of them fall into one or more of a surprisingly small set of common patterns.  But more importantly, when that pattern is detected in a timely manner, it’s usually not that difficult to steer the project back onto a healthy course. I’ve discussed this in previous writings and blogs. But this leads to an interesting question:

Wouldn’t it be great if there was an easy way to capture these common patterns and share them with coaches everywhere so more coaches could steer their project teams when needed keeping them on course?

This was my motivator for including a Part II in my book where I have framed the highlighted principles and coaching tips that have emerged from my stories in Part I within a framework called Essence.

If you have not heard of Essence yet, you have probably heard of the foundation from which it evolved, which I also explain in Part II of the book. I also explain with examples in Part II how Essence provides a simple and easy-to-use medium to communicate any organization’s practices, tips, principles, and checklists even among non-technical stakeholders.  This last point about stakeholders is particularly important. 

This is because when you read Part I you will learn how stakeholder issues related to understanding and knowing how to carry out project responsibilities is a repeating theme throughout many of my stories.  But, more importantly, it’s a repeating theme within many of those troubled projects I referred to.   

In my next Youtube and blog I share a personal story specifically related to troubled projects that can help you understand a key value of Essence that took me quite a while to fully comprehend and appreciate.

December 27, 2016

What I’ve learned about software development and why it seems opposite to everything I was taught

In this blog I would like to share with you what motivated me to write my latest book, which is titled: “It’s All Upside Down”.  And I would like to tell you a little bit about what’s in Part I of the book.

So let’s start with the motivation. The title of this blog post is actually the subtitle of the book, which has a lot to do with my motivation for writing it.

In just the past few years I have made such drastic changes in how I help software development teams as a coach that it often appears what I am recommending to my clients is the complete opposite of many well established long held software engineering principles.

Now, in fact, my recommendations are not really in opposition to these principles at all—but they appear to be because what actually works in practice oftentimes isn’t what we think based on what many of us have been taught.

This was my major motivator for writing this book. I wanted to share true stories of what we have recently discovered really works for successful software development teams in practice.  There are eight stories in Part I of the book that all occurred in 2015 and 2016.

As I share the stories I also highlight 26—what I refer to as– “upside down” principles.  Now, the principles themselves are not really upside down.  What is really upside down is what many believe they need to do to effectively apply these principles.

To help communicate this message I focus each story around three key items:

  • First, the activities successful teams conduct in practice
  • Second, how much of these activities they conduct
  • And third, when they conduct each activity

 

I expect many readers will be surprised to learn how little time successful software development teams spend on certain activities that have traditionally received high focus, and–even  more importantly–  how much time is actually spent by successful teams on activities that traditionally have received little attention.

In closing this blog I would like to point out that I am certainly not the first person to have observed that what works best in practice often doesn’t match the theory.

It is also worth pointing out that this observation is not unique to software development. As the immortal New York Yankee baseball legend Yogi Berra once said:

“In theory there is no difference between theory and practice.  In practice there is.”

Now, in this blog I have referred to both principles and best practices.  In my next blog I will share with you why I focus more on principles in the book, and I will explain the power that principles can bring to a software development team’s performance.

Click to purchase the book

September 23, 2015

What’s the Difference Between a Practice and a Pattern and How do they each Improve Performance?

What’s in this Blog

In this blog I answer this question, as well as share status of work I am currently doing using the new Essence framework and patterns with two of my clients.

Blog

I recently started reading a great book titled The Pragmatic Programmer by Dave Thomas and Andrew Hunt and was pleasantly surprised to see a discussion on patterns. At a number of conferences I attended this year the subject of patterns and how they relate to practices was a common discussion topic.

So just what is the difference between a practice and a pattern and how do they each improve performance?

To help you understand let me step back and explain some activities I have been involved in over the past few months and how I am using Essence and patterns to help two of my clients improve their performance.

In June this year I talked at the Agile West Conference on the subject of patterns –http://conferences.techwell.com/archives/bscwest-2015/sme-profiles/paul-e-mcmahon.html, and I gave a workshop at Binghamton University –http://www.binghamton.edu/watson/industry/professional-development/programs/essence.html, on the topic of Essence, the new OMG standard (www.semat.org). I explained in my talk how Essence differs from other popular frameworks and how organizations can use it to help discover their own best patterns.   In August I gave a similar keynote address and workshop at Agile Africa.

As I explained in an interview at Agile Africa in August I have started referring to the patterns I am sharing as “thinking patterns” because they help practitioners make better decisions.

Thinking patterns differ from practices in that they set a specific context related to an organization’s current pain points. This is key to getting a discussion going in the organization related to where performance improvement is needed. Essence checklists can be used to help stimulate the discussion– not to tell the team what to do– but to get the team to decide what they should do to improve their performance given their specific situation.

What is great about Essence is that it is independent of any specific method so any team can use it. It doesn’t matter what practices an organization is currently using. It can help teams discover their own best patterns– and anti-patterns they need to avoid– leading to improved practices and better performance.

I have been involved in the software development business for forty-two years and I am only now finally discovering that we have spent a great deal of time defining processes (or practices) and the effort we have put into this activity has in too many cases failed to payback in real team performance improvement because they are not giving practitioners the real help they need to solve many of the challenges they face each day.

We still need processes, but processes help primarily when you are a beginner. Once you have moved past the beginner stage, practitioners often need more focused guidance related to the specific challenges they face each day.   This is where Essence and patterns can help.

As an example, I am finding that Essence is a really good framework to help organizations that want to become more agile to improve performance but are fearful that they might lose critical disciplined engineering processes as a result. This is a valid concern because a lot of companies when they jump to agile, miss essential fundamental engineering practices that they still need to conduct.

Essence provides the fundamental common ground that helps teams continually ask the right questions to ensure they are not losing essential engineering practices as they move their organization to a more effective way of working.

You may have heard the phrase; “With Essence your practices come alive,” and, “Essence practices are what practitioners really do, not what someone thinks they should do. “ I have been using Essence with one of my clients for the past few months to help them address specific pain points, and I am just now getting started using Essence with another client to help them rapidly improve their performance.

What I am learning is that patterns are a great vehicle to make your practices come alive in the eyes of practitioners because they provide concrete examples in how to think through real challenges leading to better decisions given your specific situation.

Over the coming months I am planning to share results from my two current projects and hopefully share successful case studies using Essence and thinking patterns together to improve performance.

January 19, 2015

New Video on Practical Ways Teams Can Use Essence and New Published Paper on Essence

A few weeks ago I shared a You Tube video providing highlights of Part I of a talk on Essence (44 minutes) I gave at Binghamton University in November, 2014 to a group of Computer Science students.  Highlights from Part II of that talk are now available where you can learn practical ways software teams can use Essence including games they can play to help assess where they are, how to conduct a root cause analysis to isolate a problem, and how to use patterns to improve their performance.

Highlights of the talk can be found at:

http://youtu.be/eosjm4NmFS8

The Part II highlights are 30 minutes in length and at the front of this video you can find where in the video the following 13 topics can be found:

  1. Assessment Poker
  2. Case Study Results Carnegie Mellon West
  3. Root Cause Analysis Example
  4. How Essence Differs from Lean Six Sigma
  5. Examples Using Activity Spaces
  6. Using Essence Competencies
  7. Another Example Using Activity Spaces
  8. Where Can Essence Help Most?
  9. Practice Slices and Patterns
  10.  Two types of information practitioners need
  11.  Examples of Patterns
  12.  A Closing Thought
  13.  How Students Are Using Essence at Binghamton University

I also have a new published paper on Essence titled,

A “Thinking Framework” to Power Software Development Team Performance, appearing in Crosstalk, The Journal of Defense Software Engineering in the Jan/Feb, 2015 edition.

http://www.crosstalkonline.org/storage/issue-archives/2015/201501/201501-McMahon.pdf

September 16, 2014

How do you keep your audience engaged when they don’t understand your language?

In August, 2014 (this year) I faced this challenge when speaking at the Latin American Software Engineering Symposium (LASES) in Barranquilla, Columbia. The night before the talk Dr. Carlos Zapata and I came up with an idea that not only worked, but also generated more questions than I ever imagined.

The title of my talk was: Essence: A Practitioner and Team Performance Perspective.

Take a look at this video to see how we pulled this off.  Below the link to the video find a sampling of the questions I received and how you can locate them quickly in the video.

Following is a sampling of the questions I received during the talk:

  1. Why are there only 7 alphas in the Essence kernel?
  2. How long will the SEMAT community work on Essence?
  3. Why don’t we see practices represented on the kernel?
  4. What is the vision for how companies will represent their practices using Essence?
  5. Will there be more disciplines added to Essence?
  6. How is the kernel changed, and what changes are coming?
  7. What criteria was used in selecting Essence checklists?
  8. What is your vision for the future of Essence?
  9. How would you sell Essence to companies?
  10. Where are we headed with practices on top of the Essence kernel?
  11. What is the definition of practice from the point of view of the Essence kernel?
  12. How will practices be captured in the Essence framework?

If you don’t have time to watch the entire video, jump to the end of the video where you will find, along with the 12 questions above, 30 more key questions/concrete examples listed and a reference to where you can find them quickly in the video (minutes and seconds into the video).

August 12, 2014

Three Great Book Titles and One That Missed the Mark: Part II

In last week’s blog I explained how I whittled down a long list of possible titles for my latest book to the following top four choices:

  • The Essence of Improvement
  • 15 Fundamentals for Higher Performance in Software Development  
  • Better Decisions Through Better Practice With Patterns
  • A Framework Vision for Higher Performance in Software Development 

Only one of the titles came close to meeting Peter Gordon’s rule of keeping the title to three words or less, and that was “The Essence of Improvement”.  I liked this title for one main reason besides its length.  I worked with Ivar Jacobson and our co-authors on the “The Essence of Software Engineering” book which focuses on the essentials—or common ground—that always exist across all software engineering efforts. 

I was originally thinking when I started to write my latest book that I was going to distill “the essentials that are common across all improvement efforts”, and so the title “The Essence of Improvement” seemed perfect.  But as the book evolved based on reviewer comments, discussions, and my personal analysis of past experiences working with multiple clients, it became clear that what I was talking about in this book was not common at all.  In fact, the 15 fundamentals– while they seem simple on the surface— are rarely achieved or thought about in most organizations today. 

There was also another problem with this title.   While I have found value in these fundamentals in my own personal improvement efforts as discussed in the book (e.g. golf), the vast majority of the examples I provide relate to software development.  So the simple “Essence of Improvement” title was reaching too far without sufficient research and proof into what it takes to improve and sustain improvements in other endeavors. 

If you read my two blogs over the past few weeks about Practice Slices and Patterns you should have a good idea why “Better Decisions Through Better Practice With Patterns” would have been a great title for this book.  The value of patterns is a key point that I highlight in this book, and I provide many pattern examples from my software development experiences both as a practitioner and as a coach. 

As I researched the pattern idea I became increasingly excited when I found numerous examples of similar experiences to my own in areas that had nothing to do with software development.  Examples include the idea of “thin slicing” discussed by Malcolm Gladwell in his book “Blink: The Power of Thinking Without Thinking”.  

A second example was found In Daniel Kahneman’s book, “Thinking Fast and Slow”.  In this book Kahneman explains how we can improve our quick–or intuitive– thinking by learning to recognize common situations rapidly.  This idea fits perfectly with my own experiences in software development, especially when rapid decisions need to be made by software practitioners on a high pressure project when a deadline is approaching. 

My favorite story that I convey in my book to explain the power of pattern recognition among athletes I borrowed from Jonah Lehrer’s book, “How We Decide.”   This is the story about Tom Brady, Quarterback for the New England Patriots football team in the National Football League.  In this story the reader learns how Tom prepares for football games which gives you an idea why he is such a great quarterback when the original scouting reports indicated he would never make it as a professional athlete. 

The analogies between what Tom does, and what I have found software practitioners can do to help prepare for typical situations they face each day– especially on a high pressure software development project—may well be the most compelling part of my book.  This also turned out for me to be the most rewarding part of my research and work in writing this book.  For that reason this title was my own personal favorite.  It was also Bill Fox’s favorite. 

A late entrant into the list of possible titles was “A Framework Vision for Higher Performance in Software Development”.   I liked this title because the framework vision, which I added just in the last few months of writing the book, turned out to be a major strength of the book based on comments from a number of my reviewers. It was exactly what was needed to help people understand why we need a framework like the Essence Framework.  Creating this framework vision also helped me personally– as one of the volunteers who developed the Essence Framework—to step back and see more clearly the bigger picture and the need for a framework such as Essence.    

The Essence framework is difficult for many people to understand when first exposed to it for a number of reasons.  One reason is because it is not immediately evident to many people why we need this new framework, or what problem it is solving that other software frameworks have not been able to solve.

By presenting the framework vision in the book using very simple non-technical language it helps the reader to first understand what is needed and why we need it, before we talk about a specific solution. 

 If you take the time to read my book– whether you like the Essence framework or not– I would love to hear your feedback on whether you agree or disagree that the software community needs a framework that fits the needs of the framework vision as I describe it in my book. 

But when the voting was done, the majority of my reviewers polled preferred the title that highlighted the 15 Fundamentals.  What is it that resonates with the idea of the 15 fundamentals that I highlight in this book?

First, these fundamentals are not what many might expect to see in a book about fundamentals and software development.  You will not see Requirements, Design, Programming, and Testing mentioned.  This is because this is not a book about the fundamentals of developing software. It is a book about the fundamentals of performing at a high level and sustaining that performance even under difficult and often adverse conditions–which are not at all uncommon in today’s fast paced and competitive world– when developing software.

Second, in this book I am calling for a culture change in how we implement process improvement today in organizations. A key point I raise is the fact that the speed of change we are all witnessing in today’s world requires that we step back and take a serious look at the process we are using to help our people get better at what they do. 

It is my contention that we need a far better way than what most organizations are doing today to empower our teams to take ownership for improving their own practices and their own personal performance. 

The 15 fundamentals I present in this book are my way of helping you think a little outside the box about how you might help your own organization get started down this path.  If you only take one or two ideas from my 15 fundamentals that can help you make even a few small changes in your organization that can start you down this road, then my ultimate goal in writing this book will have been achieved. 

Love it or hate it, I would love to hear what you think. 

August 7, 2014

Three Great Book Titles and One That Missed the Mark—Part I

When I asked Bill Fox, author of “5 Minutes to Process Improvement Success” (http://5minutespisuccess.com/ ) what he thought of my current working title of my latest book he didn’t answer.  He just said, “the title of your book is so important.  I think you should write down 100 possible titles, then pick the top ten, and then poll your reviewers to get their opinion.” 

When he first suggested this I thought there was no way I could actually come up with 100 different possible titles, but within a couple of hours I had actually created a list of 102.  The next part of whittling the list down to a top ten took longer.  In my case the problem was compounded by a number of complicating factors. 

First, Peter Gordon, my publisher from Addison-Wesley for my second and third book told me that a title ideally should be no more than three words.  When I looked at my list of 102, less than 10 were three words or less and none of them were my favorites. 

Second, Rachelle Gardner, a literary agent says, an author needs to do everything possible to come up with the best possible title because your title “sets the tone, … and hints at the style of the book… and draws the reader in….” (http://www.rachellegardner.com/about-rachelle/).

While Rachelle’s advice makes sense to me, what really complicated this issue was the fact that I had multiple goals in writing this book, and there was no way I could capture them all in a single title.  Furthermore some of my reviewers were highlighting strengths of the book that weren’t even part of my original goals in writing it.

One of the lessons I have learned from writing this book is one should never be surprised if you don’t end up exactly where you set out to go when writing a book.  It is as much a learning process as it is a way to  communicate your ideas.  This is especially the case when you have over twenty reviewers many willing to help guide your thinking.  This also means you need to be open to hearing that the most valuable parts of your book may be different from what you had originally planned.    

My original working title for the book when I started it four years ago, “How to Get Better at Anything” never even made the list of 102.  And the working title I had for most of the second and third year of the book’s development as I wrote and rewrote draft after draft listening intently to my reviewer’s feedback, “Performance Improvement Simplified” made the top twenty, but missed the top ten. 

The top three titles eventually were:

  • The Essence of Improvement
  • 15 Fundamentals for Higher Performance in Software Development  
  • Better Decisions Through Better Practice With Patterns

In the last few months of developing the book a fourth candidate title was also added:

  • A Framework Vision for Higher Performance in Software Development 

In next week’s blog I will share which three titles could have been a great choice and why one of them turned out to miss the mark given where the book ended up.  I will also share which title was my favorite, and why the eventual winner was selected. 

July 31, 2014

Viewing Software Practitioners as the Customer for Your Organizational Practices: More Motivation for Practice Slices and Patterns

In last week’s blog I talked about the idea of deploying process improvements through what I referred to as practice slices and patterns.  I motivated this idea through an analogy to how we build and deploy large complex systems.  Today I want to provide another analogy to further motivate this idea. 

Today, a popular approach to describe and communicate requirements for software systems is User Stories.   A form that is often used for these stories is: 

“As a… [insert here your user role],

I want to… [insert here what you want from the system],

so that… [insert here why you wants this]”. 

This form of capturing requirements is more appealing for many software practitioners today than the traditional “shall statement” approach, but why do you think this is the case?

One reason, I believe, is because it is more personal.  It helps to put the reader of the story in the shoes of the user of the system.   In this way it communicates more effectively the real goal of the system from the perspective of that user.   The “why you wants this” is important because when we understand why a user wants something it can open up other possibilities not envisioned by the user potentially leading to a more effective solution.  

With User Stories the intent is to keep the written information to a minimum using it to stimulate a conversation where the details are fleshed out over a number of iterations.  Part of the reason this works is because it is a way to circumvent the ambiguities of written language.  Many would argue today that this approach has helped us develop software that is more responsive to user needs and has helped us reduce waste by creating fewer features that are never used. 

Now, let’s jump to the problem of developing and deploying useful practices for software developers.  The analogy I want to employ now is for you to think about your software practitioners as the customers for your organizational practices.

How often do we hear software practitioners say:

“My company processes don’t really help me with the real problems I face each day.” 

This is a common refrain that I hear over and over in organizations that have developed processes the traditional way.  So why does this happen?   Could it be the same problem that we have traditionally had with satisfying customers of our software systems?  Wouldn’t it make sense to engage our software practitioners in a similar way asking them to share their personal stories so we better understand what they want and why they want it?  

This is what we are essentially doing when we deploy our practices using practice slices and patterns.  We are developing user stories first from the software practitioner perspective.   The user story allows us to abstract the essentials of common software practitioner scenarios.  It helps us place ourselves in the shoes of our practitioners by asking them as software practitioners what do you want, and why do you want it?

 When I have discussions with software practitioners in my client organizations I listen to their stories.  I listen for their biggest pain points that they need help with now and when I abstract out the essentials often I hear feedback such as:

“As a software practitioner, I want more guidance in what I should do when I don’t understand a requirement, so I can build the best software to meet my customer’s needs.”

And

“As a software practitioner, I want to know what to do when my testing is taking too long, and I am getting pressure from my manager to finish.”

And

“As a software practitioner, I want more help in how to  handle a design risk, when the alternative designs are going to extend the schedule and I am getting pressure to finish on time.” 

Also, keep in mind that the guidance we give in response to these stories is best if it doesn’t come from an outside consultant or an internal process engineer, but rather from the expert practitioners in your own organization.  This is why we involve the experts inside client organizations in the discussions eliciting the options proven to work in the past within each organization, and also eliciting the consequences of common poor decisions.  When we add in the options and consequences based on how our experts would handle these situations we now have the patterns to use in training the less experienced personnel in the organization.

Of course the three stories listed above are not all a software practitioner needs.  But if it makes sense to deliver software in small increments, listening to the customer’s feedback before delivering the next increment, shouldn’t we be doing the same when delivering our practice improvements to our software practitioners?  

In other words, start with the first three stories your practitioners communicate to you because those are mostly likely the ones that are hurting their performance, and your organization’s performance, the most.    

This is what we are doing when we deliver process improvements with practice slices and patterns.   We are implementing process improvement in an agile and iterative way, and we believe everyone should be implementing their improvements this way regardless of what your practices and methods look like – agile, waterfall, or something else. 

Once you get started down this path you should also be asking a few other question to your practitioners at regular intervals, such as:

  • Do the practice slices and patterns we have already deployed help you?
  • What are the next most important user stories that you need help with? 

If a pattern previously deployed isn’t helping, change it in the next iteration, or delete it. In this way you keep your practice aids lean and of high quality always helping your team. 

You can build a library of practice aids in this way, based on continual conversations with your practitioners, providing assurance that you are giving your practitioners what they need most.  In this way you are also transferring the most current knowledge of your experienced people to your less experienced people raising the overall competency of your people. 

For more tips and pattern examples refer to the book, “15 Fundamentals for Higher Performance in Software Development” available at: www.leanpub.com/15fundamentals or http://www.amazon.com/dp/099045083X/ref=cm_sw_su_dp

 

July 24, 2014

Practice Slices and Patterns: A Better Way to Deploy Process Improvements

Introduction

I want to share an idea with you that I believe is a better way to deploy process improvements that I call “Practice Slices and Patterns”.   Using practice slices and patterns is a way to engage your software practitioners in their own practice improvement which is a key goal of the SEMAT initiative, the Essence framework and today’s popular agile methods.

You can view a video about practice slices and patterns on YouTube:

First, people trump process. In other words a highly competent team will usually outperform a less competent team regardless of their practices and tools.  I don’t mean to bash practices and tools. My point is that ultimately the reason why most companies invest in process improvement is because they want to raise the competency of their people. They know in the long run that is what really counts.

So think about what it would mean to your competitive situation if you could raise the competency of your people faster than your competition.  Practice slices and patterns is one way to do this.

An analogy to aid understanding

Let me give an analogy to aid understanding.  We’ve known for a long time that the best way to build a complex software system is to break the problem down into small chunks and build and deploy those small chunks incrementally in small slices.   This approach works because it gets product into the hands of customers faster where those same customers can provide rapid feedback ensuring the development team is on the right track.

So if it makes sense to build and deploy our software systems incrementally in small slices, why wouldn’t it make sense to build and deploy the practices we want our practitioners to follow incrementally in small slices?

Motivation

I will explain more about what I mean by practice slices and patterns in a moment, but to help motivate the idea let me first step back and talk about what’s wrong with how many organizations deploy practices today.

Our practices should provide useful information related to how we want our people to operate.  But people face all kinds of different situations each day on the job and so our practices can’t possibly tell practitioners what to do in each situation.

In fact, this is the mistake many organizations have made in the past.  That is, they try to define in detail what they want their people to do in every possible situation.  This has led in some organizations to practices (or processes) that are so heavyweight that they are not usable by human beings.  Other organizations have gone to the other extreme making their practices (processes) so light as to become trivial and of minimal or no value.

What practitioners really need falls in between these two extremes.  Processes need to be light enough to be usable, but they also need to contain enough value to help practitioners where they need help the most.   An example is helping them find the answers to those tough questions that often need to be asked, and helping them with the trade-offs related to how much effort to put into certain tasks once they decide the task needs to be done.

This is where practice slices and patterns can help.

So just what is a “practice slice”?

A practice slice is one or more related scenarios that commonly happen in a particular context.

What is a pattern?

A pattern is an abstraction of a practice slice that removes inessential details to ease recollection, and adds the options and consequences that can help the practitioner with the tradeoffs.  Patterns can help your people make better decisions.

An example:

Basic Scenario:  You and your team are driving toward a deadline, and your requirements are not clear and you can’t get your customer to work with you.

Related Scenario: You are still driving toward that deadline, your requirements are still not clear, but now you also realize your design approach may have a risk and the only alternative design is going to extend the schedule.

Another related Scenario: You are closing in on that deadline, but now you realize you don’t have all the data you need to fully test before release?

A practice slice could be just the basic scenario, or it could be the basic scenario together with one or both related scenarios.

You might discuss these common situations with your team and come up with various options that have proven to work for you in past similar situations.

A pattern is then just a simple way to capture the essentials of these scenarios along with the options and consequences you know have worked in the past and can therefore help you make better decisions in the future when faced with similar situations.

The Best Patterns to Aid Decision-making and Performance

When developing patterns to aid team decision-making what is most important is to not pick just any common scenarios.  For many common situations that happen everyday practitioners don’t need extra help.   So you want to pick the ones where people most often fall into making poor decisions, so the pattern becomes useful during the actual execution of their daily job.

With a number of my clients we used practice slices and patterns and these ideas really work.

Proven to work

First, we examined the common scenarios their practitioners were facing each day on the job.  Then we prioritized them and selected a small set that had a tendency to hurt their performance the most.

We then abstracted out a small set of patterns that included the options and consequences of related decisions.  Then we trained the people in the patterns, and we gave them simple checklists they could take back to use as reminders on the job.

Raising the competency of your inexperienced people faster

The experienced people in your organization know how to handle most of these common scenarios, and some falsely believe that we can’t speed up the learning process for the inexperienced people.   Let me explain why this is not the case.

First, to help you understand, there are a couple of books I like to recommend related to this subject.   One is “How We Decide” by Jonah Lehrer, and the other is “Thinking Fast and Slow” by Dan Kahneman.  Both of these books help us understand that we all can get better at decision-making even when we need to make decisions fast under pressure.

Both of these books explain how we can improve our quick thinking by learning to recognize common situations (scenarios) faster, and by keeping aware of our options and consequences and which ones work best under which specific conditions.

What we are talking about with practice slices and patterns is a way to deploy process improvements faster and more effectively ensuring we are focusing on the most important areas where practitioners need help today.

Practice slices and patterns is a proven effective way to share what your experienced people already know with your less experienced people helping you raise the competency of your people faster.

If this idea makes sense to you, you can learn more about the approach and find examples of many patterns in the book, “15 Fundamentals for Higher Performance in Software Development”.

(www.leanpub.com/15fundamentals or http://www.amazon.com/dp/099045083X/ref=cm_sw_su_dp).

You can then use the examples in the book as they are, or use them to help identify your own scenarios that are hurting your team’s performance.  Then you can create your own patterns that make the most sense for your team.

I’d love to hear what you think about practice slices and patterns. Please share your feedback by commenting on this blog or through your favorite social media site.

You can also learn more about why I wrote the 15 Fundamentals book at:

 

Create a free website or blog at WordPress.com.