waashk/dblp huggingface dataset:
portfolio management of software development projects using cocomo ii. software development projects are subject to external and internal risks that cause delays, budget overrun and poor quality. portfolio management can be used to alleviate this problem, as it pools resources together and allows for resource sharing among projects. consequently, projects are more likely to succeed. however, portfolio management using only deadlines and the number of employees to improve probability of success is still confined. this paper proposes integrating portfolio management with cocomo ii that offers more management flexibility. managers can adjust other resources, such as tools, staff capability, communication support, etc. to improve the project's success. the proposed method can also be applied despite limited historical data and expert judgment. in addition, this paper introduces time constraints into portfolio management without assuming unrealistic linearity between effort and time.
osprey: a practical type system for validating dimensional unit correctness of c programs. misuse of measurement units is a common source of errors in scientific applications, but standard type systems do not prevent such errors. dimensional analysis in physics can be used to manually detect such errors in physical equations. it is, however, not feasible to perform such manual analysis for programs computing physical equations because of code complexity. in this paper, we present a type system to automatically detect potential errors involving measurement units. it is constraint-based: we model units as types and flow of units as constraints. however, standard type checking algorithms are not powerful enough to handle units because of their abelian group nature (e.g., being commutative, multiplicative, and associative). our system combines techniques such as type inference and gaussian elimination to overcome this problem. we have implemented osprey, a prototype of the system for c programs, and evaluated it on various test programs, including computational physics and mechanical engineering applications. osprey discovered unknown errors in mature code; it is precise with few false positives; it is also efficient and scales to large programs---we have successfully used it to analyze programs with hundreds of thousands of lines of code.
deriving specifications from requirements. specification-based software development makes software easier to validate and maintain. yet specifications of large systems are themselves large, making understanding and validation difficult. one cause for this problem is that specifications and requirements are kept distinct. this paper describes an approach to specification development in which the specification arises naturally through the requirements analysis process. the emerging specification is developed into a complete system description using formal transformations called high-level editing commands. automated support for this development process within the knowledge-based specification assistant will be described. this support involves applying high-level editing commands, assisting in the choice of editing commands, and tracking the effects of these commands.
an instrumented approach to improving software quality through formal technical review. formal technical review (ftr) is an essential component of all software quality assessment, assurance and improvement techniques. however, current ftr practice leads to significant expense, clerical overhead, group process obstacles, and research methodology problems. csrs is an instrumented, computer-supported cooperative work environment for formal technical review. csrs addresses problems in the practice of ftr by providing computer support for both the process and products of ftr. csrs also addresses problems in research on ftr through instrumentation supporting fine-grained, high quality data collection and analysis. this paper describes csrs, a computer-mediated review method called ftarm, and selected findings from their use to explore issues in formal technical review
beyond the personal software process: metrics collection and analysis for the differently disciplined. pedagogies such as the personal software process (psp) shift metrics definition, collection, and analysis from the organizational level to the individual level. while case study research indicates that the psp can provide software engineering students with empirical support for improving estimation and quality assurance, there is little evidence that many students continue to use the psp when no longer required to do so. our research suggests that this "psp adoption problem" may be due to two problems: the high overhead of psp-style metrics collection and analysis, and the requirement that psp users "context switch" between product development and process recording. this paper overviews our initial psp experiences, our first attempt to solve the psp adoption problem with the leap system, and our current approach called hackystat. this approach fully automates both data collection and analysis, which eliminates overhead and context switching. however, hackystat changes the kind of metrics data that is collected, and introduces new privacy-related adoption issues of its own.
proust: knowledge-based program understanding. this paper describes a program called proust which does on-line analysis and understanding of pascal written by novice programmers. proust takes as input a program and a nonalgorithmic description of the program requirements, and finds the most likely mapping between the requirements and the code. this mapping is in essence a reconstruction of the design and implementation steps that the programmer went through in writing the program. a knowledge base of programming plans and strategies, together with common bugs associated with them, is used in constructing this mapping. bugs are discovered in the process of relating plans to the code; proust can therefore give deep explanations of program bugs by relating the buggy code to its underlying intentions.
fault localization using visualization of test information. attempts to reduce the number of delivered faults in softwareare estimated to consume 50% to 80% of the developmentand maintenance effort [3]. among the tasks requiredto reduce the number of delivered faults, debugging is oneof the most time-consuming [2, 12], and locating the errorsis the most dif.cult component of this debugging task (e.g.,[13]). clearly, techniques that can reduce the time requiredto locate faults can have a signi.cant impact on the cost andquality of software development and maintenance.
visualization of test information to assist fault localization. one of the most expensive and time-consuming components of the debugging process is locating the errors or faults. to locate faults, developers must identify statements involved in failures and select suspicious statements that might contain faults. this paper presents a new technique that uses visualization to assist with these tasks. the technique uses color to visually map the participation of each program statement in the outcome of the execution of the program with a test suite, consisting of both passed and failed test cases. based on this visual mapping, a user can inspect the statements in the program, identify statements involved in failures, and locate potentially faulty statements. the paper also describes a prototype tool that implements our technique along with a set of empirical studies that use the tool for evaluation of the technique. the empirical studies show that, for the subject we studied, the technique can be effective in helping a user locate faults in a program.
task forces: distributed software for solving problems of substantial size. task is a 'high level' specification language for defining software that executes on distributed computers. software is in the form of task forces&mdash;collections of communicating parallel processes that cooperate to achieve a common goal. using the task language, a programmer specifies the interrelated components of his task force: modules exporting functions which are potentially executed in parallel, multiple data and code objects, and processes. the user may adapt the configuration of the task force to enhance performance, reliability, or the degree of distribution. in particular, data or processes may be replicated, data may be partitioned into multiple memory units, and physical resource allocations may be controlled.
formulabuilder: a tool for graph-based modelling and generation of formulae. in this paper we present the formulabuilder, a flexible tool for graph-based modelling and generation of formulae. the formulabuilder allows easy and intuitive creation of formulae by using basic components called formula building blocks (fbbs) and arranging them as graphs according to the syntactic structure of a formula. such a graph can then be validated and used to generate the corresponding formula on the basis of a specific syntax which is chosen from a list of syntaxes supported by the formulabuilder.an important application of the formulabuilder is the formal specification of properties that describe the requirements of a system. such property specifications are usually needed by verification tools like model checkers, that help software engineers to detect errors in a specified system. the formulabuilder allows users to model property specifications as formula graphs by using commonly-occurring specification patterns.
how to integrate usability into the software development process. usability is increasingly recognized as a quality attribute that one has to explicitly deal with during development. nevertheless, usability techniques, when applied, are decoupled from the software development process. the host of techniques offered by the hci (human-computer interaction) field make the task of selecting the most appropriate ones for a given project and organization a difficult task. project managers and developers aiming to integrate usability practices into their software process have to face important challenges, as the techniques are not described in the frame of a software process as it is understood in se (software engineering). even when hci experts (either in-house or from an external organization) are involved in the integration process, it is also a tough endeavour due to the strong differences in terminology and overall approach to software development between hci and se. in this tutorial we will present, from a se viewpoint, which usability techniques can be most valuable to development teams with little or no previous usability experience, how a particular set of techniques can be selected according to the specific characteristics of the organization and project, and how usability techniques match with the activity groups in the development process.
sound methods and effective tools for model-based security engineering with uml. developing security-critical systems is difficult and there are many well-known examples of security weaknesses exploited in practice. thus a sound methodology supporting secure systems development is urgently needed.we present an extensible verification framework for verifying uml models for security requirements. in particular, it includes various plugins performing different security analyses on models of the security extension umlsec of uml. here, we concentrate on an automated theorem prover binding to verify security properties of umlsec models which make use of cryptography (such as cryptographic protocols). the work aims to contribute towards usage of uml for secure systems development in practice by offering automated analysis routines connected to popular case tools. we present an example of such an application where our approach found and corrected several serious design flaws in an industrial biometric authentication system.
tools for model-based security engineering. we present tool-support for checking uml models and c code against security requirements. a framework supports implementing verification routines, based on xmi output of the diagrams from uml case tools, and on control flow generated from the c code. the tool also supports weaving security aspects into the code generated from the models. advanced users can use this open-source framework to implement verification routines for the constraints of self-defined security requirements. we focus on a verification routine that automatically verifies crypto-based software for security requirements by using automated theorem provers.
a validation of software metrics using many metrics and two resources. in this paper are presented the results of a study in which several production software systems are analyzed using ten software metrics. the ten metrics include both measures of code details, measures of structure, and combinations of these two. historical data recording the number of errors and the coding time of each component are used as objective measures of resource expenditure of each component. the metrics are validated by showing: (1) the metrics singly and in combination are useful indicators of those components which require the most resources, (2) clear patterns between the metrics and the resources expended are visible when both resources are accounted for, (3) measures of structure are as valuable in examining software systems as measures of code details, and (4) the choice of which, or how many, software metrics to employ in practice is suggested by measures of &ldquo;yield&rdquo; and &ldquo;coverage&rdquo;.
how to identify binary relations for domain models. many approaches to requirements engineering include building a model of the domain. those using entity relationship modeling or deriving from it employ the concept of relations between entities, but identifying the relations is still more of an art than science or engineering. we deal with this problem primarily in the context of object oriented analysis (ooa), where relations between object classes are to be identified. our new approach uses natural language definitions of object classes and looks for names of other object classes in these definitions, since such a reference indicates a relation. based on this idea, we identify most binary relations for domain models in a new way. we also provide tool support for this method, which shows that a high degree of automation is possible. both a case study using the well known atm (automated teller machine) example and real world experience with our approach suggest its usefulness.
an architecture for intelligent assistance in software development. we define an architecture for a software engineering environment that behaves as an intelligent assistant. our architecture consists of three key aspects: an objectbase, a model of the software development activities, and controlled automation. our objectbase is adapted from other research, but our model is unique in that is consists primarily of rules that define the preconditions and multiple postconditions of software development activities. our most significant contribution is opportunistic processing, whereby the environment performs software development activities through controlled automation. this is accomplished by a forward and backward chaining interpretation of the rule set. activities are automatically carried out at some time between when their preconditions are satisfied and when their postconditions are required. automation is controlled through strategies that guide the assistant in choosing an appropriate point for carrying out each activity.
a bi-level language for software process modeling. the authors present a multi-user implementation of a bi-level process modeling language (pml). most process modeling formalisms are well-suited to one of two levels of specification, but not both. some concentrate on global control flow and synchronization. these languages make it easy to define the broad outline of a process, but harder to refine the process by expressing constraints and policies on individual tools and data. other process formalisms are inherently local. it is easy to define constraints, but far from straightforward to express control flow. combining global and local formalisms is proposed to produce bi-level formalisms suitable for expressing the enacting large scale processes. the new pml is called the activity structures language. the activity structures language integrates global constrained expressions with local rules. its implementation on top of the marvel rule-based environment is described
a conceptual model of software maintenance. four distinct maintenance systems are studied and synthesised: the sei quality framework and three industrial systems belonging to abb, ellemtel, and ericsson. the goal is to validate the sei framework, and to build a &ldquo;state of the practice&rdquo; conceptual model of the most fundamental software maintenance concepts. this model can help understand the underlying conditions for managing software maintenance. it can provide guidance to organisations in the process of building or improving their maintenance systems. it also constitutes a common basis for communication, for reasoning about software quality, and for building quality and maintenance models
corrective maintenance maturity model (cm): maintainer's education and training. what is the point of improving maintenance processes if the most important asset, people, is not properly utilised? knowledge of the product(s) maintained, maintenance processes and communications skills is very important for achieving quality software and for improving maintenance and development processes. in this paper, we present cm3: maintainer's education and training &mdash; a maturity model for educating and training maintenance engineers. this model is the result of a comparative study of two industrial processes utilised at abb, and of process models such as ieee 1219, iso/iec 12207, cmm, people cmm, and tickit.
maintenance support tools for java programs: ccfinder and jaat. this paper describes a maintenance support tools, ccfinder and jaat, for java programs. ccfinder identifies code clones in java program. jaat executes alias analysis for java program.
parametric analysis of real-time embedded systems with abstract approximation interpretation. my research area is fundamental of formal analysis ofreal-time embedded systems. the main objective of thisresearch is the theoretical and practical development of averification algorithm for the formal analysis of real-timeembedded systems based on the combination of real-timemodel checking and abstract interpretation of real-timemodels. the objective of the proposed combination is animproved behavior both in time and space requirement ofthe resulting algorithm. one of drawbacks of all currentreal-time model-checking tools is the limited size of thesystems that can be analyzed. by combination of state-spaceexploration with abstract interpretation we expectto scale up the size of applications
daily build and feature development in large distributed projects. daily build is a software development paradigm that originated in the pc industry to get control of the development process, while still allowing the focus on end user requirements and code. the pc industry used daily build to avoid chaos in increasingly larger applications in an environment without a strong development process. ericsson radio systems has chosen to implement daily build to increase the focus on end user requirements and code, but from a different starting point with a traditionally strong development process. in this article we discuss our experiences with daily build and feature oriented development in this context. we also relate our experience to the concept of extreme programming, arguing that our ideas can help extend the applicability of extreme programming beyond small co-located projects.
verification of fairness in an implementation of monitors. an implementation in pascal by saxena and bredt of the monitor construct is studied. techniques are given for using a program verifer to analyse the conditions under which the implementation is fair (i.e. once a process is delayed it eventually will be continued). by use of a virtual data structure, fairness is represented in terms of simple properties which can be verified automatically. examples are given illustrating how the verification can force unstated assumptions upon which the implementation depends to be made explicit, and how it can be used to study whether the implementation makes adequate use of resources. the development of techniques for analysis of such implementations is required before the correctness of high-level language operating systems such as brinch hansen's solo can be completely established.
a flexible approach to alliances of complex applications. complex distributed environments contain thousands of workstations that can run hundreds of applications. multiple networks are used to connect the workstations to dozens of behind-the-scenes servers, all of which are necessary for the user to perform even simple tasks. such distributed environments are difficult to design and maintain, and current software engineering practices are not well adapted to deal with this inherent complexity. this paper describes the single glass project in the boeing commercial airplane group. single glass expands the number of both internally developed and commercial-off-the-shelf applications a single user can access from any workstation. the result is in production use by over 6,000 people in both puget sound and wichita. the key to success is a flexible and scaleable architecture that works within a complex, heterogeneous application and delivery system environment. our work has focused on both computing technology (software and delivery systems) and general processes (primary technology, support, and organization). agreements on both technology and process improvements are essential to project success. single glass is a work in progress, and we describe areas that require additional investigation. our experience indicates that most technical problems can be addressed. however, significant improvement is needed in software engineering processes and practices to design and build applications and systems that can be tested, delivered, supported, and diagnosed when made available alongside other, independently developed applications and systems.
hfp: a hierarchical and functional programming based on attribute grammar. a hierarchical and functional programming based on attribute grammar is presented. in this approach, programs are hierarchically decomposed into modules and each module is characterized by its inputs and outputs. a set of equations is associated with each decomposition, which specifies relationship between inputs and outputs of modules that participate in the decomposition. after giving formalisms and examples, an algorithm is described which transforms a program specification in our approach into a procedural type program and optimizations that should be applied to the generated program is discussed.
towards increasing the compatibility of student pair programmers. as pair programming is used widely in software engineering education, instructors may wish to proactively form pairs to increase the likelihood of compatible pairs. a study involving 361 software engineering students was carried out at north carolina state university to understand and predict pair compatibility. we have found that students are compatible with partners whom they perceive of similar skill, although instructors cannot proactively manage this perception. pairing of two minority students is more likely and mixed gender pairs are less likely to be compatible. additionally, pairing of students with similar actual skill level as measured by midterm grades in class, gpa, and sat/gre scores also likely results in compatible pairs. our research addresses the following challenges faced by instructors in software engineering: 1) organizational concern in pairing of students; 2) increasing the retention rates of female and minority students in classes; and 3) proactively forming mutually-compatible pairs.