Architectural Description Languages - Comparative Analysis of Acme and Wright

ACME:

ACME was developed jointly by Monroe, Garlan (CMU) and Wile (USC). It is a small and rather simple language. It holds the concepts system, component, connector, port, role and representation.

ACME provides a template mechanism, which can be used for abstracting common reusable architectural idioms and patterns. ACME allows defining user specified constraints on architecture elements to model patterns.

Example:

System simple_cs = {

     Component client = {Port send-request}

     Component server = {Port receive-request}

     Connector rpc = {Roles {caller, called}}

     Attachments : {client.send-request to rpc.caller;

     server.receive-request to rpc.called}

}

Wright:

Wright was developed by Dr. David Garlan at Carnegle Mallon University. This language deals with checking component interactions through their interfaces. The models include components, connectors, ports, roles (interfaces), attachments, and styles

Rich connector support in Wright makes it a good option for patterns that heavily rely on connector and protocol specifications. Wright provides connector protocols as roles and glues, where glues can be used to define and constrain the behavior of interacting components

Elements:

Components, connectors, interfaces, attachments, styles

Components:

computation elements with multiple ports.

Connectors:

Roles and Glue

Example:

System simple_cs

   Component client = port send-request  = [behavioral spec]

         spec =  [behavioral spec]

  Component server = port receive-request= [behavioral spec]

         spec = [behavioral spec]

  Connector rpc = role caller = (request!x -> result?x ->caller) ^  STOP

         role called = (invoke?x -> return!x -> called) [] STOP

glue =  (caller.request?x -> called.invoke!x
       -> called.return?x -> called.result!x

             -> glue) [] STOP

Instances

s : server

c : client

r : rpc

Attachments:

client.send-request as  rpc.caller

server.receive-request as  rpc.called

end simple_cs.

Table: Syntax Support for Patterns in the ADLs

ADLs	Client-Server	Pipe-Filter	Layers
ACME	Strength: ACME can be used to express client-server components and configuration constraints for defining communication links and topologies	Strength: ACME is used to express filters, pipes and data flow links	Strength: ACME can be used to express grouping among components
Wright	Strength: Compatibility checking of clients and server is well supported, Deadlock detection is addressed by the use of roles and glues, allows complex topologies, reconfiguration supported, dynamism supported. Weakness: Topological constraints not explicitly addressed	Strength: Wright provides roles and glue support for expressing pipes and to define data flow connections among filters	Strength: Roles and glue specification can be used to express layered information flow constraints