Improve broken sections in paper.

Author: yegor256

paper.tex

@@ -11,6 +11,8 @@
 \usepackage{to-be-determined}
 \setlength\footskip{13pt}
 
+\newcommand\broken{\tbd{This section is not valid, must be rewritten!}}
+
 \title{Reducing Programs to Objects}
 \subtitle{
   Ver:
@@ -238,6 +240,8 @@ \subsubsection{Multiple Returns}
 \subsection{Pointers}
 \label{sec:pointers}
 
+\broken
+
 A pointer is an object in many programming languages that stores a memory address.
 Pointers may point to data memory or program memory.
 
@@ -390,7 +394,9 @@ \subsection{Procedures}
 
 This example also demonstrates how \ff{go.to} object can be used to simulate the behavior of the \ff{return} statement from within the body of a method.
 
-\subsubsection{Impure Functions}
+\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,
@@ -420,6 +426,8 @@ \subsubsection{Impure Functions}
 \subsection{Classes}
 \label{sec: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:
 
 \begin{ffcode}
@@ -465,6 +473,8 @@ \subsection{Classes}
 \subsection{Destructors}
 \label{sec: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:
 
 \begin{ffcode}
@@ -521,26 +531,25 @@ \subsection{Exceptions}
 
 \begin{ffcode}
 [] > book
-  [] > price /int
+  [] > price ?
 [b] > price
   if. > @
     b.eq 0
     error "NPE!"
     b.price.times 1.1
 [b] > print
   try > @
-    []
+    [] >>
       QQ.io.stdout > @
-        QQ.txt.sprintf
-        "The price: %d"
-        price b
-    [e]
+        QQ.txt.sprintf *1
+          "The price: %d"
+          price b
+    [e] >>
       QQ.io.stdout > @
-        QQ.txt.sprintf
-        "Error: %s"
-        e
-    []
-      nop > @
+        QQ.txt.sprintf *1
+          "Error: %s"
+          e
+    true
 \end{ffcode}
 
 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).
@@ -549,6 +558,8 @@ \subsection{Exceptions}
 
 \subsubsection{Many Exception Types}
 
+\broken
+
 A Java method may throw a number of either checked or unchecked exceptions, for example:
 
 \begin{ffcode}
@@ -607,14 +618,14 @@ \subsection{Anonymous Functions}
 \begin{ffcode}
 [lines b] > scan
   lines.each > @
-    [t]
+    [t] >>
       if. > @
         t.starts-with "#"
         b t
         true
 scan
   array
-  [x]
+  [x] >>
     QQ.io.stdout x > @
 \end{ffcode}
 
@@ -623,6 +634,8 @@ \subsection{Anonymous Functions}
 \subsection{Generators}
 \label{sec:generators}
 
+\broken
+
 A generator is a routine that can be used to control the iteration behavior of a loop.
 For example, this PHP program will print the first ten Fibonacci numbers:
 
@@ -671,7 +684,11 @@ \subsection{Generators}
 \subsection{Types and Type Casting}
 \label{sec:types}
 
-A type system is a logical system comprising a set of rules that assign a property called a type to various constructs of a computer program, such as variables, expressions, functions, or modules. The main purpose of a type system is to reduce possibilities for bugs in computer programs by defining interfaces between different parts of a computer program, and then checking that the parts have been connected in a consistent way. In this example, a Java method \ff{add} expects an argument of type \ff{Book} and compilation would fail if another type is provided:
+\broken
+
+A type system is a logical system comprising a set of rules that assign a property called a type to various constructs of a computer program, such as variables, expressions, functions, or modules.
+The main purpose of a type system is to reduce possibilities for bugs in computer programs by defining interfaces between different parts of a computer program, and then checking that the parts have been connected in a consistent way.
+In this example, a Java method \ff{add} expects an argument of type \ff{Book} and compilation would fail if another type is provided:
 
 \begin{ffcode}
 class Cart {
@@ -728,6 +745,8 @@ \subsection{Types and Type Casting}
 \subsection{Reflection}
 \label{sec:reflection}
 
+\broken
+
 Reflection is the ability of a process to examine, introspect, and modify its own structure and behavior.
 In the following Python example, the method \ff{hello} of an instance of class \ff{Foo} is not called directly on the object but is first retrieved through reflection functions \ff{globals} and \ff{getattr}, and then executed:
 
@@ -743,6 +762,8 @@ \subsection{Reflection}
 
 \subsubsection{Monkey Patching}
 
+\broken
+
 Monkey patching is making changes to a module or class while the program is running.
 This JavaScript program adds a new method \ff{print} to the object \ff{b} after the object has already been instantiated:
 
@@ -808,6 +829,8 @@ \subsection{Static Methods}
 \subsection{Inheritance}
 \label{sec:inheritance}
 
+\broken
+
 Inheritance is the mechanism of basing a class upon another class while retaining similar implementation. In this Java code class \ff{Book} inherits all methods and non-private attributes from class \ff{Item}:
 
 \begin{ffcode}
@@ -837,6 +860,8 @@ \subsection{Inheritance}
 
 \subsubsection{Prototype-Based Inheritance}
 
+\broken
+
 So-called prototype-based programming uses generalized objects, which can then be cloned and extended. For example, this JavaScript program defines two objects, where \ff{Item} is the parent object and \ff{Book} is the child that inherits the parent through its prototype:
 
 \begin{ffcode}
@@ -875,6 +900,8 @@ \subsubsection{Prototype-Based Inheritance}
 
 \subsubsection{Multiple Inheritance}
 
+\broken
+
 Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit features from more than one parent object or parent class. In this C++ example,
 the class \ff{Jack} has both \ff{bark} and \ff{listen} methods, inherited from \ff{Dog} and \ff{Friend} respectively:
 
@@ -918,6 +945,8 @@ \subsubsection{Multiple Inheritance}
 \subsection{Method Overloading}
 \label{sec:overloading}
 
+\broken
+
 Method overloading is the ability to create multiple functions with the same name but different implementations. Calls to an overloaded function will run a specific implementation of that function appropriate to the context of the call, allowing one function call to perform different tasks depending on context. In this Kotlin program two functions are defined with the same name, while only one of them is called with an integer argument:
 
 \begin{ffcode}
@@ -943,7 +972,10 @@ \subsection{Method Overloading}
 \subsection{Java Generics}
 \label{sec:generics}
 
-Generics extend Java's type system to allow a type or method to operate on objects of various types while providing compile-time type safety. For example, this Java class expects another class to be specified as \ff{T} before use:
+\broken
+
+Generics extend Java's type system to allow a type or method to operate on objects of various types while providing compile-time type safety.
+For example, this Java class expects another class to be specified as \ff{T} before use:
 
 \begin{ffcode}
 class Cart<T extends Item> {
@@ -969,6 +1001,8 @@ \subsection{Java Generics}
 \subsection{C++ Templates}
 \label{sec:templates}
 
+\broken
+
 Templates are a feature of the C++ programming language that allows functions and classes to operate with generic types, allowing a function or class to work with many different data types without being rewritten for each one.
 
 \begin{ffcode}
@@ -994,6 +1028,8 @@ \subsection{C++ Templates}
 \subsection{Mixins}
 \label{sec:mixins}
 
+\broken
+
 A mixin is a class that contains methods for use by other classes without having to be the parent class of those other classes. The following code demonstrates how a Ruby module is included in a class:
 
 \begin{ffcode}
@@ -1017,6 +1053,8 @@ \subsection{Mixins}
 \subsection{Annotations}
 \label{sec:annotations}
 
+\broken
+
 In Java, an annotation is a form of syntactic metadata that can be added to source code; classes, methods, variables, parameters, and Java packages may be annotated. Later, annotations may be retrieved through the Reflection API. For example, this program analyzes the annotation attached to the class of the provided object and changes the behavior depending on one of its attributes:
 
 \begin{ffcode}
@@ -1060,6 +1098,8 @@ \subsection{Annotations}
 
 \section{Traceability}
 
+\broken
+
 A certain amount of semantic information may be lost during the translation from a more powerful programming language to \eolang{} objects, such as, for example, names, line numbers, comments, etc. Moreover, it may be useful to have the ability to trace \eolang{} objects back to the original language constructs from which they were derived. For example, a simple C function:
 
 \begin{ffcode}