waashk/dblp huggingface dataset:
continous execution: the visiprog environment. to date, program development environments have been static rather than dynamic. even emerging interactive, integrated program development environments, like the cornell program synthesizer, view program editing and execution as essentially independent activities. we envision an even more dynamic environment in which the functionality (input/output relationship) of a network of programs, an individual program, or a program segment can be viewed &ldquo;continuously&rdquo; with editing changes to either the program input or program body. this is the visicalc concept extended to program development environments (visiprog). in this paper, this &ldquo;dynamic&rdquo; approach to program development, testing and debugging is addressed, and considerations for the user interface are discussed. the latter includes a workstation with a flexible windowing system, three-dimensional views of programs, insertion of program control and observation points, and dynamic program slicing for &ldquo;viewing&rdquo; program execution. an existing prototype and current development activities are also discussed.
a tool for writing and debugging algebraic specifications. despite their benefits, programmers rarely use formalspecifications, because they are difficult to write and theyrequire an up front investment in time. to address these issues,we present a tool that helps programmers write anddebug algebraic specifications. given an algebraic specification, our tool instantiates a prototype that can be used just like any regular java class. the tool can also modifyan existing application to use the prototype generatedby the interpreter instead of a hand-coded implementation.the tool improves the usability of algebraic specificationsin the following ways: (i) a programmer can "run" an algebraicspecification to study its behavior. the tool reportsin which way a specification is incomplete for a client application.(ii) the tool can check whether a specification anda hand-coded implementation behave the same for a particularrun of a client application. (iii) a prototype can beused when a hand-coded implementation is not yet available.two case studies demonstrate how to use the tool.
catchup!: capturing and replaying refactorings to support api evolution. library developers who have to evolve a library to accommodate changing requirements often face a dilemma: either they implement a clean, efficient solution but risk breaking client code, or they maintain compatibility with client code, but pay with increased design complexity and thus higher maintenance costs over time.we address this dilemma by presenting a lightweight approach for evolving application programming interfaces (apis), which does not depend on version control or configuration management systems. instead, we capture api refactoring actions as a developer evolves an api. users of the api can then replay the refactorings to bring their client software components up to date.we present catchup!, an implementation of our approach that captures and replays refactoring actions within an integrated development environment semi-automatically. our experiments suggest that our approach could be valuable in practice.
assessing a class of software tools. the roles and capabilities of ldra software testbeds and their appropriate environments have been described in a number of papers [1,2]. the way in which management uses the tools as elements of a controlled software development environment is described in [3]. the principal benefits of such use are that management has the assurance that software development standards are enforced, and has reliable information concerning project status. the explicit standards enforced by the use of these tools are described in detail in [2]. one class of these standards is that of test effectiveness, which is measured primarily through three test effectiveness metrics reinforced by a code auditing capability. this paper attempts to quantify the benefits of using such a software testbed in providing assurance of the absence of program errors. the attempt is made from two viewpoints, the theoretical and the experimental. the theoretical aspect is important because the practical use of a tool may fail to demonstrate that the tool can be a powerful detector of a class of errors simply because no errors of that type were present in the software sample validated. finally the paper attempts to summarise some of the experiences gained through the use of the tools over a twelve year period.
supporting the construction and evolution of component repositories. repositories must be designed to meet the evolving and dynamic needs of software development organizations. current software repository methods rely heavily on classification, which exacerbates acquisition and evolution problems by requiring costly classification and domain analysis efforts before a repository can be used effectively. this paper outlines an approach in which minimal initial structure is used to effectively find relevant software components while methods are employed to incrementally improve repository structures. the approach is demonstrated through peel, a tool to semi-automatically identify reusable components, and codefinder, a retrieval system that compensates for the lack of explicit knowledge structures through spreading activation retrieval and allows component representations to be incrementally improved while users are searching for information. the combination of these techniques yields a flexible software repository that minimizes up-front costs and improves its retrieval effectiveness as developers use it to find reusable software artifacts.
beyond computer science. computer science is necessary but not sufficient to understand and overcome the problems we face in software engineering. we need to understand not only the properties of the software itself, but also the limitations and competences humans bring to the engineering task. rather than rely on commonsense notions, we need a deep and nuanced view of human capabilities in order to determine how to enhance them. i discuss what i regard as promising examples of cognitive and organizational theories and propose research directions to develop new ways of representing run-time behavior and ways of thinking about project coordination. i conclude with observations on creating an interdisciplinary culture.
a systematic survey of cmm experience and results. the capability maturity model (cmm) for software has become very influential as a basis for software process improvement (spi). most of the evidence to date showing the results of these efforts has consisted of case studies. we present a systematic survey of organizations that have undertaken cmm-based spi to get more representative results. we found evidence that process maturity is in fact associated with better organizational performance, and that software process appraisals are viewed, in retrospect, as extremely valuable and accurate guides for the improvement effort. the path was not always smooth, however, and efforts generally took longer and cost more than expected. a number of factors that distinguished highly successful from unsuccessful efforts are identified. most of these factors are under management control, suggesting that a number of specific management decisions are likely to have a major impact on the success of the effort.
conceptual simplicity meets organizational complexity: case study of a corporate metrics program. a corporate-wide metrics program faces enormous and poorly understood challenges as its implementation spreads out from the centralized planning body across many organizational boundaries into the sites where the data collection actually occurs. this paper presents a case study of the implementation of one corporate-wide program, focusing particularly on the unexpected difficulties of collecting a small number of straightforward metrics. several mechanisms causing these difficulties are identified, including attenuated communication across organizational boundaries, inertia created by existing data collection systems, and the perceptions, expectations, and fears about how the data will be used. we describe how these factors influence the interpretation of the definitions of the measurements and influence the degree of conformance that is actually achieved. we conclude with lessons learned about both content and mechanisms to help in navigating the tricky waters of organizational dynamics in implementing a company-wide program
splitting the organization and integrating the code: conway's law revisited. it is widely acknowledged that coordination of large scale software development is an extremely difficult and persistent problem. since the structure of the code mirrors the structure of the organization, one might expect that splitting the organization across time zones, cultures, and (natural) languages would make it difficult to assemble the components. this paper presents a case study of what indeed turned out to be the most difficult part of a geographically distributed software project, i.e., integration. coordination problems were greatly exaggerated across sites, largely because of the breakdown of informal communication channels. the results imply that multi-site development can benefit to some extent from stable plans, processes, and specifications. the inherently unpredictable aspects of projects, however, require communication channels that can be invoked spontaneously, by developers, as needed. these results shed light on the problems and mechanisms underlying the coordination needs of development projects generally, be they co-located or distributed.
an empirical study of global software development: distance and speed. global software development is rapidly becoming the norm for technology companies. previous qualitative research suggests that multi-site development may increase development cycle time. we use both survey data and data from the source code change management system to model the extent of delay in a multi-site software development organization, and explore several possible mechanisms for this delay. we also measure differences in same-site and cross-site communication patterns, and analyze the relationship of these variables to delay. our results show that compared to same-site work, cross-site work takes much longer, and requires more people for work of equal size and complexity. we also report a strong relationship between delay in cross-site work and the degree to which remote colleagues are perceived to help out when workloads are heavy. we discuss implications of our findings for collaboration technology for distributed software development.
global software development at siemens: experience from nine projects. we report on the experiences of siemens corporation in nine globally-distributed software development projects. these projects represent a range of collaboration models, from co-development to outsourcing of components to outsourcing the software for an entire project. we report experience and lessons in issues of project management, division of labor, ongoing coordination of technical work, and communication. we include lessons learned, and conclude the paper with suggestions about important open research issues in this area.
analysis of error remediation expenditures during validation. approximately 200 errors were detected during the formal in-house validation of a real time communications system that provides for ship-to-shore communications via both conventional and satellite links. a cost equation was developed to assess the utilization of expenditures associated with validation. the components of this equation reflected the costs that are typically expended during validation, such as reporting, analysis, remediation, retesting, and general managerial over-head. the results of a parametric analysis of the cost equation with respect to error cause and system impact indicated a significant under utilization of resources expended for validation.
a perspective on software development. this paper retraces an evolution of thought on the key problems in producing software. the author's perspective is traced through an early emphasis on development tools and methodology to an emphasis on specifications and requirements to a broader emphasis on overall manageability. the evolving thought process is projected ahead and illustrated by some current efforts and activities. the paper concludes with a discussion of the approaches to further enhancing the development process and the author's view on which areas should be given the main attention.
towards systematic recycling of systems requirements. many (technical) systems are not developed from scratch but as an evolution of existing systems. consequently, a large portion of the system requirements employed can be recycled when building the next version of the product. usually, this recycling step is performed unsystematically, i.e. simply by copying and modifying complete requirements documents.in this paper, we present in a case study a lightweight requirements recycling approach which evolved from observations and concrete needs of projects at daimler-chrysler passenger car development. the basic idea of the approach is separation of model-dependent from model-independent requirements on the same level of abstraction. this notion is supported by document structures, criteria for identifying reusable requirements and tool support.the paper presents the core elements of the approach and provides observations and valuable experiences we made in the projects.
cost estimation of software intensive projects: a survey of current practices. the authors describe a survey conducted at the jet propulsion laboratory (jpl) to estimate software costs for software intensive projects in jpl's technical divisions. respondents to the survey described what techniques they use in estimating software costs and, in an experiment, each respondent estimated the size and cost of a specific piece of software described in a design document provided by the authors. it was found that the majority of the technical staff estimating software costs use informal analogy and high-level partitioning of requirements, and that no formal procedure exists for incorporating risk and uncertainty. the technical staff is significantly better at estimating effort than size. however, in both cases the variances are so large that there is a 30% probability that any one estimate can be more than 50% off
an approach to large-scale collection of application usage data over the internet. empirical evaluation of software systems in actual usage situations is critical in software engineering. prototyping, beta testing, and usability testing are widely used to refine system requirements, detect anomalous or unexpected system and user behavior, and to evaluate software usefulness and usability. the world wide web enables cheap, rapid, and large-scale distribution of software for evaluation purposes. however, current techniques for collecting usage data have not kept pace with the opportunities presented by web-based deployment. this paper presents an approach and prototype system that makes large-scale collection of usage data over the internet a practical possibility. a general framework for comparing software monitoring systems is presented and used to compare the proposed approach to existing techniques
an open framework for dynamic reconfiguration. dynamic reconfiguration techniques appear promisingfor building systems that have requirements for adaptabilityand/or high availability. current systems that supportdynamic reconfiguration tend to use a single, fixed, reconfiguration algorithm to manage the change process. furthermore, existing change management systems lack supportfor measuring the impact of reconfiguration on a runningsystem. in this paper, we introduce openrec, an openframework for managing dynamic reconfiguration which addressesthese drawbacks. using openrec, developers canobserve the costs, in terms of time and disturbance, associatedwith making a particular run-time change. in addition,openrec employs an extensible set of reconfiguration algorithmswhere one algorithm can be substituted for another.developers can thus make an informed decision as to whichalgorithm to use based on comparative analysis. finally,openrec is itself dynamically reconfigurable.
moving from a plan driven culture to agile development. plan driven cultures are characterized by a strong belief in the plannability and predictability of software development projects. the sei-cmm, software process improvement initiatives, and software metrics programs are some of the hallmarks of this school of thought. the more recent trend towards agile development places the emphasis on constantly adapting to a project's changing goals rather than on detailed upfront planning. the majority of reports from pracitioners of agile development are positive and confirm the advantages of this approach. however, moving from a plan driven culture to agile development is not easy. making the transition requires changes to many established practices and may even touch core values held by stakeholders. areas affected are requirements and change management, user involvement, willingness to take on responsibility, contract management, and the ability to live with many uncertainties. this talk looks at what it takes to make the transition and presents lessons learned from organizations and projects which have successfully completed the switch to agile development.
building systems from commercial components. the question of which design methods are appropriate for component-based development (cbd) is complicated by different understandings of the end objectives of cbd. a further complication is different understandings of what is meant by "component." these differences lead to entirely distinct classes of design problem. the aim of this tutorial is to, first, outline the different classes of design problem that span these differing interpretations of cbd, and, second, to outline the required methodological responses to these design problems.
software engineering: a keynote address. this paper argues that our recent progress in the development of a sound programming methodology should not lead us to ignore the more difficult aspects of engineering; and that in future we should pay more attention to the quality of our designs, and not just the accuracy of their implementation.
using ocl-queries for debugging c++. this demonstration will present a design and preliminary implementation of the ocl query-based debugger, oqbd, which is a tool to debug c++ programs using queries formulated in the object constraint language, ocl. we will illustrate how queries can be formulated to verify constraints such as class invariants and pre and post-conditions for member functions. the queries can be reused after code generation to verify the design contract, as part of the testing process, and to facilitate fault detection.
a system for automatic software evaluation. the production of consistently executable and dependable software demands a thoughtful systematic implementation&mdash;with clear documentation at each production stage. recognizing this, the data systems laboratory, at marshall space flight center, nasa, began a research effort to help discover and institute sound engineering principles into a methodology for the production of software. the design of this methodology is based upon five principal stages of software development: 1. feasibility: can software be written to solve the initial problem? 2. requirements/design: are software requirements and design clear, complete, traceable, and testable? 3. coding: is use being made of reliable high level coding practices? 4. testing: is testing sufficiently thorough to instill initial user confidence? 5. maintenance: has the software and its design been explicitly documented?
scm-10: tenth international workshop on software configuration management. new practices, new challenges, and new boundaries. with its tenth anniversary, the scm workshop series is &ldquo;leaving behind&rdquo; a long and successful past: although the tools, techniques, and processes developed over the last twenty years have proven to be extremely valuable, they are inadequate to address the rapidly changing practices that define the world of tomorrow. exemplified by component-based software development, open source, virtual enterprises, a ubiquitous use of xml, and the increasing dynamic nature of software, these new practices bring new challenges that necessitate dramatic changes to the field of cm.
configurable software architecture in support of configuration management and software deployment. in this research article we introduce the menage project. menage is based on the vision that the notion of software architecture, extended with the concept of versioning, can be used as an organizing abstraction for some of the activities in the software life cycle. in particular, we are investigating how two of those activities, namely configuration management and software deployment, can benefit from the availability of an explicit architectural representation that is enhanced with versioning capabilities.
a generic, peer-to-peer repository for distributed configuration management. distributed configuration management is intended to support the activities of projects that span multiple sites. nucm (network-unified configuration management) is a testbed that we are developing to help us explore the issues of distributed configuration management. nucm separates configuration management repositories (i.e. the stores for versions of artifacts) from configuration management policies (i.e. the procedures by which the versions are manipulated) by providing a generic model of a distributed repository and an associated programmatic interface. this paper describes the model and the interface, presents an initial repository distribution mechanism, and sketches how nucm can be used to implement two rather different configuration management policies, namely check-in/check-out and change sets.
a b.s. degree in informatics: contextualizing software engineering education. software engineering (se) is very different in focus from traditional computer science: it is not just about computers and software, but as much about the context in which they are used. this means we must teach about software and information, development and design, technical and social issues, while creating solutions as well as understanding and analyzing them. in effect, we must teach a discipline broader than se or cs alone for se education to be effective. at uc irvine, we designed and now offer a program doing just this -- a four-year b.s. degree in informatics. the major brings topics in se together with human-computer interaction, computer-supported collaborative work, social analysis, and management, along with other application disciplines. here, we discuss the philosophy behind the major, its structure, and the questions concerning se education that the new major raises.
david l. parnas symposium. david l. parnas is one of the grandmasters of software engineering. his academic research and industrial collaborations have exerted far-reaching influence on software design and development. his groundbreaking writings capture the essence of the innovations, controversies, challenges, and solutions of the software industry. together, they constitute the foundation for modern software theory and practice. this symposium is being held in recognition of parnas's work and in honour of his 60th birthday. it is an opportunity for everyone in the software engineering community to celebrate his contributions, and to think hard about where we are today and where we are going.