This directory is created automatically and some papers may be mislabeled. Only document within the CiteSeer database are listed. The directory is intended to provide entry points for browsing the database and is not intended to be authoritative. Papers may not appear in all relevant categories. For example, papers in a sub-category may not appear in higher level categories.
523.4 Executable Object Modeling with Statecharts - Harel, Gery (1997)(Correct)
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 en... / of the most significant in software engineering in recent years.
472.4 Formal Methods: State of the Art and Future Directions - Clarke, Wing (1996)(Correct)
We survey recent progress in the development of mathematical techniques for specifying and verifying complex hardware and software systems. Many of these techniques are capable of handling industrial-... / Government. Keywords Software engineering formal methods formal br methods in a routine software design project within AT T Cha
457.9 Intelligent Agents: Theory and Practice - Wooldridge, Jennings (1995)(Correct)
The concept of an agent has become important in both Artificial Intelligence (AI) and mainstream computer science. Our aim in this paper is to point the reader at what we perceive to be the most impor... / can be thought of as software engineering models of agents
439.6 Foundations for the Study of Software Architecture - Perry, Wolf (1992)(Correct)
The purpose of this paper is to build the foundation for software architecture. We first develop an intuition for software architecture by appealing to several wellestablished architectural discipline... / Acm Sigsoft Software Engineering Notes Vol No Oct br work. Introduction Software design received a great deal of
417.0 The Model Checker SPIN - Holzmann (1997)(Correct)
SPIN is an efficient verification system for models of distributed software systems. It has been used to detect design
errors in applications ranging from high-level descriptions of distributed algori... / Ieee Transactions On Software Engineering Vol. No. May
414.8 The Challenges of Mobile Computing - Forman, Zahorjan (1994)(Correct)
Advances in wireless networking technology have engendered a new paradigm of
computing, called mobile computing, in which users carrying portable devices have
access to a shared infrastructure indepen... / is a survey of the fundamental software design pressures particular to
400.0 A Survey of Program Slicing Techniques - Tip (1995)(Correct)
A program slice consists of the parts of a program that (potentially) affect the
values computed at some point of interest, referred to as a slicing criterion. The task
of computing program slices is ... / CR Categories D. . Software engineering Tools and Techniques
350.6 Software Agents - Genesereth, Ketchpel (1994)(Correct)
this paper, we discuss these questions and describe some
emerging technologies that provide answers. In the final section, we mention some additional
issues and summarize the key points of the paper. ... / removed. Agent-based software engineering was invented to facilitate
345.6 The Temporal Logic of Actions - Lamport (1994)(Correct)
This report introduces TLA and describes how it is used to specify and verify concurrent algorithms. The use of TLA to specify and reason about open systems will be described elsewhere. Categories and... / Subject Descriptors D. . Software Engineering Program Verification-
345.4 A Survey of Agent-Oriented Methodologies - Iglesias, Garijo, Gonzalez (1999)(Correct)
This article introduces the current agent-oriented methodologies. It discusseswhat approacheshave been followed (mainly extending existing objectoriented and knowledge engineering methodologies), th... / approaches Section and software-engineering techniques proposed by
340.4 Acme: An Architecture Description Interchange Language - Garlan (1997)(Correct)
Numerous architectural description languages (ADLs) have been developed, each providing complementary capabilities for architectural development and analysis. Unfortunately, each ADL and supporting to... / philos ophy to the broader software engineering community at this stage
323.7 An Old-Fashioned Recipe for Real Time - Abadi, Lamport (1993)(Correct)
Traditional methods for specifying and reasoning about concurrent systems work for realtime systems. Using TLA (the temporal logic of actions), we illustrate how they work with the examples of a queu... / Subject Descriptors D. . Software Engineering Program Verification-
315.9 Shared Memory Consistency Models: A Tutorial - Adve, Gharachorloo (1995)(Correct)
Parallel systems that support the shared memory abstraction are becoming
widely accepted in many areas of computing. Writing correct and efficient
programs for such systems requires a formal specifica... / and scaling issues in system software design and the exploration of new
313.5 Specifying Distributed Software Architectures - Magee, Dulay, Eisenbach, Kramer (1994)(Correct)
There is a real need for clear and sound design specifications
of distributed systems at the architectural level. This is the level
of the design which deals with the high-level organisation of comp... / appear in the Fifth European Software Engineering Conference ESEC ' on br Foundations of Software Engineering Software Engineering Notes
281.8 LIME: Linda Meets Mobility - Picco, Murphy, Roman (1999)(Correct)
Lime is a system designed to assist in the rapid development of dependable mobile applications over both wired and ad hoc networks. Mobile agents reside on mobile hosts and all communication takes pla... / Mobility. IEEE Trans. on Software Engineering May . D. Garlan
272.7 Parametric Shape Analysis via 3-Valued Logic - Sagiv, Reps, Wilhelm (1999)(Correct)
We present a family of abstract-interpretation algorithms that are capable of determining "shape invariants" of programs that perform destructive updating on dynamically allocated storage. The main id... / Subject Descriptors D. . Software Engineering Testing and Debugging-
266.6 RMM: A Methodology for Structured Hypermedia Design - Isakowitz, Stohr, Balasubramanian (1995)(Correct)
Hypermedia application design differs from other software design in that it involves navigation
as well as user-interface and information processing issues. We present the Relationship Management
Data... / testing as in traditional software engineering projects. In hypermedia br design differs from other software design in that it involves
257.9 An Event-Based Architecture Definition Language - Luckham, Vera (1995)(Correct)
This paper discusses general requirements for
architecture definition languages, and describes the syntax
and semantics of the subset of the Rapide language that is designed
to satisfy these requireme... / now a widespread belief that software engineering must go beyond object
243.4 The Standard Template Library - Stepanov, Lee (1995)(Correct)
this document for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supp... / This significantly simplifies software design work and also makes it
203.5 KIDS: A Semi-Automatic Program Development System - Smith (1990)(Correct)
The Kestrel Interactive Development System (KIDS) provides automated support for the development of correct and efficient programs from formal specifications. The system has components for performing ... / in IEEE Transactions on Software Engineering Special Issue on Formal br of a successful automated software design system and discussion of
197.5 Exploiting Style in Architectural Design Environments - Garlan, Allen, Ockerbloom (1994)(Correct)
As the design of software architectures emerges as a discipline
within software engineering, it will become increasingly important
to support architectural description and analysis with tools and
envi... / as a discipline within software engineering it will become br Foundationsof Software Engineering Software Engineering Notes
188.4 The STATEMATE Semantics of Statecharts - Harel, Naamad (1996)(Correct)
We describe the semantics of statecharts as implemented in the Statemate system. This
was the first executable semantics defined for the language, and has been in use for almost a
decade. In terms of ... /
178.7 A Framework for Classifying and Comparing Architecture Description.. - Medvidovic (1997)(Correct)
Software architectures shift developers' focus from lines-of-code to
coarser-grained architectural elements and their interconnection structure. Architecture
description languages (ADLs) have been p... / on the Foundations of Software Engineering pages - Los Angeles br The ultimate goal of software design and modeling is to produce
177.1 Coordination Models and Languages - Papadopoulos, ARBAB (1998)(Correct)
A new class of models, formalisms and mechanisms has recently evolved for describing concurrent and distributed computations based on the concept of "coordination". The purpose of a coordination model... / Farhad Arbab Department Of Software Engineering Cwi Amsterdam The
177.1 Bro: A System for Detecting Network Intruders in Real-Time - Paxson (1998)(Correct)
We describe Bro, a stand-alone system for detecting network
intruders in real-time by passively monitoring a network
link over which the intruder's traffic transits. We give
an overview of the system'... / IEEE Transactions on Software Engineering pp. - br separate from policy Sound software design often stresses constructing
174.4 Building Reliable Distributed Systems with CORBA - Landis, Maffeis (1997)(Correct)
New classes of large-scale distributed applications will
have to deal with unpredictable communication delays,
with partial failures, and with networks that
partition. In addition, sophisticated appli... / and concurrent software engineering require a group
173.5 Standard ML of New Jersey - Appel, MacQueen (1991)(Correct)
The Standard ML of New Jersey compiler has been under development for five years now. We have developed a robust and complete environment for Standard ML that supports the implementation of large soft... / and e cient tools for software engineering. Along the way we have
171.0 Model Checking Large Software Specifications - Anderson (1996)(Correct)
In this paper we present our results and experiences of using symbolic model checking to study the specification of an aircraft collision avoidance system. Symbolic model checking has been highly succ... / on the Foundations of Software Engineering pages - October
171.0 Threads and Input/Output in the Synthesis Kernel - Massalin, Pu (1995)(Correct)
The Synthesis operating system kernel combines several techniques
to provide high performance, including kernel code synthesis, fine-grain
scheduling, and optimistic synchronization. Kernel code synth... / techniques follow from one software engineering principle called the
165.9 A Type-Based Approach to Program Security - Volpano, Smith (1997)(Correct)
This paper presents a type system which guarantees that
well-typed programs in a procedural programming language satisfy a
noninterference security property. With all program inputs and outputs
cla... / on Formal Approaches in Software Engineering Lille France -
159.4 A Sense of Self for Unix Processes - Forrest, Hofmeyr, Somayaji, Longstaff (1996)(Correct)
A method for anomaly detection is introduced in which
"normal" is defined by short-range correlations in a process
' system calls. Initial experiments suggest that the definition
is stable during norm... / CERT Coordination Center Software Engineering Institute Carnegie-Mellon
156.5 The QoS Broker - Nahrstedt, Smith (1995)(Correct)
Many networked multimedia applications are delay-sensitive, and require services with guarantees
of resource availability and timeliness. For networks such as those based on Asynchronous
Transfer Mode... / It can be viewed as a software engineering technique for distributed
154.2 Pitfalls of Agent-Oriented Development - Wooldridge, Jennings (1998)(Correct)
While the theoretical and experimental foundations of agent-based
systems are becoming increasingly well understood, comparatively
little effort has been devoted to understanding the pragmatics of
(mu... / most influential work on software engineering and software project br work on software engineering and software project management yet
154.2 Privacy via Subsumption - Riecke (1998)(Correct)
We describe an object calculus that allows both extension of objects
and full width subtyping (hiding arbitrary components). In contrast
to other proposals, the types of our calculus do not mention "m... / most important principles of software engineering is information hiding the br J. Lakos. Large-Scale CSoftware Design. AddisonWesley .
150.7 Formalizing Style to Understand Descriptions of Software Architecture - Abowd, Allen, Garlan (1995)(Correct)
The software architecture of most systems is described informally and diagrammatically by means of
boxes and lines. In order for these descriptions to be meaningful at all, the diagrams are understood... / International Conference on Software Engineering ICSE- Sorrento Italy br and A.I.Wasserman. Tutorial on software design techniques .
142.8 Autonomous Agents for Business Process Management - Jennings, Norman, Faratin, O'Brien.. (2000)(Correct)
Traditional approaches to managing business processes are often inadequate for large-scale, organisation
-wide, dynamic settings. However since Internet and Intranet technologies have become widespr... / M. Wooldridge Agent-based software engineering. IEE Proceedings on br e.g. databases spreadsheets design software etc.required to complete
137.1 Stack-Based Typed Assembly Language - Morrisett, Crary, Walker, Glew (1998)(Correct)
In previous work, we presented Typed Assembly Language (TAL). TAL is sufficiently expressive to serve as a target language for compilers of high-level languages such as ML. That work assumed such a co... / have efficiency and software engineering advantages over their
136.3 Quantitative Analysis of Faults and Failures in a Complex Software.. - Fenton (1999)(Correct)
We describe a number of results from a quantitative study of faults and failures in two releases of a major commercial system. We tested a range of basic software engineering hypotheses relating to: t... / We tested a range of basic software engineering hypotheses relating to the
136.3 Experience with EMERALD to Date - Neumann (1999)(Correct)
After summarizing the EMERALD architecture and the evolutionary process from which EMERALD has evolved, this paper focuses on our experience to date in designing, implementing, and applying EMERALD to... / importance of good software engineering practice and the
131.9 Tool support for object-oriented patterns - Florijn, Meijers, van Winsen (1997)(Correct)
A software (design) pattern describes a general solution for a recurring design problem. The solution
is mostly described in terms of an abstract design structure expressed in design elements such as
... / Abstract A software design pattern describes a general
125.7 Systematic Concurrent Object-Oriented Programming - Meyer (1993)(Correct)
How can the object-oriented model cover concurrent programming as effectively as it
addresses sequential computation?
This article suggests that a modest adaptation to the standard mechanisms of objec... / Meyer Interactive Software Engineering Inc. Storke Road Suite
121.7 A Classification and Comparison Framework for Software Architecture.. - Medvidovic (1996)(Correct)
Software architectures shift the focus of developers from lines-of-code to coarsergrained
architectural elements and their overall interconnection structure.
Architecture description languages (ADLs) ... / on the Foundations of Software Engineering pages - Los Angeles br The ultimate goal of any software design and modeling endeavor is to
121.7 Comparing Detection Methods For Software Requirements Inspections: A.. - Porter, Votta, Jr., Basili (1995)(Correct)
Software requirements specifications (SRS) are
often validated manually. One such process is inspection, in
which several reviewers independently analyze all or part of
the specification and search fo... / Symposium on Foundations of Software Engineering. Association for Computing br these concerns -at least for software designs Parnas and Weiss
118.5 SAAM: A Method for Analyzing the Properties of Software Architectures - Kazman, Bass, Abowd, Webb (1994)(Correct)
While software architecture has become an increasingly important research topic in recent years, insufficient attention has been paid to methods for evaluation of these architectures. Evaluating arc... / are primarily motivated by software engineering considerations or software br function into that structure. Software designers choose structural
118.1 Matchmaking among Heterogeneous Agents on the Internet - Sycara (1999)(Correct)
The Internet is not only providing data for users to browse, but also databases to query, and software agents to run. Due to the exponential increase of deployed agents on the Internet, automating the... / problems in the area of software engineering and AI. Some of the main
116.0 CENTAUR: the system - Borras, Clément, Despeyrouz.. (1988)(Correct)
syntax terms occur in most rules. They
have to be valid terms w.r.t. their abstract syntax.
Every such term is typed with a syntatic category.
The type-checking phase of TYPOL compilation uses
this in... /
115.9 Software Visualization in the Large - Ball, Eick (1996)(Correct)
Software is invisible, disappearing into files on disks. The invisible nature of software contributes to low programmer productivity by hiding system complexity, particularly for large team-oriented p... / Visualization can help software engineers cope with this complexity
115.9 Seven More Myths of Formal Methods - Bowen, Hinchey (1995)(Correct)
For whatever reason, formal methods remain one of the more contentious techniques in industrial software engineering. Despite great increases in the number of organizations and projects applying forma... / techniques in industrial software engineering. Despite great increases in
110.6 The Zeno Argumentation Framework - Gordon (1997)(Correct)
The Zeno Argumentation Framework is a formal model of argumentation
based on the informal models of Toulmin and Rittel.
Its main feature is a labelling function using arguments to compute
heuristic in... / section presents a software engineering analysis of the mediation
107.2 Environment Centered Analysis and Design of Coordination Mechanisms - Decker (1995)(Correct)
Environment Centered Analysis and Design of Coordination Mechanisms
May 1995
KEITH S. DECKER
B.S., Carnegie Mellon University
M.S., Rensselaer Polytechnic Institute
Ph.D., University of Massachusetts... / and in the future to model software engineering activities. . Analyzing br networks concurrent engineering software agents' for information
102.1 Agent-Based Software Engineering - Wooldridge (1997)(Correct)
The technology of intelligent agents and multi-agent systems seems set to radically
alter the way in which complex, distributed, open systems are conceptualized and implemented.
The purpose of this pa... / Agent-Based Software Engineering Michael Wooldridge
98.9 An International Survey of Industrial Applications of Formal Methods: .. - Craigen, Gerhart, Ralston (1993)(Correct)
Formal methods are mathematically-based techniques, often supported by
reasoning tools, that can offer a rigorous and effective way to model, design
and analyze computer systems. The purpose of this s... / methods in the context of software engineering. . Formal methods have br produced Production of the software design specification document and
97.8 Interactive Foundations of Computing - Wegner (1997)(Correct)
The claim that interactive systems have richer behavior than algorithms is surprisingly easy to prove:
Turing machines cannot model interaction machines because: interaction is not expressible by a... / patterns and frameworks software engineering and AI are examined
97.1 Property Specification Patterns for Finite-State Verification - Matthew Dwyer (1998)(Correct)
Finite-state verification (e.g., model checking)
provides a powerful means to detect errors that
are often subtle and difficult to reproduce. Nevertheless,
the transition of this technology from
resea... / a component of a Masters of Software Engineering curriculum. The students br of recurring solutions to software design problems but also the
92.7 Engineering and Analysis of Fixed Priority Schedulers - Katcher (1993)(Correct)
Scheduling theory holds great promise as a means to a
priori validate timing correctness of real-time applications.
However, there currently exists a wide gap between scheduling
theory and its impleme... / . .Technical Report Software Engineering Institute Carnegie Mellon br us to evaluate hardware and software design decisions for real-time
92.7 Server Operating Systems - Kaashoek, Engler, Ganger, Wallach (1996)(Correct)
We introduce server operating systems, which are sets of abstractions and runtime support for specialized, highperformance
server applications. We have designed and are implementing a prototype server... / policies. To reduce the software engineering effort involved our
89.8 A Field Guide to Boxology: Preliminary Classification of.. - Shaw, Clements (1996)(Correct)
Software architects use a number of commonly-recognized "styles" to guide their design of system structures. Each of these is appropriate for some classes of problems, but none is suitable for all p... / Science Department and Software Engineering Institute Carnegie Mellon br problems. How then does a software designer choose an architecture
88.6 The Evolving Philosophers Problem: Dynamic Change Management. - Kramer (1990)(Correct)
One of the major challenges in the provision of distributed systems is the accomodation of evolutionary change. This may involve modifications or extensions to the system which were not envisaged at d... / on IEEE Transactions on Software Engineering SE- Nov. .
88.0 Constructing Distributed Systems In Conic - Magee, Kramer, Sloman (1989)(Correct)
Abstract -- Existing distributed systems vary from those which merely provide Existing distributed systems vary from those which merely provide interconnection of autonomous systems to those which pro... / IEEE Transactions on Software Engineering SE- April pp.
86.4 LCLint: A Tool for Using Specifications to Check Code - Evans (1994)(Correct)
This paper describes LCLint, an efficient and flexible tool that accepts as input programs (written in ANSI C) and various levels of formal specification. Using this information, LCLint reports incons... / Introduction Software engineers have long understood that br a tool for promoting modular software designs and abstract data types in
85.7 Towards a Theory of Sequential Hybrid Programs - Pandya, Hanpin, Qiwen (1998)(Correct)
A theory of Sequential Hybrid Programs (SHP) is studied. These programs consist of phase
statements and the normal sequential programming constructs such as assignments, conditionals
and iterations. P... / capture and software design programming are being
85.1 An Experiment to Assess the Cost-Benefits of Code Inspections in.. - Porter, Toman, Siy, Votta (1997)(Correct)
We conducted a long-term experiment to compare the costs and benefits of several different software inspection methods. These methods were applied by professional developers to a commercial software p... / is important for software engineering researchers. Experiments br Lawrence G. Votta. Assessing software design using capture-recapture
84.0 Scenario-Based Analysis of Software Architecture - Kazman (1996)(Correct)
Software architecture is one of the most important tools for designing and understanding
a system, whether that system is in preliminary design, active deployment, or
maintenance. Scenarios are impo... / Len Bass Paul Clements Software Engineering Institute Carnegie Mellon
83.9 Security Models - McLean (1994)(Correct)
this article we focus on the primary
use of security models, which has been to describe general confidentiality requirements. We
then give pointers to security model work in other areas.
2 Models of C... / From Encyclopedia of Software Engineering ed. John Marciniak
81.8 Bayesian Analysis of Empirical Software Engineering Cost Models - Sunita Chulani (1999)(Correct)
To date many software engineering cost models have been developed to predict the cost, schedule and
quality of the software under development. But, the rapidly changing nature of software development ... / Analysis of Empirical Software Engineering Cost Models Sunita br estimation models enable the engineering software community to more
81.1 Formalizing Space Shuttle Software Requirements - Crow, Di Vito (1996)(Correct)
This paper describes two case studies in which requirements
for new flight-software subsystems on NASA's
Space Shuttle were analyzed, one using standard formal
specification techniques, the other usin... / IEEE Transactions on Software Engineering SE- - January
81.1 A Formal Framework for Agency and Autonomy - Luck, d'Inverno (1995)(Correct)
With the recent rapid growth of interest in MultiAgent Systems, both in artificial intelligence and software engineering, has come an associated difficulty concerning basic terms and concepts. In part... / artificial intelligence and software engineering has come an associated br be implicit in the hardware or software design of the robot. It is merely
80.8 Composite Design Patterns - Riehle (1997)(Correct)
Software design patterns are the core abstractions from successful recurring problem solutions in software design.
Composite design patterns are the core abstractions from successful recurring framew... / It.IEEE Transactions on Software Engineering February br staff riehle Abstract Software design patterns are the core
80.4 An Overview of Production Rules in Database Systems - Hanson, Widom (1993)(Correct)
Database researchers have recognized that integrating a production rules facility into a database system provides a uniform mechanism for a number of advanced database features including integrity con... / is a poor approach from the software engineering perspective. Integrating a
79.0 Reasoning about Time in Higher-Level Language Software - Shaw (1989)(Correct)
Introduction
Real-time systems and many other computer applications must meet specifications
and perform tasks that satisfy timing as well as logical criteria for correctness.
Examples of timing prop... / in IEEE Transactions on Software Engineering vol. no. pp.
76.5 Software Reliability via Run-Time Result-Checking - Wasserman, Blum (1994)(Correct)
ing with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works, requires prior specific permission and... / Subject Descriptors D. . Software Engineering Testing and Debugging
76.2 The ADAPTIVE Communication Environment: An Object-Oriented Network.. - Schmidt (1993)(Correct)
The ADAPTIVE Communication Environment (ACE) implements a set of fundamental design patterns that simplify the development of concurrent event-driven communication software. ACE provides a rich set of... / ACM Transactions on Software Engineering and Methodology vol. br on fundamental communication software design patterns .
75.3 Formulations and Formalisms in Software Architecture - Shaw (1995)(Correct)
Software architecture is the level of software design that addresses the overall structure and properties of software systems. It provides a focus for certain aspects of design and development that ... / little substantive value for software engineers. But there are two reasons br Foundations of Software Engineering Software Engineering Notes
74.2 Efficient solvers for incompressible flow problems: An algorithmic.. - Turek (1998)(Correct)
standing of today's numerical work.
Let me also emphasize Owen Walsh and John Heywood from UBC Vancouver, Friedhelm
Schieweck and Lutz Tobiska from Magdeburg and Phil Gresho from the LLNL who are
inte... / my mentor in mathematical software engineering. Both Blum and Rannacher
69.5 Sequencing Run-Time Reconfigured Hardware with Software - Wirthlin (1996)(Correct)
Run-Time Reconfigured systems offer additional
hardware resources to systems based on reconfigurable
FPGAs. These systems, however, are often difficult
to build and must tolerate substantial reconfigu... / and simplicity of conventional software design and the performance of
68.0 Model Checking Complete Requirements Specifications Using Abstraction - Bharadwaj, Heitmeyer (1997)(Correct)
ion
Memorandum Report NRL/MR/5540--97--7999,
Naval Research Laboratory, Washington, DC 20375. Nov. 10, 1997
Ramesh Bharadwaj and Constance Heitmeyer
Center for High Assurance Computer Systems (Cod... / Symp. on Foundations of Software Engineering October . J. M. br Utter. Using documentation as a software design medium. Bell System Tech.
68.0 Evaluating Generalized Tabular Expressions In Software Documentation - Abraham (1997)(Correct)
This thesis presents a generalized model of tabular expressions used in software documentation, and describes how this model has been applied to build a tool that evaluates a broad class of expression... / . . McMaster University Software Engineering Research Group . br a substitute for conventional software design and implementation.
68.0 Techniques for Process Model Evolution in EPOS - Jaccheri, Conradi (1993)(Correct)
This paper categorizes some aspects of software process evolution and customization, and describes how they
are handled in the EPOS PM system. Comparisons are made with other PM systems.
A process mod... / There is an underlying software engineering database EPOSDB offering
67.6 Compositional Reachability Analysis Using Process Algebra - Yeh, Young (1991)(Correct)
State explosion is the primary obstacle to practical application
of reachability analysis techniques for concurrent
systems. State explosion can be substantially controlled
by using process algebra to... / Wei Jen Yeh Michal Young Software Engineering Research Center Department
66.6 A Pattern Matching Model for Misuse Intrusion Detection - Kumar, Spafford (1994)(Correct)
This paper describes a generic model of matching that can be usefully applied to misuse intrusion detection. The model is based on Colored Petri Nets. Guards define the context in which signatures are... / Examples of these include software engineering flaws in programs that
64.1 Distributed Programming with Logic Tuple Spaces - Ciancarini (1994)(Correct)
s are available from the same host in the directory /pub/TR/UBLCS/ABSTRACTS in plain text format. All local authors can be reached via e-mail at the address last-name@cs.unibo.it. UBLCS Technical Repo... / Programming good for in Software Engineering by P. Ciancarini and G.
63.8 Workflow Applications to Research Agenda: Scalable and Dynamic Work.. - Sheth (1997)(Correct)
this paper, we focus
on two issues. The first issue relates to the challenges that could be addressed
by evolving the current workflow technology. Two of the challenges to which
we focus our attention... / software process management software engineering organizational sciences
63.7 Productive Parallel Programming: The PCN Approach - Foster, Olson, Tuecke (1992)(Correct)
We describe the PCN programming system, focusing on those features designed to improve the productivity of scientists and engineers using parallel supercomputers. These features include a simple notat... / manageable levels. Good software engineering practice tells us that
63.6 The Application of Program Slicing to Regression Testing - Binkley (1999)(Correct)
Software maintainers are faced with the task of regression testing: retesting a program after a modification.
The goal of regression testing is to ensure that bug fixes and new functionality do not ad... / is an important part of software engineering as it consumes at least
60.8 New Methods for Competitive Coevolution - Rosin, Belew (1996)(Correct)
We consider "competitive coevolution," in which fitness is based on direct competition among
individuals selected from two independently evolving populations of "hosts" and "parasites."
Competitive co... / situations arise in complex software engineering applications where the
60.3 Fundamentals Of Deductive Program Synthesis - Manna, Waldinger (1992)(Correct)
An informal tutorial is presented for program synthesis, with an emphasis on deductive methods. According to this approach, to construct a program meeting a given specification, we prove the existence... / that are specialized to software-engineering applications we can make
59.7 The Bird-Meertens Formalism as a Parallel Model - Skillicorn (1993)(Correct)
The expense of developing and maintaining software is the major obstacle to the routine use of parallel computation. Architecture independent programming offers a way of avoiding the problem, but the ... / so that trade-offs in software design can be explored before br it is not really possible to design software since the trade-offs between
59.2 A Graphical Interval Logic for Specifying Concurrent Systems - Dillon (1994)(Correct)
The paper describes a graphical interval logic that is the foundation of a toolset supporting
formal specification and verification of concurrent software systems. Experience has shown
that most softw... / has shown that most software engineers find standard temporal br needed to determine whether software designers find a visual logic such
59.2 Virtual Schemas and Bases - Santos, Abiteboul, Delobel (1994)(Correct)
We propose the notions of virtual schemas and virtual bases as a coherent way of integrating various features in OODB views. A virtual schema is defined based on some existing (real) schema. A virtual... / is driven by database and software engineering as well as knowledge
59.0 Access Control for Collaborative Environments - Shen, Dewan(Correct)
Access control is an indispensable part of any information
sharing system. Collaborative environments introduce
new requirements for access control, which cannot be met
by using existing models develo... / in part by a grant from the Software Engineering Research Center at Purdue
57.7 Constructing Specification Morphisms - Smith (1993)(Correct)
This paper is part of a broader research program to explore a mechanizable model of software development based on algebraic specifications and specification morphisms. An algebraic specification (or s... / role in the future of software engineering. This paper is part of a
57.1 Large-Scale Parallel Geophysical Algorithms in Java: A Feasibility.. - Jacob (1998)(Correct)
The memory and time requirements of seismic calculations suggest parallel implementations. In Fortran, however, parallel program code not only lacks maintainability and reusability, but is error-prone... / major platform. From the software engineering point of view Java seems
56.7 Symbolic Analysis for Parallelizing Compilers - Haghighat (1994)(Correct)
Symbolic Domain
The objects in our abstract symbolic domain are canonical symbolic expressions. A
canonical symbolic expression is a lexicographically ordered sequence of symbolic
terms. Each symboli... / processors D. . Software Engineering Programming
56.7 On the Occur-check Free Prolog Programs - Apt, Pellegrini (1994)(Correct)
Machine
is used. This tag maintains information about the context in which a variable
is used. This makes possible to optimize the generated code by avoiding calls to
the occur-check routine at the co... / Subject Descriptors D. . Software engineering Program
55.0 Formal Refinement Patterns for Goal-Driven Requirements Elaboration - Darimont, van Lamsweerde (1996)(Correct)
Requirements engineering is concerned with
the identification of high-level goals to be achieved by the
system envisioned, the refinement of such goals, the operationalization
of goals into services... / engineering is the branch of software engineering concerned with the br of Style Analyzing a Software Design Feature with a Counterexample
55.0 Measured Capacity of an Ethernet: Myths and Reality - Boggs, Mogul, Kent (1988)(Correct)
Ethernet, a 10 Mbit/sec CSMA/CD network, is one of the most successful
LAN technologies. Considerable confusion exists as to the actual capacity of
an Ethernet, especially since some theoretical studi... / and scaling issues in system software design and the exploration of new
54.3 Critical System Properties: Survey and Taxonomy - Rushby (1994)(Correct)
This document is known as EUROCAE ED-12B in Europe. [Rus81] John Rushby. The design and verification of secure systems. In 8th ACM Symposium on Operating System Principles, pages 12--21, Asilomar, CA,... / IEEE Transactions on Software Engineering - June br assumptions that underpin the software design and to corroborate the broad
54.3 Speeding up Slicing - Reps, Horwitz, Sagiv, Rosay (1994)(Correct)
Program slicing is a fundamental operation for manysoftware
engineering tools. Currently,the most efficient algorithm
for interprocedural slicing is one that uses a program
representation called the s... / Descriptors D. . Software Engineering Tools and Techniques
53.6 On the Modularity of Termination of Term Rewriting Systems - Ohlebusch (1993)(Correct)
It is well-known that termination is not a modular property of term rewriting systems, i.e., it is not preserved under disjoint union. The objective of this paper is to provide a "uniform framework" f... / As is well-known from software engineering programmers are
53.0 The Inscape Environment - Perry (1989)(Correct)
The Inscape Environment is an integrated software development enviroment for building large software systems by large groups of developers. It provides tools that are knowledgeable about the process o... / International Conference on Software Engineering May Pittsburgh PA
51.8 Guaranteeing End-to-End Timing Constraints by Calibrating.. - Gerber (1994)(Correct)
This paper presents a comprehensive design methodology for guaranteeing end-to-end requirements of real-time systems. Applications are structured as a set of process components connected by asynchrono... / in IEEE Transactions on Software Engineering. Guaranteeing End-to-End