Disrupting developer productivity one bot at a time

work of W. Edwards Deming has convinced industry that must first measure quality and then emphasise process to improve quality. In response to Deming's arguments and in light of perception that software industry is unable to produce quality products on schedule, and within budget, more software development organisations are now emphasising process measurement, monitoring, and assessment. This paper describes what is meant by software process and discusses an approach for its measurement and improvement. INTRODUCTION Unreliable software makes big news, from emergency services disasters to social security payment blunders. Improved software quality is essential to ensure reliable products and services, and gain customer satisfaction. While software development has existed for more than four decades, we failed so far to make as an industry and as an engineering discipline rather than craft. Developing reliable and usable software that is delivered on and within budget still represents difficult endeavour for many organisations. As role of software becomes increasingly critical for businesses as well as for human lives, problems caused by software products that are late, over budget, or that do not work, become magnified. If lives are lost or people inconvenienced due to incapable computer software, news media is there to make big stories. Organisations are realising that their fundamental problems is immaturity of their software process. Robert Lai (1993) proposes that process improvement is second maturity wave of software industry. He states that the first wave of software was developed using waterfall model in 1970's. Today we are Transactions on Information and Communications Technologies vol 8, © 1994 WIT Press, www.witpress.com, ISSN 1743-3517 216 Software Management in midst of second wave maturity movement as we attempt to formally define development process and best ways to continuously improve it (Lai 1993). Taking lead in this area has been Watts Humphrey (Humphrey 1989, 1990, 1991), and Software Engineering Institute (SEI) at Carnegie Mellon University. SEI started in 1986 to develop process maturity framework to help organisations appraise maturity of their software process, and to provide guidance for organisations to improve their software process capability. A brief description of framework was released in September 1987, including maturity questionnaire. SEI evolved model and questionnaire into 5 -Level Capability Maturity Model (CMM) in 1991. In February 1993, released CMM version 1.1 (Paulk et al 1993). This paper discusses software process and describes capability maturity model (CMM). It also shows how CMM can be used as basis to measure maturity of software process of an organisation and plan its improvement. SOFTWARE QUALITY AND PROCESS IMPROVEMENT In his book Quality is Free Phil Crosby states that: Quality is free. It is not gift, is free. What cost money are unqualify of things all actions that involve not doing jobs right first time (Crosby 1980). If such statement is true for many disciplines, is particularly true for evidence is abundant in number of software products which exceeded their budget, were produced late, failed to satisfy user requirements, and are full of bugs. demand for improved software quality is increasing to ensure reliable products and services. benefits of improved quality comes in form of reduction in failure costs. For software projects failure costs include (DTI 1992): • costs of correcting defects, both before and after delivery • overruns against and budget • unnecessary high maintenance costs • indirect costs which users incur due to poor quality software link between process maturity and software quality is expressed in premise that The quality of software system is governed by quality of process used to develop and maintain it. One stumbling block to improving software quality seems to be that not enough attention is paid to overall development process itself. While software professionals typically devote their to developing, testing or documenting software products, no one has prime responsibility for improving software process. Experience has shown that if Transactions on Information and Communications Technologies vol 8, © 1994 WIT Press, www.witpress.com, ISSN 1743-3517 Managing Systems 217 no one is working on software process, orderly improvement is unlikely. process certainly won't improve itself, rather, most likely, will deteriorate over time. Continuous improvement can occur only if process infrastructure is in place. Watts Humphrey argues in an early article published in Datamation, April 1989 that: Without work on process, there will be little or no progress in improving software. THE SOFTWARE PROCESS Adopting process view of software development represents revolutionary change in perspective. A process orientation to software development involves elements of structure, focus, measurement, ownership, skills, and supporting technology. In this section we investigate what is meant by software process. What Is Software Process According to Webster's dictionary, process is a system of operations in producing something .. series of actions, changes, or functions that achieve an end result. Chambers Concise Dictionary defines process as a series of actions or events .. sequence of operations or changes undergone. IEEE defines process as a sequence of steps performed for given purpose. In general business context, process is defined as a structured, measured set of activities designed to produce specified output for particular customer or market (Davenport 1993). These definitions put strong emphasis on HOW work is done, in contrast to product focus's emphasis on WHAT. Accordingly, process can be considered as a specific ordering of work activities across and place, with beginning, an end, and clearly identified inputs and outputs: structure for action. In this paper we will adopt following definitions quoted in (Humphrey 1990, Paulk et al 1993) are intended to encompass software throughout its life, which covers new development, enhancement, and repair. software process is The set of activities, methods, and practices used in production and evolution of software. software engineering process is The total set of software engineering activities needed to transform user's requirements into software. Transactions on Information and Communications Technologies vol 8, © 1994 WIT Press, www.witpress.com, ISSN 1743-3517 218 Software Management People and Software Process Software development is still people-intensive activity. Talented people are most important element in any software organisation. Even if you get best people available, if they do not follow common process, if everyone wrote in different programming languages, used different conventions, or didn't co-ordinate their design and code changes with their peers, results will be chaos. Successful software organisations have learned that even best professionals need structured and disciplined environment in which to do cooperative work. Software organisations that do not establish such disciplines condemn their people to endless hours of repetitively solving technically trivial problems. obvious fact is that attracting best people is vital, but is also essential to support them with an effectively managed software process. Technology and Software Process Another myth is widespread belief that some technologically advanced tool or method will provide magic answer to software crisis. This is not only wrong, but is dangerous. Organisations which jumped on bandwagon of CASE tools, and ended up in failure and wasted and effort have learned their lesson hard way. Just ask yourself before introducing technology: What do I want to automate? In absence of defined, practised, and managed process, introducing automation can lead to increased chaos. There are several factors which limit effective use of software technology: an illdefined process, inconsistent process implementation, and poor process management. Software technology cannot be fully effective until these problems have been properly addressed. Need for Defined Process If no effort is made to define and enhance software development process across whole organisation, each software development project latches on to its own tools, methods, and practices with little guidance available on how to use them. This ad hoc approach will not be sufficient to tackle task of developing complex software systems. goal of software process management is to enable organisations to produce software that meets cost, schedules, and quality objectives. principles are same that underpins statistical process control-principles that have been successfully used in controlling scientific experiments and in high -volume manufacturing operations. Statistical concepts have been found to be just as applicable to software development as they are to production of manufactured goods such as motor cars. Applying such concepts will only be possible if there is defined and managed process. Software Process Models Transactions on Information and Communications Technologies vol 8, © 1994 WIT Press, www.witpress.com, ISSN 1743-3517

Software evolution is an essential foundation in delivering technology that adapts to user needs and industry dynamics. In an era of rapid technological development, software evolution is not just a necessity, but a must to ensure long-term relevance. Developers are faced with major challenges in maintaining and improving software quality over time. This research aims to investigate the correlation between feature volatility and bug occurrence rate in software evolution, to understand the impact of dynamic feature changes on software quality and development process. The research method uses commit analysis on the dataset as a marker of bug presence, studying the complex relationship between feature volatility and bug occurrence rate to reveal the interplay in software development. Validated datasets are measured by metrics and correlations are measured by Pearson-product-moment analysis. This research found a strong relationship between feature volatility and bug occurrence rate, suggesting that an increase in feature changes correlates with an increase in bugs that impact software stability and quality. This research provides important insights into the correlation between feature volatility and bug occurrence rates, guiding developers and quality practitioners to develop more effective testing strategies in dynamic development environments.

With the increasing range of software development and applications, the scale of software development is becoming larger and larger. The larger software's scale is the more possible failed in the phase of design, development, and implementation in software. As a starting point to improve the management and development of software, this paper designs a service platform for data services - JCFXBL. JCFXBL is mainly used to solve two issues, one is the management of software development, and the other is the technology of software development. In combination with two the practical application cases based on JCFXBL, from software development, software design, project management, the article describes the role of JCFXBL platform in the “Project Management” and “systems integration projects”, and verifies that JCFXBL platform can reduce the complexity of software development, improve software quality and solve software development, management issues, by actual software development.

Gender issues have recently been discussed extensively with respect to the computing fields (Bair & McGrathe-Cohoon, 2005; Camp, 2002; Margolis & Fisher, 2002). One of the discussed issues is the “shrinking pipeline” phenomenon (Camp, 1997). Camp shows how, in addition to the shrinking of the pipeline upon transition from high school to graduate school, the pipeline has been shrinking also at the bachelor-degree level since 1983. She argues that since the number of women at the bachelor’s level affects the number of women at levels higher in the pipeline and in the job market, this phenomenon is of great concern. The shrinking pipeline is explained in various ways. Among other explanations, the image of the field as requiring long hours of programming is a dominant one. Here is an illustrative case. The April 3, 2003, edition of the Pittsburgh Post-Gazette Business News addressed the question of why more women are not involved in the tech fields.1 This question was discussed by a panel, assembled by the Pittsburgh Technology Council a week before the article was published, which included some of the region’s most successful women. Among other arguments, Robbin Steif, chief financial officer of Maya Design, said, “It might be an issue of self-selection—women might not be risk takers.” Then she added, “It might also have something to do with the work/family issue, because entrepreneurs work way more than 40 hours per week.” This article focuses on software development teams using one of the agile software development methods. A high quality of working software is the primary measure of progress; however, agile software development processes, in addition, promote a sustainable pace for all the individuals (developers and users) involved in the software development process,2 welcome requirement changes even in late stages of the development, and favor face-to-face communication. Based on our observations of agile software teams both in academia and in industry, we claim that such software development frameworks enable women to gain new and better positions in the hi-tech industry in general and in software development teams in particular. We view this article as an example of how diversity can be achieved in software teams. In our current research, we explore other dimensions by which diversity can be achieved in software teams, such as minorities and nationalities. The perspective and data that are presented in this article are part of our research about human aspects of software engineering, specifically our comprehensive research about cognitive and organizational aspects of agile software development methods both in the industry and academia (Dubinsky & Hazzan, 2004; Dubinsky, Talby, Hazzan, & Keren, in press; Hazzan & Dubinsky, 2003a, 2003b; Tomayko & Hazzan, 2004).q

Phase containment metrics for software quality improvement

We empirically examine the relationship between software design modularity and software quality in open source software (OSS) development projects. Conventional wisdom suggests that degree of software modularity affects software quality. An analysis of 203 software releases in 46 OSS projects hosted on SourceForge.net lends support for a more complex relationship between software modularity and software quality than conventional wisdom suggests. We find that software modularity is associated with reduced software complexity, an increased number of static software bugs, and a mixed relationship with the percentage of bugs closed. We do not find empirical evidence supporting any relationship between modularity and other measures of customer satisfaction. In addition to empirically testing the relationship between modularity and quality, we introduce new measures of software modularity and software quality. Implications are developed for the theory of modularity and the practice of software development.

Everybody On Board Stage 3 Meaningful Use in 2018

Software testing is an important process in software quality assurance(SQA). Software testing consumes the majority of the software developers' time and cost of all the phases of system development. An important problem in software testing is to determine whether a program has been tested enough with a testing criterion and when one could stop testing. On the other hand, software measurement is used to estimate the quality of a software. Complexity measures can be used to compare software quality and development cost. This paper proposes a new testing approach which choosing testing path based on path complexity. The process is to use a set of testing paths that satisfying all-uses testing criterion, and then choose the testing path with the most complexity to test. This process is continued until the program can be accepted. The proposed formula is used to determine if it is possible to stop testing before satisfying all-du-paths testing criterion. The main contribution of the paper is that software developers can choose a proper testing action with lower testing effort.

MARVEL is a kernel for software development environments that enacts a processing modeling notation, called the MARVEL Strategy Language (MSL). The software process is defined in MSL as a collection of modular strategies, where different (sets of these) strategies are appropriate for different tool suites, user roles, phases of the lifecycle, management policies, etc. Each strategy specifies a partial object-oriented data model and a partial rule-based process model. The strategies are supplemented by a collection of envelopes, each of which describes how to apply one or more of the external tools used during software development activities; this includes the mapping from the inputs/outputs of these tools and the MARVEL objectbase and the command lines to invoke these tools. Multiple MSL strategies are merged to obtain the full data and process models for enaction by the MARVEL kernel.Each software development activity is described in MSL by a rule specifying the precondition and multiple postconditions of the activity. Both preconditions and postconditions are written in a subset of the first order predicate logic, stylized to incorporate directives for efficient queries and updates. A precondition is a logical statement that must be true before the activity is initiated; a postcondition is a logical statement asserted to be true when the activity completes. Multiple mutually exclusive postconditions reflect the multiple possible results of many activities. An activity is typically a particular combination of software development tool, options specific to that tool, and typed arguments. The notion of activity could be extended to include loading a new set of strategies to take over at this point in the process, to support both nesting of hierarchical activities and successive activity phases.Enaction of an MSL process model is implemented by what we call opportunistic processing, consisting primarily of forward and backward chaining among the rules. When a user initiates an activity, MARVEL applies backward chaining to attempt to satisfy its precondition. If this is not possible, MARVEL could use the rules in the style of an expert system to explain the problem. Once an activity has completed, MARVEL asserts one of its postconditions and uses forward chaining to automatically carry out other activities whose results are presumed to be needed in the near future.We have designed two facilities for controlling this processing, to prevent runaway automation. Hints are additional MSL preconditions that affect automatic but not user-initiated invocation of tools. Implicit queries represent a reflective capacity to keep tabs on estimated costs of automatic behavior and request user confirmation when certain user-selected thresholds are reached.MARVEL version 2.10 was recently completed, an upgrade over the version 2.01 that was demonstrated at the 3rd PSDE conference in November 1988. This latest version of MARVEL adds an X11 windows graphical user interface and new subsystems called Marvelizer and Organ. Marvelizer is a tool for immigrating existing software systems from the Unix file system or (a restricted class of) existing software development environment into a MARVEL objectbase. Organ is a set of commands for reorganizing MARVEL objectbases as the project and/or system structure evolves. Marvelizer has been used to immigrate Marvel itself, including about 35,000 lines of C code, into a C/Marvel objectbase. We would like to use the C/Marvel set of MSL strategies, which support activities using the user's favorite editor, lint, cc, ar, ranlib, less (and soon rcs, dbx and mail), for our own further development of MARVEL. Both MARVEL and C/Marvel were in use during the Spring 1989 semester by students in my E6123y Programming Environments and Software Tools course (admittedly a captive audience).We have discovered several difficulties with the MARVEL paradigm that seem likely to apply at least partially to enaction of other notations for software process modeling. First, constructing and debugging a process model is hard. We have run into many unanticipated interactions among rules, particularly among those defined in different strategies that happen to be loaded into the MARVEL kernel at the same time. We are working on debugging facilities that will uncover all direct and transitive dependencies by constructing a graphical dataflow graph of the currently loaded rules. It is feasible for a user to enable and disable individual rules, both during debugging to see how that affects the dataflow among rules and also during operation because certain behavior is not currently desired. This would be dangerous, however, if done by a naive user: if rules were turned off and on at arbitrary points, it would be possible for MARVEL to get into what is an inconsistent state with respect to the full set of rules in such a way that automatic recovery is impossible.Similar difficulties seem likely to arise for any enactable process modeling paradigm. The following questions need to be answered: How does an implementor go about writing, testing and debugging a process model? For non-trivial processes, the model is likely to be very large and hence should be modularized. What is the appropriate style of interface among process model modules and how is it enforced? Is the process model visible to the users and, if so, how is it presented? If the users can modify the process model during enaction, how does this affect continuing the process? Should (can) consistency be enforced or should (can) inconsistencies be detected and repaired?Second, constructing envelopes is even harder. We currently use the Shell languages (e.g., CShell) as notations for defining envelopes. Writing the Shell scripts requires an intimate knowledge of both the tool and the mapping of the MARVEL objectbase onto the file system. Although there is no way to avoid the former, we hope to minimize the latter by developing a higher level envelope language that understands the MARVEL objectbase implementation so the envelope writer doesn't have to. However, this is currently a relatively low priority due to lack of manpower.Again, similar difficulties seem inevitable for other enaction mechanisms intended to work with external tools. The questions: Is it possible (or desirable) to support existing tools, particularly tools where retrofitting is impractical? If only new tools are supported, can a relatively simple standard interface be developed and published so these tools can be developed separately by vendors? Would such an interface pre-empt too many design decisions, or would it be feasible for vendors to upgrade their current products?Third, supporting multiple users is hardest of all. The current MARVEL kernel does not provide any facilities for concurrency control. It would be easy to add locking of the entire objectbase, but a more flexible transaction model is needed. We are working on a number of alternative models that we think are promising for incorporation into the MARVEL kernel. Commit-serializability introduces two new transaction operations, split-transaction and join-transaction, that manipulate in-progress transactions to support coordination among multiple users. Participant transactions (AKA participation domains) distinguishes participants in group software development tasks from observers, and relaxes serializability as viewed by participants to permit cooperation.It is essential for enactable process models to support coordination and cooperation among the members of software development teams. There are two sets of questions: First, what are appropriate processes for programming-in-the-many? This is itself an active area of research, and there is certainly no consensus. One opinion, voiced at the previous workshop, is that the community should not be enacting process models until we understand the processes we are modeling. An opposing opinion is that enaction gives the community the capability to experiment with different processes without prematurely making a full scale commitment to a particular process. Assuming agreement with the second view, what process modeling notations and enaction mechanisms can support a reasonable range of cooperative work facilities?The database and operating system communities have agreed on atomic and serializable transactions, which can be implemented using a wide variety of technologies, as the basis for data consistency, failure recovery and concurrency control across their traditional application areas. Can the software engineering community develop an equally all-encompassing “transaction” model? Or is there some characteristic of the software development process such that coordination and cooperation policies will always require special support on a case-by-case basis? If so, what does this say about enaction of process models in general?In summary, MARVEL is implemented and in limited use, it works in some cases, it doesn't work in others, it raises a lot of questions, and both we the MARVEL group and we the software engineering community have a lot more work to do.

Leveraging the abundant community resources, e.g. campus students, programming fans, software amateurs, is promising to be a flexible and effective approach for relieving the enterprise's IT resource shortage. However, the concern about confidential knowledge exposure makes most enterprises hesitate to outsource software development to community resources. Unlike the traditional legal protection mechanism that prevents community resources from exposing the already known confidential knowledge, this paper presents a proactive confidential knowledge protection technology, which prevents the community resources from learning the confidential knowledge in software development activities. First, the client is facilitated on identifying confidential knowledge involved in the software development activity. Then, the risky software design elements that might expose confidential knowledge are identified in both qualitative and quantitative way. Based on the identification result, a holistic proactive protection solution is presented by orchestrating task reservation, task pretending and task partition activities. Finally, the processed software development tasks are dispatched to community developers without worrying about the confidential knowledge exposure. The technology has been preliminarily validated in two community-based software development cases.

Assessing the evidence from the use of SPC in monitoring, predicting & improving software quality

Software projects are almost always team efforts and successful projects involve well-formed and well-composed teams. Past studies have revealed that personality contributes to effective team composition and, therefore, project success. Yet despite its importance, only a couple of empirical studies have quantitatively evaluated the impact of personality on software quality and team productivity. Our previous study was an effort in this direction. In that study, we proposed a metric called Team Homogeneity Index and evaluated its impact on software quality and team productivity for two phases (implementation and testing) of the software development life cycle. This study is a continuation of our previous work. In this study, we replicate our experiment on three different phases of software development life cycle (i.e. analysis and design, implementation, and testing). We also determine the weights for all five personality traits using input from the industry and propose an improved version of Team Homogeneity Index called Weighted Team Homogeneity Index. Finally, we conduct a comparative analysis of Team Homogeneity Index and Weighted Team Homogeneity Index to determine whether weights assigned to personality traits make any difference. Our findings reveal that weights do make a difference and Weighted Team Homogeneity Index is more strongly correlated than Team Homogeneity Index for almost all of the teams, especially those composed of practitioners, in the three different phases of Software Development Life Cycle.

Putting Requirements and Quality at the Core of Global Service Delivery: Current Efforts and Future Plans at Pace University

This research is to study the application software development of the distributed control system (DCS) in a manufacturing company named ABC (unreal name). The company delivered a DCS product including both hardware and software. Since the hardware is manufactured aboard, this research focuses only at the software development from the process of gathering the customer requirements to the software inspection test and product delivery. The developed application software is made-to-order and unique. The company provides different software according to the different needs of different customers. The writer has used the failure mode and effect analysis (FMEA) and the fault tree analysis (FTA) as quality tools for analysing the potential failure modes and their effects in the DCS project execution in a systematic way. From the study, the writer has discovered three major problems in the DCS project execution. These included (1) lack of procedures to control the project execution, (2) lack of the document and data control, and (3) technical problems. The result of these problems heavily affects to the DCS project execution. The company is unable to deliver the DCS to the customer on time for several projects and software bugs are also embedded to the delivered software product. These lead to the customer dissatisfaction and the company itself has made the profit much less than it was expected. The results of the analysis using the FMEA technique have leaded to the establishment of the quality assurance system for the DCS project execution which include checklists, standard document and prodedures, and the engineering database pool software (EDP). The EDP retains the useful engineering knowledge and the application software functions of the past DCS projects. The EDP is developed with the purpose to share and enhance engineering knowledge of engineers and to reuse the past application software functions so that engineers do not have to redesign the customer requested functions which have already been created before. The established quality assurance system has been implemented to one DCS project in the company and the results were the improvement in software quality and on-time delivery. 37 software errors were detected during the pre-inspection test and there were only 8 errors during the inspection test with the customer, comparing to the average of 50 to 60 errors found during the inspection test in the past projects. In the view of changes in RPN (Risk Priority Number), the percentage of RPN for each critical process of the project execution comparing between before and after implementation decreased 33 to 94%.

Software development is a multidisciplinary collaboration involving many stakeholders. However, existing software development processes exhibit many issues related to that collaboration. Because prior research on stakeholder analysis and teamwork revealed the importance of communication, this study analyzed stakeholder communication with reference to team activities as a social and cognitive process. The study’s goal was to understand the collaboration process during software development and to delineate factors that influence this process. We focused on communication between the software developers and their clients during the requirements gathering phase, the team process, and the inter-team and interdisciplinary collaboration, in particular between software engineers and technical communicators. First, we conducted observations to help uncover the causes of variances in collaboration performance. Then we modified aspects of the collaboration process and compared team performance. We also performed an experimental study to further test the supporting effect of clients’ documents on requirement gathering. Finally, teams’ working structures and their impact on team performance were investigated using social network analysis. Among our findings was that clients are critical to the success of software development. Providing teams with documents that support requirement gathering facilitates team efficiency, but there is a trade-off in that team members may generate fewer creative ideas. Another finding was that software teams should ensure that members from all disciplines actively participate in projects. Finally, although teams need leadership, effective leadership is not a strong team member performing all coordination and tasks. A moderately centralized team structure is preferred.