*   more discussion of Component and Connector sw arch views...

    *   components - computational elements or data stores
    *   connectors - means of interaction between the components

    *   a C&C view defines the components,
        and which components are connected through which connector

        a C&C view describes a runtime structure of the system --
	which components exist at run time, and how they interact
	during execution

*   components -
    *   each has a name, representing its role, and providing
        its identity

    *   may have a type (with different types rep'd by different
        shapes)

*   connectors -
    *   interaction between components happens through connectors

    *   may be provided by the runtime environment,
        or by complex mechanisms for interaction (http, tcp/ip, ports,
	    etc.) may require their own sw to support

    *   choice of connector may affect how you choose to	
        implement a component -- SO, it is important to
	identify connectors explicitly

    *   connectors are often binary, but need not necessarily be -- 
        ...e.g., a broadcast bus, multiplexer

    *   connectors also have a name and a type

    *   often connectors are represented as a protocol --
        conventions components need to follow when using a
	connector

    *   best to use different notations for different types
        of connectors (not all solid straight lines)

*   some C&C views occur frequently enough that they
    are considered GENERAL structures useful
    for whole classes of problems --

    these, in Jalote, are called architectural styles

    (and can be combined in a given system's C&C diagram)

    ...think of them as developing your architectural
    vocabulary/toolbox!

    *   here are a FEW of these:
        *   pipe and filter
            *   one component type: filter
	    *   one connector type: pipe

        *   shared-data style
            *   data repository,	
	        one or more data accessors

            *   in "classic/strict" definition,
	        data accessors communicate with
		data accessors ONLY through the
		shared repository
 
            *   black board style - if data is posted in a
	        repository, all accessors are informed
		(shared datasource is an ACTIVE agent)

		RSS? maybe?

	    *   repository style - data repository is
	        passive, new data is posted, but accessors
		have to request data

        *   client-server style
            *   two component types: clients and servers!

            *   very classic/strict view:
	        clients can communicate only with servers,
		not other clients;

            *   communication is initiated by a client
	        which sends a request to a server, and the server
                responds with a response

            *   one connector type:
	        request/reply, which is asymmetric

...more classic C&C architectural styles on Thursday;