International Journal of Software Engineering and Knowledge Engineering

UML, being the industry standard as a common OO modeling language, needs a well-defined semantic base for its notation. Formalization of the graphical notation enables automated processing and analysis tasks. This paper describes a methodology for synthesis of a Petri net model from UML diagrams. The approach is based on deriving Object Net Models from UML statechart diagrams and connecting these object models based on UML collaboration diagram information. The resulting system-level Petri net model can be used as a foundation for formal Petri net analysis and simulation techniques. The methodology is illustrated on some small examples and a larger case study. The case study reveals some unexpected invalid system-state situations.

Version control, a fundamental component of Software Configuration Management (SCM) — a key mechanism for software development especially in large-scale systems — lacks a unified foundation for interchangeability, interoperability, and integrability. A practical solution of such problems is not readily achieved because version controls of different SCM systems employ various version models. Hence a single unified version model is required.

The work develops a single formalism to model major version control approaches as well as a prototype system. Its architecture is based on a federated SCM architecture and introduces a new SCM foundation which contains two layers: unified SCM representation and computation, based on the Resource Description Framework (RDF) and the Equivalent Transformation computational model, respectively. The evolution of software objects, their relationships as well as team cooperation strategies can be uniformly expressed under the representation layer. The computational layer is briefly mentioned for framework demonstration. Finally, a simple prototype system is presented.

It is generally accepted in the information system (IS) field that IS quality is highly dependent on the decisions made early in the development life cycle. The construction of conceptual data models is often an important task of this early development. Therefore, improving the quality of conceptual data models will be a major step towards the quality improvement of the IS development. Several quality frameworks for conceptual data models have been proposed, but most of them lack valid quantitative measures in order to evaluate the quality of conceptual data models in an objective way.

In this article we will define measures for the structural complexity (internal attribute) of entity relationship diagrams (ERD) and use them for predicting their maintainability (external attribute). We will theoretically validate the proposed metrics following Briand et al.'s framework with the goal of demonstrating the properties that characterise each metric. We will also show how it is possible to predict each of the maintainability sub-characteristics using a prediction model generated using a novel method for induction of fuzzy rules.

The objective of this work is to examine the feasibility of, as well as to learn about, a process of developing software architecture that prevents the possibility of mismatch between homogeneous components implemented according to the architectural specification. This paper shows how the architecture can be organized, which restrictions it can use and, provided that they are used, how elaborate it should be in order to ensure that independently-developed artifacts are structurally compatible. Two components are deemed structurally compatible as long as they have appropriate code to avoid mismatch. Since the focus of the paper is on the structural forms of mismatch, the results are derived under the assumption that no run-time environment can prevent a component from executing any path in its code. The paper develops a formal model of architecture that provides a minimal set of concepts in terms of which the designers can reason about incompatibility of components. The model is used to identify the causes of structural mismatch and examine alternative ways of eliminating these causes. Following that, the paper adopts a set of architectural restrictions and shows how these restrictions can be applied in the design of software architectures to prevent the possibility of structural mismatch.

Following the successful use of object-oriented metamodeling in the definition of the UML and other notation standards there is increasing interest in extending the approach to cover other concepts of software development, including processes. However, it turns out that the "obvious" approaches for using metamodels to describe processes and artifacts independently do not integrate well together in a natural and straightforward way. In this paper we discuss the problems and inconsistencies than can arise when trying to model a process and the products it creates within the same metamodeling framework, and present a solution that not only avoids many of these problems but also qualifies as a general metamodeling pattern. We then generalize the conceptual architecture to support the sound co-modeling of all independent areas of concern within the context of strict metamodeling.