waashk/dblp huggingface dataset:
identifying "good" architectural design alternatives with multi-objective optimization strategies. architecture trade-off analysis methods are appropriate techniques to evaluate design decisions and design alternatives with respect to conflicting quality requirements. however, the identification of good design alternatives is a time consuming task, which is currently performed manually. to automate this task, this paper proposes to use evolutionary algorithms and multi-objective optimization strategies based on architecture refactorings to identify a sufficient set of design alternatives. this approach will reduce development costs and improve the quality of the final system, because an automated and systematic search will identify more and better design alternatives.
fourth international workshop on dynamic analysis (woda 2006). dynamic analysis techniques reason over program executions and deal with data produced at program execution time. dynamic analysis and static analysis techniques complement each other. hence, a key focus of the workshop is dynamic analysis of software systems with an emphasis on research that integrates static and dynamic analyses.
a case study of a corporate open source development model. open source practices and tools have proven to be highly effective for overcoming the many problems of geographically distributed software development. we know relatively little, however, about the range of settings in which they work. in particular, can corporations use the open source development model effectively for software projects inside the corporate domain? or are these tools and practices incompatible with development environments, management practices, and market-driven schedule and feature decisions typical of a commercial software house? we present a case study of open source software development methodology adopted by a significant commercial software project in the telecommunications domain. we extract a number of lessons learned from the experience, and identify open research questions.
towards the principled design of software engineering diagrams. diagrammatic specification, modelling and programming languages are increasingly prevalent in software engineering and, it is often claimed, provide natural representations which permit of intuitive reasoning. a desirable goal of software engineering is the rigorous justification of such reasoning, yet many formal accounts of diagrammatic languages confuse or destroy any natural reading of the diagrams. hence they cannot be said to be intuitive. the answer, we feel, is to examine seriously the meaning and accuracy of the terms &ldquo;natural&rdquo; and &ldquo;intuitive&rdquo; in this context. this paper highlights, and illustrates by means of examples taken from industrial practice, an ongoing research theme of the authors. we take a deeper and more cognitively informed consideration of diagrams which leads us to a more natural formal underpinning that permits (i) the formal justification of informal intuitive arguments, without placing the onus of formality upon the engineer constructing the argument; and (ii) a principled approach to the identification of intuitive (and counter-intuitive) features of diagrammatic languages.
the design of data type specifications. this paper is about the design of data types in creating a software system. the major point is to explore a means for specifying a data type which is independent of its eventual implementation. the particular style of specification, called algebraic axioms, is exhibited by axiomatizing many commonly used data types. as such, these examples reveal a great deal about the intricacies of data type specification via algebraic axioms, and, in addition, provide a standard to which alternative forms may be compared. further uses of this specification technique are in proving the correctness of implementations and in interpretively executing a large system design before actual implementation commences.
feature-based decomposition of inductive proofs applied to real-time avionics software: an experience report. the hardware and software in modern aircraft controlsystems are good candidates for verification using formalmethods: they are complex, safety-critical, and challengethe capabilities of test-based verification strategies. wehave previously reported on our use of model checking toverify the time partitioning property of the deos¿ real-timeoperating system for embedded avionics. the size and complexityof this system have limited us to analyzing only oneconfiguration at a time. to overcome this limit and generalizeour analysis to arbitrary configurations we have turnedto theorem proving.this paper describes our use of the pvs theorem proverto analyze the deos scheduler. in addition to our inductiveproof of the time partitioning invariant, we present afeature-based technique for modeling state-transition systemsand formulating inductive invariants. this techniquefacilitates an incremental approach to theorem proving thatscales well to models of increasing complexity, and has thepotential to be applicable to a wide range of problems.
modular checking for buffer overflows in the large. we describe an ongoing project, the deployment of a modular checker to statically find and prevent every buffer overflow in future versions of a microsoft product. lightweight annotations specify requirements for safely using each buffer, and functions are checked individually to ensure they obey these requirements and do not overflow. our focus is on the incremental deployment of this technology: by layering the annotation language, using aggressive inference techniques, and slicing warnings by checker confidence, teams must pay only part of the cost of annotating a program to achieve part of the benefit, which provides incentive for further annotation. to date over 400,000 annotations have been added to specify buffer usage in the source code for this product, of which over 150,000 were automatically inferred, and over 3,000 potential buffer overflows have been found and fixed.
scientific rigour, an answer to a pragmatic question: a linguistic framework for software engineering. discussions of the role of mathematics in software engineering are common and have probably not changed much over the last few decades. there is now much discussion about the &ldquo;intuitive&rdquo; nature of software construction and analogies are drawn (falsely) with graphic design, (conventional) architecture, etc. the conclusion is that mathematics is an unnecessary luxury and that, like these other disciplines, it is not needed in everyday practice. we attempt to refute these arguments by recourse to ideas from the philosophy of science developed over the past century. we demonstrate why these ideas are applicable, why they establish a framework (in the sense of carnap) in which many central ideas in software engineering can be formalised and organised, why they refute the simplistic recourse to &ldquo;intuition&rdquo;, and why they provide a scientific/engineering framework in which contributions to the theory and practice of software engineering can be judged.
requirements analysis for real-time automation projects. it is in general accepted that the development of software consists of a series of activities which in ideal case follows one another sequentially. this general concept is represented through several life-cycle models, among which the most renowned model was proposed by b. boehm in his life-cycle model [l]. prorec (system for process oriented requirements capturing) has been developed on the basis of such a model and in the first phase of this development the analysis of the requirements and their formulations are investigated.
architecture-oriented programming using fred. implementing application-specific code conforming to architectural rules and conventions can be tedious. we will demonstrate a tool prototype for architecture-oriented programming that takes an architectural description as a set of programming patterns and provides an interactive task-based programming environment for the architecture. incorporating adaptive code generation and documentation, the tool provides a convenient way to adopt as well as effectively reuse a framework or architectural standard such as java beans.
preventing sql injection attacks using amnesia. amnesia is a tool that detects and prevents sql injection attacks by combining static analysis and runtime monitoring. empirical evaluation has shown that amnesia is both effective and efficient against sql injection.
tool interfaces in integrated project support environments. it is generally agreed that to meet these objectives and achieve integration an ipse should be built round a kernel or infrastructure of common services.coherence is then achieved if the infrastructure provides services to tools which relieve the toolwriter of the need to code, for example, user interface handling. not only does this aid uniformity, but of course it also offers economic leverage.control of the environment resides in the kernel and it is not possible for tools to ignore the controls and prejudice the integrity of the project data.sharing is achieved because the project data and its structure reside in the database which is under the control of the kernel.early efforts to build such an ipse were based on the stoneman model, where the kernel was the kapse. the crucial interface in this architecture is the kapse interface, which offers services to all tools. we did not sufficiently realise, however, that there is a major economic problem in designing a new interface from scratch. all tools which are to be used in an environment must, by definition, conform to this interface definition. this means that all the tools have to be specially written to use the new interface, and it became apparent that no single organisation could or should expect to provide a complete new tool kit in this way. rather one wants an open market in software tools, in the same way that it is hoped ada will lead to an open market in software components. the more recent history of ipse efforts, therefore, has been an attempt to resolve the conflict between the desire for integration and the need for environments to accept a wide range of tools from various sources. perhaps the most ambitious project taking this approach is aspect, a project within the uk alvey programme, which is currently delivering prototypes for evaluation. aspect aims to provide a highly functional open tool interface covering coherence, control and sharing. it does this by treating the open tool interface as a special case of an adaptable interface which provides user-defined views of the underlying kernel. this approach depends heavily on the notions of views developed in the relational database world.
a cooperative approach to support software deployment using the software dock. software deployment is an evolving collection of interrelated processes such as release, install, adapt, reconfigure, update, activate, deactivate, remove, and retire. the connectivity of large networks, such as the internet, is affecting how software deployment is performed. it is necessary to introduce new software deployment technologies that leverage this connectivity. the software dock framework creates a distributed, agent based deployment framework to support the ongoing cooperation and negotiation among software producers themselves and among software producers and software consumers. this deployment framework is enabled by the use of a standardized deployment schema for describing software systems, called the deployable software description (dsd) format. the software dock also employs agents to traverse between software producers and consumers in order to perform software deployment activities by interpreting the descriptions of software systems. the software dock infrastructure allows software producers to offer their customers high level deployment services that were previously not possible.
2nd international workshop on advances and applications of problem frames. software problems originate from real world problems. a software solution must address its real world problem in a satisfactory way. a software engineer must therefore understand the real world problem that their software intends to address. to be able to do this, the software engineer must understand the problem context and how it is to be affected by the proposed software, expressed as the requirements. without this knowledge the engineer can only hope to chance upon the right solution for the problem. application of the problem frames approach may well be a way of meeting this need.
an operational requirement description model for open systems. requirement engineering has been successfully applied to many superficial problems, but there has been little evidence of transfer to complex system construction. in this paper we present a new conceptual model which is for incomplete requirement descriptions. the model is especially designed for supporting the requirement specification and the analysis of open systems. an analysis of existing models and languages shows the main problem in requirement engineering: the harmony between a well-defined basic model and a convenient language. the new model remos combines the complex requirements of open systems with the basic characteristics of transaction-oriented systems. transaction-oriented systems are fault-tolerant and offer security and privacy mechanisms. such systems provide such excellent properties - why don't we already profit from it during requirement specification? the model remos and the applicative language relos take advantage of transaction properties. the idea remos is based on is the definition of scenarios and communicating subsystems. remos guides the users to making their requirements more clear, and relos offers a medium for requirement definition.
m. h. halstead's software science - a critical examination. karl popper has described the scientific method as &ldquo;the method of bold conjectures and ingenious and severe attempts to refute them&rdquo;. software science has made &ldquo;bold conjectures&rdquo; in postulating specific relationships between various 'metrics' of software code and in ascribing psychological interpretations to some of these metrics. this paper describes tests made on the validity of the relationships and interpretations which form the foundations of software science. the results indicate that the majority of them represent neither natural laws nor useful engineering approximations.
measuring reliability of computer center software. this paper investigates the application of the execution time theory of software reliability [1,2] to operational computation center software. a brief review of software reliability concepts is provided. studies of individual operating system components are discussed, as well as a functional subsystem. this work is based on data taken at a large operating computation center over a period of 15 months.
theory of software reliability based on components. we present a foundational theory of software system reliability based on components. the theory describes how component developers can design and test their components to produce measurements that are later used by system designers to calculate composite system reliability &mdash; without implementation and test of the system being designed. the theory describes how to make component measurements that are independent of operational profiles, and how to incorporate the overall system-level operational profile into the system reliability calculations. in principle, the theory resolves the central problem of assessing a component, which is: a component developer cannot know how the component will be used and so cannot certify it for an arbitrary use; but if the component buyer must certify each component before using it, component-based development loses much of its appeal. this dilemma is resolved if the component developer does the certification and provides the results in such a way that the component buyer can factor in the usage information later, without repeating the certification. our theory addresses the basic technical problems inherent in certifying components to be released for later use in an arbitrary system. most component research has been directed at functional specification of software components; our theory addresses the other, equally important, side of the coin: component quality.
a framework for data base semantic integrity. a structured framework is provided for describing the semantic integrity requirements of a data base. the semantic integrity of a data base is said to be violated when the data base ceases to represent a legitimate configuration of the application domain it is intended to model. in the context of the relational data model, it is possible to identify multiple levels of semantic integrity information. relation constraints comprise one such level; they express the semantic information not contained in the structure of the relations nor in the identity of their underlying domains. the three components of a relation constraint are considered: (1) the assertion (a predicate on the state of the data base or on transitions between data base states), (2) the validity requirement (the occasion(s) at which the assertion must hold), and (3) the violation-action (the action that is to occur if the assertion does not hold at a time when it should). a framework for relation constraints is presented. details of a structured classification scheme are outlined. this scheme is intended to form a basis for a high level, well-directed, and disciplined methodology for the design of relational data bases. emphasis is placed on the assertion component of relation constraints. assertions are viewed as more than expressions of some relationship among different values in a data base; assertions single out the data that is constrained, and state the properties that this data must possess. a classification is provided of the various predicate types used to identify constrained data and to state the properties which they are to possess. approaches to the relation constraint assertion specification process are discussed.
managing exceptions in the medical workflow systems. over the years, medical informatics researchers have studied how to use software technologies to provide decision support for using evidence-based medical procedures. software professionals have investigated how to support hospital administration, therapy and laboratory workflows. for many of these efforts, managing the exceptions in the workflows is a key issue since the medical workflows must cope with a wide variety of patient medical situations as well as those of the healthcare environments. this paper presents an analysis of past research in managing medical workflow exceptions, and proposes future research that would benefit the medical applications. the paper is focused on three topics: representing, handling and analyzing exceptions. based upon our analysis, we believe that techniques for verifying exception management models and for handling dynamic exceptions should be useful and possibly essential for developing large scale, practical medical workflow systems.
a learning curve based simulation model for software development. many of the non conventional software development methodologies (such as object-oriented analysis methodology) and tools (such as visual programming environment) have been applied in real life projects. these projects have been started without sufficient previous training given to the developers. an increment in the productivity has been seen as the projects progress. this paper proposes a simulation model for software development which can deal with variances of developers' productivity during software development. as the proposed model takes into account the developer's learning curve, it can be used to compute a developer's productivity and the quantity of gain to the developer's knowledge in executing an activity. the proposed model has been applied to four typical scenarios in our case study. the results show that it is highly practicable. an outline of a project planning prototype which is based on the proposed model is presented. the prototype can be used to make project plans which take the developer's learning curve into consideration
tracking down software bugs using automatic anomaly detection. this paper introduces diduce, a practical and effective tool that aids programmers in detecting complex program errors and identifying their root causes. by instrumenting a program and observing its behavior as it runs, diduce dynamically formulates hypotheses of invariants obeyed by the program. diduce hypothesizes the strictest invariants at the beginning, and gradually relaxes the hypothesis as violations are detected to allow for new behavior. the violations reported help users to catch software bugs as soon as they occur. they also give programmers new visibility into the behavior of the programs such as identifying rare corner cases in the program logic or even locating hidden errors that corrupt the program's results.we implemented the diduce system for java programs and applied it to four programs of significant size and complexity. diduce succeeded in identifying the root causes of programming errors in each of the programs quickly and automatically. in particular, diduce is effective in isolating a timing-dependent bug in a released jsse (java secure socket extension) library, which would have taken an experienced programmer days to find. our experience suggests that detecting and checking program invariants dynamically is a simple and effective methodology for debugging many different kinds of program errors across a wide variety of application domains.
a systems engineering view of requirements management for software-intensive systems. the importance of requirements management is widely understood and appreciated. nevertheless, the rules used to guide the process, while recognized, but rarely followed in a consistent way. requirements management often exists as a vague, undefined collection of process fragments. this presentation explores the system decomposition function of systems engineering. transition zones are defined that mark the boundaries where, during the decomposition process, the change of technical disciplines is needed. the success of the requirements management process here is defined as the systems engineer's ability to recognize and manage these transitions.
improving test suites via operational abstraction. this paper presents the operational difference technique for generating, augmenting, and minimizing test suites. the technique is analogous to structural code coverage techniques, but it operates in the semantic domain of program properties rather than the syntactic domain of program text.the operational difference technique automatically selects test cases; it assumes only the existence of a source of test cases. the technique dynamically generates operational abstractions (which describe observed behavior and are syntactically identical to formal specifications) from test suite executions. test suites can be generated by adding cases until the operational abstraction stops changing. the resulting test suites are as small, and detect as many faults, as suites with 100% branch coverage, and are better at detecting certain common faults.this paper also presents the area and stacking techniques for comparing test suite generation strategies; these techniques avoid bias due to test suite size.
executable object modeling with statecharts. a behaviorally expressive set of diagrammatic languages for modeling object-oriented systems is presented. it constitutes the constructive subset of uml, and is supported by rhapsody, a tool that enables model execution and full code synthesis.