Refactor paper.tex for clarity and consistency.

Author: yegor256

DEPENDS.txt

@@ -6,6 +6,7 @@ hard babel-russian
 hard biblatex
 hard booktabs
 hard cancel
+hard caption
 hard catchfile
 hard cjk
 hard cm-super

paper.tex

@@ -28,7 +28,7 @@
 \begin{abstract}
 C++, Java, C\#, Python, Ruby, and JavaScript are the most powerful object-oriented programming languages if language power is defined as the number of \emph{features} available to a programmer.
 \eolang{}, on the other hand, is an object-oriented programming language with a reduced set of features: it has nothing but objects and mechanisms of their composition and decoration.
-We are trying to answer the following research question: ``Which known features are possible to implement using only objects?''
+This paper asks the following research question: ``Which known features are possible to implement using only objects?''
 \end{abstract}
 
 \begin{document}
@@ -38,7 +38,7 @@
 
 \section{Features}
 
-To answer our research question we selected the most complex features and demonstrated how each of them may be represented in \eolang{}~\citep{bugayenko2021eolang} objects\footnote{%
+We selected the most complex features and demonstrated how each of them may be represented in \eolang{}~\citep{bugayenko2021eolang} objects\footnote{%
 \LaTeX{} sources of this paper are maintained in
 \href{https://github.com/REPOSITORY}{REPOSITORY} GitHub repository,
 the rendered version is \href{https://github.com/REPOSITORY/releases/tag/0.0.0}{\ff{0.0.0}}.}:
@@ -83,7 +83,8 @@ \section{Features}
 \subsection{Goto}
 \label{sec:goto}
 
-Goto is a one-way imperative transfer of control to another line of code. There are only two possible cases of goto jumps: forward and backward.
+Goto is a one-way imperative transfer of control to another line of code.
+There are only two possible cases of goto jumps: forward and backward.
 
 \subsubsection{Backward Jump}
 
@@ -121,7 +122,7 @@ \subsubsection{Backward Jump}
 \end{ffcode}
 
 Here, the one-argument abstract atom \ff{go.to} is being copied with a one-argument abstract anonymous object, which is a sequence of objects incrementing \ff{i} and then comparing it with the number ten.
-If the condition is true, \ff{g.backward} is called, which leads to a backward jump and re-iteration of \ff{go.to}.
+If the condition is true, \ff{backward} is called, which leads to a backward jump and re-iteration of \ff{go.to}.
 
 \subsubsection{Forward Jump}
 
@@ -158,7 +159,7 @@ \subsubsection{Forward Jump}
 \end{ffcode}
 
 Here, the same abstract atom \ff{go.to} is copied with an abstract one-argument object that is a sequence of objects.
-When the condition is true, a forward jump is performed by \ff{g.forward} atom.
+When the condition is true, a forward jump is performed by \ff{forward} atom.
 
 Similarly, the atom \ff{go.to} may be used to simulate other conditional jump statements, like \ff{break}, \ff{continue}, or \ff{return} in the middle of a function body (see \cref{sec:procedures}).
 
@@ -205,7 +206,7 @@ \subsubsection{Complex Case}
 
 Then, the translation to \eolang{} is trivial using the \ff{go.to} object.
 
-In more complex cases, a program may first be restructured to replace \ff{goto} statements with loops and branching, as suggested by~\citet{williams1985restructuring,pan1996formal,erosa1994taming,ceccato2008goto}.
+In more complex cases, a program may first be restructured to replace \ff{goto} statements with loops and branching, as suggested by \citet{williams1985restructuring,pan1996formal,erosa1994taming,ceccato2008goto}.
 
 \subsubsection{Multiple Returns}
 
@@ -235,7 +236,7 @@ \subsubsection{Multiple Returns}
           -1.times x
 \end{ffcode}
 
-The dataization of \ff{g.forward} will exit the \ff{go.to} object wrapping the entire code in the ``function'' \ff{abs}.
+The dataization of \ff{forward} will exit the \ff{go.to} object wrapping the entire code in the ``function'' \ff{abs}.
 
 \subsection{Pointers}
 \label{sec:pointers}
@@ -286,13 +287,19 @@ \subsubsection{Pointers to Data}
     b.price
 \end{ffcode}
 
-Here, \ff{p1} is an object that can be used as an argument of \ff{f}. It is a copy of an abstract object \ff{heap.pointer}, which expects two parameters: 1)~an absolute address in memory and 2)~the size of the memory block it points to, in bytes. Its attribute \ff{block} expects two attributes: 1)~the number of bytes in the heap and 2)~an abstract object that can encapsulate \ff{bytes} that were just read from memory.
+Here, \ff{p1} is an object that can be used as an argument of \ff{f}.
+It is a copy of an abstract object \ff{heap.pointer}, which expects two parameters:
+  1)~an absolute address in memory
+  and
+  2)~the size of the memory block it points to, in bytes.
+Its attribute \ff{block} expects two attributes: 1)~the number of bytes in the heap and 2)~an abstract object that can encapsulate \ff{bytes} that were just read from memory.
 
 The object \ff{heap} is an abstraction of a random access memory.
 
 \subsubsection{Pointers to Code}
 
-A pointer may not only refer to data in the heap but also to executable code in memory (there is no difference between ``program'' and ``data'' memory in both x86 and ARM architectures). This is an example of a C program that calls a function referenced by a function pointer, providing two integer arguments to it:
+A pointer may not only refer to data in the heap but also to executable code in memory (there is no difference between ``program'' and ``data'' memory in both x86 and ARM architectures).
+This is an example of a C program that calls a function referenced by a function pointer, providing two integer arguments to it:
 
 \begin{ffcode}
 int foo(int x, int y) {
@@ -364,12 +371,15 @@ \subsubsection{Variables in Stack}
     ret
 \end{ffcode}
 
-Here, the atom \ff{malloc} allocates a segment of bytes in the \ff{heap}. Later, the atom \ff{free} releases it. The attribute \ff{ret} is made constant to avoid its recalculation after it is ``returned'' (this mechanism is explained in \cref{sec:destructors} where destructors are discussed).
+Here, the atom \ff{malloc} allocates a segment of bytes in the \ff{heap}. Later, the atom \ff{free} releases it.
+The attribute \ff{ret} is made constant to avoid its recalculation after it is ``returned'' (this mechanism is explained in \cref{sec:destructors} where destructors are discussed).
 
 \subsection{Procedures}
 \label{sec:procedures}
 
-A subroutine is a sequence of program instructions that performs a specific task, packaged as a unit. In different programming languages, a subroutine may be called a routine, subprogram, function, method, or procedure. In this PHP example, a function \ff{max} is defined:
+A subroutine is a sequence of program instructions that performs a specific task, packaged as a unit.
+In different programming languages, a subroutine may be called a routine, subprogram, function, method, or procedure.
+In this PHP example, a function \ff{max} is defined:
 
 \begin{ffcode}
 function max($a, $b) {
@@ -398,9 +408,8 @@ \subsection{Impure Functions}
 
 \broken
 
-A function is pure when, among other qualities, it does not have side effects:
-no mutation of local static variables, non-local variables, mutable reference arguments,
-or input/output streams. This PHP function is impure:
+A function is pure when, among other qualities, it does not have side effects: no mutation of local static variables, non-local variables, mutable reference arguments, or input/output streams.
+This PHP function is impure:
 
 \begin{ffcode}
 $a = 42;
@@ -428,7 +437,8 @@ \subsection{Classes}
 
 \broken
 
-A class is an extensible program code template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods). The following program contains a Ruby class with a single constructor, two methods, and one mutable member variable:
+A class is an extensible program code template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods).
+The following program contains a Ruby class with a single constructor, two methods, and one mutable member variable:
 
 \begin{ffcode}
 class Book
@@ -461,7 +471,8 @@ \subsection{Classes}
     id.write i > @
 \end{ffcode}
 
-Here, the constructor is represented by the object \ff{ruby-init}, which finishes the initialization of the object. Making an ``instance'' of a book would look like this:
+Here, the constructor is represented by the object \ff{ruby-init}, which finishes the initialization of the object.
+Making an ``instance'' of a book would look like this:
 
 \begin{ffcode}
 book 42 > b
@@ -475,7 +486,8 @@ \subsection{Destructors}
 
 \broken
 
-In C++ and some other languages, a destructor is a method that is called for a class object when that object passes out of scope or is explicitly deleted. The following code will print both \ff{Alive} and \ff{Dead} texts:
+In C++ and some other languages, a destructor is a method that is called for a class object when that object passes out of scope or is explicitly deleted.
+The following code will print both \ff{Alive} and \ff{Dead} texts:
 
 \begin{ffcode}
 #include <iostream>
@@ -509,7 +521,8 @@ \subsection{Destructors}
 \subsection{Exceptions}
 \label{sec:exceptions}
 
-Exception handling is the process of responding to the occurrence of exceptions—anomalous or exceptional conditions requiring special processing—during the execution of a program. This C++ program utilizes exception handling to avoid segmentation fault due to null pointer de-referencing:
+Exception handling is the process of responding to the occurrence of exceptions—anomalous or exceptional conditions requiring special processing—during the execution of a program.
+This C++ program utilizes exception handling to avoid segmentation fault due to null pointer de-referencing:
 
 \begin{ffcode}
 #include <iostream>
@@ -554,7 +567,8 @@ \subsection{Exceptions}
 
 Here, the object \ff{try} expects three arguments: 1)~an abstract object to be dataized, 2)~an abstract object to be copied with one argument, in case dataization returns an encapsulated object, and 3)~an object to be dataized anyway (similar to Java \ff{finally} block).
 
-In the object \ff{price}, we get the object \ff{error}, which, if dataized, causes the termination of dataization and a non-conditional jump to the ``catch'' object of the \ff{try}. The mechanism is similar to ``checked'' exceptions in Java, where a method's signature must declare all types of exceptions the method may throw.
+In the object \ff{price}, we get the object \ff{error}, which, if dataized, causes the termination of dataization and a non-conditional jump to the ``catch'' object of the \ff{try}.
+The mechanism is similar to ``checked'' exceptions in Java, where a method's signature must declare all types of exceptions the method may throw.
 
 \subsubsection{Many Exception Types}