Concepts.md: rephrase to be less technical

hinerm · hinerm · commit 809d9897c7df · 2024-08-01T16:03:28.000-05:00
diff --git a/docs/ops/doc/Concepts.md b/docs/ops/doc/Concepts.md
@@ -3,68 +3,64 @@
 This page is designed to help *Ops users* understand the SciJava Ops concepts powering the framework.
 
 ## Ops
-An **algorithm** is a mathematical routine that transforms, interrogate, or refines input values into output values, and are used throughout scientific computing.
+An **algorithm** is a mathematical routine that transforms, interrogate, or refines input values into output values. Algorithms are used throughout scientific computing, and the fundamental [purpose](Purpose) of SciJava Ops is to facilitate their application.
 
-SciJava Ops attempts to abstract algorithm implementations into a more abstract, language independent form, called an **Op**. Ops have:
-* a **name**, defining its purpose. An Op's name describes *what* the Op does, but not *how* the Op does it. 
-  * An Op adding two Java `Integer`s would be named `math.add`
+We do that by providing a framework for consistently defining and invoking algorithm implementations as **Ops**. Ops have:
+* a **name**, establishing its purpose. An Op's name describes *what* the Op does, but not *how* the Op does it.
+  * An Op adding two numbers would be named `math.add`, as would an Op adding two images
   * An Op convolving an image with a kernel might be named `filter.convolve`, *regardless* of whether it performs that convolution in the physical or frequency domain.
 * a number of **inputs** and **outputs**, defined by language-specific **types**.
   * A `math.add` Op might take two Java `Integer` inputs and return a Java `Integer` output
   * A `filter.convolve` Op might take two OpenCV `Mat` inputs, storing the convolved result into an OpenCV `Mat` output *buffer*.
-* behavior adhering to a **functional interface** defined below.
+* behavior adhering to one of the three **Op types** defined below.
 
 ## Computers
 
-A **Computer** accepts `n` immutable inputs and a **container** as input parameters. Their singular method, `compute()`, executes an algorithm and *stores the result within* the container parameter, overwriting its contents.
+**Computer Ops** accept any number of immutable inputs and exactly one mutable **container** as parameters. When the algorithm they define is executed, *the result is stored within* the container parameter, overwriting its contents. The initial contents of the container do not affect computation.
 
-For example, consider the following pseudocode, which replaces the contents of a list of integers `outList` with the elementwise addition of integer `val` to the list of integers `inList`:
+For example, consider the following pseudocode, which populates a list of integers (`outList`) with the elementwise addition of an integer constant (`value`) to a provided list of integers (`inList`):
 ```text
-math.add(inList: list[int], val: int, outList: list[int]):
+math.add(inList: list[int], value: int, outList: list[int]):
   outList.clear()
   for i in 1..size(inList):
-    outList[i] = inList[i] + val
-  
+    outList[i] = inList[i] + value
 ```
 
 ## Functions
 
-A **Function** accepts `n` immutable inputs as parameters. Their singular method, `apply()`, executes an algorithm and *returns* a new output object to the user.
+**Function Ops** accept any number of immutable inputs as parameters. When the algorithm they define is executed, *the result is returned* as a new output to the user.
 
-For example, consider the following pseudocode, which returns a list of integers with the elementwise addition of integer `val` to the list of integers `inList`:
+For example, consider the following pseudocode, which creates a list of integers from the elementwise addition of an integer constant (`value`) to the provided list of integers (`inList`):
 ```text
-math.add(inList: list[int], val: int) -> list[int]:
+math.add(inList: list[int], value: int) -> list[int]:
   outList = list()
   for i in 1..size(inList):
-    outList[i] = inList[i] + val
+    outList[i] = inList[i] + value
   return outList
 ```
 
-Creating a new output object on every execution is a double-edged sword: on one hand, it can be convenient to delegate creation to the Op. On the other hand, output creation can be expensive and unnecessary if the Op is called many times.
+An advantage of Functions is their convenience. However, output creation can be expensive and unnecessary if the Op is called many times.
 
 ## Inplaces
 
-A **Inplace** accepts `n` input parameters, **only one** of which is mutable. Their singular method, `mutate()`, executes an algorithm and *overwrites* the single mutable parameter with the algorithm results.
+**Inplace Ops** accept any number of input parameters, **exactly one** of which is mutable. When the algorithm they define is executed, *the mutable parameter is modified* as a result of computation.
 
-For example, consider the following pseudocode, which mutates a list of integers `inList` by adding the integer `val` to each:
+For example, consider the following pseudocode, which modifies a provided list of integers (`inList`) by adding an integer constant (`value`) to each element:
 ```text
-math.add(inList: list[int], val: int):
+math.add(inList: list[int], value: int):
   for i in 1..size(inList):
-    inList[i] = inList[i] + val
+    inList[i] = inList[i] + value
 ```
 
-A major advantage of Inplaces is the efficiency gained by the absence of an output buffer. On the other hand, the input data is lost through computation.
+An advantage of Inplaces is both the convenience and savings (in time and memory) of not creating an output. On the other hand, the input data is lost through computation, and some algorithms require the input to remain unmodified (e.g. for neighborhood calculations).
 
 ## OpEnvironment
 
-The Op environment collects all available Ops, and provides access to their functionality. `OpEnvironment` objects are instantiated using the line shown below, and once created will contain all available Ops:
-```java
-OpEnvironment ops = OpEnvironment.build();
-```
+The **Op environment** collects all available Ops, and serves as a gateway for accessing their functionality. Obtaining an `OpEnvironment` is the first step for any Ops use. 
 
 With an `OpEnvironment`, users can:
 * Find Ops, using the `OpEnvironment.help()` API (see [Searching For Ops](SearchingForOps.md))
-* Execute Ops, using the `OpEnvironment.op()` API (see [Calling Ops](CallingOps.md), and the `OpBuilder` section below.)
+* Execute Ops, using the `OpEnvironment.op()` API (see [Calling Ops](CallingOps.md))
 
 ## OpBuilder
 
