CSCI927 - Service-Oriented Software Engineering Week 2

Service-Oriented Software Engineering (SOSE) is a pivotal aspect of modern software development, especially in environments where services and their orchestration are central. In this week’s post, we delve into the essentials of service modeling and how it integrates with SOSE, using tools like UML and semantic web standards.

The Ubiquity of Models

Models are everywhere in software engineering. Take UML (Unified Modeling Language), for example—it’s a design language widely used for visualizing the architecture of software systems. But when we shift our focus to service-oriented architecture, the idea of service modeling becomes crucial.

Service Description vs. Service Modeling

At its core, service modeling is about describing what a service does, how it does it, and the quality with which it performs its tasks. This includes:

Service Functionality (What): The core functional points or requirements of the service.
Information (How): How the service interacts with data, whether it’s sourcing, sinking, or using information.
Non-Functional Requirements: These quality factors define the service’s performance, reliability, and other characteristics.

Web Service Standards

In the realm of web services, standards play a key role in service modeling:

Description: Web services are described using WSDL (Web Services Description Language).
Invocation: Services are invoked through protocols like SOAP or REST.
Discovery: UDDI (Universal Description, Discovery, and Integration) is used for discovering services.

Semantic Web and Service Modeling

Semantic web technologies push the boundaries of service modeling by adding well-defined meanings to data, making it more understandable by machines. Key semantic web languages include:

OWL-S: A semantic markup language for describing the properties and capabilities of web services.
WSMO: Web Service Modeling Ontology, which provides a conceptual framework for semantic web services.
WSDL: While traditionally used for service descriptions, it also supports semantic annotations.

Most semantic web approaches adhere to a foundational model: Input-Output, Precondition-Effect (IOPE). This structure forms the basics of any service modeling language.

Examples of Semantic Languages

Semantic languages like RDF (Resource Description Framework) and OWL (Web Ontology Language) are designed to provide explicit semantics, supporting ontology, interoperability, and inference. Here’s a simple RDF example:

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:foaf="http://xmlns.com/foaf/0.1/">
  <rdf:Description rdf:about="http://example.org/person/JohnDoe">
    <foaf:name>John Doe</foaf:name>
    <foaf:age rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">30</foaf:age>
    <foaf:knows rdf:resource="http://example.org/person/JaneDoe"/>
  </rdf:Description>
  <rdf:Description rdf:about="http://example.org/person/JaneDoe">
    <foaf:name>Jane Doe</foaf:name>
  </rdf:Description>
</rdf:RDF>

Key Features of Semantic Languages

Explicit Semantics: Providing machine-readable meanings for data.
Ontology Support: Defining complex relationships and hierarchies.
Interoperability: Facilitating data integration from diverse sources.
Inference: Allowing machines to infer new information from existing data.

The Role of Logic in Service Modeling

In service modeling, logic plays a critical role:

First-Order Logic: Often used for describing static worlds.
Temporal Logic: Describes dynamic environments.
Other Logics: Dynamic logic, non-monotonic logic, etc., are also relevant.

Conditions and Assumptions in Service Modeling

Understanding conditions and assumptions is vital:

Pre-Conditions: What we have before the service execution.
Post-Conditions: The state after the service is executed.
Assumptions: Hypotheses that need to be validated or revisited.

Quality of Service (QoS)

QoS is a crucial aspect of service modeling. It measures the effectiveness of business processes, including:

Delivery Schedules: Timing and deadlines for service delivery.
Payment Schedules: Financial terms tied to service fulfillment.

Applying Service Modeling in Teams

To effectively apply service modeling concepts in a team, consider the following:

External Aspects:

Define team goals and functions.
Identify stakeholders.
Outline conditions and assumptions.
Establish QoS parameters.
Set delivery schedules.
Develop an escalation matrix for penalties.

Internal (Software Engineering) Aspects:

Build a knowledge base using semantics.
Select appropriate tools.
Determine team composition and ownership.
Delegate services wisely.

Invocation and Response Handling

Finally, understanding how to invoke services and handle responses is essential:

Invocation: Specify how requests are made.
Response: Define how responses will be delivered.

Lecture 2 Paper