waashk/dblp huggingface dataset:
responsibilities and rewards: specifying design patterns. design patterns provide guidance to system designers onhow to structure individual classes or groups of classes, aswell as constraints on the interactions among these classes,to enable them to implement flexible and reliable systems.patterns are usually described informally. while such informaldescriptions are useful and even essential, if we wantto be sure that designers precisely and unambiguously understandthe requirements that must be met when applyinga given pattern, and be able to reliably predict the behaviorsthe resulting system will exhibit, we also need formalcharacterizations of the patterns.in this paper, we develop an approach to formalizing designpatterns. the requirements that a designer must meetwith respect to the structures of the classes, as well as withrespect to the behaviors exhibited by the relevant methods,are captured in the responsibilities component of the patternýsspecification; the benefits that will result by applyingthe pattern, in terms of specific behaviors that the resultingsystem will be guaranteed to exhibit, are captured in therewards component. one important aspect of many designpatterns is their flexibility; our approach is designed to ensurethat this flexibility is retained in the formalization ofthe pattern. we illustrate the approach by applying it to astandard design pattern.
a spiral approach to software engineering project management education. this paper describes the experiences of an instructor, experienced in management, teaching a software engineering project management course at a school that specializes in software education. a "spiral approach" was used to provide for the parallel acquisition of management knowledge and experience, while building on recently acquired skills in software technology and developing confidence through the successful development of a software product. this paper describes the reason for selecting the approach, the course content, the observation of the students and the instructor, the advantages and disadvantages of the approach as applied, and conclusions. course objectives were met and course evaluations by students indicated a much higher level of acceptance than previous traditional approaches. the observations indicated that the approach may extend beyond the classroom to the industrial setting where on the job training, career path planning, and management development are of concern.
a compositional formalization of connector wrappers. increasingly systems are composed of parts: software components, and the interaction mechanisms (connectors) that enable them to communicate. when assembling systems from independently developed and potentially mismatched parts, wrappers may be used to overcome mismatch as well as to remedy extra-functional defciencies.unfortunately the current practice of wrapper creation and use is ad hoc, resulting in artifacts that are often hard to reuse or compose, and whose impact is diffcult to analyze. what is needed is a more principled basis for creating, understanding, and applying wrappers. focusing on the class of connector wrappers (wrappers that address issues related to communication and compatibility), we present a means of characterizing connector wrappers as protocol transformations, modularizing them, and reasoning about their properties. examples are drawn from commonly practiced dependability enhancing techniques.
mixin up components. recently we proposed a language called acoel (a component-oriented extension language) for abstracting and composing software components. components in acoel are black-box components, and each component consists of (1) an internal implementation containing classes, methods, and fields that is hidden to the external world, and (2) an external contract consisting of a set of typed input and output ports. components in acoel interact with each other only via these ports. in this paper we extend acoel in two directions: (1) use mixins to customize the services provided by a component without exposing its internal implementation, (2) add support for virtual types and sub-type relation among components. we will show how mixins and virtual types together allows us to build adaptable applications based on black-box component principles.
object oriented reuse: experience in developing a framework for speech recognition applications. the development of highly interactive software systems with complex user interfaces has become increasingly common, where prototypes are often used as a vehicle for demonstrating visions of innovative systems. given this trend, it is important for new technology to be based on flexible architectures that do not mandate the understanding of all complexities inherent in a system. in this context, we share our experience with developing an object oriented framework for a specific new technology, i.e. speech recognition. we describe the benefits of the object oriented paradigm rich with design patterns, which provide a natural way to model complex concepts and capture system relationships effectively, along with achieving a high level of software reuse
software engineering for undergraduates. software engineering has evolved, over a short period of time, into a dominant and omnipresent industry. in education we have recognized the importance of both managerial and technical aspects, but often failed to organize them in a coherent course with a relevant, if not realistic laboratory project. the problem is far-reaching, and should be dealt with accordingly. this paper presents our before and after findings, and elaborates on cpe 207, the new software engineering course that, in our opinion, helps in bridging the gap between university and industry.
a collection of software tools for analyzing design of concurrent software systems. we present results from a research project to investigate the feasibility of software tools for analyzing designs of software systems. such analysis would help the software developer to assess the acceptability of designs before the development of the software moves from the design phase into the implementation phase. if this could be done, futile implementation efforts based on faulty designs could be avoided. we have constructed a language for expressing designs of sequential and concurrent software systems, and software tools to analyze these designs. our analysis tools derive behavior information, in terms of reachable states or possible sequences of significant events, from system descriptions in a variety of ways. by means of controlled human-factors experiments, we have determined that our analysis tools and techniques are indeed useful, to varying extents, in helping people to understand designs and find flaws in them.
database theory for supporting specification-based database systems development. we report on the development of a formal theory of databases designed to support specification-based development of database systems. this theory formalizes database systems which include non-first normal form relations, complex integrity constraints, transactions, and embedded data types such as integers, character strings, and user-defined types. our theory is based on two axiomatized algebras (abstract data types) and is being used to mechanically prove the properties of relational algebra and functional dependencies, as well as the relationships between integrity constraints and the primitive operations on databases, e. g., inserts and deletes of tuples. we are also using the theory to prove whether or not specific transactions obey complex integrity constraints which can include universal and existential quantifiers. the latter proofs (as well as failed attempts at proofs) can be used during the design of specific systems and in the optimization of system implementations.
on the role of an environment. it is suggested that the role of an environment is to support effective use of an effective process. such a process is complex, varied, organisation-specific, and evolving. consideration of these process characteristics raises a number of issues concerning the scope of an environment, its overall architecture, and its data structures.
requirements expression and verification aid. samm is a top-down dominated activity modeling technique which has a representation scheme which has been automated. the automation, called samdf, validates the input, verifies the model, and produces a document illustrating the functional relationships of the system being modeled. sammdf significantly enhances the perception of system requirements, and it is this perception that benefits the design produced from the requirements.
an analysis of the resources used in the safeguard system software development. the safeguard system represents the development of one of the largest, most complex software systems ever undertaken. various types of software were developed, including real time applications, support, and hardware installation and maintenance. two million instructions were developed at a cost of approximately five thousand staff years of effort. the objective of this paper is to document the staff resources utilized in this development. the actual development rates for the different types of software and the various factors affecting those rates are analyzed. software productivity is shown to be a function of the type of software - logical, algorithmic, man machine, etc. emphasis is placed upon total project productivity. the allocation of staff resources for the systems engineering, design, code and unit test, and integration activities, which had an approximate percentage distribution of 20, 20, 17, 43, is analyzed and characterized.
the software engineering of agent-based intelligent adaptive systems. future software systems will be intelligent and adaptive. they will have the ability to seamlessly integrate with smart applications that have not been explicitly designed to work together. traditional software engineering approaches offer limited support for the development of intelligent systems. to handle the tremendous complexity and the new engineering challenges presented by intelligence, adaptiveness and seamless integration, developers need higher-level development constructs. agent concepts are natural to describe intelligent adaptive systems. agent-based technologies have been incorporating software engineering practices, and have matured to offer useful insights and concrete practices to mainstream software engineers.this tutorial presents the state of the art in agent development from a software engineering perspective, focusing on practices that are applicable today. we will walk the audience through analysis, design and verification of a portion of a real-world problem: a smart home network. we show how agent concepts more naturally match the engineering challenges of such systems like trust between adaptive components. the audience will have hands-on experience with analyzing and designing parts of the smart home network and learn how to incorporate agent technologies into their current projects.
some experience in building portable software. several authors have discussed methodology for making software portable, but less has been written about the specific components of programs which are likely to be system-dependent. this paper is based on several years of successful experience in making a major software product (mark iv) transportable among many operating systems and machines. the product is implemented in assembly language and developed on a single support system for all of the "target" systems. the specific strategies and conclusions presented here are based on more general principles, and should be more or less applicable to systems developed in higher-level languages. the system dependencies are isolated in as few modules as possible. various techniques are used to include system-dependent code at assembly time, at installation tape creation time and at customer installation time. the system-dependent functions addressed by this paper are: program start and termination, input/output, primary storage management, interrupt control, checkpointing, module loading, overlay structures and object module format and other installation considerations.
test templates: a specification-based testing framework. test templates and a test template framework are introduced as useful concepts in specification-based testing. the framework can be defined using any model-based specification notation and used to derive tests from model-based specifications. it is demonstrated using the z notation. the framework formally defines test data sets and their relation to the operations in a specification and other test data sets, providing structure to the testing process. flexibility is also preserved, so that many testing strategies can be used. important application areas of the framework are discussed, including refinement of test data, regression testing, and test oracles
a comparison of the use of links and secondary indices in a relational data base system. the possibility of supporting relational data sublanguages on top of a data base system with an underlying network data structure has been widely suggested. in this paper we present a formal model of a mix of interactions in one non procedural relational language. under a collection of assumptions concerning the data base and the performance criteria, we compare the following performance oriented data structures: (1) secondary indices (2) a network structure similar to a pointer array implementation of dbtg sets (3) structures 1) and 2) together it is shown that option 2) is never preferred to both @@@@ and 3) over the range of model parameters, hence, the sole use of sets or &ldquo;links&rdquo; as a performance oriented access path is questionable.
traceability for system families. system families are an idea of software reuse in a specific problem domain. existing methods have little requirements engineering support for system family development. this short paper proposes a requirements metamodel for system family development. traceability throughout model elements is a necessary precondition for preserving the consistency of the complete family model during development and is a main issue in this paper as well as for software development in general. family development based on the metamodel guarantees traceability by the inclusion of all development artifacts in a single and consistent model.
testing concurrent java components. testing concurrent software is notoriously difficult due to problems with non-determinism and synchronisation. while tools and techniques for the testing of sequential components are well-understood and widely used, similar tools and techniques for concurrent components are not commonly available. this tutorial will look at the problems associated with testing concurrent components and propose techniques for dealing with these problems. the conan (concurrency analyser) testing tool supports these techniques for the testing of concurrent java components and will be discussed and demonstrated in the tutorial. the limitations of the techniques and conan, as well as additional v&v tools and techniques to address these limitations will be presented.
how software is really engineered? the term software engineering currently ranks high on the list of today's popular buzz words. yet we still don't agree on its definition and often overlook many pragmatics associated with its use. a software engineering community is emerging which is devoting a great deal of attention to various &ldquo;systematic&rdquo; programming methodologies and automated programming tools. much of this problem stems from the difficulty of combining theoretically rich technology with an aesthetically unpleasant engineering philosophy. this engineering philosophy espouses doing what appears to be necessary to complete a large project. it is this last point which i would like to explore in the balance of this short paper. this paper will explore various pragmatic aspects of real world projects relating to &ldquo;software engineering.&rdquo; the subsequent panel discussion will serve as a forum for relating specific observations from typical project environments. extrapolation of these observations to future projects will also be discussed.
abstract models of dialogue concepts. we introduce formal, abstract models for specifying modern dialogue concepts offered by dialogue interfaces. the dialogue concepts considered in this paper are menus, forms, and windows. using these abstract models a totally formal definition of man-machine interactions and screen layouts is achieved. thus the semantics of user actions can be formalized. the specification method we are using is the vienna development method. examples are taken from the application development and support system ads which offers dialogue functions for generating and using application systems.
supporting dynamic composition of components. the internet creates new opportunities for component distribution. infrastructure for dynamic, web-based composition of software components appears to be a very impelling need. this demonstration focuses on a web-based system that supports dynamic component composition.
holmes: an intelligent system to support software product line development. holmes is a software product line tool that supports all core activities of software product line analysis and development. holmes integrates its tools using a blackboard architecture based on a linda tuple space. a novel feature is the use of a critiquing system to provide semantic support. this is demonstrated with an example.
7th international workshop on economics-driven software engineering research. the 7th international workshop on economics-driven software engineering research (edser-7) continues to be the leading forum for the discussion of emerging research ideas in software economics. the focus of the workshop is on the use of economic models for reasoning about technical issues and decisions in the definition, design, development, deployment, and evolution of software and software-intensive systems.
experience assessing an architectural approach to large-scale systematic reuse. systematic reuse of large-scale software components promises rapid, low cost development of high-quality software through the straightforward integration of existing software assets. to date this promise remains largely unrealized, owing to technical, managerial, cultural, and legal barriers, one important technical barrier is architectural mismatch. recently, several component integration architectures have been developed that purport to promote large-scale reuse. microsoft's ole technology and associated applications are representative of this trend. to understand the potential of these architectures to enable large-scale reuse, we evaluated ole by using it to develop a novel fault-tree analysis tool. although difficulties remain, the approach appears to overcome architectural impediments that have hindered some previous large-scale reuse attempts, to be practical for use in many domains, and to represent significant progress towards realizing the promise of barge-scale systematic reuse.
information survivability control systems. we address the dependence of critical infrastructures-including electric power, telecommunications, finance and transportation-on vulnerable information systems. our approach is based on the notion of control systems. we envision hierarchical, adaptive, multiple model, discrete state distributed control systems to monitor infrastructure information systems and respond to disruptions (e.g., security attacks) by changing operating modes and design configurations to minimize loss of utility. to explore and evaluate our approach, we have developed a toolkit for building distributed dynamic models of infrastructure information systems. we used this toolkit to build a model of a simple subset of the united states payment system and a control system for this model information system.
science of design. in this plenary panel session, three distinguished scholars of design will provide a range of perspectives on a science of design for software and software-intensive systems. the session will include brief presentations by the panelists as well as dialog among the panelists and with members of the audience.
a web-oriented architectural aspect for the emerging computational tapestry. an emerging tapestry of computations will soon integrate systems around the globe. it will evolve without central control. its complexity will be vast. we need new ideas, tools and methods to help map, understand and manage this tapestry. we contribute a light-weight architectural aspect that designers can use without compromising their own architectural preferences. widespread use could help. the idea is for objects to provide web-based interfaces to object-specific meta-data, state, and monitoring and control services. we discuss applications, implementation, scalability, performance, tradeoffs, and related work.
software quality assessment technology. necessities for software quality measurement and assurance technology have been increased. b. boehm and mccall proposed software evaluation criteria. based on these studies, g. murine developed software quality metrics (sqm). sqm was applied to several projects in nec experimentally. an outline of the experiment will be presented and the results discussed. software quality measurement and assurance technology (sqmat) was developed in nec as a total technology for applying to various types and size of software projects, throughout the software life cycle.
program complexity measure for software development management. the program complexity measure currently seems to be the most capable measure for both quantitative and objective control of the software project. five program complexity measures (step count, mccabe's v(g), halstead's e, weighted statement count and process v(g)) were assessed from such a viewpoint. this empirical study was done with the data collected through a practical software project. all of these measures have highly significant correlations with the management data. application of complexity measures to software development management is discussed and a method for the detection of anomalous modules in a program is proposed.
architectural support for trust models in decentralized applications. decentralized applications are composed of distributed entities that directly interact with each other and make local autonomous decisions in the absence of a centralized coordinating authority. such decentralized applications, where entities can join and leave the system at any time, are particularly susceptible to the attacks of malicious entities. each entity therefore requires protective measures to safeguard itself against these entities. trust management solutions serve to provide effective protective measures against such malicious attacks. trust relationships help an entity model and evaluate its confidence in other entities towards securing itself. trust management is, thus, both an essential and intrinsic ingredient of decentralized applications. however, research in trust management has not focused on how trust models can be composed into a decentralized architecture. the pace architectural style, described previously [21], provides structured and detailed guidance on the assimilation of trust models into a decentralized entity's architecture. in this paper, we describe our experiments with incorporating four different reputation-based trust models into a decentralized application using the pace architectural style. our observations lead us to conclude that pace not only provides an effective and easy way to integrate trust management into decentralized applications, but also facilitates reuse while supporting different types of trust models. additionally, pace serves as a suitable platform to aid the evaluation and comparison of trust models in a fixed setting towards providing a way to choose an appropriate model for the setting.