Books on CBSE
Component-Based
Software Quality: Methods and Techniques (Lecture Notes in Computer Science), Springer-Verlag, 2003.
by Alejandra Cechich, Mario
Piattini, Antonio
Vallecillo
UML
Components: A Simple Process for Specifying Component-Based Software (The
Component Software Series), Addison-Wesley Professional, 2000.
by John Cheesman, John Daniels (Paperback - October 13, 2000)
Building Reliable Component-Based Software Systems, Artech House Publishers, 2002.
by Ivica Crnkovic
and Magnus Larsson (Eds)
Component Based
Software Engineering: Putting the Pieces Together, Addison Wesley, 2001.
by George
T. Heineman, William
T. Councill
Business
Component Factory : A Comprehensive Overview of
Component-Based Development for the Enterprise, Wiley, 1999.
by Peter Herzum, Oliver Sims
Software
Ecosystem : Understanding an Indispensable Technology
and Industry, The MIT Press, 2003.
by David
G. Messerschmitt, Clemens
Szyperski
Component Software:
Beyond Object-Oriented Programming, 2nd Edition, Addison Wesley,
2002.
by Clemens Szyperski with Dominik
Gruntz and Stephan Murer
Building Systems
from Commercial Components, Addison-Wesley Professional, 2001
by Kurt
Wallnau, Scott
Hissam, Robert
Seacord
Testing
and Quality Assurance for Component-Based Software, Artech
House Computer Library, 2003.
by Jerry
Zeyu Gao, H.-S.
Jacob Tsao, Ye
Wu
Proceedings of Events in CBSE
Component-Based
Software Engineering held at the 30th Euromicro
Conference,
Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
Third International Conference on
COTS-Based Software Systems, ICCBSS 2004.
Workshop on Web
services and Service-oriented Architectures: Best-practices and Patterns
held at OOPSLA 2003,
29th
Euromicro Conference Component-Based Software Engineering
Track,
The 6th ICSE Workshop on Component-Based Software
Engineering: Automated Reasoning and Prediction
Second International Conference on COTS-Based Software
Systems, ICCBSS 2003,
Workshop on Object-Oriented Web Services held at OOPSLA2002
5th ICSE Workshop on Component-Based Software Engineering:
Benchmarks for Predictable Assembly,
Workshop on
Component-Based Software Engineering: Composing Systems from Components
held at the 9th IEEE Conference and Workshops on Engineering Component-Based
Systems,
The First International Conference on COTS-Based Software Systems, ICCBSS
2002,
-- This
bibliography is based upon Kurt Wallnau’s CBSE bibliography
(2000).
[Acher99] Franz Achermann,
Markus Lumpe, Jean-Guy Schneider and Oscar Nierstrasz, “Piccola — A Small
Composition Language”, submitted for publication,
http://www.iam.unibe.ch/~scg/Research/Piccola/pascl.pdf.
[Aguirre02] Nazareno Aguirre and Tom Maibaum. “A
Temporal Logic Approach to Component–Based System Specification and Reasoning”,
in Proceedings of the 5th ICSE Workshop on Component-Based Software
Engineering: Benchmarks for Predictable Assembly, Orlando, Florida, May 19-20,
2002. (Available online at
http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Alda04] Sascha Alda and Armin
B. Cremers. “Strategies for a Component-Based
Self-adaptability Model
in Peer-to-Peer Architectures”, in
[Aldrich04] Jonathan Aldrich and
Kevin Donnelly. “Selective Open Recursion: Modular Reasoning about Components and
Inheritance”, in Proceedings of SAVCBS 2004 – Specification and Verification of
Component-Based Systems, held at 12th ACM SIGSOFT Symposium on the Foundations
of Software Engineering Newport Beach, California, USA, October 31-November 5,
2004. (Available as Technical Report #04-09, Department of Computer Science,
Iowa State University, 226 Atanasoff Hall, Ames, IA
50011-1041, USA and online as http://www.cs.iastate.edu/~leavens/SAVCBS/2004/savcbs04.pdf)
[Alencar92] Antonio J. Alencar and
Joseph A. Goguen, “OOZE”, in Susan Stepney, Rosalind Barden, and
David Cooper (editors), Object
Orientation in Z, Workshops in Computing, Springer-Verlag,
1992, pp. 79–94.
[Alencar98] P.S. Alencar, D.D.
Cowan, C.J. Lucena, and L.C. Nova, “A Model for
Gluing Components,” in proceedings of 3rd International Workshop on
Program Composition
The
justification is that there will always be a need to compose (integrate)
components that are mismatched in some way.
[Allemang 97] Dean Allemang, " Lowering the
Barriers to the Use of Formal Techniques," in proceedings of the 1st
Workshop on Component-Based Systems,
This
paper suggests a means for making the use of formal methods tractable for
programming, involving the use of a Functional Representation of a
program. The paper makes some
observations about why formal methods are not widely accepted in industry. The paper is readable, with all the notation relegated to an appendix.
[Allen 97] Robert Allen, Rimi Douence, David Garlan, "
Specifying Dynamism in Software Architectures," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper presents an architecture description language (ADL) called Wright, which
uses a variant of Hoare’s CSP (Communicating Sequential Processes) to express
dynamism in software architectures. The
paper contains a lot of notation and requires an understanding of CSP.
[Allen 97] Allen, P. and Frost, S., “Service-based
architectures: unlocking the potential of component-based development”,
American Programmer, vol.10, no.7, p. 18-23.
[Andreoli 99] J.M. Andreoli, D. Arregui, F. Pacull, M. Riviere, J. Vion-Dury, J. Wiliamowski,
"CLF/Mekano: a framework for building
virtual-enterprise applications," in proceedings of the Third
International IEEE Conference on Enterprise Distributed Object Computing,
Mannheim, Germany, September 1996.
[Ashford-98] Colin
Ashford, "The TINA Service Composition Architecture," in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Suggests
that there is a difference between component composition and service
composition. This implies that systems are composed of
services. The TINA approach to service composition is mentioned a bit, but not
really described. (See yucel-98]).
[Assmann 97] Uwe
Assmann, Rainer Schmidt, " Towards a Model for
Composed Extensible Components," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper sketches a new model for extensible component-based software, software
cocktail mixers. This approach combines
views and operator-based composition. It
is work in progress and the formal model is not yet finished. The paper is readable, containing little
formal notation.
[Autili04] Marco Autili,
Paola Inverardi, Massimo Tivoli and David Garlan. “Synthesis of
"Correct" Adaptors for Protocol Enhancement in Component-based
Systems”, in Proceedings of SAVCBS 2004 – Specification and Verification of
Component-Based Systems, held at 12th ACM SIGSOFT Symposium on the Foundations
of Software Engineering Newport Beach, California, USA, October 31-
[Bagg-97] Vito Baggiolini, Jürgen Harms, "Toward Automatic, Run-Time Fault Management
for Component-Based Applications," in proceedings of the 2nd International Workshop on
Component-Oriented Programming (WCOP97), held in conjunction with the European
Conference on Object-Oriented Programming (ECOOP98).
The
authors develop a refinement of the pipe/filter to include interface types and
typed components. The style consists of
active and passive components, and all data items are encapsulated into data
"components" (really, objects with abstract interfaces). The style, it is argued, makes it possible to
manage the application, especially with respect to fault detection,
diagnosis and correction. The paper is a
nice illustration of using component concepts to realize an architectural
concept
[Baresi04] Luciano Baresi, Reiko Heckel, Sebastian Thöne and Dániel Varró.
“Modeling
and Analysis of Architectural Styles Based on Graph Transformation”, in
Proceedings of the 6th ICSE Workshop on Component-Based Software Engineering:
Automated Reasoning and Prediction
[Barnes97] John Barnes, High Integrity
[Barnett03a] Mike Barnett and Wolfram
Schulte. “Runtime verification of .NET
contracts”, in I. Crnkovic, H. Schmidt, J. Stafford, K. Wallnau
(Eds), Journal
of Systems and Software, Special Issue: Component-Based Software Engineering -
Component Certification and System Prediction. Elsevier Science Inc.,
65(3), March 2003, Pages 199-208.
[Barnett03b] Mike Barnett, Wolfgang Grieskamp, Clemens
Kerer, Wolfram Schulte, Clemens Szyperski,
Nikolai Tillmann and Arthur Watson. “Serious
Specification for Composing Components”, in Proceedings of the 6th ICSE
Workshop on Component-Based Software Engineering: Automated Reasoning and
Prediction
[Becker04] Steffen Becker, Sven Overhage,
and Ralf H. Reussner. “Classifying
Software Component Interoperability Errors to Support Component Adaption”, in
[Bellur-98] Umesh Bellur,“The Role of
Components & Standards in Software Reuse,” in proceedings of
OMG-DARPA-MCC Workshop on Compositional Software Architecture
Begins with a paean to standards, and why they
are crucial to the success of software components. Mostly what is
interesting is the fourteen aspects that must be supported by component
models. These, presumably, are derived
from the Oracle, IBM, Netscape, SUN, Visigenic et. al. submission to the OMG RFP
for component models. (Author is from
Oracle.)
[Benzinger-98] Lee Benzinger, “Applying the WDL Composition Theory to Analyze
Security Architectures,” in proceedings of OMG-DARPA-MCC Workshop on
Compositional Software Architecture
“Fundamental…if you have two components, and you
wire them together…what can you say about the system? This question is answered in one case using
Western Development Laboratories composition theory, “a mathematical theory for
modeling large, complex communication systems.”
The discussion and examples are not particularly convincing, but there
may be more meat there. It is unclear
whether WDL is real or the author’s fancy.
[Bergstra95] J. Bergstra, P. Klint, The
discrete time toolbus. Report p9502, Programming
Research Group, Department of Mathematics and Computer Science, University of
Amsterdam, FWI WCW, Kruislaan 403, 1098 SJ Amsterdam,
1995.
[Berry-98] Andrew Berry, S. Kaplan, “Programming the
Middleware Machine with Finesse,” in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Idea
is that interaction models should be programmable in middleware. Claim: IDL is insufficient; what is needed is
a super-IDL that can express interactions, and provide client insulation from
changes in underlying middleware platforms.
Draws parallels to SW architecture world (connectors as first-class
abstractions) and coordination languages (some references provided). Defines the language
Finesse to do this coordination programming. Has reference to a paper describing the use
of Finesse to extend RPC, streams and group communication.
[Bertolino03]
Antonia Bertolino and Raffaela
Mirandola . “Towards
Component-Based Software Performance Engineering”, in Proceedings of the 6th
ICSE Workshop on Component-Based Software Engineering: Automated Reasoning and
Prediction
[Bespal 97] Stephan Bespalko, Alexander Sindt, " Context Sensitivity and Ambiguity in Component-Based
Systems Design," in proceedings of the 1st Workshop on
Component-Based Systems,
This
paper proposes a system for compactly specifying system states that allow the
factoring of complex components into a control module and a semantic processing
module. Examples are presented of
real-world problems that are highly context-sensitive or are inherently
ambiguous. The paper is readable with
just a little notation..
[Beugnard-98] Antoine Beugnard, J. Jezequel, N. Plouzeau, and D. Watkins, "Making Components Contract
Aware," IEEE Computer, July 1999, pp. 38-45.
Proposes four levels of contract: syntactic,
behavioral, synchronization and quantitative. Syntactic contracts are just
API's, expressed, for example, in IDL.
Behavioral contracts can be specified using pre/post conditions. Synchronization contracts address concurrency
issues, and discuss (briefly) the use of tools such as path expressions to
describe such contracts. Quantitative
contracts are for quality of service, but the discussion of these contracts was
more spotty and speculative. A rudimentary
model of contract management was also sketched: definition, subscription,
application, termination and deletion.
[Bosch-96] Jan Bosch, "Language Support for Component
Communication in LayOM," in proceedings of the 1st
International Workshop on Component-Oriented Programming, held in conjunction with the European Conference
on Object-Oriented Programming (ECOOP97).
[Bosch-97] Jan Bosch , "Adapting Object-Oriented
Components," in proceedings of the 2nd
International Workshop on Component-Oriented Programming (WCOP97), held in
conjunction with the European Conference on Object-Oriented Programming
(ECOOP98).
The
author argues that adaptation of components (actually, objects, which the
author does not choose to distinguish from components) is understudied. The author then goes on to outline
requirements for adaptation, and argues that whitebox
and blackbox adaptation (wrapping and aggregation)
only satisfies these requirements, at best, partially. He proposes that there are three distinct
classes of adapter components: interface, composition and observation
(management). These are implemented in LayOM--the layered object model. Each layer acts as an interposer between the
client (or outer layer) and the inner component that
is being adapted. LayOM
requires that subclassing of the layers be explicit,
hence a source code model of adaptation is assumed.
[
[Brer 99]
[Bron 9x] Bronsard, F.; Bryan, D.; Kozaczynski, W.; Liongosari,
E.S.; Ning, J.Q.; Olafsson,
A.; Wetterstrand, J.W., “Toward software
plug-and-play”, Softw. Eng. Notes (USA),
Software Engineering Notes, vol.22, no.3, p. 19-29.
[Brooks87] Brooks, Fredrick P. 1987. No silver bullet: essence and accidents of
software engineering. IEEE Computer 20 (4):10-19 (also available as Chapter
16 in “Mythical Man Month, 20th Anniversary Edition, Addison Wesley,
1995).
Brooks discusses the
limitations associated with making significant progress in solving the problem of building large systems on time
and within budget – in his opinion mass reuse of preexisting parts was likely
to produce significant improvements, even if not a silver bullet.
[Brown 98] Alan Brown and Kurt Wallnau,
"The Current State of
[Brown 9x] Brown, A.W.; Short, K., "On components and
objects: the foundations of component-based development”, Proceedings. Fifth
International Symposium on Assessment of Software Tools and Technologies,
[Bruneton04] Eric Bruneton,
Thierry Coupaye, Matthieu Leclercq, Vivien Quema, and
Jean-Bernard Stefani. “An
Open Component Model and Its Support in Java”, in
[Bruno 97] J. Bruno and T. Kelliher,
Automatic Wrapping Architecture, GE Technical Information Series
97CRD022, Class 1, April 1997.
This
is a description of a project from General Electric. Different legacy systems
are integrated using domain specific structure and a tool to dynamically
convert legacy messages from and to this common structure. This work is not
related to CBSE.
[Büchi 97a] Martin Büchi and Wolfgang Weck, " A
Plea for Grey-Box Components," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper argues that a middle ground is needed between black-box specifications
that reveal only input-output behavior and white-box specifications that reveal
too much internal detail. Apart from
suggesting some approaches, the paper goes very little way to solving the
problem. The paper is readable with just
a little notation.
[Büchi-97b]
Martin Büchi,
Emil Sekerinski, "Formal Methods for Component
Software: The Refinement Calculus Perspective," in proceedings of the 2nd International Workshop on
Component-Oriented Programming (WCOP97), held in conjunction with the European
Conference on Object-Oriented Programming (ECOOP98).
The
authors make a good case for formal (or more formal) treatment of interface
contracts. They argue that
incompleteness, ambiguity and overspecification are
the root causes of various problems with component reuse. They argue that pre/post conditions are
insufficient (in fact, they violate encapsulation, although this is not explained). Instead, the authors suggest the Refinement
Calculus. A key idea of refinement
calculus is that it supports non-determinism in the specification. This avoids overspecification,
and allows different implementations to "refine" the same contract
[Cainc 97] S. Cimato
and P. Ciancarini, " A Formal Approach to the
Specification of Java Components," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper uses a Larch-based language called Ljala (Larch
Java interface language) for the formal specification and verification of
software components and goes on to provide a methodology for the design of
software architectures for Java-based applications. It has some interesting quotes: “According to
[Nier95], a software component is an ‘abstraction with plugs’”; “The
decomposition of complex software systems in a collection of easy combinable
computational elements with well defined responsibilities has a number of
benefits in a reuse-oriented development process.” The paper is readable, with just a little
mathematical notation in the section on verification. There are useful references to related work.
[Canal 97]
This
paper proposes the use of Milner’s pi-calculus for the specification of
software architectures. However, the
paper contains little of substance. It
is readable with just a little notation.
[Casset
99] Ludovic Casset
and Jean Louis Lanet, " A Formal Specification
of the Java Bytecode Semantics Using the B
Method" in proceedings of the first workshop on Formal Techniques for Java
Programs, in conjunction with the 13th European Conference on
Object-Oriented Programming, ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This
paper describes work in progress to formally specify the JavaCard
2.1 standard bytecode using the B method of formal
specification. The specification is then
refined in order to split the verifier and interpreter, so that verification can
be carried out off-card. This is based
on the idea of the Defensive Java Virtual Machine (dJVM)
[Cohe97]. The paper shows an example of
specifying and then refining one bytecode
instruction. It then goes on to discuss
type correctness checking for a very small subset of Java types. The paper is fairly readable, with a one-page
example that requires understanding of the B notation, and a little knowledge
of lattice theory to understand the type correctness material.
[Cenciar
99] Pietro Cenciarelli,
" Towards a Modular Denotational Semantics of
Java " in proceedings of the first workshop on Formal Techniques for Java
Programs, in conjunction with the 13th European Conference on
Object-Oriented Programming, ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This is a very technical paper describing an
application of the computational lambda calculus and algebraically complete categories to a Java-like programming
language. The paper considers a “small
but meaningful subset of Java.” It is
readable by professors of mathematics!
[Cervantes03] Humberto
Cervantes and Richard S. Hall.
“Automating
Service Dependency Management in a Service-Oriented Component Model”, in Proceedings of
the 6th ICSE Workshop on Component-Based Software Engineering: Automated
Reasoning and Prediction
[Cervantes04] Humberto Cervantes and Richard S. Hall. “A
Framework for Constructing Adaptive Component-Based Applications: Concepts and
Experiences”, in
[Chaki04] Sagar Chaki,
Natasha Sharygina, and Nishant
Sinha. “Verification of Evolving Software”, in Proceedings of SAVCBS 2004 –
Specification and Verification of Component-Based Systems, held at 12th ACM
SIGSOFT Symposium on the Foundations of Software Engineering Newport Beach,
California, USA, October 31-
[Chandy-98] K.M. Chandy, A. Rifkin, “CALTECH INFOSPHERES PROJECT,” in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
“The
infospheres project researches compositional ways of
obtaining high confidence in dynamically-reconfigurable, scalable distributed
systems.” Another argument for
internet-scale systems, with the use of internet “objects” leading (it is
argued) inherently to compositional systems.
The authors provide a list of research topics that flow from the project
focus. Interesting for our work:
component verification, using conformances and refinements relations, and
including the idea of trusted producers; selective assurance, which means assurance limited to the types of interactions within
specific use contexts.
[Cherinka-98] R. Cherinka, J.
Ricci, M. Schrank, C. Overstreet, “Maintaining a COTS
Component-Based Solution—Can Traditional Static Analysis Techniques be Useful
for this new Programming Methodology?” in proceedings of 3rd
International Workshop on Program Composition
[Chavez 98] Andrea Chavez, Catherine Tornabene,
and Gio Wiederhold,
"Software Component Licensing: A Primer," IEEE Software, September/October
1998, pp. 47-53.
An introduction to the legal aspects behind
software licensing. The paper focus on the difference between COTS licenses and
traditional ones. Although the article refers to components they are
really white box COTS items, i.e. they can be modified by the licensee. The
paper can be read without special knowledge of law.
[Chen02] Shiping Chen, Ian Gorton, Anna Liu, and Yan Liu. “Performance Prediction of COTS Component-based Enterprise Applications”, in Proceedings of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Ciancarini97] P. Ciancarini and
[Cicalese99] Cynthia Della Torre Cicalese and Shmuel Rotenstreich, “Behavioral Specification of Distributed
Software Component Interfaces”, IEEE
Computer, July 1999, pp. 46–53.
[Cimato
99] Pietro Cenciarelli,
" Towards a Modular Denotational Semantics of
Java " in proceedings of the first workshop on Formal Techniques for Java
Programs, in conjunction with the 13th European Conference on
Object-Oriented Programming, ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This is a very technical paper describing an
application of the computational lambda calculus and algebraically complete categories to a Java-like programming
language. The paper considers a “small
but meaningful subset of Java.” It is
readable by professors of mathematics!
[Ciupke 96] Oliver Ciupke, Rainer Schmidt, "Components as context
independent units of software", WCOP96 at ECOOP96, 1996,
Abstract:
Although the term 'component` its widely used, only few attempts have been made to achieve a precise definition of it.
In addition to this, the relation of components to object-oriented
concepts is not clearly specified. Therefore, we suggest a definit
ion that combines both conceptual and technical aspects of context independence."
[Clark 99] Tony Clark, " Formal
Refinement and Proof of a Small Java Program," in proceedings of the 1st
Workshop on Component-Based Systems,
[Coker-98] Louis Coker,
R. Hayes-Roth, “Services First, Components Second!” in proceedings of
OMG-DARPA-MCC Workshop on Compositional Software Architecture
Services mean infrastructure in this
context. Makes the argument that there
are fewer useful service models and that components depend on these, so why not
focus on these services, and on composition of services? Not much meat. (See also [ivanetich-98]).
[Collet -99] Philippe Collet and Roger Rousseau, " Towards Efficient Support
for Executing the Object Constraint Language," in proceedings of Technology of Object-oriented Languages and Systems,
IEEE, Santa Barbara, California, August
1999.
This paper proposes a pragmatic solution for OCL (Object Constraint Language) runtime support. It considers the origins of potential inefficiencies and suggests that the evaluation of assertions should be streamlined according to their roles. The paper also considers the possibility of sampling quantified assertions, rather than full evaluation.
[Cottenier04] Thomas Cottenier and Tzilla Elrad. “Validation of context-dependent aspect-oriented adaptations to components” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Crnkovic04a] I. Crnkovic, J.A. Stafford, H.W. Schmidt and K.Wallnau (Eds). “Component-Based Software Engineering: 7th International Symposium, CBSE 2004 Proceedings. Lecture Notes on Computer Science 3054, Springer –Verlag, 2004.
[Crnkovic04b] Ivica Crnkovic. “Component-based approach for embedded systems”
in Proceedings of the Ninth International Workshop on Component-Oriented
Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004.
(Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Crnkovic05]
[Defour04] Olivier Defour, Jean-Marc J´ez´equel, and No¨el Plouzeau. “Extra-Functional Contract
Support in Components”, in
[Dehondt-97] Koen De Hondt, Carine Lucas, Patrick Steyaert, "Reuse Contracts as Component Interface
Descriptions,", in proceedings of the
2nd International Workshop on Component-Oriented Programming
(WCOP97), held in conjunction with the European Conference on Object-Oriented
Programming (ECOOP98).
The
authors assert that most contractual specifications deal only with a syntactic
(structural) interface; even where context dependencies are noted these, too,
are merely structural dependencies. The
authors argue that contracts need to expose the "interaction structure"
of "acquaintances" in a composition.
The authors also argue that contracts may need to be modified to
accommodate alternative components. To
this end "reuse operators" are defined to manipulate contracts. These are typical operations, although there
(may be/are) others: extension, refinement, cancel,
coarsen. These are illustrated by an
example using a web browser and web document component.
[Deline-99] Robert Deline, "Avoiding Packaging Mismatch with Flexible
Packaging," in proceedings of the 21st International Conference
on Software Engineering, LA, California, May 1999.
[Della-99] Cynthia Della
Torre Cicalese and
Surprisingly
light in content. Starts with a quickie tutorial of how interprocess
communication occurs with distributed object technology, illustrated briefly
with Java RMI, CORBA, and DCOM. Then a brief overview of "Design by Contract,"
essentially B. Myers marketing hook, which involves use of pre/post conditions
and Boolean invariants on the methods described in a class interface. The paper then describes some custom
extensions to the Java language (and hence to the JVM) to provide native
support for design by contract.
[DePanfilis04] Stefano De Panfilis and Arne J. Berre. “Open issues and concerns on component-based software engineering” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[DePrince03]
[Deri
9x] Deri, L., “Yasmin: a
component based architecture for software applications”, Proceedings. Eighth
IEEE International Workshop on Software Technology and Engineering Practice
incorporating Computer Aided Software Engineering p. 4-12.
[Deugo -99] Dwight Deugo, Franz Oppacher, Bruce Ashfield, and Michael Weiss, " Communication as a
Means to Differentiate Objects, Components and Agents," in proceedings of Technology of
Object-oriented Languages and Systems, IEEE,
This
paper attempts to use communication as a means to differentiate the three
abstractions of objects, components, and agents. Communications patterns for the three
abstractions are presented in order to aid in the identification of the abstractions.
[Dijkman03] Remco M. Dijkman, Joao Paulo Andrade Almeida and Dick A.C. Quartel.
“Verifying
the Correctness of Component-Based Applications that Support Business Processes”,
in Proceedings of the 6th ICSE Workshop on Component-Based Software
Engineering: Automated Reasoning and Prediction
[D'Souza99] Desmond D'Souza
and Alam Cameron Wills, Objects, Components, and
Frameworks with UML The Catalysis Approach,
Addison-Wesley, 1999, ISBN 0-201-31012-0.
[Duke95] R. Duke, G. Rose, and G. Smith, “Object-Z: A
Specification Language Advocated for the Description of Standards”, Computer Standards and Interfaces,
17:511–533, 1995.
[Dürr94] E.H. Dürr and N. Plat
(editors), “VDM++ Language Reference Manual”, Cap Volmac,
[Dwyer 97] Matthew B. Dwyer, " Automated Analysis of
Software Frameworks," in proceedings of the 1st Workshop on
Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This paper discusses research
issues in applying automated finite-state verification techniques to the
problem of specifying high-assurance and safety-critical systems. The paper is very readable.
[Eskenazi04] Evgeni Eskenazi, Alexandre
Fioukov, and Dieter Hammer. “Performance Prediction for
Component Compositions”, in
[Fellner 99] Klement
J. Fellner and Klaus Turowki,
"Component Framework Supporting Inter-company Cooperation," in
proceedings of the Third International IEEE Conference on Enterprise
Distributed Object Computing, Mannheim, Germany, September 1996.
[Fellner2000] Klement J. Fellner and Klaus Turowski,
"Classification Framework for Business Components," in proceedings of the 33rd Hawaii
International Conference on System Sciences, 2000.
[Fisler01] K.
Fisler, S. Krishnamurthi and D. Batory. “Verifying
Component-Based Collaboration Designs”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Firesmith -99] Donald G. Firesmith, " A Comparison of Defensive Development and
Design by Contract," in proceedings
of Technology of Object-oriented Languages and Systems, IEEE, Santa Barbara, California, August 1999.
This
paper compares Defensive Development with Design by Contract. It argues that Defensive Development is
superior to Design by Contract because of how they differ in assigning the
responsibilities for checking and ensuring preconditions.
[Fischer 97] Bernd Fischer and Gregor
Snelting, " Reuse by
Contract," in proceedings of the 1st Workshop on
Component-Based Systems,
This
paper discusses the use of formal methods in the context of software component
reuse. It presents some obstacles to the
use of formal component specification and proposes some solutions. It makes the point that: “There is no
medicine for people who reject formal methods.”
The paper is very readable.
[Fischer 99] Clemens Fischer, " Software Development
with Object-Z, CSP and Java: A Pragmatic Link from Formal Specifications to
Programs," in proceedings of the 1st Workshop on
Component-Based Systems,
This
paper describes the use of a combination of Object-Z and CSP (Communicating
Sequential Processes), called CSP-OZ, for the specification of Java
programs. It then goes on to present a
more pragmatic approach which is part way between the formal specification and
ordinary Java programs. This is called Jass (Java with assertions). Jass programs are
normal Java programs augmented with assertions placed in specific comments (à la ANNA). The Jass compiler translates these assertions to Java
statements that check the predicate during run time. The paper is readable, with an example shown
in the CSP-OZ notation, and then a part of it presented in Jass. The paper points out some limitations of the
Object-Z and CSP combination, namely that systems with dynamic communication
structures do not fit within the static channels of CSP, and that problems
occur if an unbounded number of new objects can be created. It suggests that the ideas presented would
fit into a formal extension of UML.
[Franz-96] Michael Franz, "Toward an Execution Model
for Component Software," in proceedings of the 1st
International Workshop on Component-Oriented Programming, held in conjunction with the European Conference
on Object-Oriented Programming (ECOOP97).
[Franch 97] Xavier Franch, " The Convenience for a Notation to Express
Non-Functional Characteristics of Software Components," in proceedings of
the 1st Workshop on Component-Based Systems, Zurich, Switzerland,
1997. In conjunction
with European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium
on the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper presents a notation for specifying the non-functional behavior of
software components, called NoFun. This notation allows the definition of: non-functional
attributes of software, the non-functional behavior of components with respect
to these attributes, and the non-functional requirements of
implementations. This work would seem to
be unique in that nothing as powerful as NoFun is
known in the literature. The paper is
very readable with just a little, straightforward notation and an example.
[Franch 98] Xavier
Franch, “Systematic Formulation of Non-Functional
Characteristics of Software”, Proceedings of the 3rd IEEE International
Conference on Requirements Engineering (ICRE),
[Gall-97] H. Gall, R. Jazayeri, R. Klosch, G. Trausmuth, “The architectural style of component
programming," in proceedings of the twenty-first Annual International
Computer Software and Applications Conference (COMPSAC'97), p. 18-25.
[Gannon-98] Dennis
Gannon, “Component Architectures for High Performance, Distributed
Meta-Computing,” in proceedings of OMG-DARPA-MCC Workshop on
Compositional Software Architecture
Like [olken-98] describes requirements for
component infrastructures for a class of problems. These are internet-scale systems for
very-high performance (MPP-based, networked instruments, gigabyte networks,
etc.) computing applications. Gives
three examples (distributed algorithm design, tele-immersive
collaborative design, and digital sky survey) and briefly touches on the
requirements each will impose on component infrastructures. Describes three paradigms for component
composition—client server via client containers, software ICs and component
containers.
[Garlan95] David
Garlan, Robert Allen, John Ockerbloom.
“Architectural
Mismatch. or, Why it's hard to build
systems out of existing parts”, Proceedings of the 17th International
Conference on Software Engineering (ICSE-17), April 1995.
[Garlan-98] David Garlan, “Higher-Order Connectors,” in proceedings of
OMG-DARPA-MCC Workshop on Compositional Software Architecture
Architecture description languages are getting
better at describing connectors—the glue that holds components together—but
what is needed is operations over connectors that generate connectors (ala
higher-order functions that generate functions). This would allow customization of interaction
policies and their implementation, for example.
Where mismatches exist, we can wrap or modify components. But perhaps we ought also to be able to
modify the connectors. This is a
proposed research agenda.
[Garlan01] D.
Garlan and B. Schmerl. “Component-Based
Software Engineering in Pervasive Computing Environments”, in
Proceedings of the 4th ICSE Workshop
on Component-Based Software Engineering:
Component Certification and Prediction,
[Genßler01] T.
Genßler and C. Zeidler. “Rule-driven
Component Composition for Embedded Systems”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Gheyi04] Rohit Gheyi, Tiago Massoni and Paulo Borba. “Basic Laws of Object Modeling”, in Proceedings of SAVCBS 2004 –
Specification and Verification of Component-Based Systems, held at 12th ACM
SIGSOFT Symposium on the Foundations of Software Engineering Newport Beach,
California, USA, October 31-
[Ghosh-98] Anup Ghosh, "Certifying
Security of Components used in Electronic Commerce," in proceedings
of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Describes NIST/ATP project (just starting in
1998) to develop a "set of core white-box and black-box testing
technologies to certify the security of software components." Once certified, a component would be
digitally signed by the certifying organization. JavaBeans is the target component technology
for the certification technologies. (Claims that JavaBeans has had early adoption success in financial
community. We may want to verify
this with Anup.)
There is not much discussion about the technical approach being taken to
certification, however.
[Ghosh01] S.
Ghosh and A.P. Mathur. “Certification
of Distributed Component Computing Middleware and Applications”, in
Proceedings of the 4th ICSE Workshop
on Component-Based Software Engineering:
Component Certification and Prediction,
[Giannak01] D.
Giannakopoulou and J. Penix. “Component
Verification and Certification in NASA Missions”, in Proceedings of
the 4th ICSE Workshop on
Component-Based Software Engineering: Component Certification and Prediction,
Toronto, Canada, May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Gibson 97] David S. Gibson and Bruce W. Weide,
" Semantic Spaces for Specifications and Templates," in proceedings
of the 1st Workshop on Component-Based Systems, Zurich, Switzerland,
1997. In conjunction
with European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium
on the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper describes the RESOLVE framework for software component engineering. RESOLVE is unusual in that it is a
combination specification and implementation language, with modern features
such as templates, some forms of inheritance, etc. The paper contains some formal notation but
is fairly readable.
[Goed-97] Michael Goedicke and Torsten Meyer , "Design and Evaluation of Distributed
Component-Oriented Software Systems," in proceedings of the 2nd International Workshop on
Component-Oriented Programming (WCOP97), held in conjunction with the European
Conference on Object-Oriented Programming (ECOOP98).
[Gold 97] S.J. Goldsack and K. Lano and E. Dürr, "
Invariants as Design Templates in Object-Based Systems," in proceedings of
the 1st Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper describes how VDM++ can be used in the specification and refinement of
classes in an object-oriented language.
The refinement involves a process of transforming an initial class into
a structure of (usually) simpler classes.
This process is called “annealing”.
Annealing has been used as a mechanism by which model splitting may be
implemented, and in the development of design patterns. The paper contains a number of examples that
use the VDM++ notation, and an understanding of this notation is necessary to
follow these examples. Otherwise, the
paper is fairly readable.
[Graw-98] Günter Graw and Arnulf Mester, “Federated
Component Frameworks,” in proceedings of
3rd International Workshop on Program Composition
Discusses 2-tiered vs. “federated”
frameworks. For federated frameworks proposes service
traders. Each component framework is
equipped with a trader. A federation of
component frameworks is a collection of such frameworks plus an arbitrator.
[Grossman-98] Mark Grossman, “Component Testing,” in proceedings of 3rd
International Workshop on Program Composition
From Microsoft. Has nice criteria for “well-factored” vs. “well-finished”
components. Describes
(but does not not explain in detail) the use of
pre/post-conditions and state transition models for component specification. A couple of nice references to component
testing are provided (Weide, Beizer),
and worth looking into. Describes a
component testing harness (called “Test Engine”) that supports a variety of testing
strategies. The component must implement
a variety of testing interfaces—IBlackox, IWhiteBox, ITestInfo, etc. It seems they are describing a component
framework for testing! (Nice idea!)
[Gruntz-97] D.Gruntz, “Design aspects of component frameworks”, in
Proceedings OOP'97., p. 396, 353-60
[Hallstrom02] Jason O. Hallstrom, Scott M. Pike, and Nigamanth Sridhar. “Iterators Reconsidered”, in Proceedings of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Hallstrom04] Jason O. Hallstrom, Neelam Soundarajan and Benjamin Tyler. “Monitoring Design Pattern Contracts”, in
Proceedings of SAVCBS 2004 – Specification and Verification of Component-Based
Systems, held at 12th ACM SIGSOFT Symposium on the Foundations of Software
Engineering Newport Beach, California, USA, October 31-
[Hamlet 01a] D. Hamlet, D. Mason and D. Woit.
“Theory of Software Reliability Based on Components.”
Proceedings of the 23rd International Conference on Software
Engineering (ICSE 2001),
[Hamlet01b] D.
Hamlet. “Component
Synthesis Theory: The Problem of Scale”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Hamlet03] Dick
Hamlet, Milan Andric and Zheng
Tu. “Experiments
with composing component properties”, in Proceedings of the 6th ICSE
Workshop on Component-Based Software Engineering: Automated Reasoning and
Prediction Portland, Oregon, USA
[Hayton-98] Richard Hayton, M. Faupel,
"Automating Application Deployment and Evolution," in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Not (it seems) as general a solution as in
[hiemb-98]. In particular, suggests that
component code must be written to the FlexiNet API in
order to abstract component dependencies (i.e., component references) so that
actual components can be bound to these references at deployment time. Also depends on their own custom middleware,
it seems.
[Heimb-98] Dennis Heimbigner, A. Wolf, R. Hall, and A. van der Hoek, "Deploying
Component Software Systems," in proceedings of OMG-DARPA-MCC
Workshop on Compositional Software Architecture
Developing
"an infrastructure to systematically enable distributed deployment and
configuration management of software systems." Components in component-based systems evolve
independently, adding a new layer of complexity. Provides another argument
for internet-based acquisition and deployment (but not composition). Decomposes deployment into constituent (and
related) activities: release, installation, activation, de-activation, update,
adapt, de-installation, de-release. The
"agent-based" Software Dock supports these activities.
[Heimbdahl
98] Mats Heimdahl, Jeffrey Thompson and Barbara
Czerny, "Specification and Analysis of Intercomponent
Communication," IEEE Computer, April 1998, pp. 47-54.
[Heineman-98] George Heineman, “Composing Software Systems from Adaptable
Software Components,” in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Software components should provide two
interfaces: one for behavior, and one for adaptation of that behavior. Differentiates evolution (component modified
by component designer), customization (end-user chooses from a fixed set of
options)[kiczales-97], and adaptation (the focus of
this paper) whereby a 3rd-party developer writes code that adapts
the behavior of the component. The
adaptation technique described seems pretty trivial—two hooks are provided, one
for “before” computation and one for “after” computation.
[Heineman01] G.T. Heineman and W. T. Councill (Eds).
“Component-Based Software Engineering: Putting the Pieces Together”, Addison
Wesley, 2001.
[Heineman03] George
T. Heineman. “Integrating
Interface Assertion Checkers into Component Models”, in Proceedings of the
6th ICSE Workshop on Component-Based Software Engineering: Automated Reasoning
and Prediction
[Heineman04] George T. Heineman,
Joseph Loyall, and Richard Schantz.
“Component Technology and QoS
Management”, in
[Helton-98] David Helton, “The Impact of Large-Scale
Component and Framework Application Development on Businesss,”
in proceedings of 3rd
International Workshop on Program Composition
A
set of extractions from a number of papers on CBSE, strung together. Reads like an extended discussion of “related
work.” There are some intriguing
references to industrial applications.
However, there is a general mixing of component concepts, from COTS
software, to ERP packages, to Szyperski-type
components.
[Hend 97] Peter Henderson, " Formal Models of Process Components," in
proceedings of the 1st Workshop on Component-Based Systems,
This paper describes Milner’s
pi-calculus and its use in specifying the behavior of components in a
distributed system. The overview of the
pi-calculus presented is quite pragmatic.
There is a little notation, but the paper is readable and provides a
good introduction to the pi-calculus.
The ideas it presents for the formal specification of components do not
seem to go very deep.
[Heuberger 97] Philipp
Heuberger and Åbo Akademi, " Monotonicity
and Lattices as a Foundation of Component-Based Systems," in proceedings
of the 1st Workshop on Component-Based Systems,
This
paper proposes a lattice-based refinement calculus for components. This may be regarded as programming by a
development contract — the lattice operations may be interpreted as the
respective choices of two contract parties.
The paper sets out five problems in the area of component specification
and proposes solutions to these problems.
The paper is very readable with no mathematical notation.
[Hissam
99] Scott A. Hissam, David Carney, “Isolating Faults
in Complex COTS-based Systems,” in Journal of Software Maintenance: Research
and Practice, No. 11, pg. 183-199, 1999.
This paper describes a number of case studies in
diagnosing system mis-behavior where source code is
unavailable. These experiences are
relevant to component-based systems insofar as COTS software products are
software components (implementations, substitutable).
[Hissam02]
[Hissam03] Scott Hissam,
Gabriel Moreno, Judith Stafford and Kurt Wallnau. Enabling predictable assembly”, in I. Crnkovic, H. Schmidt, J.
Stafford, K. Wallnau (Eds),
Journal
of Systems and Software, Special Issue: Component-Based Software Engineering -
Component Certification and System Prediction. Elsevier Science Inc.,
65(3), March 2003, Pages 185-198.
[Hodges-98] Bob Hodges,
"Component Specification and Conformance: What Components must Expose to
Compose”, in proceedings of OMG-DARPA-MCC Workshop on Compositional
Software Architecture
Experiences
from SEMATECH CIM (computer integrated manufacturing) framework. Short on details. Identifies extensions to IDL used to capture
additional information needed for composition: event specifications, pre/post
conditions, relationships/dependencies, and constraint expressions (no examples
provided). Discusses four levels of
conformance checking in order of increasing utility (architectural, syntactic,
semantic, and substitutable); the architectural level seems meaningless as defined. Notes the tension between abstraction and
providing information needed to ensure substitutability.
[Hont-97] Koen De Hondt, Carine Lucas and Patrick Steyaert , "Reuse Contracts as Component
Descriptors," in proceedings of the 2nd
International Workshop on Component-Oriented Programming (WCOP97), held in
conjunction with the European Conference on Object-Oriented Programming
(ECOOP98).
[Holland92] Ian Holland, Reusable Components using Contracts, in proceedings of
the European Conference on Object-Oriented Programming (ECOOP), Springer-Verlag Lecture Notes in Computer Science LNCS 615,
June/July 1992.
[Huisman 99] Marieke
Huisman, Bart Jacobs, and Joachim van den Berg,
" A Case Study in Class Library Verification: Java’s Vector Class" in
proceedings of the first workshop on Formal
Techniques for Java Programs, in conjunction with the 13th European Conference on Object-Oriented Programming,
ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This
paper presents a verification of one invariant property for the Vector class
from Java’s standard library, namely that the number of elements in a vector
never exceeds its capacity. The paper
points out that the investment of formal verification for library classes can
be justified because these classes are used extremely often. This particular verification found no errors
in the Vector class, but it pointed out several places where the documentation
could be improved, including a rather subtle condition that causes an exception
to be thrown, but is not documented at all.
The verification involves using the tool “LOOP” to translate the
relevant Java source code into logical theories in the higher-order logic of
PVS, and then using the PVS proof tool to prove the verification. About 10K of Java code was translated,
resulting in about 750K of PVS code.
This enormous expansion in code size did not present problems in
verification, but meant that type checking took a long time. The paper is very readable, and presents a
real-world example using genuine Java code.
[Huizing 97] C. Huizing and B. Barenbrug, " Interactive Animation needs Components," in
proceedings of the 1st Workshop on Component-Based Systems,
This
paper proposes that interactive animation is a natural application area for
component-based systems. It does not
seem to be relevant to the foundations of CBS.
[Ibrahim-98] Rosziati Ibrahim,
"Component-Based Systems: A Formal Approach," in proceedings of Component-Oriented Software
Engineering Workshop (COSE'98), in conjunction with Australian Software
Engineering Conference (ASWEC'98), November 1998
[Ingham-98] James Ingham and Malcom
Munro, “Applying a Domain Specific Language to Component Oriented Programming,”
in proceedings of 3rd
International Workshop on Program Composition
Reprise of a familiar argument that small,
special-purpose (i.e., domain-specific) languages are useful.
Discuses the use of a domain-specific language to generate Java code,
using CORBA for communication and Java Expert System Shell (JESS) for component
“reasoning,” Seems like they describe a
trivial application.
[Ivanetich-98] Richard Ivanetich, “Enhancement of Command and Control
Architecture,” in proceedings of
OMG-DARPA-MCC Workshop on Compositional Software Architecture
Not really much meat here. Claims
that command and control systems are inherently compositional. Also discusses various DoD architecture-related tasks and their
properties—JTA, HLA, and the DARPA Advanced Information Technology Services
Reference Architecture (AITS RA). Argues that advances in compositional architectures are best
channeled through AITS RA.
[Inverardi-97] P. Inverardi, A. L.
Wolf, D. Yankelevich, “Checking assumptions in
component dynamics at the architectural level, in Proceedings Coordination
Languages and Models. Second International Conference COORDINATION '97., pp 46-63.
[Inverardi02] Paola Inverardi and Massimo Tivoli. “Correct and
automatic assembly of COTS components: an architectural approach”, in Proceedings
of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks
for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online
at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Inverardi03a] Paola Inverardi
and Massimo Tivoli. Deadlock-free software architectures for
COM/DCOM Applications”, in
I. Crnkovic, H. Schmidt, J. Stafford, K. Wallnau (Eds), Journal
of Systems and Software, Special Issue: Component-Based Software Engineering -
Component Certification and System Prediction. Elsevier Science Inc.,
65(3), March 2003, Pages 173-183.
[Inverardi03b] Paola Inverardi and Massimo Tivoli. “A
compositional synthesis of failure-free connectors for correct components
assembly”, in Proceedings of the 6th ICSE Workshop on Component-Based
Software Engineering: Automated Reasoning and Prediction Portland, Oregon, USA
[Jacobs04] B. Jacobs, K. R.M. Leino
and W. Schulte. “Verification of Multithreaded ObjectOriented
Programs
with
Invariants”, in Proceedings of SAVCBS 2004 – Specification and Verification of
Component-Based Systems, held at 12th ACM SIGSOFT Symposium on the Foundations
of Software Engineering Newport Beach, California, USA, October 31-November 5,
2004. (Available as Technical Report #04-09, Department of Computer Science,
Iowa State University, 226 Atanasoff Hall, Ames, IA
50011-1041, USA and online as http://www.cs.iastate.edu/~leavens/SAVCBS/2004/savcbs04.pdf)
[Jia03] Yinghua Jia and Joanne M. Atlee. “Run-Time
Management of Feature Interactions”, in Proceedings of the 6th ICSE
Workshop on Component-Based Software Engineering: Automated Reasoning and Prediction
[Johnson 97] D. Randolph Johnson and Haim
Kilov, " An Approach to an RM-ODP Toolkit in
Z," in proceedings of the 1st Workshop on Component-Based
Systems, Zurich, Switzerland, 1997. In conjunction with European Software Engineering Conference (ESEC)
and ACM SIGSOFT Symposium on the Foundations of Software Engineering (FSE),
1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper describes how the non-OO Z specification language may be used in the
specification of object-oriented systems.
The paper is very readable and it is a good introduction to how Z can be
used in this field.
[Johnson 97b] Johnson, R.E.,”Components, frameworks,
patterns”, Softw. Eng. Notes (USA), Software
Engineering Notes, vol.22, no.3, p. 10-17.
[deJonge03]Merijn de Jonge, Johan Muskens and Michel Chaudron.
“Scenario-Based
Prediction of Run-time Resource Consumption in Component-Based Software Systems”,
in Proceedings of the 6th ICSE Workshop on Component-Based Software
Engineering: Automated Reasoning and Prediction Portland, Oregon, USA
[Jumar04] Santosh Jumar, Bruce W. Weide,
Paolo A.G. Sivilotti, Nigamanth
Sridhar, Jason O. Hallstrom and Scott M. Pike. “Encapsulating Concurrency as an Approach to Unification”, in
Proceedings of SAVCBS 2004 – Specification and Verification of Component-Based
Systems, held at 12th ACM SIGSOFT Symposium on the Foundations of Software
Engineering Newport Beach, California, USA, October 31-
[Kallio01] P.
Kallio and E. Niemela. “Documented
Quality of COTS and OCM Components”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Keller-98a] Rudolf Keller, B. Laguë,
R. Scuauer, "International Workshop on Large
Scale Software Composition," in
proceedings of DEXA'98 Ninth International Workshop on Database and Expert
Systems Applications, Vienna, Austria, pp.
765-833.
This
paper summarizes a workshop that was held in conjunction with DEXA'98. The most interesting part of the summary was
the description of Oscar Nierstrasz' invited
presentation. In this presentation Nierstrasz claimed that component-oriented development must
be framework driven, and that "it is the generic architecture of the
framework that shapes the components and drives their coordination." He contrasted OO development, which produces
complex domain-specific objects, with what is needed for component composition--plug
compatible interfaces. Also mentioned is
a "conceptual framework for composition" that includes black-box
components, architectural style (component types and interfaces, connectors,
composition constraints), scripts that are specifications of concrete
compositions, coordination abstractions which implement the connections, and
glue code for adapting components that are not conformant with the
architectural style (or component model--my words (kcw)).
Neierstrasz referred to two projects that are of interest: Piccola,
a composition language, and FAMOOS, techniques for reengineering legacy systems
to component-based systems.
[Keller-98b] Ralph Keller and Urs Hölze, “Late Component Adaptation,” in proceedings of 3rd International Workshop on Program
Composition
Proposes deploy-time modification of binary
components. Argues that this can be done safely, and is
more efficient than using wrappers, etc., to re-bind named references.
[Keller-98c] R. K. Keller, R. Schauer,
“Design components: towards software composition at the design level”,
Proceedings of the 1998 International Conference on Software Engineering, p.
302-11
[Kiczales-97a] Gregor Kiczales, {OTHERS} “Open
Implementation Design Guidelines,” Gregor Kiczales et. al.,
in ICSE’97.
[Kiczales-97b] Gregor Kiczales,
"Aspect-Oriented Programming," in
proceedings of the European Conference on Object-Oriented Programming, Springer
Verlag LNCS 1241,June 1997.
[Klein 00] Mark Klein,
Rick Kazman, Robert Nord,
"A BASis (or ABASs)
for Reasoning about Software Architectures," submitted to the 22nd
International Conference on Software Engineering (ICSE),
[Kneisel-98] Günter Kneisel,
“Type-Safe Delegation for Dynamic Component Adaptation,” in proceedings of 3rd International Workshop on Program
Composition
Motivation
is to allow run-time adaptation of system behavior by delegation, and
components that can present different interfaces to different clients. Introduces Lava, a
Java-extension that implements
[Kotonya04] Gerald Kotonya and
John Hutchinson. “Viewpoints for Specifying
Component-Based Systems”, in
[Koutlis
98] Manolis Koutlis, P. Kourouniotis, K. Kyrimis, N. Renieri, "Inter-Component Communication as a Vehicle
Towards End-User Modeling," in proceedings of the 1st ICSE
Workshop on Component-Based Software Engineering, Kyoto, Japan, 1998,
http://www.sei.cmu.edu/cbs/icse98/papers/p7.html
[Kotrajaras 99] Vishnu Kotrajaras and Susan Eisenbach, " Threads and Main Memory Semantics" in
proceedings of the first workshop on Formal
Techniques for Java Programs, in conjunction with the 13th European Conference on Object-Oriented Programming,
ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This
paper presents a formal study into the relationship between threads and main
memory as described in the Java Language Specification. It shows that, for a single threaded Java
environment, data consistency is always guaranteed (no surprise!). In a multi-threaded environment, data
consistency on a shared variable is guaranteed when synchronization is performed
on actions that access the variable, i.e., synchronization in Java works
correctly. However, volatile variables
do not maintain data consistency, i.e., the concept of volatility in Java, as
it is presently described, does not work correctly! This shows that formal methods can detect errors
in the informal specifications of real-world languages used today. The paper is fairly readable with just a
little mathematical notation, but it refers to six appendices that are not
included in the proceedings.
[Kram98] Reto Kramer, “iContract — The Java design by Contract Tool”, in TOOLS 26: Technology of Object-Oriented
Languages and Systems, IEEE Computer Society Press, Los Alamitos,
CA, 1998, pp. 295–307.
[Kristensen
96] B. B. Kristensen, D. C. M. May, "Component
Composition and Interaction", in Proceedings of International Conference
on Technology of Object-Oriented Languages and Systems (TOOLS PACIFIC 96),
Melbourne, Australia, 1996,
http://www.cs.auc.dk/~bbk/research/copyright/hook43.ps
Abstract: Component interaction is fundamental to
software architecture. By understanding the nature of components, it is
possible to learn how to build better architectures. This paper examines the
nature of component interaction, attempting to characterize some of its
properties. Language mechanisms and techniques are presented as facilities for
supporting various types of interactions, including enclosing/local components,
notices, coroutine methods and method invocation
control.
[Kropp-98] Nathan Kropp, P. Koopman, D. Siewiorek, "Automated Testing of Off-the-Shelf
Software Components," in IEEE Fault Tolerant Computing Symposium,
[kucik-98] Bülent
Küçük, M.N. Alpdemir, R. N.
Zobel, “Customizable Adaptors for Black-Box
Components,” in proceedings of 3rd
International Workshop on Program Composition
Points
out that adapters are de rigor in hardware—analog-to-digital converters,
amplifiers, rectifiers, graphics adaptors, etc.
Components should be adaptable, so that components can be black boxes.
[Kulkarni04] Sandeep S. Kulkarni and
[Lalanda-97] Phillipe Lalanda , "A Control Model for the Dynamic Selection
and Configuration of Software Components," in proceedings of the 2nd International Workshop on
Component-Oriented Programming (WCOP97), held in conjunction with the European
Conference on Object-Oriented Programming (ECOOP98).
Idea
is a “generic architecture” to develop vertical component models, referred as
Domain Specific Software Architecture (DSSA). DSSA are not only a framework but
also a component library and a method to select and configure components. In
the “generic architecture” components are divided in domain components and
control components. As far as I can see domain components do not interact among
themselves; instead, they only respond to events generated by control
components. It is unclear if they have implemented this architecture or the
advantages of this approach.
[Lano 97] K. Lano,
J. Bicarregui, and T. Maibaum and J. Fiadeiro
" Composition of Reactive System Components," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper describes the Object Calculus of Fiadeiro and Maibaum and makes the case for using it as a component
specification technique. The Object
Calculus extends temporal logic with encapsulation and composition mechanisms
and allows for the specification of multi-processing systems with
concurrency. It is a generalization of statecharts. The
paper uses a steam boiler as a running example and contains a considerable
amount of mathematical notation.
Familiarity with temporal logic would be helpful in reading the paper.
[Larsson02] Magnus Larsson, Anders Wall, Christer Norström, and Ivica Crnkovic. “Using Prediction Enabled Technologies for Embedded Product Line Architectures”, in Proceedings of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Lau01] K. Lau. “Component
Certification and System Prediction: Is There a Role for Formality”, in
Proceedings of the 4th ICSE Workshop
on Component-Based Software Engineering: Component Certification and
Prediction, Toronto, Canada, May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Lauder 99] Anthony Lauder and Stuart Kent, "EventPorts: Preventing Legacy Componentware,"
in proceedings of the Third International IEEE Conference on Enterprise
Distributed Object Computing, Mannheim, Germany, September 1996.
[Leavens99] G.T. Leavens, A.L. Baker, and C. Ruby, Preliminary Design of JML: A Behavioral
Interface Specification Language for Java, Technical Report 98-06c, Iowa
State University, Department of Computer Science, January 1999, http://www.cs.iastate.edu/~leavens/JML/prelimdesign/index.html.
[Lee 9x] Chang Hoon Lee, Kyung Whan Lee, “Formal specification for the component
compositions”, Journal of KISS(B) (Software and
Applications), vol.24, no.11, p. 1182-90.
[Leeb 96] Angelika Leeb,
"A Flexible Object Architecture for Component Software ", Dept.
Of Electrical Engineering and Computer Science, MIT, 1996, MS Dissertation,
http://larch-www.lcs.mit.edu:8001/~aleeb/, http://larch.lcs.mit.edu:8001/~aleeb/thesis.ps.
Abstract: This thesis presents a software architecture
designed to help end-users to
build small applications efficiently by reusing existing software
components. In my approach, software is
structured into flexible components, executable objects that can be modified and
combined at runtime. Flexible components are based on existing software
interoperability standards, such as COM/OLE or
SOM/OpenDoc. They extend conventional component software by extending
the component architecture and the functionality of the component engine that manages
component interoperation. Flexible components have a component-specific
programming interface that allows not only users but other components as well to modify and
extend the functionality of a component dynamically. Furthermore, the flexible
component engine provides services for addressing, relating, grouping, and composing components in
a flexible way. With these
characteristics, flexible components combine the flexibility and
simplicity of dynamic object environments with the reusability and universality
of component software. They promote a new component-centric development style
that unifies multiple
languages and paradigms within the same application environment and supports incremental development of
components. With the implementation of a
prototype, Alego, that simulates a flexible component
environment, I have provided some evidence for the feasibility and usefulness of
flexible components.
[LeSi97] Gary Leavens and Murali Sitaraman (eds.), Proceedings
of the ESEC/FSE-Workshop on Foundations of Component-Based Systems (FoCBS), Zürich, September 1997, http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html.
[Lipari04] Giuseppe Lipari,
Paolo Gai, Michael Trimarchi,
Giacomo Guidi, and Paolo Ancilotti. “A Hierarchical Framework for
Component-Based Real-Time Systems”, in
[Liu02] Chang Liu and Debra J. Richardson. “Specifying Component Method Properties for Component State Recovery in RAIC”, in Proceedings of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Loecher04] Sten Loecher. “Model-Based
Transaction Service Configuration
for Component-Based Development”, in
[Lumpe 97] Markus Lumpe, Jean-Guy Schneider, Oscar Nierstrasz,
and Franz Achermann " Towards a Formal
Composition Language," in proceedings of the 1st Workshop on
Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper describes a general-purpose composition language, based on Milner’s
pi-calculus, called PICCOLA (PI-Calculus-based COmposition
LAnguage). The
paper is very readable with no mathematical notation. It seems to be one of the more worthwhile
contributions.
[Lycett-98] Mark Lycett, Ray J.
Paul, “Component-Based Development: Dealing with Operational Aspects of
Architecture,” in proceedings of 3rd
International Workshop on Program Composition
Nice
abstract!—provides rationale for component frameworks, and for treating the
policies embodied in a framework as components that themselves can also be
configured. From Szyperski,
a framework’s contribution is partial enforcement of architectural principles
by forcing components to perform certain tasks via mechanisms that are provided
by the framework. Composition comes in
two flavors: static, dynamic. Static is
matching up requires/provides interfaces.
Dynamic is about run-time behavior: where requests are stored, managing
concurrent access to shared resources, consistency of persistent state,
etc. These are defined as the
“operational” aspects of an architecture.
[Mason01] D.
Mason. “Probability
Density Functions in Program Analysis”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Mason02] Dave Mason
. “Probabilistic
Analysis for Component Reliability Composition”, in Proceedings of
the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks for
Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online at
http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Matevska-Meyer04] Jasminka Matevska-Meyer, Wilhelm Hasselbring, and Ralf H. Reussner. “Software architecture description supporting component deployment and system runtime reconfiguration” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Maydl04] Walter Maydl. “Design Accompanying
Analysis of Component-Based Embedded Software”, in
[McCamant04] Stephen McCamant
and Michael D. Ernst. “Formalizing Lightweight
Verification of Software Component Composition”, in Proceedings of SAVCBS 2004 –
Specification and Verification of Component-Based Systems, held at 12th ACM
SIGSOFT Symposium on the Foundations of Software Engineering Newport Beach,
California, USA, October 31-
[McGregor03] John D. McGregor, Judith A. Stafford and Il-Hyung
Cho.
“Measuring
Component Reliability”, in Proceedings of the 6th ICSE Workshop on
Component-Based Software Engineering: Automated Reasoning and Prediction
[McGregor03] J.D. McGregor, J.A. Stafford, I. Cho, "Measuring and Reporting Component Reliability," Proceedings of the First ACIS International Conference on Software Engineering Research and Applications, San Francisco, California, June, 2003.
[McIlroy 76] M. D. McIlroy, "Mass Produced Software Components",
Proceedings of the NATO Conferences: Software Engineering, Concepts and
Techniques,
Good for historical
context?
[Medvid-97] N. Medvidovic, P. Oreizy, R. N. Taylor, “Reuse of off-the-shelf components in
C2-style architectures”, Proceedings of the 1997 International Conference on
Software Engineering, p. 692-700.
[Mehlitz03] Peter C. Mehlitz and John J. Penix.
“Design
for Verification: Using Design Patterns to Build Reliable Systems”, in
Proceedings of the 6th ICSE Workshop on Component-Based Software Engineering:
Automated Reasoning and Prediction
[Meseguer-98] Jose Meseguer and Carolyn Talcott,
“Formal Foundations for Compositional Software Architectures,” in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Argues that a formal wide-spectrum language
(oddly enough, the one the authors are constructing) is needed to describe
compositional software. Rewriting logic
is the basis for Maude, the language being developed by the authors. These authors also assert that QoS is realized through meta-level computation, by which I
assume they mean interaction models and various resource management policies
(and also “reflection.”). There is a
reasonable bibliography that will be of use to Fred Long.
[Messer03] D. Messerschmitt and C. Szyperski. Software
Ecosystem – Understanding An Indispensable Technology
and Industry, MIT Press, 2003. ISBN
0-262-13432-2.
[Meyer97] Bertrand Meyer, Object-Oriented Software
Construction, 2e, Prentice-Hall International,
[Meyer 99] Bertrand Meyer, "A Really Good Idea,"
IEEE Computer, December 1999, pg. 144-147.
[Meyerh¨ofer 04] Marcus Meyerh¨ofer and Christoph
Neumann. “TESTEJB - A Measurement Framework for EJBs”, in
[Mikhajlov-97] Leonid Mikhajlov
and Emil Sekerinski , "The Fragile Base Class
Problem and Its Impact on Component Systems," in proceedings of the 2nd International Workshop on
Component-Oriented Programming (WCOP97), held in conjunction with the European
Conference on Object-Oriented Programming (ECOOP98).
[Mikhaj98] Anna Mikhajlova, "Consistent Extension of Components in
Presence of Explicit Invariants", in proceedings of 3rd International Workshop on Program
Composition
Formal specification of contracts; reasoning about
extensions (interface subtypes). Maybe
Fred should read this.
[Mikhaj99] Anna Mikhajlova,
“Specifying Java Frameworks Using Abstract Programs”, in Tools 30: Technology of Object-Oriented Languages and Systems, IEEE
Computer Society Press, Santa Barbara, CA, August 1999, pp. 136–145.
[Mikhaj-99] Anna Mikhajlova,
" Specifying Java Frameworks Using Abstract Programs," in proceedings of Technology of
Object-oriented Languages and Systems, IEEE, Santa Barbara, California, August 1999.
This
paper suggests adding assertions and other specification statements, possibly
non-deterministic, to Java. The
resulting language is called JINSLA (Java INterface
Specification LAnguage). Every construct in JINSLA has a precise
mathematical meaning in the refinement calculus. The approach is used to specify the Java
Foundation Classes (JFC).
[Mikic-Rakic04] Marija Mikic-Rakic and Nenad
Medvidovic. “Software
Architectural Support for Disconnected Operation in Highly Distributed
Environments”, in
[Min04] Hyun Gi Min, Si Won Choi, and Soo Dong Kim. “Using Smart
Connectors to Resolve Partial Matching Problems in COTS Component Acquisition”,
in
[Mitchelk -99] Richard Mitchell
" Analysis by Contract or UML with Attitude," in proceedings of Technology of Object-oriented Languages and Systems,
IEEE, Santa Barbara, California, August
1999.
This
paper summarizes a tutorial on how a model expressed using UML diagrams can be
expressed more formally, and so more precisely, with the aid of OCL. The specification of behavior is in the form
of contracts with pre- and post-conditions.
OCL is used to express the contracts, and to cross-reference the
vocabulary of the state model with that of the type model.
[Mohagheghi01] P.
Mohagheghi and R. Conradi. “Experiences
with Certification of Reusable Components in the GSN Project in Ericsson,
Norway”, in Proceedings of the 4th ICSE Workshop on Component-Based Software Engineering: Component
Certification and Prediction, Toronto, Canada, May 14-15, 2001. (Available
online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[M¨oller 04] Anders M¨oller, Joakim Fr¨oberg, and Mikael Nolin. “Industrial Requirements on
Component Technologies for Embedded Systems”, in
[Moreno02] Gabriel Moreno, Scott Hissam, and Kurt Wallnau. “Statistical
Models for Empirical Component Properties and Assembly-Level Property
Predictions: Toward Standard Labeling”, in Proceedings of the 5th
ICSE Workshop on Component-Based Software Engineering: Benchmarks for
Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online at
http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Muller 97] Peter Müller and Arnd Poetzsch-Heffter " Developing Provably Correct Programs from
Object-Oriented Components," in proceedings of the 1st Workshop
on Component-Based Systems,
This
paper describes techniques for the formal specification of software
components. It provides a useful
overview of formal frameworks, and discusses formal specification and
verification. The paper is very readable
with just a little mathematical notation.
It seems to be another of the more worthwhile contributions.
[Murer-96] Tobias Murer, Daniel
Scherer, Andy Würtz, "Improving Component
Interoperability," in proceedings of the 1st International
Workshop on Component-Oriented Programming, held
in conjunction with the European Conference on Object-Oriented Programming
(ECOOP97).
[Murer-97] Tobias Murer ,
"The Challenge of the Global Software Process," in proceedings of the 2nd International Workshop on
Component-Oriented Programming (WCOP97), held in conjunction with the European
Conference on Object-Oriented Programming (ECOOP98).
[Muskens04] Johan Muskens and
Michel Chaudron. “Prediction
of Run-Time Resource Consumption in Multi-task Component-Based Software
Systems”, in
[Niemela-98] Eila Niemelä, Juha Marjeta,
“Dynamic Configuration of Distributed Software Components,” in proceedings of 3rd
International Workshop on Program Composition
Describes
an architecture for achieving run-time reconfiguration
of components in distributed real-time systems. Refers
explicitly to module interconnection languages (MILs)
like Polylith.
[MILs are like configuration languages? What were the technical limits of MILs for component composition?].
[Ning 9x] Ning,
J.Q.,"Component-based software engineering
(CBSE)," Proceedings. Fifth International Symposium on Assessment of
Software Tools and Technologies
[Norman 98] Donald Norman, "The Invisible Computer: Why
Good Products Can Fail, The Personal Computer is So
Complex, and Information Appliances are the Solution," MIT Press, October
1998.
Although
not really about components, many of the arguments apply. Describes the business
model for computers and computer software that leads to feature proliferation
and differentiation. Also,
differentiates "non-substitutable infrastructure" (e.g., VHS vs.
Beta) from substitutable infrastructure (the tapes). This is analogous to components and framework.
[Norris04] Boyana Norris, Jaideep
Ray, Rob Armstrong, Lois C. McInnes, David E. Bernholdt, Wael R. Elwasif, Allen D. Malony, and Sameer Shende. “Computational Quality of
Service for Scientific Components”, in
[Olaf-96] Ásgeir Ólafsson and Doug Bryan, "On the Need for 'Required
Interfaces' of Components," in proceedings of the 1st
International Workshop on Component-Oriented Programming, held in conjunction with the European Conference
on Object-Oriented Programming (ECOOP97).
[Olken-98] Frank Olken, H. Jacobsen, C. McParland,
“Middleware Requirements for Remote Monitoring and Control,” in proceedings of OMG-DARPA-MCC Workshop on
Compositional Software Architecture
A thoughtful description of requirements for
coordination services for a particular class of applications. A comparison of various
infrastructures (CORBA, DCOM, DCE, etc.). May be useful as evidence
of need for custom—or niche-specific—component frameworks.
[Oreizy-98] Peyman Oreizy,
Argues that architectural styles, especially the
C2 style described in the paper, are necessary to make component technologies
move from programming- to system-level utility.
C2 seems more specific than component and connector--also implied (it
seems) is some form of layering. Claims
that middleware such as CORBA, ActiveX, JavaBeans are component-centric, while
architectural styles are system-centric.
Argues that these areas do not work together yet, but
that this could be achieved by using middleware to implement architecture
technologies (e.g., connectors). Provides a list of requirements for compositional architectures;
and a list of characteristics of successful component marketplaces (using VBXs and Pipe/Filters).
[Outhred-98] Geoff Outhred and
John Potter, “A Model for Component Composition with Sharing”, in proceedings of 3rd
International Workshop on Program Composition
Composition
via a configuration language called Ernie.
Other configuration languages:
[Parsons04] Trevor Parsons and John Murphy. “A framework for automatically detecting and assessing performance antipatterns in component based systems using run-time analysis” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Pazzi-96] Luca Pazzi, "An
Explicit Modelling Perspective for Compound and
Aggregate Entities in the Object Paradigm," in proceedings of the 1st
International Workshop on Component-Oriented Programming, held in conjunction with the European Conference
on Object-Oriented Programming (ECOOP97).
[Penix 9x] J. Penix,
P. Alexander, “Using formal specifications for component retrieval and reuse”,
Proceedings of the Thirty-First Hawaii International Conference on System
Sciences, p.356-65 vol.3
[Peltz-99b] Chris Peltz, "A
Hierarchical Technique for Composing COM based Components," in proceedings
of the 2nd International Workshop on Component-Based Software
Engineering (CBSE), held in conjunction with the 21st International
Conference on Software Engineering (ICSE), Las Angeles,
A
model, set of COM interfaces and a specification tool are described that allow
hierarchical composition of COM components.
The discussion addresses four problems: tight coupling, versioned
connections, lifetime management for assemblies, and specification of
assemblies. Connections among components
are established by matching in and out pins; the in pin implements the
connection. Although COM-specific, there are some practical insights here.
[Periya -99] K. Periyasamy, V.S. Alagar and D.Muthiayen " Verification
and Validation Techniques for Object-Oriented Software Systems," in proceedings of Technology of
Object-oriented Languages and Systems, IEEE,
This
paper presents a tutorial on some techniques for the verification and
validation of object-oriented software systems.
It considers both graphical and formal notations.
[Pfister-96] Cuno Pfister, Clemens Szyperski,
"Why Objects Are Not Enough", in Proceedings, First International
Component Users Conference (CUC'96)",
Abstract:
Object-oriented programming hasn't created a viable software component
industry. From a technical perspective, the reason for this failure lies in an
insufficient consideration of the unique requirements of component software.
Object-oriented programming too often concentrates on individual objects,
instead of whole collections of objects, i.e., components. Component-oriented
programming requires more stringent information hiding, a more dynamic approach, and better
safety properties than object-oriented programming.
[Plakosh-99] Daniel Plakosh,
Dennis Smith, Kurt Wallnau, Water Beans Component
Builder's Guide, Technical Report CMU/SEI-99-TR-024, Software Engineering
Institute, Carnegie Mellon University, Pittsburgh, PA.
[Plakosh 99b] Daniel Plakosh, Scott Hissam, Kurt Wallnau, “Into the Black Box: A Case Study in Obtaining
Visibility into Commercial Software,” Technical Note CMU/SEI-99-TN-010,
Software Engineering Institute,
Similar
to [Hissam 99] in that this paper describes a case
study that deals with the practical consequences of trying to discover how
components work where source code is unavailable.
[Plösch -99] Reinhold Plösch and Josef Pichler, "
Contracts: From Analysis to C++ Implementation," in proceedings of Technology of Object-oriented Languages and Systems,
IEEE,
Adding Python assertions to C++. Conceptually very similar to iContract (see
[Kram98]).
[Plasil -99] Frantisek Plasil, Stanislav Visnovsky, and Miloslav Besta, " Bounding Component Behavior via
Protocols," in proceedings of
Technology of Object-oriented Languages and Systems, IEEE, Santa Barbara, California, August 1999.
This
paper describes an enhancement of the SOFA (Software Appliances) component
description language with a semantic description of a component’s
functionality. The SOFA component
description language is based on CORBA IDL.
It is extended via a set of recursive CSP-based equations. It is claimed that this technique is precise
enough to capture the method calls ordering requirements of a component, and
that it is easy to read and simple to create the protocols.
[Popov01] P.
Popov, L. Strigini, S. Riddle and A. Romanovsky. “Protective
Wrapping of OTS Components”, in Proceedings of the 4th ICSE Workshop on Component-Based Software
Engineering:
Component Certification and Prediction,
[Pour -99] Gilda Pour " Java-Based
Component Model for Enterprise Application Development," in proceedings of Technology of
Object-oriented Languages and Systems, IEEE,
This
paper provides a tutorial on the Java-based component model where JavaBeans
provides the client component model and EJB the server component model. The paper also discusses the major
differences between JavaBeans and ActiveX, as well as those between EJB, MTS
and CORBA components.
[Praehofer-99] Herbert Praehofer,
Johannes Sametinger, and Alois
Stritzinger, " Component
Frameworks — A Case Study," in
proceedings of Technology of Object-oriented Languages and Systems,
IEEE,
This paper reports on an effort to
use both the system theoretic DEVS (discrete event simulation) formalism and
the JavaBeans component model as a basis for a component-based discrete event
simulation framework. This is work in
progress, but a basic set of resource and glue components have been implemented
and simple scenarios simulated. The
experience has been successful, but many questions remain unanswered.
[Preiss01] O.
Preiss and A. Wegmann. “Towards
a Composition Model Problem based on IEC61850”, in Proceedings of
the 4th ICSE Workshop on
Component-Based Software Engineering: Component Certification and Prediction,
Toronto, Canada, May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Renaud 99] K.V. Renaud and R.L. Cooper, "HERCULE: A Framework for Enhancing
Error Reporting in Component-Based Systems," in proceedings of the Third
International IEEE Conference on Enterprise Distributed Object Computing,
Mannheim, Germany, September 1996.
[Reussner04] Ralf H. Reussner, Viktoria Firus and Steffen Becker. “Parametric performance contracts for software components and their compositionality” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Rice 97] Michael D. Rice and Stephen B. Seidman
" Architectural Issues in Component-Based Software Engineering," in
proceedings of the 1st Workshop on Component-Based Systems, Zurich,
Switzerland, 1997. In
conjunction with European Software Engineering Conference (ESEC) and ACM
SIGSOFT Symposium on the Foundations of Software Engineering (FSE), 1997.
http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper does not really address “architectural issues of CBSE” per se. Instead, it argues that an architectural
description language is essential to component-based systems. The paper proposes one such language, called
ASDL (Architectural Style Description Language), that is based on Hoare’s CSP
and Z. This work, in turn, builds on
earlier work in applying Z to module interconnection languages. The paper is fairly readable but involves
some mathematical notation that requires an understanding of CSP.
[Rice99] Micheal D. Rice and Stephen B. Seidman,
“Describing Software Architectures and Architectural Styles”,
http://www.bell-labs.com/user/dep/prof/wicsa1/final/seidman.pdf.
[Robben-98] Bert Robben, F. Matthijs, Wouter Joosen, Bart Vanhaute, and Pierre
Verbaeten, “Components for Non-Functional
Requirements,” in proceedings of 3rd
International Workshop on Program Composition
Proposes one component per quality
attribute. This may not be as silly as it sounds—the
idea is based (again) on MOP, in this case controlling object interactions and
lifecycle. Introduces the
term “implicit” to denote a framework that is transparent to a component, one
which the component can not interact with. Meta objects are also objects, so can also
have a meta level, etc., leading to layered
architectures.
[Rosen-98] Arnon Rosenthal, R. Hyland, E. Hughes, “How to Componentize Data-Intensive Legacy Applications: Issues and
Initial Approaches,” in proceedings of OMG-DARPA-MCC Workshop on
Compositional Software Architecture
COE deals with one aspect of composition
(deployment, in our “base camp”): non-interference. In COE, segment=component. Discussion of the
development of mini-frameworks (special-purpose frameworks.) Note their definition of framework tends
towards the OO concept of application framework, but their examples (OpenDoc,
JavaBeans, ActiveX) tends toward component
frameworks.
[Rosenblum-98] David Rosenblum, A. Wolf, A. Carzaniga,
“Critical Considerations and Designs for Internet-Scale, Event-Based
Compositional Architectures,” in proceedings of OMG-DARPA-MCC Workshop
on Compositional Software Architecture
Argues
that event-based integration has use properties for compositional systems, and
that this style of interaction can be applied to internet-scale systems. Argues that SoftBench, Field, ToolTalk and
Yeast work well on LANs but not WANs.
The paper describes internet-scale event observation and notification
services. Defines a seven-dimensional
“design space” for such services (not all orthogonal): object model, event
model, naming model, observation model, time model, notification model and
resource model. Discusses
weaknesses of CORBA event model.
Is using the Software Dock—“an agent-based system…for internet-scale
distributed configuration management and deployment” as an exemplar
internet-scale event-based compositional system.
[Rustan 99] Rustan, M. Leino, James B. Saxe, and Raymie Stata, " Checking
Java Programs via Guarded Commands," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. " in
proceedings of the first workshop on Formal
Techniques for Java Programs, in conjunction with the 13th European Conference on Object-Oriented Programming,
ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This
paper discusses how verification conditions can be derived from Java
programs. This is a significant
engineering challenge because Java provides many programmer conveniences that
make the derivation very bulky and tedious.
Also, finding the right derivation is as much an art as a science. The paper presents a three step approach: the
Java code is first translated into a sugared guarded-command language, then
this code is de-sugared with user input, and finally the verification
conditions are generated from the de-sugared language. The paper is fairly readable.
[Reus 99] Bernhard Reus, " A Logic of Recursive Objects," in proceedings of
the 1st Workshop on Component-Based Systems,
Very
technical paper describing a denotational semantics
of an untyped functional object calculus endowed with
a higher-order logic and some proof principles in
order to obtain a logic of recursive objects.
[Sangal -99] Neeraj
Sangal, Edward Farrell, Karl Lieberherr,
and David Lorenz, " Interaction Schemata: Compiling Interactions to Code,," in
proceedings of Technology of Object-oriented Languages and Systems,
IEEE,
This
paper presents two tools that facilitate the programming of object
interactions. These enable object
interactions to be programmed generically, thereby improving the reusability of
the reactions. One tool uses standard
UML sequence diagrams, but is constrained in the kinds of interactions it can
accommodate. An
improved specification of interactions, called interaction schemata, allow
a more general code generation solution.
Seemingly this work is more relevant to OO than components, but a
similar code generator idea was used by an EJB bean provider to generate code
to compose e-commerce beans. The work
reported in this paper is rooted in the Demeter project and adaptive
programming.
[Sandstr¨om 04] Kristian Sandstr¨om,
Johan Fredriksson, and Mikael
˚Akerholm. “Introducing
a Component Technology for Safety Critical Embedded Real-Time Systems”, in
[schantz-98]
Richard Schantz, D. Bakken, D.
Karr, J. Loyall, and J. Zinky,
“Distributed Objects with Quality of Service: An Organizing Architecture for
Integrated System Properties," in proceedings of OMG-DARPA-MCC
Workshop on Compositional Software Architecture
Takes a
system-of-systems perspective on need for QoS. Makes another argument for
internet-scale systems. Claims
CORBA gets part of the way there (functional integration, heterogeneity,
interoperability, COTS infrastructure).
Several references to related work in QoS
provision in infrastructure and in object/component implementation. (The latter: Aspect-oriented programming; and
Open Implementations.). Emphasis on this
work—Quality of Objects (QoA)—is on providing control
of functional and QoS aspects of object
implementations. Defines
QDL (Quality Description Language) to complement IDL; and Contract Description
Language (CDL) to do runtime monitoring of contracts (regions in QDL?) and
arbitration in case of a divergence from contractual behavior.
[Schmidt 97] Rainer Schmidt "
Component-Based Systems, Composite Applications and Workflow-Management,"
in proceedings of the 1st Workshop on Component-Based Systems,
This
paper proposes that component-based systems are the missing link between
workflow-management and software engineering.
It sets out a basic notion of components and composition and shows how
these apply to workflow-management architectures. It does not seem to be relevant to the
foundations of CBS.
[Schmidt01] H.
Schmidt. “Trusted
Components: Towards Automated Assembly with Predictable Properties”, in
Proceedings of the 4th ICSE Workshop
on Component-Based Software Engineering: Component Certification and
Prediction, Toronto, Canada, May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Schmidt02] Heinz W. Schmidt and Ralf Reussner. “Parameterised
Contracts and Adapter Synthesis”, in Proceedings of the 5th ICSE
Workshop on Component-Based Software Engineering: Benchmarks for Predictable
Assembly, Orlando, Florida, May 19-20, 2002. (Available online at
http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Schmidt03] H. Schmidt. “Trustworthy components––compositionality and prediction”, in I. Crnkovic,
H. Schmidt, J. Stafford, K. Wallnau (Eds), Journal
of Systems and Software, Special Issue: Component-Based Software Engineering -
Component Certification and System Prediction. Elsevier Science Inc.,
65(3), March 2003, Pages 215-225.
[Schneider04] Jean-Guy Schneider and Jun Han. “Components – the past, the present, and the future” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Schrey-97] Stefan Schreyjak ,
"Coupling of Workflow and Component-Oriented Systems," in proceedings
of the 2nd International
Workshop on Component-Oriented Programming (WCOP97), held in conjunction with
the European Conference on Object-Oriented Programming (ECOOP98).
[Seacord-98] Robert Seacord, "Duke ORB Walker, in proceedings of
OMG-DARPA-MCC Workshop on Compositional Software Architecture
Describes Agora, or at least its concept. Compares the Agora idea of
an internet-based repository with more traditional notions of software
repository.
[Sha95] Lui Sha, Ragunathan
Rajkumar, Michael Gagliardi,
A Software Architecture for Dependable and Evolvable Industrial Computing
Systems, Technical Report SEI-TR-95-005, Software Engineering Institute,
Carnegie Mellon University, Pittsburgh, PA.
[Shaw-99] Mary Shaw,
"Truth vs. Knowledge: The Difference Between What
a Component Does and What We Know It Does," in proceedings of the 8th
International Workshop on Software Specification and Design, March 1996.
Nice paper with a description of the required
characteristics of a notation to specify components: incremental, extensible
and heterogeneous. Argues that it is impossible to completely specify a
component; there will always be unexpected situations. It proposes credentials
as a notation addressing the requirements.
[Shukla04] Rakesh Shukla, Paul Strooper,
and David Carrington. “A Framework for Reliability Assessment of Software Components”, in
[Simons04] Kevin Simons and Judith Stafford .
“CMEH: Container Managed Exception Handling for Increased Assembly Robustness”,
in
[Sitaraman01] M.
Sitaraman. “Compositional
Performance Reasoning”, in Proceedings of the 4th ICSE Workshop on Component-Based Software
Engineering: Component Certification and Prediction, Toronto, Canada, May
14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Sitaraman04] Murali Sitaraman,
Durga P. Gandi, Wolfgang Küchlin, Carsten Sinz and Bruce W. Weide. “DEET for Component-based Software”, in
Proceedings of SAVCBS 2004 – Specification and Verification of Component-Based
Systems, held at 12th ACM SIGSOFT Symposium on the Foundations of Software
Engineering Newport Beach, California, USA, October 31-
[Sousa-99] João Pedro Sousa and David Garlan,
"Formal Modeling of the Enterprise JavaBeans™ Component Integration
Framework," in proceedings of the World Congress on Formal Methods, FM99.
[Sridhar03] Nigamanth
Sridhar and Jason O. Hallstrom. “Generating
Configurable Containers for Component-Based Software”, in Proceedings of
the 6th ICSE Workshop on Component-Based Software Engineering: Automated
Reasoning and Prediction
[Staehli04] Richard Staehli
and Frank Eliassen. “Compositional Quality of Service Semantics”, in Proceedings of SAVCBS 2004 –
Specification and Verification of Component-Based Systems, held at 12th ACM
SIGSOFT Symposium on the Foundations of Software Engineering Newport Beach,
California, USA, October 31-
[Stafford00] J.A. Stafford and A.L. Wolf,
"Annotating Components to Support Component-Based Static Analyses of
Software Systems." Proceedings of the Grace
Hopper Celebration of Women in Computing 2000,
[Stafford01] J.A.
Stafford and K.C. Wallnau. “Is
Third Party Certification Necessary? ”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Stafford02] Judith A. Stafford and John D. McGregor. “Issues in
Predicting the Reliability of Composed Components”, in Proceedings
of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks
for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online
at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Stafford04] Judith A. Stafford and John D. McGregor. “Top-down analysis for bottom-up development” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Stauns 97] Jørgen
Staunstrup " Interface
Consistency," in proceedings of the 1st Workshop on Component-Based
Systems,
This
paper simply notes that interfaces might be interpreted differently by
providers and consumers of a service offered by an interface.
[Steen-97] Jørgen Steensgaard-Madsen , "A generator for composition
interpreters," in proceedings of the 2nd
International Workshop on Component-Oriented Programming (WCOP97), held in
conjunction with the European Conference on Object-Oriented Programming
(ECOOP98).
[Stets-99] Robert J.
Stets, G. Hunt, M. Scott, "Component-Based APIs for Versioning and
Distributed Applications," IEEE Computer, July 1999, pp. 54-61
Describes how the win32 APIs are re-factored into
a component-based API, and how various implementation details (e.g., OS
callbacks to now-remote clients) were addressed. Although the paper is about
"componentizing" the win32 API, the principles might apply equally
well to a component-wise re-factoring of arbitrary legacy applications. A three step factorization process is briefly
described which seems does not seem to be peculiarly linked with operating
system concepts.
[Strunk-99] Wolfgang Strunk, Carola Lilienthal, " Tool
Support for Testing and Documenting Framework-Based Software," in proceedings of Technology of
Object-oriented Languages and Systems, IEEE, Santa Barbara, California, August 1999.
This
paper describes a tool called VOOP (Visualizing Object-Oriented Program
architecture) that is used for framework inspection. VOOP can be used to visualize the dynamic
behavior of program components. It is
claimed that the tool might be used for comparing design documents with the
actual program at work.
[Sullivan 97] K. J. Sullivan, J. Socha,
M. Marchukov, “Using formal methods to reason about
architectural standards”, Proceedings of the 1997 International Conference on
Software Engineering, p. 503-13
[Sun 97] Hongyan Sun and Anders P.
Ravn " Architectural Jigsaw Patterns," in
proceedings of the 1st Workshop on Component-Based Systems, Zurich,
Switzerland, 1997. In
conjunction with European Software Engineering Conference (ESEC) and ACM
SIGSOFT Symposium on the Foundations of Software Engineering (FSE), 1997.
http://www.cs.iastate.edu/~leavens/FoCBS/FoCBS.html
This
paper describes an ADL that uses the ML module system and functors. Jigsaw patterns are a visual device for
depicting architectures. One consequence
of the Jigsaw idea is that components do not implement interfaces, and
connectors do not use interfaces. No
matter how well motivated or consistent with Jigsaw, this result is
non-intuitive, and does not mesh with the general interpretation of components
and interfaces. The paper is readable
with a little ML-like notation.
[Szyperski
96] Clemens Szyperski,
"Independently Extensible Systems - Software Engineering Potential and Chalanges", in Proceedings of the 19th Australasian
Computer Science Conference,
Abstract: Component-based software, open systems,
and document-based user interfaces are about to revolutionise
most areas traditionally addressed by the software engineer. We claim that many
traditional software engineering methods, from life-cycle models to programming
languages to system architectures are at least insufficient when facing the new
trends. In this paper we present the main points of criticism and state a few
unavoidable facts of life: extensible systems are in principle modular, have no
final form or final integration phase, cannot be subjected to final total
analysis, cannot be exhaustively tested, and have to allow for mutual
independence of extension providers. We also hint at possible solutions for
part of the problem set. In particular, we investigate the problem of dependence
on global analysis, the effects of Cartesian Products in the design space, and
the resulting design constraints on programming languages as the exemplary and
most important tool of the software engineer. The relevance of the observations
will be underlined by several examples drawn from contemporary programming
languages and methods that got it wrong.
[Szyperski-98a] C. Szyperski and R. Vernik,
“Establishing System-Wide Properties of Component-Based Systems,” in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
“…it does not seem reasonable to expect
conglomerates of wired components to have any system wide properties at
all! We hardly know how to specify such
properties, let alone how to verify individual components against such
specifications. Expecting that arbitrary
compositions retain such properties is even more demanding.” From this the argument that something
separate from the composites will be needed to guarantee invariant
properties—the component framework that accepts components as black-box
plug-ins. The authors pose several open
research questions, e.g., how are frameworks design to a) accommodate plug-in
style integration and b) support interoperability among frameworks? (Note: co-author Vernik
had, last year, a similar research objective to ours, with a focus on
components in C2).
[Szyperski98b] C. Szyperski, “Component Software Beyond
Object-Oriented Programming,” Addison-Wesley and ACM Press, 1998.
[Szyperski98c] C. Szyperski, Component Software: Beyond Object-Oriented
Programming, Addison Wesley, ACM Press,
[Szyperski02] C. Szyperski, D. Guntz, and S. Murer. Component Software: Beyond Object-Oriented Programming, 2nd Edition, Addison Wesley, ACM Press, November, 2002.
[Taborda04] Louis J.M. Taborda. “The Release Matrix for Component-Based Software Systems”, in
[Tarr99] Peri Tarr, Harold Ossher, William Harrison, Stanley Sutton, Jr., "N
Degrees of Separation: Multi-Dimensional Separation of Concerns," in
proceedings of the 21st International Conference on Software
Engineering (ICSE99), Las Angeles, CA, 1999.
[Theory99] Theory
Center, Press Release dated November 10, 1999, "BEA Acquires The Theory
Center and its Industry-Leading Portfolio of Java Components for Building
E-Commerce Solutions", Available WWW<URL:http://www.theorycenter.com/theory/pr111099.htm>.
[Thomas 97] Laurent Thomas "
Validation and Verification of Timing Properties of an Architecturally
Described System," in proceedings of the 1st Workshop on
Component-Based Systems,
This
paper addresses the topic of establishing global properties of a system from
the properties of its components.
Although the paper illustrates some of the complexity of reasoning about
one type of global property — time — it does not provide a convincing solution
(or any solution) to how this global property can be deduced from
components. It reads as if the author
knows real-time systems and is trying to understand how to apply formal methods
to timing properties. The paper is
marred by many typos. There are
programming examples but no deep mathematical notation.
[Thom-98] Craig Thompson, P. Pazandak,
V. Vasudevan, F. Manola, M.
Palmer, G. Hanser, S. Ford “Intermediary
Architecture: Interposing middleware services and ilitites
between web client and server,” in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
Idea
is “to interpose intermediary [sic] middleware plug-in services between the web
client and server.” Idea is integration
of “web objects” with middleware. The
claim is that through interposition various QoS-ilities
can be installed. Thin clients are
getting fatter because they are implementing QoS
features—caching, history, SSL-based security, internationalization, etc. The focus is in particular on web-based
infrastructures.
[Tivoli04] Massimo Tivoli, Paola Inverardi,
Valentina Presutti,
Alessandro Forghieri, and Maurizio Sebastianis. “Correct Components Assembly for a
Product Data Management Cooperative System”, in
[Troya-97] Jose M. Troya and
Antonio Vallecillo , "On the Addition of Properties
to Components," in proceedings of the
2nd International Workshop on Component-Oriented Programming
(WCOP97), held in conjunction with the European Conference on Object-Oriented
Programming (ECOOP98).
[Tyler04] Benjamin Tyler and Neelam
Soundarajan. “Testing
Framework Components”, in
[UL-1998] UL Standard for Safety for Software in
Programmable Components, UL 1998., Underwriters
Laboratories Inc., (UL).
[Vecellio02] Gary Vecellio, William M. Thomas, and Rob Sanders. “Containers
for Predictable Behavior of Component-based Software”, in Proceedings
of the 5th ICSE Workshop on Component-Based Software Engineering: Benchmarks
for Predictable Assembly, Orlando, Florida, May 19-20, 2002. (Available online
at http://www.sei.cmu.edu/pacc/CBSE5/CBSE5-Proceedings.html)
[Vecellio03] Gary Vecellio and William Thomas. “Infrastructure
Support for Predictable Policy Enforcement”, in Proceedings of the 6th ICSE
Workshop on Component-Based Software Engineering: Automated Reasoning and
Prediction
[Venkat-98] Nalini Venkatasubramanian and Gul Agha, “Composable
QoS-Based Distributed Resource Management, in
proceedings of OMG-DARPA-MCC Workshop on Compositional Software Architecture
QoS and
quality attributes are realized by resource management policies. (In Base Camp we defined framework as
implementing resource management policies.).
Implementing these aspects today requires code in the components
themselves. Separate specification of
resource management will allow dynamic modification of protocols to meet
changing contextual needs. Proposes a
two-tier architecture, application and meta
tiers. Similar (not as
general) as scheme proposed in [robben-98], neither of which is implemented.
[Viera01] M.E.R.
Vieira, M.S. Dias and D.J. Richardson. “Describing
Dependencies in Component Access Points”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering: Component Certification and Prediction, Toronto, Canada,
May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Voas 97] Jeffrey M. Voas " Testing Formal
Methods," in proceedings of the 1st Workshop on Component-Based
Systems,
This
paper proposes a research initiative for how best to marry formal methods with
the more traditional testing approaches.
It also suggests some non-traditional testing approaches and gives an
example for a COTS component that has been “wrapped” using formal methods but ideas
seem rather superficial.
[Wallnau
97] K. Wallnau, E. Morris, P. Feiler,
A. Earl and E. Litvak, “Engineering Component-Based
Systems with Distributed Object Technology”, Lecture Notes in Computer Science #1274,
Springer-Verlag.
[Wang-99a] Guijun Wang, L. Ungar and D. Klawitter,
"Component Assembly for OO Distributed Systems," IEEE Computer, July
1999, pp. 71-78
Describes an interesting component model,
which has the flavor of some universality. Claims that components have
four "boundary elements" (i.e., interface elements): services
provided, services required, events generated, and events observed. From these, three possible interaction styles
are possible: service-service, event-event, and event-service. (I need to think why service-event is not
included.(kcw)) Ports and Links are used to separate what a
component does (its services and events) from how it communicates with other
components, respectively.
Service-service interactions are set up between a DiscreteServiceRequire
port and a DiscreteServiceProvide port, both of which
are types of components. (There are SessionService ports as well.) Event ports (provide and require) work
analogously to JavaBeans event providers and listeners. Links are used to connect ports; there are
three link types, ServiceLink, EventLink,
EventServiceLink,
corresponding to the three interaction styles.
A prototype implementation of this component model is described, and a
sample composition of a shopping application is also described.
[Wang-99b] Guijun Wang and H. Alan
Maclean, "Software Components in Contexts and
Service Negotiations," in proceedings of the 2nd International
Workshop on Component-Based Software Engineering (CBSE), held in conjunction
with the 21st International Conference on Software Engineering
(ICSE), Las Angeles,
Suggests that components play different
roles at different points in the development process. For
the architecture phase, architectural components are proposed, which combine Szyperski's definition of component with component
models. A component model describes the
interfaces that all components must possess.
One particular component model is illustrated. The author argues that the component model
allows analysis and prediction of functional and non-functional attributes.
Also discussed is the idea that components may be mismatched with respect to
provided and required services or non-functional attributes, in which case
negotiation is needed. The examples are
a bit contrived, but the ideas are well-argued.
[Wassermann04] Gary Wassermann and Zhendong Su. “An Analysis Framework for Security in Web Applications”, in
Proceedings of SAVCBS 2004 – Specification and Verification of Component-Based
Systems, held at 12th ACM SIGSOFT Symposium on the Foundations of Software
Engineering Newport Beach, California, USA, October 31-
[Weck-96] Wolfgang Weck,
"Independently Extensible Component Frameworks," in proceedings of
the 1st International Workshop on Component-Oriented Programming, held in conjunction with the European Conference
on Object-Oriented Programming (ECOOP97).
A rather nice if high-level discussion of various
concepts: extensibility, independent extensibility, component frameworks, and
dimensions of extensibility in component frameworks. The argument is that component frameworks
prescribe (and, if implemented in software, enforce) design rules that
developers of components must follow to ensure that components will a) not
interfere, or b) will interact. Frameworks
also define in which ways a component-based system is extensible (i.e., through
the addition of components that must play some role in a system).
[Weck-97] Wolfgang Weck , "Inheritnance Using Contracts & Object
Composition," in proceedings of the 2nd
International Workshop on Component-Oriented Programming (WCOP97), held in
conjunction with the European Conference on Object-Oriented Programming
(ECOOP98).
The
author asserts that components are based in objects and therefore inheritance
should be permitted in components as it is in OO. The paper introduces dynamic
vs. static inheritance and proposes static inheritance of contracts and dynamic
inheritance of component implementations.
[Weide01] B.W.
Weide. “Modular
Regression Testing: Connections to Component-Based Software”, in
Proceedings of the 4th ICSE Workshop
on Component-Based Software Engineering: Component Certification and
Prediction, Toronto, Canada, May 14-15, 2001. (Available online at http://www.sei.cmu.edu/pacc/workshop_call.html)
[Weide03] Bruce W. Weide, William F. Ogden and Murali Sitaraman. “Expressiveness
Issues in Compositional Performance Reasoning”, in Proceedings of the 6th
ICSE Workshop on Component-Based Software Engineering: Automated Reasoning and
Prediction
[Welch-98] Ian Welch, Robert Stroud, “Adaptation of
Connectors in Software Architectures,” in
proceedings of 3rd International Workshop on Program Composition
Using
connectors to “model” metaobject protocols
(MOP). Using WRIGHT to
do this. Idea is to allow adaptation
of non-functional properties (fault tolerance, security). Focus: adaptation of interactions among
components. (Reference
to paper about using MOP for wrapper generation. Connectors is an
extension/generalization of this work.) (Reference to a paper by Stroud and Wu about MOP for satisfying
non-functional attributes.)
[Wile01] D.S.
Wile. “Ensuring
General-Purpose and Domain-Specific Properties Using Architectural Styles”,
in Proceedings of the 4th
ICSE Workshop on Component-Based Software Engineering:
Component Certification and Prediction,
[Wile03] David S. Wile. “Revealing component properties through architectural styles”, in I. Crnkovic,
H. Schmidt, J. Stafford, K. Wallnau (Eds), Journal
of Systems and Software, Special Issue: Component-Based Software Engineering -
Component Certification and System Prediction. Elsevier Science Inc.,
65(3), March 2003, Pages 209-214.
[Wileden 97] Jack C. Wileden " Toward a Conceptual
Foundation for Interoperation," in proceedings of the 1st
Workshop on Component-Based Systems,
This
paper argues that a conceptual foundation for component interoperation is
urgently needed, especially in the areas of name management and typing. The author claims that: “there are presently
[in 1997] no well-established conceptual foundations specifically addressing
interoperability. The paper is very
readable with no mathematical notation.
[Wills 99] Alan Cameron Wills, "Modeling for Component
Based Systems with Catalysis," tutorial notes, Enterprise Distributed
Object Computing (EDOC) 1999,
[Woodman01] M.
Woodman, O. Benediktsson, B. Lefever and F. Stallinger. “Issues of
CBD Product Quality and Process Quality”, in Proceedings of the 4th ICSE Workshop on Component-Based
Software Engineering:
Component Certification and Prediction,
[Wu03] Xiuping Wu,
David McMullan and
[gXie04] Gaoyan Xie and Zhe
Dang. “CTL Model-checking for Systems with Unspecified
Components”, in Proceedings of SAVCBS 2004 – Specification and Verification of
Component-Based Systems, held at 12th ACM SIGSOFT Symposium on the Foundations
of Software Engineering Newport Beach, California, USA, October 31-
[tXie04] Automatic Extraction of Sliced Object State Machines for
Component Interfaces”, in Proceedings of SAVCBS 2004 – Specification and
Verification of Component-Based Systems, held at 12th ACM SIGSOFT Symposium on
the Foundations of Software Engineering Newport Beach, California, USA, October
31-
[Yi 99] Kwangkeun Yi and Byeong-Mo Chang
" Exception Analysis for Java," in proceedings of the 1st
Workshop on Component-Based Systems, Zurich, Switzerland, 1997. In conjunction with
European Software Engineering Conference (ESEC) and ACM SIGSOFT Symposium on
the Foundations of Software Engineering (FSE), 1997. " in
proceedings of the first workshop on Formal
Techniques for Java Programs, in conjunction with the 13th European Conference on Object-Oriented Programming,
ECOOP ’99. See http://www.informatik.fernuni-hagen.de/import/pi5/publications.html.
This
paper points out that programmers may over specify the exceptions thrown by a
method, i.e., list an exception as being thrown whereas it is not, or specify
exceptions too broadly by listing an exception class which is unnecessarily
high up the class hierarchy. The paper
shows how the exception throwing requirements of a piece of code may be
analyzed precisely. The approach has not
yet been applied to any realistic Java programs. The paper includes quite a lot of notation,
but is otherwise readable.
[Yucel-98] Sakir Yucel, T. Kusano, and Saydam, “A Component
Based Distributed Software Architecture for Multimedia Services,” in proceedings of OMG-DARPA-MCC Workshop on
Compositional Software Architecture
The most interesting part of this paper is the
brief description of a component model that (it appears) is defined by TINA-C
(Telecommunications Information Networking Architecture Consortium). A component comprises several parts, each of
which is dedicated to different tasks: a functional part (what a component
does), a “substance” part (what a component needs), a management part (how the
component is managed) and a validation part (for real-time validation, whatever
that means). There are other structural
aspects of components, as well. It might
be worthwhile to track down TINA-C. (See
[ashford-98]).
[Zaremski-9x] A. M. Zaremski, J. M. Wing,
“Specification matching of software components”, ACM Transactions on Software
Engineering and Methodology, vol.6, no.4, p. 333-69.
[Zeid04] Amir Zeid, Michael Messiha, Sami Youssef. “Applicability of component-based development in high-performance systems” in Proceedings of the Ninth International Workshop on Component-Oriented Programming, June 15, 2004 at ECOOP 2004, Oslo, Norway, June 14–18, 2004. (Available online as http://research.microsoft.com/~cszypers/events/WCOP2004/)
[Zhao03] Wei Zhao, Barrett R.Bryant, Jeffrey G. Gray, Carol C. Burt, Rajeev R. Raje, Andrew M. Olson and Mikhail Auguston.
“A
Generative and Model Driven Framework for Automated Software Product Generation”,
in Proceedings of the 6th ICSE Workshop on Component-Based Software
Engineering: Automated Reasoning and Prediction