Lessons from the Front Line
Overview: Product Manager Jim Liebert shares tips for the best way to view and approach DevOps work.
At its root software development is science. It’s the process of providing a set of instructions to a hardware device to complete a desired task. Working at this level is a core competency for any developer. As skill levels progress, the process becomes more sophisticated. Programmers begin to recognize patterns and learn how best to leverage and extend existing code to get to the solution quicker. Eventually, they gain a strong understanding of the entire system.
However, there is lost opportunity if the developer, or even an entire development team, doesn’t progress past this point. It can deteriorate the Agile process down to accomplishing tasks by achieving the specified acceptance criteria. Ideal breeding ground for a feature factory.
Science, art, magic
Something changes if developers begin to see the process as more of an art than a science. If they see all answers exist in a fuzzy gray state and the real skill is determining the best fit for any given situation. Instead of assuming software development is black and white, in this gray area—as in art—there isn’t so much the right answer, as there is skill in finding the most appropriate one.
This represents an evolution in the agile process for a team as well. Results improve as the team sees stories as concepts rather than assignments, and that at the crux is the spirit of the story rather than the acceptance criteria. Stories are discussed and become more thoughtful; software delivery becomes benefit-based rather than feature-based. But the journey still isn’t done.
Software development transcends into magic when the user becomes part of the process. When the focus is on enabling the user to best accomplish what they need to achieve. When the user experience is the driving factor—when user satisfaction is the driving motivation—that is when a software team can accomplish miracles.
For cool things to happen, you have to get out of your comfort zone.” —Rony Abovitz
Once this level is achieved, the goal is wide user acceptance. Where once there was satisfaction in the science and art of software development, increasing sophistication to find the right answer that serves the best needs of the user is the truest satisfaction.
Lesson learned: Being of service to others, even in the smallest of things, returns big benefits.
Finite > Infinite
My team works in two-week sprints, and when we meet to review the status of our projects, we pit the finite against the infinite. We consider the infinite of things we could have done versus finite resources, time and people available to do those things. Every two weeks we lose, infinity wins. When finite meets infinite, infinity always wins.
What happens next? We pick ourselves up, dust ourselves off, strategize to reduce the infinite, discuss ways to increase our finite and at the issue again.
If you find a path with no obstacles, if probably doesn’t lead anywhere.” —Frank A. Clark
It’s a losing proposition but it yields a bounty. The infinite gives us room to dream beyond the boundaries of our comfort zones. The finite forces us to continuously sharpen our focus on what matters the most to our customers.
It all comes together when we release to production, share our innovation with our customers and begin to see the real-world results. At that point infinite doesn’t seem quite as daunting and we can take pride in our finite and what it provides.
Lesson learned: If you don’t let what you could do get in the way of what you can do, you’ll be amazed at what you did!
Don’t let sunk costs sink you
The psychology of sunk costs is the software equivalent of Don Quixote tilting at windmills. The adversary isn’t the sunk cost, it’s the wasted time and effort to resuscitate, revisit and re-evaluate past decisions.
My team is currently doing battle with an extreme sunk cost. Early in the life of our product, a decision was made that was exactly right for its time and place. We reached an agreement with a vendor and integrated their software deep into our product. Customers were happy. We declared victory and moved on.
But things are rarely that simple and that was true here too. As our product matured it became obvious that the third-party software was now dragging us down. The implementation was stopping us from moving fast and forcing cascading compromises in how we implemented things. Most importantly, it was causing us to not be able to fulfill fundamental requests from our customers.
The effort and time we put into this integration was significant and replacing it would be daunting. But at some point, we had to swallow our pride, admit that the current approach wasn’t working, and begin heading towards a better future. This type of pivot requires the complete commitment of the entire team and the realization that looking back is not an option.
Nothing in the universe can stop you from letting go and starting over.” —Guy Finley
The outcome has yet to be determined. However, early indications are a cleaner, simpler product with equivalent functionality and built around the ability to implement future capabilities much more quickly.
Lesson learned: Sunk costs cannot be recovered; learn from them but don’t get shackled by them.
This bit of wisdom comes to us from longtime Compuware Product Manager, DevOps Teams Jim Liebert. He’s been known to say, “Everything turns out all right in the end. If it’s not all right, it’s not the end.” Everything must be all right because this is Jim’s last blog for Compuware. He’s earned the right to sleep late, take a walk down the street for a cup of coffee anytime, and spend his days however he chooses. He’s shown us his science, his art, and most of all his magic.
Lesson learned, Jim. Your grateful coworkers.
Latest posts by Jim Liebert (see all)
- Lessons from the Front Line - August 22, 2019
- Talking Mainframe at the Compuware Customer Advisory Council - July 3, 2019
- ‘Cathedral Thinking’ with Agile Development, 1296 BC to Now - May 23, 2019