![](bg2.png)
also service-oriented (SO) and scalable with multiple
computational fidelities of services so your
communication network can be scaled up and down
dynamically, from a single computer to a large
number of computers by adjusting fidelities of
collaborating service (Sobolewski, 2017).
Computer-aided engineering is the broad usage of
heterogeneous computer software for both standalone
and distributed systems to aid in engineering complex
analyses and optimization tasks. Multidisciplinary
Analysis and Design Optimization (MADO) is a
domain of research that studies the application of
numerical analysis and optimization techniques for
the design of dynamic systems of systems involving
multiple coupled disciplines. The formulation of
MADO problems has become increasingly complex
as the number of disciplines and design variables
included in typical studies has grown from a few
dozen to thousands when applying high-fidelity
physics-based modeling early in the design process
(Kolonay, 2014). Therefore, the complex MADO
domains have been used for studying the presented
true service-orientation. First in the FIPER project
funded by NIST ($21.5 million) at the beginning of
this millennium (Sobolewski, 2002) then continued at
the SORCER/TTU Laboratory (SORCER/TTU
Projects, n.d.; Sobolewski, 2010), and maturing for
real world aerospace applications at the
Multidisciplinary Science and Technology Center,
AFRL/WPAFB (Burton, Alyanak and Kolonay, 2012;
Kolonay, 2014; Sobolewski, 2014, 2017).
The remainder of this paper is organized as
follows: Section 2 describes SML service semantics;
Section 3 describes the basic syntax and semantics of
SML; Section 4 relates SML to the OO
implementation in SORCER; then we conclude with
final remarks and comments.
2 SERVICE SEMANTICS
Service semantics can be either declarative,
imperative, or OO. A blend of all programming
paradigms should be supported by SO languages
intended for solving complex problems and building
heterogeneous SO systems. Therefore, component
services should be expressed using adequate
programming styles. Each programming paradigm
introduces distinguishing principles of its
programming model but also depends on its lower
level-supporting paradigm. Therefore, the pillars of
SO programming introduced in this paper are layered
on pillars of OO, structured, and functional
programming. The pillars of true SO programming
are focused on contexting, multifidelity, and
multityping for frontend and backend services.
A service consumer is a composition of frontend
request services and a service provider is an
implementation of service types (interface types)
using subroutines as shown in Fig. 1. A consumer is
expressed in a SO language but a provider is
actualized as the OO remote/local counterpart
implementing multiple service types. Frontend
services are references to backend services. Provider
services are service specifications – contracts but
service providers are implementations of contracts. A
federated request service, called a federal mogram
(Sobolewski, 2017), corresponds to a union of service
mograms such that each component mogram
(exertion or model) represents governance for own
collaboration of service providers. A federated
collection of cooperating collaborations defined by a
federal mogram is called a service federation. Service
federalism is a system of federal service governance
in which constituent governances (component
mograms) share governing power with the central
governance (parent mogram) to utilize federated
collaborations of service providers and subroutines as
a service federation. The rules of federal governance
are realized by a SO operating system (a kind of
federal government). The main purpose of the SO
operating system is to satisfy interests of service
consumers and to fulfill their needs using capabilities
of service federations.
Mograms are structured from elementary request
services (entries and tasks) and other mograms.
Entries and tasks depend on operation services called
evaluators and signatures, respectively. Entries use
various types of subroutine services, called
evaluators, to invoke subroutines. A signature is a
reference to a remote/local operation of service
provider. The unique signature-based architecture is
about both request service configuration complexity
and execution complexity that allows treating local
and remote service providers implementing
subroutines uniformly at various levels of granularity
and fidelity. When dealing with both complexities,
you have a case to distribute services, otherwise
create a modular monolith with locally executable
modules as local services. Later, when complexity of
the system becomes unmanageable you can deploy
almost instantly the existing local service providers as
network services on as-needed basis, and then run
changed services of the original monolith in the
network. In SORCER that is done by changing the
service type of signatures from class to interface, or
just selecting the remote service fidelity. Service
providers never communicate directly with each other
CLOSER 2019 - 9th International Conference on Cloud Computing and Services Science
332