waashk/dblp huggingface dataset:
a user interface for online assistance. this paper describes a software user interface that enables programmers to provide and maintain online aids in an interactive system. through the interface, users are given a set of consistent and unobtrusive aids that display summary information, command descriptions, explanations of error messages, and other online documentation. the interface is presented here from the views of both the end-user and the programmer.
prediction and management of program quality. techniques such as design reviews, code inspections, and system testing are commonly being used to remove defects from programs as early as possible in the development process. the objective of this paper is to demonstrate that predictors can be devised which tell us how well defects are being removed during the defect removal process. the approach is to develop a straightforward model of the defect removal process, and then use that model to develop formulas that show how measurable parameters&mdash;such as the ratio of major problems (mps) removed by reviews and inspections to the number of problems (ptms) removed by testing and the length (l) of an average problem fix&mdash;can be used to estimate: - effectiveness of the overall defect removal process - number of defects that remain at the time the product is first shipped to customers. on the bases of statistics for current products, numerical values for effectiveness measures can then be calculated.
chianti: a change impact analysis tool for java programs. chianti is a change impact analysis tool for java that is implemented in the context of the eclipse environment. chianti analyzes two versions of a java program, decomposes their difference into a set of atomic changes, and a partial order inter-dependences of these changes is calculated. change impact is then reported in terms of affected (regression or unit) tests whose execution behavior may have been modified by the applied changes. for each affected test, chianti also determines a set of affecting changes that were responsible for the test's modified behavior. this latter step of isolating failure inducing changes for one specific test from irrelevant changes can be used as a debugging technique in situations where a test fails unexpectedly after a long editing session.
systems engineering: an essential engineering discipline for the 21st century. the engineering of systems in the 21st century demands robust use of the systems approach given the nature of our times, as well as the systems being created. the global marketplace, changing competition dynamics, shorter life cycles, and increasing complexity characterize our environment. we are building systems that are much larger than ever before. and, we are building systems that are infinitely smaller than ever before. maturity of technical, management, and infrastructure processes are competitive discriminators. systems engineering, both as a profession and as practiced by multi-discipline practitioners, is key to addressing these challenges.over the past decade, there have been frequent debates on whether systems engineering is an approach or a formal field of engineering. given the technical, management, and environmental challenges of this century, i believe that systems engineering must be an essential engineering discipline for the 21st century. this talk will discuss the state of the art and practice of systems engineering, and several initiatives focused on its evolution as a formal engineering discipline.while systems engineering approaches date back to ancient times, the recent few decades have largely featured practices and methods that extend from efforts of the 1950's, thus drawing heavily from hardware engineering. as software engineering has grown as a discipline, it has had significant influence on the field of systems engineering. further, as systems engineering becomes a more integral part of commercial product development, the character of the systems engineering discipline expands and the associated research agenda takes new shape. systems engineering and software engineering must each evolve as unique engineering disciplines to address the engineering problems of the 21st century. we must ensure their evolution results in shared knowledge, and highly collaborative approaches and methods drawing on the unique strengths of each discipline.
analysis and testing of web applications. the economic relevance of web applications increases the importance of controlling and improving their quality. moreover, the new available technologies for their development allow the insertion of sophisticated functions, but often leave the developers responsible for their organization and evolution. as a consequence, a high demand is emerging for methodologies and tools for quality assurance of web based systems. in this paper, a uml model of web applications is proposed for their high level representation. such a model is the starting point for several analyses, which can help in the assessment of the static site structure. moreover, it drives web application testing, in that it can be exploited to define white box testing criteria and to semi-automatically generate the associated test cases. the proposed techniques were applied to several real world web applications. results suggest that an automatic support to the verification and validation activities can be extremely beneficial. in fact, it guarantees that all paths in the site which satisfy a selected criterion are properly exercised before delivery. the high level of automation that is achieved in test case generation and execution increases the number of tests that are conducted and simplifies the regression checks.
the inspection metho applied to small projects. the inspection method is a quality-control for written material. it is used on large projects and takes 3 to 8 persons for correct use. this excludes small projects with less than three persons from proper inspection. this paper shows how the personnel restriction may be circumvented in small projects. an example of inspection in a small project (writing a report) is given.
a partition analysis method to increase program reliability. a major drawback of most program testing methods is that they ignore program specifications, and instead base their analysis solely on the information provided in the implementation. this paper describes the partition analysis method, which assists in program testing and verification by evaluating information from both a specification and an implementation. this method employs symbolic evaluation techniques to partition the set of input data into procedure subdomains so that the elements of each subdomain are treated uniformly by the specification and processed uniformly by the implementation. the partition divides the procedure domain into more manageable units. information related to each subdomain is used to guide in the selection of test data and to verify consistency between the specification and the implementation. moreover, the test data selection process, called partition analysis testing, and the verification process, called partition analysis verification, are used to enhance each other, and thus increase program reliability.
on reliable topologies for computer networks. a computer communiation network is topologically described as a linear graph. network topologies are characterized by their associated reliability (invulnerability), overall link capacity (bandwidth) and maximal average message terminal delay. the corresponding graph theoretical parameters are the connectivity, number of lines and diameter of the underlying graph. for store-and-forward computer networks, k-connected topologies yielding the minimal delay-capacity product values are presented. such structures are noted to have a node of very high degree (i.e., connected to many other nodes). subsequently, we consider k-connected networks with regular nodes (of low degree) containing also a set of &ldquo;advanced&rdquo; (&ldquo;central&rdquo;) nodes (of higher, though appropriately bounded) degree. corresponding extremal k-connected topologies which guarantee every regular node to be within a prescribed distance from the center (being the set of central nodes), and to include a minimal center size, are derived. the optimal radius values for such network structures, to yield a minimal delay-capacity product value, are also noted.
a context-oriented framework for software testing in pervasive environment. in this article, we present our test framework for assuring pervasive software applications that overcomes the identified challenges faced by conventional testing techniques. the framework will serve as a basis for automating the test process, as well as to assist testers in generating adequacy test sets or finding test oracles.
distributed development: an education perspective on the global studio project. the global studio project integrated the work of software engineering students spread across four countries into a single project and represented, for most of the students, their first major "real-world" development experience. interviews indicated that the major areas of learning were informal skills that included learning to establish and work effectively within a team, learning how to react quickly to frequent changes in requirements, architecture and organization, and learning to manage and optimize communications. since all these skills require rapid reaction to unpredictable factors, we view them as improvisation and discuss the role of experiential education in facilitating improvisation.
embedded architect: a tool for early performance evaluation of embedded software. embedded architect is a design automation tool that embodies a static performance evaluation technique to support early, architecture-level design space exploration for component-based embedded systems. a static control flow characterization, called an evaluation scenario, is specified based on an incremental refinement of software source code, from which a pseudo-trace of operations is generated. in combination with architecture mapping and several component parameters, a software performance metric is estimated.the novel contribution is the implementation of a tool that automates specification of an evaluation scenario, which sets the context for a rapid performance evaluation of distinct candidate architectures.
improving the software process. needs and possibilities for software processes are constantly changing, and improvement is therefore a continual process. part of the task of software process improvement is the comparative evaluation of alternatives with the intent of deciding whether to shift to a new process or keep/adjust an existing one. an equally important task is to constantly increase the flexibility to adapt a software process to meet new project-related or organizational needs or utilize new technology.the intent of this panel is to expose, compare and contrast a variety of strategies and tactics for improving the software process. the assumption is that no single strategy or set of tactics will ever be best in all situations. to set the stage, the strategy and tactics discussed in the paper &ldquo;tailoring the software process to project goals and environments,&rdquo; by basili and rombach, will be presented. the panelists, each of whom has a direct responsibility for software technology improvement, will then briefly present the approaches they are using to guide software process improvement. the ensuing discussion is intended to uncover critical differences and similarities and lead to an understanding of the contexts in which the various approaches can succeed.
designing software for use by humans, not machines. the authors describe an architecture that supports a more user-centered way to design software applications architectures, and by using a specific example, they also describe benefits gained by the software applications that result. the architecture aims to resolve some management and maintenance problems which have arisen in the telecommunications support systems network specifically, but which the authors also envision arising in any large-scale, multivendor, database environment. this examination includes consideration of technological advances in user-centered design, recent discoveries about the ability to separate processing functionalityfrom user interface functionality, and the rapidly expanding wealth of available user interface software tools
experimental program analysis: a new paradigm for program analysis. program analysis techniques are used by software engineers to deduce and infer targeted characteristics of software systems for tasks such as testing, debugging, maintenance, and program comprehension. recently, some program analysis techniques have been designed to leverage characteristics of traditional experimentation in order to analyze software systems. we believe that the use of experimentation for program analysis constitutes a new program analysis paradigm: experimental program analysis. this research seeks to accomplish four goals: to precisely define experimental program analysis, to provide a means for classifying experimental program analysis techniques, to identify existing experimental program analysis techniques in the research literature, and to enhance the use of experimental program analysis by improving existing, and by creating new, experimental program analysis techniques.
behavior modelling during software design. a modeling scheme is presented which provides a medium for the rigorous, formal, and abstract specification of large-scale software system components. the scheme allows the description of component behavior without revealing or requiring the description of a component's internal operation. both collections of sequential processes and the data objects which they share may be described. the scheme is of particular value during the early stages of software system design, when the system's modules are being delineated and their interactions designed, and when rigorous, well-defined specification of undesigned components allows formal and informal arguments concerning the design's correctness to be formulated.
an empirical study of fault localization for end-user programmers. end users develop more software than any other group of programmers, using software authoring devices such as e-mail filtering editors, by-demonstration macro builders, and spreadsheet environments. despite this, there has been little research on finding ways to help these programmers with the dependability of their software. we have been addressing this problem in several ways, one of which includes supporting end-user debugging activities through fault localization techniques. this paper presents the results of an empirical study conducted in an end-user programming environment to examine the impact of two separate factors in fault localization techniques that affect technique effectiveness. our results shed new insights into fault localization techniques for end-user programmers and the factors that affect them, with significant implications for the evaluation of those techniques.
when the project absolutely must get done: marrying the organization chart with the precedence diagram. very little is new in project planning, but this is! we present a technique to marry the organization chart with a project's task precedence diagram. this permits us to simulate the project at a micro, project-specific level never before achieved. we can perform &ldquo;what-if&rdquo; scenarios related to organization structures, the deployment of specific individuals and skills, and the structure of information flow and exception-handling in a project. the tool used, viteproject, was developed over the last ten years in a stanford university laboratory, where substantial results have been achieved when applied to design activities other than software. we present our real-world experience with several software projects, where it has improved project visibility and allowed us to rationally optimize projects in a way hitherto impossible.
visualizing software release histories with 3dsoftvis. this paper briefly introduces a 3-d visualization tool (3dsoftvis) that has been developed for the analysis of the evolution of an industrial software system.
using event-based translation to support dynamic protocol evolution. all systems built from distributed components involve theuse of one or more protocols for inter-component communication.whether these protocols are based on a broadlyused "standard" or are specially designed for a particularapplication, they are likely to evolve. the goal of the workdescribed here is to contribute techniques that can supportprotocol evolution. we are concerned not with how or whya protocol might evolve, or even whether that evolution isin some sense correct. rather, our concern is with making itpossible for applications to accommodate protocol changesdynamically. our approach is based on a method for isolatingthe syntactic details of a protocol from the semanticconcepts manipulated within components. protocol syntaxis formally specified in terms of tokens, message structures,and message sequences. event-based translation techniquesare used in a novel way to present to the application the semanticconcepts embodied by these syntactic elements. weillustrate our approach by showing how it would support anhttp 1.1 client interacting with an http 1.0 server.
software engineering and the internet. to successfully compete in the drive towards e-business, businesses are faced with challenges that strain their resources across all fronts. in their bid to win new market share, businesses must balance the necessity of new innovative products, released on ever shortening cycles, with the maintenance of their core business" a core that provides the capital leverage needed to fuel this new growth. businesses must succeed in these changes with a skills base that is, relative to the market requirements, diminishing. achieving equilibrium between demands that historically have been treated as dichotomous will require nothing less than a change in the very culture of the software engineering community. this change is evident, but how will we, as a the software community, be successful in effecting this change? successful modification of this culture begins with an understanding, at all levels, of the change in the skills pool and the exponential rise in the need for reliable, scalable systems that can accommodate millions of customers on ever more complex internet based e-business applications. while an increasing number of businesses deploy mission critical applications and begin to build e-market places on the internet, we need to be able to adapt our software engineering philosophy to create software in a more flexible enviromnent that focuses on delivering capability in a more time-critical fashion than we have been challenged to do in the past. the paradigm of designing to perfection must be scaled back to a model that facilitates progressive discovery for the growing population of programmers who are relatively new to the business. only when we can deliver flexible software to support the deployment of these new e-business applications will we succeed in supporting the drive to e-business.
concern graphs: finding and describing concerns using structural program dependencies. many maintenance tasks address concerns, or features, that are not well modularized in the source code comprising a system. existing approaches available to help software developers locate and manage scattered concerns use a representation based on lines of source code, complicating the analysis of the concerns. in this paper, we introduce the concern graph representation that abstracts the implementation details of a concern and makes explicit the relationships between different parts of the concern. the abstraction used in a concern graph has been designed to allow an obvious and inexpensive mapping back to the corresponding source code. to investigate the practical tradeoffs related to this approach, we have built the feature exploration and analysis tool (feat) that allows a developer to manipulate a concern representation extracted from a java system, and to analyze the relationships of that concern to the code base. we have used this tool to find and describe concerns related to software change tasks. we have performed case studies to evaluate the feasibility, usability, and scalability of the approach. our results indicate that concern graphs can be used to document a concern for change, that developers unfamiliar with concern graphs can use them effectively, and that the underlying technology scales to industrial-sized programs.
continuous testing in eclipse. continuous testing uses excess cycles on a developer's workstation to continuously run regression tests in the background, providing rapid feedback about test failures as code is edited. it reduces the time and energy required to keep code well-tested, and it prevents regression errors from persisting uncaught for long periods of time.
first international workshop on the modeling and analysis of concerns in software (macs 2005). many software engineering activities are organized around the idea of concerns. separation of concerns is a basic tenet of software engineering intended to facilitate the development and evolution of software systems. unfortunately, separation of concerns is not always possible in practice, and concerns often end up scattered and tangled. the goal of the macs workshop is to bring together researchers and practitioners with interest and experience in techniques for modeling and analyzing the realization of concerns in software systems.
specifying multithreaded java semantics for program verification. the java programming language supports multithreading where the threads interact among themselves via read/write of shared data. most current work on multithreaded java program verification assumes a model of execution that is based on interleaving of the operations of the individual threads. however, the java language specification (which any implementations of java multithreading must follow) supports a weaker model of execution, called the java memory model (jmm). the jmm allows certain reordering of operations within a thread and thus permits more behaviors than the interleaving based execution model. therefore, programs verified by assuming interleaved thread execution may not behave correctly for certain java multithreading implementations.the main difficulty with the jmm is that it is informally described in an abstract rule-based declarative style, which is unsuitable for formal verification. in this paper, we develop an equivalent formal executable specification of the jmm. our specification is operational and uses guarded commands. we then use this executable model to verify popular software construction idioms (commonly used program fragments/patterns) for multithreaded java. our prototype verifier tool detects a bug in the widely used "double-checked locking" idiom, which verifiers based on interleaving execution model cannot possibly detect.