Index: doc/papers/concurrency/response2
===================================================================
--- doc/papers/concurrency/response2	(revision b54118ad23651a1d9e49d473d666db9fc0d8cd48)
+++ doc/papers/concurrency/response2	(revision ec21f1328840e8dfb51c98e24c53a8afc1d1235e)
@@ -27,24 +27,9 @@
       thread creation and destruction?
 
-The best description of Smalltalk concurrency I can find is in J. Hunt,
-Smalltalk and Object Orientation, Springer-Verlag London Limited, 1997, Chapter
-31 Concurrency in Smalltalk. It states on page 332:
-
-  For a process to be spawned from the current process there must be some way
-  of creating a new process. This is done using one of four messages to a
-  block. These messages are:
-
-    aBlock fork: This creates and schedules a process which will execute the
-    block. The priority of this process is inherited from the parent process.
-    ...
-
-  The Semaphore class provides facilities for achieving simple synchronization,
-  it is simple because it only allows for two forms of communication signal and
-  wait.
-
-Hence, "aBlock fork" creates, "Semaphore" blocks/unblocks (as does message send
-to an aBlock object), and garbage collection of an aBlock joins with its
-thread. The fact that a programmer *implicitly* does "fork", "block"/"unblock",
-and "join", does not change their fundamental requirement.
+Fixed, changed sentence to:
+
+ A programmer needs mechanisms to create, block and unblock, and join with a
+ thread, even if these basic mechanisms are supplied indirectly through
+ high-level features.
 
 
@@ -103,5 +88,5 @@
 storage, too, which is a single instance across all generator instances of that
 type, as for static storage in an object type. All the kinds of storage are
-at play with semantics that is virtually the same as in other languages.
+at play with semantics that is the same as in other languages.
 
 
@@ -118,11 +103,9 @@
 Just-in-Time Compiler. We modified our test programs based on his advise, and
 he validated our programs as correctly measuring the specified language
-feature. Hence, we have taken into account all issues related to performing
-benchmarks in JITTED languages.  Dave's help is recognized in the
-Acknowledgment section. Also, all the benchmark programs are publicly available
-for independent verification.
-
-Similarly, we verified our Node.js programs with Gregor Richards, an expert in
-just-in-time compilation for dynamic typing.
+feature. Dave's help is recognized in the Acknowledgment section.  Similarly,
+we verified our Node.js programs with Gregor Richards, an expert in
+just-in-time compilation for dynamic typing.  Hence, we have taken into account
+all issues related to performing benchmarks in JITTED languages.  Also, all the
+benchmark programs are publicly available for independent verification.
 
 
@@ -155,32 +138,9 @@
 Since many aspects of Cforall are not OO, the rest of the paper *does* depend
 on Cforall being identified as non-OO, otherwise readers would have
-significantly different expectations for the design. We believe your definition
-of OO is too broad, such as including C. Just because a programming language
-can support aspects of the OO programming style, does not make it OO. (Just
-because a duck can swim does not make it a fish.)
-
-Our definition of non-OO follows directly from the Wikipedia entry:
-
-  Object-oriented programming (OOP) is a programming paradigm based on the
-  concept of "objects", which can contain data, in the form of fields (often
-  known as attributes or properties), and code, in the form of procedures
-  (often known as methods). A feature of objects is an object's procedures that
-  can access and often modify the data fields of the object with which they are
-  associated (objects have a notion of "this" or "self").
-  https://en.wikipedia.org/wiki/Object-oriented_programming
-
-Cforall fails this definition as code cannot appear in an "object" and there is
-no implicit receiver. As well, Cforall, Go, and Rust do not have nominal
-inheritance and they not considered OO languages, e.g.:
-
- "**Is Go an object-oriented language?** Yes and no. Although Go has types and
- methods and allows an object-oriented style of programming, there is no type
- hierarchy. The concept of "interface" in Go provides a different approach
- that we believe is easy to use and in some ways more general. There are also
- ways to embed types in other types to provide something analogous-but not
- identical-to subclassing. Moreover, methods in Go are more general than in
- C++ or Java: they can be defined for any sort of data, even built-in types
- such as plain, "unboxed" integers. They are not restricted to structs (classes).
- https://golang.org/doc/faq#Is_Go_an_object-oriented_language
+significantly different expectations for the design. We did not mean to suggest
+that languages that support function pointers with structures support an OO
+style. We revised the footnote to avoid this interpretation. Finally, Golang
+does not identify itself as an OO language.
+https://golang.org/doc/faq#Is_Go_an_object-oriented_language
 
 
@@ -219,5 +179,5 @@
 Whereas, the coroutine only needs the array allocated when needed. Now a
 coroutine has a stack which occupies storage, but the maximum stack size only
-needs to be the call chain allocating the most storage, where as the generator
+needs to be the call chain allocating the most storage, whereas the generator
 has a maximum size of all variable that could be created.
 
@@ -314,8 +274,8 @@
 
  \item[\newterm{execution state}:] is the state information needed by a
- control-flow feature to initialize, manage compute data and execution
- location(s), and de-initialize, \eg calling a function initializes a stack
- frame including contained objects with constructors, manages local data in
- blocks and return locations during calls, and de-initializes the frame by
+ control-flow feature to initialize and manage both compute data and execution
+ location(s), and de-initialize. For example, calling a function initializes a
+ stack frame including contained objects with constructors, manages local data
+ in blocks and return locations during calls, and de-initializes the frame by
  running any object destructors and management operations.
 
@@ -330,4 +290,5 @@
 appropriate word?
 
+
     "computation only" as opposed to what?
 
@@ -335,4 +296,5 @@
 i.e., the operation starts with everything it needs to compute its result and
 runs to completion, blocking only when it is done and returns its result.
+Computation only occurs in "embarrassingly parallel" problems.
 
 
@@ -596,5 +558,5 @@
     * coroutines/generators/threads: here there is some discussion, but it can
       be improved.
-    * interal/external scheduling: I didn't find any direct comparison between
+    * internal/external scheduling: I didn't find any direct comparison between
       these features, except by way of example.
 
@@ -672,5 +634,6 @@
   }
 
-Additonal text has been added to the start of Section 3.2 address this comment.
+Additional text has been added to the start of Section 3.2 addressing this
+comment.
 
 
@@ -787,8 +750,8 @@
 and its shorthand form (not shown in the paper)
 
-  waitfor( remove, remove2 : t );
-
-A call to one these remove functions satisfies the waitfor (exact selection
-details are discussed in Section 6.4).
+  waitfor( remove, remove2 : buffer );
+
+A call to either of these remove functions satisfies the waitfor (exact
+selection details are discussed in Section 6.4).
 
 
@@ -835,4 +798,5 @@
 signal or signal_block.
 
+
     I believe that one difference between the Go program and the Cforall
     equivalent is that the Goroutine has an associated queue, so that
@@ -842,4 +806,5 @@
 Actually, the buffer length is 0 for the Cforall call and the Go unbuffered
 send so both are synchronous communication.
+
 
     I think this should be stated explicitly. (Presumably, one could modify the
@@ -985,4 +950,5 @@
       sout | "join";
   }
+
   int main() {
       T t[3]; // threads start and delay
