Customer Relationship Management for SME's

Customer Relationship Management (CRM) is getting more and more a key strategy for companies big and small. Customer care strategy and CRM software go hand in hand. In particular SME's need a CRM software that easily adapts to their customer care needs while still being low cost. In this paper I discuss the benefits of CRM for SME's and their special requirements wrt.\ CRM software. Further, I introduce the IST-project CARUSO whose objective is to provide SME's with a software framework to implement low cost, customized CRM applications. This paper presents the rational behind the CARUSO project, the architecture of the framework, and the software development process used to build the framework.

Available: PDF

Extending Activity Diagrams to Model Mobile Systems

Mobile systems are gaining more and more importance, nevertheless the means for their specifications are still underdeveloped. Existing UML diagrams can be used to conveniently model behavior, but these diagrams can be hardly used to model mobility. In this paper we present an extension to UML class and activity diagrams to model mobile systems. We assume that mobile objects can migrate from one location to another. Locations can be nested and mobile too. We introduce stereotypes to model mobile objects, locations, and activities like moving or cloning. We introduce two notational variants of activity diagrams for modeling mobility. One variant is location centered and focuses on the topology of locations. The other one focuses on the actor responsible for an activity. We compare these two types of diagrams and define a metamodel for them.

Available: PDF

Using XP to develop a CRM framework

This paper describes our experiences with using XP practices within the EU-project CARUSO. The objective of CARUSO is the development of a framework for building customized Customer Relationship Management (CRM) applications. Originally, the project was planned with a traditional software development process in mind with a first prototype for evaluation by the customer and a second prototype building on the results of that evaluation. However, problems occurred defining the requirements for the framework for several reasons. First, our prime customer had only a vague understanding of how the software support for their CRM needs should look like, and second, CRM involves almost every business process in a company. To address these problems we used an agile software development process that allowed us to start from a simple CRM process (customer service), dividing it into user-stories, and clarifying the requirements on the framework as the user-stories were implemented.

Available: PDF

Applying Test-First Programming and Iterative Development in Building an E-Business Application

Software development for applications where time-to-market is critical has to cope with, among others, imprecise requirements and reliability of the resulting soft- ware. This paper describes the positive experiences with the techniques iterative development with small increments and test-first programming in developing software for a framework for building customized Customer Relationship Management (CRM) applications.

Available: PDF

OCL Component Invariants

The Object Constraint Language (OCL) offers a formal notation for constraining model elements in UML diagrams. OCL consists of a navigational expression language which, for instance, can be used to state invariants and pre- and post-conditions in class diagrams. We discuss some problems in ensuring non-local, navigating OCL class invariants, as for bidirectional associations, in programming language implementations of UML diagrams, like in Java. As a remedy, we propose a component-based system specification method for using OCL constraints, distinguishing between global component invariants and local class invariants.

Specifying Component Invariants with OCL

The Object Constraint Language (OCL) offers a formal notation for constraining model elements in UML diagrams. OCL consists of a navigational expression language which, for instance, can be used to state invariants and pre- and post-conditions in class diagrams. We discuss some problems in ensuring non-local, navigating OCL class invariants, as for bidirectional associations, in programming language implementations of UML diagrams, like in Java. As a remedy, we propose a component-based system specification method for using OCL constraints, distinguishing between global component invariants and local class invariants.

Available: PDF

CARUSO: Customer Care and Relationship Support Office

Customer Relationship Management (CRM) is an inherent business strategy for companies big and small. The technology has reached a point where it is truly enabling the way enterprises manage their customer relationships. The goal of the EU funded project CARUSO is the design of a software toolkit that facilitates the building and maintaining of high quality business-to-business and business-to-customer relationships. CARUSO is designed to allow a multi-dimensional way of looking at markets, customers, suppliers, products, personnel, internal and external information, communication and action flow. This will be accomplished by the following core features: front-office application builder with customer care and marketing desk, basic technologies comprising a general communication server, intelligent information, document and contact access, unified messaging, and a customizable user interface. Emphasis will be put on exploiting existing tool packages as much as possible. The CARUSO toolkit is targeted at European Small and Medium Sized Enterprises (SME) and allows them to optimize their business operations to the mutual benefit of both the supplier and the consumer.

Available: PDF

BABSy: Basic Agent Framework Billing System

The fast growing field of electronic commerce brings today's applications to their limits. Agents are now being used to further automate the purchase processes. Agents already support many stages of the buying cycle, but currently there is only little agent support for accounting and payment. In this paper we describe the design and implementation of BABSy, an accounting system that helps automate payment in an agent-based electronic commerce environment. The implementation was done using the FollowMe agent framework and was tested with the Event Notification pilot application.

Available: PDF

State-Based Extension of CASL

A state-based extension of the algebraic specification language CASL is presented. It permits the specification of the static part of a complex dynamic system by means of CASL and the dynamic part by means of the facilities described in the paper. The dynamic system is defined as possessing a number of states and a number of operations (procedures) for transforming one state into another. Each state possesses one and the same static part specified by CASL and a varying part specified by additional tools. The varying part includes dynamic sorts/functions/predicates and dependant functions/predicates. The dependant functions/predicates are specified by formulae using the names of the dynamic functions/predicates so that each time one of the last ones is updated the corresponding former ones are also updated. The updates of the dynamic entities are produced by procedures which are specified by means of preconditions, postconditions and dynamic equations.

Available: PDF

Relating Abstract Datatypes and Z-Schemata

In this paper we investigate formally the relationship between the notion of abstract datatypes in an arbitrary institution, found in algebraic specification languages like Clear, ASL and CASL; and the notion of schemata from the model-oriented specification language Z. To this end the institution S of the logic underlying Z is defined and a translation of Z-schemata to abstract datatypes over S is given. The notion of a schema is internal to the logic of Z and thus specification techniques of Z relying on the notion of a schema can only be applied in the context of Z. By translating Z-schemata to abstract datatypes these specification techniques can be transformed to specification techniques using abstract datatypes. Since the notion of abstract datatypes is institution independent, this results in a separation of these specification techniques from the specification language Z and allows them to be applied in the context of other, e.g. algebraic, specification languages.

Available: PDF

Towards a UML Extension for Hypermedia Design

The acceptance of UML as a de facto standard for the design of object-oriented systems, together with the explosive growth of the World Wide Web has raised the need for UML extensions to model hypermedia applications running on the Internet. In this paper we propose such an extension for modeling the navigation and the user interfaces of hypermedia systems. Similar to other design methods for hypermedia systems we view the design of hypermedia systems as consisting of three models: the conceptual, navigational and presentational model. The conceptual model consists of a class diagram identifying the objects of the problem domain and their relations. The navigational model describes the navigation structure of the hypermedia application by a class diagram specifying which navigational nodes are defined and an object diagram showing how these navigational nodes are visited. Finally, the presentational model describes the abstract user interface by composite objects and its dynamic behavior by state diagrams. Each model is built using the notations provided by the UML, applying the extension mechanism of the UML, i.e. stereotypes and OCL constraints, when necessary.

Available: PDF

Refinement using µ-Charts: The Compaq Grand Slam Cup Case Study Revisited

In practice, software systems are often developed on an ad hoc basis using at most some semi-formal diagrams to describe the desired system behavior. This often leads to systems with unintended behavior. One also lacks the means to prove properties of the system. On the other hand, a lot of formal specification formalisms exist that allow to specify a system in a formal way and prove properties of the system. However, these formalisms are considered as not applicable to real world software engineering by practitioners. In this paper, we try to refute this consideration by specifying a real world application, the Compaq Grand Slam Cup live scoring board, with µ-charts, a statecharts-like formal specification method.

Description Techniques for Distributed Hypermedia Systems

This report describes the modeling techniques used in the A2 project Distributed Systems in Open Networks. The notations used are based on the Unified Modeling Language and are defined using the extension mechanisms provided with the UML, i.e., stereotypes combined with OCL expressions. We use notations from the OOHDM, adapted to UML, to model hypermedia aspects of software systems. Component Event Diagrams, developed in A2, and Component Interface Diagrams, developed in A1, are used to model the decomposition of a software system into components, the interaction between and the behavior of components. To model the aspects related to the distributed implementation of a software systems the notations of YAON, adapted to UML, are used. Finally, we encourage the use of µ-charts, a statechart dialect developed in C3, as a replacement of UML statecharts, whenever possible, because of their formal semantics and the existence of a refinement calculus.

Relations between Abstract Datatypes modeled as Abstract Datatypes

In this thesis we define a framework for the specification of dynamic behavior of software systems. This framework is motivated by the state as algebra approach and the model-oriented language Z. From the state as algebra approach we use the idea of modeling the environment and the state components as structures of an institution. However, in contrast to the state as algebra approach, states in our framework are modeled by structures from any suitable institution not only those having of algebras as their structures. From Z we use the idea that environment, state spaces and relations between state spaces are specified using the same logic and how more complex relations can be constructed from simpler ones by means of the schema calculus. However, we differ from Z in that our framework can be instantiated by different institutions, while the approach of Z can only work because of the particular logical system used by Z.

Available: PDF

Relations as Abstract Datatypes: An Institution to Specify Relations between Algebras

One way to model the execution state of an imperative program is as a many sorted algebra. Program variables are modeled by functions and their types by sorts. The execution of a program is modeled by a relation between the states of the program (algebras) before and after the execution of the program. There are several methods to specify such relations between algebras. One method is to use specifications in the style of Z, VDM-SL or Larch. Specifications in Z of relations between states are first order formulas over the value of the variables comprising the state before and after an operation. In this paper we shall define an institution for the specification of relations between structures of some base institution (eg. the institution of equational logic or first order predicate logic). Sets of structures over a common signature, abstract datatypes, in this institution denote relations between structures of the base institution. This makes it possible to apply a rich repertoire of already existent techniques for specifying abstract datatypes, which can be found for example in the work of Goguen and Burstall, Sannella, Wirsing and Tarlecki, Ehrig, Pepper and Orejas and others, to the specification of relations. This paper tries to narrow the gap between algebraic specification languages like Clear, ASL or Act-One and model theoretic based specification languages like Z, VDM-SL or the Larch Interface language.

Available: PDF

Unifying Initial and Loose Semantics of Parameterized Specifications in an Arbitrary Institution

In this paper we are going to present a theory of parameterized abstract datatypes as the model-theoretic level of parameterized specifications. We will show that parameterized abstract datatypes allow us to model the main approaches to the semantics of parameterized specifications, the loose approach and the free functor semantics, using the same formalism. As a consequence we obtain that, when using data constraints in a specification language, this language is able to cope with both the loose and the free functor semantics at the same time. To be independent of a specific logic this theory is developed in the context of an arbitrary institution.

Available: PDF

Using Algebraic Specification Languages for Model-Oriented Specifications

It is common belief that there is a substantial difference between model-oriented (eg. Z and VDM) and algebraic specification languages (eg. LSL and ACT-ONE) wrt. their applicability to the specification of software systems. While model-oriented specification languages are assumed to be suited better for the description of state based systems (abstract machines), algebraic specification languages are assumed to be better for abstract datatype specifications. In this paper we shall demonstrate how an algebraic specification language (the Larch Shared Language) can be used to write specifications of abstract machines in the style of Z and how support tools for algebraic specification languages, eg. type checker and theorem provers, can be used to reason about abstract machines.

Available: PDF

Parameter Passing in the typed lambda-calculus approach to Parameterized Specifications

A problem with parameter passing in the typed lambda-calculus approach to parameterized specifications is that when applying a parameterized specification to an actual parameter the part of the signature that was not already present in the formal parameter is forgotten in the result. Thus if the parameterized specification "list of elements" is applied to the specification of the natural numbers it is not allowed to write head(l1) + head(l2) in the result, since, although + is an operation on the natural numbers, it is not an operation defined by the formal parameter of the list specification. In this paper we are going to define a parameter passing mechanism for the typed lambda-calculus approach that solves this problem.

Über die Stabilität parameterisierter algebraischer Spezifikationen (About the Stability of Parameterized Algebraic Specifications)

No abstract available.

Available: PDF