Services A, B, and C are non-agnostic task services. Service A and Service B use the
same shared state database to defer their state data at runtime.
An assessment of these three services reveals that each contains some agnostic logic, but
because it is bundled together with the non-agnostic logic, the agnostic logic cannot be
made available for reuse.
The assessment also determines that because Service A and Service B and the shared
state database are each located in physically separate environments, the remote
communication required for Service A and Service B to interact with the shared state
database is causing an unreasonable decrease in runtime performance.

How can the application of the Orchestration pattern improve this architecture?

• A. The application of the Orchestration pattern will result in an environment whereby the
  Compensating Service Transaction is naturally applied, resulting in the opportunity to
  create sophisticated exception logic that can be used to compensate for the performance
  problems caused by Services A and B having to remotely access the state database. The
  Process Abstraction and Service Broker patterns are also naturally applied, enabling the
  separation of non-agnostic logic and agnostic logic while providing common transformation
  functions required to overcome any disparity in the service contracts that will need to be
  created for the new agnostic services.
• B. None of the above.
• C. The application of the Orchestration pattern will result in an environment whereby the
  Process Abstraction and Process Centralization patterns are naturally applied to Services
  A, B, and C, resulting in a clean separation of non-agnostic task services from newly
  designed agnostic services with reuse potential. Also, the State Repository pattern can be
  applied by the availability of a central state database that can be shared by Services A and
• D. This database can be made available as a local part of the environment so that Services
  A and B can avoid remote communication.
• E. The application of the Orchestration pattern will result in an environment whereby the
  State Repository and Service Data Replication patterns are naturally applied, allowing the
  shared state database to be replicated for Services A and B so that each task service can
  have its own dedicated state database. The Process Centralization pattern can also be
  applied to Services A and B, so that their logic is physically centralized, turning them into
  orchestrated task services.

Service A is a task service that is required to carry out a series of updates to a set of
databases in order to complete a task. To perform the database updates Service A must
interact with three other services, each of which provides standardized data access
capabilities.
Service A sends its first update request message to Service B (1), which then responds
with a message containing a success or failure code (2). Service A then sends its second
update request message to Service C (3), which also responds with a message containing
a success or failure code (4). Finally, Service A sends a request message to Service D (5),
which responds with its own message containing a success or failure code (6).

You've been asked to change this service composition architecture in order to fulfill a set of
new requirements: First, if the database update performed by Service B fails, then it must
be logged by Service A.
Secondly, if the database update performed by Service C fails,
then a notification e-mail must be sent out to a human administrator. Third, if the database
update performed by either Service C or Service D fails, then both of these updates must
be reversed so that the respective databases are restored back to their original states.
What steps can be taken to fulfill these requirements?

• A. Service A is updated to perform a logging routine when Service A receives a response
  message from Service B containing a failure code. Service A is further updated to send an
  e-mail notification to a human administrator if Service A receives a response message from
  Service C containing a failure code. The Atomic Service Transaction pattern is applied so
  that Services A, C, and D are encompassed in the scope of a transaction that will
  guarantee that if the database updates performed by either Service C or Service D fails,
  then both updates will be rolled back.
• B. The Atomic Service Transaction pattern is applied so that Services A, C, and D are
  encompassed in the scope of a transaction that will guarantee that if the database updates
  performed by either Service C or Service D fails, then both updates will be rolled back. The
  Compensating Service Transaction pattern is then applied to all services so that the scope
  of the compensating transaction includes the scope of the atomic transaction. The
  compensating exception logic that is added to Service D automatically invokes Service B to
  log the failure condition and Service C to issue the e-mail notification to the human
  administrator. This way, it is guaranteed that the compensating logic is always executed
  together with the atomic transaction logic.
• C. None of the above.
• D. The Compensating Service Transaction pattern is applied to Service B so that it invokes
  exception handling logic that logs failed database updates before responding with a failure
  code back to Service A . Similarly, the Compensating Service Transaction pattern is
  applied to Service C so that it issues an e-mail notification to a human administrator when a
  database update fails. The Atomic Service Transaction pattern is applied so that Services
  A, C, and D are encompassed in the scope of a transaction that will guarantee that if the
  database updates performed by either Service C or Service D fails, then both updates will
  be rolled back. The Service Autonomy principle is further applied to Service A to ensure
  that it remains consistently available to carry out this sequence of actions.

The Client and Vendor services are agnostic services that are both currently part of
multiple service compositions. As a result, these services are sometimes subjected to
concurrent access by multiple service consumers.
The Client service is an entity service that primarily provides data access logic to a client
database but also provides some calculation logic associated with determining a client's
credit rating. The Vendor service is also an entity service that provides some data access
logic but can also generate various dynamic reports.
After reviewing historical statistics about the runtime activity of the two services, it was
discovered that the majority of concurrent runtime access is related to the processing of
business rules. With the Client service, it is the calculation logic that is frequently required
and with the Vendor service it is the dynamic reporting logic that needs to be accessed
separately from the actual report generation.

Currently, due to the increasing amount of concurrent access by service consumers, the
runtime performance of both the Client and Vendor services has worsened and has
therefore reduced their effectiveness as service composition members. What steps can be
taken to solve this problem without introducing new services?

• A. None of the above.
• B. The Rules Centralization pattern can be applied by extracting the business rule logic
  from the Client and Vendor services and placing it into a new Rules service. This will
  naturally improve the runtime performance of the Client and Vendor services because they
  will no longer be subjected to the high concurrent access of service consumers that require
  access to the business rules logic.
• C. The Rules Centralization pattern can be applied together with the Redundant
  Implementation pattern to establish a scalable Rules service that is redundantly
  implemented and therefore capable of supporting high concurrent access from many
  service consumers. The Service Abstraction principle can be further applied to hide the
  implementation details of the Rules service.
• D. The Redundant Implementation pattern can be applied to the Client and Vendor
  services, thereby establishing duplicate implementations that can be accessed when a
  service reaches its runtime usage threshold. The Intermediate Routing pattern can be
  further applied to provide load balancing logic that can, at runtime, determine which of the
  redundant service implementations is the least busy for a given service consumer request.

Service A.
Service B.
and Service C are each designed to access the same shared legacy
system. The service contracts for Service A, Service B, and Service C are standardized
and decoupled from the underlying service logic. Service A and Service B are agnostic
services that are frequently reused by different service compositions. Service C is a non-
agnostic task service that requires access to the legacy system in order to retrieve
business rules required for the service to make runtime decisions that determine its service
composition logic. The legacy system uses a proprietary file format that Services A, B, and
C need to convert to and from.

You are told that additional services need to be created, all of which need access to the
legacy system. You are also told that the legacy system may be replaced in the near future.
What steps can be taken to ensure that the replacement of the legacy system has a
minimal impact on Services A, B, and C and any future services that are designed to rely
upon it?

• A. None of the above.
• B. The Legacy Wrapper pattern can be applied together with the Data Format
  Transformation pattern and the Standardized Service Contract principle in order to
  establish an intermediate layer of standardized transformation logic that is positioned
  between the legacy system and Services A, B, and C.
  This way, if the legacy system is replaced, the services will not be affected because of the abstraction established by the
  standardized transformation layer.
• C. The Legacy Wrapper pattern can be applied together with the Official Endpoint pattern
  so that the Service A service contract is positioned as the sole access point for the legacy
  system. The Data Format Transformation pattern is applied to enable the conversion
  between the proprietary legacy system file format and the XML format used in the Service
  A service contract. Finally, the Contract Centralization pattern is applied so that Service A
  is forced to only access the legacy system via its published standardized service contract.
• D. The Legacy Wrapper pattern can be applied together with the Standardized Service
  Contract principle to position a standardized service contract between the legacy system
  and any services that require access to it. This effectively establishes a new utility service
  dedicated to the encapsulation of the legacy system. When the legacy system is replaced,
  the utility service can keep its standardized service contract. To build the utility service, the
  Data Format Transformation pattern is applied to convert between the proprietary legacy
  system file format and the XML format used in the standardized service contract.