More doc updates

Author: mikera

Diff for: docs/cad/029_fungible/README.md

@@ -11,13 +11,13 @@ Typical use cases for fungible tokens might include:
 - Quantities of some resource in a game or metaverse
 - Reputation points
 
-Note: This CAD represents the Convex replacement for ERC20 / ERC777 on Ethereum
+This CAD represents the Convex replacement for ERC20 / ERC777 on Ethereum
 
 ## Specification
 
 ### CAD19 Compliance
 
-A fungible token MUST meet all the specifications for a compatible CAD19 asset, in addition to the requirements specified here.
+A fungible token MUST meet all the specifications for a compatible CAD19 asset, as well as the mandatory requirements specified in this CAD.
 
 ### Balances
 

Diff for: docs/overview/use-cases.md

@@ -6,6 +6,16 @@ tags: [convex, ecosystem, applications]
 
 Convex is a general purpose, programmable decentralised network with global state. As such, there is no inherent limit on the nature of applications that can be built. Here are some of the things that Convex can be used for, and are being actively developed within the Convex community:
 
+## Tokensiation
+
+Convex offers a uniquely powerful system for the development of tokenised assets and applications. Tokens in Convex usually support the [CAD029](cad/029_fungible/README.md) token standard, which offers multiple advantages over the common ERC20 standard.
+
+Tokens can be used for:
+- Payments in the form of stablecoins, flatcoins, nationcoins or other digital curreny types
+- Utility tokens for delivery of decentralised services
+- Reward schemes and bonus programmes
+- Governance of decentralised economic systems, e.g. with stake-weighted voting
+
 ## NFTs
 
 Non-fungible tokens (NFTs) are a powerful mechanism for creating unique virtual items that can be owned, collected traded and utilised in virtual environments such as games. Each NFT has a unique on-chain ID and can be individually addressed, transferred and used within smart contracts.

Diff for: docs/tutorial/convex-lisp/lisp-guide.md

@@ -6,35 +6,39 @@ authors: [mikera, helins]
 tags: [convex, developer, lisp]
 ---
 
-This guide is intended for developers interested in learning about Convex Lisp. We will take you through the basics of the language, all the way through to designing and deploying a simple smart contract!
+This guide is for developers interested in learning the basics of Convex Lisp. We will take you through the basics of the language, all the way through to designing and deploying a simple smart contract!
 
+<!--
 ## Setup
 
 Using the [Sandbox](/sandbox) is the easiest way to experience Convex Lisp. We recommend that you try it out as you go through this guide: It's more fun to get instant feedback and try out new ideas quickly! To do this:
 
 - Open the Sandbox (you can create a free, anonymous temporary account with one just one click!)
 - Type example code from this guide into the Sandbox input window as you progress
 - You will see outputs from Convex in the output window. we use `=>` to indicate expected outputs in the examples below.
+-->
 
 ## Lisp basics
 
-Lisp is all about expressions. All code in Lisp is ultimately an expression that can be evaluated to get a resulting value (or maybe an error, if something went wrong...). So let's take a quick tour through the most common types of expressions, and the values that they produce.
-
-### Literals
-
-The simplest type of expression is a constant literal data value, which evaluates directly to itself!
+A Lisp code is contructed out of expressions, which can be evaluated to get a resulting value (or maybe an error, if something went wrong...). The classic Lisp expression is a list enclosed in parentheses `(...)` where the first element of the list is the function to be called and the following elemenst are the arguments. So to add two numbers with the `+` function you would do something like:
 
 ```clojure
-1
+(+ 2 3)
+=> 5
 ```
 
-If you type the number `1` in the Sandbox and execute it, the result is the number one itself:
+So let's take a quick tour through the most common types of expressions, and the values that they produce.
+
+### Literals
+
+The simplest type of expression is a constant literal data value, which evaluates directly to itself! If you type the number `1` in the REPL and execute it, the result is simply the number `1` itself:
 
 ```clojure
+1
 => 1
 ```
 
-Convex can handle double precision floating point numbers as well:
+Convex can handle double precision floating point numbers, which work the same way:
 
 ```clojure
 1.5
@@ -83,7 +87,7 @@ nil
 => nil
 ```
 
-Addresses (which refer to Accounts) can be expressed as a literal starting with `#`. Address literals need not refer to an account that actually exists.
+Addresses (which refer to accounts) can be expressed as a literal starting with `#`. Address literals need not refer to an account that actually exists.
 
 ```clojure
 #12345