[GIE/docs] Add gie glossary and quick start (#2821)

As titled

docs/overview/getting_started.md

@@ -1,8 +1,8 @@
 # Getting Started
 
-This tutorial provides a quick overview of GraphScope's features. 
-To begin, we will install GraphScope on your local machine using Python. 
-Although most examples in this guide are based on local Python installation, 
+This tutorial provides a quick overview of GraphScope's features.
+To begin, we will install GraphScope on your local machine using Python.
+Although most examples in this guide are based on local Python installation,
 it also works on a Kubernetes cluster.
 
 You can easily install GraphScope through pip:
@@ -37,7 +37,7 @@ python3.9
 
 ## One-stop Graph Processing
 
-We will use a walking-through example to demonstrate how to use GraphScope to 
+We will use a walking-through example to demonstrate how to use GraphScope to
 process various graph computation tasks in a one-stop manner.
 
 The example targets node classification on a citation network.
@@ -54,7 +54,7 @@ GraphScope models graph data as property graph, in which the edges/vertices are
      alt="Sample of property graph."
      width="80%">
 
-Sample of property graph 
+Sample of property graph
 :::
 
 This graph has four kinds of vertices, labeled as paper, author, institution, and field_of_study. There are four kinds of edges connecting them, each kind of edge has a label and specifies the vertex labels for its two ends. For example, cites edges connect two vertices labeled paper. Another example is writes, it requires the source vertex is labeled author and the destination is a paper vertex. All the vertices and edges may have properties. e.g., paper vertices have properties like features, publish year, subject label, etc.
@@ -237,8 +237,32 @@ print(ret.to_dataframe(selector={'id': 'v.id', 'distance': 'r'})
 ````
 
 ## Graph Interactive Query Quick Start
+With the `graphscope` package already installed, you can effortlessly engage with a graph on your local machine.
+You simply need to create the `gremlin` instance to serve as the conduit for submitting all Gremlin queries.
+
+````{dropdown} Example: Run Interactive Queries in GraphScope
+```python
+
+import graphscope as gs
+from graphscope.dataset.modern_graph import load_modern_graph
+
+gs.set_option(show_log=True)
+
+# load the modern graph as example.
+#(modern graph is an example property graph for Gremlin queries given by Apache at https://tinkerpop.apache.org/docs/current/tutorials/getting-started/)
+graph = load_modern_graph()
+
+# Hereafter, you can use the `graph` object to create an `gremlin` query session
+g = gs.gremlin(graph)
+# then `execute` any supported gremlin query.
+q1 = g.execute('g.V().count()')
+print(q1.all())   # should print [6]
+
+q2 = g.execute('g.V().hasLabel(\'person\')')
+print(q2.all())  # should print [[v[2], v[3], v[0], v[1]]]
+```
+````
 
-TODO(Robin):
 
 ## Graph Learning Quick Start
 

docs/overview/glossary.md

@@ -15,7 +15,7 @@ Learn more: [Paper on ICDE2023](#), [Doc](https://graphscope.io/docs/latest/anal
 
 the code name of analytical engine in GraphScope. It was first indroduced in the SIGMOD2017 paper, represents <u>GRA</u>ph <u>P</u>arallel processing <u>E</u>ngine. The analytical engine inherits the design proposed in this paper.
 
-The core part of GRAPE is opensourced at https://github.com/alibaba/libgrape-lite, which is a dependency and serves as the analytical engine in GraphScope. 
+The core part of GRAPE is opensourced at https://github.com/alibaba/libgrape-lite, which is a dependency and serves as the analytical engine in GraphScope.
 
 Read more: [Best Paper on SIGMOD2017](https://homepages.inf.ed.ac.uk/wenfei/papers/sigmod17-GRAPE.pdf), [Design of GAE](https://graphscope.io/docs/latest/analytical_engine/design_of_gae.html)
 
@@ -46,7 +46,7 @@ Repo: https://github.com/alibaba/GraphAr
 
 #### Groot
 
-Groot is the code name of the persistent storage in GraphScope. It was named after the tree Groot in the movie "Guardians of the Galaxy". The name "g-root" also indicates the fundamental role of the storage component in the graph system. 
+Groot is the code name of the persistent storage in GraphScope. It was named after the tree Groot in the movie "Guardians of the Galaxy". The name "g-root" also indicates the fundamental role of the storage component in the graph system.
 
 [Read more](https://graphscope.io/docs/latest/storage_engine/groot.html)
 
@@ -62,21 +62,42 @@ Read more: [Paper on ICDE2023](#), [Code](https://github.com/alibaba/libgrape-li
 
 #### MaxGraph (deprecated)
 
-MaxGraph is the deprecated interactive engine in GraphScope. It was replaced by a new designed engine GAIA with multiple query language (e.g., Gremlin/Cypher...) support. 
+MaxGraph is the deprecated interactive engine in GraphScope. It was replaced by a new designed engine GAIA with multiple query language (e.g., Gremlin/Cypher...) support.
 
 
 #### Vineyard, or v6d
 
-Vineyard is the code name of the immutable memory mangement. Its name suggests it was a underlying component of GRAPE.
+Vineyard is the code name of the immutable memory management. Its name suggests it was a underlying component of GRAPE.
 
 Vineyard (v6d) is an innovative in-memory immutable data manager that offers out-of-the-box high-level abstractions and zero-copy in-memory sharing for distributed data in various big data tasks, such as graph analytics (e.g., GraphScope), numerical computing (e.g., Mars), and machine learning. It is a CNCF sandbox project.
 
 Repo: https://github.com/v6d-io/v6d
 
 
+#### GIE
+GraphScope Interactive Engine, or GIE for short, utilizes Gaia (or Pegasus) to enable parallel execution in distribution.
+It offers storage options consisting of the immutable, in-memory [v6d](../interactive_engine/deployment.md)
+and the mutable, persistent [groot](../storage_engine/groot.md). GIE can process queries using
+[Tinkerpop's Gremlin language](../interactive_engine/tinkerpop_eco.md), with support for
+[Neo4j's openCypher](https://opencypher.org/) to come soon. The capabilities of GIE are amplified by
+a sophisticated [Intermediate Representation (IR) Layer](../interactive_engine/design_of_gie.md) that
+dissociates the query languages from the computing engines and stores.
+
 #### GAIA
+Gaia is a distributed data-parallel compute engine based on the cyclic dataflow computation model, which
+has been employed by GIE to support large-scale interactive graph queries.
+Gaia serves as the computation engine, lying at the core of the GraphScope system. Users can construct
+the computation via a directed acyclic graph (DAG), and easily run the job on their laptop or even a
+distributed environment across a cluster of computers. Note that cycle can be introduced via the loop
+control flow, while the whole loop contexts will be wrapped in a scope within which the cycle is
+completely hidden from the users. Scope is a unique concept of Gaia to handle complex control flow
+such as loop and conditional. In addition, it is also the key to many application-level primitives,
+e.g. correlated subtask, as well as advanced scheduling techniques, e.g. early-stop mechanism.
+
+Read more: [Paper on NSDI 2021](https://www.usenix.org/system/files/nsdi21-qian.pdf)
 
-TODO(Robin): Add this.
+#### Pegasus
+A legacy name of Gaia, for which we use Gaia and Pegasus interchangeably in the project.
 
 #### Ingress
 
@@ -86,11 +107,6 @@ Ingress is planned to be integrated into GraphScope, as an incrementalization mo
 
 Read more: [Paper on VLDB2021](http://vldb.org/pvldb/vol14/p1613-gong.pdf)
 
-#### Pegasus
-
-The code name of runtime engine under the GAIA.
-TODO(Robin): Add this.
-
 #### PIE-model
 
-The subgraph centric programming model proposed in GRAPE, which is short for <u>P</u>artial evaluation, <u>I</u>ncremental evaluation and assembl<u>E</u>, the three core functions to fulfill in GRAPE.
+The subgraph centric programming model proposed in GRAPE, which is short for <u>P</u>artial evaluation, <u>I</u>ncremental evaluation and assembl<u>E</u>, the three core functions to fulfill in GRAPE.