Dissertations / Theses on the topic 'Software Engineering Productivity'

Software project management is one of the most critical activities in modern software development projects. Without realistic and objective management, the software development process cannot be managed in an effective way. There are three general problems in project management: effort estimation is not accurate, actual status is difficult to understand, and projects are often geographically dispersed. Estimating software development effort is one of the most challenging problems in project management. Various attempts have been made to solve the problem; so far, however, it remains a complex problem. The error rate of a renowned effort estimation model can be higher than 30% of the actual productivity. Therefore, inaccurate estimation results in poor planning and defies effective control of time and budgets in project management. In this research, we have built a productivity prediction model which uses productivity data from an ongoing project to reevaluate the initial productivity estimate and provides managers a better productivity estimate for project management. The actual status of the software project is not easy to understand due to problems inherent in software project attributes. The project attributes are dispersed across the various CASE (Computer-Aided Software Engineering) tools and are difficult to measure because they are not hard material like building blocks. In this research, we have created a productivity console which incorporates an expert system to measure project attributes objectively and provides graphical charts to visualize project status. The productivity console uses project attributes gathered in KB (Knowledge Base) of PAMPA II (Project Attributes Monitoring and Prediction Associate) that works with CASE tools and collects project attributes from the databases of the tools. The productivity console and PAMPA II work on a network, so geographically dispersed projects can be managed via the Internet without difficulty.

International Telemetering Conference Proceedings / October 25-28, 1999 / Riviera Hotel and Convention Center, Las Vegas, Nevada<br>Many view quality and productivity as competing concepts. After all, doesn’t high software quality come at a high cost? Doesn’t it mean that a large amount of "extra stuff" needs to be done during the software development cycle? And, doesn’t that mean that software productivity takes a back seat to (and a major hit from) quality efforts? This paper will explore these issues. This paper provides some preliminary data that supports how a disciplined software engineering process can (and has) resulted in high quality software while actually increasing productivity. Data has been gathered on organizations that have a disciplined, quality-oriented software engineering process in place. That data shows that quality and productivity can (and do) coexist. The data will be discussed along with an explanation of how these results can be achieved.

The rapidly increasing capabilities and complexity of numerical software present a growing challenge to software development productivity. While many open source projects enable the community to share experiences, learn and collaborate; estimating individual developer productivity becomes more difficult as projects expand. In this work, we analyze some HPC software Git repositories with issue trackers and compute productivity metrics that can be used to better understand and potentially improve development processes. Evaluating productivity in these communities presents additional challenges because bug reports and feature requests are often done by using mailing lists instead of issue tracking, resulting in difficult-to-analyze unstructured data. For such data, we investigate automatic tag generation by using natural language processing techniques. We aim to produce metrics that help quantify productivity improvement or degradation over the projects lifetimes. We also provide an objective measurement of productivity based on the effort estimation for the developer's work.

Absenteeism has a negative impact on organizational output in the form of lost productivity and profit reduction for software engineering companies. The purpose of this qualitative descriptive case study was to explore the strategies that software engineering managers utilize for reducing absenteeism. The theory of planned behavior formed the conceptual framework for this study. Data were collected through semistructured interviews from a purposeful sample of 11 managers at an international custom software engineering company. Data collection also included organizational data on employee absences for the past 5 years (2011-2015), e-mail memos, newsletters, employee handbook, and employee performance reviews. Based on methodological triangulation of the data sources and inductive analysis of the data, 4 themes emerged. Emergent themes from the analysis revealed that communication was key to reducing absenteeism, flexible work hours and working from home reduced absence, comradery and employee support positively impacted absenteeism, and that there was a lack of a clear and formal processes for addressing employee absenteeism. These findings suggest that, at this company, an absenteeism reduction strategy could help reduce employee absenteeism to lessen the negative impact on organizational productivity and profitability. These findings may contribute to social change by providing a template for effective absenteeism reduction strategies that managers can use to promote a decreased incidence of absenteeism, organizational profitability, reduction of the unemployment rate, employee stress, and mental health problems.

Lower cost and shorter time-to-market expectations are the major drivers of software productivity improvements. To manage productivity effectively, it is important to identify the most relevant difficulties and develop strategies to cope with them. Agile methods, including Extreme Programming and Scrum, have evolved as approaches to simplify software development process, potentially leading to better productivity. They aim to shorten development time and handle the inevitable changes resulting from market dynamics. Although the industry has extensively adopted agile methods, little research has empirically examined the software development agility construct regarding its dimensions, determinants, and effects on software development performance. Understanding this construct could help determine where to concentrate management efforts (and related financial resources) from a practical standpoint and where to focus research efforts from an academic perspective. Considerable research has been directed at identifying factors that have a significant impact on software development productivity. In general, the studied productivity factors were related to product, personnel, project, process, or organizational issues. Continuously evaluating productivity factors is important, as factors may change under new software engineering practices. However, little research has investigated the major factors influencing agile team productivity. ]The goal of this thesis was to explore productivity definitions, factors, and monitoring in agile teams and to improve the practice based on the collected evidence and gained knowledge. This thesis presents five novel contributions: C1 - Empirical verification of the importance of productivity for companies adopting agile methods and its perceived benefits; C2 - Rationale for the definition of productivity in the context of agile methods; C3 - Empirical verification of agile team productivity factors; C4 - A conceptual framework for agile team productivity factors and their impact; C5 - A team productivity monitoring process considering adaptability and an evaluation of the usefulness of agile team productivity metrics.<br>Menor custo e expectativa de menor time-to-market são os principais motivadores para melhorias de produtividade de software. Para gerir eficazmente a produtividade, é importante identificar as dificuldades mais relevantes e desenvolver estratégias para lidar com elas. Os métodos ágeis, incluindo Programação Extrema e Scrum, evoluíram como abordagens para simplificar o processo de desenvolvimento de software, potencialmente levando a uma melhor produtividade. Eles visam reduzir o tempo de desenvolvimento e lidar com as mudanças inevitáveis decorrentes da dinâmica do mercado. Embora a indústria tenha adotado amplamente métodos ágeis, há pouco entendimento científico do construto agilidade em desenvolvimento de software em relação às suas dimensões, determinantes e efeitos sobre o desempenho no desenvolvimento de software. Compreender esse construto poderia ajudar a determinar onde concentrar os esforços de gestão (e recursos financeiros relacionados) de um ponto de vista prático, assim como onde concentrar os esforços de investigação de uma perspectiva científica. Pesquisa considerável tem sido direcionada para identificar os fatores com impacto significativo na produtividade de desenvolvimento de software. Em geral, os fatores de produtividade estudados foram relacionadas ao produto, pessoas, projeto, processo ou questões organizacionais. Avaliar fatores de produtividade continuamente é importante, pois os fatores podem mudar quando novas práticas de engenharia de software são adotadas. No entanto, poucos estudos investigaram fatores influenciando a produtividade de times ágeis. O objetivo desta tese é explorar definições, fatores e monitoramento de produtividade em times ágeis e melhorar a prática baseada em evidência. Esta tese apresenta cinco novas contribuições: C1 - Verificação empírica da importância de produtividade para as empresas que adotam métodos ágeis e seus benefícios percebidos; C2 - Justificativa para a definição da produtividade no contexto de métodos ágeis; C3 - A verificação empírica de fatores de produtividade em times ágeis; C4 - Um arcabouço conceitual de fatores de produtividade em times ágeis e seu impacto; C5 - Um processo de acompanhamento de produtividade de times ágeis, considerando adaptabilidade e uma avaliação da utilidade de métricas de produtividade para esses times.

In an effort to increase both the quality of software applications and the efficiency with which applications can be written, developers often incorporate multiple programming languages into software projects. Although language specialization arguably introduces benefits, the total impact of the resulting language fragmentation (working concurrently in multiple programming languages) on developer performance is unclear. For instance, developers may solve problems more efficiently when they have multiple language paradigms at their disposal. However, the overhead of maintaining efficiency in more than one language may outweigh those benefits. This thesis represents a first step toward understanding the relationship between language fragmentation and programmer productivity. We address that relationship within two different contexts: 1) the individual developer, and 2) the overall project. Using a data-centered approach, we 1) develop metrics for measuring productivity and language fragmentation, 2) select data suitable for calculating the needed metrics, 3) develop and validate statistical models that isolate the correlation between language fragmentation and individual programmer productivity, 4) develop additional methods to mitigate threats to validity within the developer context, and 5) explore limitations that need to be addressed in future work for effective analysis of language fragmentation within the project context using the SourceForge data set. Finally, we demonstrate that within the open source software development community, SourceForge, language fragmentation is negatively correlated with individual programmer productivity.

Integrated development environment products, called CASE technology by practitioners, are being purchased by enterprises to assist systems analysts with the analysis and design of information systems. This work surveys users of a commercially available CASE product. Ninty-one users from 47 enterprises in the U.S. and Canada responded to the personal computer based survey. This work analyses the perceptions of the respondents in an attempt to determine productivity improvement over manual methods. Using the perceptions of the respondents, the component parts of the CASE product were rank ordered in terms of improved productivity. In addition to this, a psychometric preference scaling method was used to interpret the relatedness of the component parts to each other, again based on the perceptions of the respondents.

Context: Planning in software projects is a difficult problem due to the uncertainty associated with it. There are many factors that cause difficulty in formulating a plan. Not many factors that influence the efficiency of planning are identified in the previous studies. The literature focuses only on technical aspects such as requirements selection and estimation in order to plan a release or iteration. Objectives. The objective of this study is to identify factors that affect planning efficiency. The context in which the objective is achieved is large scale complex projects that are distributed across multiple teams, in multiple global sites. The motivation for selecting large scale context is because most of the existing releases planning approaches discussed in the literature were investigated in small scale projects. Hence this context will allow studying the planning process in large scale industry. Methods. A case study was conducted at Siemens’ Development Centre in Bangalore, India. A total of 15 interviews were conducted to investigate the planning process adopted by Siemens. To achieve triangulation, process documents such as release planning documents are studied and direct observation of the planning meeting is performed. Therefore multiple sources are used to collect evidences. Results. The identified challenges are grouped into technical and non-technical category. In total 9 technical factors and 11 non-technical factors are identified. The identified factors are also classified based on the context in which they affect the planning. In addition 6 effects of the factors are identified and improvements perceived by the participants are discussed in this study.

With the advent of software-defined radio, many radio applications have and are currently being designed for FPGAs, due to their high performance and reconfigurability. Invariably, "legacy" waveforms, such as FM, will need to be supported in such systems. A challenge that comes with programming FPGAs is the increased design and implementation time over conventional software programming. In this thesis, three FM demodulator techniques are implemented and compared in an FPGA. Two techniques are found to have similar SNR performance while having very different FPGA implementation characteristics. Library based design is explored for demodulators to increase FPGA design productivity. A block library is created and verified by use in tested demodulator designs. Two design tools that aim to increase design productivity in FPGAs, Ogre and HMFlow, are also examined and used to implement FM demodulators in a PCM/FM receiver design. Ogre leverages the demodulator block library, along with accompanying metadata, to decrease design time significantly. Design performance is not sacrificed when using Ogre. HMFlow, which relies on finer-grained blocks, reuses block implementation data to speed up implementation of the full design. The implementation of the HMFlow demodulator design is sped up by 3x but, when compared with the standard flow, produces an implementation with a reduced maximum clock rate (about 1/2) and with slightly more resources (about 6%). When comparing Ogre with HMFlow, the coarser-grained blocks of Ogre provide a more efficient design experience than that of HMFlow.

Downloading software from a server usually takes a noticeable amount of time, that is, noticeable to the user who wants to run the program. However, this issue can be mitigated by the use of streaming software. Software steaming is a means by which software can begin execution even while transmission of the full software program may still be in progress. Therefore, the application load time (i.e., the amount of time from when an application is selected for download to when the application can be executed) observed by the user can be significantly reduced. Moreover, unneeded software components might not be downloaded to the device, lowering memory and bandwidth usages. As a result, resource utilization such as memory and bandwidth usage may also be more efficient. Using our streaming method, an embedded device can support a wide range of applications which can be run on demand. Software streaming also enables small memory footprint devices to run applications larger than the physical memory by using our memory management technique. In this dissertation, we present a streaming method we call block streaming to transmit stream-enabled applications, including stream-enabled file I/O. We implemented a tool to partition software into blocks which can be transmitted (streamed) to the embedded device. Our streaming method was implemented and simulated on an MBX860 board and on a hardware/software co-simulation platform in which we used the PowerPC architecture. We show a robotics application that, with our software streaming method, is able to meet its deadline. The application load time for this application also improves by a factor of more than 10X when compared to downloading the entire application before running it. The experimental results also show that our implementation improves file I/O operation latency; in our examples, the performance improves up to 55.83X when compared with direct download. Finally, we show a stream-enabled game application combined with stream-enabled file I/O for which the user can start playing the game 3.18X more quickly than using only the stream-enabled game program file alone.

Este trabalho tem como objetivo propor um modelo para a criação e organização de um processo fabril de produção de software. Para atingir este objetivo foram mapeadas 11 empresas de produção de software com características fabris, 6 brasileiras (o autor deste trabalho não possui uma autorização forma para divulgar o nome das empresas) e 5 estrangeiras (as japonesas Hitachi, Toshiba, NEC, Fujtsu e a americana SDC). Salienta-se que os dados utilizados neste trabalho sobre as empresas estrangeiras foram extraídos de CUSUMANO (1991). É importante salientar que todas as fábricas brasileiras que se propuseram a participar do estudo de caso possuem certificação de qualidade em processos comprovada (CMMI e/ou ISO). Após a apresentação dos casos é realizada uma comparação entre os processos fabris brasileiros e estrangeiros. Uma aderência do processo de produção de software mapeados nas empresas ao modelo proposto, também, é desenvolvida no trabalho. Por fim, 01 caso real apresentando o comportamento do modelo proposto na criação de um processo fabril, também, se caracteriza como um dos pontos a ser destacado.<br>This work has as objective to propose a model to create and to organize a production process with factory software characteristic. To reach this objective 11 software production companies were mapped, 6 Brazilian (the author of this work doesn\'t possess an authorization to publish the name of the companies) and 5 foreigners (Hitachi, Toshiba, NEC, Fujtsu and SDC). The data used in this work, on the foreign companies were extracted of CUSUMANO (1991). All the Brazilian factories that participate of this case study possess quality certification in processes (CMMI and/or ISO). After the presentation of the cases a comparison between the Brazilian factories and the foreigners\' factories is developed. An adherence of the software production process mapped in the companies to the proposed model, also, is showed in the work. A real case presenting the behavior of the model proposed in the creation software production process, also, is characterized in the text (12 cases in the total).

Context: Test-Driven development (TDD) is a software development approach where test cases are written before actual development of the code in iterative cycles. TDD has gained attention of many software practitioners during the last decade since it has suggested several benefits in the software development process. However, empirical evidence of its dominance in terms of internal code quality, external code quality and productivity is fairly limited. Objectives: The aim behind conducting this study is to explore what has been achieved so far in the field of Test-driven development. The study reports the benefits and limitation of TDD compared to TLD and the outcome variables in all the reported studies along with their measurement criteria. Additionally, an experiment is conducted to see the impact of Test-driven development (TDD) on internal code quality, external code quality and productivity compared to Test-Last development (TLD). Methods: In this study two research methodologies are used specifically systematic literature review according to Kitchenham guidelines and controlled pilot experiment. In systematic literature review number of article sources are considered and used, including Inspec, Compendex, ACM, IEEE Xplore, Science direct (Elsevier) and ISI web of science. A review protocol is created first to ensure the objectivity and repeatability of the whole process. Second, a controlled experiment is conducted with professional software developers to explore the assumed benefits of Test-Driven development (TDD) compared to Test-Last development (TLD). Results: 9 distinct categories related to Test-driven development (TDD) are found that are investigated and reported in the literature. All the reported experiments revealing very little or no difference in internal code quality, external code quality and productivity in Test-Driven development (TDD) over Test-Last development (TLD). However, results were found contradictory when research methods are taken into account because case studies tend to find more positive results in the favor Test-Driven development (TDD) compared to experiments possibly due to the fact that experiment are mostly conducted in artificially created software development environment and mostly with students as a test subjects. On the other hand, experimental results and statistical analysis show no statistically significant result in the favor TDD compared to TLD. All the values found related to number of acceptance test cases passed (Mann-Whitney U test Exact Sig. 0.185), McCabe’s Cyclomatic complexity (Mann-Whitney U test Exact Sig. 0.063), Branch coverage (Mann-Whitney U test Exact Sig. 0.212), Productivity in terms of number of lines of code per person hours (Independent sample Ttest Sig. 0.686), productivity in terms number of user stories implemented per person hours (Independent sample T-test Sig. 0.835) in experiment are statistically insignificant. However, static code analysis (Independent sample T-test Sig. 0.03) result was found statistically significant but due to the low statistical power of test it was not possible to reject the null hypothesis. The results of the survey revealed that the majority of developers in the experiment prefer TLD over TDD, given the lesser required level of learning curve as well as the minimum effort needed to understand and employ TLD compared to TDD Conclusion: Systematic literature review confirms that the reported benefits of TDD development compared to Test-Last development are very small. However, case studies tend to find more positive results in the favor of Test-Driven development (TDD) compared to Test-Last development (TLD). Similarly, experimental findings are also confirming the fact that TDD has small benefits over TLD. However, given the small effect size there is an indication that (Test-Driven development) TDD endorses less complex code compared to Test-Last development (TLD).<br>Systematic literature review confirms that the reported benefits of TDD development compared to Test-Last development are very small. However, case studies tend to find more positive results in the favor of Test-Driven development (TDD) compared to Test-Last development (TLD). Similarly, experimental findings are also confirming the fact that TDD has small benefits over TLD. However, given the small effect size there is an indication that (Test-Driven development) TDD endorses less complex code compared to Test-Last development (TLD).<br>hassanmunirr@hotmail.com, mm1844@gmail.com

Ensuring the health of a distributed system with frequent updates is complicated. Many tools exist to improve developers’ comprehension and productivity in this task, but room for improvement exists. Based on previous research within request flow comparison, we propose a system design for using distributed tracing data in the process of reviewing code changes. The design is evaluated from the perspective of system performance and developer productivity using a critical production system at a large software company. The results show that the design has minimal negative performance implications while providing a useful service to the developers. They also show a positive but statistically insignificant effect on productivity during the evaluation period. To a large extent, developers adopted the tool into their workflow to explore and improve system understanding. This use case deviates from the design target of providing a method to compare changes between software versions. We conclude that the design is successful, but more optimization of functionality and a higher rate of adoption would likely improve the effects the tool could have.<br>Att säkerställa stabilitet i ett distribuerat system med hög frekvens av uppdateringar är komplicerat. I dagsläget finns många verktyg som hjälper utvecklare i deras förståelse och produktivitet relaterat till den här typen av problem, dock finns fortfarande möjliga förbättringar. Baserat på tidigare forskning inom teknik för att jämföra protokollförfrågningsflöden mellan mjukvaruversioner så föreslår vi en systemdesign för ett nytt verktyg. Designen använder sig av data från distribuerad tracing för att förbättra arbetsflödet relaterat till kodgranskning. Designen utvärderas både prestanda och produktivitetsmässigt under utvecklingen av ett affärskritiskt produktionssystem på ett stort mjukvaruföretag. Resultaten visar att designen har mycket låg inverkan på prestandan av systemet där det införs, samtidigt som den tillhandahåller ett användbart verktyg till utvecklarna. Resultaten visar också på en positiv men statistiskt insignifikant effekt på utvecklarnas produktivitet. Utvecklarna använde primärt verktyget för att utforska och förbättra sin egen förståelse av systemet som helhet. Detta användningsområde avvek från det ursprungliga målet med designen, vilket var att tillhandahålla en tjänst för att jämföra mjukvaruversioner med varandra. Från resultaten drar vi slutsatsen att designen som helhet var lyckad, men mer optimering av funktionalitet och mer effektivt införande av verktyget i arbetsflödet hade troligtvis resulterat i större positiva effekter på organisationen.

Utvecklingen av mobila hybrid applikationer har ökat drastiskt under det senaste årtiondet. Med tanke på mångfalden i hur stora företag börjar investera i ramverk med support för utveckling av mobila hybrid applikationer (multiplattforms ramverk), ökar nödvändigheten av aktuella studier inom detta ämnesområde. Facebook och Google är två välkända företag som har utvecklat React-Native respektive Flutter. Dessa multiplattforms ramverk utvecklas kontinuerligt och skillnader uppstår inom teknologierna hos ramverken vilket gör nya studier mer lämpliga. Syftet med denna studie är att undersöka vilket ramverk som bidrar med bäst produktivitet för utvecklaren med tanke på bristen av studier inom ämnet. Specifikt har en fallstudie utförts där studiens frågeställningar har besvarats.   Respektive frågeställningarna blev uppdelade i tre delfrågeställningar där varje fråga fick angivna kriterier att följa i fallstudien och båda ramverken blev tilldelade poäng om tillhörande kriterium för varje fråga var uppfylld. I slutet av studien räknades ett medelvärde ut som tilldelades till båda ramverken. Resultaten visade att det finns små skillnader i form av dess bidrag med bäst produktivitet för utvecklaren.<br>The development of hybrid mobile applications has increased rapidly in the last decade. Considering the diversity in how big companies starts to invest in frameworks that supports hybrid application development (cross-platform framework), the necessity of contemporary studies in this subject increase. Facebook and Google are two well-known companies that have developed React-Native and Flutter, respectively. These cross-platform frameworks are continuously developing, and differences occur in their technologies which makes new studies even more appropriate. The purpose of this study is to investigate which of these two frameworks contribute the most for the developer’s productivity considering the lack of studies in this specific subject. Specifically, a case study has been conducted where the research questions were answered.     The two research questions were divided into three sub questions, respectively where each question was given criteria to follow in the case study and each framework were assigned points if the associated criterion for each question were met. In the end of the study a mean value was assigned to each framework. The results showed that there are small differences in terms of its contribution for the developer’s productivity.