Object-Oriented Information Systems

The next generation of the Web will be the semantic Web where semantic contents of the Web resources will be interpretable not only by human but also by machine. One popular approach for Semantic Web consists of describing this semantic contents through metadata. Knowledge Management is one of the key progress factors inorganizations. It can rely on explicit and persistent materialization of knowledge of dispersed groups of people in the organization, so as to improve the activities of the organization. When the organization knowledge is distributed among several experts and documents, an Intranet inside the organization and Web technologies can be a privileged means for acquisition, modelling, management of this distributed knowledge. One promising approach relies on the analogy between the resources constituting a corporate memory and the resources accessible through the Web. A corporate memory can thus be materialised in a “corporate semantic Web” made up of resources (e.g. documents or experts), ontologies and semantic annotations on these resources by using the conceptualvocabulary of the ontologies. I shall present a survey of present research useful for building suchcorporate semantic webs.

Nowadays new business models are constantly emerging in electronic commerce and can become a major stake in the e-business game. It is even possible to patent them in some countries. Understanding them and helping to design them are important issues.

Ian Foster and Carl Kesselman outlined Grid concepts in 1999 in their book “The Grid Blueprint for a new Computing infrastructure”. In a subsequent paper, “the Anatomy of the Grid”, the following definition was proposed for Grid as “a Technology that provides coordinated resource sharing and problem solving in dynamic, multi-institutional virtual organizations”. Looking further down in actual Grid flavours we have the following functional taxonomy: Compute Grid, Data Grid, Scavenging Grid, Aggregating Grid and Hybrid Grids.

Cognitive informatics (CI) is a cutting-edge and profound interdisciplinary research area that tackles the common root problems and foundations of modern informatics, computation, software engineering, AI, and life sciences. CI is a new frontier that studies internal information processing mechanisms and processes of the brain, and their applications in computing, software, and ICT industries. Conventional information theory (Shannon, 1948) treated information as a measure of the probability of messages received from a channel. It was focused on information transmission rather than information itself. Modern information theory perceives information as any aspect of the natural world that can be abstracted and digitally represented. With this orientation, information is regarded as entities of messages, rather than a probabilistic measurement of them as in the classical information theory. However, it is recognized that current information theories are still in a category of external informatics. Complementing to these, there is a whole range of extremely interesting new research areas known as CI, a term which was coined by the author in 2001. I think, therefore I am (Rene Descartes, 1596–1650).’ CI draws the attention of research on the internal information processing mechanisms of the brain, which are perceived as the foundation of next generation IT and software technologies, such as neural computers, bio-computers, novel methodologies of software engineering, quantum information processing, and powerful ICT systems. This talk focuses on the natural information processing mechanisms and cognitive processes. The latest development on CI at the First IEEE International Conference on Cognitive Informatics (ICCI’02) will be reported. At heoretical framework of CI as an emerging and interdisciplinary research area will be presented. The objectives of this talk are to draw attention of researchers, practitioners and graduate students on the investigation of cognitive mechanisms and processes of human information processing, and to stimulate the collaborative international effort on CI research and engineering applications.

Deliveringe- content as a service to end users involves addressing various cross-cuttinga spects, includingthe heterogeneity of source and data, user needs, business rules as well as the evolution of the content itself. Cateringfor these aspects when modeling information systems calls for an architecture that accommodates evolution through separation of concerns and tailorability, and provides uniform access to the underlyingc ontent. Based on the notions of services and servicing rules, modules, providers, and module composition we show that effective modelling of service-based e-content delivery system is accomplished.

E-forms are central to the development of e-government, being a basic means for implementing most of the public services considered as required for local and central public administration authorities. In this paper, we present an object-oriented model for e-form-based administrative services, which spans the e-service lifecycle, including development, deployment and use by enterprises and citizens, data collection and communication with legacy information systems. The proposed approach encompasses semantic, structural and active aspects of e-forms, providing thus an inclusive framework for modelling electronic services.

People see trust as an important key issue in embracing electronic commerce. In this paper we review trust within the context of electronic commerce and we propose a trust model, which is based on object-oriented concepts.

Many practical cases of database schema evolution require an effective support from configuration management. Although DBMS construction and software configuration management (SCM) constitute the well established areas of research, they are usually considered in separation from each other. In this paper different issues of SCM are summarized and their relevance to DBMS is investigated. We suggest to extend the OODBMS metamodel to allow recording certain aspects of application-database dependencies in a database schema repository. The extended metamodel contains both typical database metamodel information as well as software configuration information. Such a solution we consider necessary for solving some of schema evolution problems.

It is often necessary to develop database applications with no prior knowledge of the structure of the database. Such applications may be referred to as generic applications, and often they can be required to manipulate multiple (possibly heterogenous) databases across a network. We explore the problems of developing generic applications for the current standard of object-oriented databases, and describe the properties that are needed to build a truly generic application.

Query cost models are widely used, both for performance analysis and for comparing execution plans during query optimisation. In essence, a cost modelp redicts where time is being spent during query evaluation. Although many cost models have been proposed, for serial, parallel and distributed database systems, surprisingly few of these have been validated against real systems. This paper presents cost models for the parallel evaluation of ODMG OQL queries, which have been compared with experimental results obtained using the Polar object database system. The paper describes the validation of the cost model for a collection of queries, using three join algorithms over the OO7 benchmark database. The results show that the cost model generally both ranks alternative plans appropriately, and gives a useful indication of the response times that can be expected from a plan. The paper also illustrates the application of the cost model by highlighting the contributions of different features and operations to query response times.

To be fully usable, digital multimedia contents should be supported by a set of tools to query them, and more generally to manipulate them. This is one of the major goals of an audio database management system (DBMS). Existing work, e.g., radio or television archives, generally tackles the signal processing aspects, often leaving the DBMS question open. In this paper, we lay the foundations for integrating audio into a general purpose DBMS in the form of an object- oriented library. This library provides additional capabilities on top of (MPEG-7) audio descriptions used for mere selections.

Effective development of web applications requires process support just as does traditional development. In the context of an established OO/CBD process, OPEN (Object-oriented Process, Environment and Notation), we identify the special requirements of web application development in order to add these elements to the OPEN repository of process components. In particular, we focus on the need for new Techniques to accomplish Tasks and Activities previously identified as well as focussing on the role that individuals need to play in a web development team.

As XML is becoming a de facto standard data exchange format for web-based business applications, it is imperatively required to integrate semantically heterogeneous XML data sources. In this paper, we study a semantic integration of heterogeneous XML data sources. First, we consider a common data model that is designed to capture semantics of XML data. Second, we define semantic conflicts in the context of XML data, and resolve them using the rule-based method. Third, we develop a semantic integration technique of XML data using XML view mechanism. We describe how our approach has been used to integrate heterogeneous XML data sources providing various object-oriented abstraction facilities such as generalization, specialization and aggregation.

In this paper we propose a new method to store an XML document in an object database (DB). First, the document’s DTD is mapped into a DB schema, then the XML document is mapped into a DB instance. Our method stores the element-subelement relationships and the element attributes. It takes into account the order and the cardinality of subelements. It keeps track of the groupings in an element, and alternatives among subelements. Our method allows us also to retrieve back the DTD and the entire document from the database without loss of information. We implemented our method in the F2 database system, and tested it on sample XML documents

In this paper we analyze the process of mapping business policies into object-oriented software structures. We stress that separation of concerns is a key strategy for obtaining high quality and evolvable implementations. In particular, we show that a naive mapping of business policies into object rules may result in a bad design compromising the overall software stability. We first present our work in the context of customizable of e-commerce applications, and briefly explain why customization functionality should be dealt by separating concerns. We next present our approach for combining object rules with other object-oriented design structures; we show that these modular software constructs allow seamless evolution and maintenance.

The pattern notion defines techniques allowing the existing knowledge reuse. Usually, the knowledge encapsulated in these patterns is stored in classic library repositories that quickly become overcrowded. To solve this problem, [1] proposes the use of process maps in order to organize and select them. But the completeness of the maps is a very important problem that has to be solved in order to offer a useful guidance to the method engineer. This paper proposes a guideline pattern construction technique guiding engineers when creating the maps.

Patterns systems are becoming more and more numerous. They offer product patterns or process patterns of varied range and cover (analysis, design or implementation patterns, and general, domain or enterprise patterns). New application development environments have been developed together with these pattern-oriented approaches and should address two kinds of actors: patterns engineers who specify patterns systems, and applications engineers who use these systems to specify information systems. Nevertheless, most of the existing development environments are made for applications engineers; they offer few functionalities allowing definition and organization of patterns systems. This paper presents AGAP, a development environment for defining and using patterns, which distinguishes pattern formalisms from patterns systems. Not only does AGAP address applications engineers, but it also allows patterns engineers to define patterns systems in order to increase the level of reuse. We illustrate the use of AGAP by the presentation of P-Sigma, a common formalism for patterns representation. P-Sigma expresses a semantics common to most of the existing formalisms and standardizes the expression of product patterns and process patterns. It allows to clarify the patterns selection interface and facilitates the organization of patterns systems.

We propose an object oriented support system which suggests solutions in multi-domain problems. It exhibits two reuse levels: (i)during the knowledge acquisition phase, a framework is provided to the experts and allows reusing of other acquisitions, (ii) this framework is given to the end-users for their real cases representation. The system mixes an hybrid approach: object modeling and Case-Based Reasoning paradigm. All the components indexed by specific objects are stored in different libraries. We introduce the concept of version for object types and instances to increase reuse and to manage their evolution.

It has been a long time since appeared of the Object Oriented (OO) paradigm. From that moment, the designers have accumulated much knowledge in design and construction of OO systems. Patterns are the most refined OO Design Knowledge. However, there are many others kinds of knowledge than not yet classified and formalized. We distinguish and classify the following categories: principles, heuristics, patterns and refactorings. In this paper, we propose an Ontology for Object Oriented Design Knowledge and a measure of impact for patterns, two key elements to create a method based in knowledge.

The paper presents and elaborates on the idea of automatic acquisition of knowledge about domain structure from ontologies into an object-oriented software development process. The information required to be included in the domain model produced during the development process is identified. The existence of the knowledge in ontologies is investigated. Requirements for ontology description languages are formulated followed by brief evaluation of existing languages against these requirements. A schema for domain knowledge acquisition is outlined. A realization of the schema is sketched in the paper while the implementation details can be found in the technical report.

The aim of our work is to provide researchers in experimental sciences means to review their knowledge in a given domain, while confronting it to experimentation data or to calculation tool results. To set up this environment and a methodology, we described the researcher’s knowledge as an oriented object framework and we make use of a format of exchange facilitating the comparison of the results generated by the different tools. Besides, our tool is able to provide researchers the useful information which is extracted from the domain databases. In this article, we present the architecture of our approach and its components. Finally, we will illustrate our framework by an acquisition/revision cycle argued by an example in immunogenetics.

The concept of generalization used during analysis when building a class diagram has a close relationship with the notion of inheritance included in object-oriented programming languages. However, from the point of view of programming, inheritance is a useful mechanism but not especially conceived to implement the generalization specified in analysis. Thus, generalization should be treated suitably in order to obtain sounded design and code from analysis specifications. In addition, it is known that it does not exist concensus about the interpretation and use of inheritance and each programming language provides its particular vision. Hence, when moving from analysis to design and/or implementation (and normally without using a formal approach) the generalization relationships are prone to misinterpretation. OASIS is a formal approach to specify object-oriented conceptual models. In OASIS generalization is included as a language construct that allows specifying generalization patterns with precise semantic and sintaxis. Although OASIS is a textual formal language, the main aspects of one OASIS specification can be mapped and represented using the UML notation, in particular generalization relationships among classes. In this paper we present OASIS generalization patterns and we show how they can be implemented in Java. We also propose other ways to carry out this implementation.

We demonstrate a flexible technique for aspect specification using the UML. The technique uses Role Models to specify design aspects. Roles allow greater flexibility in an aspect over other template-based techniques (e.g. profile extensions). While Role Models do allow us to create templates, they also allow us to create flexible specifications that can be applied by identifying existing model elements that can play aspect roles either as is, or with augmentation based on the aspect specification. This additional capability means that our aspect designs can be applied to specific system designs with fewer constraints on the designer and the initial system models.We demonstrate this flexibility by applying a design aspect developed for one problem domain to a problem in a different domain. No changes are needed in the aspect models, although not all portions of the aspect specification are used in the second problem. In addition, there is no need to constrain the problem in the new application of the aspect; the specification technique is flexible enough that we can apply the aspect without change. We are also able to use the same set of weaving rules to compose the aspect with models of the new problem.

XML-based Metadata Interchange (XMI) is an interchange format for metadata defined in terms of the MOF standard. In addition to supporting the exchange of complete models, XMI supports the exchange of models in differential form. Our paper builds on this feature to examine the possibility of XMI-based generic transformations of UML models. A generic transformation can be configured to generate (via XSLT) a specialized transformation that will be used to transform a UML model. The approach promotes model reuse, speeds up the modeling process and can be used to assure that only predefined semantics (as specialized by an agent) is included in the transformed model.

Internet search engines today are facing problems in keeping upw ith the pace of web growth. Two facts are responsible: bandwidth bottlenecks due to central indexing; deep web (or invisible web) contents that are inaccessible for search engines. Powerful and flexibly extensible object-oriented frameworks are available that assist in the implementation of distributed search infrastructures, thus addressing the first problem. In order to address the second problem, searchability has to be designed into the online applications constituting the deep web, and integrations to the distributed search infrastructures have to be implemented. A model-driven approach to software construction can be used to specify an application’s searchability. This paper presents an extension to the UML that can be used to specify an application’s searchability in an efficient way. The resulting models can be used to generate large parts of the searchability implementation automatically.

In both academy and practice, BP (Business Process) modelling and re-engineering are used to enlighten the IS adaptations required when enterprises change. However, industrial scale BP models are large and complex, and analysing the current and the required BPs at the same time is difficult. We believe this issue can be dealt with by abstracting BP models. This paper proposes a methodological framework organising this analysis into several levels. At the highest level an abstract formalism, called MAP, is used to synthesise BP goals and strategies. Our expectation is that MAP facilitates analysis of change with traditional BP models. A process starting with MAP is also proposed to conduct BP change and IS adaptation analysis. The resulting method was applied in an industrial case study. The paper reports the framework, case study and lessons learned by observation and critics made during the case study.

New object-oriented technologies have been developed in order to manage complexity inherent in new information system development. But developments are very different one from the others, and a given technique, notation or mechanism is used differently depending an the Software under consideration. Flexibility is required from the methodology with regards to the Software context.We propose JECKO, a flexible approach to analysis and design rohere flexibility is handled through a fragmentation mechanism. In order to adapt the analysis and design activities, fragments are selected with regards to Software context. The chosen fragments constitute the route map built for the Software specificity.

The use of object technology (OT) has been highly successful for many software development companies, yet there are still a large number of organizations who have not yet adopted OT. For those companies currently adopting object technology, the transition from traditional procedurally-oriented technologies remains a challenge. Indeed, there is sparse empirical evidence to suggest the best ways to undertake this culture change. Here, we reports on action research results of two case studies within the software development arm of a large multinational professional information solutions provider. The company used the Trans-OPEN process for their transition process. This transition process has seven major activities: initiation, planning, technology insertion, deployment, the use of a retrospective for evaluation, improvement planning and further improvement. the process is incremental and iterative. Furthermore, the case studies underline the need for a more formal approach to culture change in the context of the adoption of object technology.

Today, complex information systems need a simple way for changing the object behavior according with changes that occur in its running environment. We present a reflective architecture which provides the abilityt to change object behavior at run-time by using designtime information. By integrating reflection with design patterns we get a flexible and easilyad aptable architecture. A reflective approach that describes object model, scenarios and statecharts helps to dynamically adapt the software system to environmental changes. The object model, system scenario and manyot her design information are reified by special meta-objects, named evolutionary meta-objects. Evolutionary metaobjects deal with two types of run-time evolution. Structural evolution is carried out by causal connection between evolutionary meta-objects and its referents through changing the structure of these referents by adding or removing objects or relations. Behavioral evolution allows the system to dynamically adapt its behavior to environment changes by itself. Evolutionary meta-objects react to environment changes for adapting the information they have reified and steering the system evolution. They provide a natural liaison between design information and the system based on such information. This paper describes how this liaison can be built and how it can be used for adapting a running system to environment changes.

There exists a gap between business system modelling and object-oriented information system modelling as organization structures and business processes are not explicitly modelled in object models by current object modelling techniques and methods. Organization structures are considered as the outside of the system boundary and business processes are implied by sequences of messages among objects. This gap has caused a difficulty of building object models for information systems that are suited not only to information systems but also to organizations. This paper suggests a new object modelling approach that aims to bridge the gap by building a business system model for organizations and using it as a vehicle for generating an object model for information systems. Three primary business elements (i.e., business processes, organization structures, and resources) are focused and explicitly modelled in the business system model, using business concepts and terms. They are then translated into classes in the object model, using object concepts and terms. Three types of classes (i.e. user interface classes, control classes, and entity classes) are particularly generated by the translation.

The development of information systems has changed a lot in the last years. Nowadays, applications are often developed in distributed environment. It is quite common, they are distributed via Internet and they usually have hypermedia and multimedia elements in huge databases. They are characterized by having complex functional and security requirements, many and undefined users who have different degree of knowledge. These systems are named Global Information Systems. The development of these complex global information systems must be like a software project, based on a development methodology, to get the application suitable to the client’s requirements. This methodology must offer a right treatment of all its aspects. Nowadays, there is no standard methodology which covers all these characteristics. On the one hand, there are some traditional propositions, like the Unified Process [11]. This is a good proposition to work with storage and functional requirements. On the other hand, there are propositions that have come from the multimedia environment, like OOHDM [18], Hyper-UML [14], WSDM [4], etc. which, although give more importance to the interface and navigation, don’t cover all the phases of the whole life cycle. After doing a comparative study of the most relevant methodologies for hypermedia and Web development published in the last few years [7], we have made a methodology proposition to develop global information systems. This methodology is based on the Unified Process, but it adds new models and aspects to treat correctly the navigation, the hypermedia and the interface. In this paper, we present a global vision of our methodology and we focus on the proposition to get requirements from the user. To present the results, we apply the proposition to a real problem in a public company in Seville.

Enterprise JavaBeans is a successful component model for the development of distributed business applications. Enterprise Java-Beans have to adhere to a set of rules and guidelines which, amongst others, require that a significant amount of glue code between the components is written. By using Declarative Meta Programming (DMP) we can codify these rules and guidelines as a logic program which operates on the Java code. Our DMP development tool can not only generate Java code, but can also verify compliance of developer code.

In this paper, we assess the performance of DSMIO cachecoherence algorithm implemented in a parallel object-based database management system (ODBMS). The distinguishing feature of DSMIO is its use of the lazy release memory consistency model and multiplewriter protocol to reduce both the number and size of coherence messages required to keep coherent a distributed ODBMS across a cluster of PC servers. Using a large distributed database and several application workloads we evaluate DSMIO performance and also compare it against that of the well-known Call-Back Locking (CBL) algorithm. Our results showt hat both algorithms perform very well for read operations whereas DSMIO outperforms signi.cantly CBL for write operations with DSMIO speed-ups attaining as much as 5.4 while CBL speed-ups reach at most 1.4 for an 8-node cluster. Overall, these results suggest that designers of cluster-based ODBMS should consider DSMIO as an e.cient option for developing future projects in the field.

A mechanism of retrieving software components is indispensable for component-based software development. However, conventional retrieval techniques require an additional description, and cannot evaluate the total characteristics of a component. In this paper, we propose a new similarity metric, “directed replaceability similarity” (DRS), which represents how two components differ in terms of structure, behavior, and granularity. We developed a retrieval system that automatically measures DRS between a user’s prototype component and components stored in a repository, without any source codes or additional information. As a result of evaluation experiments, it is found that the retrieval performance of our system is higher than those of conventional techniques.

Our detailed investigation into various approaches to evaluate Information Systems Development methods has shown that numerous attempts to assess these methods only yield inconclusive and questionable results. There are two general trends as to how various criteria for evaluation are organised. There are relatively ad hoc lists of criteria for evaluation, and systematically organised frameworks, which generally provide more authoritative assessment results. However, the frameworks investigated are too generic and disproportionate in their emphases on certain parts of a method. Our initial motivation was the development of a framework for assessment of Component-based Software Development methods. However, in response to the shortcomings in existing approaches to method evaluation, a more generic framework that can be used to evaluate various types of Information Systems Development methods such as object-oriented methods, structured methods etc, is presented in this paper. The proposed framework defines three major elements of a method, namely, System Models, System Development Process and Software Architecture. This paper discusses the technique for evaluation of System Models and due to limitations on length of the paper, discussions on the evaluation of the other two elements are not included.

This paper describes a capability-based access control mechanism implemented on a Java environment. In this scheme, access to objects is controlled by means of software capabilities that can be exchanged between mutually suspicious interacting applications. Each application defines the access control rules that must be enforced when interacting with other applications. The definition of access right is managed as a non-functional aspect in the sense it is completely separated from the application code, thus enforcing modularity and ease of expression. It is described in an extended Interface Definition Language (IDL) at the interface level. We have experimented with two prototypes that show how this access control mechanism can be efficiently implemented on a standard Java environment.

This paper presents a European approach to the development of a new industrial architecture of commercial off-the-shelf (COTS) software components, and a practical technology for design and implementation of test-reusable COTS. This work, known as the European COMPONENT+ project, is supported by the European 5th Framework programme and by a number of leading industrial partners in component-based software engineering.Existing COTS architectural technologies were focused on code reuse. The following fundamental problems inherited in conventional COTS technologies have been identified: a) Low testability for end-users; b) Low maintainability for end-users; c) No support for run-time testing; and d) Separated software code and test cases.Being oriented to the problems and challenges as identified above, this paper presents new solutions and techniques for testable COTS architecture developed in the European Component+ project, such as: a) A new technology for implementing BIT-based COTS; b) A new approach to COTS test; c) An extension of OO technology from code reuse to test reuse in COTS development; and d) A new approach to enabling COTS test at run-time. BIT components can be embedded in any conventional COTS for enabling test reuse as well as code reuse. The BIT + COST technologies have been found a wide range of applications in component-based software engineering.

In practice, the development of distributed systems is complex as the design process must take into account the mechanisms and functions required to support interaction, communication and coordination between distributed components. In the context of distributed testing, we illustrate how we can use the concept of active object including the concepts of multi-threading, object and process to solve the problem of the coordination.

The notion of associations is motivated and presented. This kind of association is seen as first class a concept in notations at both modeling and programming level. Among others the association support evolution of systems by adding descriptions and instantiations of associations to executing systems.

Measuring quality is the key to developing high-quality software, and it is widely recognised that quality assurance of software products must be assessed focusing on early artifacts, such as class diagrams. After having thoroughly reviewed existing OO measures applicable to class diagrams at a high-level design stage, a set of metrics for the structural complexity of class diagrams obtained using Unified Modeling Language (UML) was defined. This paper describes a controlled experiment carried out in order to corroborate whether the metrics are closely related to UML class diagram modifiability. Based on data collected in the experiment, a prediction model for class diagram modifiability using a method for induction of fuzzy rules was built. The results of this experiment indicate that the metrics related to aggregation and generalization relationships are the determinant of class diagram modifiability. These findings are in the line with the conclusions drawn from two other similar controlled experiments.

A software product line primarily structures the software architecture around the commonalities of a set of products within a specific organization. Common alities can be implemented in prefabricated components, and product differences are typically treated by well-defined variation points that are actualized later on.Dyna mic, domain-specific aspects, such as ad hoc customization by domian experts, are hard to model with static extension techniques.In this paper, we will discuss open issues for dynamic and domain-specific customizations of product line architectures. We will also present an indirection architecture based on Component Wrapper objects and message redirection for dynamically composing and customizing generic components for the use in concrete products. As a case study, we will discuss two designs from a Multimedia Home Platform product line: end-user personalization across different new media platforms and customization of interactive applications by content editors.

Traditionally, quality software development has been based on the study of lines of implemented code. Software is usually evaluated by means of metrics coming from programming languages.On the one hand, regarding the great importance of the early stages of development, metrics must be defined from higher level of abstraction. Consequently, high-level metrics to be defined and validated in this work, come from specification languages.On the other hand, the concept of quality has subjective aspects leading to numerous proposals for its assurance. Typically, they can be classified in process-centric and product-centric methods. This classification establishes a gap among existing methods. This paper is an attempt to bridge this gap by means of unifying part of the most relevant work about the quality issue, under one umbrella framework. This framework is a methodological approach to software quality assurance based on an object-oriented conceptual modeling method including automatic code generation. It also combines a formal specification language with standard notation.Due to the particular concepts included in our method, the core of this work is to define and validate a specific set of high-level metrics. They assess the quality of an Information System from the Conceptual Model designed with this method.The originality of the paper is the way that high-level metrics are obtained. Using practical experiences modeling real systems, the Quality Hypotheses are established. Metrics involved in them are chosen as candidates to be incorporated in the set which is being defined. The final step is to describe the strategy for their formal and empirical validation.Summing up our methodological approach, software quality assurance consists of: modeling a problem, evaluating the set of metrics, and automatically generating the code of the final software application for a target environment.In future works, the generalization of these ideas to other object-oriented methods will be studied.

Use-case modelling provides a means of specifying external features of a system during requirements elicitation. In principle, use cases can be used to size the system about to be built but, for that, a standard format for their documentation is required. Furthermore, gathering use-case metrics requires a software development process that produces complete use-case descriptions in a repeatable way. Here, we set out the requirements for such a standardization so that use cases can be metricated. Once accomplished, it is possible to evaluate the important research questions of whether use-case attributes such as size and complexity can be controlled and whether use-case metrics are sufficiently rigorous for estimating effort. Finally, we note that this added rigour applied to use cases should improve the consistency and quality of communication between client and developer, helping to ensure that the right system is built.

Web-based Information Systems (WIS) are used for diffusing and processing information over the Internet. Because of the large amounts of information they manage, it is crucial to adapt the delivered information. This can be done by giving users a progressive access to information. For this purpose, we propose to stratify the Information Space of a WIS by decomposing it into personalized sub-Information Spaces. This stratification is described through a Progressive Access Model (PAM) written in UML. The PAM gives WIS users, first, access to some information considered as minimal and essential, and then, allows them to navigate through larger and/or smaller personalized Information Spaces. Together with the PAM, we present a specific query language which allows to query a stratified Information Space. This way, the stratification is taken into account in query expressions, while replies are formatted according to the different levels of detail available in the stratified user’s Information Space.

This paper presents a solution to resolve the problem of multimedia documents collection reorganizing. This solution is based on a documentary warehouse enriched by metadata (for each media type) elicited, modeled and structured in XML meta-documents. To homogenize these meta-document representation, we based our annotation on a document indexing and segmentation process.The warehouse thus created is seen as the hyperbase to which the user will apply personalization and querying mechanisms. The personalization enables dynamic re-structuring and re-construction of documents answering to the user queries. This approach is based on the OOHDM methodology extension with the use of the metadata.

Collaboration flow management is a new paradigm for virtual team support which aims at assisting the opportunistic flow of collaboration within a distributed project, considered as a living and self-organizing system. Such a flow includes informal and formal, synchronous and asynchronous, task-oriented and project management-oriented collaborative sessions. Some of them are elements of model-driven session-based process fragments. The paper defines the collaboration flow management paradigm and describes our Java prototype of collaboration flow management system through a realistic scenario. The paper also discusses how a high level of flexibility is obtained through a set of design choices and object oriented implementation techniques.

To enable integration of heterogeneous components, the description of offered interfaces (services offered by the component to its environment) of the components is not always sufficient. To support complex assemblies, two additional concepts have to be handled: required interfaces (services offered by the environment to the component) and connectors (mechanisms needed to interconnect components). CCM (CORBA Component Model) has recently been proposed as a component model on top of CORBA middleware: it integrates the concept of required interfaces but not yet the concept of connectors. Our proposal is to add this concept to CCM. We illustrate it with different varieties of connectors, like interface adaptors and mediators integrating mechanisms such as load balancing and fault tolerance.

Component-based programming is a promising approach to distributed application development [1]. It encourages software reuse and promotes the separation (as in aspect-oriented programming[5]) between the components’ business implementations and the code managing the used system services. One system service of particular importance to the distributed computing domain is replication.

Information Systems with a large user base require thin client technology due to deployment issues. Configuration and version management, added to maintenance cost are major players on this decision. However, heavy traffic loads and network latency impose severe penalties on users. Candidate solutions to this problem must optimize users ergonomics whilst keeping maintenance costs low. In a straightforward approach, client architectures should provide web deployable local processing facilities. This paper describes an architecture based on the MVC paradigm capable of porting portions of the system to client executable scripts. Required entities are encapsulated in XML carriers and exchanged on demand between client and server side systems. Numerous user interactions are executed on the client side, relieving the network and improving responsivity. This solution not only enhances ergonomics but is also highly scalable, delegating tasks to the greater number of client machines, whereas focusing server activity on more relevant operations.

A product-line is a set of software systems sharing the same architecture and implementation platform. Based on an analysis of several industrial product-lines, a general layered model is proposed as the main structuring principle of a product-line. It is demonstrated that the model can be used to explain and clarify several existing productline architectures.

Integrated communications have been largely associated with message-oriented middleware in collaborative distributed computing environments, both on small and large scales. Past experience has shown that monolithic architectures based on large executables are extremely difficult to maintain and very unresponsive to change. This paper aims at proposing an intelligent, object-oriented communications and messaging architecture based on interrelated business objects and components, designed to support business-to-business communication. The philosophy behind our approach has been to construct a scalable and flexible system architecture that enables the incorporation of new services at minimum effort. The framework allows for the implementation of reusable components, independently from the core architecture, that can be automatically discovered, configured and plugged-in to the system and used as “cartridges” on demand, according to the communication requirements of the application that will make use of the bearers linked to the system.

This paper argues for strong notions of Object Schizophrenia (OS) and Object Schizophrenia Problem (OSP) and makes subtle distinction between them. It presents how OSP can occur in modeling is-part-of and is-role-of relationships. Basically, we assert that OS-condition of an object does not necessarily entail OSP. The occurrence of OSP is investigated in the realm of role modeling. Broken consultation, wrong message interpretation and security schizophrenia problem that arise due to reusing mechanisms in role modeling such as delegation are incorporated as new symptoms into the semantic scope of the notion of OSP. We introduce plurality of OS and OSP by categorizing OSs and OSPs based on various models for object relationships and OSP symptoms. A comparison picture of the existing role models is presented with regard to OSP. We assert that there can be different approaches for handling the OSP and that a solution to OSP works out only in a model-specific way. In the realm of role modeling, this work emphasizes that modeling the role paradigm should ensure that the role model is OSP-free. We argue for strong notion of object identity for role-playing objects in terms of the Oid integrity principle.

Both, the role concept and aspect-oriented programming are techniques which permit a flexible adaptation of object-oriented constructs and therefore can be used to adjust existing software to new challenges. While the former one is already well known in the object-oriented world, the latter was only recently introduced. Currently, both techniques co-exist without affecting each other and therefore concrete software projects either use the one or the other approach. There are some situations where the result of utilizing the one or the other is approximately the same. Therefore, it is reasonable to analyze each approach in respect to its underlying philosophy and its impact on the implementation level and to compare them on the basis of those observations. This paper discusses the equivalences and differences between the role concept and aspect-oriented programming and reveals potential synergies between both approaches.

Object-oriented views play a key role when giving accessing applications a new or restricted perspective on persistent object-oriented data. However, traditional object-oriented view systems only allow for limited changes when it comes to restructuring a database schema and the related persistent objects in a view. We present a new approach for defining object-oriented views that enables view schemas and view objects whose structure is highly flexible with respect to the underlying database structure. Nevertheless we can guarantee complete type-safety of view schemas and a well-defined and consistent behavior when running updates on view objects as well as on underlying database objects.We reach this goal through the concept of method propagation: given that a method of a persistent base class fulfills certain conditions, it can be attached to view classes after its signature is appropriately adjusted. At runtime a method call on a view object is delegated to a corresponding base object and executed there.In the course of this paper we introduce a formal model for objectoriented databases which serves as a basis for defining method propagation conditions. We then present a view language that is derived from our formal approach and highlight the architecture of a prototypical view system.

This paper presents the specification of an Is_A hierarchies reorganization method, called REORG, with a process modeling language called MAP. REORG proposes two complementary mechanisms: the splitting and the restructuring mechanisms. The first one derives Is_A hierarchies concealed in existing entities. The second one performs grouping of existing entities without losing the inheritance semantics by introducing several types of constraints. MAP is a process modeling language that provides a formalism combining visual facilities and formal descriptions of information systems processes. The specification of REORG with MAP supplies a process model, which makes explicit modeling practices and then allows the integration of these practices into any CASE tool.