waashk/dblp huggingface dataset:
compositional verification of middleware-based software architecture descriptions. in this paper we present a compositional reasoningto verify middleware-based software architecture descriptions.we consider a nowadays typical software system development,namely the development of a software applicationa on a middleware m. our goal is to efficiently integrateverification techniques, like model checking, in thesoftware life cycle in order to improve the overall softwarequality. the approach exploits the structure imposed on thesystem by the software architecture in order to develop anassume-guarantee methodology to reduce properties verification from global to local. we apply the methodology on a non-trivial case study namely the development of a gnutellasystem on top of the siena event-notification middleware.
practical software measurement. this tutorial provides a one-day overview of practical software measurement (psm). the measurement approach focuses on satisfying the information needs of project managers. innovative elements of psm include the measurement process model and the measurement information model. rather than discussing specific numerical techniques in detail, this course emphasizes basic concepts.
statistical techniques for software engineering practice. many factors are combining to promote theuse of quantitative and statistical methods bypracticing software engineers. while thesetechniques are not new to industry in general,they are relatively new to the software industry.consequently, there is significant uncertainty inthe community about their difficulty andapplicability. this tutorial provides anintroduction to basic concepts and shows howthey can be applied to help solve commonsoftware engineering problems.
criteria for software modularization. a central issue in programming practice involves determining the appropriate size and information content of a software module. this study attempted to determine the effectiveness of two widely used criteria for software modularization, strength and size, in reducing fault rate and development cost. data from 453 fortran modules developed by professional programmers were analyzed. the results indicated that module strength is a good criterion with respect to fault rate, whereas arbitrary module size limitations inhibit programmer productivity. this analysis is a first step toward defining empirically based standards for software modularization.
transitions in programming models: 2. the future of programming languages is not what it used to be. from the 50's to the 90's, richer, more flexible, and more robust structures were imposed on raw computation. generally, new models of data and control managed to subsume older ones. but now, as programs and applications expand beyond a single local network and a single administrative domain, the very nature of data and control changes, and many long-lasting conceptual invariants are disrupted. we discuss three of these disruptive changes, which seem to be happening all at the same time, and for related reasons: asynchronous concurrency, semistructured data, and (in much less detail) security abstractions. we outline research project that address issues in those areas, mostly as examples of much larger territories yet to explore.
comparing frameworks and layered refinement. object-oriented frameworks are a popular mechanism for building and evolving large applications and software product lines. this paper describes an alternative approach to software construction, java layers (jl), and evaluates jl and frameworks in terms of flexibility, ease of use, and support for evolution. our experiment compares schmidt's ace framework against a set of ace design patterns that have been implemented in jl. we show how problems of framework evolution and overfeaturing can be avoided using jl's component model, and we demonstrate that jl scales better than frameworks as the number of possible application features increases. finally, we describe how constrained parametric polymorphism and a small number of language features can support jl's model of loosely coupled components and stepwise program refinement.
software research in the department of defense. the department of defense has a comprehensive program of coordinated r & d initiatives to improve software engineering tools and methods. one thrust of the program is to automate significant aspects of the software development and maintenance process. another thrust is to increase the availability of software tools and to institutionalize the exchange of the best tools and techniques throughout dod.
structured programming: from theory to practice. one of the more controversial topics to appear within the field of computer science has been the theory of structured programming and the specific tools and techniques associated with this generic title. with respect to this topic, it is the intent of this paper to provide a documented history of the research, prototyping and deliberate implementation of the structured programming technology within the united states army computer systems command. structured programming as used within the context of this paper involves the concepts of structured code, top down development, walkthrus, program design language, design and documentation tools, program support library and a programming team. the usacsc experience is viewed as not just another case study but rather an organizational change impacting a large number (500 cobol programmers) of personnel, standards, and normal operating procedures. one of the more intriguing topics to appear within the field of computer science has been the theory of structured programming and the specific tools and techniques associated with this generic title. after several years of discussion, pilot projects, technical articles and more discussions, the basic questions remain: what does the technology buy you? what does it cost you? how does one implement the technology on a large scale in a software production shop? with respect to these questions, and many others that the software community shares regarding structured programming, it is the intent of this paper to provide a documented history of the research, prototyping and deliberate implementation of the structured programming technology within the united states army computer systems command (usacsc).
integrating prior knowledge with a software reliability growth model. the authors describe an application of ohba's inflection s reliability growth model to an ibm software product consisting of 1200 kloc. the central theme deals with the management requirement that forecasts be made early in the test cycle when there is little data. a simple brute force monte carlo simulation is implemented which utilizes prior knowledge about the total number of failures in the product prior to test. attention is also given to the decisions made regarding the data to select as input to the model. scaled forecasts and field results are presented which show reasonably good results
third international workshop on distributed event-based systems - debs '04. event-based systems are made of reactive componentsthat cooperate by exchanging information and control in theform of events. the occurrence of an event, as well as thedata characterizing that event, may trigger the execution ofone or more components, which may in turn generate otherevents. in a distributed event-based system, where componentsare physically distributed over a network, eventsmust be signaled to remote components through some formof communication mechanism. this workshop is about (1)the engineering methods that support the design of event-basedapplications, and (2) the design of the communicationmechanisms that support the event-based interactionof components over a network.
comparison of two component frameworks: the fipa-compliant multi-agent system and the web-centric j2ee platform. this work compares and contrasts two component frameworks: (1) the web-centric java 2 enterprise edition (j2ee) framework and (2) the fipa-compliant multi-agent system (mas). fipa, the foundation for intelligent physical agents, provides specifications for agents and agent platforms. both frameworks are component frameworks; servlets and enterprise java beans (ejbs) in the case of j2ee and software agents in the case of mas. both frameworks are specification based. both frameworks mandate platform responsibilities towards their respective component(s).we develop a framework with which to structure the comparison of the component frameworks. we apply this comparison structure in the context of a 'data access' scenario to application development in the respective component frameworks. furthermore, we have prototyped this scenario in each of the two component frameworks. we conclude with a discussion of the benefits, drawbacks, and issues of developing new applications in each of the component frameworks.
experience with a modular typed language: protel. the support for modular software and the ability to perform type checking across module boundaries are becoming the mainstay of recent high level language design. this is well illustrated by languages such as mesa and the us department of defence's new standard language ada. at bell-northern research, protel, one of the first modular typed languages, has been used since 1975 to implement a substantial software system. the experience accumulated in building this system has given us a unique perspective. it has shown that the confidence of language designers in modular typed languages is well founded. it has also revealed some pitfalls which others will undoubtedly encounter. the purpose of this paper is to share our experience by outlining the nature of the problems and our solutions to them.
little-jil/juliette: a process definition language and interpreter. little-jil, a language for programming coordination in processes is an executable, high-level language with a formal (yet graphical) syntax and rigorously defined operational semantics. the central abstraction in little-jil is the &ldquo;step,&rdquo; which is the focal point for coordination, providing a scoping mechanism for control, data, and exception flow and for agent and resource assignment. steps are organized into a static hierarchy, but can have a highly dynamic execution structure including the possibility of recursion and concurrency.little-jil is based on two main hypotheses. the first is that coordination structure is separable from other process language issues. little-jil provides rich control structures while relying on separate systems for resource, artifact, and agenda management. the second hypothesis is that processes are executed by agents that know how to perform their tasks but benefit from coordination support. accordingly, each little-jil step has an execution agent (human or automated) that is responsible for performing the work of the step.this approach has proven effective in supporting the clear and concise expression of agent coordination for a wide variety of software, workflow, and other processes.
from software requirements to architectures. the first international workshop from software requirements to architectures (straw01) was held in toronto, ontario, canada, on may 14, 2001, just before the 23rd international conference on software engineering (icse). this brief paper outlines the motivation, goals and organisation of the workshop.
managing software artifacts on the web with labyrinth. software developers are increasingly exploiting the web as a document management system. however, the web has some limitations, since it is not aware of the structure and semantics associated to pieces of information (e.g., the fact that a document is a requirement specification) and of the semantics of relationships between pieces of information (e.g., the fact that a requirement specification document may be associated to some design specification document). in the labyrinth project we enhance the capabilities of the web as a document management system by means of a semantic model (called schema, in analogy with database schemas), which is associated to web documents. this model is itself a web document and can be accessed and navigated through a simple web browser.
p2p file sharing analysis for a better performance. the so-called second generation p2p file-sharing applications have with no doubt a better performance than the first implementations. the most remarkable difference is due to the file division into smaller pieces, where a receiving peer of any piece automatically becomes a new source to other peers. but a new question arises on how we distribute all the pieces provided by a seed peer to minimize the global and presumably individual download times. in this paper we summarize part of the work we have developed up until now to answer this general question, in particular, we will analyze how close the present second generation p2p file-sharing applications remain from an ideal solution with the theoretical best performance, that is, where all peers are interconnected with each other and all peers have an altruistic behavior always uploading its contents at any chance. successive modifications of the ideal solution will lead us to more realistic scenarios. we will estimate the performance on each case and finally present the current studies we are carrying out to improve the overall capacity.
autonomous adaptation to dynamic availability using a service-oriented component model. this paper describes a project, called gravity, that defines a component model, where components provide and require services (i.e., functionality) and all component interaction occurs via services. this approach introduces service-oriented concepts into a component model and execution environment. the goal is to support the construction and execution of component-based applications that are capable of autonomously adapting at run time due to the dynamic availability of the services provided by constituent components. in this component model the execution environment manages an application that is described as an abstract composition that can adapt and evolve at run time depending on available functionality. the motivation of gravity is to simplify the construction of applications where dynamic availability arises, ranging from modern extensible systems to novel computing approaches, such as contrext-aware applications.
safety verification in murphy using fault tree analysis. murphy is a language-independent, experimental methodology for building safety-critical, real time software, which will include an integrated tool set. using ada as an example, this paper presents a technique for verifying the safety of complex, real-time software using software fault tree analysis. the templates for ada are presented along with an example of applying the technique to an ada program. the tools in the murphy tool set to aid in this type of analysis are described.
modular verification of software components in c. we present a new methodology for automatic verification of c programs against finite state machine specifications. our approach is compositional, naturally enabling us to decompose the verification of large software system into subproblems of manageable complexity. the decomposition reflects the modularity in the software design. we use weak simulation as the notion of conformance between the program and its specification. following the abstract-verify-refine paradigm, our tool magic first extracts a finite model from c source code using predicate abstraction and theorem proving. subsequently, simulation is checked via a reduction to boolean satisfiability. magic is able to interface with several publicly available theorem provers and sat solvers. we report experimental results with procedures from the linux kernel and the openssl toolkit.
decoupling synchronization from local control for efficient symbolic model checking of statecharts. symbolic model checking is a powerful formal verification technique for reactive systems. we address the problem of symbolic model checking for software specifications written as statecharts. we concentrate on how the synchronization of statecharts relates to the efficiency of model checking. we show that statecharts synchronized in an oblivious manner, such that the synchronization and the local control are decoupled, tend to be easier for symbolic analysis. based on this insight, the verification of some non-oblivious systems can be optimized by a simple, transparent modification to the model to separate the synchronization from the local control. the technique enabled the analysis of the statecharts model of a fault tolerant electrical power distribution system developed by the boeing commercial airplane group. the results disclosed subtle modeling and logical flaws not found by simulation.
promises: limited specifications for analysis and manipulation. structural change in a large system is hindered when information is missing about portions of the system, as is often the case in a distributed development process. an annotation mechanism called promises is described for expressing properties that can enable many kinds of structural change in systems. promises act as surrogates for an actual component, and thus are analogous to &ldquo;header&rdquo; files, but with more specific semantic information. unlike formal specifications, however, promises are designed to be easily extracted from systems and managed by programmers using automatic analysis tools. promises are described for effects, unique references, and use properties. by using promises, a component developer can offer additional opportunity for change (flexibility) to clients, but at a potential cost in flexibility for the component itself. this suggests the possibility of using promises as a means to allocate flexibility among the components of a system
drt: a tool for design recovery of interactive graphical applications. nowadays, the majority of productivity applications are interactive and graphical in nature. in this demonstration, we explore the possibility of taking advantage of these two characteristics in a design recovery tool. specifically, the fact that an application is interactive means that we can identify distinct execution bursts corresponding closely to "actions" performed by the user. the fact that the application is graphical means that we can describe those actions visually from a fragment of the application display itself. combining these two ideas, we obtain an explicit mapping from high-level actions performed by a user (similar to use case scenarios/specification fragments) to their low-level implementation. this mapping can be used for design recovery of interactive graphical applications. we demonstrate our approach using lyx, a scientific word processor.
design recovery of interactive graphical applications. nowadays, the majority of productivity applications are interactive and graphical in nature. in this paper, we explore the possibility of taking advantage of these two characteristics in a design recovery tool. specifically, the fact that an application is interactive means that we can identify distinct execution bursts corresponding closely to "actions" performed by the user. the fact that the application is graphical means that we can describe those actions visually from a fragment of the application display itself. combining these two ideas, we obtain an explicit mapping from high-level actions performed by a user (similar to use case scenarios/specification fragments) to their low-level implementation. this mapping can be used for design recovery of interactive graphical applications. we demonstrate our approach using lyx, a scientific word processor.
software model checking in practice: an industrial case study. we present an application of software model checking to the analysis of a large industrial software product: lucent technologies' cdma call-processing library. this software is deployed on thousands of base stations in wireless networks world-wide, where it sets up and manages millions of calls to and from mobile devices everyday. our analysis of this software was carried out using verisoft, a tool developed at bell laboratories that implements model-checking algorithms for systematically testing concurrent reactive software.verisoft has now been used for over a year for analyzing several releases and versions of the cdma call-processing software. although we started this work with a fairly robust version of the software, the application of model checking exposed several problems that had escaped traditional testing. model checking also helped developers maintain a high degree of confidence in the library as it evolved through its many releases and versions.to our knowledge, software model checking has rarely been applied to software systems of this scale. in this paper, we describe our experience in applying this technology in an industrial environment.
bayesian models of design based on intuition. most computer system designers use a great deal of intuition in the design process. intuition is often used to handle uncertainty in design parameters. since uncertainty seems to be intrinsic to most design problems it follows that designers will continue to rely on intuition or &ldquo;sound engineering judgement&rdquo;. this paper attempts to use bayesian decision theory to explore the possibility of setting up a structure and theory for making design decisions in the computer system design environment while explicitly taking the intuitive nature of many design decisions into account. we shall focus attention on a particular problem in distributed data base design in which the designer must use his intuition to estimate the load on the system which he is designing. similar bayesian approaches could be used in other design problems.
symbolic model checking of declarative relational models. this paper explores the idea of augmenting traditional model checkers with the expressiveness of a declarative, relational language. the goal is to enable programmers to write very intuitive and compact specifications, in order to allow the automatic verification of more complicated software systems. the key idea is that many structural operations (common in object-oriented programs) can be easily described using relations and relational operators, while other operations are best described using the primitive data types and their operations (such as simple arithmetic operations on numbers). by allowing a mixture of both, and by allowing parts of the model to be described declaratively rather than imperatively, the programmer has the freedom to model each part of the system differently, using the most intuitive and simple constructs. we built a bdd-based model checker for the language, and successfully verified a straightforward model of the dependency algorithm in apache ant for up to 5 nodes.
fluent-based web animation: exploring goals for requirements validation. we present a tool that provides effective graphical animations as a means of validating both goals and software designs. goals are objectives that a system is expected to meet. they are decomposed until they can be represented as fluents. animations are specified in terms of fluents and driven by behaviour models.
evaluating object-oriented designs with link analysis. the hyperlink induced topic search algorithm,which is a method of link analysis, primarily developedfor retrieving information from the web, is extended inthis paper, in order to evaluate one aspect of quality inan object-oriented model. considering the number ofdiscrete messages exchanged between classes, it ispossible to identify "god" classes in the system, elementswhich imply a poorly designed model. the principaleigenvectors of matrices derived from the adjacencymatrix of a modified class diagram, are used to identifyand quantify heavily loaded portions of an object-orienteddesign that deviate from the principle ofdistributed responsibilities. the non-principaleigenvectors are also employed in order to identifypossible reusable components in the system. themethodology can be easily automated as illustrated by ajava program that has been developed for this purpose.