GENTUT02.TXT
General Tutorial for Lisa GJ2 Fic3
-- the f3 language explained as a series
of tiny essays
THIS IS ESSAY 02. WHEN IT GETS MORE THAN
99, WE'LL BRING IN LETTERS AND SUCH,
E.G. A1
Written by Aristo Tacoma with L.A.H.
Date: 2011:2:22
Copyright author, further distribution
license is www.yoga4d.org/cfdl.txt.
Kids: there are other tutorials for you.
But you should find pieces here and there
which are easy to read. In B9, use the
search function, CTR-F or F4 within each.
***MORE PHILOSOPHICAL INTRODUCTION: WARPS & ESSENCE NUMBERS
I have claimed that the warp-friendly Lisa GJ2 Fic3
language is the first one created with the understanding
of the proper relationship of the infinity of informal
language to the finiteness of 32-bit whole numbers.
Indeed, I have said that it has come as a necessity when
I first worked out the understanding -- which is also
called essence numbers -- that infinity is something
which cannot be understood properly by applying 'etc' to
arithmetic operations we do with finite numbers. This
necessity explains ALL its peculiarities, or resonant
features. Indeed, there cannot be any other language
which answers more fully to my infinity theorem. So it
is necessary, and it is also sufficient, a complete and
adequate and in that sense final answer, the only
possible answer, in terms of what a formal language can
be when the essence number understanding is full and
ripe.
Not a thousand books would be adequate to justify in
enterial boolean logic terms the above statements from
the simple premises which leads to the existence of easy
arithmetic. Instead, I submit what I said above --
insofar as you have the vocabulary to make sense of it
(consult earlier booklets and such from my hand) -- to
your own neopopperian intuitive synchronistic judgement.
Nevertheless, in this tiny essay, I will give some
what we can call metaphorical or poetic reasons how the
particular key feature of Lisa GJ2 Fic3, or f3, namely
warps, is wrapped up with this understanding of
infinity. In fact, the claim I've made is that a
language has to be warp-friendly once one has understood
the work on infinity relative to finite numbers that I
did. I wonder whether you have ever pondered over this
particular feature of FIC3.TXT:
(LET TEXT>MATRIX (( => & >N1 LENGTH => >N2 )) BE
((
(( N2
(COUNT
N1 => CHN => N1 ; N3 ; # => PM
COUNTUP) ))
(( 0 ; N2 INC ; N3 ; # => PM ))
(( RM ; && ))
)) OK)
}* ..and further on in the code: }*
(( }N1} => ? ; }TEXT>MATRIX} => ? ; 88 ADD => POKE ))
To make sense of it all, start up F3 and type
:TEXT>MATRIX UNCOMPUTER
You will there see how everything is made of warps, and,
as we know, each of the most native words are written in
machine code, doing 32-bit finite work in clear-cut
boolean and arithmetic ways. The UNCOMPUTER function
(see my early writings on this in MYWEBOOK.TXT)
discloses that the function TEXT>MATRIX contains 28
32-bit numbers. You see them mapped out, and this
includes some data as well.
So, by a bit of study in F3DOCS.TXT, you can work out
that what happens in the FIC3.TXT code, further on in
the document where the POKE line above is found, is that
a certain 32-bit number -- a warp inside the TEXT>MATRIX
-- is given a new value. In particular, the N3 in the
second line before the OK) )) line is corrected to N1.
The reason why this correction of the code was done
this way was to reinforce the standard -- just how the
coe is compiled, and how it can be changed after it is
compiled. There is no hocus-pocus about these warps:
they are part of the standard definition of the language
as such, and they work their magic smoothly, and all the
time as needed, always.
Now, in f3, in short, EVERYTHING is warps. No part of
any function, no function call, is other than a warp;
even data is, in a legitimate sense, a kind of warp.
These warps are finite 32-bit whole numbers.
This is fundamentally different than having a language
where that which is called functions, or such, is an
entity which exists in a self-enclosed type of
quasi-world, whether or not these are (as in e.g. Java,
or other so-called object-oriented languages), have a
bridge to data by means of the imposed, enforced,
artificial concept of classes of objects.
To see this, consider this metaphor: how you view the
stars in heaven at night. If you view them with the
understanding that there is a finite number of them all
in all -- it is part of the supermodel theory, as
applied to astronomy, to regard it that there is a
finite number of stars, with continual creation and
continual expansion, with a continual destruction at the
peripheries -- and that this finite, manifest part of
the universe is excessively much greater than that which
can be appreciated by any type of telescope.
To view the stars you can see with your naked eye with
this appreciation is a different experience altogether
than trying to view them with a notion of there being an
infinite number of them, and past history has had many
examples of thinkers postulating the latter view.
In this metaphor, the functions (whether or not
defined inside some kind of class concept, with all its
mechanical hierarchical structure) are as the stars.
There being a finite number of them corresponds to the
notion of 32-bit-ness. By the function UNCOMPUTER, and
by the follow-up of PEEK and POKE, you can prove it as
much as you like to yourself that functions are made up
of 32-bit numbers, or warps, and this fundamentally
alters your perception of what a function is. In
contrast, while e.g. a language like the one which
underlies much of Linux, called by the letter c, allows
the creation of an array of function pointers which can
be called, and such, it is only by complicated
syntactical maneuvers which are not garanteed to work
across implementations of the language that these
function pointers can be seen for what they truly are,
namely just a bunch of finite numbers. Instead, one gets
the feeling -- and this is typical in all dominant
programming languages prior to f3, even in Forth as it
eventually was defined through ANSI-standard committees
and such -- that one better lay off trying to look at
just what pointers are, and one should certainly not act
on the assumption that they are such and such numbers.
The the level of meaning, therefore, -- and meaning is
what counts when we speak of differences between formal
languages -- a formal language can only be said to be
warp-friendly if it has within its core definition
evidence that the warp-friendliness is grounded in
32-bit numbers, in a wholly easy and commonplace way,
that allows standards in how programming is being done
with them, which are EXACTLY IDENTICAL to how all other
number data is handled, seamlessly and elegantly and
with superb ease.
Also, with everything being warps, phrases such as the
POKE line above, can without change being put inside a
function. One can also call a function with the word
HYPERCONNECT or its synonym H, and find its warp by the
word WARPADDRESS or its synonym ?. However, note that
technically, while each warp is 32-bit, and while the
arrangements of warps within each function is as stable
as can be, the exact positioning within the RAM of the
computer in terms of the 32-bit address space thus
allotted, can naturally vary each time a program is
started up, due to allowancies of various background
programs which possibly require sometimes more,
sometimes less data areas for themselves. Still, it is
within the 32-bit well-definedness (and as I have shown
elsewhere, 32-bit is psychologically meaningful in terms
of number of digits, and programming must be
psychologically meaningful to be first-hand, which is,
in fact, also something which is rather derived from the
infinity theorem).