List of Presentations
Koetter Hans-Friedrich and Nan Guo, Fern Universitaet Hagen:
Automated Request Brokerage using Type-dependent Decisions and Monitoring
The World Wide Web and Distributed Object-Oriented Systems (like
e.g. CORBA) provide foundation and infrastructures for distributed
client-server computing. This talk presents our work to integrate
CORBA-Objects into the Web through the employment of the software
packages OrbixWeb and Orbix. With the programming language JAVA and
the CORBA-tool OrbixWeb, we have implemented a graphical frontend
which runs on any JAVA platform and allows access to remotely offered
services. In our application, brokerage is based on type-dependent
decisions. Routing to the most appropriate server is decided dynamically
depending on load characteristics of the web-servers and the request-type.
The service itself is implemented in C++ and the CORBA-tool Orbix, providing
a realistic example of an application of the CORBA language mapping facility.
Full Text (compressed postscript).
Complementary Figure (compressed postscript).
Bergner Klaus, Technische Universität München:
Casting an Abstract Design into the Framework of Java RMI.
Java's Remote Method Invocation mechanism is an object-oriented
middleware framework for the development of distributed applications. We
describe our experiences with a case study where we casted an abstract design
specification for a small, distributed multi-user editor into the framework
of Java RMI. We concentrate on the encountered difficulties and present
workarounds for certain problems.
Snoeck Monique, Kath. Univ. Leuven:
A proper architecture allows to keep requirements independent
from implementation frameworks.
The implementation environment for Information systems is
evolving rapidly and often new systems have to coexist and inter-operate
with existing legacy systems. This requires a very flexible (adaptable
and maintainable) information systems architectures in order to keep the
cost of software development manageable.
Current OOAD methods do not sufficiently take account for these
factors: they are to much focused on the development of new projects
where everything is build from scratch.
However, an adapted version of the Zachman framework for Information
Systems architecture can provide us with interesting guidelines for
partitioning and layering specifications such that specifications remain
as independent as possible from the choosen implementation environment.
In addition it provides concepts for structuring "make or buy"
decisions, for the evaluation of "off-the-shelf" software and for the
integration of new systems with legacy systems.
Tai Stefan and Wortmann Jan, Technische Univ. Berlin:
On the Impact of Integration Platforms on Architecting Air Traffic
Integration platforms such as CORBA have the potential to facilitate the
implementation of distributed applications, since tedious network programming
can be avoided. The platform technology and especially its object model
however impact design decisions and such must be recorded in the software
architecture. In this paper we regard as an example the air traffic control
domain and discuss the benefits of using software architectural abstractions
of components and connectors to better cope with system evolution.
Kurki Tiina, TT Tieto Oy, Finland:
Application of object-based CASE-Tools in systems development process
(ESSI Process Improvement Project, project "FI-TOOLS", ESSI number: 21367).
Excerpt from project report (main conclusions): When using an object-oriented
CASE-tool from methodological point of view, the CASE-tool builds a connection
between design and implementation phases of the project. The personnel in
Banking and Financial systems has become aware of component libraries. This is
a remarkable point both from the business and technical point of view in the
longer run. When we are producing new components it is crucial for the
further use of the components, that they are very well tested.
Rivett-Carnac John Ainsworth and Assoc., UK.
Raghavan Sri, Digital, U.S.A.:
Keller Rudolf, University of Montreal, Canada:
Middleware for Software Design.
Abstract component software models promote software development by assembly of
prefabricated, configurable, and independently evolving building
blocks. Although effective for systems implementation, this approach is
inadequate for the creation of reusable and changeable software
architectures. Architectural design is an evolutionary process that requires
abstract thinking and expertise in both the application domain and software
design. Successful software architectures usually arise from a continuous
reassessment of design alternatives and redistribution of responsibilities.
Design patterns address exactly these shortcomings of component-based software
development. They capture the formal and informal expertise that is necessary
for a reusable solution to a recurring problem. Thus, design patterns become
the conceptual building blocks for software development. However, so far there
is no methodical approach to providing these building blocks in a tangible,
flexible, and composable form. To address this shortcoming, we introduce
design components, reified design patterns fit for component software. Design
components allow for an incremental evolution and iterative refinement of
software, beginning with architectural design and ending with the executable
application. Design components can be abstract or concrete, generic or
domain-specific, basic or composite, and incorporate both the formal design
pattern structure and informal design expertise, such as applicability and
trade-offs. They are modeled using extended techniques of object modeling
languages, such as the UML. Most importantly, they exhibit a clear interface
and are formal enough to allow for computer-supported composition,
customization, storage, and retrieval. They can be considered as middleware
for software design. In this talk, we coin and explore the notion of design
component and apply it to a case study.
< retour à (back to)
STEP'97. Workshop on Object-Oriented Middleware and Frameworks for
Systems Integration: Practical Issues and Challenges
Dernière mise à jour par (last update by):
Sat Jul 26 14:19:13 EDT 1997.