waashk/dblp huggingface dataset:
architectural mismatch or why it's hard to build systems out of existing parts. many would argue that future breakthroughs in software productivity will depend on our ability to combine existing pieces of software to produce new applications. an important step towards this goal is the development of new techniques to detect and cope with mismatches in the assembled parts. some problems of composition are due to low-level issues of interoperability, such as mismatches in programming languages or database schemas. however, in this paper we highlight a different, and in many ways more pervasive, class of problem: architectural mismatch. specifically, we use our experience in building a family of software design environments from existing parts to illustrate a variety of types of mismatch that center around the assumptions a reusable part makes about the structure of the application in which is to appear. based on this experience we show how an architectural view of the mismatch problem exposes some fundamental, thorny problems for software composition and suggests possible research avenues needed to solve them.
nico habermann's research: a brief retrospective. the last decade and a half of nico habermann's research career focused on software engineering, and in particular on software development environments. his earlier work was oriented more towards operating systems and programming language research. we take this opportunity to look back at his research, putting it in a larger perspective, identifying some general themes that characterize his contributions to software engineering in particular, and to computer science in general
deas 2005: workshop on the design and evolution of autonomic application software. understanding software engineering issues for autonomic computing systems is critical for the software and information technology sectors, which are continually challenged to reduce the complexity of their systems. to be autonomic, a system must know itself as well as its boundaries and its environment, configure and reconfigure itself, continually optimize itself, recover or heal from malfunction, protect itself, and function in a heterogeneous world-while keeping its complexity hidden from the user. the goal of this workshop is to bring together researchers and practitioners, who investigate concepts, methodologies, techniques, technologies, and tools to design and evolve autonomic software.
traffic-aware stress testing of distributed systems based on uml models. a stress test methodology aimed at increasing chances of discovering faults related to network traffic in distributed systems is presented. the technique uses the uml 2.0 model of the distributed system under test, augmented with timing information, and is based on an analysis of the control flow in sequence diagrams. it yields stress test requirements that are made of specific control flow paths along with time values indicating when to trigger them. different variants of our stress testing technique already exist (they stress different aspects of a distributed system) and we focus here on one variant that is designed to identify and to stress test the system at the instant when data traffic on a network is maximal. using a real-world distributed system specification, we design and implement a prototype distributed system and describe, for that particular system, how the stress test cases are derived and executed using our methodology. the stress test results indicate that the technique is significantly more effective at detecting network traffic-related faults when compared to test cases based on an operational profile.
process design engineering: a methodology for real-time software development. this paper describes the process design methodology, a disciplined engineering approach to development of a real-time software process. the approach described is part of an overall software research thrust, sponsored by the bmd advanced technology center, which is directed at resolving fundamental problems of excessive cost, failure to meet schedules, and inadequate performance associated with the specification, design, implementation, and testing of bmd software processes.
reporting about industrial strength software engineering courses for undergraduates. how do you organize an "industrial strength" one semester educational programming project for up to 200 second year students? this paper reports on four years of experience with such projects at the university of paderborn and the university of braunschweig. key properties of our project design are: starting with an existing large application, regular hard deadlines with peer reviews and presentations to a large audience, working in groups, applying project and configuration management tools, a standard system architecture with interchangeable components and competing software agents, quality assurance and standard conformance testing through final overall system integration spanning all groups, and exposure to real-world project threats.
a model of roll-back recovery with multiple checkpoints. a stochastic model of a transaction oriented computer system in the presence of intermittent failures, operating with a checkpoint and roll-back recovery scheme, is proposed in the case of a hierarchy of checkpoints and failures. an analysis provides the stationary probability distribution for the model and the optimum checkpoint intervals for two cases of interest: when a fixed checkpoint is used for each failure and when the allowable checkpoint closest in time is used.
knowledge-based architectural adaptation management for self-adaptive systems. self-adaptive systems continually evaluate and modify their own behavior to meet changing demands. an important element in the construction of architecture-based self-adaptive software is the specification of adaptation policy: this extended abstract presents an overview of work towards basing such specification on architecture-centric knowledge-based policies. this approach leverages techniques from the artificial intelligence field to explicitly represent adaptation policy at the architectural level, providing for strong decoupling between policy specification and architectural compositions, and supports dynamic runtime policy evolution promoting reuse potential and runtime flexibility.
application of axiomatic methods to a specification analyser. the goal of this paper was to model a specification language and its analyser using axiomatic methods derived from those applied previously to abstract data type and state transition specifications. the models attempt to cover many interesting features of psl/psa, a widely used specification language and analyser for information systems. simple properties expected to hold for actual psl/psa were formalized and proved about some models, with assumptions about undefined parts. both model formulation and property proofs were performed within the affirm specification and verification system. the results show (1) the applicability of axiomatic methods for modeling a new kind of software system, (2) insights into the psl/psa class of specification system, (3) a possible route for formal definition of such analysers, and (4) additional lessons on the art of specification, modeling, verification, and validation.
formal methods: an international perspective. the goal of formal methods is to base the software development process upon a workable set of mathematical techniques. the common names associated with various subclasses of formal methods express both the purpose and mode of the technique; formal specification, mathematical verification, proofs of correctness, formal description languages, rigorous development methods, stepwise refinement, etc. north american and european research groups took different technical directions. the author provides the perspective of one us researcher who has been particularly influenced by the international forces shaping the formal methods field as both a technical subject and a social enterprise
observations on industrial practice using formal methods. formal methods refer to the use of mathematically based techniques in software and system engineering. the authors summarize observations on their use in a dozen applications in industrial settings. application goals ranged from reengineering to system certification. the purpose is to extract some of the key observations about practice in software engineering terms with minimal reference to formal methods terminology and glossing over distinctions among methods. the methodology of the study is described. applications include oscilloscopes, nuclear reactors, trains, planes, ships, satellites, smartcards, transaction processing, arithmetic units, networks, medical instruments, and language processors. the observations follow from a systematic survey of these applications using a structured interview process and analysis of results using a set of features covering various aspects of practice: process, methods, tools, and technology transfer
the challenges of software engineering education. we discuss the technical skills that a software engineer should possess. we take the viewpoint of a school of engineering and put the software engineer's education in the wider context of engineering education. we stress both the common aspects that crosscut all engineering fields and the specific issues that pertain to software engineering. we believe that even in a continuously evolving field like software, education should emphasize principles and recognize what are the stable and long-lasting design concepts. even though the more mundane technological solutions cannot be ignored, the students should be equipped with skills that allow them to dominate the evolution of technology.
assume-guarantee verification of source code with design-level assumptions. model checking is an automated technique that can beused to determine whether a system satisfies certain requiredproperties. to address the "state explosion" problemassociated with this technique, we propose to integrateassume-guarantee verification at different phases of systemdevelopment. during design, developers build abstract behavioralmodels of the system components and use them toestablish key properties of the system. to increase the scalabilityof model checking at this level, we have previously developedtechniques that automatically decompose the verification task by generating component assumptions for the properties to hold. the design artifacts are subsequentlyused to guide the implementation of the system, but also toenable more efficient reasoning of the source code. in particular,we propose to use assumptions generated for the designto similarly decompose the verification of the actualsystem implementation. we demonstrate our approach ona significant nasa application, where design models wereused to identify and correct a safety property violation, andthe generated assumptions allowed us to check successfullythat the property was preserved by the implementation.
advanced visual modeling (tutorial session): beyond uml. the tutorial is example driven and illustrates how the new notations are combined with those of uml, including ocl. some of the examples are drawn from industrial contexts, in particular the telecomms sector. highlights include:a crash critique of uml, stressing its weaknesses and strengths.a rich visual constraint language and an insight into subtle issues that arise when defining a visual language.lots of examples, some taken from an industrial context.a demonstration of a graphical editor (available free from the web and on disk at the tutorial) for the constraint-diagrams language.a series of 3d notations for providing rich visualizations of dynamic behavior.a vision for visual modeling tools of the futurefor more information see http://www.cs.ukc.ac.uk/people/staff/sjhk/cds.html
advanced visual modelling: beyond uml. with the adoption of uml by the omg and industry as the linguae-francae of visual systems modelling, one begins to ponder what will come next in this field? this tutorial brings a vision for visual modelling beyond uml. we present and consolidate radical new notations, proposed in a series of research papers and with quickly increasing adoption by industry, for the specification of complex systems in an intuitive visual, yet precise manner. the recurring theme of these notations is the upgrading of familiar diagrams into a powerful visual language. spider diagrams considerably extend venn-diagrams to the specification of oo-systems. most familiar oo-concepts are translated to set theoretical terms: class into set of objects, inheritance corresponding to subset, and even harel's statecharts interpreted as the set of objects in that state. constraint diagrams enhance the arrow notation to describe static system invariants which cannot be described by uml class-object diagram. reasoning rules are developed for the notation and strong completeness results are given. finally, 3d-diagrams show how the third dimension and vrml modelling can be used for a conceptual modelling of dynamic system behaviour. much of the tutorial will be based on a case study developed in industry, illustrating how the new notations are combined with those of uml, including ocl.highlights include:&bull; a crash critical overview in uml, stressing its weaknesses and strengths,&bull; a rich visual constraint language and an insight into subtle issues that arise when defining a visual language, for applying the popular design-by-contract using a visual formalism&bull; a discussion of diagrammatic reasoning with the notation, including completeness results&bull; a case study&bull; a demonstration of a graphical editor for the constraint-diagrams language&bull; a look to the future of visual modelling, including ideas about 3d modelling notations and visual modelling tools.
an integrated system for program testing using weak mutation and data flow analysis. the idea of weak mutation testing is to construct test data which would force program components such as expressions and variable references to produce a wrong 'result' if they were to contain certain types of error, for example, off-by-a-constant or wrong-variable. the idea of data flow driven testing is to construct test data which forces the execution of different interactions between variable definitions and references in a program. this paper describes a tool for fortran 77 programs which has been developed to help a user apply the weak mutation and data flow testing techniques. the tool instruments a given source program and collects a program execution history. it is then able to report on the completeness of the test data with respect to weak mutation and a family of data flow path selection criteria. some preliminary experiments with use of the tool are described.
designing and implementing : design process, architectural style, lessons learned. this paper reports on the design and implementation of a software development framework named coo (which stands for cooperation and coordination in the software process). its design process is first detailed and justified. then, the paper emphasizes its layered and subject-oriented architecture. particularly, it is shown how this architectural style leads to a very flexible and powerful way of defining, integrating and combining services in a software development environment.
interacting process classes. many reactive control systems consist of classes of interacting objects where the objects belonging to a class exhibit similar behaviors. such interacting process classes appear in telecommunication, transportation and avionics domains. in this paper, we propose a modeling and simulation technique for interacting process classes. our modeling style uses standard notations to capture behavior. in particular, the control flow of a process class is captured by a labeled transition system, unit interactions between process objects are described by message sequence charts and the structural relations are captured via class diagrams. the key feature of our approach is that our execution semantics leads to a symbolic simulation technique. our simulation strategy is both time and memory efficient and we demonstrate this on well-studied non-trivial examples of reactive systems.
the value of a usability-supporting architectural pattern in software architecture design: a controlled experiment. design patterns have been claimed to facilitate modification and improve understanding in software design. a controlled experiment was performed to assess the usefulness of portions of a usability-supporting architectural pattern (usap) in modifying the design of software architectures to support a specific usability concern. software engineering and information technology graduate students received different subsets of a usap supporting cancellation functionality. they then studied a software architecture design and made modifications to add the ability to cancel commands. results showed that participants who received a usability scenario, a list of general responsibilities, and a sample solution thought of significantly more key issues than participants who saw only the scenario. implications for software development are that usability concerns can be included at architecture design time, and that usaps can significantly help software architects to consider responsibilities inherent from usability concerns.
designing concurrent, distributed, and real-time applications with uml. object-oriented concepts are crucial in software design because they address fundamental issues of adaptation and evolution. with the proliferation of object-oriented notations and methods, the unified modeling language (uml) has emerged to provide a standardized notation for describing object-oriented models. however, for the uml notation to be effectively applied, it needs to be used with an object-oriented analysis and design method. this tutorial describes the comet method for designing real-time and distributed applications, which integrates object-oriented and concurrency concepts and uses uml.
prototyping as a tool in the specification of user requirements. one of the major problems in developing new computer applications is specifying the user's requirements such that the requirements specification is correct, complete and unambiguous. although prototyping is often considered too expensive, correcting ambiguities and misunderstandings at the specification stage is significantly cheaper than correcting a system after it has gone into production. this paper describes how a prototype was used to help specify the requirements of a computer system to manage and control a semiconductor processing facility. the cost of developing and running the prototype was less than 10% of the total software development cost.
an interactive fortran structuring aid. this paper describes a tool at the jet propulsion laboratory which aids a programmer in converting fortran to a structured syntax. the program is a highly interactive system using computer graphics techniques to facilitate the operations necessary for such a conversion. editing and structure recognition capabilities, including the ability to handle arbitrary levels of block structure, have been combined into a system that reduces the effort involved in updating old software.
using weaves for software construction and analysis. the authors discuss the architectural features of weaves, their implementation, and their use in a variety of applications. weaves are networks of concurrently executing tool fragments that communicate by passing objects. weaves are distinguished from other dataflow styles by their emphasis on instrumentation, continuous observability, and dynamic rearrangement: basic low-overhead instrumentation is inserted automatically, executing weaves can be observed at any time by means of sophisticated analysis agents, without degrading the performance of the weave, and weaves can be dynamically snipped and spliced without interrupting the data flow
architecting in the face of uncertainty: an experience report. understanding an applicationýs functional and non-functionalrequirements is normally seen as essential fordeveloping a robust product suited to client needs. thispaper describes our experiences in a project that, bynecessity, commenced well before concrete clientrequirements could be known. after a first version of theapplication was successfully released, emergingrequirements forced an evolution of the applicationarchitecture. the key reasons for this are explained,along with the architectural strategies and softwareengineering practices that were adopted. the resultingapplication architecture is highly flexible, modifiable andscalable, and therefore should provide a solid foundationfor the duration of the applicationýs lifetime.
software component quality assessment in practice: successes and practical impediments. this paper describes the authors' experiences of initiating and sustaining a project at csiro aimed at accelerating the successful adoption of cots middleware technologies in large business and scientific information systems. the projects aims are described, along with example outcomes and an assessment of what is needed for wide-scale software component quality assessments to succeed.
architectures and technologies for enterprise application integration. architects are faced with the problem of buildingenterprise scale information systems, with streamlined,automated internal business processes and web-enabledbusiness functions, all across multiple legacyapplications. the underlying architectures for suchsystems are embodied in a range of diverse productsknown as enterprise application integration (eai)technologies. in this tutorial, we highlight some of themajor problems, approaches and issues in designingeai architectures and selecting appropriatesupporting technology. the tutorial presents a rangeof the common architectural patterns frequently usedfor eai applications. it also explains service orientedarchitectures as the current best practice architecturalframework for eai. it then describes the state-or-the-artin eai technologies that support thesearchitectural styles, and discusses some of the keydesign trade-offs involved when selecting anappropriate integration technology (including buyversus build decisions).
an architects guide to enterprise application integration with j2ee and .net. architects are faced with the problem of building enterprise scale information systems, with streamlined, automated internal business processes and web-enabled business functions, all across multiple legacy applications. the underlying architectures for such systems are embodied in a range of diverse products known as enterprise application integration (eai) technologies. in this tutorial, we highlight some of the major problems, approaches and issues in designing eai architectures and selecting appropriate supporting technology. an architect's perspective on designing large-scale integrated applications is taken, and we discuss requirements elicitation, architecture patterns, eai technology and features, and risk mitigation. j2ee and .net technologies are used to illustrate the capabilities of state-or-the-art integration technologies.