Clean up getting started text

docs/_pages/getting-started.md

@@ -42,7 +42,7 @@ print(isfoo(1))
 
 Note that there are no warnings about calling ``ispositive()`` with a string, or calling ``isfoo()`` a number. 
 
-## Enabling type inference
+## Type inference
 
 Now modify the script to include ``--!strict`` at the top:
 
@@ -64,7 +64,11 @@ print(isfoo("bar"))
 print(isfoo(1))
 ```
 
-Note that the editor now highlights the incorrect calls to ``ispositive()`` and ``isfoo()``.
+In ``strict`` mode, Luau will infer types based on analysis of the code flow. There is also ``nonstrict`` mode, where analysis is more conservative and types are more frequently inferred as ``any`` to reduce cases where legitimate code is flagged with warnings.
+
+In this case, Luau will use the ``return x > 0`` statement to infer that ``ispositive()`` is a function taking an integer and returning a boolean. Similarly, it will use the ``return a == "foo"`` statement to infer that ``isfoo()`` is a function taking a string and returning a boolean. Note that in both cases, it was not necessary to add any explicit type annotations.
+
+Based on Luau's type inference, the editor now highlights the incorrect calls to ``ispositive()`` and ``isfoo()``:
 
 <figure>
   <img src="{{ site.url }}{{ site.baseurl }}/assets/images/error-ispositive.png">
@@ -87,7 +91,7 @@ result = ispositive(1)
 
 ```
 
-Everything is good. We've told the editor that ``ispositive()`` accepts a number and returns a boolean, and that's how we're using it. But imagine that later we decide to change ``ispositive()`` to return a string value:
+Now we've told explicitly told Luau that ``ispositive()`` accepts a number and returns a boolean. This wasn't strictly (pun intended) necessary in this case, because Luau's inference was able to deduce this already. But even in this case, there are advantages to explicit annotations. Imagine that later we decide to change ``ispositive()`` to return a string value:
 
 ```lua
 --!strict
@@ -104,13 +108,13 @@ local result : boolean
 result = ispositive(1)
 ```
 
-Oops -- we're returning string values, but we forgot to update the function return type. Since ``print()`` accepts anything, the call to ``ispositive()`` is still valid. But because the annotation doesn't match our code, we get a warning in the function body itself:
+Oops -- we're returning string values, but we forgot to update the function return type. Since we've told Luau that ``ispositive()`` returns a boolean (and that's how we're using it), the call site isn't flagged as an error. But because the annotation doesn't match our code, we get a warning in the function body itself:
 
 <figure>
   <img src="{{ site.url }}{{ site.baseurl }}/assets/images/error-ispositive-string.png">
 </figure>
 
-And then of course, the fix is simple; just change the annotation to declare the return type as a string.
+The fix is simple; just change the annotation to declare the return type as a string:
 
 ```lua
 --!strict
@@ -127,13 +131,13 @@ local result : boolean
 result = ispositive(1)
 ```
 
-Well, almost - we also declared result as a boolean, and now that's clearly wrong.
+Well, almost - since we declared ``result`` as a boolean, the call site is now flagged:
 
 <figure>
   <img src="{{ site.url }}{{ site.baseurl }}/assets/images/error-ispositive-boolean.png">
 </figure>
 
-So now we update the type of the local variable, and everything is good.
+If we update the type of the local variable, everything is good. Note that we could also just let Luau infer the type of ``result`` by changing it to the single line version ``local result = ispositive(1)``.
 
 ```lua
 --!strict
@@ -152,4 +156,4 @@ result = ispositive(1)
 
 ## Conclusions
 
-To dive into more areas of Luau, check out our main reference pages for [syntax](syntax) and [typechecking](typecheck)
+This has been a brief tour of the basic functionality of Luau, but there's lots more to explore. If you're interested in reading more, check out our main reference pages for [syntax](syntax) and [typechecking](typecheck).