waashk/dblp huggingface dataset:
building awareness of system testing issues. managers of large software projects with system test groups face a problem that they may not be aware of. vague notions among project members about the role of system testing tend to cloud the relationship between developers and testers with misunderstanding and disappointment. the main source of the problem is unrealistic expectations about what can be accomplished during the system test phase of the project. this has the effect of de-emphasizing the developers' responsibility for software quality and imposing a definition of success on system testers that is not possible to achieve. this paper describes a series of role awareness seminars at which a discussion technique was used to clarify expectations between developers and testers. transcending the discussion of roles was a fundamental message: the quality of software is determined during the development phase and cannot be radically improved during the system test phase.
modeling behavioral design patterns of concurrent objects. object-oriented software development practices are being rapidly adopted within increasingly complex systems, including reactive, real-time and concurrent system applications. while data modeling is performed very well under current object-oriented development practices, behavioral modeling necessary to capture critical information in real-time, reactive, and concurrent systems is often lacking. addressing this deficiency, we offer an approach for modeling and analyzing concurrent object-oriented software designs through the use of behavioral design patterns, allowing us to map stereotyped uml objects to colored petri net (cpn) representations in the form of reusable templates. the resulting cpns are then used to model and analyze behavioral properties of the software architecture, applying the results of the analysis to the original software design.
resource controller tasks in ada: their structure and semantics. the focus of this paper is on the processes that control access to shared resources in concurrent systems. processes that access a shared resource send access requests to the controller of the shared resource which in turn services requests based on such criteria as the conditions enabling the requests, the fairness specified, etc. in this paper we examine the structure of resource controllers, in particular, we show how resource controllers manifest themselves in ada. our prime motivation for this work is to develop schemes by which controllers with complex resource control policies can be implemented using the tasking constructs of ada. to enable the verification of ada resource controllers, we provide a temporal semantics for the tasking constructs as well as for the resource controller components.
specifying and proving properties of sentinel processes. this paper presents a technique for specifying and verifying properties of &ldquo;sentinels&rdquo;&mdash;a high-level language construct for synchronizing access to shared resources. statements in the specification language possess formal temporal semantics. as a prelude to proving the correctness of sentinels, the semantics of constructs used in sentinels is given. the proof technique involves showing that the temporal behavior of a sentinel conforms to that defined by the specification. the methodology is illustrated by applying it to a typical synchronization problem.
algorithmic cost estimation for software evolution. this study addresses the problem of cost estimation in the context of software evolution by building a set of quantitative models and assessing their predictive power. the models aim at capturing the relationship between effort, productivity and a suite of metrics of software evolution extracted from empirical data sets.
understanding code mobility (tutorial session). the tutorial provides a conceptual framework for code mobility by illustrating a taxonomy of related technologies, architectural paradigms, and applications. as a final case study, the concepts developed in the taxonomy are then applied to a quantitative assessment of the benefits of mobile code technologies and architectures in the network management application domain.
exception-chain analysis: revealing exception handling architecture in java server applications. although it is common in large java programs to rethrow exceptions, existing exception-flow analyses find only single exception-flow links, thus are unable to identify multiple-link exception propagation paths. this paper presents a new static analysis that, when combined with previous exception-flow analyses, computes chains of semantically-related exception-flow links, and thus reports entire exception propagation paths, instead of just discrete segments of them. these chains can be used 1) to show the error handling architecture of a system, 2) to assess the vulnerability of a single component and the whole system, 3) to support better testing of error recovery code, and 4) to facilitate the tracing of the root cause of a logged problem. empirical findings and a case history for tomcat show that a significant portion of the chains found in our benchmarks span multiple components, and thus are hard to find manually.
analyzing the test process using structural coverage. a large, commercially developed fortran program was modified to produce structural coverage metrics. the modified program was executed on a set of functionally generated acceptance tests and a large sample of operational usage cases. the resulting structural coverage metrics are combined with fault and error data to evaluate structural coverage in the sel environment. we can show that in this environment the functionally generated tests seem to be a good approximation of operational use. the relative proportions of the exercised statement sub-classes (executable, assignment, call, do, if, read, write) changes as the structural coverage of the program increases. we also propose a method for evaluating if two sets of input data exercise a program in a similar manner. we also provide evidence that implies that in this environment, faults revealed in a procedure are independent of the number of times the procedure is executed and that it may be reasonable to use procedure coverage in software models that use statement coverage. finally, the evidence suggests that it may be possible to use structural coverage to aid in the management of the acceptance test process.
3rd international workshop on software engineering for automotive systems - seas 2006. this workshop summary presents an overview of the one-day international workshop on software engineering for automotive systems (seas 2006), held in conjunction with the 28 th international conference on software engineering (icse'06). details about seas 2006 may be found at: http://www.inf.ethz.ch/personal/pretscha/events/seas06/.
data flow analysis techniques for test data selection. this paper examines a family of program test data selection criteria derived from data flow analysis techniques similar to those used in compiler optimization. it is argued that currently used path selection criteria which examine only the control flow of a program are inadequate. our procedure associates with each point in a program at which a variable is defined, those points at which the value is used. several related path criteria, which differ in the number of these associations needed to adequately test the program, are defined and compared.
aspect-oriented software development beyond programming. this tutorial focuses on applying aspect-oriented software development (aosd) concepts beyond the programming stage of the software development life cycle. using concrete methods, tools, techniques and notations we discuss how to use aosd techniques to systematically treat crosscutting concerns during requirements engineering (re), architecture design and detailed design as well as the mapping between aspects at these stages. with a clear focus on composition, modelling, trade-off analysis and assessment methods, the tutorial imparts an engineering ethos for translation into day-to-day processes and practices.
human-computer communication meets software engineering. a contemporary software engineering problem is to adapt an existing piece of software to a new interface technology.we describe the process of integrating a software engineering tool with a window-based direct manipulation interface. four stages of this process are described - from a simple integration to a fully integrated system in which it becomes hard to separate properties of the tool from those of the interface.we take advantage of wlisp, an object-oriented, knowledge-based user interface construction kit that contains a large number of tools and intelligent support systems. the object-oriented architecture of wlisp is well suited for making use of existing interface components and tailoring them to the specific needs of the application. this is illustrated by describing the implementation of two of the four integration stages in some detail. thereby we show benefits and problems of separating the interface from the application system.
software evolution in componentware using requirements/assurances contracts. in practice, pure top-down and refinement-based development processes are not sufficient. usually, an iterative and incremental approach is applied instead. existing methodologies, however, do not support such evolutionary development processes very well. in this paper, we present the basic concepts of an overall methodology based on component ware and software evolution. the foundation of our methodology is a novel, well-founded model for component-based systems. this model is sufficiently powerful to handle the fundamental structural and behavioral aspects of component ware and object-orientation. based on the model, we are able to provide a clear definition of a software evolution step.during development, each evolution step implies changes of an appropriate set of development documents. in order to model and track the dependencies between these documents, we introduce the concept of requirements/assurances contracts. these contracts can be rechecked whenever the specification of a component evolves, enabling us to determine the impacts of the respective evolution step. based on the proposed approach, developers are able to track and manage the software evolution process and to recognize and avoid failures due to software evolution. a short example shows the usefulness of the presented concepts and introduces a practical description technique for requirements/assurances contracts.
the structure and characteristics of distributed systems. phrases such as 'distributed processing' and 'distributed operating systems' are currently very much in vogue and are being applied to many systems that seem to be entirely different in nature. what used to be a system with a separate input-output channel or a multiprocessor system or a network without load balancing is now a distributed system. the common feature seems to be a multiplicity; i. e., more than one, of clearly distinguishable modules, as determined by the beholder, operating simultaneously. this paper is an attempt to categorize distributed systems so that one can examine the generic characteristics and problems associated with each category. the first step is to realize that distribution involves the apportioning of a set of tasks among a set of entities that can perform the tasks.
architectural interaction diagrams: aids for system modeling. this paper develops a modeling paradigm called architectural interaction diagrams, or aids, for the high-level design of systems containing concurrent, interacting components. the novelty of aids is that they introduce interaction mechanisms, or buses, as first-class entities into the modeling vocabulary. users then have the capability, in their modeling, of using buses whose behavior captures interaction at a higher level of abstraction than that afforded by modeling notations such as message sequence charts or process algebra, which typically provide only one fixed interaction mechanism. this paper defines aids formally by giving them an operational semantics that describes how buses combine subsystem transitions into system-level transitions. this semantics enables aids to be simulated; to incorporate subsystems given in different modeling notations into a single system model; and to use testing, debugging and model checking early in the system design cycle in order to catch design errors before they are implemented.
on the syllogistic structure of object-oriented programming. recent works by sowa and by rayside & campbell demonstrate that there is a strong connection between object-oriented programming and the logical formalism of the syllogism, first set down by aristotle in the prior analytics. in this paper, we develop an understanding of polymorphic method invocations in terms of the syllogism, and apply this understanding to the design of a novel editor for object-oriented programs. this editor is able to display a polymorphic call graph, which is a substantially more difficult problem than displaying a non-polymorphic call graph. we also explore the design space of program analyses related to the syllogism, and find that this space includes unique name, class hierarchy analysis, class hierarchy slicing, class hierarchy specialization, and rapid type analysis.
semantic anomaly detection in online data sources. much of the software we use for everyday purposes incorporates elements developed and maintained by someone other than the developer. these elements include not only code and databases but also dynamic data feeds from online data sources. although everyday software is not mission critical, it must be dependable enough for practical use. this is limited by the dependability of the incorporated elements.it is particularly difficult to evaluate the dependability of dynamic data feeds, because they may be changed by their proprietors as they are used. further, the specifications of these data feeds are often even sketchier than the specifications of software components.we demonstrate a method of inferring invariants about the normal behavior of dynamic data feeds. we use these invariants as proxies for specifications to perform on-going detection of anomalies in the data feed. we show the feasibility of our approach and demonstrate its usefulness for semantic anomaly detection: identifying occasions when a dynamic data feed is delivering unreasonable values, even though its behavior may be superficially acceptable (i.e., it is delivering parsable results in a timely fashion).
supporting reflective practitioners. the theme and title for this panel is inspired bydonald schönýs writings about the reflective practitionerin which he describes professional practice as being aprocess of reflection in action. ill-defined problemsincluding design decisions lead to breakdowns, whichbecome opportunities for reflection and modification ofpractice. this panel seeks to provide icse attendees witha broad cross section of the history, state of the art, andopen issues with some of the methods and tools directedat supporting reflective software practitioners.
reuse of verificatino efforts and incomplete specifications in a formalized, iterative and incremental software process. the possibility of verifying systems during any phase of the software development process is one of the most significant advantages of using formal methods. model checking is considered to be the broadest used formal verification technique, even though a great quantity of computing resources are needed to verify medium-large and large systems. as verification is prevent over the whole software process, these amount of resources is more critic in incremental and iterative life cycles. our proposal focuses on reusing incomplete models and their verification results &mdash;which are obtained from a model checking algorithm&mdash; in order to improve these kind of life cycles. making good use of these previous verification results can reduce the formal verification costs by minimizing the set of requirements and the set of system states where the properties must be verified. the unspecification inherent to incomplete systems is used to provide an approximate and content-oriented retrieval which is supplemented by suggestions to match the desired specifications.
software technology maturation. we have reviewed the growth and propagation of a variety of software technologies in an attempt to discover natural characteristics of the process as well as principles and techniques useful in transitioning modern software technology into widespread use. what we have looked at is the technology maturation process, the process by which a piece of technology is first conceived, then shaped into something usable, and finally &ldquo;marketed&rdquo; to the point that it is found in the repertoire of a majority of professionals. a major interest is the time required for technology maturation &mdash; and our conclusion is that technology maturation generally takes much longer than popularly thought, especially for major technology areas. but our prime interest is in determining what actions, if any, can accelerate the maturation of technology, in particular that part of maturation that has to do with transitioning the technology into widespread use. our observations concerning maturation facilitators and inhibitors are the major subject of this paper.
prototyping real-time vision systems: an experiment in dsl design. describes the enhancement of xvision, a large library of c++ code for real-time vision processing, into fvision (pronounced "fission"), a fully-featured domain-specific language (dsl) embedded in haskell. the resulting prototype system substantiates the claims of increased modularity, effective code reuse and rapid prototyping that characterize the dsl approach to systems design. it also illustrates the need for judicious interface design: relegating computationally expensive tasks to xvision (pre-existing c++ components) and leaving modular compositional tasks to fvision (haskell). at the same time, our experience demonstrates how haskell's advanced language features (specifically, parametric polymorphism, lazy evaluation, higher-order functions and automatic storage reclamation) permit a rapid dsl design that is itself highly modular and easily modified. overall, the resulting hybrid system exceeded our expectations: visual tracking programs continue to spend most of their time executing low-level image processing code, while haskell's advanced features allow us to quickly develop and test small prototype systems within a matter of a few days, and to develop realistic applications within a few weeks.
jive: visualizing java in action demonstration description. dynamic software visualization should provide a programmer with insights as to what the program is doing. most current dynamic visualizations either use program traces to show information about prior runs, slow the program down substantially, show only minimal information, or force the programmer to indicate when to turn visualizations on or off. we have developed a dynamic java visualizer that provides a view of a program in action with low enough overhead that it can be used almost all the time by programmers to understand what their program is doing while it is doing it.
pecan: program development systems that support multiple views. this paper describes the pecan family of program development systems. pecan supports multiple views of the user's program. the views can be representations of the program or of the corresponding semantics. the primary program view is a syntax-directed editor. the current semantic views include expression trees, data type diagrams, flow graphs, and the symbol table. pecan is designed to make effective use of powerful personal machines with high-resolution graphics displays and is currently implemented on apollo workstations.
a conceptual programming environment. conceptual programming means having programmers work directly with their models of how their system is put together. it means providing them with the means for designing, coding and maintaining systems on a computer using the pictures and text they normally use on paper. an environment for conceptual programming requires flexibility to support a wide range of languages and graphics to support languages based on pictures. the garden system is a prototype conceptual programming environment that uses an object-oriented framework to meet these requirements.
simplifying data integration: the design of the desert software development environment. this paper describes the design and motivations behind the desert environment. the desert environment has been created to demonstrate that the facilities typically associated with expensive data integration can be provided inexpensively in an open framework. it uses three integration mechanisms: control integration, simple data integration based on fragments, and a common editor. it offers a variety of capabilities including hyperlinks and the ability to create virtual files containing only the portions of the software that are relevant to the task on hand. it does this in an open environment that is compatible with existing tools and programs. the environment currently consists of a set of support facilities including a context database, a fragment database, scanners, and a tooltalk interface, as well as a preliminary set of programming tools including a context manager and extensions to framemaker to support program editing and insets for non-textual software artifacts.
clime: an environment for constrained evolution demonstration description. we are building a software development environment that uses constraints to ensure the consistency of the different artifacts associated with software. this approach to software development makes the environment responsible for detecting most inconsistencies between software design, specifications, documentation, source code, and test cases. the environment provides facilities to ensure that these various dimensions remain consistent as the software is written and evolves. the environment works with the wide variety of artifacts typically associated with a large software system. it handles both the static and dynamic aspects of software. moreover, it works incrementally so that consistency information is readily available to the developer as the system changes. the demonstration will show this environment and its capabilities.
encoding program executions. dynamic analysis is based on collecting data as the program runs. however, raw traces tend to be too voluminous and too unstructured to be used directly for visualization and understanding. we address this problem in two phases: the first phase selects subsets of the data and then compacts it, while the second phase encodes the data in an attempt to infer its structure. our major compaction/selection techniques include gprof-style n-depth call sequences, selection based on class, compaction based on time intervals, and encoding the whole execution as a directed acyclic graph. our structure inference techniques include run-length encoding, context-free grammar encoding, and the building of finite state automata.
demonstration of jive and jove: java as it happens. dynamic software visualization is designed to provide programmers with insights as to what the program is doing. most current visualizations either use program traces to show information about prior runs, slow the program down substantially, show only minimal information, or force the programmer to indicate when to turn visualizations on or off. we have developed a dynamic java visualizer that provides a statement-level view of a java program in action with low enough overhead so that it can be used almost all the time by programmers to understand what their program is doing while it is doing it.