TIBCO ActiveSpaces Use Cases

How in-memory computing supercharges your infrastructure

S O L U T I O N B R I E F
Table of Contents
3 | Introduction
4 | Caching
6 | Accelerating Services
8 | Spikes in Processing
8 | E-Commerce
9 | Fault Tolerance and Disaster Recovery
11 | Distribution of Rapidly Changing Data
11 | Offoading Expensive Resources
11 | Messaging
13 | TIBCO BusinessWorks Enhancements
13 | Fast Data Visualization
13 | Summary
S O L U T I O N B R I E F
3
TIBCO ActiveSpaces

is a distributed in-memory data grid

that provides very fast data access and update. While its
performance will vary depending on multiple factors, it is
not uncommon for ActiveSpaces to be 100x faster than
corresponding database implementations. For this reason
and others described here, ActiveSpaces is a great solution
for lifting the burden of big data, reducing reliance on
costly transactional systems, and building highly scalable,
fault-tolerant applications.
Introduction
Combining the features and performance of databases, caching systems, and messaging
software, TIBCO ActiveSpaces supports very large, highly volatile data sets and event-
driven applications as described in the use cases that follow. In addition, it provides:
Distributed, Dynamic Architecture: Scales and handles large data volumes.
Dynamically adds or drops nodes without requiring a system restart.
Distributed Processing: Processes data on each node, in parallel, in a distributed
manner. Handles large processing requirements by distributing the processing over
multiple servers. Supports transactions across multiple spaces (tables).
Fault Tolerance: Stores backup copies of data on multiple nodes, so in case of node
outage(s), processing continues without impact. Data is redistributed as a background
task without impacting on-going processing.
Persistence Options: Optionally provides no persistence with data stored in a
database (shared all) or locally in fles on each node (shared nothing).
Put and Take: Employs operations similar to messaging. Allows for client applications
to register to receive events when certain criteria are met as defned by a SQL-
likequery.
Query Support: Supports a subset of SQL-like queries.
Confgurable Data Purging: Allows time to live (TTL) to be confgured for items in the
space, automatically removing items when TTL has expired.
Data Lock Controls: Provides ability to lock items, with features for lock wait, lock
break, and automatic release of the lock.
Embedding: Transparently embeds with applications or confgures as separate nodes
that are accessed by applications.
Remote Invocation: Provides the ability to invoke processing on other node(s).
ActiveSpaces is a great solution
for lifting the burden of big
data, reducing reliance on
costly transactional systems,
and building highly scalable,
fault-tolerant applications.
TIBCO ActiveSpaces Use Cases
How in-memory computing supercharges your infrastructure
S O L U T I O N B R I E F
4
Caching
Caching for Fast Data Access
ActiveSpaces is frequently used as a cache to speed information access. In this example,
ActiveSpaces is not the system of record for the data in the cache. A separate loader
process or application is responsible for loading the data into ActiveSpaces. Because
the data is read-only, ActiveSpaces does not require persistence to save data changes.
This makes all ActivesSpaces gets very fast. A side beneft is that the processing load on
the back-end data store is reduced because the client applications are not querying the
master data set.
ActiveSpaces
Loader
Client Client Client Client
Data
Your Industry
ActiveSpaces clients can be written
in many technologies including Java,
.Net, C++, TIBCO BusinessWorks

, and
TIBCO BusinessEvents

. The examples
presented here include specifc
industry scenarios, but use cases can
apply to many industries.
S O L U T I O N B R I E F
5
Caching + Dynamic Load
A variation on the caching example is to have the data dynamically loaded into
ActiveSpaces when the data is frst accessed by a client application. A service is provided
that frst looks in ActiveSpaces for the data. If found, the data is directly returned. If the
service does not fnd the data in ActiveSpaces, it queries a backend data store. If the data
is found in the backend data store, it is returned to the client application and stored into
ActiveSpaces. If desired, time to live (TTL) can be confgured for the data in ActiveSpaces
so that it is automatically purged. One beneft of this approach is that the service can
present a standard interface and the client applications are not required to implement
any ActiveSpaces code.
Service
ActiveSpaces
Client Client Client Client
Data
S O L U T I O N B R I E F
6
Accelerating Services
Broad Performance Improvements
There are many ways that ActiveSpaces can be used to speed services. It can
cache information from back-end applications or cache common lookup, index, or
transformation information. Any service that retrieves data from an external data
store, application, or fle system has the potential for performance improvement using
ActiveSpaces.
Ultra-Fast Data Store
ActiveSpaces can also be used as a very fast data store. In this case, it allows updates to
the data and persists the new data values. It provides two options for persisting data:
shared all (database) and shared nothing (distributed fle system). The shared nothing
approach is illustrated below. With shared nothing, each ActiveSpaces node maintains
a fle with only the subset of data that is managed by the node. The system volume and
speed is scaled by adding more nodes on different servers.
ActiveSpaces
Client Client Client Client
File File File
Non-Stop Data Store
While possible, it can be expensive to achieve 24x7x365 availibility with database
technologies because they are frequently deployed on separate, potentially expensive
hardware platforms. This hardware can add more failure points and reduce calculated
reliability numbers. Further, databases often require planned outages for routine
maintenance.
With ActiveSpaces it is often possible to remove the database and the associated failure
points from these implementations. ActiveSpaces persistence is distributed across
multiple commodity servers, providing a high availability system at a fraction of the cost
of other approaches.
Distributed,
NotCentralized
Databases are central to many
enterprise applications, but also
struggle to handle high volumes,
rapidly changing values, and large
numbers of concurrent client
applications. ActiveSpaces can be
used to improve their performance;
However, it is rarely a drop-in, no-
code replacement because the
application/database interchange
can be complicated, involving SQL,
business logic, and data spread across
architectural tiers.
Because ActiveSpaces uses a
distributed architecture to achieve
its performance and fault tolerance,
some database features are not
directly supported. For example, the
ActiveSpaces JDBC driver does not
support all SQL language syntax
but there are ways to provide the
samefunctionality.
S O L U T I O N B R I E F
7
Fast Data Store with Separate Master Update
A more full-featured use case involves using ActiveSpaces to manage high volumes of
data reads and updates, and to also send and receive data updates from a separate
master system of record. This is especially useful when spikes of data access and data
updates overload the back offce system of record. An ActiveSpaces event listener gets
notifed whenever a data value is changed and sends updates through a message queue
(for example, TIBCO Enterprise Message Service

) for updating the master system

of record. The back offce system can also be updated through other channels so any
updates are passed through a loader back to ActiveSpaces.
ActiveSpaces
Client Client Client Client
Data
Base
File File File
App
Event
Listener
Loader
ActiveSpaces and Sorts
ActiveSpaces queries run in parallel
on multiple nodes, and the result is
passed back to the client application
unsorted. The client application can
perform the sort, if desired.
S O L U T I O N B R I E F
8
Spikes in Processing
Spikes in Processing: Ticket Sales
ActiveSpaces is frequently used to handle spikes in processing that would overwhelm
legacy systems, such as tickets sales made over the web or through multiple channels.
When highly sought-after tickets are frst offered, a large number of consumers will
attempt to purchase immediately. ActiveSpaces manages the spike in processing volume,
providing accurate, real-time inventory and seat reservation data. The spike of data is
passed to the back-offce system of record at a lower volume that can be more easily
handled by these systems.
Spikes in Processing: Online Betting
Certain Internet events can have a large number of users simultaneously logging in
horse races, sporting events, election results coverage. If an issue occurs that causes
users to be logged off, it will likely cause hundreds of thousands, or even millions, of
users to simultaneously try to log back in. This huge spike in processing will overwhelm
most conventional systems. In the case of online betting for a horse race, most bets are
placed a few minutes before the start of the race. An outage at this time could have a
multimillion dollar impact.
ActiveSpaces is used in these types of scenarios to cache user information in a fault-
tolerant manner and to handle extremely high spikes in processing.
E-Commerce
Session Caching for E-commerce
Much e-commerce data is only needed for the current session. ActiveSpaces is used to
cache this information and speed system response.
Load
Balancer
Client Requests
HTTP Web Servers with Inline Cache
ActiveSpaces
ActiveSpaces and Joins
Distributed processing prevents
ActiveSpaces from performing joins of
multiple tables. So you cannot directly
perform an operation like the following,
but you could use multiple queries
and some processing by the client to
arrive at the same result: Select * from
Customer, Orders, Inventory where
Customer.id = Order.customerId and
Order.partnum = Inventory.partnum
order by Order.date.
One technique for addressing joins
is to de-normalize data by combining
what would be contained in multiple
tables in a relational database into a
single table, or space, in ActiveSpaces.
There is often suffcient memory
to accommodate de-normalized
data, and with ActiveSpaces it is
faster to perform one get or set on
a large row of data than operations
on smaller sets in three separate
spaces. Therefore, many ActiveSpaces
implementations focus on fatter data
sets; implementations to handle very
complex hierarchical data may require
additional work.
Implementation
Differences
It can be possible to use ActiveSpaces
to increase application performance
without impacting the application
or the application database. Or,
development may be required to
add ActiveSpaces to the architecture.
Some analysis of the application,
data, and process will be required in
each situation to determine the best
approach for using ActiveSpaces to
speed application processing.
S O L U T I O N B R I E F
9
Dynamic Inventory
Dynamic inventory that is viewed and accessed from a variety of channels provides
a great use case for ActiveSpaces. One nationwide retailer maintains an inventory of
returned or damaged items using ActiveSpaces, which allows local store employees to
enter and update their inventory and local web users to view and purchase items for pick
up. With ActiveSpaces, the retailer can manage the dynamic inventory in real-time for
hundreds of stores.
Real-Time Offers
Formulating and presenting offers customized in real time according to user preferences
is an ideal use case for ActiveSpaces. When a telecom customer is reviewing their usage
and remaining minutes, they may be considering moving to a different carrier. In that
moment, they are also more likely to accept a special offer designed to keep them.
A retail customer is more likely to accept an offer at the point of sale rather than
afterwards. Presenting offers in real time requires immediate access to customer
information, usage, or spending history, as well as information on prior offers. This
information is often contained in overloaded billing or customer relationship
management (CRM) systems that cannot respond as quickly as needed. Adding a real-
time offer capability to these systems will just further overload them.
ActiveSpaces can provide real-time access to customer preferences, recent spending
history, and other relevant information and service a high volume of requests.
Fault Tolerance and Disaster Recovery
Fault-Tolerant Active-Active Processing
Many applications provide fault tolerance by running in active-standby on multiple
servers. The standby server or server application can be either warm (running but not
processing) or cold (not running). With ActiveSpaces it is possible to build fault-tolerant
applications that run on multiple servers in an active-active confguration. The data and
state information is shared by all servers, and back-up copies of the information can
be persisted on multiple servers. ActiveSpaces provides sophisticated and fast-locking
mechanisms that can be used to synchronize processing across multiple servers.
ActiveSpaces
File File
Server Server
App App
S O L U T I O N B R I E F
10
Multisite Data Replication
Many organizations would like to run certain applications in multiple data centers in an
active-active manner, or at least to have the data synchronized. It is not recommended
to run ActiveSpaces across data centers that are more than a few kilometers apart.
The network latencies will impact the overall system performance and can lead to
othercomplications.
However, it is possible to have ActiveSpaces in each data center synchronized. The
technique uses a local event listener that can remotely invoke processing in the other
data centers. Updates to ActiveSpaces in one data center are replicated in the other.
With this technique, the data centers can operate in an active-active mode, and both
have copies of the data in case of disaster recovery.
ActiveSpaces ActiveSpaces
Client Client
Event
Listener File File
Event
Listener
Data Center A Data Center B
Remote
Invocation
S O L U T I O N B R I E F
11
Distribution of Rapidly Changing Data
Database technology is useful for long-term data storage, but not as well suited for
managing large volumes of rapidly changing data. There are many situations where only
the most recent values in a large, rapidly changing dataset are of interest. Examples
include power plant monitoring data, stock market prices, satellite telemetry, and
the status and location of packages. The system load becomes more intensive when
there are a large number of consuming systems that are interested in subsets of the
overallinformation.
ActiveSpaces can manage large volumes of rapidly changing data. Client applications
register event listeners for specifc subsets of the information and are notifed in real-time
when data events of interest occur.
Offoading Expensive Resources
Legacy back offce applications can be very expensive to operate and scale, especially
when mainframes incur a charge on a per transaction basis. When the transaction is a
read of non-changing or slowly changing data, ActiveSpaces can be used as a cache to
reduce the load and cost of expensive resources.
Messaging
Routing Messages to Back Offce Applications
Organizations that receive a common data feed that needs to be parsed and routed
to several back-offce applications can use ActiveSpaces as a reference for the routing
application. It can hold reference information so the router can quickly determine where
to send the data. Bank payments and insurance claims processing are two examples.
ActiveSpaces
App
App
App
App
Router
App
Data Feed
S O L U T I O N B R I E F
12
Multi-System Asynchronous Request-Reply
Systems that depend on a request-reply interface to synchronize messages can use
ActiveSpaces to prevent correlation problems. These systems typically are synchronized
using a transaction or correlation ID. Problems occur when back offce applications
cannot process or respond with the correlation ID, and when multiple back-offce systems
process the same message.
A gateway application can be used to send the correlation ID to ActiveSpaces, which
then forwards the data to the back offce system for processing. When the back offce
application responds, the gateway application retrieves the correlation ID and inserts it
into the outbound message.
ActiveSpaces
App
App
App
App
Gateway
App
Gateway
App
Duplicate Message Detection
Anyone implementing a message processing system for critical information will eventually
need to defne a mechanism for identifying duplicate messages. Sometimes the approach
is to pass deduplication downstream to the receiving systems, but it can be much better
to implement message deduplication at the enterprise service bus (ESB).
ActiveSpaces can implement duplicate message identifcation. When a message is
received, ActiveMatrix BusinessWorks

will query ActiveSpaces to see if the message

has been processed before. The query can use any uniquely identifying information
contained in the message. If the message has not been processed, ActiveMatrix
BusinessWorks inserts a new row into ActiveSpaces. Locking strategies can be used to
coordinate across multiple ActiveMatrix BusinessWorks engines, processing in an active-
active confguration.
Save Message Information
Sometimes information must be retained and correlated across multiple messages. A
transaction might generate several messages linked by a common transaction ID that
should be processed as a group. ActiveSpaces can retain the information from the
message group and correlate them as needed.
S O L U T I O N B R I E F
exported12Jun2013
13
TIBCO BusinessWorks Enhancements
In-Memory Data Persistence for BusinessWorks
By design, TIBCO ActiveMatrix BusinesWorks, our fagship integration platform, is
stateless. It runs a process, and when complete, all of the information is fushed
from its memory. This works fne for many use cases where it facilitates integration
betweensystems.
However, when it would be better for ActiveMatrix BusinessWorks to retain information
across processes, the high-speed, easy-to-implement ActiveMatrix BusinessWorks plugin
for ActiveSpaces flls the bill.
BusinessWorks Engine Synchronization
When processing or state needs to be coordinated across multiple BusinessWorks
engines, ActiveSpaces in-memory data-access provides a very fast solution. Before
ActiveSpaces, the options for implementing this coordination included a database or
ActiveMatrix BusinessWorks shared variables stored in a database. This approach was
relatively slow and did not meet the performance requirements of many implementations.
ActiveMatrix BusinessWorks plugin for ActiveSpaces is very simple and straightforward
toimplement.
Fast Data Visualization
Fast Data Store for TIBCO Spotfre
An ActiveSpaces adapter for TIBCO Spotfre

enables rich graphic visualizations and

analysis of data contained in ActiveSpaces.
Summary
TIBCO ActiveSpaces is a powerful and fexible distributed in-memory data processor that
solves a variety of technical challenges. The use cases presented here are only a few of
the many ways that it can deliver value by supercharging your infrastructure.
Download ActiveSpaces at www.tibcommunity.com
S O L U T I O N B R I E F
TIBCO Software Inc. (NASDAQ: TIBX) is a provider of infrastructure software for companies to use on-premise or as part of cloud
computing environments. Whether its effcient claims or trade processing, cross-selling products based on real-time customer
behavior, or averting a crisis before it happens, TIBCO provides companies the two-second advantage

the ability to capture the

right information, at the right time and act on it preemptively for a competitive advantage. More than 4,000 customers worldwide
rely on TIBCO to manage information, decisions, processes and applications in real time. Learn more at www.tibco.com.
2013, TIBCO Software Inc. All rights reserved. TIBCO, the TIBCO logo, and TIBCO ActiveMatrix BusinessWorks, TIBCO ActiveSpaces, TIBCO BusinessEvents,
TIBCO BusinessWorks, TIBCO Enterprise Message Service, and TIBCO Spotfre are trademarks or registered trademarks of TIBCO Software Inc. in the United
States and/or other countries. All other product and company names and trademarks in this document are the property of their respective owners and mentioned
for identifcation purposes only.
www.tibco.com Global Headquarters
3307 Hillview Avenue
Palo Alto, CA 94304
Tel: +1 650-846-1000
+1 800-420-8450
Fax: +1 650-846-1005