Measuring Productivity of Software Development Teams

This paper gives an exhaustive literature review of the techniques and models available to measure the productivity of software development teams. Definition of productivity, measuring individual programmer's productivity, and measuring software development team productivity are discussed. Based on the literature review it was found that software productivity measurement can be done using SLOC (Source Lines of Code), function points, use case points, object points, and feature points. Secondary research findings indicate that the team size, response time, task complexity, team climate and team cohesion have an impact on software development team productivity. List of factors affecting the software development team productivity are studied and reviewed.


INTRODUCTION
The objective of IT function for any organization is to achieve operational efficiency, reduce costs on repetitive tasks, reduce response time of the customer, achieve consistency, reliability and accuracy in customer transactions so that customer satisfaction can be improved. In achieving this, the organization forms project teams, cross functional teams to meet the organizational objectives. More than 70% of the Fortune 500 organizations have teams in their organizations. Particularly software development is done by teams in organizations. Onsite, offshore teams, virtual teams, globally distributed teams, high performance teams, and self managed teams are some of the terminology we hear in software industry in current days. The objective of any software business organization is to achieve maximum team productivity to reduce costs and to increase profitability. With the advent of process maturity models such as CMMI and PCMM, software services organizations in Asian countries are even thriving for continuous improvement. The definition of productivity follows.

DEFINITION OF PRODUCTIVITY
Traditionally Productivity can be defined as a ratio of output units produced to the input units of effort (Scacchi, 1995;Maxwell, 2001;Wagner & Ruhe, 2008a;Nwelih & Amadin, 2008). Output units can be the number of lines of source code and input units can be the person months of time. Traditionally the lines of code (LOC) or the Function Points are used for measurement of productivity in software development (Wagner & Ruhe, 2008a). According to Wagner and Ruhe (2008a), the number of lines of code written or the number of function points implemented per man hour by the developer is used as a measure of productivity. Previous software team productivity studies were conducted in organizations such as IBM, NASA, ITT, and HP. According to Nwelih and Amadin (2008), software productivity definition includes complexities of both software and people. According to them software productivity can be calculated by dividing software size with cost of development.
According to Card (2006), Productivity is defined as the ratio of outputs produced to the resources consumed.
Earlier researchers like Albrecht (1979) have developed Function Points at IBM andJones (1986) has studied the productivity and quality of the software projects. Jones (1986) work on productivity is published in his popular book Programming Productivity. Researcher Lakhanpal (1993) has studied the characteristics of groups and their impact on productivity (Wagner & Ruhe, 2008a). Study of software development team productivity involves disciplines such as Software Engineering, Management and Organizational Psychology. Banker, Datar and Femerer (1991) have studied the variables impacting the productivity of software maintenance projects with the help of an empirical study of 65 software maintenance projects of a large commercial bank.

WHY MEASURE TEAM PRODUCTIVITY?
According to Scacchi (1995), Software team productivity is to be measured to reduce the software development costs, to improve the quality of deliverables, and to increase the rate at which software is to be developed. According to him, the software productivity is to be measured to recognize the top performers to reward and identify the bottom performers to provide the training.
The major productivity improvements can result into substantial amount of savings in development costs (Scacchi, 1995).
Measuring productivity helps in identifying under utilized resources (Nwelih & Amadin, 2008). The study of software productivity is important because higher productivity leads to lower costs (Bouchaib & Charboneau, 2005). Bouchaib and Charboneau (2005) have studied the comparison of productivity of in-house developed projects and productivity of outsourced projects to third party with a sample of 1085 projects developed worldwide.
Krishnan, Kriebel, Kekre and Mukhopadhyay (1999) have studied the software life cycle productivity, which includes both development and maintenance costs and drivers of software team productivity and quality such as personnel capability, product size, usage of tools and software process factors. According to Banker and Kauffman (1991), software productivity can be found from the following formula.

MEASURING INDIVIDUAL PROGRAMMER'S PRODUCTIVITY
According to Wagner and Ruhe (2008), software productivity can be measured traditionally using the lines of code or function points and the productivity is the LOC or FP produced per hour by the programmer. The productivity and cost estimation model COCOMO developed by Boehm (1981) also considers the individual programmer's productivity as a decisive role. The factors identified by Barry Boehm and team which affect software productivity and cost include programmer capability, team cohesion, platform experience, programmer's programming languages and tools experience, software applications experience, and analyst capability.
Setting goals to the programmer, providing training, giving periodic feedback on his or her performance improves the individual productivity of programmer (Wagner & Ruhe, 2008). According to Chiang and Mookerjee (2004), improving software development productivity depends on people, technology and process.
The constraints which control the programmer productivity are the time constraints, financial constraints, software specifications, corporate environment and programming methodology (Vyhmeister, 1996). According to Vyhmeister (1996), one can use Lines of code (LOC), Function Points (FPs), and Object points (OPs) to measure the productivity of software programmer.
Individual programmer's productivity can vary between 1 to 10 times in the same experience level programmers and team productivity can have variations of a factor of 5 (White, 1999). People related issues are the critical factors of individual programmer's productivity.
According to M. Pinkowska, team productivity is dependent on individual team member's productivity and the team member's experience of success impacts his or her motivation, team cohesiveness and work atmosphere.
Teams with high cohesiveness exhibit lower tension and anxiety, less variations of productivity, improved team member satisfaction, improved team communication, and commitment. Team members in cohesive teams enjoy team membership, experience low personnel turnover, and they are very productive (M. Pinkowska's Research). According to Blackburn, Lapre and Wassenhove (2002), the measure of productivity using number of function points divided by man months of effort is applicable irrespective of the programming language in which the project is being implemented.
According to Card (2006), the productivity of large teams is lower than the productivity of small teams. According to him, while measuring productivity labor related to engineering, management, testing and support needs to be taken into consideration. According to the research done by Banker, Datar and Femerer (1987), high project quality need not necessarily reduce the software maintenance team productivity. The teams that behave in correlated fashion perform better than the teams that behave randomly (Potok & Vouk, 1999). According to Potok and Vouk (1999), weak team's productivity is less than the productivity of teams that behave randomly and the better way to handle the weak team performance is to shuffle the team members randomly. Software team performance is dependent on the human characteristics of the team (Potok & Vouk, 1999).
Currently Function points and Lines of Code are measures of software productivity (Maxwell & Forselius, 2000).

FACTORS AFFECTING THE PRODUCTIVITY
Major changes to technologies of the project product lead to minimal productivity improvements (Scacchi, 1995). According to Scacchi (1995), some of the factors facilitate high software team productivity include substantial computing infrastructure, software engineering tools and techniques such as rapid prototyping tools, software testing tools, e-mail, document management systems, object oriented programming languages, and configuration management systems. The attributes such as well organized project teams, experienced programmers, and different team work structures facilitate the high software team productivity.
The product, process and production setting characteristics affect the software productivity of individual programmer as well as software development team (Scacchi, 1995). User participation, experience of the programmer with the programming language and program design constraints are the factors affecting the software productivity (Wagner & Ruhe, 2008a). According to Wagner and Ruhe (2008a), soft factors such as team culture, team identity, team cohesion, support for innovation, turnover, and team communication affect the software team productivity.
Average team size, programming language used (3GL or 4GL), development platform and development techniques have impact on software team productivity (Jiang & Comstock, 2007). Team size has impact on team productivity and project costs (Tockey, 1996).
According to Potok and Vouk (1999), strong teams have high productivity over all the assigned tasks where as weak teams have low productivity over all assigned tasks. It was also proven by Vijayashree and Jagdischchandra (2011) and by Kuye and Sulaimon (2011). Software reuse can be used to improve the software team productivity (Nwelih & Amadin, 2008). Large team size reduces the software development productivity (Blackburn, Lapre & Wassenhove, 2002). According to Blackburn, Lapre and Wassenhove (2002), project complexity increases the team size and team size decreases the team productivity significantly. They have studied 117 software projects provided by the Software Technology Transfer Finland. According to Banker and Kauffman (1991), experience of the programmer has impact on the productivity of software maintenance projects.
According to the research done by Blackburn, Lapre and Wassenhove (2002), experience of the project manager and project size increases the team productivity.
According to them, change in user requirements and usage of tools significantly decreases the software development team productivity. Banker, Datar and Femerer (1991) have examined the effects of project team member ability, application experience, system quality, hardware and methodological tools on software maintenance team productivity.
According to Banker, Datar and Femerer (1987), the environmental variables affecting the software team productivity are project management, personnel, user and technical environment. According to them personnel variables critically impact the productivity of software project teams. According to Banker and Kauffman (1991), reuse is the major factor affecting the software development productivity.
According to Agrell and Gustafson (1994), team climate consists of vision, participative safety, team orientation, and support for excellence have impact on team productivity. They have used Team Climate Inventory (TCI) developed by the Anderson and West for finding the team climate and productivity of Swedish work-groups. Wagner and Ruhe (2008) have derived some soft factors which affect the software development team's productivity. They are team identity, personnel turnover, team cohesion, team communication, clear goals and support for innovation. Support for innovation as a factor affecting the team productivity has been proved by the study of Agrell and Gustafson (1994) on Swedish work teams.
Premraj, Shepperd, Kitchenham and Forselius (2005) have identified the factors such as task difficulty, interaction with customer, skills of project team, and non functional requirements such as performance and dependability impact the software team productivity. According to Premraj, Shepperd, Kitchenham and Forselius (2005) research, productivity varies from company to company and business sector to business sector. Within the same company different business sectors can have different productivity levels and productivity is also dependent on year and hardware.
The factors affecting the software development team productivity are the system construction time and coordination efforts (Chiang & Mookerjee, 2004). This is because if the system construction time is less, team size increases and if team size increases productivity per programmer reduces. Organizational structure, internal politics, organization size, team morale, and physical facilities have impact on the software team productivity (Vyhmeister, 1996). According to Jiang, Naude and Comstock (2007), software team productivity variations are because of average team size and the unbalanced usage of programming languages (3GLs or 4GLs).
Product characteristics, people, process, and technology have impact in the software development time and product outcome (White, 1999). People factors affecting the software development team productivity are the staffing, motivation and work environment. According the M. Pinkowska's research, team cohesiveness has impact on software team productivity.
According to Comstock, Jiang and Naude (2007), fourth generation programming languages give more productivity than third generation programming languages. According to Teasley, Covi, Krishnan, and Olson (2000), teams in warrooms give double the productivity than the normal teams. According to their research team collocation increases the software team productivity.

OTHER PRODUCTIVITY MEASUREMENTS
Traditionally SLOC and Function points are used as units of software team productivity. Other measures such as use case points, object points and feature points are also used in some of the IT organizations. These new measures kept in mind the object orientation, extendibility and reusability in finding the software team productivity.

CONCLUSION
The definition of productivity and why to measure software productivity have been explained. The productivity measures such as SLOC, KLOC and Function points are discussed. The models and techniques related to software development team productivity are tabulated. The factors affecting the software development team productivity are explained.
Other productivity measures such as Use Case points, object points, feature points are mentioned. Further research can be done on finding the soft factors affecting the software development team productivity.
The productivity measured can be improved. An organization working on the factors affecting the software development team's productivity can improve the overall organizational productivity. Organizational productivity is dependent on individual and team productivity. Thus improving software development team's productivity results into improved organizational productivity. The productivity improvement is part of team development. Hence, one should try to increase the productivity of software development teams resulting into the better organizational productivity and performance.