fix: Correct sentences

docs/usage/interpreter/interpreter_binding_mode.md

@@ -31,14 +31,14 @@ limitations under the License.
 <br/>
 
 Interpreter is a JVM process that communicates with Zeppelin daemon using thrift. 
-Each Interpreter process can have a interpreter group, and each interpreter instance belongs to this interpreter group.
+Each interpreter process has a single interpreter group, and this interpreter group can have one or more instances of an interpreter.
 (See [here](../../development/writing_zeppelin_interpreter.html) to understand more about its internal structure.) 
 
 Zeppelin provides 3 different modes to run interpreter process: **shared**, **scoped** and **isolated**.   
-Also, user can specify the scope of these mode as well: **per user** or **per note**.  
+Also, the user can specify the scope of these modes: **per** user or **per note**.
 These 3 modes give flexibility to fit Zeppelin into any type of use cases.
 
-In this documentation, we mainly discuss the combination of **per note** mode with **shared**, **scoped** and **isolated** modes for explanation. 
+In this documentation, we mainly discuss the **per note** scope in combination with the **shared**, **scoped** and **isolated** modes.
 
 ## Shared Mode
 
@@ -56,8 +56,8 @@ In **Shared** mode, single JVM process and a single session serves all notes. As
 </div>
 <br/>
 
-In Scoped mode, Zeppelin still runs single interpreter JVM process but multiple sessions serve each note. (in case of **per note**) 
-So, each note have their own dedicated session. (but still possible to share objects via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
+In **Scoped** mode, Zeppelin still runs a single interpreter JVM process but, in the case of per note scope, each note runs in its own dedicated session. 
+(Note it is still possible to share objects between these notes via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
 
 ## Isolated Mode
 
@@ -66,8 +66,8 @@ So, each note have their own dedicated session. (but still possible to share obj
 </div>
 <br/>
 
-**Isolated** mode runs separate interpreter process for each note. (in case of **per note**) 
-So, each note have absolutely isolated session. (but still possible to share objects via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
+**Isolated** mode runs a separate interpreter process for each note in the case of **per note** scope. 
+So, each note has an absolutely isolated session. (But it is still possible to share objects via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
 
 ## Which mode should I use?
 
@@ -75,11 +75,11 @@ So, each note have absolutely isolated session. (but still possible to share obj
 
 Mode | Each notebook...	| Benefits | Disadvantages | Sharing objects
 --- | --- | --- | --- | ---
-**shared** | Shares a single sessions in a single interpreter process (JVM) | Low resource utilization and Easy to share data between notebooks | All notebooks are affected if Interpreter Process dies | can share directly
-**scoped** | Has its own note sessions in the same Interpreter Process (JVM) | Less resource utilization than isolated mode | All notebooks are affected if Interpreter Process dies | can't share directly, but possible to share objets via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
-**isolated** | Has its own Interpreter Process | One notebook not affected directly by other notebooks (**per note**) | Can't share data between notebooks easily (**per note**) | can't share directly, but possible to share objets via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
+**shared** |  Shares a single session in a single interpreter process (JVM) |  Low resource utilization and it's easy to share data between notebooks |  All notebooks are affected if the interpreter process dies | Can share directly
+**scoped** | Has its own session in the same interpreter process (JVM) | Less resource utilization than isolated mode |  All notebooks are affected if the interpreter process dies | Can't share directly, but it's possible to share objects via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
+**isolated** | Has its own Interpreter Process | One notebook is not affected directly by other notebooks (**per note**) | Can't share data between notebooks easily (**per note**) | Can't share directly, but it's possible to share objects via [ResourcePool](../../interpreter/spark.html#object-exchange)) 
 
-In case of **per user** (available on multi-user environment), Zeppelin manages interpreter sessions per user. For example,
+In the case of the **per user** scope (available in a multi-user environment), Zeppelin manages interpreter sessions on a per user basis rather than a per note basis. For example:
  
 - In **scoped + per user** mode, `User A`'s notes **might** be affected by `User B`'s notes. (e.g JVM dies, ...) Because all notes are running on the same JVM
 - On the other hand, **isolated + per user** mode, `User A`'s notes will not be affected by others' notes which running on separated JVMs
@@ -87,7 +87,7 @@ In case of **per user** (available on multi-user environment), Zeppelin manages
 <br/>
 
 Each Interpreter implementation may have different characteristics depending on the back end system that they integrate. And 3 interpreter modes can be used differently.
-Let’s take a look how Spark Interpreter implementation uses these 3 interpreter modes with **per note** mdoe, as an example. 
+Let’s take a look how Spark Interpreter implementation uses these 3 interpreter modes with **per note** scope, as an example.
 Spark Interpreter implementation includes 4 different interpreters in the group: Spark, SparkSQL, Pyspark and SparkR. 
 SparkInterpreter instance embeds Scala REPL for interactive Spark API execution.
 
@@ -109,8 +109,8 @@ In this mode, if `Note A` defines variable ‘a’ then `Note B` not only able t
 
 In Scoped mode, each note has its own Scala REPL. 
 So variable defined in a note can not be read or overridden in another note. 
-However, still single SparkContext serves all the sessions. 
-And all the jobs are submitted to this SparkContext and fair scheduler schedules the job. 
+However, a single SparkContext still serves all the sessions.
+And all the jobs are submitted to this SparkContext and the fair scheduler schedules the jobs.
 This could be useful when user does not want to share Scala session, but want to keep single Spark application and leverage its fair scheduler.
 
 In Isolated mode, each note has its own SparkContext and Scala REPL.