Architectures & Communication

Styles of Architecture

A style is:

• Replaceable components with well-defined interfaces
• The way components are connected to each other
• The data exchanged between components
• How components and connectors are jointly configured in a system

Layered

Relevant lecture

A monolithic architecture. Can also be considered tiered architecture. Layered architectures consist of a number of tiers / layers that perform a specific task in the system.

Each layer is independant from the rest of the system and interacts with the rest of the system through a well-defined interface, e.g. REST. It exposes its own functionality through a similar, abstract API.

In the above image, you can see layers making downcalls along with upcalls between layers.

A call can usually be met with a response associated with the call. However, upcalls should be generally avoided.

OSI Layered Model

7 Layers:

1. Physical
2. Data Link
3. Network
4. Transport
5. Session
6. Presentation
7. Application

Each layer is appended to a packet before being sent to the next

Examples of Layered Architecture

• Network Model
• Web Architecture Model

Advantages of Layered Architecture

• Allows open systems to communicate
• Well defined communication protocols allow a new service to be implemented with little additional work

Object-Based & Service Oriented

Each object refers to a component in a system. The components are connected through procedure calls. Works similar to a regular programming language:

class A {
  void DoSomething(B b) {
    b.DoSomethingElse();
  }
}

The interface is placed on the client, with the object placed on another machine. In this case, the object is a distributed object / remote object.

The client binds to the distributed object, copying the implementation of the object’s interface into a proxy loaded into the client.

class Client {
  Proxy proxy;

  public void Bind(DistributedObject obj) {
    // Get a copy of the interface's implementation
    proxy = obj.GetProxy();
  }

  public void Run() {
    Bind();
    proxy.CallSomeMethod(params);
  }
}

A proxy’s job is to marshall method invocation, and unmarshall their results. On the other end, a skeleton unmarshalls the data back into a method invocation with the same interface.

Service Oriented Architecture

An extension of Object-Based Architecture. An object is completely independent of everything else, and just acts to provide to a client.

Advantages of Object-Based Architecture

• Has a natural way of encapsulating data or object state.
• Interfaces conceal implementation details.
• Objects can be considered independent of their environment.
• A new object with the same interface should be able to replace an old one.

Disadvantages of Object-Based Architecture

• While the interface is distributed, the state is not. Only one machine holds the state of an individual object. Solved by using many small objects that communicate in a less dependent manner.

Resource-Centered

1. Resources are identified through a single naming scheme.
2. All services offer the same interface, consisting of at most four operations.
3. Messages sent to or from a service are fully self-described.
4. After executing an operation at a service, that component forgets everything about the caller.

Glossary

• Downcall: A call that goes down to the next layer in a layered architecture
• Upcall: A call that goes up to the previous layer in a layered architecture