Merge branch 'main' into docs

knowledge_knowledge/knowledge_aquamarine/README.md

@@ -6,12 +6,13 @@ At the core of Aquamarine is the design ideal and idea to pair concurrent system
 
 ## Background
 
-When we build systems, we need to be able to model, specify, analyze and verify them and this is especially important to concurrent systems such as parallel and multi-threaded systems. [Formal specifications](https://en.wikipedia.org/wiki/Formal_specification) are a family of formal approaches to design, model, and verify system. In the context of concurrent systems, there are two distinct formal specification techniques available. The state oriented approach is concerned with modeling verifying a systems state and state transitions and is often accomplished with [TLA+](https://en.wikipedia.org/wiki/TLA%2B). Modern blockchain design, modeling, and verification tend to rely on a state-based specification.
+When we build systems, we need to be able to model, specify, analyze and verify them and this is especially important to concurrent systems such as parallel and multi-threaded systems. [Formal specification](https://en.wikipedia.org/wiki/Formal_specification) are a family of formal approaches to design, model, and verify system. In the context of concurrent systems, there are two distinct formal specification techniques available. The state oriented approach is concerned with modeling verifying a systems state and state transitions and is often accomplished with [TLA+](https://en.wikipedia.org/wiki/TLA%2B). Modern blockchain design, modeling, and verification tend to rely on a state-based specification.
 
 An alternative, complementary approach is based on [Process calculus](https://en.wikipedia.org/wiki/Process_calculus) to model and verify the sequence of communications operations of a system at any given time. [π-Calculs](https://en.wikipedia.org/wiki/%CE%A0-calculus) is a modern process calculus employed in a wide range of applications ranging from biology to games and business processes.
 
 Aquamarine, Fluence's distributed composition language and runtime, is based on π-calculus and provides a solid theoretical basis toward the design, modeling, implementation, and verification of a wide class of distributed, peer-to-peer networks, applications and backends.
 
+
 ## Language
 
 [Aquamarine Intermediate Representation](https://github.com/boneyard93501/docs/tree/a512080f81137fb575a5b96d3f3e83fa3044fd1c/src/knowledge-base/knowledge_aquamarine__air.md) \(AIR\) is a low-level language modeled after the [WebAssembly text format](https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format) and allows developers to manage network peers as well as services and backends. AIR, while intended as a compile target, is currently the only Aquamarine language implementation although a high level language \(HLL\) is currently under active development.

knowledge_knowledge/knowledge_aquamarine/hll.md

@@ -1,10 +1,6 @@
 # HLL
 
-### Aquamarine High Level Language
 
-Since parenthesis management is a bit of a downer, we are very soon providing a high level language with AIR as the compile target. Aquamarine users, rejoice !
+## Aquamarine High Level Language
 
 _**Stay Tuned -- Coming Soon To A Repo Near You**_
-
-
-

knowledge_knowledge/knowledge_aquamarine/knowledge_aquamarine_air.md

@@ -53,3 +53,4 @@ This instruction is intended for organizing branches in the flow of execution as
 
 This is an empty instruction: it takes no arguments and does nothing. The _**null**_ instruction is useful for generating code.
 
+

knowledge_knowledge/knowledge_tools.md

@@ -24,12 +24,11 @@ h/help                                    print this message
 q/quit/Ctrl-C                             exit
 ```
 
-
-
 ## Fluence Proto Distributor: FLDIST
 
 \`\`[`fldist`](https://github.com/fluencelabs/proto-distributor) is a command line interface \(CLI\) to Fluence peers allowing for the lifecycle  management of services and offers the fastest and most effective way to service deployment.
 
+
 ```text
 mbp16~(:|✔) % fldist --help
 Usage: fldist <cmd> [options]

knowledge_knowledge/node/knowledge_node_services.md

@@ -14,10 +14,12 @@ Each Fluence peer is equipped with a set of "built-in" services that can be call
 
 Please note that the [`fldist`](../knowledge_tools.md#fluence-proto-distributor-fldist) CLI tool, as well as the [JS SDK](../knowledge_tools.md#fluence-js-sdk), provide access to node-based services.
 
+
 ## API
 
 ### peer is\_connected
 
+
 Checks if there is a direct connection to the peer identified by a given PeerId
 
 * **Arguments**:
@@ -30,8 +32,6 @@ Example of a service call:
 (call node ("peer" "is_connected") ["123D..."] ok)
 ```
 
-### peer connect
-
 Initiates a connection to the specified peer
 
 * **Arguments**
@@ -89,6 +89,7 @@ Example of service call:
 
 ### peer timestamp\_ms
 
+
 Get Unix timestamp in milliseconds
 
 * **Arguments**: None
@@ -102,6 +103,7 @@ Example of service call:
 
 ### peer timestamp\_sec
 
+
 Get Unix timestamp in seconds
 
 * **Arguments**: None
@@ -365,6 +367,7 @@ Example of service call:
 
 Used in service aliasing. _\*\*_Stores the specified service provider \(provider\) in the internal storage of the node indicated in the service call and associates it with the given key \(key\). After executing add\_provider, the provider can be accessed via the get\_providers service using this key.
 
+
 * Arguments:
 
   * key – a string; usually, it is a human-readable service alias. 
@@ -391,6 +394,7 @@ Used in service aliasing to retrieve providers for a given key.
 * Returns: an array of objects of the following structure:
 
   ```javascript
+
   { 
       "peer": "123D...", // required field
       "service_id": "uuid-1234-..." // optional field
@@ -400,6 +404,7 @@ Used in service aliasing to retrieve providers for a given key.
 Example of service call:
 
 ```scheme
+
 (call node ("deprecated" "get_providers") [key] providers)
 ```