free MP3s recorded of codesimian:
fractalSound1.mp3
b.mp3
c.mp3
d.mp3
but its more fun to create your own...
DNA
is the simplest programming-language ever
|
DNA is software, specificly a programming-language specialized in building life.
It is software because it can be converted from molecules
to a huge number (base 4, 3 billion digits) and back to molecules with no data loss.
Each digit is 1 of 4 molecules.
It is not analog by itself (its digital), but its interaction with other molecules is analog.
It is a sequence of molecules and
there are only 4 types of molecules (each with their opposite molecule, but that does not add information),
therefore each molecule equals 2 bits of computer memory.
3 billion digits * 2 bits each = 750 megabytes. Your DNA could almost fit on 1 CD.
But if you compress your DNA into a ZIP file, it would fit on 1 CD.
Because DNA is software, it can be EXECUTED in any system based on LOGIC.
The laws of physics obey logic. Statistics is a kind of logic so even quantum uncertainty is logical.
When you execute DNA, it outputs a group of connected molecules, a Human.
To execute DNA, certain molecules must be around it.
A woman's body provides these molecules, but is not the only hardware that would work.
With better physics knowledge, a fast enough computer (much faster than what exists today)
could simulate the molecules of DNA as they grow into a Human,
then the physics simulation would become a Human simulation.
The software would be as smart as a Human.
But that is not practical. It wastes computer speed.
We dont need to simulate every molecule in a Human to get Human-level intelligence.
The software doesnt even have to think like a Human.
It just has to be at least that smart.
Computers have different strengths and weaknesses than Humans,
so the smartest software for them is different than a Human brain.
Smarter-than-Human software will evolve in its own way.
It will interact with Humans, but will think very differently,
but come to many of the same conclusions.
I'm not saying CodeSimian can do any of that,
but software 5 levels descended from CodeSimian maybe could,
or it could be built by anyone else. The hardware is there today to run the software if somebody built it...
CodeSimian is almost as simple as DNA.
CodeSimian is a language that has only 4 words: # name ( )
# means define name
name is some example of a name, like theIf in code: if#theIf(ask('repeat this question?') theIf)
( means start list
) means end list
The following code opens a window with a button that when clicked opens a window showing the code of the first window:
window#w(button(window(w)))
window, button, window, and w are names
# defines the name w (window was defined in file WindowCS.java)
( and ) define which things contain which other things
You might think that "STRING LITERALS" are not made of those 4 words, but they are:
print("STRING LITERALS") does the same thing as
print(list(83 84 82 73 78 71 32 76 73 84 69 82 65 76 83))
list and numbers are names of things.
Its just a list of numbers, each representing a letter, number,
and sometimes other symbols... the ascii code. Each number in the list represents 1 letter or other symbol.
Which numbers mean which symbols was chosen by computer-programmers many years ago.
How can I call name ONE thing when it is many names?
Because the text of the name doesnt matter.
You just type the same name in multiple places and you get the same object.
Its a way of connecting objects.
Code will evolve better than DNA...
Input code into param1 (second thing), output in param0 (first thing).
CodeSimian code for a compiler:
compilerPipeline#theCompiler(
0
0
tokenizeCode(
0
0
)
tokensToObjects(
0
0
)
parseObjects(
0
0
)
)
Lets compile some code. Execute the following code:
setP(
theCompiler
1
"compilerPipeline( 0 0 tokenizeCode(0 0) tokensToObjects(0 0) parseObjects(0 0) )"
)
then execute:
theCompiler
Input the code into itself, and it outputs a copy of itself. Code almost understands itself.
After everything executes (recursively)...
compilerPipeline#theCompiler(
compilerPipeline( 0 0 tokenizeCode(0 0) tokensToObjects(0 0) parseObjects(0 0) )
"compilerPipeline( 0 0 tokenizeCode(0 0) tokensToObjects(0 0) parseObjects(0 0) )"
tokenizeCode(
list(
"compilerPipeline" "(" "0" "0" "tokenizeCode" "(" "0" "0" ")"
"tokensToObjects" "(" "0" "0" ")" "parseObjects" "(" "0" "0" ")" ")"
)
"compilerPipeline( 0 0 tokenizeCode(0 0) tokensToObjects(0 0) parseObjects(0 0) )"
)
tokensToObjects(
list(
compilerPipeline LPAREN 0 0 tokenizeCode LPAREN 0 0 RPAREN
tokensToObjects LPAREN 0 0 RPAREN parseObjects LPAREN 0 0 RPAREN RPAREN
)
list(
"compilerPipeline" "(" "0" "0" "tokenizeCode" "(" "0" "0" ")"
"tokensToObjects" "(" "0" "0" ")" "parseObjects" "(" "0" "0" ")" ")"
)
)
parseObjects(
compilerPipeline( 0 0 tokenizeCode(0 0) tokensToObjects(0 0) parseObjects(0 0) )
list(
compilerPipeline LPAREN 0 0 tokenizeCode LPAREN 0 0 RPAREN
tokensToObjects LPAREN 0 0 RPAREN parseObjects LPAREN 0 0 RPAREN RPAREN
)
)
)
compilerPipeline, tokenizeCode, tokensToObjects, and parseObjects are all COMPILERS.
They convert one form of object to an other, using param0 and param1 as output and input.
compilerPipeline is a RECURSIVE COMPILER. It contains any number of compilers
that it executes in sequence, copying the output from the last to the input of the next...
The last compiler's output is copied to param0 of compilerPipeline, so compilerPipeline is a valid compiler.