Tag Archives: teams

The Value-Up Paradigm

The paradigms I’m going to contrast are how we view the entire development process. I will refer to two different paradigms: the first is the “work-down” approach which I will contrast with the “value-up” approach. I read about this in Software Engineering with Microsoft Visual Studio Team System concerning the new Microsoft approach to software development including an introduction to the Agile SDLC. However, I’m not here to promote Microsoft Team System or Agile methodology; instead, I’m here presenting a paradigm that is pertinent regardless of your chosen SDLC or technological platform.I will start by defining both the work-down and value-up approaches (and I will use “approach” and “paradigm” interchangeably), outlining the effects of both paradigms, and I will finish with ensuring that this paradigm becomes practical in your daily development tasks.

The Old, Work-Down Approach

Most of us are very familiar with this approach. We meet with the prospective client, define requirements as much as possible, and approach the development task as marking off completed requirements until completion. This methodology works fine when you have no scope creep, have low risk, and well-defined requirements; but unfortunately this doesn’t describe most of our projects. This is especially true for us that freelance as the risks involved for us are much higher.

A project manager typically has three variables to use in the work-down approach: time, resources, and functionality. What has happened is that a fourth area needs to be recognized-namely, quality. Due to this and the truth that most of our project managers don’t take quality into account as one, if not the, most important attributes of successful software development from the very beginning.

The Value-Up Approach

When approaching this paradigm we need to remember what most satisfies us when we make a purchase. Even though we might not consciously think of it, when we make a purchase we are intending the purchase to return value to us in one form or another. I am most satisfied and suffer less cognitive dissonance when I see the value received from my purchase.

In the never-ending process to ensure that our customers are satisfied we should view their investment in us as a desire to receive value of some kind. Concentrating on a consistent flow of value to the customer should be a paradigm that will utilize, but we must not internalize as we must also convey that emphasis to our customer.

Software development is also different than other forms of development. For instance, when building a bridge there is no intrinsic value in a bridge that is only half-way done! But in opposition to this, software development isn’t build along the same vein. My customer can receive benefit by starting to use an application even though the interface is not yet completely finished. The earlier our customers see value being delivered to them the happier they will be throughout the process. Even though I’m not endorsing an agile approach to software development, this approach, when combined with agile iterations can help you effectively deal with the inevitable scope creep.

Contrasting the Paradigms

The book lays out a table to visually see the impact of using the paradigms (of which I will use the majority of the table), and the information is verbatim from the book (pgs. 6–7). While not exhaustive, it will help us to see tangible results of making such a change.

Core Assumption Work-Down Approach Value-Up Approach
Planning and change process Planning and design are the most important activities to get right. You need to do these initially, establish accountability to plan, and monitor against the plan, and carefully prevent change from creeping in. Change happens, embrace it. Planning and design will continue through the project. Therefore you should invest in just enough planning and design to understand risk and to manage the next small increment.
Primary measurement Task completion. Because we know the steps to achieve the end goal. Only deliverables that the customer values (working software, completed documentation, etc.) count.
Definition of quality Conformance to specification. That’s why you need to get the specs right at the beginning. Value to the customer. This perception can (and probably will) change…don’t specify too much too soon.
Approach to Trust People need to be monitored and measured to standards. Incentives should be used by management to reward individuals for their performance relative to plan. Pride of workmanship and teamwork are more effective than individual incentives. Trustworthy transparency, where the whole team can see all the team’s performance data, works better than management directive.

The first thing to realize is that in a value-up paradigm we embrace that changes happens throughout the software development process. I’m sure we have all had our fair share of frustration when we complete tasks according to the original specifications, but when we from the beginning perceive change throughout the process as inevitable-and ultimately positive-then it makes the process much easier for us.

Notice as well that the only true values of progress measurements are items that actually give value to the customer. In other words, our Gantt Chart should reflect tasks that actually give value to the customer not only tasks completed. In the context of a web application, that might be the installation and/or customization of a content management system, maybe it might be the ability for the user to customize the interface, or it could be a litany of other items. The only thing our customer should hear from us is that we are delivering value and utility to them throughout the process. This also helps when our customer comes to us and says something like: “This doesn’t do what the requirements outlined.” Well, in our perception it might be what the requirement stated, but if value is not given to our customer then we haven’t made any progress.

I do understand that there is variance that, no matter how much you try and avoid, conflict happens over what requirements. But the adage, “the customer is always right” is still very applicable to software development.

Moving from the Ethereal to the Practical

Now that we have outlined the philosophy we must ask how this can be of practical value to us in our everyday work. The best way to bring this back down to earth is to share a practical example.

I get to do software development with government agencies (Air Force, USAID), and if any of the readers share that experience then they understand my pain and frustration. More than any other clients, government agencies are some of the hardest to work with. The paradigm for development in general, whether software or weapons development, is the traditional (non-agile) methodology of outlining all the requirements from the beginning down to the type of paper you’ll submit to them.

These government agencies are familiar with only seeing something when the developer feels it’s presentable, and updates are traditionally provided in terms of a work down paradigm. I had to, with some very conscious thought, change the way I conversed with my customer. Here are some examples of changes I made in conversing with my customer. The first list will be the traditional way of conveying progress, and the second list will be the verbiage I changed from a value-up paradigm.

Work-Down Terminology

  • Per the requirements documentation, we have completed 1.A, 1.B, and 2.A.
  • Your new requirements are not in the original document so we will have to stop and revisit the documentation.
  • We have successfully completed the project according to the requirements.

Value-Up Terminology

  • With the completion of this iteration, you can now dynamically edit your content, customize the layout, and you can start to see how it will function as we finalize the user interface.
  • New requirements are a natural part of the process, and we will focus on your new requirements in the next iteration.
  • We have successfully completed the project in light of your desired capability.

Conclusion

The value-up paradigm is a powerful way to approach software development, but change is something that needs conscious focus. The value of changing paradigms will become evident nearly instantaneously as the relationship improves between you and your customer, and the reputation of your company as one that delivers tangible value early grows and supplies a constant flow of work.

You can view the slides for my original presentation on SlideShare.

Engaging the Entire Development Team

Before I left college the only experience I had in software development was as a one-man team. I did all the design and back-end development. There wasn’t a conflict of interest between designer and programmer, because they were both one person! As I left college and got into the “real world” I found that it was impossible to do large-scale software development by oneself. All of the sudden there were information architects, program managers, user interface experts, database administrators, technical writers, and on and on.

I came to realize the value of specializing in one field. For instance, it would be counter-productive to mandate a DBA to learn Photoshop inside and out, and likewise it would be counter-productive to have the UI person learn how to know how to write every variation of database indexes. But I also saw the lack of knowledge that each had even of what the other team member’s responsibilities were that led to inefficient meetings, miscommunication between clients (especially in terms of requirements gathering), and overall it lead to a “that’s not my job” mentality that hurt the overall productivity of the team.

The Thesis

I believe we need address the lack of communication between the team members by increasing collaboration and at least a general knowledge of what the other is doing. If the programmer knows that the UI person is very concerned with Web standards then they can address that while he designs (among many other examples). All members of the team address the same client with the same requirements, and with knowledge of the various aspects of the SDLC the client can receive the maximum amount of value for their investment.

The article is broken up into examining the role and duties of the project manager and the developers. Both have unique responsibilities in order to ensure that the efficiency of the team is what it can be.

The Responsibility of the Project Manager

The responsibility of making this work falls on all members of the team, but the project manager (project lead, technical lead, etc.) is the one that has the authority to delegate who will work with who and for how long. There should also be a strong impetus for this person to embrace this ideology, because when conflicts arise between developers or between developers and clients the project manager is the one usually responsible for resolving the conflict.

By delegating developers to have a working knowledge of what the other members are doing through the software development and maintenance cycle then all members are able to offer constructive criticism to one another and help in a time of need. It is a great asset in the toolbox of delivering quality software.

Reduce Developer “Possession” of Code
I was sitting in a meeting, and when a customer bug request came up in a certain module then we automatically pointed to that one person who designed the module. The mentality behind it keeps other people on the team from double-checking the code and able to help each other of bug fixing and future development. Kent Beck, the popular proponent of eXtreme Programming (XP) (which I neither endorse nor discourage) says the following on “collective ownership.”

One of the effects of collective ownership is that complex code does not live very long. Because everyone is used to looking all over the system, such code will be found sooner rather than later. And when it is found, someone will try and simplify it. […] Collective ownership also tends to spread knowledge of the system around the team.” (Kent Beck. Extreme Programming Explained: Embrace Change (2nd Edition) (The XP Series). New York: Addison-Wesley Professional, 2004.)

Regardless of whether one uses XP or another SDLC, the concepts introduced are a good starting point to increase the amount of communication between team members, increase productivity, reduce errors, and deliver higher levels of customer satisfaction.

Facilitate Team Briefings
We all love to talk about what we’re passionate about; so why not use that to the advantage of your team? I work on a team where the project lead encouraged us to give a briefing on a new technology or certain aspect of their job that would benefit other members of our team. Let’s use an example.

The user interface designer is constantly frustrated why the DBA and developers just don’t “get” web standards. It leads to conflict, because the developer is solely concerned about the function and not the form (in an extreme example). Well, why not let that designer brief the team on the value of web standards? It would also be helpful for that individual to outline best practices so the application has both maximum form and function. Often miscommunication happens over very small issues, and by taking the time to clearly outline a concept then the problem often goes away.

In fact, recently I gave a briefing to my development team introducing CSS and CSS best practices. Months of frustration on my part was alleviated as many members of the team started to see the business value of separating presentation from structure. We are now converting our old table layout to a CSS-driven layout.

Managing Many Egos
Let’s face it-designers and programmers have egos, and not just small egos but large egos. Everyone has their own philosophy on how development should be done; this is normally a good thing that brings variety and many perspectives, but sometimes it can also be a hindrance when trying to empathetically communicate with team members.

How many technical meetings have we all been in that seemed to go on and on and seemingly accomplish nothing? It seems like we spend most of the time debating philosophically on the best route which is perpetuated by our own individual ideologies. This can, and should be, alleviated by realizing that what’s best for the application isn’t always how we feel it should be.

The project manager has the added responsibility of ensuring that these debates don’t get out of hand by effectively managing the conversation and ensuring that every side is heard. Ultimately, every business decision that is made must be made by some superior who weighs the options and chooses the best. A manager that is open yet firm in making decision does wonders for moving development along.

The Role of the Developers

The project manager can do quite a bit to ensure to ensure that the team works in an optimized state, but ultimately it comes to the people that comprise the team-the developers. I want to give a few suggestions for the developers to ensure that cohesiveness is improved.

Everyone Should Test Everything
A great way to get team members to get involved with the entire project is to not relegate testing to individual projects or a singular tester. By involving all members of the team in testing helps ensure that the quality of the application will continue to increase. I am continually amazed at how members of my development team don’t even know how to use many aspects of the very application they develop. It is often the result of the “possession” of code problem address above.

Improved Knowledge Management
A good development team should be the most experienced and concerned about knowledge management. As the application matures then it becomes more and more necessary to ensure that correct and complete documentation is retained (although don’t wait to start). The great knowledge management challenge of capturing tacit (un-written) knowledge is critical to address when you’re in a development team. As developers come and go the need to be less reliant on one or two developers is extremely important. You should, at least in theory, have enough documentation to move developers around and if necessary to replace.

Fostering Mutual Respect
Aretha Franklin had the idea when she said: “All I’m askin’ / Is for a little respect”. We all love to know that we are respected by our peers, but it only comes about when we extend it to others. That whole Golden Rule idea is very applicable in this situation. When developers create an atmosphere where we respect one another and each other’s contributions then more efficient communication is likely to take place.

In Summary

There are many ways to engage the entire development team, and the responsibility lies within the managers and the developers. It is truly a trial and error effort, but if you and your team seek to improve in the areas above then you are more likely to deliver a quality product to your customers and improve professional satisfaction.