Farhad Mavaddat

A graph-based approach to Web services composition

Automatic composition of Web services has drawn a great deal of attention recently. By composition, we mean taking advantage of currently existing Web services to provide a new service that does not exist on its own. Therefore, in order to have a more complex service, we can use some semantically related simpler Web services and execute them in such a way that the whole set provides the desired service. There are Web service specification languages that specify semantic properties of Web services. These languages are helpful in searching for those Web services that can participate in a composition. This work is aimed at searching among Web services in order to find those whose composition provides a specific behavior. Those Web services found after this search are incrementally composed together to build a new service that realizes that behavior. Our technique takes advantage of graph structures and also a particular formalism called interface automata.

A Graph-Based Framework for Composition of Stateless Web Services

During the past few years, Web services composition has been one of the ongoing research activities in the software engineering area. It is simply defined as finding a composition of available Web services that provides a requested behavior. In this paper, we study this problem for stateless Web services; i.e., Web services with a two-step workflow: receiving some inputs and returning some outputs as the result. Using a graph model we represent the behavior of available Web services in terms of their input-output information, as well as semantic information about the Web data. We also introduce a process algebra to specify the behavior of composite Web services based on the behavior of simpler ones. Using the graph and the process algebra, we explain how to find useful Web services for a request and how to compose them to obtain the expected behavior. We discuss the complexity of this approach and show that although it is a naturally complex process, by applying some simplifications, a reasonable overall complexity can be achieved

Architectural design recovery using data mining techniques

The paper presents a technique for recovering the high level design of legacy software systems according to user defined architectural plans. Architectural plans are represented using a description language and specify system components and their interfaces. Such descriptions are viewed as queries that are applied on a large database which stores information extracted from the source code of the subject legacy system. Data mining techniques and a modified branch and bound search algorithm are used to control the matching process, by which the query is satisfied and query variables are instantiated. The matching process allows the alternative results to be ranked according to data mining associations and clustering techniques and, finally, be presented to the user.

A pattern matching framework for software architecture recovery and restructuring

The paper presents a framework for software architecture recovery and restructuring. The user specifies a high level abstraction view of the system using a structured pattern language. A pattern matching engine provides an optimal match between the given pattern and a decomposition of the legacy system entities by satisfying the inter/intramodule constraints defined by the pattern. The data mining technique Apriori is used by the matching engine to reveal meaningful data and control flow properties of the target system and limit the search space. A branch and bound search algorithm using a score function, models the constraints in the pattern as a Valued Constraint Satisfaction Problem (VCSP), and assists in searching for an optimal match between the given pattern and the target system.

Towards an Automated Deployment Planner for Composition of Web Services as Software Components

Abstract In this paper, we present our work-in-progress on developing an automated deployment planner for the composition of Web services as software components using the Reo coordination middleware in a distributed environment. Web services refer to accessing services over the Web. Reo is an exogenous coordination model for compositional construction of component connectors based on a calculus of mobile channels that has been developed at CWI (the Netherlands). Reo has a strong theoretical underpinning which makes it a good candidate model for coordinating the work of Web services participating in a composition. Suppose a new Web application has been developed by composing a number of Web services with different requirements and constraints. To run the application, it is required to deploy it on a number of hosts with different computational capabilities available to the application in the distributed environment (e.g., Internet) so that all constraints and requirements are satisfied. Because of the many parameters and constraints in such a deployment problem, it is difficult to do it manually. Thus, an automated deployment planner is required for this purpose.

Reliable Deployment of Component-based Applications into Distributed Environments

Software deployment process is a sequence of related activities for installing an already developed application into its target environment, and bringing it into an executing state. For complex component-based applications that should be deployed into a large distributed environment, several deployment configurations are typically possible. These deployment configurations can have significant impacts on the applications quality of service properties such as reliability. In distributed systems, the reliability of the application is highly dependent on the reliability of its network, and network failures can have adverse effects on the applications reliability. Thus, one possible way to increase the reliability of a distributed component-based application is to deploy it so that the communications among its components are done as local as possible. In this paper, a graph-based deployment planning approach is proposed for this purpose

Interface Automata with Complex Actions

Many formalisms use interleaving to model concurrency. To describe some system behaviours appropriately, we need to limit interleaving. For example, in component-based systems, we wish to limit interleaving to force the inputs to a method to arrive together in order. We introduce interface automata with complex actions (IACA), which add complex actions to de Alfaro and Henzingers interface automata (IA). A complex action is a sequence of actions that may not be interleaved with actions from other components. The composition and refinement operations are more involved in IACA compared to IA, and we must sacrifice associativity of composition. However, we argue that the advantages of having complex actions make it a useful formalism.

Experiments with an efficient heuristic algorithm for local microcode generation

A local microcode generation method for a control-unit synthesis is presented. The register-transfer behavior of a data path is specified by a dTOL system (an L-system-type parallel formal language), and local microcode generation is formulated as a parsing problem of the corresponding DTOL language. The authors propose an efficient, goal-oriented, search algorithm to parse a behavioral specification, and discuss several heuristics for improving the performance of the method. Five data paths, designed by well-known synthesis tools, were used to study the performance of the method. The results of the study and some problems arising in a few of the designs are discussed.<<ETX>>

Another experiment with teaching of programming languages

The key issue in successful teaching is that of keeping the interest of students alive. In a first course on computer programming, this can be achieved by presenting interesting problems of reasonable complexity early in the course. This is often a difficult task, as most of the common programming languages used for instruction are intangible and therefore cumbersome to master before any serious programming may start.Here a simple and tangible programmable machine is introduced. It is shown that important programming concepts can be defined and exercised in terms of possible operations on this machine. It is also shown that a seemingly difficult problem can be solved by novice programmers within the first few sessions of an introductory course.

Deploying loosely coupled, component-based applications into distributed environments

With significant advances in software development technologies in recent years, it is now possible to have complex software applications, which include a large number of heterogeneous software components distributed over a large network of computers with different computational capabilities. To run such applications, their components must be instantiated on proper hardware resources in their target environments so that some requirements and constraints are met. This process is called software deployment. For large, distributed, component-based applications with many constraints and requirements, it is difficult to do the deployment process manually, and some automated tools and techniques are required. This paper presents a graph-based approach for this purpose that is not dependent on any specific component technology and does the deployment planning with respect to the communication resources required by application components and communication resources available on the hosts in the target environment. In our approach, component-based applications and distributed environments are modeled with the help of graphs. Deployment of an application is then defined as the mapping of the application graph to the target environment graph