Changes in doc/papers/concurrency/response2 [016b1eb:b54118a]

File:

• doc/papers/concurrency/response2 (modified) (14 diffs)

doc/papers/concurrency/response2

@@ -27 +27 @@
       thread creation and destruction?
 
-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.
+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.
 
 
@@ -88 +103 @@
 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 the same as in other languages.
+at play with semantics that is virtually the same as in other languages.
 
 
@@ -103 +118 @@
 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. 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.
+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.
 
 
@@ -138 +155 @@
 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 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
+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
 
 
@@ -179 +219 @@
 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, whereas the generator
+needs to be the call chain allocating the most storage, where as the generator
 has a maximum size of all variable that could be created.
 
@@ -274 +314 @@
 
  \item[\newterm{execution state}:] is the state information needed by a
- 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
+ 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
  running any object destructors and management operations.
 
@@ -290 +330 @@
 appropriate word?
 
-
     "computation only" as opposed to what?
 
@@ -296 +335 @@
 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.
 
 
@@ -558 +596 @@
     * coroutines/generators/threads: here there is some discussion, but it can
       be improved.
-    * internal/external scheduling: I didn't find any direct comparison between
+    * interal/external scheduling: I didn't find any direct comparison between
       these features, except by way of example.
 
@@ -634 +672 @@
   }
 
-Additional text has been added to the start of Section 3.2 addressing this
-comment.
+Additonal text has been added to the start of Section 3.2 address this comment.
 
 
@@ -750 +787 @@
 and its shorthand form (not shown in the paper)
 
-  waitfor( remove, remove2 : buffer );
-
-A call to either of these remove functions satisfies the waitfor (exact
-selection details are discussed in Section 6.4).
+  waitfor( remove, remove2 : t );
+
+A call to one these remove functions satisfies the waitfor (exact selection
+details are discussed in Section 6.4).
 
 
@@ -798 +835 @@
 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
@@ -806 +842 @@
 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
@@ -950 +985 @@
       sout | "join";
   }
-
   int main() {
       T t[3]; // threads start and delay