Conceptual Modeling — ER 2000

Model management is a framework for supporting meta-data related applications where models and mappings are manipulated as first class objects using operations such as Match, Merge, ApplyFunction, and Compose. To demonstrate the approach, we show how to use model management in two scenarios related to loading data warehouses. The case study illustrates the value of model management as a methodology for approaching meta-data related problems. It also helps clarify the required semantics of key operations. These detailed scenarios provide evidence that generic model management is useful and, very likely, implementable.

Computer and related information and communication technologies have profoundly affected the shape of modern society. Shepherding the creation and utilization of effective and efficient computational technologies are the joint tasks of Computer Science and Information Systems researchers. Their realm is to understand and explicate the nature of those technologies and how and why they come into existence. This knowledge forms the foundation of theories to explain and, hopefully, to predict their impacts on individuals, groups, organizations, and society as a whole. The very creation of an innovative technology focused on a specific problem in a specific context can have far reaching effects, completely unpredicted and unintended by the innovator. We argue that researchers in Computer Science and Information Systems must be cognizant of the broader implications of their work and encourage their interaction with practitioners and researchers in a variety of disciplines to identify fruitful areas of scientific inquiry.

Modeling social settings is becoming an increasingly important activity in software development and other conceptual modeling applications. In this paper, we review i* [Yu95], a conceptual model specifically intended for representing social settings. Then, we introduce Tropos, a formal language founded on the primitive concepts of i*, and demonstrate its expressiveness through examples. Finally, we give an overview of a project which uses Tropos to support software development from early requirements analysis to detailed design.

One of the challenges in practical information system development is to find suitable methods for schema integration. Schema integration aims at replacing a set of existing schemata by a single new one. In this case there is a need to guarantee that with respect to information capacity the new schema dominates or is equivalent to the old ones. We develop formal transformation rules for schema integration. These rules rely on the Higher-order Entity-Relationship model and its theory of schema equivalence and dominance. The rules are embedded in a pragmatic method telling how they should be applied for integration. The method has been applied to various schemata of realistic size.

Description-driven systems based on meta-objects are an increasingly popular way to handle complexity in large-scale object- oriented database applications. Such systems facilitate the management of large amounts of data and provide a means to avoid database schema evolution in many settings. Unfortunately, the description-driven approach leads to a loss of simplicity of the schema, and additional software behaviour is required for the management of dependencies, description relationships, and other Design Patterns that recur across the schema. This leads to redundant implementations of software that cannot be handled by using a framework-based approach. This paper presents an approach to address this problem which is based on the concept of an ontology of Design Patterns. Such an ontology allows the convenient separation of the structure and the semantics of database schemata. Through that, reusable software can be produced which separates application behaviour from the database schema.

The mediation architecture is widely used for bridging heterogeneous data sources. We investigate how such architecture can be extended to embrace information processing services and suggest a framework that supports declarative specification of mediation logic. In this paper we show how our framework can be applied to enrich interface descriptions of distributed objects and to integrate them with other client/server environments.

In databases based on a multi-aspects object-oriented data model which enables multiple aspects of a real-world entity to be represented and to be acquired/lost dynamically, Object Migration (OM) updating membership relationships between an object and classes occurs, as the properties of the object evolve in its lifetime. To keep an object consistent in OM, this paper introduces temporal consistency constraints such as temporal transitional constraints and temporal multiplicity constraints by extending OM consistency constraints for snapshot databases. To this end, a temporal interval is attached to each aspect of an object for representing its duration in the real world. Then, temporal transitional constraints are represented by transitional rules with conditions referring to temporal intervals. Additionally, temporal multiplicity constraints are represented by object-schemas. Furthermore, the paper proposes OM behavior modeling using Colored Petri Nets (CPN) based on temporal consistency constraints.

In this paper, we propose a query language and data model for spatio-temporal information, including objects of time-changing geometry. Our objective is to minimize the extensions required in SQL, or other relational languages, to support spatio-temporal queries. We build on the model proposed by Worboys where each state of a spatial object is captured as a snapshot of time; then, we use a directed-triangulation model to represent spatial data, and a point-based model to represent time at the conceptual level. Spatio-temporal reasoning and queries can be fully expressed with no new constructs, but user-defined aggregates, such as AREA and INSIDE for spatial relationships, DURATION and CONTAIN for temporal ones, and MOVING_DISTANCE for spatio-temporal ones. We also consider the implementation problem under the assumption that, for performance reasons, the representation at the physical level can be totally different from the conceptual one. Thus, alternative physical representations and mappings between conceptual and physical representations are discussed.

TBE (Trigger-By-Example) is proposed to assist users in writing trigger rules. TBE is a graphical trigger rule specification language and system to help users understand and specify active database triggers. Since TBE borrowed its basic idea from QBE, it retained many benefits of QBE while extending the features to support triggers. Hence, TBE is a useful tool for novice users to create simple trigger rules easily. Further, since TBE is designed to insulate the details of underlying trigger systems from users, it can be used as a universal trigger interface for rule formation.

In the relational data model, the problem of data redundancy has been successfully tackled via decomposition. In advanced data models, decomposition by pivoting provides a similar concept. Pivoting has been introduced by Biskup et al. [5], and used for decomposing relationship types according to a unary nonkey functional dependency. Our objective is to study pivoting in the presence of cardinality constraints which are commonly used in semantic data models. In order to ensure the equivalence of the given schema and its image under pivoting, the original application-dependent constraints have to be preserved. We discuss this problem for sets of participation and co- occurrence constraints. In particular, we prove the necessity of path cardinality constraints, and give an appropriate foundation for this concept.

Even with the presence of active research communities that study information system design, the term information system (IS) still lacks precise formal underpinnings. Unlike for databases, there is no agreement on what constitutes “IS principles.” Any significantly advanced IS contains some kind of a database system. On the other hand, any useful database system is actually an IS, providing additional services beyond simply maintaining data and running queries and updates. As a result, the distinction between issues related to databases and to ISs tends to get blurred, and it is not clear that the principles underlining the study of ISs should be different than those for databases. In this paper we argue that the interactive aspect of ISs necessitates a fundamentally different set of IS design principles, as compared to conventional database design. We provide some promising directions for a formal study of IS models, based on the observation that interactive behaviors cannot be reduced to algorithmic behaviors.

When modelling a real-world phenomenon, it can often be useful to have multiple descriptions of the phenomenon, each expressed using a different modelling approach or representation. Different representations such as entity-relationship modelling, data ow modelling and use case modelling allow analysts to describe different aspects of real- world phenomena, thus providing a more thorough understanding than if a single representation were used. Researchers working with multiple representations have approached the problem from different directions, resulting in a diverse and potentially confusing set of terminologies. In this paper is described a viewpoint-based framework for discussing the use of multiple modelling representations to describe real-world phenomena. This framework provides a consistent and integrated terminology for researchers working with multiple representations. An abstract notation is also defined for expressing concepts within the framework.

Materialized views in data warehouses are typically complicated, making the maintenance of such views difficult. However, they are also very important for improving the speed of access to the information in the data warehouse. So, the selection of materialized views is crucial to the operation of the data warehouse both with respect to maintenance and speed of access. Most research to date has treated the selection of materialized views as an optimization problem with respect to the cost of view maintenance and/or with respect to the cost of queries. In this paper, we consider practical aspects of data warehousing. We identify problems with the star and snow ake schema and suggest solutions. We also identify practical problems that may arise during view selection and suggest heuristics based on data dependencies and access patterns that can be used to measure if one set of views is better than another set of views, or used to improve a set of views.

The development of object-oriented software starts from requirements expressed commonly as Use Cases. The requirements are then converted into a conceptual or analysis model. Analysis is a fundamental stage because the conceptual model can be shown to satisfy the requirements and becomes the skeleton on which the complete system is built. Most of the use of software patterns until now has been at the design stage and they are applied to provide extensibility and flexibility. However, design patterns don’t help avoid analysis errors or make analysis easier. Analysis patterns can contribute more to reusability and software quality than the other varieties. Also, their use contributes to simplifying the development of the analysis model. In particular, a new type of analysis pattern is proposed, called a Semantic Analysis Pattern (SAP), which is in essence a miniapplication, realizing a few Use Cases or a small set of requirements. Using SAPs, a methodology is developed to build the conceptual model in a systematic way.

The size and complexity of modern information systems together with requirements for short development time increase the demands for reuse of already existing solutions. The idea of reuse itself is not novel and the ability of reuse is even a part of the learning process. However, not much support for reuse can be found for the analysis phase of information systems design. Collecting reusable solutions, called patterns, in a library and supporting the search for an appropriate pattern within such a library is one approach addressed in this area. A tool for this purpose has been partly implemented and the results from a case study testing this tool are reported here.

Taxonomies based on a partial-ordering relation commonly known as is-a, class inclusion or subsumption have become an important tool in conceptual modeling. A well-formed taxonomy has significant implications for understanding, reuse, and integration, however the intuitive simplicity of taxonomic relations has led to widespread misuse, making clear the need for rigorous analysis techniques. Where previous work has focused largely on the semantics of the is-a relation itself, we concentrate here on the ontological nature of the arguments of this relation, in order to be able to tell whether a single is-a link is ontologically well-founded. For this purpose, we discuss techniques based on the philosophical notions of identity, unity, essence, and dependence, which have been adapted to the needs of information systems design. We demonstrate the effectiveness of these techniques by taking real examples of poorly structured taxonomies, and revealing cases of invalid generalization. The result of the analysis is a cleaner taxonomy that clarifies the modeler’s ontological commitments.

Most documents available over the web conform to the HTML specification. Such documents are hierarchically structured in nature. The existing graph-based or tree-based data models for the web only provide a very low level representation of such hierarchical structure. In this paper, we introduce a conceptual model for the web that is able to represent the complex hierarchical structure within the web documents at a high level that is close to human conceptualization/visualization of the documents. We also describe how to convert HTML documents based on this conceptual model. Using the conceptual model and conversion method, we can capture the essence (i.e., semistructure) of HTML documents in a natural and simple way.

In this paper, we show how view adaptation can be supported in order to keep views up to date and running after view redefinition. In particular in the area of integrated systems such as Web sites, data warehousing systems and mediator systems, efficient solutions to this task are of most importance. The proposed view adaptation is based on a novel view selection approach that consists in decomposing views into fragments and then merging them into a Multi View Materialization Graph, sharing materialized fragments where possible. The goal is to minimize both communication cost (i.e., accessing the sources) and the cost of adapting the view materialization. In related work, view adaptation is based solely on the old materialization of the same view. Our approach performs view adaptation regarding all the materialized views therefore it optimizes the communication cost.

We present a temporal web data model designed for wa- rehousing historical data from World Wide Web that changes with time. As the Web is now populated with large volume of web information, it has become necessary to capture some useful web information in a data warehouse that supports further intelligent data analysis. Nevertheless, due to the unstructured and dynamic nature of Web, the traditional relational model and its temporal variants could not be used to build such a data warehouse. In this paper, we therefore propose a temporal web data model that captures the connectivities of web documents and their content in the form of temporal web tables. To support the analysis of web data that evolve with time, valid time intervals are associated with each web document. To manipulate temporal web tables, we define a variety of web operators and illustrate their usefulness using some realistic motivating examples.

A business process model represents the basic building block for a workflow-enabled enterprise information system. Generally, a process model evolves through numerous changes during its lifetime to meet dynamic and changing business requirements. It is essential that such changes are introduced systematically and their impact is clearly understood. Process model transformation is a suitable approach for this purpose. Applying pre-defined transformation operations can ensure that the modified process conforms to a given class of constraints specified in the original model. Using a generic process modelling language, we identify three classes of transformation principles — equivalent, imply, and subsume — to manage changes in process models. A simple algebraic notation for representing process graphs is also presented that can be used to reason about transformation operations.

A guide to requirements modeling is presented in this paper, in which use cases and the conceptual model are directly obtained from a business modeling based on UML activity diagrams. After determining the business processes of the organization, and describing their workflows by means of activity diagrams, use cases are elicited and structured starting from the activities of each process, while the concepts of the conceptual model are obtained from the data that flow between activities. Furthermore, business rules are identified and included in a glossary, as part of the data and activities specification. One notable aspect of our proposal is that use case and conceptual modeling are performed at the same time, thus making the identification and specification of suitable use cases easier. Both use case and conceptual modeling belong to the requirements analysis phase, which is part of a complete process model on whose definition we are currently working. This process is being experimented in a mediumsized organism of a Regional Public Administration.

This paper presents a multi-agent conceptual model for resource allocation in a manufacturing environment. To attain this purpose a framework called M-DRAP — Multi-agent Dynamic Resources Allocation Planning — was developed. Multi-agent systems have been employed as a solution for problems that require decentralization and distribution in both decision-making and execution process. This is a premise in many information systems where (i) the domain involves intrinsic distribution of data, problem-solving capabilities and responsibilities; (ii) it is necessary to maintain the autonomy of the subparts, without lost of organizational structure; and (iii) the problem solution cannot be completely described a priori due to the possibility of real-time perturbations in the environment (equipment failures, for example) and also as a consequence of the natural dynamics of the business process. The main contribution of this work is the proposition of a set of activities and models defining a framework to represent multi-agent systems for business process under an enterprise model perspective.

XML is increasingly becoming the preferred method of encoding structured data for exchange over the Internet. XML-Schema, which is an emerging text-based schema definition language, promises to become the most popular method for describing these XML-documents. While text-based languages, such as XML-Schema, offer great advantages for data interchange on the Internet, graphical modelling languages are widely accepted as a more visually effective means of specifying and communicating data requirements for a human audience. With this in mind, this paper investigates the use of Object Role Modelling (ORM), a graphical, conceptual modelling technique, as a means for designing XML-Schemas. The primary benefit of using ORM is that it is much easier to get the model ‘correct’ by designing it in ORM first, rather than in XML. To facilitate this process we describe an algorithm that enables an XML-Schema file to be automatically generated from an ORM conceptual data model. Our approach aims to reduce data redundancy and increase the connectivity of the resulting XML instances.

As Extensible Markup Language (XML) [5] is emerging as the data format of the internet era, there are increasing needs to efficiently store and query XML data. One way towards this goal is using relational database by transforming XML data into relational format. In this paper, we argue that existing transformation algorithms are not complete in the sense that they focus only on structural aspects and ignoring semantic aspects. We present the semantic knowledge that needs to be captured during the transformation to ensure a correct relational schema. Further, we show a simple algorithm that can 1) derive such semantic knowledge from the given XML Document Type Definition (DTD) and 2) preserve the knowledge by representing them in terms of semantic constraints in relational database terms. By combining the existing transformation algorithms and our constraints-preserving algorithm, one can transform XML DTD to relational schema where correct semantics and behaviors are guaranteed by the preserved constraints. Experimental results are also presented.

Relational databases get more and more employed in order to store the content of a web site. At the same time, XML is fast emerging as the dominant standard at the hypertext level of web site management describing pages and links between them. Thus, the integration of XML with relational database systems to enable the storage, retrieval and update of XML documents is of major importance. This paper presents X-Ray, a generic approach for integrating XML with relational database systems. The key idea is that mappings may be defined between XML DTDs and relational schemata while preserving their autonomy. This is made possible by introducing a meta schema and meta knowledge for resolving data model heterogeneity and schema heterogeneity. Since the mapping knowledge is not hard-coded but rather reified within the meta schema, maintainability and changeability is enhanced. The meta schema provides the basis for X-Ray to automatically compose XML documents out of the relational database when requested and decompose them when they have to be stored.

Data acquisition systems (DAS) are the basis for building monitoring tools that enable supervision of local and remote systems. Unfortunately, DASs are commonly based on proprietary technologies. The data format usually depends on the industrial process, the fieldbus characteristics or the development platform. Currently, there are many standards of DASs, but none of them offer a well-accepted Application Programming Interface (API). However, all of them comply with the same conceptual model. Understanding this model allows for the significant improvement of the design of a specific DAS. In this paper, we propose a conceptual model of a generic DAS. This model gives researchers an abstraction of DASs and a quasi-formal specification of a generic DAS. It also enables developers to compare the existing standards and/or to propose a new open standard.

In the chemical industry a major task is to design manufacturing pro-cesses, which is a creative, ill-defined, complex, and incompletely understood problem. Currently, the design knowledge and experience are mostly located in the mind of the individual engineer. It is desirable to move this knowledge at least in part into a computer supported environment. The key element is a proper model of the design process itself, which is essential for understanding and supporting it. Examples of design processes in chemical engineering are analyzed in order to learn what is necessary to describe them completely. This leads to requirements a modeling language for design processes in chemical engineering has to fulfill. Because the requirements are not completely met by existing work process modeling languages, an existing language is modified and enhanced to allow representation of the processes under consideration. The new language is used to formally represent sample work processes from the application domain. It serves as a basis for the development of a support functionality which guides the designing engineer through his work within a prototypical environment for mathematical modeling of chemical processes, a major part of the design process.

Modeling video data poses a great challenge since they do not have as clear an underlying structure as traditional databases do. We propose a graphical object-based model, called VideoGraph, in this paper. This scheme has the following advantages: (1) In addition to semantics of video individual events, we capture their temporal relationships as well. (2) The inter-event relationships allow us to deduce implicit video information. (3) Uncertainty can also be handled by associating the video event with a temporal Boolean-like expression. This also allows us to exploit incomplete information. The above features make VideoGraph very exible in representing various metadata types extracted from diverse information sources. To facilitate video retrieval, we also introduce a formalism for the query language based on path expressions. Query processing involves only simple traversal of the video graphs.

Whilst research has indicated that the practitioner use of entity-relationship modelling is problematic, proponents of object oriented modelling suggest that their paradigm offers both a new approach and also more effective modelling. This paper examines some practitioner perceptions of one object oriented modelling technique in the context of previous work on entity-relationship modelling. The findings show that there are similar practitioner issues arising from common underlying techniques and that object oriented modelling is problematic when used with project clients. However, the suggestion is that object oriented practitioners are not gaining insight from practitioner experience from more than twenty years of entity-relationship modelling practice.

Relationships have been repeatedly identified as an important object-oriented modeling construct. Today most emerging modeling standards such as the ODMG object model and UML have some support for relationships. However while dealing with schema evolution, OODB systems have largely ignored the existence of relationships. We are the first to propose comprehensive support for relationship evolution. A complete schema evolution facility for any OODB system must provide (1) primitives to manipulate all object model constructs; (2) and also maintenance strategies for the structural and referential integrity of the database under such evolution. We hence propose a set of basic evolution primitives for relationships as well as a compound set of changes that can be applied to the same. However, given the myriad of possible change semantics a user may desire in the future, any pre-defined set is not sufficient. Rather we present a exible schema evolution framework which allows the user to define new relationship transformations as well as to extend the existing ones. Addressing the second problem, namely of updating the schema evolution primitives to conform to the new set of invariants, can be a very expensive re-engineering effort. In this paper we present an approach that de-couples the constraints from the schema evolution code, thereby enabling their update without any re-coding effort.

Reuse of domain models is often limited to the reuse of the structural aspects of the domain (e.g. by means of generic data models). In object-oriented models, reuse of dynamic aspects is achieved by reusing the methods of domain classes. Because in the object-oriented approach any behavior is at-tached to a class, it is impossible to reuse behavior without at the same time re-using the class. In addition, because of the message passing paradigm, object interaction must be specified as a method attached to one class which is invoked by another class. In this way object interaction is hidden in the behavioral as-pects of classes. This makes object interaction schemas difficult to reuse and customize. The focus of this paper is on improving the reuse of object-oriented domain models. This is achieved by centering the behavioral aspects around the concept of business events.

Relational database systems represent the current standard technology for implementing database applications. Now that the object-oriented paradigm becomes more and more mature in all phases of the software engineering process, object-oriented DBMS are seriously considered for the seamless integration of object-oriented applications and data persistence. However, when reengineering existing applications or constructing new ones on top of relational databases, a large semantic gap between the new object model and the legacy database’s model must be bridged. We propose database migration to resolve this mismatch: the relational schema is transformed into an object-oriented one and the relational data is migrated to an object-oriented database. Existing approaches for migration do not exploit the full potential of the object-oriented paradigm so that the resulting object-oriented schema still “looks rather relational” and retains the drawbacks and weaknesses of the relational schema. We propose a redesign environment which allows to transform relational schemas into adequate object-oriented ones. Schemas and transformation rules are expressed in terms of a new data model, called semi object types (SOT). We also propose a formal foundation for SOT and transformation rules. This formalization makes it possible to automatically generate the data migration process.

Separation of concerns is a determining factor of the quality of object- oriented software development. Done well, it can provide substantial benefits such as additive rather than invasive change and improved adaptability, customizability, and reuse. In this paper we propose a software architecture that integrates concepts from business process modeling with concepts of object- oriented systems development. The presented architecture is a layered one: the concepts are arranged in successive layers in such a way that each layer only uses concepts of its own layer or of layers below. The guiding principle in the design of this layered architecture is the separation of concerns. On the one hand workflow aspects are separated from functional support for tasks and on the other hand domain modeling concepts are separated from information system support. The concept of events (workflow events, information system events and business events) is used as bridging concept between the different layers.

Corollary to the development of new kinds of application - like decision support ones - manipulating large quantities of data structured in new kinds of data supports -like data warehouses, queries formulated to access this data have been growing in their complexity. However, with the exception of approaches facilitating syntax problems, there is a noticeable absence of models taking charge of the user through from specification of their needs to formulation of their queries. In the case of object-oriented database systems, whose data models and concepts are more complex than those of relational databases, database users need assistance with several kind of formulation problems. In this article, we take a novel look at object-oriented queries - reifying the ones which users formulate as components then reusing them, by means of strategies for selecting, assembling and adapting them to help in the formulation of new complex queries.

The process of system design often begins with the selection of an appropriate reference model. Model selection necessitates a good understanding of the system to be developed, as well as of the reference models available for that particular type of systems. In this paper, we propose a conceptual framework for comparing reference models, based on an elaboration of a linguistics-based classification approach. This framework is applied to the comparative analysis of two well known reference models for electronic commerce.

System developers are increasingly realising that the quality of a system must be ensured in the early stages of the development life cycle. It is in this context that a number of quality frameworks for conceptual schemes have been proposed. However, before the quality of a conceptual schema can be improved, it must be assessed. Accordingly, a number of measure suites have been proposed for measuring quality properties of conceptual schemes. In this paper we focus on one particular quality property, i.e. complexity. This property can be described as the mental burden of the persons that must understand, modify, extend, verify, implement, and reuse conceptual schemes. The proposed complexity measures for conceptual schemes have in common that they only capture the complexity of the static or structural aspects of a conceptual schema. We therefore present a complementary suite of measures that focuses on conceptual schema complexity as seen from a dynamic perspective.

Database quality depends greatly on the accuracy of the requirement specification and the greatest effort should focus on improving the early stages of database life cycle. Conceptual data models form the basis of all later design work and determine what information can be represented by a database. So, its quality has a significant impact on the quality of the database which is ultimately implemented. In this work, we propose a set of metrics for measuring entity relationship diagram complexity, because in today—s database design world it is still the dominant method of conceptual modelling. The early availability of metrics allows designers to measure the complexity of entityrelationship diagrams in order to improve database quality from the early stages of their life cycle. Also we carried out a controlled experiment in order to analyse the existent relationships between each of the proposed metrics and each of the maintainability sub-characteristics. In order to analyse the obtained empirical data we propose a novel data analysis technique based on fuzzy regression trees.

Object-oriented design methods express the behavior an object exhibits over time, i.e., the object life cycle, by notations based on Petri nets or state charts. The paper considers the specialization of life cycles via inheritance relationships as a combination of extension and refinement, viewed in the context of UML state machines. Extension corresponds to the addition of states and actions, re- finement refers to the decomposition of states into substates. We use the notions of observation consistency and invocation consistency to compare the behavior of object life cycles and present a set of rules to check for behavior consistency of UML state machines, based on a one-to-one mapping of a meaningful subset of state machines to Object/Behavior Diagrams.

In object-oriented (OO) development the viewpoint abstraction has attracted by far less attention than classical abstraction mechanisms, such as classification, generalization, and aggregation. In OO databases, however, recent research has produced powerful view concepts supporting customization, schema evolution, and updates of base objects through views. This paper discusses features of the viewpoint abstraction in the context of OO modeling and specifies extensions to the UML to support the modeling of views. We suggest employing an explicit notion of a view based on research on contexts and on OO databases in order to facilitate the customization of OO models through views. Further, the role of views to support an incremental development process will be discussed.

The eXtensible Markup Language (XML) is increasingly finding acceptance as a standard for storing and exchanging structured and semi-structured information. With its expressive power, XML enables a great variety of applications relying on such structures - notably product catalogs, digital libraries, and electronic data interchange (EDI). As the data schema, an XML Document Type Definition (DTD) is a means by which documents and objects can be structured. Currently, there is no suitable way to model DTDs conceptually. Our approach is to model DTDs and thus classes of documents on the basis of UML (Unified Modeling Language). We consider UML to be the connecting link between software engineering and document design, i.e., it is possible to design object-oriented software together with the necessary XML structures. For this reason, we describe how to transform the static part of UML, i.e. class diagrams, into XML DTDs. The major challenge for the transformation is to define a suitable mapping reflecting the semantics of a UML specification in a DTD correctly. Because of XML—s specific properties, we slightly extend the UML language in a UML-compliant way. Our approach provides the stepping stone to bridge the gap between object-oriented software design and the development of XML data schemata.

Careful analysis and preparation is required in order to prepare for XML-based delivery of data via Corporate Portals. This process is refereed to as Metadata Engineering. This presentation describes the use of the metadata model to guide the metadata engineering as a precursor to metadata implementation in preparation for XML-based delivery.

The Corporate Portal is a central gateway to the processes, databases, systems and workflows of an enterprise. When personalized to the job responsibilities of employees via the Intranet, the corporate portal provides a seamless, single point of access to all of the resources that employees need to do their jobs. When further personalized securely via the Internet and Extranets to the interests of suppliers, customers and business partners, the corporate portal becomes the integrating conduit of the many disparate databases, systems and workflows each enterprise uses to carry out business with others. It also becomes a single place to manage rapid enterprise change. Implementation of a corporate portal requires interfaces with legacy systems and data warehouses. An application of the enterprise architecture technique lends itself to a logical design for an enterprise portal. The portal grows through evolutionary stages. It is therefore, essential that all portal planning and development be based on the adaptive architecture, which is systematically maintained. The configuration of the portal continuously changes as the ebusiness changes. Metadata initiated during the architecture stage will play a key role in maintaining and managing the corporate portal on an ongoing basis. The presentation also covers issues Data Administration has to address in order to assure successful functioning of a corporate portal.

Many types of data models are being developed using a variety of different methods and notations. Some of these data models are oriented toward physical implementation, others toward understanding business data, and a few toward business managers. Many of the data models are overloaded with detail and much of that detail is not relevant to the intended audience. The result is a confusion about what the data models represent, their intended audience, and their purpose. This abstract provides a framework for understanding the different types of data models through a five-tier five-schema concept developed by the author.

The adequate cross-referencing of a physical database and its logical model is crucial for software maintenance support. The paper describes approach, which eliminates the need for the logical model to closely follow the physical design. It allows modernizing of the logical model with new ideas and concepts without losing information needed for the support of an installed base of applications. Examples of meta-data transformations and corresponding documentation requirements are included.

The book Data Model Patterns: Conventions of Thought describes a set of standard data models that can be applied to standard business situations. These patterns, it turns out, occur on several levels. At the basic level are models of the things seen in business. The patterns in the book are a bit more abstract than conventionally seen, but they do describe things that are easily recognizable to anyone: people and organizations, products, contracts, and so forth.

Larry English tells us that “quality is free.” The lack of quality is what is costly. Ensuring the quality of the data in an organization involves those who are involved in every stage of an organization’s entire information chain — starting with the planning and conceptual modeling of the data. Establishing information quality requires understanding — and practicing — the principles of information and data quality at every stage of the information chain.

Effective database applications, business rules management, data warehousing, enterprise modeling and re-engineering all depend on the quality of the underlying data model. To properly exploit relational, object-relational or object database technology, a clear understanding is needed as to how to create conceptual business models, transform them to logical database models for implementation on the chosen platform, and query the populated models. Factorientation provides a truly conceptual way to accomplish these tasks, facilitating communication between the modeler, the domain expert and the application. This presentation provides insights into the fact-oriented approach for modeling and querying information systems, focusing on verbalization and instantiation of data use cases for capturing business rules, including recent work on negative and default rule verbalizations.

Recently, digital broadcasting has experienced rapid growth. Digital broadcasting can deliver additional data as program attachments, which viewers can use to flexibly browse and retrieve parts of the program on their TVreceiving terminals. They can also make personalized digests from the broadcast TV programs. This function is particularly useful for viewers of sports programs because the digests reflect varied viewer preferences, such as favorite teams and players. This paper presents a method for making personalized digests for sports programs using additional data attachments.