SE 501 Software Development
Processes
Dr. Basit Qureshi
College of Computer Science and Information Systems
Prince Sultan University
Lecture for Week 13
Contents
•
•
•
•
•
•
Motivation: Why Software re-use
Re-use of Software
What is Component
Building Components
Erlang: Distributed component development
Middleware & Web services framework
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Bibliography
• Roger Pressman, Software Engineering: A practitioners approach, MC
GrawHill, 2009.
• Lars-°Ake Fredlund, Course on Component based Software at Madrid
Polytech University: Last access October 2012.
• Ian Sommerville, Software Engineering, 9th edition, Addison Wesley, 2010.
• Erlang programming language: http://www.erlang.org/
SE 501 Dr. Basit Qureshi: Lecture for Week 13
MOTIVATION: WHY RE-USE
SOFTWARE
SE 501 Dr. Basit Qureshi: Lecture for Week 13
SE 501 Dr. Basit Qureshi: Lecture for Week 13
SE 501 Dr. Basit Qureshi: Lecture for Week 13
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
• Increasingly modern applications are using configurable
components
• Classic argument: Cost of software development
– need to re-use software to reduce costs
– better to buy off-the-shelf than re-implementing
• More reliable software
– more reliable to reuse software than to create
– system requirements can force use of certified components (car
industry, aviation, . . . )
• Emergence of a component marketplace
– Apple’s App Store, Android Market, . . .
• Emergence of distributed and concurrent systems we
need to build systems composed of independent parts, by
necessity
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
Trends in SW design:
• Concurrency – multiple activities at the same time
• Distribution – multiple activities at the same time, at
different locations
Today component frameworks needs to address concurrency
and distribution because of
• Hardware developments: microprocessors with many
cores
– (Intel quad –4– cores..., ARM processors for mobile phones)
Leading to renewed interest in concurrent programming
• Software developments: Web services communicate to
offer composite services (business processes) Distribution
and fault tolerance to handle 24/7 availability
requirements
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
Some History (towards component-based software)
• Distributed systems
• Open systems
• The problem of re-use
• Evolution of programming models (including web)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
Distributed Systems: Concurrent programs executing on
different hosts that do not share memory
• Different communication mechanisms: message
passing, RPC (remote procedure calls), . . .
• Typically systems that are online 24/7
• Reliability and fault tolerance is a key concern:
hardware and software will fail, network links will fail,
software has to recover from failures
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
Open Systems
• Distributed systems consisting of heterogeneous programs
• Programs programmed in different languages, running under
different operating systems, . . .
• Some programs already exists (legacy systems)
• Other programs enter and leave the system during its execution
• Example: a Java based system accepting a new applet:
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
OpenDoc: one of the first component-based
systems
• Document centric: no main application exists,
the document is the central information store
(compare Linda)
• Compositional: documents are composed
from (possibly) distributed elements that
themselves may be documents
• Document elements can be active entities.
Every element item has an editor
(application) associated with it.
• Created at Apple in the 1990s (compare
Microsoft OLE)
• Very ambitious goals: difficult to realize then
and probably even today (compare the state
of web browsers/servers)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
Mash up web
applications
• “A web application
that combines data
from external
sources to create a
new service”
• Example: a
customized google
page:
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• The age-old problem in software industry: how to reuse
software
• At the most basic level: source code reuse
• Old solution example: reuse of code for regular expressions
evaluation in UNIX (replicated in many applications: grep, bash,
sed, . . . )
• Advantages:
– Good productivity
– Consistency (regular expressions work the same)
– No need to test re-used software pieces
• Everything is reused (analysis, design, code, documentation)
• Normally put in code libraries
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• Disadvantages: Problems with re-use at the source
code library level:
– When a library is modified one has to recompile and relink
all applications making use of the library piece
– Hard to maintain different library versions for different
applications
– Difficult to sell
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• Binary Libraries:
– No need to recompile and relink applications upon library change
(dynamic libraries)
– Easier to sell (no need to distribute code)
But:
– Because of weak interfaces (at most type checked) it is difficult to
know what impact a library change has on the corresponding
application (we have to test and test and test. . . )
– Difficult to have cross-language libraries (although works to some
extent. . . )
– Binaries usable on one (processor, OS) architecture only
– The result will be multiple library versions in a running system
(hard to maintain)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• Binary Libraries: Intermediate Code
– A common solution to the problem of binary compatibility is to
use intermediate code instead of native (Intel X86) machine code
– A compiler translate a high-level programming language to
intermediate code (not specific to the target architecture)
– An abstract machine (virtual machine) executes intermediate code
(probably somewhat specific to the target architecture)
– Example of languages that use such an implementation strategy:
Java (Java Virtual Machine), C#, Erlang
– Using an abstract machine technology can be a way in which to
permit multiple languages to communicate: example CRL
(Common Language Runtime) for C#
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• Natural evolution:
–
–
–
–
Module-based programming (Modula)
Object-oriented programming (Java,C++)
Aspect-oriented programming (AspectJ)
Component-based programming (WWW example)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• Object-oriented programming (Java,C++)
– Abstract machine technology: Java Virtual Machine (JVM)
– Applets: small Java applications that can be sent between
computers, and executed at the receiving side
– Applets: small Java applications that can be sent between
computers, and executed at the receiving side
– Different security models for applets:
• Applets are put in a sandbox, where they cannot harm the host (so
can only do limited actions)
• Applets come with a (behavior) certificate issued by some authority
(which one can trust or not)
• Applets come with a description of their behavior, and a checkable
proof of compliance (proof-carrying code)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• Aspect-oriented programming
– Programs are decomposed into different aspects, each
aspect responsible for one requirement (security, logging,
fault-tolerance, concurrency, . . . )
– The aspects can be largely independently developed,
sometimes even in different programming languages
– Weaver: the task of combining different aspects into a whole
program
– Attractive development model but still not very mature
– Example: AspectJ for aspect-oriented programming in Java
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
How to re-use software
• WWW for component-based programming
– First WWW generation: documents published using
HTTP/HTML
– Second generation: dynamic generation of documents, using
forms and databases (CGI)
– Third generation: everything is part of the Web
• Data is structured in a standard way (XML)
• Documents become (web) services
• Web services become accessible by other (web) services
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Motivation: Why Re-use software
SE 501 Dr. Basit Qureshi: Lecture for Week 13
WHAT IS A COMPONENT
SE 501 Dr. Basit Qureshi: Lecture for Week 13
What is a Component
Properties of a Component:
• Encapsulated i.e., with well defined interfaces and with an
unknowable interior
• Compose-able with other components (using a well establish
composition mechanism)
• Multiple-use (i.e., not a restricted resource)
• Not context dependent (usable in multiple systems)
• A unit of independent deployment and versioning
(independent of other components)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
What is a Component
Fundamental Concepts
• Component interface: describes the operations (method calls,
messages, . . . ) that a component implements and that other
components may use
• Composition mechanism: the manner in which different
components can be composed to work together to accomplish
some task. For example, using message passing
• Component platform: A platform for the development and
execution of components
SE 501 Dr. Basit Qureshi: Lecture for Week 13
What is a Component
Component-based Applications
• Example: The Firefox web browser:
– Extensible architecture (using plugins – components)
– New plug-ins can be added (Adobe flash, spell checkers, . . . )
At runtime?
– A well-defined plugin architecture: no need for plug-in
developers to know all the internals of Firefox
– Separation of plug-ins from other plugins and the main
application: a faulty plug-in should not crash Firefox
(compare Google Chrome)
– Different providers
SE 501 Dr. Basit Qureshi: Lecture for Week 13
What is a Component
Component-based Systems
• Example Linux:
– New hardware drivers from different providers (can be
added at runtime?)
– Isolation of core OS and drivers very important (but difficult)
– Language independent?
• GNOME (desktop environment):
– Consistent application configuration (gconf)
– Reuse of components for consistency: file browser, printer
selector, secret key storage (keyring) . . .
– D-Bus for component intercommunication
SE 501 Dr. Basit Qureshi: Lecture for Week 13
What is a Component
Component-based Systems
• AUTomotive Open System Architecture (AUTOSAR):
– A software architecture for the car industry
– Goal: reduce costs
– Vehicle producer’s want third-party companies to develop
their software (but are still responsible for the overall
quality)
– Or use standard software pieces (components), but adapted
to the vehicle manufacturer, moving towards a software
component marketplace
– Problems: cost reductions, complex standards
SE 501 Dr. Basit Qureshi: Lecture for Week 13
BUILDING COMPONENTS
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
An economic argument and a safety argument. . .
• Developing components is hard: a job for (expensive) experts
• Constructing systems by composing components is easier: let
less expensive programmers do the job
• Buy components off-the-shelf instead of constructing them
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Tasks
• How to program a component?
• How to accurately describe the interface of a component?
• How to check that a component fulfills its interface
specification?
• How to compose components?
• And vitally important: how to maintain a system constructed
from components . . .
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Criticism
• Does the economic argument about the facility/cheapness of
composition hold?
• Puzzle pieces may be easy to compose; we can tell just by the
shape if it composes with another piece
• And so there are attempts to do the same for software: give
components a shape by characterizing the type of inputs and
outputs
• But even for puzzles things are not so easy:
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Criticism
• Software components are hard to compose; there are many
extra dimensions to a software component
• A user has to consider these extra dimensions when deciding
whether to use a component
“Dimensions” of components:
• Input/output types
• Functional behavior
• Concurrent behavior
• Timing behavior
• Resource usage
• Security
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Input/output types
• Lets specify the operations on a component storing a set of
integers:
initialize()
add(Integer)
member(Integer) -> Bool
...
• We also may need exceptions – handling exceptional
(nonstandard) behavior
• The operation remove is used to remove an existing element
from a set
remove(Integer)
throws exception
// when element to remove is absent
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Functionality: what is the behavior of an operation?
• What is the relation between input and output parameters of a component
and its state?
• Lets describe the integer set component again (not a program):
component integer_set
var state : set
initialize():
state’ = 0;
add(element):
state’ = state Union {element}
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Concurrent behavior
• Are concurrent calls to operations permitted?
• If yes, how are concurrent calls coordinated?
• What happens if a component invokes the operation add(2)
at the same time as another component invokes the operation
initialise()?
• Does the resulting set contain 2 or not?
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Timing behavior
• What is the time complexity of invoking an operation? (when is
an answer returned)
• For example, what is the worst-case time complexity of
invoking the operation member(element)?
• Constant time (some hashing scheme used) or linear time (a list
used in the implementation)?
• Are there any timers associated with the behavior of the
component?
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Resource Usage
• Example: how much memory does a component consume?
• For example, how much memory is used to store a hundred
million integers using the operation add(element)?
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Security – what are the security implications of operations?
• Example: assume that a credit card component provides
validateCard(CardNumber,Pin) -> Bool for
checking a pin code against a credit card
• To use the validateCard operation we want to know that the
pin code is not leaked in any way from the credit card component:
–
–
–
–
the operation communicates the pin to a third party
if the operation saves the pin, and lets another operation communicate it
if the operation saves the pin, and reveals it by clever timing of operations
if the operation saves the pin, and reveals it by clever use of resources
(memory, power usage!)
– An information-flow property (hard to verify)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Maintainability: components may have a long lifetime –
how do we maintain them?
• Inspection:
– What are the interfaces of a component?
– What is the state of a component, or a component
interconnection mechanism?
•
•
•
•
How many requests has the component served?
Average waiting time until a request is served?
How many times has the component been restarted?
Are the queues used for component communication overloaded? (memory
usage)
– Code upgrade: how to update components on-line, without
taking down the whole system
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Towards building Components
Reliability:
• Many component-based systems has to work 24/7, with high
reliability (5 nines, i.e., 99.999%)
• Fault tolerance: can the component recover from hardware
failures?
• A good component framework provides support to design and
use components that are reliable, fault tolerant and
maintainable
SE 501 Dr. Basit Qureshi: Lecture for Week 13
ERLANG: AN INTRODUCTION
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
Problems of distributed systems
• Distributed programming is hard
• Challenges for concurrency:
– process coordination and communication
• And challenges for distributed software:
– heterogeneous systems
– security, reliability (lack of control)
– performance
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
Distributed Programming Today
• Vision – easy programming of distributed systems
• The nightmare/reality – Web services, XML, Apache, SOAP,
WSDL, . . .
• Why are Web services a nightmare?
– Too many standards, too many tools, too many layers, too complex!
• Erlang is an Industrially proven solution for developing and
maintaining demanding distributed applications
• Good qualities of Erlang as a distributed systems platform:
–
–
–
–
–
Complexity encapsulated in a programming language,
good performance,
efficient data formats,
Debug-able,
not complex
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
Erlang: A quick overview
• Processes are the components
• Components (processes) communicate by binary asynchronous
message passing
• Component communication does not depend on whether
components are located in the same node, or physically remote
(distribution is seamless)
• Component programming is facilitated by using design patterns
(client/server patterns, patterns for fault tolerant systems, etc)
and larger components (web server, database)
• Component maintenance, and fault tolerance is facilitated by
language features and design patterns
• But the devil is in the details: let’s see them!
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
Erlang: A quick overview
• Basis: a general purpose functional programming language
• Automatic Garbage Collection
• With lightweight processes (in terms of speed and memory
requirements)
• Typical software can make use of many thousands of processes;
smp supported on standard platforms
• Implemented using virtual machine technology and compilation
to native code (Intel x86, Sparc, Power PC)
– Available on many OS:es (Windows, Linux, Solaris, . . . )
• Supported by extensive libraries:
– OTP – open telecom platform – provides tools such as components,
distributed database, web server, etc
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
Erlang: Some History
• Erlang language born in 1983
• Used inside and outside Ericsson for telecommunication
applications, for soft real-time systems, . . .
• Industrial users: Ericsson, Swedish Telecom, T-Mobile (UK), and
many smaller start-up companies
• Application example: High-speed ATM switch developed in
Erlang (2 million lines of Erlang code), C code (350 000 lines of
code), and 5 000 lines of Java code
• Other examples: parts of Facebook chat written in Erlang (70
million users), CouchDB (integrated in Ubuntu 9.10), users at
Amazon, Yahoo, . . .
• Open-source; install from http://www.erlang.org/
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
• Concurrency and Communication
• Concurrency and Communication model inspired by
the Actor model (and earlier Ericsson
software/hardware products)
• Processes execute Erlang functions
• No implicit sharing of data (shared variables) between
proceses
• Two interprocess communication mechanisms exists:
– processes can send asynchronous messages to each other
(message passing)
– processes get notified when a related process dies (failure
detectors)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Erlang: An Introduction
• Erlang and Errors
• Unavoidably errors happen in distributed systems
– hardware (computers) fail
– network links fail
– local resources (memory) runs out
• Errors happen, good fault-tolerant systems cope with them
• Many Erlang products have high availability goals: 24/7,
99.9999999% of the time for the Ericsson AXD 301 switch
(31 ms downtime per year!)
• The Erlang philosophy is to do error detection and
recovery, but not everywhere in the code, only in certain
places
SE 501 Dr. Basit Qureshi: Lecture for Week 13
MIDDLEWARE & WEB-SERVICES
FRAMEWORK
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
• Classical World Wide Web provided:
Computer (web page) – Human communication
• But soon people started wanting to use the very successful
infrastructure (XML, HTTP) for program–to–program
communication and so the Web Services idea was born:
Web Service – Client Program communication
• Nowadays focus is on:
Web Service – Web Service communication
(business processes)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Web Services Vision:
• Support distributed applications composed of independent
processes which communicate by message passing
• Enables communication between web services implemented in
different languages, and by different companies, and on
different platforms
Web Services Framework Development
• Development of the Web Services framework has been layerby-layer and rather ad-hoc
• Web Servers-> Standard Data Format (XML) ->Message Passing
-> Web Services-> Business Processes ->. . .
• As a result there is a huge pile of stacked “standards”: XML, XML
Schema, SOAP, WSDL, UDDI, . . .
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Web Services Framework Development
• As the web of services is built bottom-up, lacking a single
architect or design team, and evolves rapidly, we get complex
solutions
• Interested parties are many – there is a lot of money in web
services, and lots of hype!
• Strong players are Microsoft, Google, IBM, Oracle, SAP, Sun,
BEA, and open source enterprises such as Apache
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
The ultimate aim of the web services program is to build a serviceoriented architecture (SOA) with the properties:
• Access to services is standardized (interfaces defined)
• Network nodes make (reusable) services available to other
nodes, independent of physical location (location transparency)
• The publishing of information about available services is
standardized (a service directory)
• SOA should be independent of implementation technology –
e.g. services can interoperate regardless of implementation
environment or language (Java, C#, . . . )
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
HTTP:
• Asymmetric protocol: has a client and server side
• A synchronous protocol: one request −> one reply
• A stateless protocol: no history of communication between client and server
available to server, every request is understandable on its own
• But the statelessness of operations is often too expensive – in practise
mechanisms like cookies are used:
• Universal addressing of resources (URIs)
• HTTPS – for encryption using SSL/TLS
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
XML:
• XML Extensible Markup Language: a general purpose markup
language
Advantages:
• Text format makes for readability, understanding and easier
debugging of services on top of XML
• Easy to define new formats on top of XML
• Makes for extensible documents: a tool doesn’t need to know
everything about a format to extract information useful to itself
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
XML:
Disadvantages:
• Data is described hierarchically rather that relationally. For example: what is
the hierarchy between actors and movies?
• Can be complex to parse and unparse
• XML is inefficient for many uses: makes for slow applications and
communication
• Binary data is stored using Base64 encoding, which increases the size 1.33
times (problems for transmission of movies, audio data, . . . )
• And so attempts to improve exists: JSON (JavaScript Object Notation), YAML,
Binary XML, compressed and binary XML (Fast Infoset, BiM – Binary MPEG
format for XML)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Web Service Definition Language (WSDL): An XML format
for describing how to communicate with web services
• Describes the public abstract interface to the service, i.e., which
operations the interface provides
• Describes a binding – how to exchange messages with a server
implementing the service interface (e.g., using SOAP and HTTP)
• Describes where the service is available That is, at which URL
address the service is located
• Normally used with SOAP (messages) and XML Schema
(defining data structures)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Universal Description, Discovery and Integration
(UDDI):for publishing & discovery of web services
• UDDI was heavily hyped:
– UDDI would provide a universal registry for business to provide service
listings (web service descriptions, etc)
– web service discovery: UDDI would spawn a service broker infrastructure
where a client looking for a service searchers for a suitable provider in
the UDDI registry
• Nowadays the basic aspects of UDDI is emphasized: publish and
search for web services, and private (in-business) use
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Status Check – Web Services: What have we got so far?
• A stack of standards for describing operations, data formats,
and the locations at which the operations are available
• And a set of bindings to concrete programming languages such
as Java, C# for invoking and providing web services
• But this is not very different from earlier attempts like CORBA??
• Except we have “cool” Web Servers that implement Web
Services instead of “boring” CORBA Servers and applications
• But the connection of WebServices and language (Java) is
indirect leading to ugly, complex and slow solutions
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Web Services: Positives..
• In truth: more interactivity and easier debugging through better
data formats like XML
• Seeing your data instead of decoding it is very rewarding
• Possibly a key to the success of scripting languages too easy
construction/deconstruction of data leads to less separation of
code and data!
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Web Services: What’s missing..
Are Web Services (as we have seen them so far) suitable for
implementing a (distributed) component framework?
No: several features from other frameworks are missing:
• To enable communication between Web Services we need to
establish various basic rules regarding communications:
– communication guarantees
– security mechanism
– trust model, . . .
• Design-by-contract: where are the abstract contract
descriptions of web services? (post– and pre–conditions,
invariants)
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Web Services: Distributed Middleware Concerns
There are a large number of “add-on” specifications that provide support
for web service design and interaction:
• WS-Addressing: embedding address information in XML (including
reply information)
• WS-Reliable Messaging: provides reliable SOAP message delivery
• WS-Transactions: transaction support for web services
• WS-Security: provides end-to-end security (message confidentiality,
integrity)
• WS-Trust: manages trust (credentials, who has the permission to do
an operation)
• WS-Policy: permits web services to announce policies (Quality–of–
service, security), and users to state requirements upon web services
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
Popular Web Service Frameworks
• Apache Axis
• Web Services Interoperability Technology (SUN)
• Windows Communication Foundation (Microsoft,
.NET-based)
• ...
• All implement at least WS-Addressing, WS-Reliable
Messaging and WS-Security
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Web services…
In conclusion:
• Lots of money in Web Services – as a result a lot of hype driven
by companies such as Microsoft, SUN, IBM, Oracle
• Early standards approach yields clumsy solutions
• Layered standards further result in clumsy approaches
• SOA and Enterprise Service Bus are attempts at a more elegant
framework – but implemented using the same base standards
(XML, SOAP, WSDL)
• Still lacking semantic contract specifications (compare designby-contract for programming languages)
• Formal methods link for Business Processes Modelling? So far
just hype!
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Summary
•
•
•
•
•
•
Motivation: Why Software re-use
Re-use of Software
What is Component?
Building Components
Erlang: Distributed component development
Middleware & Web services framework
SE 501 Dr. Basit Qureshi: Lecture for Week 13
Descargar

SE 501 Software Development Processes