[15/26] ignite git commit: Updated Ignite description

[sboikov]

Updated Ignite description


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/1b5ca444
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/1b5ca444
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/1b5ca444

Branch: refs/heads/ignite-6149
Commit: 1b5ca4446f7961e6c1b3f9c6bab0d8dc540b932f
Parents: 8bcd69d
Author: Denis Magda <dma...@gridgain.com>
Authored: Fri Sep 15 09:54:44 2017 -0700
Committer: Denis Magda <dma...@gridgain.com>
Committed: Fri Sep 15 09:54:44 2017 -0700

----------------------------------------------------------------------
 README.md | 194 +++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 140 insertions(+), 54 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/1b5ca444/README.md
----------------------------------------------------------------------
diff --git a/README.md b/README.md
index b9833ef..d018878 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,50 @@
-# Apache Ignite In-Memory Data Fabric
+# Apache Ignite In-Memory Computing Platform
 
-<img src="https://ignite.apache.org/images/logo3.png"; hspace="20" />
+<a href="https://ignite.apache.org/";><img 
src="https://ignite.apache.org/images/logo3.png"; hspace="20"/></a>
 
 [![Join the chat at 
https://gitter.im/apacheignite/ignite](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/apacheignite/ignite?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 <a 
href="http://ci.ignite.apache.org/viewType.html?buildTypeId=IgniteTests_IgniteBasic&branch_IgniteTests=%3Cdefault%3E";><img
 
src="http://ci.ignite.apache.org/app/rest/builds/buildType:(id:IgniteTests_IgniteBasic)/statusIcon"
 /></a>
 
-The [Apache Ignite][apache-homepage] In-Memory Data Fabric is a 
high-performance, integrated and distributed in-memory platform for computing 
and transacting on large-scale data sets in real-time, orders of magnitude 
faster than possible with traditional disk-based or flash technologies.
+[Apache Ignite][apache-homepage] is the <b>in-memory</b> computing platform
+that is <b>durable</b>, <b>strongly consistent</b>, and <b>highly available</b>
+with powerful <b>SQL</b>, <b>key-value</b> and <b>processing</b> APIs.
 
 <p align="center">
     <a href="https://apacheignite.readme.io/docs";>
-        <img src="https://ignite.apache.org/images/apache-ignite.png"; />
+        <img src="https://ignite.apache.org/images/durable-memory.png"; 
width="900px"/>
     </a>
 </p>
 
-Apache Ignite In-Memory Data Fabric is designed to deliver uncompromised 
performance for a wide set of in-memory computing use cases from [high 
performance computing](https://ignite.apache.org/features.html), to the 
industry most advanced [data grid](https://ignite.apache.org/features.html), 
highly available [service grid](https://ignite.apache.org/features.html), and 
[streaming](https://ignite.apache.org/features.html).
+## Durable Memory
+Ignite's durable memory component treats RAM not just as a caching layer but 
as a complete fully functional storage layer. This means that users can turn 
the persistence on and off as needed. If the persistence is off, then Ignite 
can act as a distributed **in-memory database** or **in-memory data grid**, 
depending on whether you prefer to use SQL or key-value APIs. If the 
persistence is turned on, then Ignite becomes a distributed, **horizontally 
scalable database** that guarantees full data consistency and is resilient to 
full cluster failures.
+
+## ACID Compliance
+Data stored in Ignite is ACID-compliant both in memory and on disk, making 
Ignite a **strongly consistent** system. Ignite transactions work across the 
network and can span multiple servers.
+
+## Complete SQL Support
+Ignite provides full support for SQL, DDL and DML, allowing users to interact 
with Ignite using pure SQL without writing any code. This means that users can 
create tables and indexes as well as insert, update, and query data using only 
SQL. Having such complete SQL support makes Ignite a one-of-a-kind 
**distributed SQL database**.
+
+## Key-Value
+The in-memory data grid component in Ignite is a fully transactional 
**distributed key-value store** that can scale horizontally across 100s of 
servers in the cluster. When persistence is enabled, Ignite can also store more 
data than fits in memory and survive full cluster restarts.
+
+## Collocated Processing
+Most traditional databases work in a client-server fashion, meaning that data 
must be brought to the client side for processing. This approach requires lots 
of data movement from servers to clients and generally does not scale. Ignite, 
on the other hand, allows for sending light-weight computations to the data, 
i.e. **collocating** computations with data. As a result, Ignite scales better 
and minimizes data movement.
+
+## Scalability and Durability
+Ignite is an elastic, horizontally scalable distributed system that supports 
adding and removing cluster nodes on demand. Ignite also allows for storing 
multiple copies of the data, making it resilient to partial cluster failures. 
If the persistence is enabled, then data stored in Ignite will also survive 
full cluster failures. Cluster restarts in Ignite can be very fast, as the data 
becomes operational instantaneously directly from disk. As a result, the data 
does not need to be preloaded in-memory to begin processing, and Ignite caches 
will lazily warm up resuming the in memory performance.
+
+## Ignite Persistence
+
+Ignite Native Persistence is a distributed ACID and SQL-compliant disk store 
that transparently integrates with Ignite's Durable Memory as an optional disk 
layer storing data and indexes on SSD, Flash, 3D XPoint, and other types of 
non-volatile storages.
+
+With the Ignite Persistence enabled, you no longer need to keep all the data 
and indexes in memory or warm it up after a node or cluster restart because the 
Durable Memory is tightly coupled with persistence and treats it as a secondary 
memory tier. This implies that if a subset of data or an index is missing in 
RAM, the Durable Memory will take it from the disk.
+
+<p align="center">
+    <a href="https://apacheignite.readme.io/docs/distributed-persistent-store";>
+        <img src="https://ignite.apache.org/images/check_pointing-2.png"; 
width="400px"/>
+    </a>
+</p>
 
 ## Advanced Clustering
 
@@ -26,6 +56,14 @@ Ignite nodes can automatically discover each other. This 
helps to scale the clus
     </a>
 </p>
 
+Apache Ignite can be deployed on:
+* AWS
+* Docker
+* Google Cloud
+* Kubernetes
+* Mesos
+* YARN
+
 ## Data Grid (JCache)
 
 Ignite data grid is an in-memory distributed key-value store which can be 
viewed as a distributed partitioned hash map, with every cluster node owning a 
portion of the overall data. This way the more cluster nodes we add, the more 
data we can cache.
@@ -42,64 +80,61 @@ Ignite data grid supports local, replicated, and 
partitioned data sets and allow
 
 Our data grid offers many features, some of which are:
 
-* Primary & Backup Copies.
-* Near Caches.
-* Cache queries and SQL queries.
-* Continuous Queries.
-* Transactions.
-* Off-Heap Memory.
-* Affinity Collocation.
-* Persistent Store.
-* Automatic Persistence.
-* Data Loading.
-* Eviction and Expiry Policies.
+* Primary & Backup Copies
+* Near Caches
+* Cache queries and SQL queries
+* Continuous Queries
+* Transactions
+* Off-Heap Memory
+* Affinity Collocation
+* Persistent Store
+* Automatic Persistence
+* Data Loading
+* Eviction and Expiry Policies
 * Data Rebalancing
-* Web Session Clustering.
-* Hibernate L2 Cache.
-* JDBC Driver.
-* Spring Caching.
-* Topology Validation.
+* Web Session Clustering
+* Hibernate L2 Cache
+* JDBC Driver
+* Spring Caching
+* Topology Validation
 
-## Streaming & CEP
+## SQL Grid
+Apache Ignite incorporates distributed SQL database capabilities as a part of 
its platform. The database is horizontally scalable, fault tolerant and SQL 
ANSI-99 compliant. It supports all SQL, DDL, and DML commands including SELECT, 
UPDATE, INSERT, MERGE, and DELETE queries. It also provides support for a 
subset of DDL commands relevant for distributed databases.
 
-Ignite streaming allows to process continuous never-ending streams of data in 
scalable and fault-tolerant fashion. The rates at which data can be injected 
into Ignite can be very high and easily exceed millions of events per second on 
a moderately sized cluster.
+With Ignite Durable Memory architecture, data as well as indexes can be stored 
both in memory and, optionally, on disk. This allows executing distributed SQL 
operations across different memory layers achieving in-memory performance with 
the durability of disk.
 
-Real-time data is ingested via data streamers. We offer streamers for JMS 1.1, 
Apache Kafka, MQTT, Twitter, Apache Flume and Apache Camel already, and we keep 
adding new ones every release.
-
-<p align="center">
-    <a href="https://apacheignite.readme.io/docs/streaming--cep";>
-        <img src="https://ignite.apache.org/images/data-streamers.png"; />
-    </a>
-</p>
+You can interact with Apache Ignite using the SQL language via natively 
developed APIs for Java, .NET and C++, or via the Ignite JDBC or ODBC drivers. 
This provides a true cross-platform connectivity from languages such as PHP, 
Ruby and more.
 
-The data can then be queried within sliding windows, if needed:
 
 <p align="center">
-    <a href="https://apacheignite.readme.io/docs/streaming--cep";>
-        <img src="https://ignite.apache.org/images/sliding-event-window.png"; />
+    <a href="https://apacheignite.readme.io/docs/distributed-sql";>
+        <img 
src="https://ignite.apache.org/images/ignite-distributed-database.png"; 
vspace="15" width="400px"/>
     </a>
 </p>
 
+
 ## Compute Grid
 
 Distributed computations are performed in parallel fashion to gain high 
performance, low latency, and linear scalability. Ignite compute grid provides 
a set of simple APIs that allow users distribute computations and data 
processing across multiple computers in the cluster. Distributed parallel 
processing is based on the ability to take any computation and execute it on 
any set of cluster nodes and return the results back.
 
 <p align="center">
     <a href="https://apacheignite.readme.io/docs/compute-grid";>
-        <img src="https://ignite.apache.org/images/in_memory_compute.png"; />
+        <img src="https://ignite.apache.org/images/in_memory_compute.png"; 
vspace="15"/>
     </a>
 </p>
 
 We support these features, amongst others:
 
-* Distributed Closure Execution.
-* MapReduce & ForkJoin Processing.
-* Clustered Executor Service.
-* Collocation of Compute and Data.
-* Load Balancing.
-* Fault Tolerance.
-* Job State Checkpointing.
-* Job Scheduling.
+* Distributed Closure Execution
+* MapReduce & ForkJoin Processing
+* Continuous Mapping
+* Clustered Executor Service
+* Per-Node Shared State
+* Collocation of Compute and Data
+* Load Balancing
+* Fault Tolerance
+* Job State Checkpointing
+* Job Scheduling
 
 ## Service Grid
 
@@ -121,12 +156,12 @@ In addition, IGFS provides API to execute map-reduce 
tasks over file system data
 
 ## Distributed Data Structures
 
-Ignite supports complex data structures in a distributed fashion: 
+Ignite supports complex data structures in a distributed fashion:
 
-* Queues and sets: ordinary, bounded, collocated, non-collocated.
-* Atomic types: `AtomicLong` and `AtomicReference`.
-* `CountDownLatch`.
-* ID Generators.
+* Queues and sets: ordinary, bounded, collocated, non-collocated
+* Atomic types: `AtomicLong` and `AtomicReference`
+* `CountDownLatch`
+* ID Generators
 
 ## Distributed Messaging
 
@@ -147,7 +182,7 @@ Our Hadoop Accelerator provides a set of components 
allowing for in-memory Hadoo
 An alternate high-performant implementation of job tracker which replaces 
standard Hadoop MapReduce. Use it to boost your Hadoop MapReduce job execution 
performance.
 
 <p align="center">
-    <a href="https://apacheignite.readme.io/docs/map-reduce";>
+    <a href="https://apacheignite-fs.readme.io/docs/map-reduce";>
         <img src="https://ignite.apache.org/images/hadoop-mapreduce.png"; 
vspace="15" height="400"/>
     </a>
 </p>
@@ -157,7 +192,7 @@ An alternate high-performant implementation of job tracker 
which replaces standa
 A Hadoop-compliant IGFS File System implementation over which Hadoop can run 
over in plug-n-play fashion and significantly reduce I/O and improve both, 
latency and throughput.
 
 <p align="center">
-    <a href="https://apacheignite.readme.io/docs/file-system";>
+    <a href="https://apacheignite-fs.readme.io/docs/in-memory-file-system";>
         <img src="https://ignite.apache.org/images/ignite_filesystem.png"; 
height="300" vspace="15"/>
     </a>
 </p>
@@ -168,21 +203,72 @@ An implementation of `SecondaryFileSystem`. This 
implementation can be injected
 
 ### Supported Hadoop distributions
 
-* Apache Hadoop.
-* Cloudera CDH.
-* Hortonworks HDP.
-* Apache BigTop.
+* Apache Hadoop
+* Cloudera CDH
+* Hortonworks HDP
+* Apache BigTop
 
 ## Spark Shared RDDs
 
 Apache Ignite provides an implementation of Spark RDD abstraction which allows 
to easily share state in memory across Spark jobs. The main difference between 
native Spark `RDD` and `IgniteRDD` is that Ignite RDD provides a shared 
in-memory view on data across different Spark jobs, workers, or applications, 
while native Spark RDD cannot be seen by other Spark jobs or applications.
 
 <p align="center">
-    <a href="https://apacheignite.readme.io/docs/shared-rdd";>
+    <a href="https://apacheignite-fs.readme.io/docs/ignite-for-spark";>
         <img src="https://ignite.apache.org/images/spark-ignite-rdd.png"; 
height="400" vspace="15" />
     </a>
 </p>
 
+## Ignite Facts
+
+<b>Is Ignite a persistent or pure in-memory storage?</b><br/>
+**Both**. Native persistence in Ignite can be turned on and off. This allows 
Ignite to store data sets bigger than can fit in the available memory. 
Essentially, the smaller operational data sets can be stored in-memory only, 
and larger data sets that do not fit in memory can be stored on disk, using 
memory as a caching layer for better performance.
+
+[Read More](https://apacheignite.readme.io/docs/distributed-persistent-store)
+
+<b>Is Ignite a distributed database?</b><br/>
+**Yes**. Data in Ignite is either *partitioned* or *replicated* across a 
cluster of multiple nodes. This provides scalability and adds resilience to the 
system. Ignite automatically controls how data is partitioned, however, users 
can plug in their own distribution (affinity) functions and collocate various 
pieces of data together for efficiency.
+
+[Read More](https://apacheignite.readme.io/docs/distributed-sql)
+
+<b>Is Ignite a relational SQL database?</b><br/>
+**Not fully**. Although Ignite aims to behave like any other relational SQL 
database, there are differences in how Ignite handles constraints and indexes. 
Ignite supports *primary* and *secondary* indexes, however, the *uniqueness* 
can only be enforced for the *primary* indexes. Ignite also does not support 
*foreign key* constraints.
+
+Essentially, Ignite purposely does not support any constraints that would 
entail a cluster broadcast message for each update and significantly hurt 
performance and scalability of the system.
+
+[Read More](https://apacheignite.readme.io/docs/indexes)
+
+<b>Is Ignite an in-memory database?</b><br/>
+**Yes**. Even though Ignite *durable memory* works well in-memory and on-disk, 
the disk persistence can be disabled and Ignite can act as a pure *in-memory 
database*.
+
+[Read More](https://apacheignite.readme.io/docs/distributed-sql)
+
+<b>Is Ignite a transactional database?</b><br/>
+**Not fully**. ACID Transactions are supported, but only at *key-value* API 
level. Ignite also supports *cross-partition* transactions, which means that 
transactions can span keys residing in different partitions on different 
servers.
+
+At *SQL* level Ignite supports *atomic*, but not yet *transactional* 
consistency. Ignite community plans to implement SQL transactions in version 
2.2.
+
+[Read More](https://apacheignite.readme.io/docs/sql-queries#known-limitations)
+
+<b>Is Ignite a key-value store?</b><br/>
+**Yes**. Ignite provides a feature rich key-value API, that is JCache 
(JSR-107) compliant and supports Java, C++, and .NET.
+
+[Read More](https://apacheignite.readme.io/docs/data-grid)
+
+<b>Is Ignite an in-memory data grid?</b><br/>
+**Yes**. Ignite is a full-featured data grid, which can be used either in pure 
in-memory mode or with Ignite native persistence. It can also integrate with 
any 3rd party database, including any RDBMS or NoSQL store.
+
+[Read More](https://apacheignite.readme.io/docs/data-grid)
+
+<b>What is durable memory?</b><br/>
+Ignite *durable memory* architecture allows Ignite to extend in-memory 
computing to disk. It is based on a paged-based off-heap memory allocator which 
becomes durable by persisting to the *write-ahead-log (WAL)* and, then, to main 
Ignite persistent storage. When persistence is disabled, durable memory acts 
like a pure in-memory storage.
+
+[Read More](https://apacheignite.readme.io/docs/durable-memory)
+
+<b>What is collocated processing?</b><br/>
+Ignite is a distributed system and, therefore, it is important to be able to 
collocate data with data and compute with data to avoid distributed data noise. 
Data collocation becomes especially important when performing distributed SQL 
joins. Ignite also supports sending user logic (functions, lambdas, etc.) 
directly to the nodes where the data resides and computing on the data locally.
+
+[Read More](https://apacheignite.readme.io/docs/collocate-compute-and-data)
+
 ## Ignite On Other Platforms
 
 <a href="modules/platforms/dotnet">Ignite.NET</a>