Distribution and components

Slides:



Advertisements
Similar presentations
COM vs. CORBA.
Advertisements

A component- and message-based architectural style for GUI software
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 12 Slide 1 Distributed Systems Design 2.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 9 Distributed Systems Architectures Slide 1 1 Chapter 9 Distributed Systems Architectures.
Basic Concepts in Component-Based Software Engineering
1 Introduction to XML. XML eXtensible implies that users define tag content Markup implies it is a coded document Language implies it is a metalanguage.
8.
Technical Architectures
Distributed Systems Architectures
CS 501: Software Engineering Fall 2000 Lecture 16 System Architecture III Distributed Objects.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 12 Slide 1 Distributed Systems Architectures.
Software Engineering Module 1 -Components Teaching unit 3 – Advanced development Ernesto Damiani Free University of Bozen - Bolzano Lesson 2 – Components.
12-1 © Prentice Hall, 2004 Chapter 12: Design Elements Object-Oriented Systems Analysis and Design Joey F. George, Dinesh Batra, Joseph S. Valacich, Jeffrey.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 12 Slide 1 Distributed Systems Design 1.
QoS-enabled middleware by Saltanat Mashirova. Distributed applications Distributed applications have distinctly different characteristics than conventional.
©Ian Sommerville 2006Software Engineering, 8th edition. Chapter 12 Slide 1 Distributed Systems Architectures.
What is Enterprise Architecture?
1 소프트웨어공학 강좌 Chap 9. Distributed Systems Architectures - Architectural design for software that executes on more than one processor -
UNIT – II ARCHITECTING WEB SERVICES. WHAT ARE WEB SERVICES ? Web Services are loosely coupled, contracted components that communicate via XML-based interfaces.
©Ian Sommerville 2000 Software Engineering, 6th edition. Slide 1 Component-based development l Building software from reusable components l Objectives.
XML Web Services Architecture Siddharth Ruchandani CS 6362 – SW Architecture & Design Summer /11/05.
Service Oriented Architecture CCT355H5 Professor Michael Jones Suezan Makkar.
Distribution and components. 2 What is the problem? Enterprise computing is Large scale & complex: It supports large scale and complex organisations Spanning.
Chapter 2 Database System Concepts and Architecture Dr. Bernard Chen Ph.D. University of Central Arkansas.
CS 240, Prof. Sarwar Slide 1 CS 240: Software Project Fall 2003 Sections 1 & 2 Dr. Badrul M. Sarwar San Jose State University Lecture #23.
CS 501: Software Engineering Fall 1999 Lecture 12 System Architecture III Distributed Objects.
Design Reuse Earlier we have covered the re-usable Architectural Styles as design patterns for High-Level Design. At mid-level and low-level, design patterns.
Component Patterns – Architecture and Applications with EJB copyright © 2001, MATHEMA AG Component Patterns Architecture and Applications with EJB Markus.
Enterprise Computing Distribution and components.
1 SERVICE ORIENTED ARCHITECTURE ANTHONY GACHANGO D61/70547/2008 DIS 601.
Software Architecture Patterns (3) Service Oriented & Web Oriented Architecture source: microsoft.
A service Oriented Architecture & Web Service Technology.
CORBA Antonio Vasquez, John Shelton, Nidia, Ruben.
1 Distributed Systems Architectures Distributed object architectures Reference: ©Ian Sommerville 2000 Software Engineering, 6th edition.
12. DISTRIBUTED WEB-BASED SYSTEMS Nov SUSMITHA KOTA KRANTHI KOYA LIANG YI.
Distributed Systems Architectures Chapter 12. Objectives  To explain the advantages and disadvantages of different distributed systems architectures.
Distributed Systems Architectures. Topics covered l Client-server architectures l Distributed object architectures l Inter-organisational computing.
J2EE Platform Overview (Application Architecture)
Chapter 12: Architecture
Prototyping in the software process
Object Oriented Programming
N-Tier Architecture.
Chapter 2 Database System Concepts and Architecture
Principles of Network Applications
Java Beans Sagun Dhakhwa.
Software Connectors.
Distributed web based systems
CSC 480 Software Engineering
Software Quality Engineering
#01 Client/Server Computing
Ch > 28.4.
Inventory of Distributed Computing Concepts and Web services
Service-centric Software Engineering
Ch 15 –part 3 -design evaluation
Lecture 4: RPC Remote Procedure Call Coulouris et al: Chapter 5
Inventory of Distributed Computing Concepts
Chapter 12: Physical Architecture Layer Design
Service Oriented Architecture (SOA)
Chapter 40 Remote Method Invocation
Lecture 4: RPC Remote Procedure Call CDK: Chapter 5
Software Connectors.
An Introduction to Software Architecture
SAMANVITHA RAMAYANAM 18TH FEBRUARY 2010 CPE 691
Chapter 46 Remote Method Invocation
Chapter 46 Remote Method Invocation
Chapter 5 Architectural Design.
Distributed System using Web Services
Distributed Systems Architectures
#01 Client/Server Computing
Presentation transcript:

Distribution and components Enterprise Computing Distribution and components

Distribution

The solution Therefore you need to be able breakdown applications into units which Can be separately maintained and evolved Can be recombined to address new business problems. Can effectively use ‘bought in’ software and customised for a individual organisation. Services can be reused for new applications Can be distributed across servers in multiple locations if required. What technology and architectures are required to do this? Writing it all is difficult and requires the rare technical skills.

Class Exercise Two applications A and B Each running on its own server. A cable links the two servers. Describe the software required to allow application A to invoke a block of code in application B, and receive and successfully interpret the returning message from A.

Solution: A mechanism for communicating between the units of code. Should be independent of the language the unit is written in. Should be independent of location or network. A mechanism to locate where the other unit of code is located.

Exercise I What do you need to ensure that each unit Can be separately maintained and evolved Can be recombined to address new business problems. Can effectively use ‘bought in’ software and customised for a individual organization. Services can be reused for new applications Can be distributed across servers in multiple locations if required.

Distributed architecture: Interfaces An interface is A specification of its access point, offering no implementation details for any of its operations. A contract between the provider of the interface and any client requiring its services defined by the messages that are exchanged and data passed between the client and the server. This separation (loose coupling) makes it possible to: Replace the implementation part without changing the interface; Add new interfaces (and implementations) without changing the existing implementation,

Interfaces: Limitations Sufficient in describing functional properties. i.e. How the function is called and the data returned Does not provide an explanation of the what capabilities the interface provides. Does not describe extra-functional properties such as quality attributes like accuracy, availability, latency, security, etc. These must be delivered by the environment. 8

Distributed architecture: Need for late binding Embedding the precise location of a resource in code reduces the flexibility of the overall system Using a name which is then resolved into the resource at run-time (known as late binding) allows the resources to be changed to support Load balancing Migration of the resource from one location to another Replacement of the resource In the context of a distributed architecture, the name specifies the interface and any additional attributes required

Distributed architecture: Location service A location service receives a request containing a resource name and returns one or more locations where the resource is available Location services are a subset of naming services and typically referred to simply as naming services A naming service is a commonly used architectural principle, examples include DNS

Distributed architecture: Protocol Once a server has been identified supporting the interface... = A resource matching the name A protocol must be agreed to exchange information In most distributed architectures, there is a single base protocol that is supported by all systems participating in the architecture The information exchanged is typically messages reflecting the structure of the interface The protocol supports the invocation of functions on the interface and returning of values

Implementing a distributed architecture A distributed architecture defines the three elements Interface, location service and protocol Implementations of an architecture will provide toolkits and libraries to automatically generate the middleware code related to the interfaces and protocol Implementations also provide services to provide location service Enterprise grade distributed architectures also include enterprise services such as transactionality, security etc.

Implementing a distributed architecture Client-Side Network Middle Tier connect to remote object invokes Skeleton Stub invoke Client Server-Side code return results return results return results Stub and Skeleton are typically auto-generated in a distributed system; client “thinks” its making a local call, most networking details are hidden from client; the main detail is obtaining a reference to the remote object naming service

Components

Characteristics of a component Described completely by: A set of interfaces provided to other components A set of requirements from the environment. An executable code, which can be coupled to the code of other components via interfaces. To improve the component quality, the following elements can be included in the specification of a component: The specification of non-functional characteristics, The validation code, Additional information.

Objects and Components The distinction between objects and components is at the conceptual level: Components can be implemented using objects or any other methodology. A component as a collection of objects, in which the objects co-operate with each other, and are intertwined tightly. Components are architectural level entities Components are often larger units of granularity than objects, and have complex actions at their interfaces. Components often rely on environmental services Persistent storage whereas objects have local state.

Software Frameworks Software is built by "putting pieces together". Frameworks provide the context in which the pieces can be used. A framework may be seen as: A reusable design of a system, A skeleton of an application which can be customised by an application developer.

Coordination Services (transactions, persistence..) Component Frameworks Frameworks in general describe a typical and reusable situation at a model level, A component framework describes a “circuit-board” with empty slots into which components can be inserted to create a working instance. Component Framework Coordination Services (transactions, persistence..)

Component Models The two concepts Component Models and Component Frameworks are sometimes intermixed. A component model defines a set of standards and conventions used by the component developer whereas a component framework is a support infrastructure for the component model. Component model

Relationships Between Concepts Interface that satisfies contracts Component-type Specific interface Component implementation Independent deployment Component model Component Framework Coordination Services (transactions, persistence..)

Components and frameworks Component specifications are essential for component users who are focused on the component features, functional and non-functional The main purpose of frameworks is to support the process of component composition Component developers must obey the rules and formats specified by the framework to develop and to specify the component, while component users will use frameworks to compose systems from components in a more efficient and accurate way.