Ingredients-oriented paradigm

The ingredients-oriented programming paradigm is an esoteric programming subparadigm oriented towards Information Security, being harder to hack, and based on cooking. The basic structure is to mix a set of ingredients in a vessel. Ingredients must be declared during the program (preferably at the start) and may only be used once. An example of Hello World in the paradigm is: stdout("Hello, World!")

Which effectively "Mixes" "Hello, World!" in the stdout vessel, which has the special property of sending its result product to the standard output.

Ingredients
The ingredient declaration syntax is: [keywords] ["[" "]"] = is optional by language. This declares a group of ingredients of size and type named, each item of the value. For example: byte b[256] = 100 Will declare 256 bytes of value 100. Whenever the "b" variable is referenced as an ingredient, one item is popped from the array and its value is used in the combinator. If b is referenced with a subscript after it (b[n]), then that many b's are popped from the array and used as arguments. This means that this: byte b[4] = 5 sum(b, b, b, b) is equivalent to: byte b[4] = 5 sum(b[4])

This feature may be excluded in some languages.

Keywords, also language-dependent features, are used to affect the way a variable works. Some example keywords are:
 * Unending: Don't use up variables when used (used for constants)

Mixing
In ingredients-oriented programming, actions are performed by Mixing ingredients in a vessel. The mixing syntax is: vessel(ingredient1, ingredient2...) For many vessels, ingredient order is irrelevant.

Vessels
Vessels are where ingredients are mixed. Vessels accept a list of arguments which's order may or may not matter and which may have special properties. Example vessels are:
 * mixer: Standard mixer
 * stdout: Prints its return value to the stdout
 * stderr: Ditto for the stderr
 * stdin: Automatically includes text from the stdin as an ingredient
 * (vessel class) port: Sends data to a port when flushed

Utensils
"Utensils" are the equivalent of first-class vessels in an ingredient language. They are similar to ingredients, except they aren't used up after usage in a declaration (and thus should not be used to store information). When mixed into a combinator, they are applied to all other non-utensil arguments, meaning this: vessel(ut, var1, var2) is equivalent to: vessel(ut(var1), ut(var2))

Exception Handling
Exception Handling should be powerful such as to avoid crashes. For example, at the beginning of a program, this line may be able to be added: This sets what value a vessel should output when an error is encountered during execution.
 * 1) onerror return

Hash an Input (with MD5)
import hash.md5 //Get the md5 utensil from the module stdout("Input to hash: ") //Print out "Input to hash: " stdout(mixer(md5, input)) // Hash the input by applying md5 utensil to input