Why Fusion?
Many modern internet-facing applications suffer from the following drawbacks:
- Service life-cycle management
- Service clients are developed and managed independently of the services. Service writers change APIs and service functionality in an ad-hoc (and usually backward incompatible) manner leaving clients to their own devices.
- Service discovery
- Service APIs are often presented as REST interfaces, with little structure behind them. At most, version number conventions are used (along with release notes) to indicate that the service has changed to the client. Developers writing service clients have to look through JSON files or example documentation to figure out why their code has suddenly stopped working.
- Service introspection
- Client development is an art, with little or no support for automation and error detection provided by service interfaces.
Fusion is a grounds-up effort to develop a cloud-native environment for information integration using formal techniques based on concepts from Services Oriented Architectures (SOA) and Model-Driven Architectures (MDA).
An SOA breaks functionality into federated services, each assumed to be controlled and managed independently of others. The services expose state and operations to one another, and can be composed into larger building blocks by integrating them through standardized interfaces. By explicitly creating “service blueprints” that define interactions between services, SOAs formalize relationships and interactions between services. Similarly, object-oriented programming paradigms use “objects” as the abstraction to capture state encapsulation and create application programming interfaces (APIs) to allow software modularity and reusability. By capturing service definitions as formal "models", MDAs enable tools that can reason over service states automatically.
Fusion tools use formal models to define all concepts within the SOA, and use object-oriented techniques for integration of concepts. Each service not only exposes data and operations to the clients, but also a formal model of itself in its client-facing interfaces. This enables, for example, the client to detect changes as they occur at the service endpoint, check compatibility, and detect where incompatible changes have taken place [Becker et. al.] Thus the tools offer the developer the following benefits:
- Plug-and-play services:
- Fusion balances a decentralized execution environment typical over the web with the ability to re-use services in an automated manner. Because each service exposes not only the data and operations available to clients, but also a model of itself, clients can introspect services for their latest definition, and adapt automatically as necessary.
- Decentralized Service Models:
- In any distributed automation environment, there are multiple vendors or developers for the required management tools. This makes it difficult, if not impossible, to maintain a single model that captures all dependencies and tools within the environment. Fusion addresses this issue by clearly defining domains within which model coherency can be maintained, while providing freedom to each service to define its own model of interaction.
- Customization:
- Fusion is targeted at service automation. Because the scope of automation is large, Fusion assumes that any given deployment will need to be customized. Thus the tools make very few assumptions about the services, products, and protocols that are present within a domain.
- Protocol Evolution and Independence:
- There is an ever growing and evolving list of “standards” that are used within the web. This poses a problem for developers, since a change in interaction protocols requires changes in every service. Fusion separates out service descriptions and interactions in a platform independent manner by describing them in models. It then uses the notion of a communication proxy service to handle the details of transforming these descriptions to actual “on-the-wire” data structures. By localizing any protocol related dependencies within the communication proxy service, Fusion frees the developers from changing service or client code each time the underlying protocol evolves.