Intro

EntMa

JackB

J

An duction to

erprise shups

e Corporation

une, 2007

Table of Contents

Defining Enterprise Mashups ......................................................................................3

The Case for Enterprise Mashups................................................................................3

A Foundation for Enterprise Mashups..........................................................................4

Information............................................................................................................5

Mediation...............................................................................................................5

Governance ...........................................................................................................6

Interface................................................................................................................7

Steps to Creating an Enterprise Mashup......................................................................7

Step 1: Determining Patterns of Use........................................................................8

Step 2: Identifying Sources .....................................................................................9

Step 3: Understanding Services...............................................................................9

Step 4: Interface ..................................................................................................10

JackBe’s Enterprise Mashup Solution......................................................................... 10

Conclusion .............................................................................................................. 12

2

An Introduction to Enterprise Mashups

Defining Enterprise Mashups Today’s businesses move quickly and agility can become a critical core competency. For business users, this can mean a need to easily and quickly self-consume service data, create business applications, quickly and easily, to support an agile enterprise. This is the concept behind enterprise mashups.

According to the Wikipedia, a mashup ‘is a website or application that combines content from more than one source into an integrated experience’1. By extrapolation, the enterprise mashup is composed of what’s best about new Internet interface technology like Ajax with what’s best about new enterprise information integration approaches such as SOA. More formally, enterprise mashups are a way for business users to self-integrate data from enterprises data sources while conforming to enterprise standards for security, reliability and governance.

The Case for Enterprise Mashups The Web provides a sound proving ground for applications, architecture, and platforms of the modern enterprise. Indeed, as the Web grew in popularity in the early 90s, it was quickly put into use within many enterprise as intranet applications, or enterprise applications leveraging Web technoloCGI, NSAPI, ISAPI, etc.

Today, with modern Rich Internet Applications (RIA) technologyenterprises have the ability to create Web applications that haveas existing client-server applications, both inside and outside of Moreover, with the pervasiveness of broadband, modern securitacceptance of Web-delivered applications, it’s easy to see how tbetween the Web and the more traditional ‘fat client’. Enterprisexample of this trend.

1 http://en.wikipedia.org/wiki/Mashup_%28web_application_hybrid%29

A popular example of a consumer mashup is seen here: Flickr Photos on

a third-party map.

gy such as HTML, HTTP,

such as AJAX, the same look-and-feel the enterprise. y technology, and user he lines are blurring e mashups are a clear

3

However, just having the ability to do mashups does not mean that they are ready for the enterprise. We must properly provision and manage the services available for mashups, and understand their purpose and place in the context of an overall enterprise strategy. The supporting technology to make it ‘enterprise ready’ includes:

• Secure access to data and services from disparate locations and systems. • Flexible and efficient user-driven integration capabilities. • Ability to leverage public and private data assets through enterprise mashups. • Entitlement-based sharing of user created mashups and widgets.

In essence, we’re looking to manage access to assets that we may or may not control, and make sure those assets are consumable, secure and governed. Moreover, we want to create micro-applications by mashing up valuable information, and behaviors into an application that has both situational and long-term value to the business. Missing from this notion in many organizations is a layer of intelligent software that sits between the data systems and the end users and makes the tools and environment available for the tacit user. It’s this technology that provides the agility between the core business information-behavior, and the end user who needs the value of both. This layer allows the user to mix and match information, rules, logic, and external data, in an ad-hoc manner to form meaningful applications and views. And thus, provides the value of productivity, performance, agility, and reuse. Indeed, these views and applications are customizable at any time and for any reason (if authorized), and support the need for users to align with the ever changing business needs.. In essence, this is the perfect business information system, which is easily aligned to the business through this ad-hoc client, leveraging Ajax, and the “mashup-oriented SOA software” behind it. Creating enterprise mashups is something that requires some planning and proven Web 2.0 technology for enterprise mashup development, as well as the use of open-standards. This paper explores an approach for establishing mashups as valuable enterprise tool.

A Foundation for Enterprise Mashups While there are many different applications of mashups for all sorts of business purposes, there are some commonly-recurring parts to mashup implementations. Identifying some of these parts will allow for better understanding, planning, and design. They are:

• Information • Connectivity and Mediation • Governance

4

• Open Access

Information Information is the foundation of any mashup, since you’re typically processing, changing, exposing, and/or analyzing information when considering the business purpose of the mashup. Thus you need to examine two information domains: Enterprise metadata, as related to your target mashups, and external metadata, or information bound to services, APIs, or applications you don’t own (see Figure 1).

Figure 1: The first step in designing a mashup is understanding the information.

At the end of this process you should have an inventory of the metadata that feeds into your mashup, metadata that’s local to your mashups, the abstraction of that information into logical groupings for your mashups, and any data services that are leveraged or created for your mashups.

Mediation Once the information layer is understood, we need to understand how we are going to connect to disparate data sources and mediate the difference between the protocols and semantics of these sources. Key to this step is enabling integration technology that’s ‘mashup-aware’, capable of placing a mediation layer between the systems you’re mashing up. This layers brings information from many back-end systems to a single user interface or enterprise mashup.

5

It’s important that your mediation layer be able to work and play well with your target mashup environment (often a browser), and manage back-end resources as they change over time. Moreover, the medium layer needs to deal with resources that are both local and remotely hosted.

Governance One of the critical components to a mashup infrastructure is a governance layer, or the ability to track and manage critical components of your mashup, including interfaces, services, data, security, and other resources. The governance layer provides the following key features

• The ability to maintain a directory of all resources, including information, services, and mashups.

• Manage security around those resources.

• Manage policy around those resources.

• Manage design and interdependencies around those resources.

Enterprise M

Before planning and implementing an enteintegration patterns most commonly addrebelow outlines these patterns.

Pattern Description

Filtering

filter, group, sort, coresult sets

Join/Merge

join or merge data fvarious service typemesh database recoRSS feed data

Semantic Equivalence

abstracting disparatemodels to ease repoanalysis across multdatabase sources

Analysis

execute statistical &mathematical functioagainst one or moreservice result sets

Transformation

unify data formats astructure

Graphical Data Canvas

automatically bind cdata types to compagraphical objects i.eTable, Calendar, Tim

Service Choreography

define a more compsequence of actions manipulate output fror more services

Dynamic Drilldown

enable widgets to inservices based on re

ashup Patterns

rprise mashup, it can help to understand the ssed by enterprise mashups. The table

Example

mpare Pricing Analysis: define data filtering actions against different services to automate ad-hoc analysis of regional sales data

rom s i.e. rds with

Market Research: combine county property data with retail sales figures with demographics data to pick new store location

data rting and iple

Global Revenue Reporting: quickly determine who the top 50 clients are even though multiple reps have sold different products to different divisions of the same overall client entity

ns

data

Risk Forecasting: financial analysts must apply min/max, avg., std. deviation functions to develop forecast models

nd data Insurance Pricing: transform columnar data from a legacy system so we can apply a new formula that expects input data to be in rows

ertain tible . Chart, eline

Project Management: if the imported data represents dated events, automatically plot them into a graphical calendar or timeline

lex that om one

Custom Billing: get usage data set A, find the average, repeat for data set B, C, and D; finally determine the average of the averages

voke Accounts Receivable: invoke the

• Manage the allocation of the mashups themselves, once created and in the directory.

6

sults delinquent account process if any account becomes ninety days past due

Interface When building mashups, interfaces are fundamental. Indeed, they provide the platform for combining services, other interfaces, and information into the target solution. The core features of interface development technology for enterprise mashups should include the ability to:

• Unite data from disparate core assets for the end user.

• Present dynamic, interactive views of real-time business data.

• Reduce development and deployment times and costs.

• Support RIA technology, such as AJAX, for rich dynamic user interfaces.

The interface development environment needs to support the creation of key dynamic elements for the user interface, as well as leverage the combination of back end services and information resources to form the enterprise mashup (See Figure 2)

Figure 2: Mediation layers bring information from all types of back-end systems to a single user interface or mashup.

Steps to Creating an Enterprise Mashup

7

Creating an enterprise mashup is much like many modern application development exercises today, typically leveraging pre-built component parts as well as predefined information and structures. Thus, the approach is more about combining than new development, which makes this approach that much more valuable to the business

because you’re adding value to existing enterprise assets by leveraging them in new ways to meet specific business needs.

The steps for creating an Enterprise Mashup include:

1. Determining Patterns of Use

2. Identifying Sources (Note: Understanding Semantics is too heavy)

3. Understanding Services

4. Mashup Design

5. Assembly and Testing

Step 1: Determining Patterns of Use Determing the pattern of use requires analysis of the requirements for the end user’s perspective, focusing upon the target use case for the enterprise mashup and what business problem does it solve. Typically this includes the following:

• The business purpose for the mashup(s).

• The use cases as defined by the target user.

• Definition of a successful final mashup instance.

• Cost savings realized if mashup is effective

• How this mashup will work and play with existing enterprise processes.

Thus, what comes out of this step is a clear understanding of what the enterprise mashup will do, and who will use it, why, and for what business purpose. This analysis will provide important guidance to the next few steps of the mashup implementation.

8

Enterprise Mashup Case Study: The DIA Takes a Futuristic Approach To Collaboration

In today’s intelligence community the need to be technologically driven correlates directly to the centralization of information among various

government agencies. The need for rich and effective collaboration and integration solutions that enable communication flow throughout government

departments are essential to building mission critical applications. Overwatch is a Virtual Operating Center application that integrates multiple intelligence sources into a desktop like intelligence asset dashboard for the real-time

analysis of data.

Agency Profile

The Defense Intelligence Agency is a Department of Defense combat support agency and an important member of the United States Intelligence Community.

With over 11,000 military and civilian employees worldwide, DIA is a major producer and manager of foreign military intelligence. The DIA provides military

intelligence to warfighters, defense policymakers and force planners, in the Department of Defense and the Intelligence Community, in support of U.S.

military planning and operations and weapon.

Challenge

Under time constraints, DIA needed a fully functioning technological platform that would present a browser based interactive application complying with

government security standards. The DIA chose the JackBe solution because it eliminated significant time and rich in developing an Ajax-based solution. Alternative solutions did not provide the version control, browser-server

asynchronous communications tier and API required to make this project a success. JackBe was able to provide expert professional services consultants,

trained in the use of JackBe software, to quickly join the project team and ensure knowledge transfer and rapid development.

Solution

Overwatch (See Figure 2) was designed to address these challenges by empowering the end user to quickly paint a picture of situational awareness

across various intelligence data sources, using a paradigm of drag-and-drop and bookmarking that is used for future private briefings. The process begins with a user selecting an Area of Responsibility such as a Combatant Command, which

limits all intelligence to that specific AOR.

The user then selects the type of intelligence such as a facility, personnel, naval vessel, aircraft, event or travel, to further limit intelligence to that specific type. Additional filtering can be specified depending on the type. Once filtered, the

resulting intelligence asset can be updated and comments made for rapid information sharing to occur.

Step 2: Identifying Sources In this step we need to understand the information sources we expect to leverage within the mashup, including:

• The source databases and attributes, source enterprise applications, and which ones are to be leveraged by this mashup. This provides for a better definition of just where the data is coming from as well as ownership.

• The development of metadata information around the key data elements, including structure, security, and business purpose. This provides for the further refining of the data into metadata, and thus a better semantic understanding of the information.

• Logistical grouping of information for the purpose of the mashup. For instance, all sales information combined within a virtual sales database linked back to several different physical databases. This provides a better logical representation of complex data, thus making the creation of the mashup easier.

Step 3: Understanding Services Information sources can be considered information ‘services’. Services can come in all shapes and sizes, including existing services built upon legacy APIs, new services built from scratch, or composite services where services are combined, or simple data services. In this step we need to:

• Catalog all candidate services, both public and private, that have potential value for our enterprise mashup, like the examples depicted in Figure 32.

• Understand which information is bound to those services, using information gathered in Step 2.

• Consider access methods, including protocols, enabling standards (such as Web services), and performance.

• Expose older sources in more standardized interfaces formats such as SOAP.

• Capture all Services in a centralized repository for easy reuse as well as security and governance monitoring.

• Integrate services, when necessary, to allow for better use by users.

9

2 Source: www.csc.com, ‘Harnessing Web 2.0: Enterprise Strategies for Living on the Web’, Spring 2007

Step 4: Interface Finally, it’s the “build it” step. As the user is the driver of the final mashup, the primary concern is the installation of an interface that:

• Can consume the services exposed in step 3,

• Allow for additional service integration not pre-integrated in step 3,

• Support the presentation of information via common ‘skins’ such as graph, table, map, calendar, and timeline,

• Provides features for user preferences and layouts to be frozen, saved and reloaded.

JackBe’s Enterprise Mashup Solution Considering how enterprise mashups are understood, designed, and built, it’s helpful to employ an enterprise mashup development platform that includes much of the component parts commonly required. Using such technology could add up to huge savings in both productivity and management of the enterprise mashup.

JackBe’s Presto platform offers an enterprise-grade architecture for mashups. Presto’s features are components that provide Ajax messaging, dynamic combination or ‘mashup’ of disparate SOA services, development and run-time frameworks, and a browser-based studio that empowers users to address their own application needs.

Presto addresses three of the business requirements critical to deploying Enterprise Mashups:

1. Governance: Service Management integrated with common enterprise tools for security and management

2. Empowerment: Rich service consumer interfaces for both advanced IT developers as well as business unit power users.

3. Reliability: Robust and secure Ajax messaging for enterprise-class service mashups.

10

To address these business mashup needs, Presto includes:

• Presto Studio, a visual drag-and-drop IDE that allows developers to create rich Ajax-based micro-forms and smart widgets for consumption by Dash users or for use in rich interactive portal enhancement (RIPE) projects. Packed with features based on five years of commercial deployments, Studio includes a complete palette of application widgets, a WYSIWYG canvas, and includes JackBe’s powerful Enterprise Ajax Framework API for extreme Web 2.0 development and production performance. And because Studio is integrated with Presto Edge server, binding services to your Enterprise Web 2.0 applications and creating smarter widgets is a simple point, click, and configure process.

• Presto Dash, a dynamic Desktop for User-Driven Mashups & Analytics. More and more workers rely on information stored inside and outside the enterprise and increasingly see the benefits of blending the two together on-the-fly to solve a particular need. Presto Dash removes user productivity barriers by packaging the latest web technologies into a browser-based desktop solution allowing users to process many pieces of diverse information, and then combining them in a meaningful way. Dash reduces the time employees spend searching, accessing, retrieving, and then using the information to do their jobs.

• Presto Edge, a virtualization, mashup, and collaboration server. The freedom and power of Enterprise Web 2.0 user-driven integration makes it difficult to predict how users will leverage the assets they now have at their fingertips. Presto Edge’s virtualization capabilities provide the most flexible, scalable, and secure access means for Enterprise Web 2.0 users and developers to quickly consume internal and external services (WSDL, REST, RSS, etc), databases, POJO’s, ERP, mainframe, or even “legacy” Web applications. Presto Edge’s mashup capabilities lets users and developers massage, manipulate, and combine services so relevant information is harnessed from the plethora of services coming on-line each day. Finally, Presto Edge’s collaboration capabilities give users virtual collaboration spaces for sharing and finding useful mashups, composite services, and other creations that benefit colleagues and partners. Presto Edge also addresses the basic requirements common to all applications: real-time data delivery and security with data ‘push’ features to ensure that all Presto applications can provide timely information to the user’s application or mashup. And Edge allows managers to define domain-specific consumption policies while enforcing existing identity management and SOA policies to ensure users access and mashup appropriate assets on-the-fly as they see fit to complete their tasks.

11

Presto provides the software infrastructure to provide consolidated views that access both internal and external information in a trusted environment.

Conclusion While enterprise mashups are relatively new, the foundation of this technology and influence of the emerging Web 2.0 really define their value for solving critical business problems quickly and easily. Considering the value of these applications, we mush also carefully consider their purpose, form, and fit for both the end user and the enterprises in which they will add value. In essence, we approach enterprise mashups as a valuable enterprise asset that has the potential to add significantly to the bottom line.

Beyond approaches, a critical success factor is leveraging the correct technology for the job. While existing development environments are always a consideration, the unique aspect of mashups call for technology that addresses enterprise mashups specifically. By leveraging this technology, you’ll find that it quickly pays for itself in both developer productivity and operational efficiencies. Moreover, it does not replace, only enhances, existing enterprise assets such as services or information. Enterprise mashup are indeed the wave of the future, and approached correctly with the proper technology, have huge ROI potential.

12