Home > What is SOA > About Web Services

About Web Services

The Web services platform is defined through a number of industry standards that are supported throughout the vendor community. This platform can be partitioned into two clearly identifiable generations, each associated with a collection of standards and specifications:


First-Generation Web Services Platform 

The original Web services technology platform is comprised of the following core open technologies and specifications: 

  • Web Services Description Language (WSDL) 
  • XML Schema Definition Language (XSD) 
  • SOAP (formerly the Simple Object Access Protocol) 
  • UDDI (Universal Description, Discovery, and Integration) 
  • WS-I Basic Profile

These specifications have been around for some time and have been adopted across the IT industry. However, the platform they collectively represent seriously lacks several of the quality of service features required to deliver mission critical, enterprise-level production functionality. 


Second-Generation Web Services Platform (WS-* extensions) 

Some of the greatest quality of service-related gaps in the first-generation platform lie in the areas of message-level security, cross-service transactions, and reliable messaging. These, along with many other extensions, are being provided by the second-generation Web services platform. 

Consisting of numerous specifications that build upon the fundamental first-generation messaging framework, this set of Web services technologies (generally labeled as "WS-* extensions") provides a rich feature-set far more complex both in technology and in design.

Some of the notable WS-* specifications include: 

  • WS-Security (and WS-SX)
  • WS-Coordination, WS-AtomicTransaction, WS-BusinessActivity (and WS-TX) 
  • WS-ReliableMessaging (and WS-RX) 
  • WS-Policy 
  • WS-Addressing 

For an introduction to first and second-generation Web services technologies, read the short tutorials located at WS-* Specs. To view the actual specifications, visit Service Tech Specs


A typical Web service is comprised of the following:

  • A physically decoupled technical service contract consisting of a WSDL definition, an XML schema definition, and possibly a WS-Policy definition. This service contract exposes public functions (called operations) and is therefore comparable to a traditional application programming interface (API).
  • A body of programming logic. This logic may be custom-developed for the Web service, or it may exist as legacy logic that is being wrapped by a Web service in order for its functionality to be made available via Web services communication standards. In the case that logic is custom-developed, it generally is created as components and is referred to as the core service logic (or business logic).
  • Message processing logic that exists as a combination of parsers, processors, and service agents. Much of this logic is provided by the runtime environment, but it can also be customized. The programs that carry out message-related processing are primarily event-driven and therefore can intercept a message subsequent to transmission or prior to receipt. It is common for multiple message processing programs to be invoked with every message exchange.
About Web Services: Three variations of a single Web service showing the different physical parts of its architecture that come into play, depending on the role it assumes at runtime.

Figure 1 - Three variations of a single Web service showing the different physical parts of its architecture that come into play, depending on the role it assumes at runtime.

A Web service can be associated with temporary roles, depending on its utilization at runtime. For example, it acts as a service provider when it receives and responds to request messages, but can also assume the role of service consumerwhen it is required to issue request messages to other Web services. 

When Web services are positioned within service compositions, it is common for them to transition through service provider and service consumer roles. Note also that regular programs, components, and legacy systems can also act as service consumers as long as they are able to communicate using Web services standards.