waashk/dblp huggingface dataset:
principles of software evolution: 5 international workshop on principles of software evolution (iwpse 2002). we present an overview of the 5th international workshop on principles of software evolution (iwpse 2002).
web services engineering: promises and challenges. web services are emerging technologies to reuse software as services over the internet by wrapping underlying computing models with xml. web services are rapidly evolving and are expected to change the paradigms of both software development and use. this panel will discuss the current status and challenges of web services technologies.
software engineering challenges in bioinformatics. data from biological research is proliferating rapidlyand advanced data storage and analysis methods are requiredto manage it. we introduce the main sources of biologicaldata available and outline some of the domainspecific problems associated with automated analysis. we discuss two major areas in which we are likely experiencesoftware engineering challenges over the next ten years:data integration and presentation.
aspectual mixin layers: aspects and features in concert. feature-oriented programming (fop) decomposes complex software into features. features are main abstractions in design and implementation. they reflect user requirements and incrementally refine one another. although, features crosscut object-oriented architectures they fail to express all kinds of crosscutting concerns. this weakness is exactly the strength of aspects, the main abstraction mechanism of aspect-oriented programming (aop). in this article we contribute a systematic evaluation and comparison of both paradigms, aop and fop, with focus on incremental software development. it reveals that aspects and features are not competing concepts. in fact aop has several strengths to improve fop in order to implement crosscutting featuressymmetrically, the development model of fop can aid aop in implementing incremental designs. consequently, we propose the architectural integration of aspects and features in order to profit from both paradigms. we introduce aspectual mixin layers (amls), an implementation approach that realizes this symbiosis. a subsequent evaluation and a case study reveal that amls improve the crosscutting modularity of features as well as aspects become well integrated into incremental development style.
a framework for evaluating specification methods for reactive systems: experience report. numerous formal specification methods for reactive systems have been proposed in the literature. because the significant differences between the methods are hard to determine, choosing the best method for a particular application can be difficult. we have applied several different methods, including modechart, vfsm, esterel, basic lotos, z, sdl, and c, to an application problem encountered in the design of software for at&t's 5ess¯ telephone switching system. we have developed a set of criteria for evaluating and comparing the different specification methods. we argue that the evaluation of a method must take into account not only academic concerns, but also the maturity of the method, its compatibility with the existing software development process and system execution environment, and its suitability for the chosen application domain.
supporting the deployment of object-oriented frameworks. frameworks [4] are usually large and complex, and typically reusers need to understand them well enough to effectively use them. this research concentrates on verifying applications built on top of oo frameworks. the idea is to get framework builders to specify a set of constraints for the correct usage of the framework and check them using static analysis techniques.
efficient and precise dynamic impact analysis using execute-after sequences. as software evolves, impact analysis estimates the potential effects of changes, before or after they are made, by identifying which parts of the software may be affected by such changes. traditional impact-analysis techniques are based on static analysis and, due to their conservative assumptions, tend to identify most of the software as affected by the changes. more recently, researchers have begun to investigate dynamic impact-analysis techniques, which rely on dynamic, rather than static, information about software behavior. existing dynamic impact-analysis techniques are either very expensive---in terms of execution overhead or amount of dynamic information collected---or imprecise. in this paper, we present a new technique for dynamic impact analysis that is almost as efficient as the most efficient existing technique and is as precise as the most precise existing technique. the technique is based on a novel algorithm that collects (and analyzes) only the essential dynamic information required for the analysis. we discuss our technique, prove its correctness, and present a set of empirical studies in which we compare our new technique with two existing techniques, in terms of performance and precision.
on the uniformity of software evolution patterns. preparations for y2k reminded the software engineering community of the extent to which long-lived software systems are embedded in our daily environments. as systems are maintained and enhanced throughout their lifecycles they appear to follow generalized behaviors described by the laws of software evolution. within this context, however, there is some question of how and why systems may evolve differently. the objective of this work is to answer the question: do systems follow a set of identifiable evolutionary patterns? in this paper we use software volatility to describe the lifecycle evolution of a portfolio of 23 software systems. we show by example that a vector of software volatility levels can represent lifecycle behavior of a software system. we further demonstrate that the portfolio ' s 23 software volatility vectors can be grouped into four distinguishable patterns. thus, we show by example that there are different patterns of system lifecycle behavior, i.e. software evolution.
artificial intelligence and software engineering. software engineering is a knowledge-intensive activity, requiring extensive knowledge of the application domain and of the target software itself. many software engineering costs can be attributed to the ineffectiveness of current techniques for managing this knowledge, and artificial intelligence techniques can help alleviate this situation. more than two decades of research have led to many significant theoretical results, but few demonstrations of practical utility. this is due in part to the amount and diversity of knowledge required by software engineering activities, and in part to the fact that much of the research has been narrowly focused, missing many issues that are of great practical importance. important issues that remain to be addressed include the representation and use of domain knowledge and the representation of the design and implementation history of a software system. if solutions to these issues are found, and experiments in practical situations are successful, the implications for the practice of software engineering will be profound, and radically different software development paradigms will become possible.
a process for consolidating and reusing design knowledge. significant improvements in design quality and productivity are possible when designers operate in a domain-specific information workspace with low-cost access to relevant application, design, and technology information. the authors present a validated process for constructing such workspaces to support product family design and evolution. the process involves three related efforts: techniques to consolidate critical analysis and design information from different projects and different engineering sites called domain analysis; online representation of the information in structured form called technology books; and methods and tools to reuse information. each area is described, with the focus being on technology books. technology books are object-oriented databases whose objects capture typed information about analyses, designs, and code in a variety of notations. relations with well-defined semantics link objects; these can be used to navigate through the technology book, and to reason about the information it contains
process engineering with spearmint/epg. this paper presents the spearmint process modeling tool and the electronic process guide (epg) generator. together they enable process engineers to elicit, model, analyze and document software processes and then to automatically generate web-based guidebooks based on the documented processes.
automatic programming for streams ii: transformational implementation. &phgr;nix is an automatic programming system, now under development, for writing programs which interact with external devices through temporally-ordered streams of values. abstract specifications are stated in terms of constraints on the values of input and output streams. the target language is the stream machine, a language which includes concurrently executing processes communicating and synchronizing through streams. &phgr;nix produces programs by repeatedly transforming abstract specifications through successively more concrete forms until concrete stream machine programs are produced. an example which &phgr;nix has successfully implemented involves three major steps: transforming the specification into an applicative expression, transforming the applicative expression into three imperative processes, and merging the processes into a single process. each major step involves several other transformation steps that reformulate and simplify intermediate expressions.
understanding and predicting the process of software maintenance release. one of the major concerns of any maintenance organization is to understand and estimate the cost of maintenance releases of software systems. planning the next release so as to maximize the increase in functionality and the improvement in quality are vital to successful maintenance management. the objective of the paper is to present the results of a case study in which an incremental approach was used to better understand the effort distribution of releases and build a predictive effort model for software maintenance releases. the study was conducted in the flight dynamics division (fdd) of nasa goddard space flight center (gsfc). the paper presents three main results: (1) a predictive effort model developed for the fdd's software maintenance release process, (2) measurement-based lessons learned about the maintenance process in the fdd, (3) a set of lessons learned about the establishment of a measurement-based software maintenance improvement program. in addition, this study provides insights and guidelines for obtaining similar results in other maintenance organizations.
empirically driven se research: state of the art and required maturity. software engineering researchers are increasingly relying on the empirical approach to advance the state of the art. the level of empirical rigor and evidence required to guide software engineering research, however, can vary drastically depending on many factors. in this session we identify some of these factors through a discussion of the state of the art in performing empirical studies in software engineering, and we show how we can utilize the notion of empirical maturity to set and adjust the empirical expectations for software engineering research efforts.regarding the state of the art in performing empirical studies, we will offer perspectives on two classes of study: those concerned with humans utilizing a technology, e.g., a person applying a methodology, a technique, or a tool, where human skills and the ability to interact with the technology are some of the primes issues, and those concerned with the application of the technology to an artifact, e.g., a technique or tool applied to a design or a program. in the first case, the emphasis is typically on issues like feasibility, usefulness, and then on effectiveness. the technology tends to be less well specified and based more on the experience and skills of the technology applier. in the second case, the emphasis is typically on the efficiency and effectiveness of the technology. the technology tends to be well defined and the assumption is that the individual skill and experience plays a less important role. we will discuss the set of factors that influence the design, implementation, and validity of these studies.regarding empirical maturity and its implications on the se community's expectations, we will provide examples of the large spectrum of studies with different maturity levels that can be performed to successfully support software engineering research. we will then identify and analyze the following aspects that are likely to impact a study's maturity level: technology (well-specified vs. under development), goals of the study (effectiveness vs. feasibility), type of design and analysis (controlled experiment vs. case study, quantitative vs. qualitative), control and specification of threats to validity (internal vs. external threats), dependence on context (in vivo vs. in vitro), relationship to previous empirical work (replicated on-site, replicated off-site, non-replicated, non-replicable), and purposes of the study (exploratory vs. confirmatory). we will lead a discussion on these key aspects that must be considered to assess the empirical maturity of a piece of work in the context of its research area and the empirical maturity of that area.
lessons learned from 25 years of process improvement: the rise and fall of the nasa software engineering laboratory. for 25 years the nasa/gsfc software engineering laboratory (sel) has been a major resource in software process improvement activities. but due to a changing climate at nasa, agency reorganization, and budget cuts, the sel has lost much of its impact. in this paper we describe the history of the sel and give some lessons learned on what we did right, what we did wrong, and what others can learn from our experiences. we briefly describe the research that was conducted by the sel, describe how we evolved our understanding of software process improvement, and provide a set of lessons learned and hypotheses that should enable future groups to learn from and improve on our quarter century of experiences.
tailoring the software process to project goals and environments. this paper presents a methodology for improving the software process by tailoring it to the specific project goals and environment. this improvement process is aimed at the global software process model as well as methods and tools supporting that model. the basic idea is to use defect profiles to help characterize the environment and evaluate the project goals and the effectiveness of methods and tools in a quantitative way. the improvement process is implemented iteratively by setting project improvement goals, characterizing those goals and the environment, in part, via defect profiles in a quantitative way, choosing methods and tools fitting those characteristics, evaluating the actual behavior of the chosen set of methods and tools, and refining the project goals based on the evaluation results. all these activities require analysis of large amounts of data and, therefore, support by an automated tool. such a tool &mdash; tame (tailoring a measurement environment) &mdash; is currently being developed.
analyzing medium-scale software development. the collection and analysis of data from programming projects is necessary for the appropriate evaluation of software engineering methodologies. towards this end, the software engineering laboratory was organized between the university of maryland and nasa goddard space flight center. this paper describes the structure of the laboratory and provides some data on project evaluation from some of the early projects that have been monitored. the analysis relates to resource forecasting using a model of the project life cycle based upon the rayleigh equation and to error rates applying ideas developed by belady and lehman.
evaluation of a software requirements document by analysis of change data. we describe in this paper an effective data collection method for evaluating software development methodologies, from definition of the objectives of the data collection to analysis of the results. we show how the data analysis can answer questions with respect to how successfully the goals of the development methodology are met. the a-7 requirements document is used as an example. we provide the results of data analyses conducted partway through the a-7 flight software development cycle, and discuss the utility of information obtained by such partial analyses. results from the study show that data collection is feasible and useful when performed as part of configuration control, that data distributions based on partial data provide useful feedback to the developers, and that the a-7 requirements document is easily maintained and changed.
beyond templates: a study of clones in the stl and some general implications. templates (or generics) help us write compact, generic code, which aids both reuse and maintenance. the stl is a powerful example of how templates help achieve these goals. still, our study of the stl revealed substantial, and in our opinion, counter-productive repetitions (so-called clones) across groups of similar class or function templates. clones occurred, as variations across these similar program structures were irregular and could not be unified by suitable template parameters in a natural way. we encountered similar problems in other class libraries as well as in application programs, written in a range of programming languages. in the paper, we present quantitative and qualitative results from our study. we argue that the difficulties we encountered affect programs in general. we present a solution that can treat such template-unfriendly cases of redundancies at the meta-level, complementing and extending the power of language features, such as templates, in areas of generic programming.
prestige: a case workbench for the jsd implementor. the authors provide an overview of prestige, a case toolkit which supports the implementation phase of jackson system development (jsd). the authors present an outline of jsd, a brief discussion on operational specifications, and a description of the two-stage model of jsd implementation which forms the basis of the toolkit's functionality. the toolkit's current capabilities are described and illustrated through simple examples. finally, the authors indicate directions for further work
usability-supporting architectural patterns. software architects have techniques to deal with manyquality attributes such as performance, reliability, andmaintainability. usability, however, has traditionallybeen concerned primarily with presentation and notbeen a concern of software architects beyondseparating the user interface from the remainder of theapplication.in this tutorial, we present usability-supportingarchitectural patterns. each pattern describes ausability concern that is not supported by separationalone. for each concern, a usability-supportingarchitectural pattern provides the forces from thecharacteristics of the task and environment, thehuman, and the state of the software to motivate animplementation independent solution cast in terms ofthe responsibilities that must be fulfilled to satisfy theforces. furthermore, each pattern includes a samplesolution implemented in the context of an overridingseparation based pattern such as j2ee model viewcontroller.
experimental evaluation of a fuzzy-set based measure of software correctness using program mutation. experimental evaluation of software reliability models that depend on the source code of the target program is expensive due to the need for a large sample of programs. the authors have used program mutation to generate many versions of one of the more complex components comprising a hypothetical but realistic nuclear reactor safety control program. trivial mutants were filtered by using branch and path testing. these programs were used to assess a fuzzy set based measure of program correctness. the results confirmed that the model is conservative. in addition, the experiments provided new insights into the model, including reassessment of its assumptions and directions for refining it
some classes of naturally provable programs. three different classes of programs are identified for which the proof of correctness is shown to be &ldquo;natural&rdquo;, in that the functional input-output specifications of the programs lead, in a straightforward manner, to the verification conditions that should be proven. furthermore, these verification conditions are shown to be necessary and sufficient so that a proof/refutation follows by proving/disproving the corresponding verification conditions. it is not necessary to follow the exact control flow of the programs to generate these conditions; certain simple checks are enough to show whether a particular program belongs to one of the classes. these apparently different programs have the common feature that they operate &ldquo;uniformly&rdquo; on the data domain; changing the input to the program changes the dynamic behavior of the program in a predictable, easily definable fashion. implications of this feature in program construction are discussed.
product-line architectures, aspects, and reuse (tutorial session). genvoca pla designs have been created for diverse domains: 2-way radios, extensible compilers, communication protocols, command-and-control fire support, avionics, and matrix computation libraries [7]. genvoca designs are used in industry; its central concepts relate a wide variety of contemporary and classical research topics, including: aspect-oriented programming, parameterized programming, oo frameworks, perry's lite semantics [8], generative programming [7], design maintenance [9], and layered software.
a tutorial on feature oriented programming and product-lines. feature oriented programming (fop) is a design methodology and tools for program synthesis. the goal is to specify a target program in terms of the features that it offers, and to synthesize an efficient program that meets these specifications. fop has been used to develop product-lines in disparate domains, including compilers for extensible java dialects [3], fire support simulators for the u.s. army [5], high-performance network protocols [1], and program verification tools [14].
feature-oriented programming and the ahead tool suite. feature oriented programming (fop) is an emerging paradigmfor application synthesis, analysis, and optimization. atarget application is specified declaratively as a set of features,like many consumer products (e.g., personal computers,automobiles). fop technology translates suchdeclarative specifications into efficient programs.
scaling step-wise refinement. step-wise refinement is a powerful paradigm for developing a complex program from a simple program by adding features incrementally. we present the ahead (algebraic hierarchical equations for application design) model that shows how step-wise refinement scales to synthesize multiple programs and multiple non-code representations. ahead shows that software can have an elegant, hierarchical mathematical structure that is expressible as nested sets of equations. we review a tool set that supports ahead. as a demonstration of its viability, we have bootstrapped ahead tools solely from equational specifications, generating java and non-java artifacts automatically, a task that was accomplished only by ad hoc means previously.