Update to include ffi-support

Signed-off-by: Michael Lodder <redmike7@gmail.com>

Author: mikelodder7

text/language-bindings/README.md

@@ -27,7 +27,8 @@ callable libraries. This RFC covers how Ursa will enable its code to be
 consumable by other languages.
 
 When exporting to other languages there are two types of wrappers that
-can be created: thin and idiomatic. Example code written
+can be created: thin and idiomatic. Thin wrappers are just language bindings and shall be called
+bindings. Example code written
 in Rust below will be used to illustrate the difference.
 
 ```rust
@@ -43,7 +44,7 @@ impl Ed25519 {
 }
 ```
 
-The purpose of the wrapper is to expose `sign` and `verify`. A thin wrapper
+The purpose of the wrapper is to expose `sign` and `verify`. Bindings
 will be the simplest method like so:
 
 ```c
@@ -56,7 +57,7 @@ int ursa_bls_verify(const unsigned char *const message, const unsigned long long
                     const unsigned char *const signature, const unsigned long long signature_length);
 ```
 
-The C code now exposes those two functions so C# can use them as a thin wrapper
+The C code now exposes those two functions so C# can use them via the binding
 
 ```csharp
 using System;
@@ -79,11 +80,11 @@ namespace Hyperledger.Ursa.Api
 }
 ```
 
-Thin wrappers are not desirable by end users because it requires more knowledge
+Using bindings are not desirable by end users because it requires more knowledge
 about the native library than they perhaps want to know. It also does not allow
-language developers to use what they are most familiar with. However, thin wrappers
+language developers to use what they are most familiar with. However, bindings
 are required because they handle marshaling between the two languages. Idiomatic wrappers
-are written to hide the nastiness of the thin wrapper and allow language developers to
+are written to hide the nastiness of the bindings and allow language developers to
 stick to what they like and are familiar with. Continuing the example above, an idiomatic
 wrapper can be written like this
 
@@ -137,19 +138,26 @@ namespace Bls
 
 The idiomatic wrapper provides more logic and parameters for convenience than the thin wrapper does.
 It can also be expanded to include other types but ultimately maps all inputs to
-the expected thin wrapper types.
+the expected binding types.
 
-Thin wrappers are composed of many functions using the [foreign function interface (FFI)](https://doc.rust-lang.org/nomicon/ffi.html).
+Bindings are composed of many functions using the [foreign function interface (FFI)](https://doc.rust-lang.org/nomicon/ffi.html).
 
 # Reference-level explanation
 [reference-level-explanation]: #reference-level-explanation
 
-Thin wrappers can be problematic to write by hand and maintain as APIs change.
-It is desirable to have thin wrappers generated programmatically.
+Bindings can be problematic to write by hand and maintain as APIs change.
+It is desirable to have bindings generated programmatically.
 Rust supports generating FFI using `bindgen`. `bindgen` can map to other languages like
-C and WASM. Thus thin wrappers should be created and maintained as much as possible using features like `bindgen`.
-Thin wrappers should be included in the Ursa project itself in a folder called `wrappers`. This will allow them to
-stay in-sync with any other changes to the core library.
+C and WASM. Thus bindings should be created and maintained as much as possible using features like `bindgen`.
+Bindings should be included in the Ursa project itself in a folder called `wrappers`. This will allow them to
+stay in-sync with any other changes to the core library. Rust also offers the [ffi-support](https://crates.io/crates/ffi-support) crate. The crate exposes
+Rust objects in three ways:
+
+- Serialization methods like proto or flat buffers or JSON.
+- HandleMaps that return handle Id's to callers
+- Converts between raw Rust native types to C native types.
+
+Bindings should use the best appropriate option for the given language. For example, WASM must use serialization but Python could use any of them.
 
 Idiomatic wrappers usually cannot be generated by hand as they require more in depth language experience
 than automatic generators can produce. Therefore, idiomatic wrappers should be written by project contributors
@@ -160,9 +168,9 @@ Here are general guidelines for producing wrappers:
 
 `<language>` should follow the naming convention as described [here](https://support.codebasehq.com/articles/tips-tricks/syntax-highlighting-in-markdown)
 
-- Thin wrappers
+- Bindings
     - Produced by code
-    - Output into the `libursa/wrappers/<language>/folder`
+    - Output into the `libursa/bindings/<language>/folder`
 - Idiomatic wrappers
     - Written by developers
     - Implemented as best deemed by contributors/community
@@ -180,7 +188,7 @@ Here are general guidelines for producing wrappers:
 [drawbacks]: #drawbacks
 
 - Some developers may want all ursa code written in the language of their needs to avoid issues presented by FFI.
-- Some languages cannot generate thin wrappers yet using `bindgen`.
+- Some languages cannot generate bindings yet using `bindgen`.
 
 # Prior art
 [prior-art]: #prior-art