We You Net: Soul Bots Anonymous

suj name text be section ya comment section .text end-comment
suj num 34 obj 1-it do copy ya comment mov ax,34 end-comment
suj 3-it obj 2-it do 4byte copy ya comment mov eax,ebx end-comment
suj name byte print be function ya comment byte_print: end-comment
suj name byte print do call ya comment call byte_print end-comment

really, that’s the gist of what I’m designing here.

yes human speakable programming language is part of it.
but it’s really more of a necessary prerequisite.
vast amounts of knowledge are available in human languages.

as well as math syntax programming simply isn’t an easy flowing activity
as talking or typing in a spoken language.

baby steps.

http://www.ariadne.ac.uk/issue7/search-engines/

can have bots that search for things related to your interests.

intersts can be derived from the meta-information gathered about the user,
or set interests for a specific project,
perhaps even based on recent words typed.

http://www.miller-mccune.com/health/total-recall-%E2%80%A6-or-at-least-the-gist-364

yes, interesting,

verbatim like source code memory,
gist like native code.

though it can also be pragmatics or implied statement.

instead of storing exactly what sentences user used,
can store what functions or arguments are common.
then can have a gist of what the user likes.

gonna pretend we’ve already written the compiler.
and write it using the language as it stands so far.

a hello world program first

do say quote hello world enquote

k for parser program

name parser be story ya

do remember suj name text talk ya
do remember suj name parser chapter
and suj name interpreter chapter ya
do remember suj full-name from english to machine do translate end-name ya

name main be chapter ya

define start ya
do interpret by the translate ya
suj start do server of the interpret for the talk ya
comment starts server,
running function (the) interpret,
using the text talk system ( standard console input output )
end-comment

suj a input obj name server be define of a function for a interface ya
if suj the suj phrase obj start do equal
then
sij name the input sentence do entity comment create process named the input sentence end comment
suj a sentence by the for do get to the of
enif

name interpret be define
comment input string output string end-comment

define start ya
comment suj is input, obj is output
suj do parse to a syntax tree ya
suj the syntax tree do translate

suj a text obj name parser be define comment suj is input of function obj is name of function

to make these functions.

10 syntax parsing
11 sensory memory (input – output, buffer, queues)
12 short-term memory (registers)
13 medium-term memory (ram)

^- basic machine code

14 heart-memories, anchor memories, goals, processes
15 code-memory, how-to, machine-code
16 data-memory, facts statements, strings
17 semantic-memory, symbol tables, translations

^- programming language

18 emotional memory ( meta-information,
hz requirements (many difficult, few easy),
mem requirements (many heavy, few lite),
safety, ( cracked scary, secure safe )
reliability ( error-halt prone annoying, creative (for unexpected inputs) interesting )
19 episodic memory (logs, was done)
1A prospective memory (to do)
1B numeric memory, statistics, (usage, users, processes, lengths)

^- process manager

1C area navigational memory, directory-structures, DNS, IP-regions, website navigation lists
1D light protocol memory terminal, ssh, vga, tcp/ip,
1E matter memory, formatting memory, screen, printers, html,
1F quality memory, who knows? something. constants,, like 0, and pi, as well as golden ratio

^- userland or network

for an AI to write itself,
a language that can write itself.

functions accepted as strings “do add”,
passed to interpreter.

can record an interpreter session and then print commands to file

accepting functions as arguments

for instance, can receive a string input, and convert it to function.

suj a string do translate to a function so name functionName

function is truly a functionAddress

or can have everything as a string, and run it through interpreter.

interpreter can be used to modify source, including it’s own, recompile and restart.
during night time can sleep/dream modify-source and test,
can have backups to insure safety.

running former interpreter simultaneously with current,
using hypervisor layer, can test hypervisor ontop of hypervisor as well.

simplicity, reliability

Projects should manage themselves.

People can write their own versions of functions.
These functions can be (potentially automatically) propagated to friends or net.

Once a function is received,
it is checked for safety
it is tested for compliance, (for same input, same output)
checked for leaks, (side effects not pertaining to output)
then it can be tested for performance,
if it exceeds a meta extreme (speed, size, simplicity, readability) for some function,
it can be saved as a default for that meta-extreme, (and can be used when that meta-extreme is activated)

This removes the overhead of spending homo-sapien time on sorting out what patches to accept to an application.
As each computer develops it’s own function repository based on it’s experience and knowledge of functions.

distributions, or “snapshots” can still be made, either from any given computer,
or a specially group maintained and certified signed version for a particular mono-culture.