The advent of SOA and standard-base Web services together with Internet based delivery models has provided the essential base for facilitating new software platform innovations. One of these innovations is a breakthrough software componentization technique that we have coined Service Oriented Programming (SOP). While SOA focuses on communication between systems using “service operations,” SOP provides a new technique to build agile application modules using in-process, native service operations as the “units of assembly.” Instead of using services just to go across systems, SOP provides a model-driven technique that uses an in-memory image of services to run an entire application. Since these in-memory services can transparently externalize through Web service standards or any proprietary protocol, SOP automatically brings SOA inside the application modules and enables real-time integration from “inside,” thus eliminating the need for costly data replication. SOP modules can adapt to change and integrate orders of magnitude faster and easier than it’s possible with SOA alone.

Model-Driven SOP Development & the Multi-Tenant Service Virtual Machine
SOP combines an in-memory service composition technique with service-oriented and model-driven programming constructs to create application modules as services without coding or scripting. SOP with “SOA inside,” unifies application componentization and integration functionality and, thus, eliminates the need for a bundle of application and SOA integration servers. Because the SOP paradigm is already model-driven, there is no need for tens of complex add-on “middleware” products ranging from Workflow and Business Process Management (BPM) tools to Data Exchange tools. Model-driven SOP changes the economics of software automation by eliminating the need for the entire SOA middleware stack.  SOP models, defined through a single design-time environment, are automatically run and managed by a Multi-tenant Service Virtual Machine (SVM) at runtime.

SOP implements hierarchical software modules, with the lowest level, the atomic service, representing the smallest unit of work; and the highest level, the composite service, containing a stack of nested service modules. Business logic consists of composite services that are automatically multithreaded and virtualized at a molecular level across multiple cores, processors and servers at runtime. A service like “Get Annual Customer Service Orders” may contain a hundred nested services. Instead, by executing these services serially, the Service Runtime Environment automatically dispatches them across multiple cores, greatly reducing execution time. It understands the whole gamut of parallelization issues, like data dependencies, and addresses them behind the scenes without any user input. This fully utilizes the parallel computing capability of an HPC system without burdening the programmer with thread creation.

Convergence Through the Power of “Transparent Externalization” 
In SOP, service interfaces form the unit of in-memory encapsulation and can be transparently externalized at runtime regardless of where they are used in the hierarchical stack of composition. This transparent ability to externalize any sub service-component of a higher level service module is at the heart of the convergent property of SOP. It is the key to built-in virtualization of all the subcomponents across multiple cores and servers, inside-out SOA integration, and many other innovative mechanisms that are enabled through SOP.  

SaaS 2.0: The Convergence of SOA, SaaS and Service Virtualization Through SOP
Today, the main platform differentiation between traditional applications delivered on-premise and the one used by a SaaS application vendor is in the multi-tenancy of the SaaS application platforms. Besides the multi-tenant delivery model, the paradigm and techniques used for development of SaaS and on-premise applications is fundamentally the same. Using a multi-tenant SOP platform for developing and running SaaS application components brings the advantages of 100% model-driven development, inside-out SOA, and automatic component virtualization to the existing economics of SaaS delivery. SOP is the convergence point of SaaS, SOA, and Virtualization.

Example of Migrating to an SOP Platform
Ventyx supplies ERP applications for Service Delivery Management used by corporations to manage customers, workforce, spare parts inventory, tools and documentation. They serve more than 400 companies in over 40 countries, including nuclear power companies who operate energy facilities that generate and distribute electricity. Because their customers typically customize the business logic in the application software, Ventyx migrated to an SOP platform that could better support customers by ensuring a high level of integration while maintaining optimal computer performance.

Ventyx deployed the Hyperservice Business Platform and Service Runtime Environment (SRE) from NextAxiom, which helped them migrate legacy code and develop new applications to run on an SOP platform. Hyperservice™ Studio provides a full featured semantic-based environment for building, managing and customizing software modules called services, while Service Runtime Environment provides a managed runtime environment for automating the parallel execution of services. Legacy code can either be converted to the SOP model or encapsulated in “wrappers” so they run as before, with only minor software modifications.

With NextAxiom’s SOP platform, developing business logic is visual like creating flowcharts. Users drag and drop native service interfaces, add visual programming constructs and connect them together with lines. “Now, our customers can snap together services to tailor and integrate solutions on demand,” says Fernando Alvarez, Director of Product Architecture at Ventyx. Instead of writing code, users create services semantically which are executed automatically by the platform. This means services can be created by experienced business process experts as well as software programmers. Because code is neither written nor generated, solutions remain flexible throughout their lifecycle.

NextAxiom’s customers can run a combination of single-thread legacy code and multithreaded composite services, both of which Intel Architecture processors execute exceptionally well. This benefits applications that demand high compute performance across a wide array of workloads. This application software is optimized to run on HP Integrity rx6600 servers powered by Dual-Core Intel Itanium 2 processors.