code review 4252048: docs: make "runtime" a word only as a name for the package.

doc/go_for_cpp_programmers.html

 <!-- Go For C++ Programmers -->
 
 <p>
 Go is a systems programming language intended to be a general-purpose
 systems language, like C++.
 These are some notes on Go for experienced C++ programmers. This
 document discusses the differences between Go and C++, and says little
 to nothing about the similarities.
 
 <p>
@@ skipping 537 matching lines @@
 This is not precisely the same as a child class in C++.
 When a method of an anonymous field is called,
 its receiver is the field, not the surrounding struct.
 In other words, methods on anonymous fields are not virtual functions.
 When you want the equivalent of a virtual function, use an interface.
 
 <p>
 A variable which has an interface type may be converted to have a
 different interface type using a special construct called a type assertion.
 This is implemented dynamically
-at runtime, like C++ <code>dynamic_cast</code>.  Unlike
+at run time, like C++ <code>dynamic_cast</code>.  Unlike
 <code>dynamic_cast</code>, there does
 not need to be any declared relationship between the two interfaces.
 
 <pre>
 type myPrintInterface interface {
   print()
 }
 func f3(x myInterface) {
         x.(myPrintInterface).print()  // type assertion to myPrintInterface
 }
@@ skipping 13 matching lines @@
 <pre>
 type Any interface { }
 </pre>
 
 <p>
 Containers may be written in terms of <code>Any</code>, but the caller
 must unbox using a type assertion to recover
 values of the contained type.  As the typing is dynamic rather
 than static, there is no equivalent of the way that a C++ template may
 inline the relevant operations.  The operations are fully type-checked
-at runtime, but all operations will involve a function call.
+at run time, but all operations will involve a function call.
 
 <pre>
 type iterator interface {
         get() Any
         set(v Any)
         increment()
         equal(arg *iterator) bool
 }
 </pre>
 
@@ skipping 95 matching lines @@
 To use <code>manager2</code>, given a channel to it:
 
 <pre>
 func f4(ch &lt;- chan cmd2) int {
         myCh := make(chan int)
         c := cmd2{ true, 0, myCh }   // Composite literal syntax.
         ch &lt;- c
         return &lt;-myCh
 }
 </pre>