Skip to content

Feed aggregator

Make Stories Small When You Have "Wicked" Problems

Johanna Rothman - Fri, 11/21/2014 - 16:10

If you read my Three Alternatives to Making Smaller Stories, you noticed one thing. In each of these examples, the problem was in the teams’ ability to show progress and create interim steps. But, what about when you have a “wicked” problem, when you don’t know if you can create the answer?

If you are a project manager, you might be familiar with the idea of “wicked” problems from   from the book Wicked Problems, Righteous Solutions: A Catalog of Modern Engineering Paradigms. If you are a designer/architect/developer, you might be familiar with the term from Rebecca Wirfs-Brock’s book, Object Design: Roles, Responsibilities, and Collaborations.

You see problems like this in new product development, in research, and in design engineering. You see it when you have to do exploratory design, where no one has ever done something like this before.

Your problem requires innovation. Maybe your problem requires discussion with your customer or your fellow designers. You need consensus on what is a proper design.

When I taught agile to a group of analog chip designers, they created landing zones, where they kept making tradeoffs to fit the timebox they had for the entire project, to make sure they made the best possible design in the time they had available.

If you have a wicked problem, you have plenty of risks. What do you do with a risky project?

  1. Staff the project with the best people you can find. In the past, I have used a particular kind of “generalizing specialist,” the kind where the testers wrote code. The kind of developers who were also architects. These are not people you pick off the street. These are people who are—excuse me—awesome at their jobs. They are not interchangeable with other people. They have significant domain expertise in how to solve the problem. That means they understand how to write code and test.
  2. Help those generalizing specialists learn how to ask questions at frequent points in the project. In my inch-pebble article, I said that with a research project, you use questions to discover what you need to know. The key is to make those questions small enough, so you can show progress every few days or at least once week. Everyone in the project needs to build trust. You build trust by delivering. The project team builds trust by delivering answers, even if they don’t deliver working code.
  3. You always plan to replan. The question is how often? I like replanning often. If you subscribed to my Reflections newsletter (before the Pragmatic Manager), back in 1999, I wrote an article about wicked projects and how to manage the risks.
  4. Help the managers stop micromanaging. The job of a project manager is to remove obstacles for the team. The job of a manager is to support the team. Either of those manager-types might help the team by helping them generate new questions to ask each week. Neither has the job of asking “when will you be done with this?” See Adam Yuret’s article The Self-Abuse of Sprint Commitment.

Now, in return, the team solving this wicked problem owes the organization an update every week, or, at the most, every two weeks about what they are doing. That update needs to be a demo. If it’s not a demo, they need to show something. If they can’t in an agile project, I would want to know why.

Sometimes, they can’t show a demo. Why? Because they encountered a Big Hairy Problem.

Here’s an example. I suffer from vertigo due to loss of (at least) one semi-circular canal in my inner ear. My otoneurologist is one of the top guys in the world. He’s working on an implantable gyroscope. When I started seeing him four years ago, he said the device would be available in “five more years.”

Every year he said that. Finally, I couldn’t take it anymore. Two years ago, I said, “I’m a project manager. If you really want to make progress, start asking questions each week, not each year. You won’t like the fact that it will make your project look like it’s taking longer, but you’ll make more progress.” He admitted last year that he took my advice. He thinks they are down to four years and they are making more rapid progress.

I understand if a team learns that they don’t receive the answers they expect during a given week. What I want to see from a given week is some form of a deliverable: a demo, answers to a question or set of questions, or the fact that we learned something and we have generated more questions. If I, as a project manager/program manager, don’t see one of those three outcomes, I wonder if the team is running open loop.

I’m fine with any one of those three outcomes. They provide me value. We can decide what to do with any of those three outcomes. The team still has my trust. I can provide information to management, because we are still either delivering or learning. Either of those outcomes provides value. (Do you see how a demo, answers or more questions provides those outcomes? Sometimes, you even get production-quality code.)

Why do questions work? The questions work like tests. They help you see where you need to go. Because you, my readers, work in software, you can use code and tests to explore much more rapidly than my otoneurologist can. He has to develop a prototype, test in the lab and then work with animals, which makes everything take longer.

Even if you have hardware or mechanical devices or firmware, I bet you simulate first. You can ask the questions you need answers to each week. Then, you answer those questions.

Here are some projects I’ve worked on in the past like this:

  • Coding the inner loop of an FFT in microcode. I knew how to write the inner loop. I didn’t know if the other instructions I was also writing would make the inner loop faster or slower. (This was in 1979 or so.)
  • Lighting a printed circuit board for a machine vision inspection application. We had no idea how long it would take to find the right lighting. We had no idea what algorithm we would need. The lighting and algorithm were interdependent. (This was in 1984.)
  • With clients, I’ve coached teams working on firmware for a variety of applications. We knew the footprint the teams had to achieve and the dates that the organizations wanted to release. The teams had no idea if they were trying to push past the laws of physics. I helped the team generate questions each week to direct their efforts and see if they were stuck or making progress.
  • I used the same approach when I coached an enterprise architect for a very large IT organization. He represented a multi-thousand IT organization who wanted to revamp their entire architecture. I certainly don’t know architecture. I know how to make projects succeed and that’s what he needed. He used the questions to drive the projects.

The questions are like your tests. You take a scientific approach, asking yourself, “What questions do I need to answer this week?” You have a big question. You break that question down into smaller questions, one or two that you can answer (you hope) this week. You explore like crazy, using the people who can help you explore.

Exploratory design is tricky. You can make it agile, also. Don’t assume that the rest of your project can wait for your big breakthrough.  Use questions like your tests. Make progress every day.

I thank Rebecca Wirfs-Brock for her review of this post. Any remaining mistakes are mine.

Categories: Blogs

Wer ist eigentlich … Christoph Schmiedinger?

Scrum 4 You - Fri, 11/21/2014 - 08:21

Wie beschreibst du deinen Eltern/ Freunden deinen Arbeitsalltag bei Boris Gloger Consulting?
Viele verbinden mit Unternehmensberatung gut gekleidete Menschen, viel reisen, Überstunden en masse und schöne PowerPoint-Foliensätze. Im Wesentlichen stimmen einige dieser Aspekte, doch ich denke, dass es bei Boris Gloger Consulting doch ein wenig anders abläuft als in klassischen Beratungen. Meiner Familie und Freunden beschreibe ich meinen Arbeitsalltag immer als äußerst abwechslungsreich und herausfordernd. In der Hauptsache bin ich dazu da, anderen Menschen zu helfen, ein Produkt erfolgreicher zu entwickeln. Dazu verwende ich moderne Ansätze, die in vielen Organisationen Widerstand hervorrufen. Auch das ist ein Grund, warum ich mit an Bord bin. Neben den Projekten beschreibe ich meinen Freunden auch oft unsere differenzierte Arbeitsweise im Unternehmen selbst, etwa das Prinzip der Freiwilligkeit oder den Freiraum, der uns gegeben wird. Viele können das nicht nachvollziehen, weil sie nicht glauben können, dass eine Firma auf Basis dieser Prinzipien funktionieren kann.

Welchen Beruf wolltest du als Kind unbedingt ergreifen?
Als Kind wollte ich die klassischen Abenteuer-Berufe wie Feuerwehrmann oder Polizist ergreifen. Vielleicht war es aber auch die Hilfsbereitschaft, die mich dazu motivierte. Ich denke, dass ich mit meiner Berufswahl als Consultant diese Wünsche zumindest teilweise ausleben kann. Immerhin ist jedes Projekt immer wieder ein Abenteuer und ich liebe es, anderen Menschen zu zeigen, dass sie ihren Arbeitsalltag erleichtern und gleichzeitig erfolgreich sein können.

Wie siehst du deine bisherige Karriere? Viel Zufall oder überwiegend sorgfältige Planung?
Meine bisherige Karriere war überwiegend sorgfältig geplant. Ich habe bereits kurz vor meiner Matura (Abitur) den Entschluss gefasst, gleichzeitig einen verantwortungsvollen Job anzunehmen und mein Studium am Abend und Wochenende zu absolvieren. Fünf Jahre später bin ich froh, diesen Weg gewählt zu haben. Ich erkenne, wie viel Vorsprung ich durch meine zusätzlichen fünf Jahre Berufserfahrung nach meinem Studienabschluss hatte oder noch immer habe. Auch der Weg ins Consulting war geplant, da ich nach fünf Jahren im gleichen Unternehmen „raus“ in die weite Welt und „Neues“ kennenlernen wollte. Da mich agile Methoden bereits im letzten Unternehmen und auch während meines Studiums fasziniert haben, fiel die Wahl auf eine Unternehmensberatung mit Fokus auf agile Methoden und dann letztendlich auf Boris Gloger Consulting.


Gibt es ein bestimmtes Ritual in der Arbeitswoche, auf das du nicht verzichten könntest?
Interessanterweise habe ich bei dieser Frage als Erstes den Weekly Report, den wir dem Kunden zu Abschluss der Arbeitswoche schicken, im Kopf. Für mich ist dieses „Absenden“ der formale Abschluss der Projektwoche, mit dem ich meine Gedanken für das Projekt zum Wochenende ruhen lasse.

Unter all den Projekten, die du für Boris Gloger Consulting realisiert hast: Welches ist dein All-Time-Favourite?
Ich hatte erst ein Projekt bei Boris Gloger Consulting, das ich nun bereits seit mehr als sechs Monaten begleite. Ich denke aber, dass es durchaus einer der All-Time-Favourites werden könnte. Die große Herausforderung in dem Projekt waren die sehr unterschiedlichen Typen und Charaktere (Entwickler, SAP-Berater und Anwender), die erst zur Zusammenarbeit bewogen werden mussten. Es war großartig zu sehen, wie diese Entwicklung über den Lauf der Sprints zunehmend stattgefunden hat, so dass wir nach ein paar Monaten ein hoch performantes und gut zusammenarbeitendes Team geschaffen haben.

Drängende Kundenanfragen, E-Mail-Flut, Meeting-Marathon oder als Consultant jeden Tag an einem anderen Ort: Was ist dein Geheimrezept, um im hektischen Arbeitsalltag einen kühlen Kopf zu bewahren?
Bereits während meines Studiums, das ich neben meinem 40-Stunden-Job absolviert habe, habe ich mir angewöhnt, ein gutes Zeitmanagement zu betreiben. Dazu gehört neben einer ordentlich gepflegten To-Do-Liste auch die richtige Einstellung bzw. Herangehensweise. Ich versuche beispielsweise, alle Aufgaben so früh wie möglich abzuschließen, auch wenn die Deadline noch weit entfernt scheint. Das hilft mir, nicht zu sehr in Stress zu geraten, wenn diese Termine näher rücken. Zusammengefasst ist mein Rezept ein strukturiertes und zeitnahes Abarbeiten der zu erledigenden Themen.

Was ist für dich das Besondere an der Arbeit bei Boris Gloger Consulting?
Das Besondere ist einerseits das Projektumfeld, das äußerst spannend und herausfordernd ist. Immer wieder gibt es neue Projekte, in denen man am liebsten selber mitwirken will, weil das Problem oder die Situation einfach nur aufregend und spannend ist. Andererseits ist es die Atmosphäre im Unternehmen selbst. Alles basiert auf Freiwilligkeit und jeder kann sich einbringen, wo er seine eigenen Stärken sieht, solange es zum Unternehmensziel beiträgt. Dieser Freiraum ist anfangs ungewohnt, auch ich habe ein paar Wochen bis Monate gebraucht, um mich damit zurecht zu finden. Nun bin ich in vielen Themen engagiert und weiß, wo ich zu den Unternehmenszielen beitragen kann und das auch tue.

Gibt es eine Marotte, mit der du deine Kollegen regelmäßig auf die Palme bringst?
Da ich ein sehr ruhiger und friedliebender Mensch bin, sind es wenn nur kleine Marotten, wie beispielsweise meine Penibilität beim Review von Blogbeiträgen, in denen ich regelmäßig viel in der Wortwahl und Satzstellung ändere.

Was machst du in deiner Freizeit, um runterzukommen?
In meiner Freizeit verbringe ich viel Zeit mit meiner Lebensgefährtin, auch weil wir uns unter der Woche nicht bzw. äußerst selten sehen. Dabei stehen nicht außergewöhnliche Hobbies, sondern einfach die gemeinsame Zeit im Vordergrund. Das heißt, wir unternehmen total unterschiedliche Dinge und gerade das, worauf wir spontan Lust haben. Gerne komme ich aber auch allein „runter“, meist bei sportlichen Aktivitäten wie Rad fahren, Snowboarden oder Tauchen.

Scrum ist für mich…
die perfekte Methode, ein großes Vorhaben strukturiert und erfolgreich zum Ziel zu bringen und zugleich das Team zufriedener mit seiner Arbeit zu machen.

Categories: Blogs

New SAFe Principles and Revised LSE Big Picture

Agile Product Owner - Thu, 11/20/2014 - 23:21

Ok, so these are not the same topic, but they are related, so I thought one blog post could cover both … so …

We’ve been working on highlighting the principles behind SAFe and SAFe LSE. In future versions of both, we’ll have a tab for Principles on the left, including a nav to elaborations on each principle topic. Then, everything on the right will be practices. It will look something like this:

Screen Shot 2014-11-20 at 10.34.44 AM

Principles on the left. Practices on the right.

And perhaps a new meta-message, SAFe: Proven Practices from Immutable Principles.

In moving forward with this plan, we have established a draft set of Principles that will be applied to both versions of the framework. Our current WIP is here:

Screen Shot 2014-11-20 at 10.37.51 AM


And finally, to make sure that we both really get our money’s worth on this post, we have a new version of the LSE Big Picture. We aren’t stopping, but the pace of needed change is slowing down, so something a lot like this will be likely when we go live with the development site in January.

SAFE LSE BP Version many

SAFe LSE BP Version many


Categories: Blogs

Agile Quick Links #26

Notes from a Tool User - Mark Levison - Thu, 11/20/2014 - 21:15
Walt Disney curiosity quoteSome interesting reading for the Agile community:
Categories: Blogs

Organizational Design and Scrum

Scrum Expert - Thu, 11/20/2014 - 19:47
It’s very easy to become hierarchical and turn into a “bank” when software company is growing fast. Is there a way to avoid that? How to keep the focus on value creation? What about Value departments, not Functional departments? This presentation shares ideas what we can learn from Scrum and apply in organizational design. It shares hypothesis how a company could look like when everybody is focused on value creation. Video producer: Agile Latvia
Categories: Communities

Effective SCM Strategy for the Modern Enterprise

Danube - Thu, 11/20/2014 - 18:53

Recently CollabNet published the new whitepaper “Effective SCM Strategy for the Modern Enterprise“, which discusses issues that large companies face when working on their Software Delivery Lifecycle (SDLC) infrastructure. While understanding the requirements for repository management is a major part an enterprise IT strategy, when we talked to our customers and prospects, we noticed an interesting (and somewhat troublesome) trend in how people view SCM technology.

The key problem we were seeing is that software configuration management (SCM) is typically viewed as a merely technical issue. Business stakeholders often completely rely on the technical experts – users of the SCM – in their technology choice. The effect this creates is that SDLC as a whole does not pay enough attention to repository management. SCM is still thought of as a passive storage component that provides advanced version control  and  maintains history of what developers do with the code. It seemed that enterprises are losing sight for the business objective for SCM, so we published the paper to bring attention to the issues.

In our opinion, SCM is the core of SDLC and must be an intelligent and active infrastructure component. We think it is losing some of its “hotness” because it is no longer new, and many people think that only new things deserve proper attention. Well, we don’t think so. Your business applications are at the core of your business! If you spend so much time and money to write your code, then you should have the best SCM you can possibly afford.

Here are the key takeaways from the whitepaper:

The combination of these seemingly unrelated forces have created unique technology and business challenges for enterprise development organizations, including:

  • Growth of heterogeneous development environments and diversification of tools and processes

  • Need for secrecy impedes productivity and keeps stakeholders “in the dark”

  • Lack of automated compliance process increases risks of failed audits

The selection of an SCM technology is no longer merely a technical concern — it also has a major impact on business performance for organizations. However, when it comes to SCM technology direction, business stakeholders are rarely involved in the decision making process and it tends to be viewed as a tactical technical decision. In order to effectively address modern business challenges, SCM needs to become a strategic investment and play a role of an intelligent, active infrastructural component that improves the overall business performance and supports the goals of the organization.

A few key capabilities need to be evaluated as a part of the technology selection process:

  • Platform for integrating tools and processes in heterogeneous environments

  • Enterprise-ready administration and repository management

  • Predicable, effective audit process

  • Enforceable policies for intellectual property protection

  • Scalable, repeatable engineering processes

  • Organization-wide collaboration and code reuse

The key decision makers need start viewing the SCM investments in the context of technology choices and engineering best practices. Choosing an SCM technology that is ready for enterprise-scale deployments enables companies to achieve business agility without compromising on vital aspects of modern enterprise – manageability, scalability, compliance, and governance.

To learn more, read the full version of the whitepaper.

Follow CollabNet on Twitter and LinkedIn for more insights from our industry experts.

The post Effective SCM Strategy for the Modern Enterprise appeared first on

Categories: Companies

Rally: Our Dev Team Therapist

Rally Agile Blog - Thu, 11/20/2014 - 15:00

(Guest blogger and Rally user Erine Gray is the founder of Aunt Bertha, a software platform that makes it easy for people to find and apply for food, health, housing and education programs in the U.S.)

This is the story of how Aunt Bertha used Rally to get our team organized, communicate better, and start loving each other again. It was kind of like group therapy.

I’m only sort of joking. Our team doubled in size this year and there are now more people writing code. There’s more knowledge to be transferred. There’s more testing that needs to be done. There’s more that can go wrong. And things did go wrong; like any relationship, communication is key.

A Story

We had a new customer, Critical Mass, who wanted its users to be able to know if they qualified for a local cancer program using rules common in the cancer program space: current age, age at diagnosis, type of cancer, and current stage of cancer. We’ve always had ways of determining whether someone qualified for a program based on their income, but we didn’t have an easy way to extend this qualification to other eligibility rules, like these.

Ideally, a cancer survivor should be able to see—with the click of a button—whether or not they qualify for a cancer program, and why. They should be able to see something like this:

Since Aunt Bertha’s mission is to make program information accessible, we were excited to build this feature into our product. However, we had a problem.

Teamwork and Knowledge Transfer

When we first started using Rally at Aunt Bertha, we had two new programmers on the team. I was the lead developer, and I was terrible at knowledge transfer. Release after release would go by and features were not delivered on time. And it was my fault.

I had no doubt in my mind this feature should be built, and I knew how I was going to do it. I had a vision of what it was supposed to look like and a rough idea of how the algorithm would work, since I’d written most of the search code over the last three years.

The trouble was that building this feature was going to be a significant amount of work, and I didn’t have time to build it. Programmers are typically optimistic about how long it takes to do stuff, but we have short memories. It’s kind of like golf: we only remember those great drives that lay up perfectly on the fairway; we don’t remember the time we spent digging through the weeds to find our ball (or the late nights spent debugging only to find out we put a semicolon in the wrong place.)

Aunt Bertha was also in a growth phase. I didn’t need to be the lead programmer anymore. I had to delegate, but I was afraid because I knew that this feature would touch hundreds of lines of code that only I understood.

Enter Rally

Around this time our product manager, Ruby, started implementing Rally for our software development process. Prior to Rally, we had used Github as a code repository and for issue tracking. It was a nice, lightweight way of keeping track of issues and milestones, but now we had more developers and staying organized was a real challenge. We needed more rigor and structure.

I didn’t know much about agile software development. Ruby implemented a bi-weekly sprint planning meeting, and gave us all homework. Our job was to look at all of our stories, and break them down into digestible tasks.

I took the Critical Mass eligibility rule story and began to break it down. In the past I would typically jump into a feature, only to discover later just how complex it was. Breaking down a feature into stories and tasks really forced me to think about the problem in small chunks. That was when the light bulb went off in my head: I could indeed delegate some of these tasks to our new developers. I didn’t have to be the one to do it all; I just had to coach them along.

I’m happy to report we built a pretty amazing feature that’s making it easier for cancer survivors to navigate the myriad programs out there. Our developers can now dig into the most complex code, and I can now concentrate on getting new customers and setting the longer-term vision for the product.

Rally helped us communicate better, and set deadlines that we could actually make. Rally helped us understand that big problems are nothing but a series of small problems.

Making It Fun

One of my favorite views in Rally is the Story Estimation screen.

After we’ve developed our stories and added the requisite tasks, our next step is to estimate about how long a story (or feature) will take to build. This screen allows you to easily drop in a story by the estimated size. We size ours based on the size of our dogs (we’re a dog friendly office.)

A small story is a “Cinco.” A “Rosie” (that’s my dog) is a medium-sized story. A “Beowolf” (Chris’ dog) is a big story.

Cinco, Rosie, and Beowolf represent small, medium, and large story sizes

It may seem silly to estimate your workload this way, but the truth is that sizing is relative. What matters is how many Beowolfs, Rosies, or Cincos you can accomplish in a two-week sprint.

Why We Chose Rally

We considered plenty of options: we could have just stayed with Github, and we looked at Rally competitors. But we ended up going with Rally for a couple of reasons. One reason was that Rally offers its products at a discount for fellow B Corporations (Aunt Bertha has been a B Corporation since 2011.) The primary reason, however, was an encounter I had with Rally’s founder, Ryan Martens.

Ryan was a mentor at Boulder’s Unreasonable Institute, and when Aunt Bertha went through the 2012 Unreasonable Institute in Boulder, I had a chance to interact with Ryan. During that summer the team would spend most evenings with mentors: getting our questions answered, hearing about their experiences, or just sharing stories. I distinctly remember one of Ryan’s comments on business and ethics: the passion of his delivery and his desire for our success made me a fan immediately. Simply put, he seemed like a guy I wanted to be like, someday. And Rally is a company we want to be like someday.

Erine Gray
Categories: Companies

Avoid Failure to Launch: Kick-Start Your Next Initiative

Agile Management Blog - VersionOne - Thu, 11/20/2014 - 14:43

Guest post from two Davisbase consultants:  Adam Mattis and Leslie Morse

The Challenge

It’s a great day:  you wake up, the sun is shining, there is no traffic on the way to work, and when you get to the office… there it is. A shiny, new, fully sanctioned project. It’s GO TIME!

Easy there, killer. Before you dive in head first, let’s take a step back and get our proverbial ducks in a row.

All too often with agile-run initiatives or projects, we skip the foundational efforts that set the team up for success. In business environments where teams are constantly challenged to do more, faster, and with less, these foundational efforts are often overlooked. However, this quick-to-launch mentality ends up costing us much more, further on down the line.

What are these foundational efforts that we speak of? Let’s take a step back to bootcamp and remember the importance of:

  • Product Vision
  • Product Roadmap
  • User Roles
  • Initial Backlog Population
  • The Architectural and UX Runway

Three Preconditions for Starting Work

No one embarks on a new effort, initiative, project, or body of work with the intent to fail. However, agile development is often used as an excuse to make it up as you go along. Let’s frame up the goal of foundational work for agile workstreams by creating a user story.

user story table


1.  Business Readiness:  The degree to which business stakeholders are in alignment on what the vision is, who it is intended to benefit, and how much money should be investing in realizing the value.

2.  Architectural Readiness:  Ensuring that key IT stakeholders understand the vision and target scope for the effort as well as the definition of a high-level architectural approach to delivering value.

3.  Team Readiness:  Critical collaboration activities and workshops necessary to prepare the team for an incremental delivery cadence.


The business defines the ‘what’ for an agile team; therefore, readiness on behalf of the business is of paramount importance before engaging the technology group. But what does business readiness look like?

Business Case: Defining the Need

The business case provides justification for funding a new initiative. Depending on your organization, this could be something as simple as an elevator pitch, or a much more detailed document outlining market opportunities, value propositions, return structures, etc.

Regardless of the level of detailed that is needed, having a clearly documented business case helps build a shared understanding of value among executives, sponsors, and key stakeholders. Continued support from these individuals is as key to the product launch as is the technical solution.  See Figure 1 for an example of the Elevator Pitch Structure.

FIGURE 1: Elevator Pitch Structure

figure 1

Product Vision

With the business case crafted, the next task is to develop a cornerstone for the team to focus on. This cornerstone, or product vision, serves as the high-level focus from which every epic, every feature, and every user story is created. All work done by the agile team should be focused on satisfying the product vision.

The vision should be comprised of the product name, a value statement, and a few key features that differentiate the product. The vision may also outline some basic technical requirements such as OS compatibility or platform such as “web-based.”

FIGURE 2 – Design the Box

figure 2


While it is important for the product owner and key stakeholders to understand and align on the vision when preparing to kick-start the initiative, keep in mind that it will be necessary to have a vision workshop with the cross-functional agile team in order to ensure a shared understanding of the product they are building. Once created, the product vision should be posted in a common team area to serve as an information radiator. The vision will help keep the team focused throughout the work cycle.

Product Roadmap

The product roadmap helps link the product vision to the work which agile teams do every day. The roadmap is not intended to be a commitment or project plan, but simply a guide that the agile team uses to plan their work during release planning sessions.

Without a roadmap, teams are left without a clear strategic vision. It is a common misconception that agile teams do not strategize. The reality is that agile teams are highly strategic and nimble enough to shift focus with rapidly changing market conditions.

FIGURE 3 – Product Roadmap



The roadmap focuses on high-level themes, epics, or features – and, like the backlog, remains fluid throughout the course of the initiative. To be effective, the artifact should be highly visible and referred to often. As market conditions and priorities change, so should the roadmap and other downstream artifacts. Again, aligning on the roadmap before engaging the agile team is critical in order to avoid swirl and confusion when getting the team started. It is important to ensure that business stakeholders understand that the roadmap will most certainly evolve as the team begins work.

User Roles

With the ‘what’ defined in the business case, product vision, and product roadmap, it is now time to consider the ‘who.’ The definition of user roles seems like a fairly straightforward task, but once the discussion begins, teams are often surprised at how difficult the task can be.

Consider Facebook. On first thought it may seem simple: New User, Existing User, Administrator. Not so fast. Really think about all of the different interactions that take place on Facebook.

New User Existing User Business User Group Administrator Advertiser Photo Poster Marketplace User Under 13

And that’s not even scratching the surface!

Now consider any system within your organization and imagine how challenging it would be to identify all of the different paths and user types within the system. Consider the importance of evaluating the individual needs of each of these users in creating a solution.

Remember, one of the key benefits of an agile culture is the delivery of high-quality, customer-focused software. If the team is not sure who they are solutioning for, it is likely that the product will not sufficiently satisfy the needs of anyone.

Baseline User Stories & The Backlog

With the product and users now defined, it is time to elicit basic needs from our business partners. Remember, the business product owner (BPO) is the tip-of-the-spear for all things business. The BPO serves as the single voice for the customer, product management, sales, marketing, legal, finance, and all of the other organizations that make up the business function. The BPO and supporting team need to elicit baseline user stories from each of these groups and place them on the backlog for prioritization.

As the program progresses, the BPO will be accountable for making sure any inputs from the business team are ready for the agile  team at the appropriate time. A few examples of these items may include legally approved verbiage, approved graphics from the marketing team, and any special promotional offers from the sales team. The BPO, with full control over the prioritization of the backlog, must maintain awareness of upcoming user stories and their dependency of these inputs.


Now that we understand the ‘what,’ it is time to engage the technology group! HOLD ON… let’s tap those brakes! You’re only partially right. With the ‘what’ defined, we still have not begun to explore the solution. To begin framing up the ‘how,’ we need to engage the solutions architect.

Developing Shared Understanding

The solutions architect is in a unique position to begin bridging the gap between business need and technology execution. This individual has a broad view of all technology groups, infrastructure types, and data locations. In bringing the architect in early, the business will be able to get an accurate gauge of the technical feasibility of their ask, as well as the level of effort involved to deliver.

Identify IT Impacts

Once the feasibility study is complete, the solutions architect will start to map out the solution. This sketch will include the identification of new infrastructure, data flow mapping, and systems impacts. With this analysis complete, leaders can determine the right skill sets and organizational units that need to be involved in forming the agile team(s) who will work on the initiative.


Let’s assume you’ve followed a good plan for initiating this new body of work. Your product owner is firing on all cylinders, business stakeholders are in alignment and engaged, the architects have a vision for the solution needed to deliver value, and the cross-functional set of agile team members are locked and loaded.  Please, please, please — don’t make the assumption that those folks are clairvoyant and have a shared understanding of what the organization is looking to achieve!

Agile teams need to practice the full Five Levels of Agile Planning [See Figure 4]. It doesn’t mean the product owner and business stakeholders do Levels 1-3 and the team only engages in Levels 4-5.  The entire agile team plus key stakeholders need to collaborate in order to prepare for the first sprint planning event. Highly effective agile teams engage in Levels 1-3 of planning during a timeboxed period often called Sprint Zero. When well-facilitated, it could take only a week, but spending more than four weeks on these activities would likely lead to analysis paralysis. Key preconditions, activities, and outcomes of Sprint Zero are outlined in Figure 5.

FIGURE 4 – Five Levels of Agile Planning

figure 4


FIGURE 5 – Sprint Zero Summary

figure 5

Start Small & Improve Incrementally

Feeling overwhelmed?  If you’ve got a gap in your pre-planning processes or you’re currently feeling the pain associated with a lack of readiness in one of these three areas, consider one of these three techniques in order to improve. After that, make a backlog of all of the opportunities to improve your pre-planning processes, prioritize the list, and affect change incrementally over time.

1.  The Stakeholder Engagement Cadence

Product owners are intended to be the single source of truth around ‘what’ the agile team needs to deliver. In order to effectively do this, product owners need to fully understand their stakeholders and proactively engage them so that priorities and acceptance criteria are the best quality possible.Figure 6 outlines a framework for a stakeholder engagement cadence where stakeholders are classified into one of three groupings (Advisors, Supporters, or Sponsors) and then, based on the classification, are brought together once a month, twice a month, or weekly, based on their level of involvement in the workstream. To learn more about this technique, check out Proactive Stakeholder Engagement, a post on Davisbase’s #BecomingAgile blog.

FIGURE 6 – Stakeholder Engagement Cadence

figure 6


2.  The Backlog Refinement Cadence
It is essential that teams keep a product backlog deep enough to sustain incremental delivery. While pure Scrum doesn’t call for teams maintaining a runway of “ready” stories or a projection of the backlog items they will be completing in which sprint, in practice – it is a useful planning approach for keeping flow within the system and aligning the dependencies and coordination points that often exist within organizations of scale and complexity. Figure 7 outlines a backlog refinement approach that creates focus for agile teams and helps build the discipline to keep one sprint’s worth of stories in a “ready” state, as well as get the details and specifications just enough in advance of the sprint where they will commit to the work.  When paired with the Stakeholder Engagement Cadence, this information radiator can also be useful for creating context on topics for collaboration. To learn more about the cadence for backlog refinement, check out the #BecomingAgile Webinar recording Strategies for Grooming Your Backlog.

FIGURE 7 – Refinement Cadence

figure 7


3.  The Architectural Feedback Loop

In a similar manner to how feedback is generated often in software demonstrations, it is equally as important for feedback to be passed on the to architect. On an agile team, the solutions architect is working six to eight weeks ahead of the development team laying down the architectural runway. If the development team finds that some elements of the architecture are either missing or not working, it is important to pass that information along to the architect on a regular basis in order to correct the issues in upcoming iterations.

As a result of this feedback loop, many technical and architectural user stories will begin to appear on the backlog. These elements can appear either on a product backlog in the case of tactical changes, or as the Scaled Agile Framework® (SAFe™) tells us, enterprise changes may appear on the program backlog.

FIGURE 8 – Architectural Epics

figure 8

Image courtesy of, 2014



Please comment on this post and keep the conversation going. We’re constantly looking for better ways of doing things and get excited by helping others with #BecomingAgile. Learn more by checking out these additional resources:

About the Authors

Adam Mattis and Leslie Morse are colleagues at Davisbase Consulting and, combined, have over 29 years of experience delivering value with software and information systems.

Adam is a program manager by trade residing in Nashville, TN. He spends most of his time working with new teams adopting agile practices. You can reach him at or on Twitter @AgitatedAgilist.

Leslie is a business analyst by trade and resides in Columbia, SC. Most often she engages with organizations initiating agile transformations. You can reach her at or on Twitter @lesliejdotnet.

Categories: Companies

The Napoleon Corporal

Leading Agile - Mike Cottmeyer - Thu, 11/20/2014 - 14:08

In my previous post, Replacing Backlog Grooming, I wrote about leveraging a Product Owner (PO) Team instead of the “Scrum” team in Progression Workshops (backlog grooming).

To clarify, the members of the PO teams are mainly populated by a Product Owner (Product Lead) and facilitator (could be a Scrum Master), but from there we’ll include others like a development lead, a testing lead, and an architect. We use the team construct over a single person because we’re operating at scale, with multiple delivery teams.  The Leads and Architects are thinking bigger-picture strategy and are aware of external dependencies that need to be avoided or dealt with.  The goal is to progress work along, getting it ready for the delivery team.  To help bridge the knowledge gap with the delivery teams, there are members of the delivery teams who will attend the progression workshops, mostly to play the part of the Napoleon Corporal. (I call them that, not the client)

For those unfamiliar with the term Napoleon Corporal:

Napoleon recognized how vital it was to have an enlisted soldier in the planning process. During every Battle Plans briefing Napoleon would have a Corporal shine his boots knowing that the Corporal was listening. Once the General Staff finished the brief, Napoleon would look down at the Corporal and asked if he understood the plan. If the Corporal answered, Yes Sir! The General would have his Staff execute the plan. If the Corporal answered, No Sir! The General would have the General Staff rewrite the plan.

It doesn’t matter if you’re doing textbook Scrum or something at scale.  Your people still need a shared understanding. If not, you’re going to start seeing a lot of delays and a lot of rework.

When you have a Scrum or Kanban team, you’re not always getting “A” players. Sometimes it’s a real mixed bag.  To expand the military metaphor, sometime you don’t get a Corporal. Sometimes, you get yourself a Boot Private.  If work is outsourced, developers and testers won’t necessarily have domain experience. They might be great coders or testers but not experienced in financial, medical, or other verticals.  You need to get them to understand the mission and the mission is not necessarily to write and test code. The shared understanding is how to solve a problem for the customer.

Depending on the experience of the delivery team, the conversation (and backlog) may need to be simplified enough to be understood by someone junior to a Corporal.


The post The Napoleon Corporal appeared first on LeadingAgile.

Categories: Blogs

9th International PMI Poland Chapter Congress

Leading Answers - Mike Griffiths - Thu, 11/20/2014 - 05:31
I will be in Warsaw next week for the 9th International PMI Poland Chapter Congress – themed “Mission Impossible”. I am very much looking forward to it and sessions like the “Global Challenges of Mega Projects” by Virginia Greiman of... Mike Griffiths
Categories: Blogs

Great CrowdChat with John Furrier and Kartik Raghavan

Danube - Thu, 11/20/2014 - 00:10

John Furrier, founder of CrowdChat, Kartik Raghavan and I held a 1 hour session on CrowdChat earlier today. Interesting activity stream format integrated into LinkedIn, Twitter, etc. Click below on the #EnterpriseAgility link to see the conversation.

The post Great CrowdChat with John Furrier and Kartik Raghavan appeared first on

Categories: Companies

Three Alternatives for Making Smaller Stories

Johanna Rothman - Wed, 11/19/2014 - 20:02

When I was in Israel a couple of weeks ago teaching workshops, one of the big problems people had was large stories. Why was this a problem? If your stories are large, you can’t show progress, and more importantly, you can’t change.

For me, the point of agile is the transparency—hey, look at what we’ve done!—and the ability to change. You can change the items in the backlog for the next iteration if you are working in iterations. You can change the project portfolio. You can change the features. But, you can’t change anything if you continue to drag on and on and on for a give feature. You’re not transparent if you keep developing a feature. You become a black hole.

Managers start to ask, “What you guys doing? When will you be done? How much will this feature cost?” Do you see where you need to estimate more if the feature is large? Of course, the larger the feature, the more you need to estimate and the more difficult it is to estimate well.

Pawel Brodzinski said this quite well last year at the Agile conference, with his favorite estimation scale. Anything other than a size 1 was either too big or the team had no clue.

The reason Pawel and I and many other people like very small stories—size of 1—means that you deliver something every day or more often. You have transparency. You don’t invest a ton of work without getting feedback on the work.

The people I met a couple of weeks ago felt (and were) stuck. One guy was doing intricate SQL queries. He thought that there was no value until the entire query was done. Nope, that’s where he is incorrect. There is value in interim results. Why? How else would you debug the query? How else would you discover if you had the database set up correctly for product performance?

I suggested that every single atomic transaction was a valuable piece. That the way to build small stories was to separate this hairy SQL statement was at the atomic transaction. I bet there are other ways, but that was a good start. He got that aha look, so I am sure he will think of other ways.

Another guy was doing algorithm development. Now, I know one issue with algorithm development is you have to keep testing performance or reliability or something else when you do the development. Otherwise, you fall off the deep end. You have an algorithm tuned for one aspect of the system, but not another one. The way I’ve done this in the past is to support algorithm development with a variety of tests.

Testing Continuum from Manage It!This is the testing continuum from Manage It! Your Guide to Modern, Pragmatic Project Management. See the unit and component testing parts? If you do algorithm development, you need to test each piece of the algorithm—the inner loop, the next outer loop, repeat for each loop—with some sort of unit test, then component test, then as a feature. And, you can do system level testing for the algorithm itself.

Back when I tested machine vision systems, I was the system tester for an algorithm we wanted to go “faster.” I created the golden master tests and measured the performance. I gave my tests to the developers. Then, as they changed the inner loops, they created their own unit tests. (No, we were not smart enough to do test-driven development. You can be.) I helped create the component-level tests for the next-level-up tests. We could run each new potential algorithm against the golden master and see if the new algorithm was better or not.

I realize that you don’t have a product until everything works. This is like saying in math that you don’t have an answer until you have the finished the entire calculation. And, you are allowed—in fact, I encourage you—to show your interim work. How else can you know if you are making progress?

Another participant said that he was special. (Each and every one of you is special. Don’t you know that by now??) He was doing firmware development. I asked if he simulated the firmware before he downloaded to the device. “Of course!” he said. “So, simulate in smaller batches,” I suggested. He got that far-off look. You know that look, the one that says, “Why didn’t I think of that?”

He didn’t think of it because it requires changes to their simulator. He’s not an idiot. Their simulator is built for an entire system, not small batches. The simulator assumes waterfall, not agile. They have some technical debt there.

Here are the three ways, in case you weren’t clear:

  1. Use atomic transactions as a way to show value when you have a big honking transaction. Use tests for each atomic transaction to support your work and understand if you have the correct performance on each transaction.
  2. Break apart algorithm development, as in “show your work.” Support your algorithm development with tests, especially if you have loops.
  3. Simulate in small batches when you have hardware or firmware. Use tests to support your work.

You want to deliver value in your projects. Short stories allow you to do this. Long stories stop your momentum. The longer your project, and the more teams (if you work on a program), the more you need to keep your stories short. Try these alternatives.

Do you have other scenarios I haven’t discussed? Ask away in the comments.

This turned into a two-parter. Read Make Stories Small When You Have “Wicked” Problems.

Categories: Blogs

Make Concepts Explicit when Fixing Bugs

Dear Junior

To find implicit concepts and make them explicit is a very powerful way to improve code. But, sometimes it is hard to judge beforehand which concept is important enough to make explicit. We try to make good judgements, but sometimes we miss.

But, no reason to despair, we can take Time as our helpful aid. So, instead of everything perfect from start, we continuously perfect it whenever we find a reason. Two of the topmost reasons are either a bug appearing or further development of the code.

Let me for now fokus on the case of when a bug appears. If the code does not behave the way we intended it to do, then there is most often a place in the code that was to convoluted. In that convoluted state, subtle misunderstandings and simple mistakes could hide. The solution is to clarify the code until it is obvious whereof the mistake consists.

Things get clearer by examples, so let me clarify what I mean with a very minimal example, the story about a bug and its fix.
In real life, more or less a decade ago, I worked on a project where we did a batched import of records coming from an external source. The code looked roughly like this following in the class ImportCron.
public class ImportCron {
    private RecordImporter importer;    private Logger logger;
    void runImport()  {        List records = importer.listWaitingRecords();        logger.log(Level.INFO, "Importing records: " + records.size());        for ( Object rec : records) // imports each of the records in turn    …    }
Now, the import was run once a minute, but most of the time there where non records waiting.  Problem was the import log became filled with rows saying "Importing records: 0" so we had to grep out the non-zero lines each time we wanted to look at what was happening.
One of those days I got tired of this, fired up the editor, and wrapped the logging in an if statement to filter out all those zero-import writes.
    void runImport()  {        List records = importer.listWaitingRecords();        if (records.size() == 0)            logger.log(Level.INFO, "Importing records: " + records.size());        for ( Object rec : records) // imports each of the records in turn    …    }
A few days later we released during lunch, which was the best time for our users. The deploy went smooth, apps started up as expected, and soon it was time for the first import "tick".
Within a minute, import was run the first time, and the log line read:<timestamp> Importing records: 0While standing confused, a minute went by, and the log line read:<timestamp> Importing records: 0Another minute went by … and no log line.While firing up my editor to check the code, another minute went by and a third log line appeared:<timestamp> Importing records: 0A colleague of mine looking in the database calmly reported "We just imported three records".It only took me a split of a second to realise my mistake once I had the code in front of me.
    void runImport()  {        List records = importer.listWaitingRecords();        if (records.size() == 0)            logger.log(Level.INFO, "Importing records: " + records.size());        for ( Object rec : records) // imports each of the records in turn
Obviously my spine reflex for coding "check for zero" made me write the boolean expression the wrong way around. By the way, did you capture that mistake at first glance in the code on my first description? Confirmation bias is a nasty thing.
Now, I must say this kind of bugs are pretty uncommon, bugs that are typos or simply mispunching the keys. Most bugs in my opinion are rather that pieces of code subtly misunderstand each other.
Well there are at least two ways of fixing this code. The obvious, and fastest would be to quickly change "==" to "!=". However, humbled by the mistake I had done in the first place, I realised that that kind of hasty coding was what got me in the trouble in the first place.
One of my coding mantras since long have been "Code should mean something, not just do something". So, a better way out would be to make the code more meaning-ful. From Eric Evans I learned the phrase "Make implicit concepts explicit", which says the same thing in this context, but gives a better guiding direction forward.
I took to the challenge of fixing the bug by finding what implicit concepts had been missed, and making them explicit until it was blatantly obvious that the code was wrong. An added benefit would be to be able to make a test proving the code was wrong.
Extracting the boolean condition to a method of its own would force me to spell out the meaning of that piece of code.
    void runImport()  {        List records = importer.listWaitingRecords();        if (containsRecords(records))            logger.log(Level.INFO, "Importing records: " + records.size());        for ( Object rec : records) // imports each of the records in turn
    static boolean containsRecords(List records) {        return records.size() == 0;    }
Granted, this is more code than I started with - but I think the code is more "to the point" (phrased inspired by Rickard Öberg, another of the great programmers).
At least this made me able to write a test
    @Test    public void shouldConsiderEmptyListNotContainingRecords() {       Assert.assertFalse(ImportCron.containsRecords(Collections.EMPTY_LIST));    }
Well, at least this is what the test would look today - at the time JUnit looked slightly different.
Anyway, now I have a failing test. Claiming "the empty list does not contain records" is simply false - as proven by the test. We safely update the code to fix the bug.
    static boolean containsRecords(List records) {        return records.size() != 0;    }
Upon which the test switched to green as expected.
During this "refactor -> put under test -> fix" something interesting has happened. The concept "import list contains records" that hitherto had been implicitly represented by the technical "records.size() != 0" has now been made explicit and given a name "containsRecords".
It might be claimed that the main benefit in this example was derived from the drive to put code under test before making a change. Undeniably, that is a point, but I think it only tells half the tale. 
Simply putting things under test can be done in a myriad of ways, and I have seen several very technology-based efforts. I do not think those efforts have paid off handsomely. Mostly the code get cut along technical lines to push in tests in the gaps. But, the code does not get more comprehensible over time.
Focusing on "make implicit concepts explicit" have been a more productive course for me when working with code.
ps My team-mates did not force me to skip lunch to fix the bug. We went out together, and when we came back satisfied and rested, I sat down and fixed the code. We released the fix during lunch-time the day thereafter.

Categories: Blogs

My Journey From Waterfall to Agile (and Back Again)

Agile Management Blog - VersionOne - Wed, 11/19/2014 - 18:00

2007 – I had been working for several years as a traditional Project & Program Manager in the .com division of a Fortune 500 company. There was a constant cloud over my head. I didn’t really enjoy my work and had been soul searching for some time. I had been exploring and reading a lot about better ways to get work done, and came across this thing called Scrum. So I signed up for a CSM class, took it, was enlightened, and excitedly told my Director all about it. He gave me the green light to try it out on a small project or two, which I did. Somewhat surprisingly, these two projects were wildly successful. The productivity was more than triple the traditional Waterfall projects, the number of defects introduced was almost zero, our customers loved the quick feedback and the ability to change their minds whenever, and the buzz was that this was actually something fun to be a part of.

I was quickly named as the Lead Scrum Master, Coach, and Trainer for all things Agile, as I was the only one who knew anything about this stuff at the time. Others started inquiring about getting on one of these Scrum teams, how they could get training, how to get started, rooms, projectors, supplies, tools, etc.. I recruited some help, and we made incremental progress, getting more and more traction as we went along. It was very cool to be part of something like this. That’s not to say everything was perfect; it wasn’t. Our PMO still managed scope poorly, jamming too much work into a small pipe. Alignment at the Program and Portfolio levels wasn’t really there yet. Not everyone wanted to be part of a Scrum team, which we just kinda assumed they would. The culture held us back in certain areas. Not all the Management level was on the same page. We didn’t have any budget for external training, which is why they used me; I was ‘free’. But at the end of the day, enough folks were convinced this was something that was valuable that we expanded the initiative. 

2011 – I made the decision to leave the big company I had been working for to become an Agile Consultant at a small Midwest consulting firm in their Agile practice. It was an exciting time for me personally. I thought I’d be able to work with different clients, and help them do the same thing I did in my previous experiences. The opportunity for growth appeared to be huge. But as time went on, the work turned out to be intermittent at best, and we were struggling to gain any new business. Building up an Agile practice is not only hard work, but takes time, money and patience. The hard work part of the equation we had, but the rest was pretty limited. Once my 6 month Agile consulting engagement with our one and only customer was completed, I found myself in a bit of a pinch. We didn’t have another client for our Agile consulting services, and in order to stay on with the firm, I had to take whatever came my way. In this case it was a traditional Project Manager position with an insurance company. And yes, they utilized the Waterfall method of getting work done. The fact that I had a PMP after my name, and several years of good experience qualified me for the interview, which I passed. I needed the work, and so did my firm. The hourly rate was good, so I took it. I would soon come to find out what a nightmare I was in for.

It had been years since I last managed a Waterfall project, and those memories were less than fond. So I brushed up on my MS Project skills, dusted off the old PMBOK, reviewed the organization’s procedural guide for project management, and talked with some of the other PM’s at this new organization I’d be working with. None of them seemed too thrilled with their jobs, which was a red flag that I chose to consciously overlook. 

First week at the new gig was fine. Pleasantries, meeting the players, getting comfortable, reading procedural manuals, software downloaded, all that stuff you do the first few days. Then I got assigned as the Project Manager for three projects (one new and two in-flight). I was gung-ho and ready to show them what a great Project Manager they just hired. I was expected to manage the schedule, cost, and resources, which were all fixed. I would soon come to find out that this was not the case, but not in the way you might think. Managers would intermittently pull resources from in-flight projects to work on other higher priority projects or bug fixes, with the same expectations of us finishing the contracted scope and time deadlines for the projects. Of course, the beautifully constructed Gannt charts went down the toilet. I spent way too much time fighting for resources, adjusting the schedule, dealing with a multitude of dependencies, and discovering issues and impediments much too late. As each project team member was working on an average of 4 projects simultaneously, context switching was through the roof. The ‘throw it over the wall’ mentality was well established. There was a rush to get tasks completed on one project and move on to the next project. Back and forth, ad infinitum. Waste, frustration and technical debt; a vicious and unhealthy cycle that just dug deeper holes. I was also the person in between the customer and the team, and as such, was required to know everything, all the time, and communicate it all to everyone at least once a week in a high stakes status meeting where key team members would often either not show up at all, respond to emails on their phones if they did, and the internal customer would freak out about dates, scope, cost and risks. They didn’t want to hear about reality. Needless to say, those status meetings were hell. I was constantly on the hot seat, folks waited to be told what to do and when to do it, and when things fell down, the finger was squarely pointed at me, the Project Manager. This was not natural and it wasn’t working. The concept of a true Team was missing. It seemed that folks didn’t care about one another or the success or failure of the projects. I talked with a couple of my peers about their experiences, and while they recognized the same situation privately, they were not willing to call things out publicly. I presume this was based in fear. That cloud sitting over my head had returned. I knew the situation wasn’t sustainable, but I kept on for another couple of months anyway. It got to the point where my mental health was worth more than a paycheck, so I respectfully resigned. But just before I did, I had a chat with the Director of the Project Management Office. I talked with him about Scrum, and all the ways it could change things for the better, even in a regulated environment with hard completion dates. I explained it would be a big effort to transition to Agile. And that it wouldn’t happen overnight. That it would require investment. But over the long term, it was the smart thing to do and absolutely necessary to remain competitive. He listened, but wasn’t interested at the time. Too much critical stuff in flight to introduce such a change at the moment. Maybe later, he said. So that was it. At least I had tried. 

2012 – Happy ending to this story… I soon landed an Agile Coaching gig with a larger consulting firm on the east coast, shortly after the aforementioned Waterfall debacle. The client was open to new ideas and eager to transform their organization to Agile/Scrum/Lean/XP practices. We made a lot of headway by investing in people, teams, training, Agile Business and Technical Coaches, various tools, and open collaborative spaces. Upper and middle management created a culture of trust and transparency, and became true servant leaders to the teams. The business side began working closely with the technical side. No more throwing stuff over the wall and moving on to something else. We would succeed or fail as a team, not as individuals. Huge changes in a short period of time, yielding huge gains in productivity, efficiency, and quality. And most importantly, we gave the customer what they needed, not what they asked for 9 months ago. Customer involvement throughout was one of the key factors of this success.

During my tenure as an Agile Coach at the aforementioned consulting firm, we chose VersionOne as our ALM tool.  A VersionOne Coach and Product Consultant came in and helped us to configure the tool to fit the client’s organizational structure, showed us how to administer it, and trained a large group of IT and business folks on how to use it over the course of about two weeks. I got to know this VersionOne dude. We worked together on a few issues, and kept in touch. Soon there was an opening for an Agile Coach at VersionOne, and the rest, as they say, is history. I’ve been an Agile Coach & Product Consultant with VersionOne for about a year and a half now. The access and influence I’m afforded in helping organizations moving the Agile needle is amazing. It’d be hard to find this kind of opportunity with any other company. At the end of the day, I like helping people. And in my current role, it happens to be a perfect fit.

Categories: Companies

When Women Stopped Coding : Planet Money : NPR

Agile Complexification Inverter - Wed, 11/19/2014 - 15:24

What happened in the mid 1980s?  Previously women were in the hi-tech industries at the same rates as any other industry - but then it all changed.  Women fled the compute sciences field.  Is this the rise of the computer geek era?

Was it the geeks that ran the women away?  Or was it the lack of women that attracted the geeks?  Was there cause and effect or just an interesting correlation?

Planet Money has an interesting investigation and some answers - give it a listen.

When Women Stopped Coding :: Planet Money - NPR

Categories: Blogs


TargetProcess - Edge of Chaos Blog - Wed, 11/19/2014 - 14:19

I’m 35 and only recently I truly nailed what drives my life — it’s “creation”. When I create something meaningful I feel really great. My creations are not tangible in most cases, like poems, songs, design solutions, new product features, articles, books and blog posts. In general I think creation of anything that lasts is a good way to spend your life.

Minecraft Kings LandingSource: 25 ‘Minecraft’ Creations That Will Blow Your Flippin’ Mind

Deep immersion into a working process turns off everything around. You suddenly ignore all external sounds, you don’t feel how minutes and even hours passing by, you don’t notice poor lighting and reject timid body requests. Then you wake up and check the result. Maybe it’s not perfect, maybe it’s just a start of something significant, maybe you will throw it away in several days after critical examination, but nevertheless you have a sense of achievement. You’ve just completed a thing that may be a part of your legacy.

Can you write? Can you invent a software that changes people lives? Can you build a house? You never know till you try. Your life passion is not “programmed”, it should be “discovered” via experiments and achievements. Moreover, public recognition in many cases is not a good indicator of your achievements. Your personal feelings do matter. When you achieve something and enjoy the process, it is a good signal that your experiment was successful and you should keep going. When you spent quite a lot of time on, let’s say, quantum physics with no clear results and theoretical constructions bored you to death, maybe you should try something else (or maybe you just have a depression, but it’s curable).

Any startup and any ambitious mature company should hire as many creators as it can. These people are enthusiastic, active and relentless. They are the engine of a company. They keep learning, experiment a lot and failures are just a part of their working process. Every team desperately needs at least one creator, otherwise it will be mediocre at best.

How to discover a creator? It is relatively easy to do. Usually they can have something from the list below:

  • Side products (frameworks, apps, whatever)
  • Blog, articles, books, whatever
  • Hobbies related to creation (painting, robots construction, fancywork)
  • They usually like LEGO and Minecraft (this option alone is not 100% proof that a person is a creator)

Consumers are all around. We all consume books, movies, TV shows, cars, food, etc. How many of us transform all these consumed information, experiences and skills into something meaningful? Surprisingly, creators are quite rare. It’s incredibly hard to find one and align his goals with company goals. Sometimes they are not polite and hate everything that blocks or slow downs acts of creation. They will not tolerate political games and bureaucracy. Most attempts to cheat them and exploit them will fail in the long run.

We need to build companies that promote honesty, creation and learning. I’m here to create. You?

Categories: Companies

You are not your IDE

Derick Bailey - new ThoughtStream - Wed, 11/19/2014 - 14:00

Over the weekend, I attended the Nodevember developer conference in Nashville, TN. I was fortunate enough to speak and showed a demo of how we can break the shackles of our big, bloated IDEs in software development. Now, that’s not to say there’s no value in IDEs… but I don’t need to explain my complete position, here. You can watch the video of the talk, if you want to know more. One of the things I say in that video, though, has stuck with me for the last few days:

“You Are Not Your IDE!”


I said this with purpose, as a continuation of the conference’s opening keynote speaker saying, “You are not your code,” and as a play on the “Tyler Durden” character and his “you are not …” lines from the movie, Fight Club. The more I think about this line and the rant that I wanted to go in to, the more important I think this idea is. But I keep coming back to it, not because I think your favorite IDE is worthless… but because “you are not …” is a two-way street.

The Way It’s Always Been

We often get stuck in a rut as human beings – not just as developers, but as humans in general. We fall in to comfortable habits, and we do them without thinking.

I moved in to my current house almost 10 years ago. While settling in, my dad bought me a large set of drill bits and other attachments knowing I would need them. A few hours after getting the new bits, I needed to put a hole in something. YOU WON’T BELIEVE WHAT HAPPENED NEXT! (LOL – sorry. couldn’t resist a bit of link bait. :D) After figuring out what size drill bit I needed, I went searching through the old tools in my garage, hoping to find a small pack of drill bits that I knew I had … completely forgetting that I had this brand new, well organized, right-in-front-of-my-face case with 90+ bits and other attachments in it!

We All Have Habits

It wasn’t that I liked my old drill bits better. In fact, I didn’t like them much at all. I remember thinking that I hoped they would survive the job and be the right size. I had new drill bits, but I had already forgotten about them because in the short time that I went from getting them to needing them, I fell in to old habits and comfort – even if that comfort was more painful than what the new thing would have been.

It’s easy for us to forget that humans have ingrained habits – whether it’s ourselves or others around us. It’s easy to fall back in to our comfort zones. Things that are familiar are more comfortable than things that are not, even if they are not better.

It’s no wonder, then, that people still use older tools from bygone times. We get comfortable with them and we have a hard time putting them down (I use Vim, after all… one ancient editor!)


I like new tools and new things in software development. It doesn’t mean I don’t get stuck or that I always have time to try new things, but I do make an effort. And let’s face it – half the time that I want to try a new tool is just because it’s new. It may or may not solve any problems or do something better, but it’s a new toy! And I want to play with it!

There’s not necessarily anything wrong with this. Allowing myself to play with the new, shiny development tool toys gives me an advantage at times. It helps me to find tools that really do help me improve in some way. This talk that I gave at the conference? It was full of the new toys that I have been playing with and using for the last year, or in some cases many years.

But new toys aren’t always what we need. Sometimes, the old toys that we keep going back to out of habit, or the toys collecting dust in the bin, are the ones that we really need.

The Old Toys Are Nice, Too

One of the problems with new toy syndrome, is that we forget about other people that just need to get things done. We forget about comfort zones and familiarity. We forget that not everyone can be as productive as we are, with something new. Not everyone has time to play with new toys and learn new things, either. I don’t event have that much time, in spite of what it may look like to some people.

When we forget about the nice old toys, or even the toys that are kind of broken but still help someone get the job done, we sometimes get a little mean. We point and laugh at the kid with last year’s toy, while we run off with our new friends playing with this year’s toy. But, that’s not ok.

You Are Not …

My Fight Club ranting moment had a point – being overly attached to our tools, our language, our development environments, our whatever… that can do damage in a lot of ways. But the “You are not …” meme is a two way street. It’s true that you are not your IDE of choice. But, what is your IDE of choice? Is it an IDE of old? Is it a vendor-specific IDE? Or is it a conglomoration of command line tools that you’ve strung together, as I’ve shown in the above video?

You are not your code.
You are not your programming language.
You are not your IDE, or command line tools!
You are not the contents of your GitHub repository!
You are not … !!!

It’s easy to think we’re doing better than others because we’re playing with the “cool kids”. It’s easy to laugh at others and think less of them, too. But it’s far more valuable for everyone – ourselves included – if we remember that level of comfort and familiarity in the old tools and techniques. It’s also equally as important to remember that we are not the new tools that we are using. We are not here to hang with the cool kids, either. We’re here to do our jobs; to solve problems and hopefully make the world and the lives of other people better. If we can remember that, we can empathize and we can relate. We can show people the new things and share our new toys.

And maybe… just maybe we can even help someone else become productive with the new tools that we’ve found.

But not always. And that is ok.

- Derick

Categories: Blogs

Next round please!

Scrum 4 You - Wed, 11/19/2014 - 08:42

Plan, Do, Check, Act – Plan, Do, Check, Act – Plan, Do, Check, Act – Plan …
Der Deming Cycle begleitet mich als Mensch schon ein Leben lang. Die dahinterliegenden Begriffe sind umgangssprachlich schnell erklärt (Für eine intensivere Auseinandersetzung siehe oder die Vielzahl der Bücher zum Thema.)

Plan – Lege fest, wie Du das Ziel erreichen willst.
Do – Zerlege das Ziel in kleine Schritte und führe diese aus.
Check – Analysiere das Ergebnis dieser Schritte.
Act – Führe korrektive Maßnahmen durch und mache diese zum Bestandteil des nächsten Durchlaufs.

Plan, Do, Check, Act – Plan, Do, Check, Act – Plan, Do, Check, Act – Plan …
Das Konzept ist ein Grundbestandteil der Scrum Methodik und somit ein fester Bestandteil unserer täglichen Arbeit. In den Estimation und Sprint Plannings #1 & #2 planen wir, WAS getan und WIE es getan werden soll (Plan). In den Sprints setzt das Team diese Planung durch die Ausführung von Tasks um (DO). Im Review und in der Retro sehen wir uns an, wie es für die Kunden und für das Team gelaufen ist und was wir in der nächsten Runde besser machen können (Check). Diese konkreten Verbesserungsvorschläge nehmen wir mit in die nächste Runde, um wieder Dinge ein Stück weit zu verbessern (Act).

Plan, Do, Check, Act – Plan, Do, Check, Act – Plan, Do, Check, Act – Plan …
Es ist ein ständiger Kreislauf. Als Metapher dazu fällt mir der ständige Kreislauf der Natur ein. Der Frühling ist der Anfang: Es fangen die ersten Triebe zu sprießen an und die Luft ist voll von Hoffnung auf Wachstum und darauf, in diesem Jahr ungeahnte Größen zu erreichen. Im Sommer beginnt der Wettbewerb der Schönsten: alles blüht und zeigt, welche Pracht die Natur entwickeln kann. Im Herbst ist Showtime: Was wurde denn wirklich produziert und wer trägt die meisten Früchte? Der Winter ist die Regenerationsphase: Es gibt eine Ruhepause, in der die Natur ihre Kräfte sammelt, um im Frühling den Zyklus wieder neu beginnen zu können.

Plan, Do, Check, Act – Plan, Do, Check, Act – Plan, Do, Check, Act – Plan …
So und nun folgendes Szenario: Mutter Natur sagt eines Tages als Personifikation des gesamten Kreislaufes: “Puh, immer dieser Kreislauf und dieses ständige Verbessern und Verändern der Gene und das Mutieren. Ach lassen wir das doch einfach sein. Wir haben das doch schon so einige Jahrmillionen Jährchen gemacht, langsam sollte ich den Dreh ja raus haben, ich hör jetzt einfach auf mich zu verändern. Ich hab mein Ziel erreicht.”

Klingeln da nur bei mir dir Alarmglocken oder geht das anderen Lesern auch so? Ich habe den starken Verdacht, dass diese Maßnahme kein gutes Ende für die Natur (geschweige denn für uns Menschen) haben würde. Was würde mit unserem Ökosystem passieren, wenn Bäume sich entschließen würden, sich nicht mehr an ihre Umstände anzupassen und sich zu verbiegen, um das Sonnenlicht zu erreichen? Was würde passieren, wenn Blumen nicht immer neue Geruchsstoffe entwickeln würden, um Insekten jedes Jahr aufs Neue anzulocken?

Das ständige, nie aufhörende sich Verändern ist ein stetiger Bestandteil der Natur, dem wir unser Überleben verdanken. Mehr noch, wir Menschen selbst befinden uns in einem ständigen Veränderungsprozess, der unser eigenes Überleben ermöglicht. Eine Lebensphase wechselt die nächste ab. Was gestern noch unglaublich wichtig war, kann morgen schon bedeutungslos sein.

In diesem Sinne, feiern Sie in Scrum den Herbst (Review) und nutzen Sie die Winter (Retrospektive), um sich Gedanken zur Optimierung der nächsten Iteration zu machen – aber bitte vermeiden Sie es, das Ende von Scrum zu suchen. Das Ende von Scrum als iterativer Prozess wäre das Ende der Weiterentwicklung. Die Weiterentwicklung ist jedoch der größte Vorteil auf einem sich verändernden Markt und hilft, jede Schwierigkeit zu meistern.

Categories: Blogs

What about Microsoft Component Extensions for C++?

Sonar - Wed, 11/19/2014 - 08:32

After my previous blog entry about the support of Objective-C, you could get the impression that we’re fully focused on Unix-like platforms and have completely forgotten about Windows. But that would be a wrong impression – with version 3.2 of the C / C++ / Objective-C plugin released in November, 2014, support for the Microsoft Component Extensions for Runtime Platforms arrived in answer to customer needs. The C-Family development team closely follows discussions in the mailing list for customer support, so don’t hesitate to speak about your needs and problems.

So what does “support of Microsoft Component Extensions for Runtime Platform” mean? It means that the plugin is now able to analyze two more C++ dialects: C++/CLI and C++/CX. C++/CLI extends the ISO C++ standard, allowing programming for a managed execution environment on the .NET platform (Common Language Runtime). C++/CX borrows syntax from C++/CLI, but targets the Windows Runtime (WinRT) and native code instead, allowing programming of Windows Store apps and components that compile to native code. Also could be noted there is not much static analyzers capable to analyze those dialects.

So now the full list of supported C++ dialects looks quite impressive – you can see it in the configuration page:

And this is doesn’t even count the C and Objective-C languages!

You also may notice from the screenshot above, that now there is clear separation between the ISO standards, the usual Microsoft extensions for C/C++ (which historically come from Microsoft Visual Studio compiler), and GNU extensions (which historically come from GCC compiler). The primary reason for the separation is that some of these extensions conflict with each other, as an example – the Microsoft-specific “__uptr” modifier is used as an identifier in the GNU C Library. To ease configuration, the plugin option names closely resemble the configuration options of GCC, Clang and many other compilers.

But wait, you actually don’t need to specify the configuration manually, because you can use the build-wrapper for Microsoft Visual Studio projects just like you can with non-Visual Studio projects. Just download “build-wrapper” and use it as a prefix to the build command for your Microsoft Visual Studio project. As an example:

build-wrapper --out-dir [output directory] msbuild /t:rebuild

and just add a single property to configuration of analysis:[output directory]

The build wrapper will eavesdrop on the build to gather configuration data, and during analysis the plugin will use the collected configuration without the headaches of manual intervention. Moreover, this works perfectly for projects that have mixed subcomponents written with different dialects.

So all this means that from now you can easily add projects written using C++/CLI and C++/CX into your portfolio of projects regularly analysed by SonarQube.

Of course, it’s important that the growth of supported dialects is balanced with other improvements, and that’s certainly the case in this version: we made several improvements, added few rules and fixed 28 bugs. And we’re planning to go even further in the next version. Of course, as usual there will be new rules, and improvements, but we’ll also be adding a major new feature which will make analysis vastly more powerful, so stay tuned.

In the meantime, the improvements in version 3.2 are compatible with all SonarQube versions from 3.7.4 forward, and they’re worth adopting today.

Categories: Open Source

Knowledge Sharing

SpiraTeam is a agile application lifecycle management (ALM) system designed specifically for methodologies such as scrum, XP and Kanban.