A short introduction to reactive applications. This document details different traits of reactive applications and some of the languages that help implement them.

1. Applications that are event-driven, scalable, resilient and responsive: delivering highly
responsive user experiences with a real-time feel, backed by a scalable and resilient
application stack, ready to be deployed on multicore and cloud computing architectures.
Applications today are deployed on infrastructures
ranging from mobile devices to cloud clusters.
Response time expectations are now in milliseconds
and 100% uptime is a basic necessity.
The need of the hour is to have a highly responsive,
scalable, resilient application that can keep the user
engaged.
This calls for new technologies that have these
features built in to the basic design rather than these
features getting added to an existing application as
an afterthought.
Reactive applications represent a balanced approach
to addressing a wide range of challenges in software
development. Building on an event-driven, message-
based foundation, they provide the tools needed to
ensure scalability and resilience. On top of this they
support rich, responsive user interactions.
It's a concept that really has been around for a long
time, but it's now gaining special focus and becoming
viable in main stream languages.
It’s essentially moving away from executing a set of
steps to executing an event on a component which
might require other events on the same or other
components to be fired which in turn might fire
further more events. The components are loosely
coupled and each are scalable independently and
location transparent.
Key Traits of Reactive Applications
Event Driven: Events are discrete pieces of
information describing facts. Event-driven systems
push data to consumers when it is available avoiding
the wastage of resources by having the consumers
continually listen or wait for the data. The
asynchronous nature of communication implements
loose coupling design. It also means that the
application is highly concurrent by design.
They can make use of multicore hardware without
changes. Any core within a CPU is able to process any
message event, leading to a dramatic increase in
opportunities for parallelization.
These applications are capable of reacting to
Events: The event-driven nature enables the
following qualities.
Load: Focus on scalability rather than single-user
performance.
Failure: Build resilient systems with the ability to
recover at all levels.
Users: Combine the above traits for an interactive
user experience.

2. Scalable: A scalable application expands according to
its usage. Achieved with the options of being able to
scale out or in or up or down without redesigning or
rewriting the application. The loose coupling and
location independence between components and
subsystems make it possible to scale out the system
onto multiple nodes while retaining the same
programming model with the same semantics.
Scalability helps managing risk by providing optimal
hardware and scaling it based on demand. A scalable
solution also avoids having an application that is
unable to make use of new hardware becoming
available.
Resilient: In a reactive application, resilience is not an
afterthought but part of the design from the
beginning. Making failure a first class construct in the
programming model provides the means to react to
and manage it, which leads to applications that are
highly tolerant to failure by being able to heal and
repair themselves at runtime.
The event-driven model has the necessary primitives
to realize this model of failure management. The
loose coupling in an event-driven model provides fully
isolated components in which failures can be
captured together with their context, encapsulated as
messages, and sent off to other components that can
inspect the error and decide how to respond.
Responsive: Responsive applications are real-time,
engaging, rich and collaborative. They create an open
and ongoing dialog with the customers. They enable
highly interactive applications like Google Docs which
is a collaborative document editing tool.
Observable models of reactive applications enable
other systems to receive events when state changes.
This can provide a real-time connection between
users and systems. For example, when multiple users
work concurrently on the same model, changes can
be reactively synchronized bi-directionally between
them, thus appearing as if the model is shared
without the constraints of locking.
Reactive Languages
NetFlix: Leverages server-side conconcurrency
without the typical thread-safety and synchronization
concerns.
React: from Facebook, lets you build application using
components that know how to render some data.
When data changes, components update
automatically in a very efficient way, only where
necessary
Typesafe: A JVM-based runtime and toolset for
building Reactive applications
Node.js: Uses an event-driven non-blocking I/O model
that is ideal for data-intensive and real-time
applications running across distributed devices.
References
http://www.reactivemanifesto.org/
http://en.wikipedia.org/wiki/Reactive_programming
http://www.infoq.com/news/2013/08/reactive-programming-emerging
http://www.infoworld.com/t/java-programming/fear-multicore-apps-reactive-programming-the-rescue-227985