waashk/dblp huggingface dataset:
paris: a system for reusing partially interpreted schemas. this paper describes paris, an implemented system that facilitates the reuse of partially interpreted schemas. a schema is a program and specification with abstract, or uninterpreted, entities. different interpretations of those entities will produce different programs. the paris system maintains a library of such schemas and provides an interactive mechanism to interpret a schema into a useful program by means of partially automated matching and verification procedures.
applying and adjusting a software process improvement model in practice: the use of the ideal model in a small software enterprise. software process improvement is a demanding and complex undertaking. to support the constitution and implementation of software process improvement schemes the software engineering institute (sei) proposes a framework, the so-called ideal model. this model is based on experiences from large organizations. the aim of the research described here was to investigate the suitability of the model for small software enterprises. it has therefore been deployed and adjusted for successful use in a small danish software company. the course of the project and the application of the model are presented and the case is reflected on the background of current knowledge about managing software process improvement as organizational change.
quantifying the costs and benefits of architectural decisions. the benefits of a software system are assessable only relative to the business goals the system has been developed to serve. in turn, these benefits result from interactions between the system's functionality and its quality attributes (such as performance, reliabilty and security). its quality attributes are, in most cases, dictated by its architectural design decisions. therefore, we argue in this paper that the software architecture is the crucial artifact to study in making design tradeoffs and in performing cost-benefit analyses. a substantial part of such an analysis is in determining the level of uncertainty with which we estimate both costs and benefits. in this paper we offer an architecture-centric approach to the economic modeling of software design decision making called cbam (cost benefit analysis method), in which costs and benefits are traded off with system quality attributes. we present the cbam, the early results from applying this method in a large-scale case study, and discuss the application of more sophisticated economic models to software decision making.
bridging the gaps between software engineering and human-computer interaction. the first international workshop on the relationships between software engineering and human-computer interaction was held on may 3--4, 2003 as part of the 2003 international conference on software engineering, in portland, or, u.s.a. this workshop was motivated by a perception among researchers, practitioners, and educators that the fields of human-computer interaction and software engineering were largely ignoring each other and that they needed to work together more closely and to understand each other better. this paper describes the motivation, goals, organization, and outputs of the workshop.
bridging the gaps ii: bridging the gaps between software engineering and human-computer interaction. the second international workshop on the relationshipsbetween software engineering and human-computer interaction was held on may 24-25, 2004 as part of the 2004 international conference on softwareengineering, in edinburgh, scotland. this workshop wasthe second at icse and the fourth in a series held at internationalconferences in the past two years. it was motivatedby a perception among researchers, practitioners,and educators that the fields of human-computer interactionand software engineering were largely ignoringeach other and that they needed to work together moreclosely and to understand each other better. this reportdescribes the motivation, goals, organization, and outputsof the workshop.
experience with performing architecture tradeoff analysis. software architectures, like complex designs in any field, embody tradeoffs made by the designers. however, these tradeoffs are not always made explicitly by the designers and they may not understand the impacts of their decisions. this paper describes the use of a scenario-based and model-based analysis technique for software architectures-called atam-that not only analyzes a software architecture with respect to multiple quality attributes, but explicitly considers the tradeoffs inherent in the design. this is a method aimed at illuminating risks in the architecture through the identification of attribute trends, rather than at precise characterizations of measurable quality attribute values. in this paper, the operationalization of atam is illustrated via a specific example in which we analyzed a u.s. army system for battlefield management.
designing and analyzing software architectures using abass (tutorial session). this tutorial will discuss, exemplify, and involve the students in the use of attribute-based architectural styles (abass)&mdash;architectural styles accompanied by explicit analysis reasoning frameworks&mdash;in both the design and analysis of software and system architectures. the tutorial has several objectives: to introduce the students to a catalog of abass covering performance, availability, testability, modifiability, and usability; to convince students that abass provide a basis for insightful reasoning about a software architecture's ability to meet its quality attribute goals; and to demonstrate the utility of abass by showing examples of how abass are used to design and analyze real-world system architectures. we will present some large excerpts from our growing abas handbook and show that abass help us in designing architectures efficiently and predictably and in quickly finding architectural risks and tradeoffs when doing analysis.
the 8th international workshop on economics-driven software engineering research. this paper presents the 8th international workshop on economics-driven software engineering research (edser-8).
agile process tailoring and problem analysis (aptly). developing software using a well-defined, well-understoodprocess improves the likelihood of deliveringa product with the required quality. enhancing thatprocess to meet recognised process standards, such ascmmi and iso 9000, can further facilitate thedevelopment of complex systems in a repeatable andpredictable way. there are tradeoffs involved, however.in particular, because projects differ in their scale, scope,and technical challenge, the same process will not suit allcircumstances. agile approaches to development, such asextreme programming (xp), scrum and crystalmethodologies, recognise this dilemma and suggest thatprocesses be tailored to each situation. the researchproblem for postgraduate investigation is to determine indetail how this can be achieved successfully. this willinclude a consideration of how best to define, maintainand give access to a knowledge base recording details ofprocess concepts, techniques and experience.
an inheritance-based technique for building simulation proofs incrementally. this paper presents a formal technique for incremental construction of system specifications, algorithm descriptions, and simulation proofs showing that algorithms meet their specifications.the technique for building specifications and algorithms incrementally allows a child specification or algorithm to inherit from its parent by two forms of incremental modification: (a) signature extension, where new actions are added to the parent, and (b) specialization (subtyping), where the child's behavior is a specialization (restriction) of the parent's behavior. the combination of signature extension and specialization provides a powerful and expressive incremental modification mechanism for introducing new types of behavior without overriding behavior of the parent; this mechanism corresponds to the subclassing for extension form of inheritance.in the case when incremental modifications are applied to both a parent specification s and a parent algorithm a, the technique allows a simulation proof showing that the child algorithm a&prime; implements the child specification s&prime; to be constructed incrementally by extending a simulation proof that algorithm a implements specification s. the new proof involves reasoning about the modifications only, without repeating the reasoning done in the original simulation proof.the paper presents the technique mathematically, in terms of automata. the technique has been used to model and verify a complex middleware system; the methodology and results of that experiment are summarized in this paper.
user interface development and software environments: the chiron-1 system. the authors discuss a list of requirements which should be met by the user interface development system (uids) to address the special demands of software environments. chiron-1 uses an annotation-based, concurrent model which makes a clear separation between an application's functional and user interface parts, while still promoting effective communication between those parts. the uids model and language interface and the uids architecture are described. the authors describe how applications are built with chiron-1, and illustrate the process with an example. important chiron-1 concepts are presented, and their significance in the software environment context is explained. the authors detail some design issues and report on the status of current work and the plans for future research
a comprehensive process model for studying software process papers. efficient and effective study of scientific papers is an important part of software engineering education. a comprehensive process model has been developed, enacted, improved and validated. the process model describes literature search, paper selection, reading, and group discussion of papers, as well as recording, validation, and retrieval of the data captured from the selected papers. the focus lies on the group discussion of the model. a model of this sub-process describes the systematic classification, analysis, and evaluation of the papers. it is used to guide the group discussion, and helps to ensure that pertinent information from the discussion is retained in an annotated database
pattern-based reverse-engineering of design components. many reverse-engineering tools have been developed to derive abstract representations from source code. yet, most of these tools completely ignore recovery of the all-important rationale behind the design decisions that have lead to its physical shape. design patterns capture the rationale behind proven design solutions and discuss the trade-offs among their alternatives. we argue that it is these patterns of thought that are at the root of many of the key elements of large-scale software systems, and that, in order to comprehend these systems, we need to recover and understand the patterns on which they were built. in this paper, we present our environment for the reverse engineering of design components based on the structural descriptions of design patterns. we give an overview of the environment, explain three case studies, and discuss how pattern-based reverse-engineering helped gain insight into the design rationale of some of the pieces of three large-scale c++ software systems.
a comparison of four design methods for real-time systems. the purpose of this paper is to compare four design methods which are of current interest in real-time software development. the comparison presents the relative strengths and weakness of each method with additional information on graphic notation and the recommended sequence of steps involved in the use of each method. the methods selected for comparison were:structured design for real-time systemsobject oriented designpamela (process abstraction method for embedded large applications)scr (software cost reduction project - naval research laboratory) readers interested in a framework for comparing methods, an overview of the four selected methodologies, and an aid to narrowing candidates for adoption should find this find this paper helpful.
cybersecurity. as more business activities are being automated and an increasing number of computers are being used to store sensitive information, the need for secure computer systems becomes more apparent. this need is even more apparent as systems and applications are being distributed and accessed via an insecure network, such as the internet. the internet itself has become critical for governments, companies, financial institutions, and millions of everyday users. networks of computers support a multitude of activities whose loss would all but cripple these organizations. as a consequence, cybersecurity issues have become national security issues. protecting the lnternet is a difficult task.cybersecurity can be obtained only through systematic development; it can not be achieved through haphazard seat-of-the-pants methods. applying software engineering techniques to the problem is a step in the right direction. however, software engineers need to be aware of the risks and security issues associated with the design, development, and deployment of network-based software.this paper introduces some known threats to cybersecurity, categorizes the threats, and analyzes protection mechanisms and techniques for countering the threats. approaches to prevent, detect, and respond to cyber attacks are also discussed.
research challenges of autonomic computing. autonomic computing is a grand-challenge vision of the future in which computing systems will manage themselves in accordance with high-level objectives specified by humans. the it industry recognizes that meeting this challenge is imperative; otherwise, it systems will soon become virtually impossible to administer. but meeting this challenge is also extremely difficult, and will require a worldwide collaboration among the best minds of academia and industry. in the hope of motivating researchers in relevant areas to apply their expertise to this vitally important problem, i outline some of the main scientific and engineering challenges that collectively make up the grand challenge of autonomic computing, and provide pointers to initial efforts to address these challenges.
specification and implementation of parallel activities on abstract objects. this paper describes a new method for the specification and implementation of parallel activities on abstract objects. the priority relationship, which is of practical importance, is an important part of this method. the syntax of a suitable specification language is given. restrictions in the lower levels of a hierarchical system can be hidden towards the upper levels (e.g. finite capacity of buffers or memories) by an appropriate use of synchronization. to make the use of a particular level as flexible as possible, the level should be subject to as few restrictions as possible. synchronization conditions on different levels can lead to deadlocks.
a comparison of lifecycle models. preliminary comparison of world views in systems development is given. the purpose of the paper is to present the finnish psc systemeering model to the software engineering (se) community and to compare it with the ideas of d. ross and practical approaches in se.
a synthetic english query language for a relational accociative processor. synthetic english is a very-high-level query language based on natural english. query specification in synthetic english parallels the user's natural thought processes, thereby allowing him to formulate complex queries without regard to implicit or explicit language control structures. synthetic english is designed to be used in conjunction with the functional data model, which is a conceptual graph model whose nodes and arcs represent sets and total functions, respectively. further, the functional model admits a transformation to the relational model representation. queries written in synthetic english are easily parsed, using semantic predication analysis and the underlying graph, into primitive templates which are in one-to-one correspondence with the high-level machine language of the relational associative processor called rap. rap is an associative and cellular back-end processor designed to support relational data bases. rap's proven performance superiority over conventional architectures, its high-level machine language, and its query processing philosophy, make the interface to synthetic english extremely efficient, avoiding intermediate-level code generation.
analysis of a scheduler for a cad framework. the experience report describes a case study in which a key component of a software system was modeled and analyzed to better understand a proposed algorithm prior to implementation. a promela model of a linear scheduler for a cad framework was developed. the spin simulator was used to debug the model and, later, to illustrate how the algorithm works in different scenarios. additionally, the spin verifier was used to check various safety and liveness properties. the study revealed a deficiency with the algorithm, as originally proposed. subsequently, the modeling tools provided by spin were used in devising solutions to the problems. finally, the promela model was modified and verified to be correct. the actual implementation of the scheduler involves a significant amount of message passing, multiple execution threads, and potentially huge data structures. by focusing on the interfaces between threads, restricting the system scope, and abstracting details of data structures and irrelevant computations, a very simple model was obtained, which nevertheless provides an accurate representation of the communication between threads. the paper describes the steps that were abstracted and highlights the restrictions imposed on the model.
extending the representational state transfer (rest) architectural style for decentralized systems. because it takes time and trust to establish agreement,traditional consensus-based architectural styles cannotsafely accommodate resources that change faster than ittakes to transmit notification of that change, nor resourcesthat must be shared across independent agencies.the alternative is decentralization: permitting independentagencies to make their own decisions. ourdefinition contrasts with that of distribution, in whichseveral agents share control of a single decision.ultimately, the physical limits of network latency and thesocial limits of independent agency call for solutions thatcan accommodate multiple values for the same variable.our approach to this challenge is architectural: proposingconstraints on the configuration of componentsand connectors to induce particular desired properties ofthe whole application. specifically, we present, implement,and evaluate variations of the world wide webýsrepresentational state transfer (rest) architecturalstyle that support distributed and decentralized systems.
aspect-oriented programming and modular reasoning. aspects cut new interfaces through the primary decomposition of a system. this implies that in the presence of aspects, the complete interface of a module can only be determined once the complete configuration of modules in the system is known. while this may seem anti-modular, it is an inherent property of crosscutting concerns, and using aspect-oriented programming enables modular reasoning in the presence of such concerns.
a type-checking program linkage system for pascal. we describe a new software facility useful in the development, debugging, and integration of quasi-independent program modules. it has been implemented in conjunction with a pascal compiler for ibm 360 computers, but the linkage facility is machine-independent up to the point of formattingsystem object modules. with some minor syntactic extensions to permit the designation of external references, pascal becomes a powerful language for modular programming. the new linkage subsystem allows the compile-time verification of type-correctness of pascal programs to be extended uniformly across program module interfaces. this extends not only those diagnostics formerly restricted to compilation, but also the post-mortem diagnostic capability of the progranming system, and without sacrifice of run-time efficiency. the paper also discusses several language issues raised in meeting the requirements of modular programming, as well as implementation considerations.
a software engineering experiment in software component generation. the paper presents results of a software engineering experiment in which a new technology for constructing program generators from domain-specific specification languages has been compared with a reuse technology that employs sets of reusable ada program templates. both technologies were applied to a common problem domain, constructing message translation and validation modules for military command, control, communications and information systems (c/sup 3/i). the experiment employed four subjects to conduct trials of use of the two technologies on a common set of test examples. the experiment was conducted with personnel supplied and supervised by an independent contractor. test cases consisted of message specifications taken from air force c/sup 3/i systems. the main results are that greater productivity was achieved and fewer error were introduced when subjects used the program generator than when they used ada templates to implement software modules from sets of specifications. the differences in the average performance of the subjects are statistically significant at confidence levels exceeding 99 percent.
asadal: a tool system for co-development of software and test environment based on product line engineering. recently, product line software engineering (plse) is gaining popularity. to employ plse methods, many organizations are looking for a tool system that supports plse methods so that core assets and target software can be developed and tested in an effective and systematic way.asadal (a system analysis and design aid tool) supports the entire lifecycle of software development process based on a plse method called form (feature-oriented reuse method) [6]. it supports domain analysis, architecture and component design, code generation, and simulation-based verification and validation (v&v). using the tool, users may co-develop target software and its test environment and verify software in a continuous and incremental way.
uml-based service robot software development: a case study. the research field of intelligent service robots, which has become more and more popular over the last years, covers a wide range of applications from climbing machines for cleaning large storefronts to robotic assistance for disabled or elderly people. when developing service robot software, it is a challenging problem to design the robot architecture by carefully considering user needs and requirements, implement robot application components based on the architecture, and integrate these components in a systematic and comprehensive way for maintainability and reusability. furthermore, it becomes more difficult to communicate among development teams and with others when many engineers from different teams participate in developing the service robot. to solve these problems, we applied the comet design method, which uses the industry-standard uml notation, to developing the software of an intelligent service robot for the elderly, called t-rot, under development at center for intelligent robotics (cir). in this paper, we discuss our experiences with the project in which we successfully addressed these problems and developed the autonomous navigation system of the robot with the comet/uml method.