699 research outputs found
Working notes of the KI \u2796 Workshop on Agent Oriented Programming and Distributed Systems
Agent-oriented techniques are likely to be the next significant breakthrough in software development process. They provide a uniform approach throughout the analysis, design and implementation phases in the development life cycle. Agent-oriented techniques are a natural extension to object-oriented techniques, but while there is a whole pIethora of analysis and design methods in the object-oriented paradigm, very little work has been reported on design and analysis methods in the agent-oriented community. After surveying and examining a number of well-known object-oriented design and analysis methods, we argue that none of these methods, provide the adequate model for the design and analysis of multi-agent systems. Therefore, we propose a new agent-specific methodology that is based on and builds upon object-oriented methods. We identify three major models that need to be build during the development of multi-agent applications and describe the process of building these models
The advantages and cost effectiveness of database improvement methods
Relational databases have proved inadequate for supporting new classes of
applications, and as a consequence, a number of new approaches have been taken
(Blaha 1998), (Harrington 2000). The most salient alternatives are denormalisation
and conversion to an object-oriented database (Douglas 1997). Denormalisation
can provide better performance but has deficiencies with respect to
data modelling. Object-oriented databases can provide increased performance
efficiency but without the deficiencies in data modelling (Blaha 2000).
Although there have been various benchmark tests reported, none of these
tests have compared normalised, object oriented and de-normalised databases.
This research shows that a non-normalised database for data containing type
code complexity would be normalised in the process of conversion to an objectoriented
database. This helps to correct badly organised data and so gives the
performance benefits of de-normalisation while improving data modelling.
The costs of conversion from relational databases to object oriented databases
were also examined. Costs were based on published benchmark tests, a
benchmark carried out during this study and case studies. The benchmark tests
were based on an engineering database benchmark. Engineering problems such as
computer-aided design and manufacturing have much to gain from conversion to
object-oriented databases. Costs were calculated for coding and development, and
also for operation. It was found that conversion to an object-oriented database was
not usually cost effective as many of the performance benefits could be achieved
by the far cheaper process of de-normalisation, or by using the performance
improving facilities provided by many relational database systems such as
indexing or partitioning or by simply upgrading the system hardware.
It is concluded therefore that while object oriented databases are a better
alternative for databases built from scratch, the conversion of a legacy relational
database to an object oriented database is not necessarily cost effective
A Method for Consistent Non-Local Configuration of Component Interfaces
Service-oriented computing is a popular technology that facilitates the development
of large-scale distributed systems. However, the modular composition and flexible
coordination of such applications still remains challenging for the following reasons: 1)
the services are provided as loosely coupled black boxes that only expose their interfaces
to the environment; 2) interacting services are not usually known in advance: web
services are dynamically chosen to fulfil certain roles and are often replaced by services
with a similar functionality; 3) the nature of the service-based application is decentralised.
Loose coupling of web services is often lost when it comes to the construction of an
application from services. The reason is that the object-oriented paradigm, which is
widely used in the implementation of web services, does not provide a mechanism for
service interface self-tuning. As a result, it negatively impacts upon the interoperability
of web services.
In this dissertation we present a formal method for automatic service configuration in
the presence of subtyping, polymorphism, and flow inheritance. This is a challenging
problem. On the one hand, the interface description language must be flexible enough to
maintain service compatibility in various contexts without any modification to the service
itself. On the other hand, the composition of interfaces in a distributed environment must
be provably consistent.
Our method is based on constraint satisfaction and Boolean satisfiability. First, we
define a language for specifying service interfaces in a generic form, which is compatible
with a variety of contexts. The language provides support for parametric polymorphism,
Boolean variables, which are used to control dependencies between any elements of
interface collections, and flow inheritance using extensible records and variants. We
implemented the method as a constraint satisfaction solver.
In addition to this, we present a protocol for interface configuration. It specifies a
sequence of steps that leads to the generation of context-specific service libraries from
generic services. Furthermore, we developed a toolchain that performs a complete
interface configuration for services written in C++. We integrated support for flexible
interface objects (i.e. objects that can be transferred in the application along with their
structural description). Although the protocol relies solely on interfaces and does not
take behaviour concerns into account, it is capable of finding discrepancies between
input and output interfaces for simple stateful services, which only perform message
synchronisation. Two running examples (a three buyers use-case and an image processing
application) are used along the way to illustrate our approach.
Our results seem to be useful for service providers that run their services in the
cloud. The reason is twofold. Firstly, interfaces and the code behind them can be
generic as long as they are sufficiently configurable. No communication between service
designers is necessary in order to ensure consistency in the design. Instead, the interface
correspondence in the application is ensured by the constraint satisfaction algorithm,
which we have already designed. Secondly, the configuration and compilation of every
service are separated from the rest of the application. This prevents source code leaks in
proprietary software which is running in the cloud
Detecting and correcting errors in parallel object oriented systems
Our research concerns the development of an operational formalism for the in-source specification of parallel, object oriented systems. These specifications are used to enunciate the behavioural semantics of objects, as a means of enhancing their reliability. A review of object oriented languages concludes that the advance in language sophistication heralded by the object oriented paradigm has, so far, failed to produce a commensurate increase in software reliability. The lack of support in modern object oriented languages for the notion of 'valid object behaviour', as distinct from state and operations, undermines the potential power of the abstraction. Furthermore, it weakens the ability of such languages to detect behavioural problems, manifest at run-time. As a result, in-language facilities for the signalling and handling of undesirable program behaviours or states (for example, assertions) are still in their infancy. This is especially true of parallel systems, where the scope for subtle error is greater. The first goal of this work was to construct an operational model of a general purpose, parallel, object oriented system in order to ascertain the fundamental set of event classes that constitute its observable behaviour. Our model is built on the CSP process calculus and uses a subset of the Z notation to express some aspects of state. This alphabet was then used to construct a formalism designed to augment each object type description with the operational specification of an object's behaviour: Event Pattern Specifications (EPS). EPSs are a labeled list of acceptable object behaviours which form part of the definition of every type. The thesis includes a description of the design and implementation of EPSs as part of an exception handling mechanism for the parallel, object oriented language Solve. Using this implementation, we have established that the run-time checking of EPS specifications is feasible, albeit it with considerable overhead. Issues arising from this implementation are discussed and we describe the visualization of EPSs and their use in semantic browsing
An incremental prototyping methodology for distributed systems based on formal specifications
This thesis presents a new incremental prototyping methodology for formally specified distributed systems. The objective of this methodology is to fill the gap which currently exists between the phase where a specification is simulated, generally using some sequential logical inference tool, and the phase where the modeled system has a reliable, efficient and maintainable distributed implementation in a main-stream object-oriented programming language. This objective is realized by application of a methodology we call Mixed Prototyping with Object-Orientation (in short: OOMP). This is an extension of an existing approach, namely Mixed Prototyping, that we have adapted to the object-oriented paradigm, of which we exploit the flexibility and inherent capability of modeling abstract entities. The OOMP process proceeds as follows. First, the source specifications are automatically translated into a class-based object-oriented language, thus providing a portable and high-level initial implementation. The generated class hierarchy is designed so that the developer may independently derive new sub-classes in order to make the prototype more efficient or to add functionalities that could not be specified with the given formalism. This prototyping process is performed incrementally in order to safely validate the modifications against the semantics of the specification. The resulting prototype can finally be considered as the end-user implementation of the specified software. The originality of our approach is that we exploit object-oriented programming techniques in the implementation of formal specifications in order to gain flexibility in the development process. Simultaneously, the object paradigm gives the means to harness this newly acquired freedom by allowing automatic generation of test routines which verify the conformance of the hand-written code with respect to the specifications. We demonstrate the generality of our prototyping scheme by applying it to a distributed collaborative diary program within the frame of CO-OPN (Concurrent Object-Oriented Petri Nets), a very powerful specification formalism which allows expressing concurrent and non-deterministic behaviours, and which provides structuring facilities such as modularity, encapsulation and genericity. An important effort has also been accomplished in the development or adaptation of distributed algorithms for cooperative symbolic resolution. These algorithms are used in the run-time support of the generated CO-OPN prototypes
Cohesion Metrics for Improving Software Quality
Abstract
Software product metrics aim at measuring the quality of software. Modu-
larity is an essential factor in software quality. In this work, metrics related
to modularity and especially cohesion of the modules, are considered. The
existing metrics are evaluated, and several new alternatives are proposed.
The idea of cohesion of modules is that a module or a class should consist
of related parts. The closely related principle of coupling says that the
relationships between modules should be minimized.
First, internal cohesion metrics are considered. The relations that are
internal to classes are shown to be useless for quality measurement. Second,
we consider external relationships for cohesion. A detailed analysis using
design patterns and refactorings confirms that external cohesion is a better
quality indicator than internal. Third, motivated by the successes (and
problems) of external cohesion metrics, another kind of metric is proposed
that represents the quality of modularity of software. This metric can be
applied to refactorings related to classes, resulting in a refactoring suggestion
system.
To describe the metrics formally, a notation for programs is developed.
Because of the recursive nature of programming languages, the properties of
programs are most compactly represented using grammars and formal lan-
guages. Also the tools that were used for metrics calculation are described.Siirretty Doriast
Working notes of the KI '96 Workshop on Agent Oriented Programming and Distributed Systems
Agent-oriented techniques are likely to be the next significant breakthrough in software development process. They provide a uniform approach throughout the analysis, design and implementation phases in the development life cycle. Agent-oriented techniques are a natural extension to object-oriented techniques, but while there is a whole pIethora of analysis and design methods in the object-oriented paradigm, very little work has been reported on design and analysis methods in the agent-oriented community. After surveying and examining a number of well-known object-oriented design and analysis methods, we argue that none of these methods, provide the adequate model for the design and analysis of multi-agent systems. Therefore, we propose a new agent-specific methodology that is based on and builds upon object-oriented methods. We identify three major models that need to be build during the development of multi-agent applications and describe the process of building these models
Working notes of the KI '96 Workshop on Agent Oriented Programming and Distributed Systems
Agent-oriented techniques are likely to be the next significant breakthrough in software development process. They provide a uniform approach throughout the analysis, design and implementation phases in the development life cycle. Agent-oriented techniques are a natural extension to object-oriented techniques, but while there is a whole pIethora of analysis and design methods in the object-oriented paradigm, very little work has been reported on design and analysis methods in the agent-oriented community. After surveying and examining a number of well-known object-oriented design and analysis methods, we argue that none of these methods, provide the adequate model for the design and analysis of multi-agent systems. Therefore, we propose a new agent-specific methodology that is based on and builds upon object-oriented methods. We identify three major models that need to be build during the development of multi-agent applications and describe the process of building these models
- …