scispace - formally typeset
Search or ask a question
Book ChapterDOI

A Structural Computing Model for Dynamic Service-Based Systems

TL;DR: A new architectural model, the Information Unit Hypermedia Model, IUHM, is designed for modelling and implementing dynamic systems, where both the data and the services available to users are freely extensible by the users and the strict distinction between system and user no longer exists.
Abstract: Traditional techniques for Programming in the Large, especially Object- Oriented approaches, have been used for a considerable time and with great success in the implementation of service-based information systems. However, the systems for which these techniques have been used are static, in that the services and the data available to users are fixed by the system, with a strict separation between system and user. Our interest lies in currently emerging dynamic systems, where both the data and the services available to users are freely extensible by the users and the strict distinction between system and user no longer exists. We describe why traditional object-oriented approaches are not suitable for modelling such dynamic systems. We discuss a new architectural model, the Information Unit Hypermedia Model, IUHM, which we have designed for modelling and implementing such dynamic systems. IUHM is based upon the application of structural computing to a hypermedia-like structure, which thereby operates as a service-based architecture. We discuss the details of this model, and illustrate its features by describing some aspects of a large-scale system, built using this architecture.

Summary (7 min read)

1 Introduction

  • An important current trend in system design and development is the consideration of dynamic systems, particularly dynamic service-based systems.
  • The authors present a new architectural model for modelling and implementing such systems.
  • This linked network may be viewed as a hypermedia structure, with manipulations taking the form of the application of structural computing to this hypermedia structure, which thereby operates as a service-based architecture.
  • OPALES provides a portal to a set of diverse open digital library services, and is designed for the cooperative manipulation of shared multimedia documents among multiple users and user-groups.
  • In section 2 the authors further describe the general context of their work, and they discuss the design rationale for the architecture to be described.

2 General Context

  • In this section the authors consider the general context on which their work is based.
  • In particular the authors discuss the essential differences between what they term static and dynamic systems, for it is these differences which provide the motivation for the architectural design which they will discuss in later sections.

2.1 Static Systems -- Description

  • By the term static system the authors refer to a system in which there is a fixed number of predefined services available to users of the system, that is the set of allowable user operations and the available data (and data types) are both pre-determined.
  • In such a system, there is a clear distinction between the system developers, and the system users.
  • Users are permitted to access particular services which access and/or modify data in well-defined ways.
  • The use of such systems is widespread, and such systems include banking systems, travel reservation systems, university on-line registration systems, and so forth.
  • Generally speaking, making such new services available to other general users takes the form of a new upwardscompatible system release.

2.2 Static Systems -- Implementation

  • Such static systems lend themselves well to traditional programming in the large implementation approaches [5].
  • In particular, the services provided in such a system are fixed, and are usually classified into a number of distinct categories.
  • Within each category, the available services are to a large extent hierarchical in nature, and thus the traditional object-oriented approach is an appropriate one.

2.3 Dynamic Systems -- Description

  • Moreover, end-users may also restructure the system architecture to tailor the system to their own needs, and may create new services as compositions of existing services; such user level adaptation may imply quite deep component restructuring.
  • Indeed, user operations of this sort are the intent of a dynamic system.
  • Such large-scale changes imply that provision for automatic reorganization of computing within the system is one of the primary requirements of the system architecture.
  • The authors take their illustrations from the OPALES digital video library system.
  • The authors give a more detailed description of how their model handles such systems in a later section.

2.3.1 Developer-based extension

  • OPALES provides several tools for indexing and retrieving data, including queries based on descriptors, on keywords, on text similarity, or conceptual graphs and so on.
  • Let us suppose the authors also want to support the Conceptual Vectors [13] querying technique.
  • The data type and its associated set of tools are first implemented in the small in Java, say, in an IUHM [21] compliant manner.
  • Any existing service concerned with indexing tools or data has automatic access to the new components.
  • Similarly, annotating and indexing tools will gain access to the associated new editor.

2.3.2 End-user based structuring

  • OPALES provides private and sharable workspaces to its users.
  • The user may define work-rules within the workspace and restrict the data created by users of this group to be handled only by a set of specific tools, according to specific rules.
  • Such a restriction is achieved by simply specifying the appropriate relationships between the data-type defining the interest group in question and the other items of the system.
  • Any service in the system then automatically, configures accordingly, thus providing for the extensions, restriction and reconfigurations appropriate to this user group.
  • These examples taken from the OPALES system are by no means exclusive, and are cited to illustrate the types of user service which might be found in a dynamic system and which their architecture is designed to support.

2.4 Dynamic Systems -- Implementation

  • The evolutionary nature of service and data creation within such a dynamic system means that a traditional object-oriented approach will not be sufficient, for a number of reasons.
  • Indeed, users may create quite diverse services, so that the very concept of "the system as a whole" as a discernible item is lacking.
  • Further, the creation of new services must be implemented in an evolutionary manner, without the need to modify the remainder of the system, or the need to resort to discrete versioning.
  • In the following sections the authors discuss an architectural model designed to implement such dynamic systems, and therefore to meet the various points just listed.

3 The Information Unit Hypermedia Model

  • The Information Unit Hypermedia Model, IUHM, is fully described in [21], and here the authors briefly review the model to the extent needed for the purposes of this paper.
  • The authors observe that in IUHM, system construction corresponds to the specification of a network, and that the primary idea of IUHM is to provide a graph-based description of relationships between Information Units which encapsulate any entity (data, metadata, services), so that structural computing techniques can be applied.
  • The type-based hypermedia structure the authors have chosen for IUHM induces a generalized typing mechanism on objects which is far richer than the classical class inheritance graph of object-oriented classes.
  • As the authors discuss in the following paragraph, the originality of the IUHM Model is that each tool may set its own type matching rules, enabling a late binding which relies on the structure of the actual IU graph.

3.1 Design Rationale

  • Notions such as classes, polymorphism, inheritance and so on have proven their efficacy in object-oriented programming.
  • Programming in the large with dynamic binding of services and data, and composition of services requires a distinct paradigm which is suited to the specification of the rules which apply when data are assigned to services and the specification of how services cooperate.
  • This section informally introduces the fundamental notions on which IUHM is based; these notions are developed in detail in the next paragraphs.
  • The authors introduce two new notions: surroundings and affinity.
  • The surroundings of an item characterizes the relationships between that item and the others in the system.

3.2 Information Units

  • IUHM has its origins in a hypertext model and is the result of a long evolution and enrichment of their work on typed links hypertext systems [19].
  • IUHM introduces the notion of role and makes an explicit distinction between the notion of role and the notion of type.
  • Fig. 1 illustrates how typed links are used to specify the surroundings of an information unit.
  • An IU may have several roles, thus enabling organizations based upon the semantic level to be set.
  • The authors point out, however, that the link mechanism may be used to derive notions found in other programming paradigms, particularly object-oriented paradigms.

4 Architecting a Service-Based System with IUHM

  • The authors discuss how a dynamic service-based system may be modelled and implemented using the IUHM approach.
  • It is important to realise that the complete specification of the behaviour of a system is not simply the content of IU nodes (code and data) but also includes the hypertext network induced by the links which depict relationships between IUs.
  • Specifically, in OPALES surroundings are used to represent the fact that certain data is within the concern of some workgroup, and has been validated by the group moderator.
  • The IUHM functional core provides the primary mechanisms required in order to run an application described by an IUHM network4.
  • This section discusses in greater detail the notions of type, role, surroundings and affinities of IUs and describes the dynamic management of these items in the IUHM core.

4.1 Reflexivity in Type and Role Descriptions

  • Reflexivity implies all IUs throughout the system have links to a type IU and a role IU.
  • This type-role network is terminated by a set of primitive types and roles, which are directly implemented in the system core.
  • Primitive types and roles are nonetheless represented in the hypertext network, making use of the predefined node called predefined (see Fig. 1).
  • This approach ensures that the graph description is consistent with respect to link types: there is no dangling links, rather links pointing to the undefined node and there are no missing links, rather links to the empty node.
  • This reflexive technique is both quite simple and powerful, and enables replacement and substitution of system components to be implemented by link replacement.

4.2 Why Types, Roles and Affinities?

  • The distinction between types and roles places emphasis on two distinct and separate aspects of the manipulation of items within the system.
  • The type manages the technical, implementation aspects; the role determines what user-level semantics are attached to the item.
  • Further, the IU which contains information about Mrs Smith, say the group moderator, may point to the owner of this set of work rules, and so on (see Fig. 2).
  • Furthermore, the services which can operate on a given data in a large scale dynamic system are not selected simply on the basis of the data type, which provides information at too low a level, but rather according to the surroundings of the object, which provides the appropriate semantic level.
  • The annotation service provides the user with a general interface which operates on any annotation (the authors say that is belongs to the annotation role) regardless of the actual type of the annotation.

4.3 IUHM and reuse

  • The separation of type and role makes possible easier reuse of parts of the system components, since aspects represented by low level types and by higher level roles are clearly separated.
  • Naturally, both type and role can be hierarchically organized with a inherit link.
  • It should be noted that low level system code supporting interoperability of types and roles must be provided, IUHM does not provide any syntactic means for interoperability checking, whereas it can easily support dynamic (run time) checking.
  • It may be observed that data of different types may share the same role(s) without any need to adapt the role implementation.
  • Conversely, new roles can be added by taking advantage of the type-level code, provided two conditions are satisfied: a role is constructed using the interface provided by the type, the contents of the interface are unchanged when the new type is introduced.

4.4 Affinities and Dynamic Aspects

  • IUMH manages sets of services, that is applications which cooperate and which interact with users in a given context.
  • The authors have not mentioned the type of af simply because the type of af contains the code which is capable of handling the low level description of the affinities of s, whereas the role affinity enforces the high-level methods provided by this role to comply with the affinity semantics predefined in the system.
  • The IUHM functional core registers services and handles the set of affinities of the registered services to dispatch IUs to the appropriate services.
  • If a service responds true to Share, other services whose affinity matches the IU can share the data.
  • Alternatively, one may override the default and define a private strategy for loading services by providing a link to a specific code for this type.

4.5 Affinities and Generic Service Structure

  • Because of the reflexive nature of IUHM, there is no difference between data and service, both are IUs.
  • Selects that which has affinities with the data to de handled.
  • The example described in section 2.3 works in this manner.
  • To add the Conceptual vectors search engine into Opales, one just needs to place a role link between this search engine and the role search engine.
  • Furthermore, when a compound query contains an IU whose type is Conceptual vectors, the generic querying mechanism would simply asks for a search engine to open this UI and would receive the Conceptual vectors search engine as the target of the core call.

5.1 Object-Oriented Development versus Structural Computing

  • The main idea introduced in this paper is that it is possible to represent an application architecture explicitly by a computing structure compliant with the IUHM model.
  • Thus the various elements which are responsible for the assignment of an IU to a service are extremely dynamic; the service loader is responsible for the set of active services in a given context, the affinities are responsible for matching data to services, the surroundings are representative of the general over structure of the system.
  • Adaptive Object Models provide a way to free the designer from the obligation of creating dozens of classes when it is not necessary.
  • An AOM is basically an instance-based model in which some instances play the role of classes (similar to types in IUHM) and others play the role of base objects.
  • Finally, in [28], [29] it is described how to use roles to describe and design composite patterns and object-oriented application framework.

5.2 Openness and Service-Based Architecture

  • From the considerable literature on the subject, it is clear that the construction of open systems has been a topic of great interest for some time.
  • Jini network technology [9] is an open software architecture that enables developers to create network-centric services -- whether implemented in hardware or software -- that are highly adaptive to change.
  • The growing movement around web services, the new step in the evolution of the World Wide Web infrastructure, aims at allowing programmable elements to be placed on Web sites where others can access distributed behaviors through published description of services (WSDL) [33].
  • These descriptions do not appear sufficient to elaborate strategic development for business applications.
  • But from a design point of view, one can observe that there has been an evolution from designing application by decomposition [5], [31], [1], to designing application by composition [3], [25], or by flow description [14].

5.3 Open Hypermedia Architecture and Structural Computing

  • These computing fields are very representative of growing efforts in a particular domain, hypermedia, to use generic architecture [35] in order to separate the concerns of application modelling and underlying techniques used to manipulate the hypermedia structures of the application [27].
  • As the authors described in [21], they feel that an approach which adopts distinct models for describing hypermedia structures on the one hand and services on the other are not relevant.
  • The use of such an approach in their view complicates the management of openness and interoperability while maintaining homogeneous semantics [18].

5.4 Scalability, Interoperability, Reflexivity, Flexibility, Adaptation

  • A primary requirement of architecture capable of describing a dynamically evolving system is that the architecture should embody a simple resolution of the problems of interoperability between modules.
  • A number of approaches to interoperability are to be found in the literature, including object-oriented approaches [22], 15], [16], layered approaches [17], and aspect oriented programming [11], [6].
  • While their approach has elements in common with several of these, the authors have not found any of these existing approaches entirely adequate for their needs.
  • These various approaches appear to be more concerned with applying these notions to implementation, whereas their perspective embodied in IUHM is that an IUHM compliant structure makes it possible to both model and support execution of the application.
  • The authors observe that IUHM is fully reflexive, thus facilitating adaptation and offering flexibility.

6 Conclusion

  • The IUHM technology is the consequence of a three-year maturation of the Opales project, in which the authors had to cope with the continuous evolution and enrichment of the system, and its adaptation to the evolution of user needs.
  • The authors long experience in hypermedia systems suggested to us that the authors should take advantage of typed-links hypertext structure and of structural programming to support the specification, the development, and the evolution of the system in a unified manner.
  • And have extracted the key elements which may be utilized to depict and organize large-scale service based applications in a generic manner.the authors.
  • IUHM sets a paradigm both for the description and for the dynamic behaviour of the system.
  • Even the service affinity determination code or the service loader code themselves are handled as services and thereby can be overridden at will, as by editing links in the IUHM description.

Did you find this useful? Give us your feedback

Content maybe subject to copyright    Report

HAL Id: lirmm-00269457
https://hal-lirmm.ccsd.cnrs.fr/lirmm-00269457
Submitted on 3 Apr 2008
HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entic research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.
L’archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diusion de documents
scientiques de niveau recherche, publiés ou non,
émanant des établissements d’enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.
A Structural Computing Model for Dynamic
Service-Based Systems
Peter R. King, Marc Nanard, Jocelyne Nanard, Gustavo Rossi
To cite this version:
Peter R. King, Marc Nanard, Jocelyne Nanard, Gustavo Rossi. A Structural Computing Model for
Dynamic Service-Based Systems. MIS’03, Sep 2004, Graz, Austria. pp.100-118, �10.1007/978-3-540-
24647-3_9�. �lirmm-00269457�

A Structural Computing Model for
Dynamic Service-Based Systems
Peter King
1
, Marc Nanard
2
, Jocelyne Nanard
2
, and Gustavo Rossi
3
1
Department of Computer Science; University of Manitoba,
Winnipeg; MB; R3T 2N2 Canada
prking@cs.Umanitoba.ca
2
LIRMM, CNRS/Univ. Montpellier, 161 rue Ada,
34392 Montpellier cedex 5, France
{mnanard,jnanard}@lirmm.fr
3
LIFIA, Fac. Cs. Exactas- Universidad Nacional de La Plata,
(1900) La Plata, Buenos Aires, Argentina
gustavo@sol.info.unlp.edu.ar
Abstract. Traditional techniques for Programming in the Large, especially
Object-Oriented approaches, have been used for a considerable time and with
great success in the implementation of service-based information systems.
However, the systems for which these techniques have been used are static, in
that the user-services and the data available to users are fixed by the system,
with a strict separation between system and user. Our interest lies in currently
emerging dynamic systems, where both the data and the services available to
users are freely extensible by the users and the strict distinction between system
and user no longer exists. We describe why traditional object-oriented
approaches are not suitable for modelling such dynamic systems. We discuss a
new architectural model, the Information Unit Hypermedia Model, IUHM,
which we have designed for modelling and implementing such dynamic
systems. IUHM is based upon the application of structural computing to a
hypermedia structure, which thereby operates as a service-based architecture.
We discuss the details of this model, and illustrate its features by describing
some aspects of a large-scale system which was built by using this architecture.
1 Introduction
An important current trend in system design and development is the consideration of
dynamic systems, particularly dynamic service-based systems. In this paper, we
present a new architectural model for modelling and implementing such systems.
Specifically, we are interested in dynamic systems where users of the system are free
to create new data and new data types together with new services for the interrogation
and manipulation of such data. Furthermore, the addition of new types and services
must not require any explicit changes, upgrades or reorganization in existing parts of

the system; indeed existing types and services should be able to make automatic use of
such additional components
1
.
Indeed, the existence of these two forms of user extension, new data and new
services, serves to characterize the class of system of interest to us. The dynamic
nature of both data and functionality within such a system has very considerable effect
on the viability of implementation approaches. Whereas traditional techniques for
programming in the large, particularly object-oriented approaches, provide substantial
support for low- and medium-scale programming, these approaches do not lend
themselves as readily to a number of the specific issues arising in such large-scale
dynamic systems. The work we describe herein shows how structural computing [23]
techniques, based on graphical description of relationships between system
components, are particularly applicable to the management of large-scale extensibility
and tailorability. These techniques provide a means to describe formally the structure
of the system and to depict properties of items within the system. Moreover, properties
similar to those that have proved useful in object-oriented approaches, such as
inheritance, polymorphism, and delegation, are readily described by these structural
techniques. Thus, our overall approach to implementing such dynamic systems is a
joint one, in which we use traditional object-oriented programming for programming
the individual system components "in the small", and use the structural programming
based approach to be described in this article to provide an implementation model for
the other aspects of a dynamic system.
The systems which we are considering in this article are not auto-adaptive, but
depend exclusively on user interactions for their extensibility. The systems we have in
mind are large and may involve many users.
The architectural model which we describe in this paper is a unified, reflexive one,
in which all entities (data, metadata, service, ontology, etc.) are represented in a
uniform fashion; each entity is encapsulated as an Information Unit (IU), and
relationships between entities are denoted by an explicit graph structure, built as a
linked network of IUs. This linked network may be viewed as a hypermedia structure,
with manipulations taking the form of the application of structural computing to this
hypermedia structure, which thereby operates as a service-based architecture. This
approach enables us to apply well-known meta-level programming techniques in order
to reason on the system structure (the meta-level), just as we reason on the system data
(the base level). Furthermore, the IU maintains a distinction between structure and
semantics in the manipulation of an entity. As we explain in what follows, each IU
contains a number of links (pointers to other IUs) and in particular, an IU has a type
link and a role link, which are both dynamic and which correspond, respectively, to
the structure and the semantics of the entity represented in the information unit in
question.
The infrastructure discussed in this paper describes, naturally, a conceptual rather
than a physical architecture, that is to say the infrastructure says nothing about the
physical locations of the actual software elements. Nevertheless, the approach has
been used in practice, in the implementation of the OPALES system, designed and
implemented for INA, (the National Institute for Audiovisual Archives in Paris).
1 We use the term tailorability to describe this aspect of the system.

Opales services implementation contains some 80,000 lines of Java code, and the
same amount of C++ code [4], [20]. OPALES provides a portal to a set of diverse
open digital library services, and is designed for the cooperative manipulation of
shared multimedia documents among multiple users and user-groups. In particular,
such documents may be enriched by multiple annotation and indexation structures
through private and public workspaces. The techniques we describe are intended for
dynamic systems such as OPALES; however, they also work well where there is a
limited degree of extensibility where, for example, new upwards compatible,
functionality may be added in a system-controlled fashion.
The remainder of this paper is organized as follows. In section 2 we further
describe the general context of our work, and we discuss the design rationale for the
architecture to be described. Section 3 briefly describes the Information Unit
Hypermedia Model, our infrastructure for modelling dynamic systems. Subsequent
sections go into further detail of how this infrastructure meets the requirements
described in section 2. Thus section 4 discusses how the IUHM model may be used
for modelling and implementing a dynamic system, We introduce and describe in
detail the concepts of role and type, and discuss how these concepts lead to a simple
resolution of the question of interoperability between system modules. Section 4 also
discusses the notion of reflexivity, and describes in detail the information unit which is
at the core of our infrastructure. Section 4 also explains the dynamic mechanism used
to run the pattern matching in the implementation of our model. In section 5, we
briefly discuss a number of important aspects of related work, and section 6
concludes.
2 General Context
In this section we consider the general context on which our work is based. In
particular we discuss the essential differences between what we term static and
dynamic systems, for it is these differences which provide the motivation for the
architectural design which we will discuss in later sections.
2.1 Static Systems -- Description
By the term static system we refer to a system in which there is a fixed number of pre-
defined services available to users of the system, that is the set of allowable user
operations and the available data (and data types) are both pre-determined. In such a
system, there is a clear distinction between the system developers, and the system
users. Users are permitted to access particular services which access and/or modify
data in well-defined ways. The use of such systems is widespread, and such systems
include banking systems, travel reservation systems, university on-line registration
systems, and so forth. In such systems data security is of primary importance, and in
addition, therefore, to careful user authentication, such systems expressly exclude any

facility whereby a general user could create a new service, since such a service could
access data in a non-authorized fashion.
It should be noted that the distinction between user and developer is more usually a
distinction between classes or levels of user: thus one may in particular have a class of
super-user, who have responsibility for system maintenance, including updating
existing services and the creation of new services. Generally speaking, making such
new services available to other general users takes the form of a new upwards-
compatible system release.
2.2 Static Systems -- Implementation
Such static systems lend themselves well to traditional programming in the large
implementation approaches [5]. In particular, the services provided in such a system
are fixed, and are usually classified into a number of distinct categories. Within each
category, the available services are to a large extent hierarchical in nature, and thus the
traditional object-oriented approach is an appropriate one.
2.3 Dynamic Systems -- Description
By way of contrast, a dynamic service-based system is one in which developers are
free to add new classes of data and new services to access such data at any time, such
as in [9], without the need to suspend, to reorganize or to re-release an entire system.
Moreover, end-users may also restructure the system architecture to tailor the system
to their own needs, and may create new services as compositions of existing services;
such user level adaptation may imply quite deep component restructuring. Indeed, user
operations of this sort are the intent of a dynamic system. Such large-scale changes
imply that provision for automatic reorganization of computing within the system is
one of the primary requirements of the system architecture.
Dynamic systems are less common, and thus we provide some examples of user
activity by describing some typical user-induced system extensions. We take our
illustrations from the OPALES digital video library system. We give a more detailed
description of how our model handles such systems in a later section.
2.3.1 Developer-based extension
OPALES provides several tools for indexing and retrieving data, including queries
based on descriptors, on keywords, on text similarity, or conceptual graphs and so on.
Let us suppose we also want to support the Conceptual Vectors [13] querying
technique. The data type and its associated set of tools are first implemented in the
small in Java, say, in an IUHM [21] compliant manner. This new type of data and
tools are then added into OPALES simply by setting, in a formal manner, the
relationships between this new data-type and existing types by means of links between
IUs. In this manner, any existing service concerned with indexing tools or data has

Citations
More filters
Proceedings ArticleDOI
09 Nov 2005
TL;DR: DYVA is presented, a unified framework, that has been designed to be suitable to dynamic deployment and reconfiguration for most of the currently component technologies and is based on a model-driven approach.
Abstract: Permanent and uninterrupted functioning can be sometimes a requirement for some kinds of software systems. This is especially true in the case of complex and distributed systems where stopping and restarting the system constitute a tedious and costly task, also when the system must be highly available or when its execution environment changes frequently. Many component technologies exist today and solve hot (dynamic) deployment and reconfiguration issues offering ad-hoc solutions. This paper presents DYVA, a unified framework, that has been designed to be suitable to dynamic deployment and reconfiguration for most of the currently component technologies. Components from these technologies have to satisfy common features like en-capsulation, interfaces, etc...). The proposed framework is based on a model-driven approach. This approach helps in developing specific hot deployment and reconfiguration systems by the personalization of the unified framework. The personalization is done via plug-ins which make transformation between specific component descriptions and more general ones.

17 citations

Journal Article
TL;DR: Roles in the modeling and design armory of existing Web engineering methods are introduced and it is shown how it improves their expressive power and help to solve design problems that appear frequently in Web applications.
Abstract: Although role modeling is a topic that has been treated over years in the object-oriented community, its use in the life cycle of Web Engineering, and particularly in object-oriented Web design methods, has been seldom discussed and used yet. In this paper, we introduce roles in the modeling and design armory of existing Web engineering methods and show how it improves their expressive power and help to solve design problems that appear frequently in Web applications. We first survey the state of the art of Web engineering modeling approaches. A simple example is used to point out some situations in classic Web engineering modeling where it is not possible to express that objects or nodes should change their properties (attributes or behaviors) according to the collaborating subject (the objects which send them messages or the nodes which are linked to them). Next, we introduce the object-oriented role concept and discuss how it has been used so far in the software engineering community and how it can be useful for Web engineering modeling. Existing methods (like UWE and OOHDM) are used as an example to show how to introduce roles during the Web engineering process. We compare our approach with others and conclude with some further research we are pursuing.

9 citations

Proceedings ArticleDOI
Jessica Rubart1
09 Nov 2005
TL;DR: This paper proposes security contexts and affinities for handling context-based access control for shared resources in a flexible way and identifies components that can benefit very much from hypermedia models in terms of flexibility and extensibility.
Abstract: Various use cases require flexible and dynamic access control management. This paper proposes security contexts and affinities for handling context-based access control for shared resources in a flexible way. It identifies components that can benefit very much from hypermedia models in terms of flexibility and extensibility. In addition, behavior components being able to interpret specific kinds of structures are suggested. This enables access control models that can be dynamically adapted and extended.

7 citations


Cites background or methods from "A Structural Computing Model for Dy..."

  • ...Affinities can be described in terms of hypermedia graph pattern matching [5]....

    [...]

  • ...IUHM, A Hypermedia-Based Model for Integrating Open Services, Data and Metadata....

    [...]

  • ...The Information Unit Hypermedia Model (IUHM) [5, 8] sup­ports system modeling and in addition to types it makes explicit roles for information units (IUs)....

    [...]

  • ...To handle such rights dynamically, they can be derived from bindings, e.g. ob ject component bindings of groupware components [16] or IUHM service a.nities [5]....

    [...]

  • ...object component bindings of groupware components [16] or IUHM service affinities [5]....

    [...]

Book ChapterDOI
15 Sep 2004
TL;DR: In this article, a conceptual architecture for a structural computing environment is presented to serve as a point of reference (framework) for discussing important issues facing the structural computing research community, and an agenda for structural computing is presented.
Abstract: Structure plays an important role in knowledge work. The overall goal of structural computing research is to provide effective support for knowledge workers. Structural computing research has reached a level of maturity, where it is relevant and essential to define and discuss common research directions. This paper presents an agenda for structural computing research. A conceptual architecture for a structural computing environment is presented to serve as a point of reference (framework) for discussing important issues facing the structural computing research community.

5 citations

Journal Article
TL;DR: In this article, a conceptual architecture for a structural computing environment is presented to serve as a point of reference (framework) for discussing important issues facing the structural computing research community, and an agenda for structural computing is presented.
Abstract: Structure plays an important role in knowledge work. The overall goal of structural computing research is to provide effective support for knowledge workers. Structural computing research has reached a level of maturity, where it is relevant and essential to define and discuss common research directions. This paper presents an agenda for structural computing research. A conceptual architecture for a structural computing environment is presented to serve as a point of reference (framework) for discussing important issues facing the structural computing research community.

5 citations

References
More filters
Book
01 Jan 1994
TL;DR: The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns, which most experienced OOP designers will find out they've known about patterns all along.
Abstract: The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns. The nice thing is, most experienced OOP designers will find out they've known about patterns all along. It's just that they've never considered them as such, or tried to centralize the idea behind a given pattern so that it will be easily reusable.

22,762 citations


"A Structural Computing Model for Dy..." refers background or methods in this paper

  • ...AOMs use the Type Object pattern [10] and the Strategy pattern [7] to provide a way to add behaviors dynamically....

    [...]

  • ...The Role Object pattern use decorators [7] to “extend” a base class with roles....

    [...]

Journal ArticleDOI
Gregor Kiczales1
TL;DR: This work proposes to use aspect-orientation to automate the calculation of statistics for database optimization and shows how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries.
Abstract: The performance of relational database applications often suffers. The reason is that query optimizers require accurate statistics about data in the database in order to provide optimal query execution plans. Unfortunately, the computation of these statistics must be initiated explicitly (e.g., within application code), and computing statistics takes some time. Moreover, it is not easy to decide when to update statistics of what tables in an application. A well-engineered solution requires adding source code usually in many places of an application. The issue of updating the statistics for database optimization is a crosscutting concern. Thus we propose to use aspect-orientation to automate the calculation. We show how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries. Due to the automatic nature, computation takes place on time for complex queries, only when necessary, and only for stale tables. The implementation language for the automated aspect-oriented statistics update concern is AspectJ, a well known and mature aspect-oriented programming language. The approach can however be implemented in any other aspect-oriented language. Unlike in traditional object-oriented pattern solutions, e.g. using the interceptor pattern, we do not have to modify existing code.

5,161 citations

Book ChapterDOI
14 Jun 1999
TL;DR: An analysis of why certain design decisions have been so difficult to clearly capture in actual code is presented, and the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects.
Abstract: We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in “tangled” code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they cross-cut the system's basic functionality. We present the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming.

3,355 citations

Proceedings ArticleDOI
01 Sep 2001
TL;DR: This tutorial shows how to use AOP to implement crosscutting conerns in a concise modular way and includes a description of their underlying model, in terms of which a wide range of AOP languages can be understood.
Abstract: Aspect-oriented programming (AOP) is a technique for improving separation of concerns in software design and implementation. AOP works by providing explicit mechanisms for capturing the structure of crosscutting concerns. This tutorial shows how to use AOP to implement crosscutting conerns in a concise modular way. It works with AspectJ, a seamless aspect-oriented extension to the Java(tm) programming language, and with AspectC, an aspect-oriented extension to C in the style of AspectJ. It also includes a description of their underlying model, in terms of which a wide range of AOP languages can be understood.

3,187 citations

Journal ArticleDOI
TL;DR: The Dexter hypertext reference model as mentioned in this paper is an attempt to capture, both formally and informally, the important abstractions found in a wide range of existing and future hypertext systems, providing a principled basis for comparing systems as well as for developing interchange and interoperability standards.
Abstract: This paper presents the Dexter hypertext reference model. The Dexter model is an attempt to capture, both formally and informally, the important abstractions found in a wide range of existing and future hypertext systems. The goal of the model is to provide a principled basis for comparing systems as well as for developing interchange and interoperability standards. The model is divided into three layers. The storage layer describes the network of nodes and links that is the essence of hypertext. The runtime layer describes mechanisms supporting the user’s interaction with the hypertext. The within-component layer covers the content and structures within hypertext nodes. The focus of the model is on the storage layer as well as on the mechanisms of anchoring and presentation specification that form the interfaces between the storage layer and the within-component and runtime layers, respectively. The model is formalized in the specification language Z, a specification language based on set theory. The paper briefly discusses the issues involved in comparing the characteristics of existing systems against the model.

1,075 citations

Frequently Asked Questions (1)
Q1. What contributions have the authors mentioned in the paper "A structural computing model for dynamic service-based systems" ?

The authors describe why traditional object-oriented approaches are not suitable for modelling such dynamic systems. The authors discuss a new architectural model, the Information Unit Hypermedia Model, IUHM, which they have designed for modelling and implementing such dynamic systems. The authors discuss the details of this model, and illustrate its features by describing some aspects of a large-scale system which was built by using this architecture.