waashk/dblp huggingface dataset:
a comprehensive product line scoping approach and its validation. product line engineering is a recent approach to software development that specifically aims at exploiting commonalities and systematic variabilities among functionally overlapping systems in terms of large scale reuse. taking full advantage of this potential requires adequate planning and management of the reuse approach as otherwise huge economic benefits will be missed due to an inappropriate alignment of the reuse infrastructure.key in product line planning is the scoping activity, which aims at focussing the reuse investment where it pays. scoping actually happens on several levels in the process: during the domain analysis step (analysis of product line requirements) a focusing needs to happen just like during the decision of what to implement for reuse. the latter decision has also important ramifications for the development of an appropriate reference architecture as it provides the reusability requirements for this step.in this paper, we describe an integrated approach that has been developed, improved, and validated over the last few years. the approach fully covers the scoping activities of domain scoping and reuse infrastructure scoping and was validated in several industrial case studies.
introducng a software modeling concept in a medium-sized company. in this paper, we describe, using the quality improvement paradigm (qip), how an improvement project aimed at improving the modeling and documentation approach of a medium-sized company (msud) was conducted. we discuss the new modeling approach which may serve for other companies as a template for deriving their own adapted approach. further, we illustrate our insights from this project that can help in future technology transfer projects. a major characteristic of this project was that it was embedded in a long-term consulting relationship.
introducing the pulse approach to an embedded system population at testo ag. over the last few years, product line engineering has become a major theme in software engineering research, and is increasingly becoming a central topic of software engineering practice in the embedded domain.migrating towards a product line approach is not an easy feat. it is even less so, if it is done under tight technology constraints in an embedded environment. it becomes even more difficult if the transition directly aims at integrating two product families into a single product population. in this paper, we discuss our experiences with a project where we successfully dealt with these difficulties and achieved a successful product line transition. in our paper we strongly emphasize the role of technology transfer, as many facets of product line know-how had to be transferred to guarantee a complete transition to product line engineering. from the experiences of this project many lessons learned can be deduced, which can be transferred to different environments.
patterns, frameworks, and middleware: their synergistic relationships. the knowledge required to develop complex software has historically existed in programming folklore, the heads of experienced developers, or buried deep in the code. these locations are not ideal since the effort required to capture and evolve this knowledge is expensive, time-consuming, and error-prone. many popular software modeling methods and tools address certain aspects of these problems by documenting how a system is designed. however, they only support limited portions of software development and do not articulate why a system is designed in a particular way, which complicates subsequent software reuse and evolution.patterns, frameworks, and middleware are increasingly popular techniques for addressing key aspects of the challenges outlined above. patterns codify reusable design expertise that provides time-proven solutions to commonly occurring software problems that arise in particular contexts and domains. frameworks provide both a reusable product-line architecture [1] guided by patterns -- for a family of related applications and an integrated set of collaborating components that implement concrete realizations of the architecture. middleware is reusable software that leverages patterns and frameworks to bridge the gap between the functional requirements of applications and the underlying operating systems, network protocol stacks, and databases. this paper presents an overview of patterns, frameworks, and middleware, describes how these technologies complement each other to enhance reuse and productivity, and then illustrates how they have been applied successfully in practice to improve the reusability and quality of complex software systems.
calculating architectural reliability via modeling and analysis. we present a software architecture-based approach tocompositional estimation of systemýs reliability. ourapproach is applicable to early stages of developmentwhen the implementation artifacts are not yet available,and exact execution profile is unknown. the uncertainty ofthe execution profile is modeled using stochastic processeswith unknown parameters. the compositional approachcalculates overall reliability of the system as a function ofthe reliability of its constituent components and their(complex) interactions. sensitivity analysis to identify criticalcomponents and interactions will be provided.
consistency checking within embedded design languages. it is difficult to ensure consistency between a program's design and its implementation. an embedded design language (one superimposed on an implementation language) can help. this paper describes a particular embedded design language that was successfully used to design and implement a very large compiling system. this design language has a rich set of constructs for expressing the high-level and detailed designs of a program. it also supports various levels of design and implementation consistency checking, and the generation of a variety of documents for use by programmers and reviewers.
estimating software component reliability by leveraging architectural models. software reliability techniques are aimed at reducing or eliminat-ing failures in software systems. reliability in software systems istypically measured during or after system implementation. how-ever, software engineering methodology lays stress on doing the"correct things" early on in the software development lifecycle inorder to curb development and maintenance costs. in this paper, wepropose a framework for reliability estimation of software compo-nents at the level of software architecture.
prototypes as assets, not toys: why and how to extract knowledge from prototypes. software prototypes are becoming more and more important, as computer applications invade new domains and as personal prototyping environments become more powerful. although numerous approaches recommend their use, prototypes are sometimes treated like their developers' personal toys, and little effort is made to extract and share the experiences and knowledge that emerged as a by-product of building the prototype. in this paper, a strategy is proposed to extract crucial pieces of knowledge from a prototype and from its developer. the strategy is based on monitoring explanations that developers give, analyzing their structure, and feeding results back to support and to focus explanations. during this process, the prototype turns into the centerpiece of a hyperstructured information base, which can be used to convey concepts, implementation tricks and experiences. if organizations begin to view-and treat-prototypes as executable representations of knowledge, they can fully capitalize on the assets prototypes really are.
effective experience repositories for software engineering. software development and acquisition require knowledge and experience in many areas of software engineering. experience helps people to make decisions under uncertainty, and to find better compromises. experience-based process improvement considers experience as a prerequisite for competent behavior in software development. there is usually a repository to store experiences and to make it available for reuse. at daimlerchrysler, we have been building those repositories for more than five years. we learned to concentrate on certain properties that seem to be key success factors for experience repositories. during our experience-based work in business units, five key quality aspects have been identified that determine the chances for success of an experience repository. the quality criteria can be used to analyze a given repository; or they can be applied to guide the construction of more effective experience repositories.
teaching contract programming concepts to future software engineers. current research in software engineering at karlstad university is concentrated on non-formal software design methods with a focus on semantics. one goal is to produce methods, which may be applied in both industry and academia. in concrete terms, ideas from contract programming, including pre- and post-conditions have been introduced into the first year curriculum. this paper presents results taken from three surveys of the same group of first-year students during their second semester, in an attempt to ascertain how well the students have internalised these and other programming concepts. the results show that the majority of the students are aware of the concepts but are still at various stages of understanding. a good understanding of terminology emerges as one key area of focus for future courses. the results are a reasonable reflection of reality, given the limited time in which the students are expected to absorb these ideas, and provide feedback for further integration and development of the related programming courses.
extreme programming at universities - an educational perspective. to address the problems of traditional software devel- opment, recent years have shown the introduction of more light-weight or "agile" development processes (extreme programming being the most prominent one). these processes are intended to support early and quick production of working code by structuring the development into small release cycles and focus on continual interaction between developers and customers. as such software development processes become more popular, there is a growing demand from industry to introduce agile development practices in tertiary education.this is not a straightforward task as the corresponding practices may run counter to educational goals or may not be adjusted easily to a learning environment. in this paper, we discuss some of these issues and reflect on the problems of teaching agile processes in tertiary education.
integrated program measurement and documentation tools. this paper describes an attempt to integrate the collection and the efficient utilisation of measurements in the development and the use of programs. the work presented consists in three parts: - the design of both static and dynamic measurement tools, - examples of data processing on measurements collected on a sample of pascal programs, - the design of a quantitative documentation of a program, which is automatically built as measurements are collected. the first and third steps have been developed inside an existing programming environment, mentor, and we shall discuss the advantages we found in integrating the tools in such an environment.
understanding and aiding code evolution by inferring change patterns. evolution continues to play an ever-increasing role in software engineering. although changing a program is the core of software evolution, program change patterns have not been considered as a first class entity in most classic studies of software evolution. past empirical studies of software evolution primarily relied on quantitative and statistical analyses of a programover time [1], but did not focus on semantic and qualitative change patterns of a program. we hypothesize that by treating change patterns as first class entities we can better understand software evolution and also aid programmers in changing software.
wysiwyt testing in the spreadsheet paradigm: an empirical evaluation. is it possible to achieve some of the benefits of formal testing within the informal programming conventions of the spreadsheet paradigm? we have been working on an approach that attempts to do so via the development of a testing methodology for this paradigm. our &ldquo;what you see is what you test&rdquo; (wysiwyt) methodology supplements the convention by which spreadsheets provide automatic immediate visual feedback about values by providing automatic immediate visual feedback about &ldquo;testedness&rdquo;. in previous work we described this methodology; in this paper, we present empirical data about the methodology's effectiveness. our results show that the use of the methodology was associated with significant improvement in testing effectiveness and efficiency even with no training on the theory of testing or test adequacy that the model implements. these results may be due at least in part to the fact that use of the methodology was associated with a significant reduction in overconfidence.
the first workshop on end-user software engineering. weuse is a workshop dedicated to the problems faced by end-user programmers, and research that can address those problems.
cost estimation for web applications. in this paper, we investigate the application of the cobra&trade; method (cost estimation, benchmarking, and risk assessment) in a new application domain, the area of web development. cobra combines expert knowledge with data on a small number of projects to develop cost estimation models, which can also be used for risk analysis and benchmarking purposes. we modified and applied the method to the web applications of a small australian company, specializing in web development. in this paper we present the modifications made to the cobra method and results of applying the method. in our study, using data on twelve web applications, the estimates derived from our web-cobra model showed a mean magnitude of relative error (mmre) of 0.17. this result significantly outperformed expert estimates from allette systems (mmre 0.37). a result comparable to web-cobra was obtained when applying ordinary least squares regression with size in terms of web objects as an independent variable (mmre 0.23).
scl: static enforcement and exploration of developer intent in source code. software developers spend a large fraction of their time dealing with intent, seeking to answer questions like does this code really do what it is expected to do?is this module used appropriately?is this code easy to modify or extend?can this code be used in a different context? as a result, developers make many mutually-dependent design decisions to express intentions about software and try to convert them into code precisely.
the impact of test suite granularity on the cost-effectiveness of regression testing. regression testing is an expensive testing process used to validate software following modifications. the cost-effectiveness of regression testing techniques varies with characteristics of test suites. one such characteristic, test suite granularity, involves the way in which test inputs are grouped into test cases within a test suite. various cost-benefits tradeoffs have been attributed to choices of test suite granularity, but almost no research has formally examined these tradeoffs. to address this lack, we conducted several controlled experiments, examining the effects of test suite granularity on the costs and benefits of several regression testing methodologies across six releases of two non-trivial software systems. our results expose essential tradeoffs to consider when designing test suites for use in regression testing evolving systems.
a system for parallel programming. the programming of efficient parallel software typically requires extensive experimentation with program prototypes. a programming system that supports rapid prototyping of parallel programs should provide high-level primitives with which programs can be explicitly, statically or dynamically tuned with respect to performance and reliability. when using such primitives, programmers should not need to interact explicitly or even be aware of the software tools involved in program construction and tuning, such as compilers, linkers, and loaders. in addition, programmers should be provided with the information about the executing program and the parallel hardware required for tuning. such information may include monitoring data about the current or previous program or even hints regarding appropriate tuning decisions.a programming system that includes primitives and tools for program tuning is presented in this paper. the system has been implemented, and has been tested with a variety of parallel applications on a network of unix workstations.
a framework for evaluating regression test selection techniques. regression testing is a necessary but expensive activity aimed at showing that code has not been adversely affected by changes. a selective approach to regression testing attempts to reuse tests from an existing test suite to test a modified program. this paper outlines issues relevant to selective retest approaches, and presents a framework within which such approaches can be evaluated. this framework is then used to evaluate and compare existing selective retest algorithms. the evaluation reveals strengths and weaknesses of existing methods, and highlights problems that future work in this area should address
using return on investment to compare agile and plan-driven practices in undergraduate group projects. in this paper we describe our experiences of introducing agile practices into undergraduate group work by comparing the results to more traditional plan-driven groups. when considering whether to adopt an agile or plan-driven project management strategy in a commercial context, return on investment (roi) is an important factor. we have adapted the roi model to our analysis to assess what affect a chosen development approach has on the outcome of the groups' projects. in our investigation we observed seven software teams as they implemented a business information system. two groups adopted agile practices, including fortnightly iterative delivery; the other groups were controls. we found that being labelled agile did not necessarily imply that a group's practices were more agile. also, it was unclear whether the so-called agile groups delivered a better roi than their plan-driven counterparts.
handling safety-related feature interaction in safety-critical product lines. the variation management of software product lines is currently handled without adequately taking safety or other system-level properties into account. this is largely due to (1) the fact that the available product-line variation-management techniques lack sufficient support for representing the combined effect of different features, and (2) the existing feature interaction techniques do not suffice for handling one-to- many feature interactions typical of many safety-critical product lines. the challenge is that we need to track the safety-related feature interactions while still promoting reuse. the expected contribution of this work is to demonstrate how safety-related feature interactions can be better investigated and managed by the safety-analysis guided, model-based approach described in this paper.
what you see is what you test: a methodology for testing form-based visual programs. form-based visual programming languages, which include commercial spreadsheets and various research systems, have had a substantial impact on end-user computing. research shows, however, that form-based visual programs often contain faults. we would like to provide at least some of the benefits of formal testing methodologies to the creators of these programs. this paper presents a testing methodology for form-based visual programs. to accommodate the evaluation model used with these programs, and the interactive process by which they are created, our methodology is validation driven and incremental. to accommodate the users of these languages, we provide an interface to the methodology that does not require an understanding of testing theory. we discuss our implementation of this methodology and empirical results achieved in its use
an intelligent tool for re-engineering software modularity. the author describes a software tool that provides heuristic modularization advice for improving existing code. a heuristic design similarity measure is defined, based on the parna information hiding principle. the measure supports two services: clustering, which identifies groups of related procedures, and maverick analysis, which identifies individual procedures that appear to be in the wrong module. the tool has already provided useful advice in several real programming projects. the tool will soon incorporate an automatic tuning method, which allows the tool to learn from its mistakes, adapting its advice to the architect's preferences. a preliminary experiment demonstrates that the automatically tuned similarity function can assign procedures to modules very accurately
object naming analysis for reverse-engineered sequence diagrams. uml sequence diagrams are commonly used to represent object interactions in software systems. this work considers the problem of extracting uml sequence diagrams from existing code for the purposes of software understanding and testing. a static analysis for such reverse engineering needs to map the interacting objects from the code to sequence diagram objects. we propose an interprocedural dataflow analysis algorithm that determines precisely which objects are the receivers of certain messages, and assigns the appropriate diagram objects to represent them. our experiments indicate that the majority of message receivers can be determined exactly, resulting in highly-precise object naming for reverse-engineered sequence diagrams.
fragment class analysis for testing of polymorphism in java software. adequate testing of polymorphism in object-oriented software requires coverage of all possible bindings of receiver classes and target methods at call sites. tools that measure this coverage need to use class analysis to compute the coverage requirements. however, traditional whole-program class analysis cannot be used when testing partial programs. to solve this problem, we present a general approach for adapting whole-program class analyses to operate on program fragments. furthermore, since analysis precision is critical for coverage tools, we provide precision measurements for several analyses by determining which of the computed coverage requirements are actually feasible. our work enables the use of whole-program class analyses for testing of polymorphism in partial programs, and identifies analyses that compute precise coverage requirements and therefore are good candidates for use in coverage tools.
software evolution management: an integrated discipline for managing software. many models have been devised to represent the processes involved in developing software with hopes of providing foundations for increasingly useful environment support tools. they have met with varied success in their abilities to relate to &ldquo;reality&rdquo;. this paper presents a model called the software evolution management (sem) model. the sem model focuses on the problems and situations that commonly arise in commercial software development organizations, although it is probably relevant to other situations as well. this paradigm establishes a structure within which a tracking system can be implemented that smoothly integrates many different types of management and development activities.