Because of the large amount of information managed by Web-based Information Systems (WIS), their users often experience some disorientation and cognitive overload syndromes. In order to attenuate this negative effect, we introduce the concept of Progressive Access which aims at giving WIS users a flexible and personalized access to data. First, information considered as essen-tial regarding the user’s needs is provided, and then, additional information, if needed, becomes gradually available. Progressive access requires to stratify the information space. These stratifications are described through a central model called the Progressive Access Model (PAM). We present here the PAM and its connections to four other models (data model, functional model, hypermedia model, user model).We show how these five models are linked and exploited during the design of the WIS. Instantiating these models leads to the generation of WIS which integrate the progressive access approach.
Attribute grammars have been developed by Knuth [9] for the specification and implementation of static semantic aspects of programming languages. Since then, they have matured into a recognized field of study with many applications [17]. In this paper, we propose a system for transformation of information system models based on this formalism. First, the problem will be defined followed by the necessity for model transformation. Next, some model transformations approaches are presented, with special attention to XSLT. This brief survey gives the characteristics of the problem of model transformation and situates our approach. The semantics offered by attribute grammars brings the rigor of formal semantics while providing good performance at the implementation by a specific software called an evaluator. Thus, our system architecture consists essentially in defining a textual abstract syntax of the source meta-models and in building an attribute grammar to express the transformation. The input of the automatically generated evaluator is some text describing the source model, the syntax of which is defined by an abstract syntax. The output of the evaluator is another text corresponding to the target model in accordance with its grammar. In the last section, the characteristics and the benefits of our approach are discussed.
This paper presents DSL-DIA, an environment that lets a system-family vendor define a metamodel for a custom domain-specific language used by customers for specifying properties of family members. Once the metamodel is imported in the environment, the environment allows the customer a flexible way to program in the domain-specific language and translates obtained programs to implementations of family members. In our case, family members are always database-intensive applications with application logic executed in the database server.
Eliciting change requirements in the context of system evolution is different from eliciting requirements for a system developed from scratch. Indeed, there is a system and documentation that should be referred to. Therefore, the issue is not only to identify new functions, but to uncover and understand differences with the current situation. There is few approaches that systematise the identification and documentation of such change requirements. Our approach is based on the analysis at the model level of the fitness relationship between the business and the system. Our experience showed us that another kind of change requirements could also be found when asking the question of continuity at the instance level. The literature already proposes so called “modification policies" that allow to manage current instances of the system workflows and business processes when their model evolve. However, these approaches are not interested in the elicitation of the requirements that relate to these modification policies, but to the technical solutions that these policies provide. The position taken in this paper is that change requirements can be elicited by analysing system evolutions through modification policies at the instance level. The paper proposes to document these requirements using the same approach as other change requirements.
In this paper, we propose a methodology for managing database evolutions by exploiting two ontologies. The first ontology describes the changes occurring in a database application. The second one aims at characterizing techniques and tools useful for database change management. We propose an algorithm performing ontologies matching and its application to identify appropriate techniques and tools for a given database change.
We propose the concept of “atomic use case” and demonstrate how this concept can be used to bring the analysis of functional requirements of information systems to a much deeper level than usual, and ultimately to construct a precise specification of the system’s functionality. Specifically, the complete functionality of an information system is defined by a set of atomic use cases, which are consistently specified in terms of their input, output, pre- and postcondition. We also show that the usefulness of the atomic use case concept goes beyond analysis. With this concept, a characterization of the business logic layer can be clearly formulated, and this layer can be systematically extended to effectively support the construction of graphical user interface.
User Interfaces (UI) are an essential part of most softwares, especially data intensive ones as database or Web based applications. Most of the approaches dealing with UI focus on design and implementation aspects and are driven by a specific technology. We believe UI specification has already to be taken into account through the analysis phase, because it is closely related to the application Business Domain (BD), which is apprehended in the earliest steps of the Analysis and Design Process (A&D-Pr). Moreover, during the analysis phase, the UI is described in a more abstract way and a larger variety of UI can be taken into consideration.The UI and the BD aspects of the application have to be studied in a closely-related way. But most of the existing approaches propose a specific notation for the UI, different from the one used to define the BD. And when guidelines are associated with the notation, they focus on the UI and are poorly related to the BD. We propose an integrated approach (i) using a single notation in order to facilitate and support the integration of BD and UI aspects modeling and (ii) proposing an application model distinguishing the UI and BD aspects via separate views and clearly setting relationships between them. We choose the UML notation to illustrate our work in order to facilitate. its use in any standard A&D-Pr. Our approach also includes a methodology to explain how to create the application model. Its aim is not only to model the UI from a pure technical point of view, but from a business one; providing guidelines for error management, or business rules support for instance. In this paper, we present our UML profile for UI and show how we could take advantage of it through the different phases of the AD-Pr.
This paper builds on previous work showing a way to map the concepts used in object-oriented business domain modelling onto (a subset of) the concepts used by the COSMIC Full Function Points (COSMIC-FFP) functional size measurement method for modelling and sizing a software system from the point of view of its functional user requirements. In this paper we present a refined set of measurement rules resulting from a careful revision of our previous proposal, based on ‘field trials’ and feedback from function points experts. The main contribution of the paper is, however, an extended set of rules to be used when applying COSMIC-FFP to multi-layer conceptual models, including at least an enterprise layer and, on top of this, an information system services layer.
Implementation architectures of today are based on the modularisation of software into objects, components, web services, (intelligent) agents, ... with communication and coordination between components being based on peer-to-peer communication (a client-component requests a service from a server-component). Because this binary and uni-directional form of communication implies substantial restrictions on software maintainability, this paper proposes the development of a new N-ary and multi-directional communication paradigm based on the notion of “event": components will interact by jointly participating in events. This new communication paradigm uses event broadcasting as a coordination mechanism between software components. It can be implemented by means of generic binary interaction frameworks applicable across diverse platforms (distributed, web-based and centralised systems) and implementation paradigms (synchronous and asynchronous communication). In addition, events can be enriched with intelligent features so as to be able to act autonomously and to be capable of undertaking some rescue actions when one of the composing actions fails.
The deployment of information systems can turn into a baffling problem when components which compose those systems exhibit non-functional requirements. If the platform on which such components are deployed cannot satisfy their non-functional requirements, then they may in turn fail to perform satisfactorily. In this paper we focus on a specific category of non-functional requirements: those that pertain to the resources software components need to use at runtime. This paper reports the design of the resource-oriented contract model implemented in the Jamus platform. These contracts allow software components to negotiate with the Jamus platform for the resources they need.
Most of existing software are nowadays characterized as complex information systems. For their crucial phase of specification/validation, the present paper proposes to perceive information systems as fully distributed, autonomous yet cooperating evolving concurrent components. The formal specification/validation framework for this advanced perception is an adequate integration of object concepts with modularity features into an appropriately tailored variant of algebraic Petri nets. For a true (intra- and inter-object) concurrent exhibition and symbolic computation, this integration referred to as CO-NETS is semantically interpreted using an adaptation of rewriting logic.More precisely, we first propose a clear incremental methodology for constructing complex information systems starting from their informal UML-based diagrammatic description and leading to interacting Co-NETS components. As a second-level of reusability we then gradually endow each component with a Petri-net based meta-level for coping with runtime behavioural changes in each component. This leads not only to keep component specifications always updated and running but also to reconfigure the architecture of the system in a runtime way. All these issues are illustrated using a simplified banking system case study.
In an age in which some practitioners actually believe that the existence of ANGLE BRACKETS portends the solution to centuries-old philosophical problems in semantic representation, it is increasingly difficult to explain that systems evolve both from within (due to changes in requirements, growth, mergers & acquisitions, etc.) and without (new staff, new technologies, the ever-present “next best thing”). But evolve they do. Most “OO” vendors used to be “AI” vendors, and soon they’ll be “Model Driven” vendors. Consolidation in the modeling market this year will see to that. Because of the cost of evolution, software is expensive to build, and more expensive to maintain and integrate; worse, the moment it’s created it’s a legacy that must be integrated with everything else that comes afterward. Getting past this problem once and for all will require some way to move up a level to designs that allow implementation on many platforms, as implementation infrastructure changes. Modeling is an obvious way to move to a meta-design level, but nearly all modeling methods have focused primarily on the requirements analysis and software design stages of development-the tip of the iceberg. Model Driven Architecture (MDA) extends models to system implementation, long-term maintenance and most importantly integration of applications. In this session Dr. Soley will explain what the Model Driven Architecture Initiative is about, what the first products & deployments look like, and how the market will evolve.
Problems relating to modularity result in the under-performance of the object-oriented software development paradigm in a number of areas. Aspect-oriented software development (AOSD) is a relatively new technology that extends modularisation capabilities in computer software. In particular, crosscutting concerns can be modularised. A crosscutting concern arises in a software system when the implementation of a system requirement impacts on more than one implementation module. Such a property hinders the ease with which the software can evolve. With AOSD techniques, the ability to modularise crosscutting concerns results in software that exhibits greater evolvability, as it enhances changeability, pluggability and comprehensibility. This paper reports on the impact on system evolvability arising from the re-implementation of an existing object-oriented system using AOSD techniques. In particular, AspectJ is used, which is an aspect-oriented extension to JavaTM. We found that the use of AOSD techniques and AspectJTM can greatly enhance the modularisation of certain concerns, leading to enhanced evolvability properties. However, for other types of concern the effects on evolvability were less positive. The difference between the two types of concerns related to the extent to which they could actually be modularised using AspectJ.
The lack of a broader acceptance of today's pure ODBMS (as represented by the ODMG standard) brought many questions concerning necessary changes of their architecture. One of the issues worth reconsidering is the design of metamodel that would make metadata operations simpler and the underlying data model more evolvable and extensible. In this paper we discuss the implications of proposed simplified generic metadata structure for an object database. The role of a query language in metadata management is emphasized. We also consider the issue of compliance with existing metamodels. We argue that the simplified structure offers not only greater flexibility of database metamodel, but also contributes to a more intuitive metadata access.
Efficient execution of an object method has a great impact on a query response time. Optimising access to data returned by methods is difficult as methods are written in a high-level programming language and their code is usually hidden to a query optimiser in order to preserve encapsulation. Moreover, estimating the cost of executing a method is another serious problem. In this paper we propose a framework for the materialisation of method results in object databases. In our approach, the materialisation of method m results also in the materialisation of intermediate results of methods called from m. We call this technique hierarchical materialisation. The hierarchical materialisation technique was implemented and evaluated in a prototype based on the FastObjects t7 object-oriented database.
Workflows are computational representations of business processes. When workflows are changed, a strategy for dealing with actual running workflow instances is needed, since workflows are typically long-running processes. As the basic strategies abort and flush are rarely applicable, hybrid workflow schemas have to be defined (transitional provisions) for the continuation of these instances. In this paper we focus on workflow evolutions where merely the order and parallelism of activities are changed and present a technique for generating a manifold of hybrid workflows based on control flow and data flow analysis.
Recently, advanced Web-based applications require integrated access to diverse types of multimedia data such as images, video clips, and audios. To help development of these applications, it is necessary to integrate heterogeneous multimedia data from disparate sources into a single data warehouse. In this paper, we propose a novel view mechanism for integrating multimedia data. First, we design a common data model called the XML/M and develop a view definition language called the XQuery/M. The XML is extended to describe multimedia contents and to capture semantic relationships among multimedia objects. The XQuery language is also extended to access, edit, and update multimedia contents. Second, we develop a layered view mechanism composed of intra-media views and inter-media views to support user queries efficiently. Finally, we suggest a rule-based view maintenance technique. We show that how the Mediaviews mechanism generates user-centered views and manages changes from underlying data sources. Our approach provides semantics-based integration and content-based retrieval of multimedia data.
Web Engineering is concerned with establishment and use of sound scientific, engineering and management principles. In this paper we present an agile approach for web engineering supported by a MDA (Model Driven Architecture) tool, named Netsilon. We promote agility by automating the generation of executable applications via model transformations (even from incomplete models), allowing the developer to focus on three essential aspects (business, presentation and navigation), while getting immediate feedback, at any time, through interaction with the system under development.
We propose to characterize OO evolution according to its own features and independently from any language or model syntax. We outline the three dimensions of OO evolution that we consider as fundamental: the subject of evolution (the structure or the behavior of objects), the type of evolution (whether evolution is foreseeable or not) and the mechanism of evolution used to deal with object evolution (from class or instance toward classes or instances). After that, we focus only on the first part of the subject dimension, namely the object structure. We propose taxonomy on object structure (the node and the connection) and taxonomy on unary and binary evolution operations. Finally, we analyze according to these taxonomies and propose how to position any evolution strategy within the proposed repository.
The Component Oriented Design of Information Systems is spreading. After being used for gaining in reusability at the architectural level, components are nowadays applied at the business logic level. We focus here on the design of multiple functional views in such information systems, specially within the EJB framework. Traditionally, in the database context, this problem is solved by the notion of “view-schemas” applied to a database schema. We present a composition-oriented approach grounded on the splitting of entities according to views requirements. Two original design patterns are formulated and capture the main issues of the approach. The first one is concerned with the management of the split component and its conceptual identity. The second offers a solution for relationships among such components. Finally, we apply these patterns to the EJB framework. This framework improves evolution and traceability of views.
