Mashup (web application hybrid)

A mashup (computer industry jargon), in web development, is a web page or web application that uses content from more than one source to create a single new service displayed in a single graphical interface. For example, a user could combine the addresses and photographs of their library branches with a Google map to create a map mashup.[1] The term implies easy, fast integration, frequently using open application programming interfaces (open API) and data sources to produce enriched results that were not necessarily the original reason for producing the raw source data. The term mashup originally comes from British - West Indies slang meaning to be intoxicated, or as a description for something or someone not functioning as intended. In recent English parlance it can refer to music, where people seamlessly combine audio from one song with the vocal track from another—thereby mashing them together to create something new.

The main characteristics of a mashup are combination, visualization, and aggregation. It is important to make existing data more useful, for personal and professional use. To be able to permanently access the data of other services, mashups are generally client applications or hosted online.

In the past years, more and more Web applications have published APIs that enable software developers to easily integrate data and functions the SOA way, instead of building them by themselves. Mashups can be considered to have an active role in the evolution of social software and Web 2.0. Mashup composition tools are usually simple enough to be used by end-users. They generally do not require programming skills and rather support visual wiring of GUI widgets, services and components together. Therefore, these tools contribute to a new vision of the Web, where users are able to contribute.

The term "mashup" is not formally defined by any standard-setting body.[2]


The broader context of the history of the Web provides a background for the development of mashups. Under the Web 1.0 model, organizations stored consumer data on portals and updated them regularly. They controlled all the consumer data, and the consumer had to use their products and services to get the information.

The advent of Web 2.0 introduced Web standards that were commonly and widely adopted across traditional competitors and which unlocked the consumer data. At the same time, mashups emerged, allowing mixing and matching competitors' APIs to develop new services.

The first mashups used mapping services or photo services to combine these services with data of any kind and therefore to produce visualizations of data.[3] In the beginning, most mashups were consumer-based, but recently the mashup is to be seen as an interesting concept useful also to enterprises. Business mashups can combine existing internal data with external services to generate new views on the data.

Types of mashup

There are many types of mashup, such as business mashups, consumer mashups, and data mashups.[4] The most common type of mashup is the consumer mashup, aimed at the general public.

  • Business (or enterprise) mashups define applications that combine their own resources, application and data, with other external Web services.[3] They focus data into a single presentation and allow for collaborative action among businesses and developers. This works well for an agile development project, which requires collaboration between the developers and customer (or customer proxy, typically a product manager) for defining and implementing the business requirements. Enterprise mashups are secure, visually rich Web applications that expose actionable information from diverse internal and external information sources.
  • Consumer mashups combine data from multiple public sources in the browser and organize it through a simple browser user interface.[5] (e.g.: Wikipediavision combines Google Map and a Wikipedia API)
  • Data mashups, opposite to the consumer mashups, combine similar types of media and information from multiple sources into a single representation. The combination of all these resources create a new and distinct Web service that was not originally provided by either source.

By API type

Mashups can also be categorized by the basic API type they use but any of these can be combined with each other or embedded into other applications.

Data types


Mashup enabler

In technology, a mashup enabler is a tool for transforming incompatible IT resources into a form that allows them to be easily combined, in order to create a mashup. Mashup enablers allow powerful techniques and tools (such as mashup platforms) for combining data and services to be applied to new kinds of resources. An example of a mashup enabler is a tool for creating an RSS feed from a spreadsheet (which cannot easily be used to create a mashup). Many mashup editors include mashup enablers, for example, Presto Mashup Connectors, Convertigo Web Integrator or Caspio Bridge.

Mashup enablers have also been described as "the service and tool providers, [sic] that make mashups possible".


Early mashups were developed manually by enthusiastic programmers. However, as mashups became more popular, companies began creating platforms for building mashups, which allow designers to visually construct mashups by connecting together mashup components.

Mashup editors have greatly simplified the creation of mashups, significantly increasing the productivity of mashup developers and even opening mashup development to end-users and non-IT experts. Standard components and connectors enable designers to combine mashup resources in all sorts of complex ways with ease. Mashup platforms, however, have done little to broaden the scope of resources accessible by mashups and have not freed mashups from their reliance on well-structured data and open libraries (RSS feeds and public APIs).

Mashup enablers evolved to address this problem, providing the ability to convert other kinds of data and services into mashable resources.

Web resources

Of course, not all valuable data is located within organizations. In fact, the most valuable information for business intelligence and decision support is often external to the organization. With the emergence of rich internet applications and online Web portals, a wide range of business-critical processes (such as ordering) are becoming available online. Unfortunately, very few of these data sources syndicate content in RSS format and very few of these services provide publicly accessible APIs. Mashup editors therefore solve this problem by providing enablers or connectors.

Data integration challenges

There are a number of challenges to address when integrating data from different sources. The challenges can be classified into four groups: text/data mismatch, object identifiers and schema mismatch, abstraction level mismatch, data accuracy.[6]

Text–data mismatch

A large portion of data is described in text. Human language is often ambiguous - the same company might be referred to in several variations (e.g. IBM, International Business Machines, and Big Blue). The ambiguity makes cross-linking with structured data difficult. In addition, data expressed in human language is difficult to process via software programs. One of the functions of a data integration system is to overcome the mismatch between documents and data.[6]

Object identity and separate schemata

Structured data are available in a plethora of formats. Lifting the data to a common data format is thus the first step. But even if all data is available in a common format, in practice sources differ in how they state what is essentially the same fact. The differences exist both on the level of individual objects and the schema level. As an example for a mismatch on the object level, consider the following: the SEC uses a so-called Central Index Key (CIK) to identify people (CEOs, CFOs), companies, and financial instruments while other sources, such as DBpedia (a structured data version of Wikipedia), use URIs to identify entities. In addition, each source typically uses its own schema and idiosyncrasies for stating what is essentially the same fact. Thus, Methods have to be in place for reconciling different representations of objects and schemata.

Abstraction levels

Data sources provide data at incompatible levels of abstraction or classify their data according to taxonomies pertinent to a certain sector. Since data is being published at different levels of abstraction (e.g. person, company, country, or sector), data aggregated for the individual viewpoint may not match data e.g. from statistical offices. Also, there are differences in geographic aggregation (e.g. region data from one source and country-level data from another). A related issue is the use of local currencies (USD vs. EUR) which have to be reconciled in order to make data from disparate sources comparable and amenable for analysis.

Data quality

Data quality is a general challenge when automatically integrating data from autonomous sources. In an open environment the data aggregator has little to no influence on the data publisher. Data is often erroneous, and combining data often aggravates the problem. Especially when performing reasoning (automatically inferring new data from existing data), erroneous data has potentially devastating impact on the overall quality of the resulting dataset. Hence, a challenge is how data publishers can coordinate in order to fix problems in the data or blacklist sites which do not provide reliable data. Methods and techniques are needed to: check integrity and accuracy; highlight, identify and corroborate evidence; assess the probability that a given statement is true; equate weight differences between market sectors or companies; establish clearing houses for raising and settling disputes between competing (and possibly conflicting) data providers; and interact with messy erroneous Web data of potentially dubious provenance and quality. In summary, errors in signage, amounts, labeling, and classification can seriously impede the utility of systems operating over such data.

Mashups versus portals

Mashups and portals are both content aggregation technologies. Portals are an older technology designed as an extension to traditional dynamic Web applications, in which the process of converting data content into marked-up Web pages is split into two phases: generation of markup "fragments" and aggregation of the fragments into pages. Each markup fragment is generated by a "portlet", and the portal combines them into a single Web page. Portlets may be hosted locally on the portal server or remotely on a separate server.

Portal technology defines a complete event model covering reads and updates. A request for an aggregate page on a portal is translated into individual read operations on all the portlets that form the page ("render" operations on local, JSR 168 portlets or "getMarkup" operations on remote, WSRP portlets). If a submit button is pressed on any portlet on a portal page, it is translated into an update operation on that portlet alone (processAction on a local portlet or performBlockingInteraction on a remote, WSRP portlet). The update is then immediately followed by a read on all portlets on the page.

Portal technology is about server-side, presentation-tier aggregation. It cannot be used to drive more robust forms of application integration such as two-phase commit.

Mashups differ from portals in the following respects:

Portal Mashup
Classification Older technology, extension of traditional Web server model using well-defined approach Uses newer, loosely defined "Web 2.0" techniques
Philosophy/approach Approaches aggregation by splitting role of Web server into two phases: markup generation and aggregation of markup fragments Uses APIs provided by different content sites to aggregate and reuse the content in another way
Content dependencies Aggregates presentation-oriented markup fragments (HTML, WML, VoiceXML, etc.) Can operate on pure XML content and also on presentation-oriented content (e.g., HTML)
Location dependencies Traditionally, content aggregation takes place on the server Content aggregation can take place either on the server or on the client
Aggregation style "Salad bar" style: Aggregated content is presented 'side-by-side' without overlaps "Melting pot" style - Individual content may be combined in any manner, resulting in arbitrarily structured hybrid content
Event model Read and update event models are defined through a specific portlet API CRUD operations are based on REST architectural principles, but no formal API exists
Relevant standards Portlet behavior is governed by standards JSR 168, JSR 286 and WSRP, although portal page layout and portal functionality are undefined and vendor-specific Base standards are XML interchanged as REST or Web Services. RSS and Atom are commonly used. More specific mashup standards such as EMML are emerging.

The portal model has been around longer and has had greater investment and product research. Portal technology is therefore more standardized and mature. Over time, increasing maturity and standardization of mashup technology will likely make it more popular than portal technology because it is more closely associated with Web 2.0 and lately Service-oriented Architectures (SOA).[7] New versions of portal products are expected to eventually add mashup support while still supporting legacy portlet applications. Mashup technologies, in contrast, are not expected to provide support for portal standards.

Business mashups

Mashup uses are expanding in the business environment. Business mashups are useful for integrating business and data services, as business mashups technologies provide the ability to develop new integrated services quickly, to combine internal services with external or personalized information, and to make these services tangible to the business user through user-friendly Web browser interfaces.[8]

Business mashups differ from consumer mashups in the level of integration with business computing environments, security and access control features, governance, and the sophistication of the programming tools (mashup editors) used. Another difference between business mashups and consumer mashups is a growing trend of using business mashups in commercial software as a service (SaaS) offering.

Many of the providers of business mashups technologies have added SOA features.

Architectural aspects of mashups

The architecture of a mashup is divided into three layers:

Architecturally, there are two styles of mashups: Web-based and server-based. Whereas Web-based mashups typically use the user's web browser to combine and reformat the data, server-based mashups analyze and reformat the data on a remote server and transmit the data to the user's browser in its final form.[9]

Mashups appear to be a variation of a façade pattern.[10] That is: a software engineering design pattern that provides a simplified interface to a larger body of code (in this case the code to aggregate the different feeds with different APIs).

Mashups can be used with software provided as a service (SaaS).

After several years of standards development, mainstream businesses are starting to adopt service-oriented architectures (SOA) to integrate disparate data by making them available as discrete Web services. Web services provide open, standardized protocols to provide a unified means of accessing information from a diverse set of platforms (operating systems, programming languages, applications). These Web services can be reused to provide completely new services and applications within and across organizations, providing business flexibility.

See also


  1. ^ Fichter Darlene, What Is a Mashup? ( retrieved 12 August 2013)
  2. ^ "Enterprise Mashups: The New Face of Your SOA". SOA WORLD MAGAZINE. Retrieved 2010-03-03. The term mashup isn't subject to formal definition by any standards-setting body.
  3. ^ a b Clarkin, Larry; Holmes, Josh. "Enterprise Mashups". MSDN Architecture Journal. MSDN Architecture Center.
  4. ^ Sunilkumar Peenikal (2009). "Mashups and the enterprise" (PDF). MphasiS - HP.
  5. ^ "Enterprise Mashups: The New Face of Your SOA". SOA WORLD MAGAZINE. Retrieved 2010-03-03. A consumer mashup is an application that combines data from multiple public sources in the browser and organizes it through a simple browser user interface.
  6. ^ a b E. Curry, A. Harth, and S. O’Riain, “Challenges Ahead for Converging Financial Data,” Archived 2012-07-18 at in Proceedings of the XBRL/W3C Workshop on Improving Access to Financial Data on the Web, 2009.
  7. ^ Digna, Larry (2007). "Gartner: The future of portals is mashups, SOA, more aggregation". ZDNET.
  8. ^ Holt, Adams (2009). "Executive IT Architect, Mashup business scenarios and patterns". IBM DeveloperWorks.
  9. ^ Bolim, Michael (2005). "End-User Programming for the Web, MIT MS thesis, 2.91 MB PDF" (PDF). pp. 22–23.
  10. ^ Design Patterns: Elements of Reusable Object-Oriented Software (ISBN 0-201-63361-2) by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides



BlooSee was a web- and mobile-based social mapping platform for ocean recreation and conservation. The platform was designed to host a combination of crowdsourced and institutional media, forecasts, charts, and location-based points of interest, safety, navigation, conservation, and cruising routes.

BlooSee is owned by BlooSee, Inc. a Silicon Valley startup company founded in 2010 by Internet entrepreneurs Pedro Valdeolmillos (originator of the idea) and Marc Puig. It closed in 2015.

Composite application

In computing, a composite application is a software application built by combining multiple existing functions into a new application. The technical concept can be compared to mashups. However, composite applications use business sources (e.g., existing modules or even Web services ) of information, while mashups usually rely on web-based, and often free, sources.

It is wrong to assume that composite applications are by definition part of a service-oriented architecture (SOA). Composite applications can be built using any technology or architecture.

A composite application consists of functionality drawn from several different sources. The components may be individual selected functions from within other applications, or entire systems whose outputs have been packaged as business functions, modules, or web services.

Composite applications often incorporate orchestration of "local" application logic to control how the composed functions interact with each other to produce the new, derived functionality. For composite applications that are based on SOA, WS-CAF is a Web services standard for composite applications.

Data scraping

Data scraping is a technique in which a computer program extracts data from human-readable output coming from another program.

Enterprise Mashup Markup Language

EMML, or Enterprise Mashup Markup Language, is an XML markup language for creating enterprise mashups, which are software applications that consume and mash data from variety of sources, often performing logical or mathematical operations as well as presenting data. Mashed data produced by enterprise mashups are presented in graphical user interfaces as mashlets, widgets, or gadgets. EMML can also be considered a declarative mashup domain-specific language (DSL). A mashup DSL eliminates the need for complex, time-consuming, and repeatable procedural programming logic to create enterprise mashups. EMML also provides a declarative language for creating visual tools for enterprise mashups.

The primary benefits of EMML are mashup design portability and interoperability of mashup solutions. These benefits are expected to accelerate the adoption of enterprise mashups by creating transferable skills for software developers and reducing vendor lock-in. The introduction of EMML is expected to help accelerate the trend toward the integration of Web-based applications and service-oriented architecture (SOA) technologies. Bank of America was a high-profile early supporter of EMML. Other prominent early supporters included Hewlett-Packard, Capgemini, Adobe Systems, and Intel.

Fluid UI

Fluid UI is a browser-based wireframing and prototyping tool developed by Fluid Software and used to design mobile touch interfaces.

Importer (computing)

An importer is a software application that reads in a data file or metadata information in one format and converts it to another format via special algorithms (such as filters). An importer often is not an entire program by itself, but an extension to another program, implemented as a plug-in. When implemented in this way, the importer reads the data from the file and converts it into the hosting application's native format.

For example, the data file for a 3D model may be written from a modeler, such as 3D Studio Max. A game developer may then want to use that model in their game's editor. An importer, part of the editor, may read in the 3D Studio Max model and convert it to the game's native format so it can be used in game levels.

Importers are important tools in the video game industry. A plug-in or application that does the converse of an importer is called an exporter.


JackBe Corporation was a privately held vendor of enterprise mashup software for real-time intelligence applications. In August 2013 JackBe was acquired by Software AG JackBe's flagship product is an enterprise mashup platform called Presto, which is used for enterprise mashups, business management dashboards, and real-time intelligence applications.

Lotus Mashups

Lotus Mashups is a business mashups editor developed and distributed by IBM as part of the IBM Mashup Center system. Lotus Mashups is intended for use in professional environments, such as corporations and governments.


MashQL is a semantic data mashup language. The idea of MashQL is to allow people to query, mash up, and pipeline RDF data intuitively. In the background MashQL queries are automatically translated into and executed as SPARQL queries. The novelty of MashQL is that it allows one to query (and navigate) an RDF graph without any prior knowledge about its schema, vocabulary, structure or technical details; as well as it supports query pipelines as a built-in concept.

MashQL is also called as a query-by-diagram language where users create mashups in a graphical manner while the queries are generated in the background. This is different from more developer oriented approaches such as extensible Javascript for instance.


Mashup may refer to:

Mashup (culture), the rearrangement of spliced parts of musical pieces as part of a subculture

Mashup (education), combining various forms of data and media by a teacher or student in an instructional setting

Mashup (music), a song or composition created by blending two or more pre-recorded songs

Mashup (video), a video that is edited from multiple sources to appear unified

Mashup (book), fiction combining pre-existing literature with other genres to create a single narrative

Mashup (web application hybrid), a web application that combines content from more than one source in a single graphical interface

"Mash-Up" (Glee), the eighth episode of the American television series Glee, first aired in 2009

Mash Up (TV series), a 2012 American television show on Comedy Central starring T.J. Miller

Mashup (culture)

Participants in an online music scene who rearrange spliced parts of musical pieces form mashup culture. The audio-files are normally in MP3 format and spliced with audio-editing software online. The new, edited song is called mashup. The expression mashup culture is also strongly connected to mashup in music. Even though it was not originally a political community, the production of mash-up music is related to the issue of copyright. Mashup Culture is even regarded as "a response to larger technological, institutional, and social contexts".

Microsoft Popfly

Microsoft Popfly (internally codenamed Springfield) was a Web site that allowed users to create web pages, program snippets, and mashups using the Microsoft Silverlight rich internet applications runtime and the set of online tools provided. It was discontinued on August 24, 2009.

Open API

An open API (often referred to as a public API) is a publicly available application programming interface that provides developers with programmatic access to a proprietary software application or web service. APIs are sets of requirements that govern how one application can communicate and interact with another. APIs can also allow developers to access certain internal functions of a program, although this is not typically the case for web APIs. In the simplest terms, an API allows one piece of software to interact with another piece of software, whether within a single computer via a mechanism provided by the operating system or over an internal or external TCP/IP-based or non-TCP/IP-based network. In the late 2010s, many APIs are provided by organisations for access with HTTP. APIs may be used by both developers inside the organisation that published the API or by any developers outside that organisation who wish to register for access to the interface.

Open Mashup Alliance

The Open Mashup Alliance (OMA) is a non-profit consortium that promotes the adoption of mashup solutions in the enterprise through the evolution of enterprise mashup standards like EMML. Enterprise mashup usage is expected to grow tenfold in the next five years. The initial members of the OMA include some large technology companies such as Adobe Systems, Hewlett-Packard, and Intel, and some major technology users such as Bank of America and Capgemini.

According to information technology industry analyst Dion Hinchcliffe, "Ultimately, the OMA creates a standardized approach to enterprise mashups that creates an open and vibrant market for competing runtimes, mashups, and an array of important aftermarket services such as development/testing tools, management and administration appliances, governance frameworks, education, professional services, and so on."


QuickCode (formerly ScraperWiki) is a web-based platform for collaboratively building programs to extract and analyze public (online) data, in a wiki-like fashion. "Scraper" refers to screen scrapers, programs that extract data from websites. "Wiki" means that any user with programming experience can create or edit such programs for extracting new data, or for analyzing existing datasets. The main use of the website is providing a place for programmers and journalists to collaborate on analyzing public data.The service was renamed circa 2016, as "it isn't a wiki or just for scraping any more". At the same time, the eponymous parent company was renamed 'The Sensible Code Company'.

Situational application

In computing, a situational application is "good enough" software created for a narrow group of users with a unique set of needs. The application typically (but not always) has a short life span, and is often created within the group where it is used, sometimes by the users themselves. As the requirements of a small team using the application change, the situational application often also continues to evolve to accommodate these changes. Although situational applications are specifically designed to embrace change, significant changes in requirements may lead to an abandonment of the situational application altogether – in some cases it is just easier to develop a new one than to evolve the one in use.

Ubiquity (Firefox)

Ubiquity, an add-on for Mozilla Firefox, is a collection of quick and easy natural-language-derived commands that act as mashups of web services, thus allowing users to get information and relate it to current and other webpages. It also allows Web users to create new commands without requiring much technical background.


A webhook in web development is a method of augmenting or altering the behavior of a web page, or web application, with custom callbacks. These callbacks may be maintained, modified, and managed by third-party users and developers who may not necessarily be affiliated with the originating website or application. The term "webhook" was coined by Jeff Lindsay in 2007 from the computer programming term hook.The format is usually JSON. The request is done as a HTTP POST request. The receiving endpoint can choose to whitelist certain IP addresses from known sources. The webhook can include information about what type of event it is, and a secret or signature to verify the webhook. GitHub and Stripe signs their requests using a HMAC signature included in as HTTP header. Facebook signs their requests using SHA-1.

Yahoo! Pipes

Yahoo! Pipes was a web application from Yahoo! that provided a graphical user interface for building data mashups that aggregate web feeds, web pages, and other services, creating Web-based apps from various sources, and publishing those apps. The application worked by enabling users to "pipe" information from different sources and then set up rules for how that content should be modified (for example, filtering). Other than the pipe editing page, the website had a documentation page and a discussion page. The documentation page contained information about pipes including guides for the pipe editor and troubleshooting. The discussion page enabled users to discuss the pipes with other users.


This page is based on a Wikipedia article written by authors (here).
Text is available under the CC BY-SA 3.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.