Enabling dynamic application layer protocols in heterogeneous distributed systems

Traditional heterogeneous distributed computing systems generally achieve cross-platform communications through standardized message passing. The messages are fixed at compile-time based on the specifics of the standard chosen and the interface defined between clients and the server. There are several issues with this approach. First, the systems are tightly coupled to the standard and specific version at compile-time. As standards advance or new technologies emerge, the systems are unable to advance as well without re-compilation, re-deployment and possibly re-design. Second, in order to affect the client-server network traffic to achieve some goal (e.g., provide additional request information, reduce bandwidth consumption) one must change the standard (not likely) or the client-server interface. Interface changes minimally create version dependencies among clients and services that must be managed and in the worst case break system interoperability altogether. Finally, even if the interface is changed to affect network traffic, due to the standardization based on the interface, this change is applied to all communications. Individual interactions between specific clients and services are unable to take advantage of (or compensate for) the current environment and situation such as client capabilities, instantaneous network congestion, or remaining battery life. To address these issues, we describe a service oriented architecture and a novel language that allow service providers, at runtime, to inject logic into heterogeneous clients for communicating back to the service provider. By abstracting the logic of the network protocol behind a service-provided, runtime-defined, client-side service proxy, the client is freed from compile-time binding to any single network protocol. An individual service provider, meanwhile, can dynamically modify their specific client-side proxy, and therefore the application layer protocol, as desired and at any time during the interaction's life-cycle providing that the changes continue to meet the service's interface contract. Interoperability of the entire system is also improved as the client's proxy is provided on-demand and at runtime by the specific service provider instance with which it will communicate. To support heterogeneous sharing of service proxy logic, we define the Application Logic Markup Language to capture proxy definitions in a high-level, object-oriented representation that is not targeted toward any specific programming language or runtime machine stack (real or virtual). The novelty of our approach is capturing the logic at a very high-level (e.g., conditionals, loops) rather than lower-level, stack-based manipulations. This enables execution of the logic in any modern object-oriented environment without complicated language mappings or significant virtual runtime development. At the same time, our approach supports exploiting target environment-specific runtime optimizations such just-in-time compiling and method in-lining without additional development effort. We survey a number of object-oriented languages to determine the necessary, desired, and appropriate properties and features of such a language. Through several case studies utilizing Lizard, our reference implementation supporting the Application Logic Markup Language, we demonstrate how a single client application without recompilation, redeployment, or compile-time knowledge of the application layer protocol can seamlessly and transparently interoperate with a variety of service providers. Each service provider implements the same service interface, yet they have differing system goals and utilize diverse network protocols to achieve them.