docs: fixes typos in documentation (alibaba#3554)

Signed-off-by: Josh Soref <[email protected]>

Author: jsoref

.github/ISSUE_TEMPLATE/bug_report.md

@@ -25,7 +25,7 @@ If applicable, add screenshots to help explain your problem.
 
 **Environment (please complete the following information):**
  - GraphScope version: [e.g., v0.1, v0.2.2, master]
- - OS: [e.g. MacOS, Linux]
+ - OS: [e.g. macOS, Linux]
  - Version [e.g. 10.15]
  - Kubernetes Version [e.g., 1.19]
 

CONTRIBUTING.md

@@ -13,7 +13,7 @@ Newcomers to GraphScope
 For newcomers to GraphScope, you could find instructions about how to build
 and run applications using GraphScope in [README][2].
 
-GraphScope is hosted on Github, and use Github issues as the bug tracker.
+GraphScope is hosted on GitHub, and use GitHub issues as the bug tracker.
 you can [file an issue][3] when you meets trouble when working with GraphScope.
 
 Before creating a new bug entry, we recommend you first [search][4] among existing
@@ -72,7 +72,7 @@ or `[FEATURE-2345] Support loading empty graphs`.
 ### Git workflow for newcomers
 
 You generally do NOT need to rebase your pull requests unless there are merge
-conflicts with the main. When Github complaining that "Can’t automatically merge"
+conflicts with the main. When GitHub complaining that "Can’t automatically merge"
 on your pull request, you'll be asked to rebase your pull request on top of
 the latest main branch, using the following commands:
 

README-zh.md

@@ -13,7 +13,7 @@
 
 GraphScope 是阿里巴巴达摩院智能计算实验室研发并开源的一站式图计算平台。依托于阿里海量数据和丰富场景，与达摩院的高水平研究，GraphScope 致力于针对实际生产场景中图计算的挑战，提供一站式高效的解决方案。
 
-GraphScope 提供了 Python 客户端，能十分方便的对接上下游工作流，具有一站式、开发便捷、性能极致等特点。它整合了智能计算实验室多个重要的创新性技术，包括 [GRAPE](https://github.com/alibaba/libgrape-lite)，[MaxGraph](interactive_engine/)，[Graph-Learn](https://github.com/alibaba/graph-learn)，分别支持图分析、图的交互式查询和图学习任务，引擎间使用 [Vineyard](htps://github.com/v6d-io/v6d) 存储，提供跨进程，零拷贝的内存数据共享服务。其中核心优势包括在业界首次支持了 Gremlin 分布式编译优化，支持了算法的自动并行化、提供了企业级场景下的极致性能等。在阿里巴巴内外部应用中，GraphScope 已经证明在多个关键互联网领域（如风控，电商推荐，广告，网络安全，知识图谱等）实现了重要的业务新价值。
+GraphScope 提供了 Python 客户端，能十分方便的对接上下游工作流，具有一站式、开发便捷、性能极致等特点。它整合了智能计算实验室多个重要的创新性技术，包括 [GRAPE](https://github.com/alibaba/libgrape-lite)，[MaxGraph](interactive_engine/)，[Graph-Learn](https://github.com/alibaba/graph-learn)，分别支持图分析、图的交互式查询和图学习任务，引擎间使用 [Vineyard](https://github.com/v6d-io/v6d) 存储，提供跨进程，零拷贝的内存数据共享服务。其中核心优势包括在业界首次支持了 Gremlin 分布式编译优化，支持了算法的自动并行化、提供了企业级场景下的极致性能等。在阿里巴巴内外部应用中，GraphScope 已经证明在多个关键互联网领域（如风控，电商推荐，广告，网络安全，知识图谱等）实现了重要的业务新价值。
 
 GraphScope 整合了达摩院的多项学术研究成果，其中的核心技术曾获得数据库领域顶级学术会议 SIGMOD2017 最佳论文奖、VLDB2017 最佳演示奖、VLDB2020 最佳论文奖亚军、世界人工智能创新大赛SAIL奖等。GraphScope 的交互查询引擎的论文已被 NSDI 2021录用。还有其它围绕 GraphScope 的十多项研究成果发表在领域顶级的学术会议或期刊上，如 TODS、SIGMOD、VLDB、KDD等。
 

analytical_engine/java/README.md

@@ -12,7 +12,7 @@ enables Java programmers to write and run graph algorithms with these benefits.
   GRAPE-JDK substantially narrows the gap between apps written in Java and in C++. As [experiments](#performance) shows, the overall performance gap 
   between native C++ and GRAPE-JDK are lower than 2x, and in some scenarios like PageRank, GRAPE-JDK runs nearly as fast as native C++ implementation. 
 
-- **Support Giraph app**. We also prvide user with a Giraph SDK, grape-giraph. The algorithms user implemented on [Giraph](https://github.com/apache/giraph)
+- **Support Giraph app**. We also provide user with a Giraph SDK, grape-giraph. The algorithms user implemented on [Giraph](https://github.com/apache/giraph)
   interface can be run on GRAPE-JDK without any modification.
 
 - **Support Spark Graphx**. We break down the storage gap between Spark RDD and GraphScope Fragment, enabling `fragment-as-rdd` wrapping 
@@ -29,7 +29,7 @@ enables Java programmers to write and run graph algorithms with these benefits.
 
 - **grape-demo** Provides example apps and [FFIMirrors](#user-defined-data-structure).
 - **grape-jdk** Provides the PIE SDK with graph computing interfaces.
-- **grape-runtime** Contains the essential files for JNI code-gen and the glue code invoked by the analytcial engine (building with `ENABLE_JAVA_SDK`). 
+- **grape-runtime** Contains the essential files for JNI code-gen and the glue code invoked by the analytical engine (building with `ENABLE_JAVA_SDK`). 
 - **grape-giraph** Integrating grape with Apache Giraph.
 - **grape-graphx** Integrating grape with Spark GraphX.
 - **grape-rdd-reader** Providing RDD reader for spark RDD.
@@ -49,7 +49,7 @@ mvn clean install
 This will only install `grape-jdk` for you, if you are only interested in writing 
 graph algorithms in java, that's enough for you :D.
 
-To build the whole project, make sure there is one usable c++ compiler in your envirment
+To build the whole project, make sure there is one usable c++ compiler in your environment
 and both [`GraphScope-Analytical engine`](https://github.com/alibaba/GraphScope/tree/main/analytical_engine) 
 and [`Vineyard`](https://github.com/v6d-io/v6d) is installed.
 
@@ -76,7 +76,7 @@ You can include grape-jdk as a dependency in your maven project
 Online JavaDoc is available at [GraphScope Docs](https://graphscope.io/docs/reference/gae_java/index.html).
 
 You can also generate the documentation with in three different ways.
-- use Intellij IDEA plugin: [Intellij IDEA-javadoc](https://www.jetbrains.com/help/idea/working-with-code-documentation.html) 
+- use IntelliJ IDEA plugin: [IntelliJ IDEA-javadoc](https://www.jetbrains.com/help/idea/working-with-code-documentation.html) 
 - Use Eclipse plugin: [Eclipse-javadoc](https://www.tutorialspoint.com/How-to-write-generate-and-use-Javadoc-in-Eclipse). 
 - Generate javaDoc from cmd.
 ```bash

analytical_engine/java/grape-graphx/performance.md

@@ -3,7 +3,7 @@
 We test GraphScope for GraphX in end-to-end scenarios to measure the performance improvement of graph computing on Spark GraphX. This includes:
 - Graph loading: loading graphs from the file system into memory in the form of a graph
 - RDD Op: transforming the graph using RDD-defined operators
-- Pregel computin: running graph algorithms based on GraphX Pregel, such as SSSP, PageRank, and CC
+- Pregel computing: running graph algorithms based on GraphX Pregel, such as SSSP, PageRank, and CC
 
 ##  Settings:
 

analytical_engine/java/grape-runtime/README.md

@@ -5,7 +5,7 @@ This folder contains the implementation of **```GraphScope Java runtime```**.
 If you just want to implement your java app and run it on ```GraphScope```
 Analytical Engine, you have nothing to know about this directory. You Just need to download
 GRAPE-jdk, write your own app with the programming interfaces, and invoke
-```Graphscope.JavaApp``` to run your java app.
+```GraphScope.JavaApp``` to run your java app.
 
 If you are interested in this submodule, than you may find some runtime-needed java utilities to run
 your Java App on ```GraphScope``` Analytical Engine, and the actual implementation code for

analytical_engine/java/performance.md

@@ -1,6 +1,6 @@
 # Performance
 
-We evaluate the performandce of `grape-jdk` on [LDBC Graph Analytics Benchmark.](https://graphalytics.org/).
+We evaluate the performance of `grape-jdk` on [LDBC Graph Analytics Benchmark.](https://graphalytics.org/).
 In particular, we evaluate the performance with typical graph apps over LDBC XL-size datasets. 
 
 Comparing the performance result of `grape-jdk` with the performance data from native **analytical engine**, we found that the performance gap between **Java app** and **C++ app** has been made narrowed substantially with the help of `grape-jdk`.
@@ -138,6 +138,6 @@ pr_delta set to 0.85, running for 50 rounds.
 | Java(+LLVM4JNI) time 	| 49.80 	| 24.15 	| 10.54 	| 6.63  	| 3.83 	| 2.95 	| 3.42 	|
 
 
-## Graphscope-GraphX Integration
+## GraphScope-GraphX Integration
 
-We also evaluate the performance of `grape-graphx`, the integration of GraphScope on Spark GraphX. See [grape-graphX performace](grape-graphx/performance.md).
+We also evaluate the performance of `grape-graphx`, the integration of GraphScope on Spark GraphX. See [grape-graphX performance](grape-graphx/performance.md).

charts/graphscope-store/README.md

@@ -125,7 +125,7 @@ $ helm install my-release \
 ```
 
 Add multiple extra config to the component which is defined in the configmap by
-`--set extraConfig="k1=v1;k2=v2"`. Note we use `;` to seperate config items. For example,
+`--set extraConfig="k1=v1;k2=v2"`. Note we use `;` to separate config items. For example,
 
 ```bash
 $ helm install my-release \

docs/analytical_engine/dev_and_test.md

@@ -14,11 +14,11 @@ docker run --name dev -it --shm-size=4096m registry.cn-hongkong.aliyuncs.com/gra
 Alternatively, you can also manually install all dependencies on your local machine.
 Please refer to [Dev Environment](../development/dev_guide.md#dev-environment) to find more options to get a dev environment.
 
-After the environment is prepared, clone the repository and enter the `analatical_engine` directory of the repository.
+After the environment is prepared, clone the repository and enter the `analytical_engine` directory of the repository.
 
 ```bash
 git clone https://github.com/alibaba/GraphScope.git
-cd analatical_engine
+cd analytical_engine
 ```
 
 ## Understanding the Codebase
@@ -27,7 +27,7 @@ Since the analytical engine inherits from GRAPE, it requires libgrape-lite as a
 Please note that the core functionalities of libgrape-lite, such as graph structures, graph partitioners, workers, 
 communication between workers, and applications, are heavily reused in the analytical engine of GraphScope.
 
-If you want to fully understand the analytcial engine, it is highly recommaned that you start from libgrape-lite.
+If you want to fully understand the analytical engine, it is highly recommended that you start from libgrape-lite.
 
 The code located in the `analytical_engine` directory functions like extensions to libgrape-lite, thereby making it full-fledged with the following enhancements:
 

docs/analytical_engine/getting_started.md

@@ -59,4 +59,4 @@ Next, you may want to learn more about the following topics:
 
 - [Design of the analytical engine of GraphScope and its technical details](analytical_engine/design_of_gae)
 - [Disaggregated deployment of GraphScope on a k8s cluster for large-scale graph analysis](analytical_engine/deployment)
-- [A set of examples with advanced usage, including customized algorithms, NetworkX/Giraph/GraphX compatibility, etc.](analytical_engine/guide_and_exmaples)
+- [A set of examples with advanced usage, including customized algorithms, NetworkX/Giraph/GraphX compatibility, etc.](analytical_engine/guide_and_examples)

docs/analytical_engine/performance_tuning.md

@@ -60,7 +60,7 @@ its property graphs. Basically, the `ArrowFragment` has the following members:
 
         By default, the type of `offset` is `size_t`.
 
-        The size of `indices` aray is `num_vertices + 1`, which is a 0-based offset array.
+        The size of `indices` array is `num_vertices + 1`, which is a 0-based offset array.
 
     - outgoing edges: a CSR matrix, same as the incoming edges, but for outgoing edges
       of current partition.
@@ -81,7 +81,7 @@ its property graphs. Basically, the `ArrowFragment` has the following members:
 
         By default, the type of `offset` is `size_t`.
 
-        The size of `indices` aray is `num_vertices + 1`, which is a 0-based offset array.
+        The size of `indices` array is `num_vertices + 1`, which is a 0-based offset array.
 
 - Properties: the second part of the property graph is the properties: each vertex
   label and each edge label has a table for its properties:

docs/analytical_engine/programming_model_pie.md

@@ -90,7 +90,7 @@ void IncEval(const fragment_t& frag, context_t& ctx,
 ```
 
 In the above code, given a source vertex `source`, in the `PEval` function, we first execute the Dijkstra's
-algorithm on the sub-graph (fragment) where the `source` resides in to obtain a partial result. After that, the [`SyncStateOnOuterVertex` function](https://graphscope.io/docs/latest/analytical_engine/key_concepts.html#synconoutervertex) is invoked, where the partial result is sent to other fragments to trigger `IncEval` function. 
+algorithm on the sub-graph (fragment) where the `source` resides to obtain a partial result. After that, the [`SyncStateOnOuterVertex` function](https://graphscope.io/docs/latest/analytical_engine/key_concepts.html#synconoutervertex) is invoked, where the partial result is sent to other fragments to trigger `IncEval` function.
 
 In the `IncEval` function, each fragment first receives messages through the [message manager](https://graphscope.io/docs/latest/analytical_engine/key_concepts.html#messagemanager-and-messagestrategy), then executes incremental evaluation based on received messages to update the partial result. If the partial result is updated, each fragment needs to execute the `SyncStateOnOuterVertex` function to synchronize the latest partial result of [outer vertices](https://graphscope.io/docs/latest/analytical_engine/key_concepts.html#outervertex) with other fragments to trigger next round of `IncEval`. Please checkout the following tutorials for more details about how to develop graph applications with the PIE model.
 

docs/analytical_engine/tutorial_dev_algo_cpp_pie.md

@@ -36,7 +36,7 @@ class MyAppContext : public grape::VertexDataContext<FRAG_T, uint64_t> {
 };
 ```
 
-As shown in the code, the MyAppContext class defines two member variables called `step` and `param1` to store the current superstep and algorithm-specific parameter, respectively. And we also define a member variable named `result` with `uint64_t` type to store the the degree for each vertex in the fragment. The `Init` method is used to initialize the context of the computation. In current example, we initialize the `step` and `param1` variables to zero and the algorithm-specific parameter. We also set the result to zero for each vertex.
+As shown in the code, the MyAppContext class defines two member variables called `step` and `param1` to store the current superstep and algorithm-specific parameter, respectively. And we also define a member variable named `result` with `uint64_t` type to store the degree for each vertex in the fragment. The `Init` method is used to initialize the context of the computation. In current example, we initialize the `step` and `param1` variables to zero and the algorithm-specific parameter. We also set the result to zero for each vertex.
 
 ## Step 2: Define the Algorithm class
 
@@ -142,7 +142,7 @@ result = my_app(simple_graph, 10)  # pass 10 as param1 defined in 'MyAppContext.
 print(result.to_numpy('r'))
 ```
 
-## GraphScope C++ SDK with Github Template
+## GraphScope C++ SDK with GitHub Template
 
 To help you develop your algorithms more efficiently, we provide a [C++ template library](https://github.com/GraphScope/cpp-template) to help you get started with your algorithm development. It includes examples and best practices for implementing PIE algorithms in C++.
 

docs/analytical_engine/tutorial_dev_algo_java.md

@@ -17,7 +17,7 @@ from graphscope.framework.app import load_app
 # turn on this line to enable log verbose
 # graphscope.set_option(show_log=True) 
 
-"""Or lauch session in k8s cluster"""
+"""Or launch session in k8s cluster"""
 sess = graphscope.session(cluster_type='hosts') 
 
 graph = load_p2p_network(sess)    
@@ -170,17 +170,17 @@ sess = graphscope.session(cluster_type='hosts')
 graph = load_p2p_network(sess)
 graph = graph.project(vertices={"host": ['id']}, edges={"connect": ["dist"]})
 # you can also use your own graph, refer to graphscope load graph tutorial.
-# But remember project to singel property graph before running algorithms.
+# But remember project to single property graph before running algorithms.
 
 app=JavaApp(
     full_jar_path="{full/path/to/your/packed/jar}", # *-shaded.jar
-    java_app_class="{fullly/qualified/class/name/of/your/app}", # com.a.b.c
+    java_app_class="{fully/qualified/class/name/of/your/app}", # com.a.b.c
 )
 ctx=app(graph, "{param string}") # a=b,c=d
 ```
 
 After computation, you can obtain the results stored in context with the help of [`Context`](https://graphscope.io/docs/reference/context.html#context).
 
-## GraphScope JavaSDK with Github Template
+## GraphScope JavaSDK with GitHub Template
 
 If you don't bother creating new project to try `GRAPE-jdk`, we provide a template project [GraphScope-Java-template](https://github.com/zhanglei1949/GraphScope-Java-template). By click **Use this template**, you can create a new repository with same files and structure of the template repository. You can then try developing your own algorithms in this project.

docs/analytical_engine/tutorial_networkx_algorithms.md

@@ -1,4 +1,4 @@
-# Tutorial: Graph Algorithms with NetowrkX APIs
+# Tutorial: Graph Algorithms with NetworkX APIs
 
 In the [previous tutorial](https://graphscope.io/docs/latest/analytical_engine/tutorial_networkx_operations.html), we have introduced how to manipulate graph data with NetworkX APIs. In this tutorial, we will show how to use GraphScope to perform graph analysis like Networkx. 
 
@@ -119,7 +119,7 @@ Download dataset if it is not in environment:
 wget https://raw.githubusercontent.com/GraphScope/gstest/master/twitter.e -P /tmp
 ```
 
-Then load dataset both in GraphScope and NetwrokX.
+Then load dataset both in GraphScope and NetworkX.
 
 ```python
 import os

docs/analytical_engine/tutorial_networkx_operations.md

@@ -1,4 +1,4 @@
-# Tutorial: Graph Operations with NetowrkX APIs
+# Tutorial: Graph Operations with NetworkX APIs
 [NetworkX](https://networkx.org/) is a Python package for the manipulation and functions for graph data on a single machine. However, it lacks the capability of handling large-scale graphs on a distributed environment. Fortunately, GraphScope is compatible with NetworkX APIs, and thus a program written with NetworkX can directly run on GraphScope with only some small changes. In this tutorial, we will first introduce how to manipulate graph data with NetworkX APIs.
 
 ## Creating an Empty Graph
@@ -264,7 +264,7 @@ list(K.edges)
 Note that different from `subgraph`/`edge_subgraph` APIs in NetworkX which return a view, `graphscope.nx` returns a deepcopy of `subgraph`/`edge_subgraph`.
 
 ## Making Copies
-One can use `to_directed` to return a directed representaion of the graph.
+One can use `to_directed` to return a directed representation of the graph.
 
 ```python
 DG = G.to_directed()  # here would return a "deepcopy" directed representation of G.