zAgile CEO: Why you should consider model-driven integration

As more and more businesses turn to cloud applications and platforms, we risk reinventing the siloed organization, where different business units go around IT to adopt various disconnected solutions. Duplicate yet slightly different records about the same products and customers become scattered in isolated data stores, often serving a single app. For the organization as a whole, the chaotic result can be a step backward from carefully integrated legacy systems, which may have been rigid, but at least they talked to each other.

Enterprise applications integration, the traditional solution for breaking down silos, is not necessarily suited for cloud integration — giving rise to a number of fresh solutions for the cloud era. In this week’s New Tech Forum, we’ve invited Sanjiva Nath, CEO of zAgile, to explain the metamodel-driven technology behind his Wikidsmart platform, which offers data integration and can also tie application data with process context and team activities. Currently, the most common applications for Wikidsmart are to integrate CRM data sources and to manage large software development projects across multiple, far-flung teams.

— Paul Venezia

Model-driven integration The problem of integrating enterprise applications is not new. But the demand for integration and the complexity of implementing it keep increasing, thanks to rising adoption of SaaS and market forces that push teams to improve their collaboration and delivery capabilities.

Traditional enterprise application integrations have proven time-consuming and expensive, typically involving months of effort and significant cost. A big contributor to this overhead is the fact that integration schemes typically lack any formal representation of application data — that is, metadata. As a result, the interpretation of the application data and its mapping to any integration scheme becomes a manual, tedious, and nonrepeatable process.

zAgile’s Wikidsmart — a platform for integrating applications, teams, processes, and collaboration within the enterprise — addresses this problem in a unique fashion. Drawing on technology developed for the semantic Web, Wikidsmart supports the formal representation of systems via metamodels or ontologies that richly describe application objects, their attributes, and the nature of their relationships with each other. These metamodels may also be adapted to represent team collaborations and methodologies.

Metamodels allow application data to be integrated with process context and team activities, which traditional integration technologies have failed to achieve. To realize the benefits of metamodels, however, you must first understand the fundamentals of metadata.

What metadata really means Metadata refers to data about data. It lays the groundwork for capturing structured information about a data element or resource that is machine-interpretable — and enables use of that element in a variety of contexts within applications and components, as well as across systems.

Metadata exists within applications for internal consumption anywhere an application needs to manipulate elements, and occasionally, it is defined formally to facilitate sharing of the information across applications. It does not imply the representation of any specific aspect of an element. Instead, it defines the possible parameters for that element, including structural information (such as the address field in a database record), descriptive information (such as color or type), or administrative information (such as access rules or persistence).

The idea is that metadata does not imply the granularity or composition of a data element. A data element described by metadata could be a field, column, row, table, or database.

Metadata capture also does not necessarily follow any predefined organization or categorization, since application developers make choices based upon how one or many applications expect to consume the metadata, which may represent multiple facets of an element.

Metadata vs. metamodel Whereas metadata relates to information captured about an element, a metamodel generally refers to a formal specification of what information is captured about that element and how it is captured. A metamodel provides a structured, consistent, and shareable mechanism for metadata definition and exchange.

Like metadata, metamodels abound in software systems. Metamodels vary in the type of information specification as well as the degree of abstraction in defining metadata related to an element.

Metamodels provide a frame of reference for capturing information about an element. They may focus on specific dimensions of an element, such as its access rules, device-specific visualization characteristics, and transformation rules across applications.

One metamodel may not serve all purposes of an application or system. Metamodels may be combined, integrated, or leveraged separately depending upon the application and use cases. For example, one metamodel may represent the characteristics of a relational systems (tables, rows, columns, indexes, and so on), and another represents users, groups, and roles. These may be combined to create a facet that not only represents a relational system but also expresses access privileges associated with its resources, specific to users, groups, and roles.

Furthermore, a system may be represented by several metamodels, depending upon the frame of reference of the application and stakeholder. Similar to metadata, metamodels may represent various “views,” such as an analytical view, a design view, a structural view, and more.

Expressing and leveraging metadata Applications use a variety of technologies for expressing and accessing metadata. Beyond embedding metadata internally within application code, the most common medium of expression is XML, which was invented to share information across applications.

XML’s most significant limitation, however, is that it offers no schema or standardized approach to express information about resources or link them with other resources. To facilitate this, frameworks such as RDF (Resource Description Framework) have been introduced. Based upon XML, RDF offers a standardized approach to capturing of information about a resource. It also provides a way to create meaningful and interpretable links between resources (XML structures) across applications and across the Web.

One of the most significant advantages that frameworks such as RDF provide is the ability to extend schemas without directly impacting all the applications that are consumers of that schema.

RDF has further been extended to allow for much more formal representations of taxonomies, hierarchies, attributes, and relationships between various concepts. OWL (Web Ontology Language) provides a highly structured and meaningful approach for the representation of taxonomies, as well as interrelationships between concepts (such as hierarchies and aggregations). Depending upon the flavor of OWL used, there is also a way of characterizing the nature of such relationships to support inferencing. For example:

Symmetric relation:

‘Term A’ is a synonym of ‘Term B’ then

‘Term B’ is a synonym of ‘Term A’ (inferred relation)

Transitive relation:

Domain ‘X’ is related to Domain ‘Y’

Domain ‘Y’ is related to Domain ‘Z’ then

Domain ‘X’ is related to Domain ‘Z’ (inferred relation)

Such expressivity is explicit, machine-interpretable, and platform-independent.

OWL’s expressive capabilities go further. Even its lightest form of implementation can provide an effective implementation of metamodels to include definitions for data (either from SQL or NoSQL sources), visualization (to support mobile devices), taxonomies (for categorization and hierarchical structuring of dimensions and views), report metadata (to support annotations and collaboration), and business vocabularies (such as synonyms, narrower/broader terms, glossaries).

Wikidsmart’s model-driven architecture Wikidsmart’s model-driven architecture leverages the power of OWL-based ontologies as a way of formally expressing the metamodel(s) representing a system (such as CRM or software engineering lifecycle software). Because similar models may exist to represent methodologies, processes, and collaboration, multidimensional integration is possible.

The approach helps facilitate a common understanding of the subsystem and provides a consistent method of capturing and sharing information about specific elements in that subsystem. It supports a platform and application-independent method for capturing metadata that allows:

• Reusability, interoperability and portability of this metadata across applications and systems
• Richer definition of metadata that includes abstractions and broader usability
• A better understanding of the elements in the context of the model
• Reduced maintenance through the lifecycle of applications and systems leveraging this architecture

Wikidsmart’s application-specific connectors automatically capture information from each application and submit it to Wikidsmart Context Server for integration with other relevant concepts in Wikidsmart’s semantic repository. This repository is based on a deep and rich information model for specific domains. Currently, domains representing CRM, software lifecycle management, help desk, and software configuration management are available. Since Wikidsmart is open source, it is possible to extend its deployment into other verticals and domains, providing the appropriate models are provided to support it.

Wikidsmart Context Server interacts with zAgile’s application-specific connectors to provide a common repository of integrated information to the corresponding applications. This, in conjunction with point-to-point connectivity between the tools, provides a rich integrated and interoperable environment across disparate tools.

The value of model-driven integration Organizations often struggle to answer simple questions, such as:

• Which stakeholders are being served by a given project release and what are the costs associated with addressing their concerns?
• What features and requirements are in a given release and what is the test coverage of each?
• Who are all of our customers, which ones are referenceable, what product versions are installed with each, and what is the recent support activity related to them?
• What process/methodology was used to implement a project? What exceptions were raised? How was the project outcome measured?

Finding answers to such questions can be difficult or impossible when valuable information remains fragmented and strewn across all manner of data sources. With a model-driven approach, such as that on which Wikidsmart is based, metamodels can be reused and applied in various contexts, providing structured, consistent, and shareable mechanism for data integration across a wide range of applications and platforms.

New Tech Forum provides a means to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all enquiries to newtechforum@infoworld.com.

This article, “zAgile CEO: Why you should consider model-driven integration,” was originally published at InfoWorld.com. For the latest business technology news, follow InfoWorld.com on Twitter.