typos (#3668)

* typos

* reorder and reword raco exe flags for CS/BC

Suggestsions from @sorawee, thanks!

* make two suggested edits, retract one

pkgs/racket-doc/scribblings/guide/performance.scrbl

@@ -105,7 +105,7 @@ Racket is available in two implementations, @deftech{CS} and
 In general, Racket programs should run the same in all variants.
 Furthermore, the performance characteristics of Racket program should
 be similar in the @tech{CS} and @tech{BC} implementations. The cases
-where a program may depends on the implementation will typically
+where a program may depend on the implementation will typically
 involve interactions with foreign libraries; in particular, the Racket
 C API described in @other-doc[inside-doc] is different for the
 @tech{CS} implementation versus the @tech{BC} implementation.
@@ -138,7 +138,7 @@ variant-independent format on all Racket implementations, but running
 code in that format requires an additional internal conversion step to
 the implementation's main bytecode format.
 
-Machine-independent bytecode for @tech{BC} implementation is further
+Machine-independent bytecode for the @tech{BC} implementation is further
 compiled to native code via a @deftech{just-in-time} or @deftech{JIT}
 compiler. The @tech{JIT} compiler substantially speeds programs that
 execute tight loops, arithmetic on small integers, and arithmetic on
@@ -147,7 +147,7 @@ for x86, x86_64 (a.k.a. AMD64), 32-bit ARM, and 32-bit PowerPC processors.
 The @tech{JIT} compiler can be disabled via the
 @racket[eval-jit-enabled] parameter or the @DFlag{no-jit}/@Flag{j}
 command-line flag for @exec{racket}. Setting @racket[eval-jit-enabled]
-to @racket[#f] has not effect on the @tech{CS} implementation of Racket.
+to @racket[#f] has no effect on the @tech{CS} implementation of Racket.
 
 The @tech{JIT} compiler works incrementally as functions are applied,
 but the @tech{JIT} compiler makes only limited use of run-time

pkgs/racket-doc/scribblings/raco/exe.scrbl

@@ -185,17 +185,19 @@ The @exec{raco exe} command accepts the following command-line flags:
    libraries when the executable is distributed to a different
    machine).}
 
+ @item{@DFlag{cs} --- generate an executable based on the @gtech{CS}
+   implementation of Racket, which is the default unless running a
+   @exec{raco exe} that is based on the @gtech{BC} implementation.}
+
  @item{@DFlag{3m} --- generate an executable based on the @gtech{3m}
-   variant of Racket, which is the default unless running a @exec{raco
-   exe} that is based on the @gtech{CGC} or @gtech{CS} variant.}
+   variant of Racket, which is the default only when running a @exec{raco
+   exe} that is based on the @gtech{3m} variant of the @gtech{BC}
+   implementation.}
 
  @item{@DFlag{cgc} --- generate an executable based on the @gtech{CGC}
    variant of Racket, which is the default only when running a
-   @exec{raco exe} that is based on the @gtech{CGC} variant.}
-
- @item{@DFlag{cs} --- generate an executable based on the @gtech{CS}
-   variant of Racket, which is the default only when running a
-   @exec{raco exe} that is based on the @gtech{CS} variant.}
+   @exec{raco exe} that is based on the @gtech{CGC} variant
+   of the @gtech{BC} implementation.}
 
  @item{@DPFlag{aux} @nonterm{file} --- attach information to the
    executable based on @nonterm{file}'s suffix; see

pkgs/racket-doc/scribblings/reference/compiler.scrbl

@@ -22,7 +22,7 @@ parameter to @racket[#f] or supplying the @DFlag{compile-any}/@Flag{M}
 flag on startup. See @racket[current-compile-target-machine] for more
 information.
 
-Other compilation modes depend on the Racket variant (see
+Other compilation modes depend on the Racket implementation (see
 @secref["implementations"]).
 
 

pkgs/racket-doc/scribblings/reference/implementation.scrbl

@@ -19,27 +19,27 @@ the implementation. Racket currently has two main implementations:
        specific to an operating system and architecture.}
 
  @item{The @deftech{BC} implementation was the default implementation
-       up until version 7.8. The ``BC'' label stands for ``before
+       up until version 7.9. The ``BC'' label stands for ``before
        Chez'' or ``bytecode.''
 
        Compiled Racket BC code in a @filepath{.zo} file normally
        contains platform-independent bytecode that is further compiled
        to machine code ``just in time'' as the code is loaded.
 
-       Racket BC has two subvariants: @deftech{3m} and @deftech{CGC}.
+       Racket BC has two variants: @deftech{3m} and @deftech{CGC}.
        The difference is the @tech{garbage collection} implementation,
        where 3m uses a garbage collector that moves objects in memory
        (an effect that is visible to foreign libraries, for example)
        and keeps precise track of allocated objects, while CGC uses a
        ``conservative'' collector that requires less cooperation from
        an embedding foreign environment. The 3m subvariant tends to
-       perform much better than CGC, and it because the default
+       perform much better than CGC, and it became the default
        variant in version 370 (which would be v3.7 in the current
        versioning convention).}
 
 ]
 
-Most Racket programs run the same in all variants, but some Racket
+Most Racket programs run the same in all implementation variants, but some Racket
 features are available only on some implementation variants, and the
 interaction of Racket and foreign functions is significantly different
 across the variants. Use @racket[system-type] to get information about