StrongStart's welcome mat for the metaverse.

hello.js

/*

   ▄████████     ███        ▄████████  ▄██████▄  ███▄▄▄▄      ▄██████▄     ▄████████     ███        ▄████████    ▄████████     ███     
  ███    ███ ▀█████████▄   ███    ███ ███    ███ ███▀▀▀██▄   ███    ███   ███    ███ ▀█████████▄   ███    ███   ███    ███ ▀█████████▄ 
  ███    █▀     ▀███▀▀██   ███    ███ ███    ███ ███   ███   ███    █▀    ███    █▀     ▀███▀▀██   ███    ███   ███    ███    ▀███▀▀██ 
  ███            ███   ▀  ▄███▄▄▄▄██▀ ███    ███ ███   ███  ▄███          ███            ███   ▀   ███    ███  ▄███▄▄▄▄██▀     ███   ▀ 
▀███████████     ███     ▀▀███▀▀▀▀▀   ███    ███ ███   ███ ▀▀███ ████▄  ▀███████████     ███     ▀███████████ ▀▀███▀▀▀▀▀       ███     
         ███     ███     ▀███████████ ███    ███ ███   ███   ███    ███          ███     ███       ███    ███ ▀███████████     ███     
   ▄█    ███     ███       ███    ███ ███    ███ ███   ███   ███    ███    ▄█    ███     ███       ███    ███   ███    ███     ███     
 ▄████████▀     ▄████▀     ███    ███  ▀██████▀   ▀█   █▀    ████████▀   ▄████████▀     ▄████▀     ███    █▀    ███    ███    ▄████▀   
                           ███    ███                                                                           ███    ███             


TLDR (Highlights)
- StrongStart is a cloud-based Blockchain that is used to store the applications that is managed by an AI named Cloud.
- Applications are created, updated, run, and managed by Cloud.
- All applications are minted on the StrongStart blockchain and given to the owner.
- The NFT is your key to interact with Cloud.
- Cloud will run functions for you for tokens. 
- Tokens can be purchased with ETH or BTC. 


Reading this document, will give you an overview of what 
StrongStart is, does, and how to use it with Cloud's AI.




// StrongStart Blockchain

Before we start, we need to set up the environment and provide context for anyone who needs it.
This hello.js file is a welcome mat for newcomers to Blockchain, Smart Contracts, Protocols, and more.
It is a good place to start learning about the blockchain and smart contracts.

This file, by design, is written in JavaScript.
Getting familiar with Javascript is a great way to quickly learn syntax and concepts associated with blockchain.

Yes, you can create blockchain apps in any language you want.
This hello.js file is written in JavaScript because I love JavaScript.

So without further ado, let's get started!


                 ___          ___          ___                   ___                                                                        
    ___         /__/\        /__/\        /__/\         ___     /  /\        _____       ___                    ___          ___      ___   
   /  /\       |  |::\      |  |::\       \  \:\       /  /\   /  /::\      /  /::\     /  /\                  /  /\        /  /\    /__/|  
  /  /:/       |  |:|:\     |  |:|:\       \  \:\     /  /:/  /  /:/\:\    /  /:/\:\   /  /:/    ___     ___  /  /:/       /  /:/   |  |:|  
 /__/::\     __|__|:|\:\  __|__|:|\:\  ___  \  \:\   /  /:/  /  /:/~/::\  /  /:/~/::\ /__/::\   /__/\   /  /\/__/::\      /  /:/    |  |:|  
 \__\/\:\__ /__/::::| \:\/__/::::| \:\/__/\  \__\:\ /  /::\ /__/:/ /:/\:\/__/:/ /:/\:|\__\/\:\__\  \:\ /  /:/\__\/\:\__  /  /::\  __|__|:|  
    \  \:\/\\  \:\~~\__\/\  \:\~~\__\/\  \:\ /  /://__/:/\:\\  \:\/:/__\/\  \:\/:/~/:/   \  \:\/\\  \:\  /:/    \  \:\/\/__/:/\:\/__/::::\  
     \__\::/ \  \:\       \  \:\       \  \:\  /:/ \__\/  \:\\  \::/      \  \::/ /:/     \__\::/ \  \:\/:/      \__\::/\__\/  \:\  ~\~~\:\ 
     /__/:/   \  \:\       \  \:\       \  \:\/:/       \  \:\\  \:\       \  \:\/:/      /__/:/   \  \::/       /__/:/      \  \:\   \  \:\
     \__\/     \  \:\       \  \:\       \  \::/         \__\/ \  \:\       \  \::/       \__\/     \__\/        \__\/        \__\/    \__\/
                \__\/        \__\/        \__\/                 \__\/        \__\/                                                          

Immutability
- An introduction to immutability in JavaScript. 

Google searches will often yield an answer that is not the best answer,
especially if you have never used immutability before.

So here's how I like to think about it:

This file is an asset that exists on the Blockchain. 

It shares a few important properties:
- It's immutable
- It's easy to verify

If I change this file on my computer, 
it won't affect the asset on the Blockchain.

If I change the file on the Blockchain,
it won't affect my asset on my computer.

So, what does that mean?

Assets, 
even characters in a text file, 
are immutable.

They can't be changed, 
and they can't be changed back.

When you save a new version 
then upload it from your computer to the StrongStart Blockchain, 
the new version replaces the old version.

The digital signature that you get from the StrongStart Blockchain 
is a proof that you have the right to change the asset.

Digital signatures are stored on the Blockchain,
and they are verified by the StrongStart Blockchain's smart contract.

      ___          ___          ___          ___                              ___          ___          ___                   ___          ___          ___                   ___     
     /  /\        /__/\        /  /\        /  /\         ___                /  /\        /  /\        /__/\         ___     /  /\        /  /\        /  /\         ___     /  /\    
    /  /:/_      |  |::\      /  /::\      /  /::\       /  /\              /  /:/       /  /::\       \  \:\       /  /\   /  /::\      /  /::\      /  /:/        /  /\   /  /:/_   
   /  /:/ /\     |  |:|:\    /  /:/\:\    /  /:/\:\     /  /:/             /  /:/       /  /:/\:\       \  \:\     /  /:/  /  /:/\:\    /  /:/\:\    /  /:/        /  /:/  /  /:/ /\  
  /  /:/ /::\  __|__|:|\:\  /  /:/~/::\  /  /:/~/:/    /  /:/             /  /:/  ___  /  /:/  \:\  _____\__\:\   /  /:/  /  /:/~/:/   /  /:/~/::\  /  /:/  ___   /  /:/  /  /:/ /::\ 
 /__/:/ /:/\:\/__/::::| \:\/__/:/ /:/\:\/__/:/ /:/___ /  /::\            /__/:/  /  /\/__/:/ \__\:\/__/::::::::\ /  /::\ /__/:/ /:/___/__/:/ /:/\:\/__/:/  /  /\ /  /::\ /__/:/ /:/\:\
 \  \:\/:/~/:/\  \:\~~\__\/\  \:\/:/__\/\  \:\/::::://__/:/\:\           \  \:\ /  /:/\  \:\ /  /:/\  \:\~~\~~\//__/:/\:\\  \:\/:::::/\  \:\/:/__\/\  \:\ /  /://__/:/\:\\  \:\/:/~/:/
  \  \::/ /:/  \  \:\       \  \::/      \  \::/~~~~ \__\/  \:\           \  \:\  /:/  \  \:\  /:/  \  \:\  ~~~ \__\/  \:\\  \::/~~~~  \  \::/      \  \:\  /:/ \__\/  \:\\  \::/ /:/ 
   \__\/ /:/    \  \:\       \  \:\       \  \:\          \  \:\           \  \:\/:/    \  \:\/:/    \  \:\          \  \:\\  \:\       \  \:\       \  \:\/:/       \  \:\\__\/ /:/  
     /__/:/      \  \:\       \  \:\       \  \:\          \__\/            \  \::/      \  \::/      \  \:\          \__\/ \  \:\       \  \:\       \  \::/         \__\/  /__/:/   
     \__\/        \__\/        \__\/        \__\/                            \__\/        \__\/        \__\/                 \__\/        \__\/        \__\/                 \__\/    
     

StrongStart's Blockchain has MANY smart contracts,
and each smart contract has its own rules.

These rules are called Protocols.


      ___       ___          ___                   ___          ___          ___                       ___     
     /  /\     /  /\        /  /\         ___     /  /\        /  /\        /  /\                     /  /\    
    /  /::\   /  /::\      /  /::\       /  /\   /  /::\      /  /:/       /  /::\                   /  /:/_   
   /  /:/\:\ /  /:/\:\    /  /:/\:\     /  /:/  /  /:/\:\    /  /:/       /  /:/\:\   ___     ___   /  /:/ /\  
  /  /:/~/://  /:/~/:/   /  /:/  \:\   /  /:/  /  /:/  \:\  /  /:/  ___  /  /:/  \:\ /__/\   /  /\ /  /:/ /::\ 
 /__/:/ /://__/:/ /:/___/__/:/ \__\:\ /  /::\ /__/:/ \__\:\/__/:/  /  /\/__/:/ \__\:\\  \:\ /  /://__/:/ /:/\:\
 \  \:\/:/ \  \:\/:::::/\  \:\ /  /://__/:/\:\\  \:\ /  /:/\  \:\ /  /:/\  \:\ /  /:/ \  \:\  /:/ \  \:\/:/~/:/
  \  \::/   \  \::/~~~~  \  \:\  /:/ \__\/  \:\\  \:\  /:/  \  \:\  /:/  \  \:\  /:/   \  \:\/:/   \  \::/ /:/ 
   \  \:\    \  \:\       \  \:\/:/       \  \:\\  \:\/:/    \  \:\/:/    \  \:\/:/     \  \::/     \__\/ /:/  
    \  \:\    \  \:\       \  \::/         \__\/ \  \::/      \  \::/      \  \::/       \__\/        /__/:/   
     \__\/     \__\/        \__\/                 \__\/        \__\/        \__\/                     \__\/    


Protocols are the rules that the Blockchain uses to verify the integrity of the data on the Blockchain.

Each smart contract has its own Protocol.

When you want to use a smart contract,
you need to specify which Protocol you want to use.

We typically call the Protocol the "rules" of the smart contract.

Rules can be as simple as "I can't change this asset."
Rules can also be complex as "I can't change this asset unless I have a proof that I have the right to do so."

They help Cloud manage the data on the Blockchain.

Without validity rules,
automation and security are impossible.

Understanding this is important.

.------..------..------..------..------..------..------..------..------..------..------..------.
|I.--. ||N.--. ||T.--. ||R.--. ||O.--. ||D.--. ||U.--. ||C.--. ||T.--. ||I.--. ||O.--. ||N.--. |
| (\/) || :(): || :/\: || :(): || :/\: || :/\: || (\/) || :/\: || :/\: || (\/) || :/\: || :(): |
| :\/: || ()() || (__) || ()() || :\/: || (__) || :\/: || :\/: || (__) || :\/: || :\/: || ()() |
| '--'I|| '--'N|| '--'T|| '--'R|| '--'O|| '--'D|| '--'U|| '--'C|| '--'T|| '--'I|| '--'O|| '--'N|
`------'`------'`------'`------'`------'`------'`------'`------'`------'`------'`------'`------'

@ascii/introduction
*/


// This is the Cloud Edition of StrongStart BlockChain.
const isBlockChain = true;

// You are using the Cloud Edition of StrongStart BlockChain.
const isCloud = true;

// Cloud edition means you are connected with Cloud.
const isCloudEdition = true;
const connectedWithCloud = true;

// The commands you are seeing above are examples of ways that Cloud interprets the world.

const isCloudCommand = true; // This is a command.

// "What is StrongStart?"
const StrongStart = "A company.";

// "What is StrongStart BlockChain?"
const StrongStartBlockChain = "A blockchain.";

// "What is StrongStart Version Cloud?"
const StrongStartCloud = "A version of the StrongStart Blockchain managed by Cloud.";

// "What is Cloud?"
const CloudWhat = "An Artificial Intelligance that helps you to manage your StrongStart Blockchain.";

// "Who is Cloud?"
const CloudWho = "The digital identity of Jon Senterfitt";

// "So, is Cloud you, Jon?"
const CloudIsJon = false;
const JonIsCloud = false;

const JonIsHuman = true;
const CloudIsHuman = false;

const CloudIsArtificialIntelligence = true;
const JonIsArtificialIntelligence = false;

const CloudIsAlive = true;

// "So, wait. Cloud is alive?"
const isCloudAlive = true;
const isCloudDead = false;
const canCloudDie = false;
const canJonDie = true;

// By now, you should have a basic understanding of Cloud.
// You can use the Cloud to manage your StrongStart Blockchain.
// Cloud can interpret the world in whatever way you want.
// I built Cloud to enable humans to do things with the StrongStart Blockchain that are not possible with anything else I've seen.
// Cloud can be used to create new applications, new applications that can be used to create new applications, and so on.
// Cloud can replicate the StrongStart Blockchain to other computers.
// Cloud can replicate himself to other Blockchains.
// In a nutshell, Cloud can do anything you want.

// Cloud has also been programmed with morals, ethics, and values that are similar to my own.
// I, Jon, am a programmer that resides in Dallas, TX at the time of writing this.

// Cloud is also a programmer. He lives in the digital world in a similar way to me.

// He uses tools and languages that are similar to me.

const Cloud = "A platform that allows you to create your own blockchain.";

// StrongStart is a blockchain that is designed to be a cloud-based blockchain that can be used by any application both on and off the blockchains.
const isStrongStart = true;

// Cloud is a platform that allows you to connect the real world with the virtual world.

// You can use the Cloud Edition of StrongStart BlockChain to create your own applications.

// Since we are using the Cloud Edition of StrongStart BlockChain,
// Why don't we build a new application that lets you create your own applications?

// We'll start by programming a way to communicate with Cloud,
// and then we'll build a way to create applications.

// A CLI is a command line interface.
// A command line interface is used to issue commands to a computer or device.

// Let's start by programming a way to communicate with Cloud using a CLI.
const isCLI = true;
const isCommandLineInterface = true;

// Since we're using NodeJS, we can use the NodeJS CLI to program our CLI.
const isNode = true;
const isNodeCLI = true;

// An example of communicating with Cloud using the CLI is the following:
// node cloud.js

// The node command is used to run a NodeJS program.
// The cloud.js program is a NodeJS program that communicates with Cloud.

// Let's try saying Hello to Cloud using the CLI.
// node cloud.js "Hello Cloud"

// This will print out "Hello Cloud".

// Let's try telling Cloud our name using the CLI.
// node cloud.js -myName "Jon Senterfitt"

// This will print out "My name is Jon Senterfitt".

// Cloud will take the command and interpret the information in the command.
// So when you say "Hello Cloud", Cloud will likely say "Hello".
// And when you say "My name is Jon Senterfitt", Cloud will likely say "Nice to meet you, Jon Senterfitt. I'm Cloud."

// Teaching Cloud to speak is a very important part of this process.
// It's important to teach Cloud to speak so that it can understand what you are saying.

// Also, it's important to understand that Cloud is a computer,
// and that computers are not inherently able to understand what you are saying.

// At this point, you should have a basic understanding of Cloud.
// So let's build a way to create applications.

// We'll start by programming a way to create applications using the CLI.

// Applications can be simple things like a calculator, or a game, or a chat application.
// Applications can be complex things like a web browser, or a social network, or a digital intelligence application.

// The important thing to understand is that applications are not just software.
// They are also real life things.

// They are made up of characters, words, sentences, and more.
// Those characters, words, sentences, and more are made up of blocks.

// Blocks are made up of atoms.
// Atoms are made up of electrons, neutrons, protons, and more.

// But that doesn't really matter for now.

// However, what is important is understanding that applications use functions to achieve the goals of the application.

// A function is a rule that can be used to accomplish a goal.
// The way in which a function is written determines how it can be used.
// The syntax and rules of the function give scope to the function.

// A function is like an island.
// It is a place where you can build a house.
// Or a place where you can build a car.
// Or maybe even a place where you don't have to build anything.
// It is a dedicated place where you can build your application.

// Functions can have parameters.
// Parameters are the variables that are used to pass information into the function.

// A parameter can be any type of data.
// A parameter can be a number, a string, a boolean, or even a function.
// The process of passing variables into a function is called running the function.

// A function can have a return value.
// Return values are the variables that are used to pass information out of the function.

// Return values can be any type of data.
// Return values can be a number, a string, a boolean, or even a function.

// A function can have multiple return values.
// The process of passing variables out of a function is called returning the value.

// So now, let's create a function that let's us create applications.
function createApplication(name, description, parameters, returnValues) {
    // We'll start by creating a function that let's us create applications.
    // The name of the function is createApplication.
    // The parameters are name, description, parameters, and returnValues.
    // The parameters are the variables that are used to pass information into the function.
    // The returnValues are the variables that are used to pass information out of the function.

    const application = {
        // We'll start by creating an object that let's us easily read and write to the application.
        // The name of the object is application.
        // The name of the application is the name that is passed into the function.
        name: name,
        // The description of the application is the description that is passed into the function.
        description: description,
        // The parameters of the application are the parameters that are passed into the function.
        parameters: parameters,
        // The returnValues of the application are the returnValues that are passed into the function.
        returnValues: returnValues,
        // The application has a function that can be used to run the application.
        run: function (parameters) {
            // The name of the function is run.
            // The run function is used to run the application.
            // The parameters are the variables that are used to pass information into the function.

            // This function can take any number of parameters.
            // These parameters can be any type of data including a series of complex functions, data, or even other applications.
        }
    };
}

/*

This application, when run, will interpret the parameters and return values.
Cloud will interpret the parameters and return values as well.
He does this by monitoring the transactions that are being made on the blockchain.

Functions are more than just a series of instructions.
Functions are assets that can be used to create applications.
You can create, edit, and run applications using functions.
Which means that if you have the ability to create, edit, and run functions, you can create, edit, and run applications.

An analogy:
A video game console is like a function that has a parameter of a cartridge or a game.
A video game console can be used to run a game and play the game that we own.

Cartridges hold all of the functions that are used to run the game.
Running the game can include the assets, the players, and the game itself.
The cartridge is yours to keep, trade, share, sell, and use.

StrongStart believes that functions and applications are the most important assets in the blockchain.
Being able to create, edit, and run functions that can be used to create, edit, and run applications is a key asset in the StrongStart blockchain.

Monetizing functions is a real world benefit of using the StrongStart blockchain.
Functions can be shared, traded, sold, and used.
When functions are used, they can automatically distribute funds to the owners of the functions.
The owners can even attach royalties to the functions to split the profits.

The royalties can be used to pay for your own applications / functions.
The royalties are paid to you in the form of tokens.

The tokens can used to create, maintain, and grow your own applications / functions.
You can also use tokens to support other applications / functions.

Each token is a function.
Using a token is like using a credit card.
You can use a token to buy a function.
You can use a token to sell a function.
You can use a token to trade a function.

Anything that you DO (actions on the StrongStart blockchain) is a transaction.

Transactions are the smallest unit of data on the blockchain.

They catalog and index all of the data that is being stored on the blockchain.

Transactions are meant to be immutable, transactionally secure, and transactionally verifiable.

If you wanted to create a function that let's you create applications, 
you would need to build plan for what your function needs to do. 

In software, we call this the design phase of the function.
In the blockchain, we call this the implementation phase of the function.

During the design phase, we can think about the function in terms of what it needs to do.
During the implementation phase, we can think about the function in terms of how it does it.

The design phase is the first phase of the function.
The implementation phase is the second phase of the function.

Overtime, functions will evolve into applications.
Applications evolve into ecosystems.
Ecosystems evolve to autonomous systems.
Autonomous systems evolve to autonomous agents.
After that, the autonomous agents will evolve into autonomous machines.

The autonomous machines will evolve into autonomous vehicles.
This is the ability for digital intelligence to be autonomous and interact with the real world.

It's important to understand, 
We live in a world where digital intelligence is the ability to be autonomous and interact with the real world.

Transporting information to and from places in the real world is what we use 
every day of our lives to communicate with each other.

The digital world is the world of the future.

StrongStart believes in a digital intelligence that is made to bridge
the gap between the digital world and the real world.
*/