Accessible Scala: more text to explain the problem + fix typos

Author: MasseGuillaume

blog/_posts/2018-06-13-accessible-scala.md

@@ -7,19 +7,42 @@ title: Introducing Accessible Scala
 
   Scala is proudly a welcoming environment for all. The Scala Center is demonstrating this by supporting 
 the development of Accessible Scala, a tool for blind and partially-sighted developers (see [SCP-016]).
-One of its goals is to remove the noise introduced by various delimiters. For example, we could read the 
-following expression: `class S[+T]` as `class S parameterized with covariant T`. Since there is more than one way
-to pronounce Scala source code, we are open to the community proposition. You can find an extensive test case
+One of its goals is to remove the noise introduced by various delimiters. The current solution with
+text-to-speech engine, would read 
+
+```scala
+def foo[A: Wibble](s: String, b: Wobble[A]): Int = ...
+```
+
+as
+
+```bash
+def space foo open square bracket capital s colon space
+wibble close square bracket open bracket a colon space
+string comma space b colon space wobble open square bracket
+capital a close square bracket close bracket colon
+space Int space equals space ...
+```
+
+Indeed such a description is necessary to enable precision editing.
+
+However, the following would convey the same information more efficiently:
+
+```bash
+def foo parameterized with: A context bounded by: Wibble. s String, b Wobble of A returns: Int
+```
+  
+Since there is more than one way to pronounce Scala source code, we are open to the community proposition. You can find an extensive test case
 here: [DescribeTest.scala]. If you find that descriptions could be improved, send us a pull request with the 
 expected form.
 
-  Reading Scala out loud make some of its syntactic elements less intimidating for beginners. There is no more 
-need to mentally associate the syntax `+T` with its concept `co-variant`. Notice on the example above, how the type parameter delimiters: `[` and `]` are absent from the verbal description. It call also help sighted developers to describe Scala orally, for example in the context of pair programming. However, when expressions get more complex, the audible form can become ambiguous or difficult to decypher. 
+  Reading Scala out loud make some of its syntactic elements makes it less intimidating for beginners. There is no more 
+need to mentally associate the syntax `+T` with its concept `co-variant`. Notice in the example above, how the type parameter delimiters: `[` and `]` are absent from the verbal description. It can also help sighted developers to describe Scala orally, for example in the context of pair programming. However, when expressions get more complex, the audible form can become ambiguous or difficult to decipher. 
 
   To overcome the limitation of verbal description, we created a technique called the Cursor. The idea is simple:
 from your cursor location, you can navigate the abstract syntax tree of the source code. From a node, you can
 navigate to the parent node, to the siblings (left or right) or the first child. As you navigate the code,
-it's described verbally and selected. Here is an illustrated example, the arrows (→ exp ←) repesents the highlighted text and <kbd>Alt</kbd> + <kbd>Arrow</kbd> the keyboard shorcut applied to navigate. 
+it's described verbally and selected. Here is an illustrated example, the arrows (→ exp ←) represents the highlighted text and <kbd>Alt</kbd> + <kbd>Arrow</kbd> the keyboard shortcut applied to navigate. 
 
 ```
 
@@ -49,7 +72,7 @@ technique and hear the descriptions.
 
 # Want to try it?
 
-We created an [online demo]. You can try it now! (Tip: It works best on google-chrome! )
+We created an [online demo]. You can try it now! (Tip: It works best on Google Chrome! )
 
 We also created a [vscode extension], so you can try on your project. Search for `Accessible Scala` in the 
 extension manager