applying code review requests

Author: tiagobstr

Writerside/topics/ChiselMethod.md

@@ -1,6 +1,6 @@
 # The Chisel Method
 
-The Chisel method for writing parsers allows to build parsers consistently using the same approach which allows to achieve a consistency on the architectural decisions and enables developers to get familiar with a project easily.
+The Chisel method allows to build parsers consistently using the same approach which allows to achieve a consistency on the architectural decisions and enables developers to get familiar with a project easily.
 
 This method is called Chisel because building parsers is about getting the information out of the code, as when you use a chisel you "take" the statue out of the marble. Also, since Strumenta means tools in Latin, Chisel takes the place as one of the most important tool in the company's toolset.
 
@@ -12,7 +12,8 @@ The Chisel method is based on the following principles:
 
 The Chisel method is based on the following steps:
 
-1. Create a parser using the StarLasu Libraries, for that you need to:
+1. Create a parser using the StarLasu Libraries and Starlasu Tools, for that you need to:
+
   - Define a grammar;
   - Use the starlasu libraries to generate the AST;
   - Refine the AST;

Writerside/topics/CodeGeneration.md

@@ -1,8 +1,8 @@
 # Code Generation
 
-Code Generation modules are usefull to generate new files programmatically. This is the case when building a transpiler, where there is the need to generate text (code) from an AST representation.
+Code Generation modules are useful to generate new files programmatically. This is the case when building a transpiler, where there is the need to generate text (code) from an AST representation.
 
-Currently Code Generation modules can be written only with Kolasu.
+Currently, Code Generation modules can be written with Kolasu and SharpLasu.
 
 ## Setup 
 
@@ -33,7 +33,6 @@ dependencies {
 
     implementation("com.github.ajalt.clikt:clikt:3.5.0")
 }
-
 ```
 
 ## Generation rules
@@ -48,7 +47,7 @@ class MyCodeGenerator : ASTCodeGenerator() {
             indent()
             println(it.field2)
             dedent()
-            printList(prefix = "",postfix = "",elements = it.children,separator = "\n")
+            printList(prefix = "", postfix = "", elements = it.children, separator = "\n")
             printFlag(it.flag,"Flag is true")
         }
     }
@@ -67,18 +66,21 @@ The methods to generate code are quite simple and intuitive to use:
 
 There is the need to know how the generated code should look like. 
 
-Unit testing can be done by writing the expected output in a file/string and comparing the generated output with the expected output using as input a manually created AST.
+For that unit testing can be done by writing the expected output in a file/string and comparing the generated output with the expected output using as input a manually created AST.
 
 It is also a good practise to have end-to-end tests, and one can follow 2 methods:
 
 1. AST to AST testing:
-   - Parse an input file that contains the original code to the target AST representation;
-   - Parse an input file that contains the expected code to the expected AST representation;
-   - Compare the expected AST with the generated AST.
+
+   - Parse an input file that contains the original code, obtaining a first AST;
+   - Generate the code from this first AST, obtaining the generated code;
+   - Reparse the generated code, obtaining a second AST;
+   - Compare the first and the second AST.
 
 This testing method is useful to test large examples, where it is hard to write the expected output manually. It allows to test the code generation in a more abstract way, where we check that the produced AST matches the one we expect. Of course it lacks coverage for code styling and formatting.
 
 2. AST to code testing:
+
    - Parse a string that contains the original code to the target AST representation;
    - Generate the code from the target AST;
    - Compare the expected output with the generated output.

Writerside/topics/DualCodeModelAPIs.md

@@ -1,14 +1,17 @@
 # The Dual Code Model APIs
 
-This segment is more theoretical than the others. It is meant to provide a high-level overview of the dual code model APIs and the approach followed in the development of the starlasu tools.
-It will approach the concepts of homogenous and heterogeneous APIs, and how to use and leveraged them in the starlasu tools.
+This segment is more theoretical than the others. It is meant to provide a high-level overview of the dual code model APIs and the approach followed in the development of the StarLasu libraries.
+It will approach the concepts of homogenous and heterogeneous APIs, and how to use and leveraged them in the StarLasu libraries.
 
 ## Homogenous APIs
 
 In kolasu, [Nodes](https://github.com/Strumenta/kolasu/blob/main/core/src/main/kotlin/com/strumenta/kolasu/model/Node.kt) are the basic building blocks of an AST. They are used to represent the different elements of the language being parsed.
-All the instances of nodes are the same and have a defined set of properties and methods, such as the origin, parent, etc... This is what we call a homogenous API. 
+All the instances of nodes are the same and have a defined set of properties and methods, such as the origin, parent, etc... 
 
-This homogenous APIs are important to develop generic tools, such as the current efforts to have an algorithm to find idioms within a language. Using the homogenous API, we can develop a tool that can be used for any language that has an AST representation.
+There are also reflective capabilities: so that its possible to ask each node for its properties and for each property to have access to the name, type and multiplicity, which allows to write fully generic algorithms. 
+This is what we call a homogenous API. 
+
+This homogenous APIs are important to develop generic tools, like interpreters or semantic enrichment modules. Using the homogenous API, we can develop a tool that can be used for any language that has an AST representation.
 ## Heterogeneous APIs
 
 On the other hand, each Node can also have its own specific set of properties and methods. For instance a Node that represents an if statement can have the condition and the body properties.

Writerside/topics/Serialization.md

@@ -2,7 +2,7 @@
 
 In addition to what is described here, there is also EMF serialization, which is discussed separately. See [EMF](EMFInteroperability.md).
 
-StarLasu supports exporting ASTs to JSON and XML. 
-Additionally, kolasu supports import/export from the [Lionweb](https://github.com/Strumenta/kolasu/blob/main/lionweb/src/main/kotlin/com/strumenta/kolasu/lionweb/LionWebModelConverter.kt) format. 
+StarLasu Tools supports exporting ASTs to JSON and XML. 
+Additionally, [kolasu](https://github.com/Strumenta/kolasu/blob/main/lionweb/src/main/kotlin/com/strumenta/kolasu/lionweb/LionWebModelConverter.kt) and [tylasu](https://github.com/Strumenta/tylasu/blob/master/src/interop/lionweb.ts) support import/export from the LionWeb format 
 
 _See in [Kolasu](https://github.com/Strumenta/kolasu/tree/main/serialization/src/main/kotlin)_.