g15 pmn programming

Background. The desire, which in part makes sense, to construct computer-driven robots that take over heavy, dangerous and/or boring tasks from human beings, has led to a number of programming approaches that involve a mimicking of some features of human pattern recognition and human learning and human task solving. It is however clear that a number of studies in the philosophy of logic, in the wake of such as Kurt Goedel’s famous Second Incompleteness theorem, and in the philosophy of mind, physics and biology, there are fundamental properties given to mind not given to machines (not even the machines made in the wake of the most advanced form of quantum theory): we will not give a resume of these here, but only point out that for any one of deep interest, there is enough material of this nature for many  months, at least, of whole-time study (including much from this writer). Put simply, the project of enabling robots to have some human-like features cannot be subsummarized under such an over-the-limit concept as “Artificial Intelligence”, or “AI”. Rather, AI is a slogan that is more proper for advertisement companies than for serious thinkers: it is a hyped, hubris-rich concept with little serious scientific credibility of any sort, unless the notion of ‘intelligence’ is made small and mediocre--and this is not the approach of the philosopher nor of the serious scientist. But, then, what is the better concept? We can speak of ‘robotics’, but that is a somewhat more hardware-oriented word. What is the proper software content of an advanced robot? We propose here, in attunement with the proposals in the Firth platform from 2006--where also “first-hand” is used in connection to programming--and consistent with other proposals later on, where we also speak of FCM--to call the field of software in advanced robots as explorations of FIRST-HAND COMPUTERISED MENTALITY, with acronym “FCM”. A brief explanation follows. In an educational unit {indeed, the next one}, we are exploring how FCM can be initiated using the G15 PMN programming language, with the particular high-powered PMN Terminal summarising all the advanced functions in the G15 platform that as app is called “Second Foundation” PMN, also called the ‘Quattro-powered PMN Terminal’.

  The notion of first-hand means that the human minds of the programmer and programmers are engaged in a relationship, first-hand and not behind a ‘statistical screen’, with the data and algorithms involved in each program. This is necessarily a question of degree: total understanding of every bit of every algorithm at all times is unrealistic, and unnecessary. But to understand every bit in principle, and all key parts in praxis--at least by looking into the code and its comments--is realistic, when the programming language as a whole is keyed to the human mind and is well-defined enough within a meaningful digital context.

  When we speak of FCM, or First-Hand Computerised Mentality, we are investing a first-hand program with features that, although entirely algorithmic, digital, and bound to meaningful numbers of well-known sizes (in G15 PMN, the approach is to embrace 32-bit as the paradigm of all good programming because of the vast possibilities contained within this still-meaningfully sized number range--in contrast to the absurdly long numbers of higher bits such as 64, 128, 256 or 512),--it also has features that are inspired by some abstract features of the living mind. But these are implemented in a way that is responsibly limited: the mentality of the programmer and programmers is involved in avoiding any projection of an image of ‘intelligence’ as such, for ‘general intelligence’, or just ‘intelligence’, is a feature involving a living perceptual capacity connected to questions of infiniteness, and not what we can meaningfully and scientifically include in any machine-performable digital program, no matter of what kind. The mentality of the programmers is also involved in that the program is seen as an expression of this mentality--rather as a great literary work is an expression of the mentality of the novelist. The human beings who interact with a robot containing the FCM, or with the FCM steering software-units of a vaguely robotic kind on a normal PC, do meet a bit of the mentality of the programmers as encapsulated in context-specific robotic programs. This includes also limits of use of the FCM, and, for suitably advanced forms of FCM, it includes also ethical priorities in the FCM.

  A FCM program will stay within the boundaries of a context-specific enough set of algorithms. These algorithms will in general involve some data-set, often organised, probably, as a matrix. The FCM doesn’t automatically change these data-sets uncontrollably. Rather, an FCM program can be put in a well-controlled ‘learning mode’. The words used by the FCM program about itself are moderate--for instance, any psychological word like “learning” should be put in quotes, and, where possible, more technical-sounding words should be used instead. For instance, ‘entraining’ a matrix is a better word than ‘training’; and ‘pattern matching’ is a better word for a program than ‘pattern recognition’. Also, the word ‘action’ sounds like something done by living being whereas the word ‘task’ is more neutral--and so on. This, then, shows awareness in the constructors of the FCM program and this awareness expresses itself through the FCM program by the virtue of modesty. It is part of this modesty that the FCM program is clear about what contexts it is made for. FCM isn’t made for all contexts. It is bound up to some contexts, and these must be well-defined enough. Where there are ethical priorities involved--for instance, an FCM robot soldering an electronics circuit in a lab where also human beings are around must have (as the scifi writer Isaac Asimov pointed out) a first priority or law in not harming human beings--these priorities cannot be ‘unlearned’. The data input to a matrix being entrained must concern a limited area of its functionality. It is part of this necessary modesty of a good FCM program in an advanced robot that these robots are not set up to produce new FCM programs or robots: for that could undo the priorities and make them do things outside of the human-decided proper ethical context.

  In order for the FCM program to have well-functioning fixed priorities the starting-point of the setup of the program and its matrixes must have features of simplicity and first-hand obviousness, at least to advanced programmers. The part of the FCM that involves data that has been entrained by ‘entrainment sessions’ must not touch the core priorities built into the FCM. Also, such sessions should be turned off; the data are then checked; if they are good, they are put to use--and only a very moderate degree of further data input happens when the FCM program or robot is in actual use. Obviously, some data input is necessary in the day-to-day performance of an FCM robot, and this may well take place by analogy to the entrainment phase. But the entrainment phase goes deeper, and has human beings who are giving indications as to how correct or incorrect an action is as the FCM robot, perhaps via some Relatively Free Fluctuation Generators (RFFG), is engaged in tentative task-patterns. These indications inform the matrix, and is part of how the mentality of the programmer becomes part of the whole setup of the FCM program.

  When the entrainment has taken place, the human beings overseeing the FCM program or robot must check the entrained data sets in a variety of contexts. The entrainment mode is switched off, and the FCM is then put to practical use,--but it must then have additional possibilities of being regulated when it makes mistakes, as it will, since any environment can have unexpected features relative to an entrained context-dependent set of inputs. It is part of the ethical constraints of robot building that a robot should look like a robot, not like a living being; that it has several easy-to-access buttons to switch off actions that may be inappropriate, and that it has numerous software elements in it all oriented towards turning itself off when there are any signals in the environment that things aren’t as laid out in the original scheme for it; and that programmers are regularly overseeing it.

  Put simply, FCM is the approach of applying good common sense and the quality of good sound reasoning so as to make the best of computer technology when it is expanded with motors and sensors, without engaging the slightest in any hubris as to what it is all about. And let us be clear that while many tasks in dangerous (eg toxic) contexts can with advantage be done by robots, as well as tasks requiring extreme precision (eg making of tiny semiconductor devices) or extreme repetitiousness (eg making of some parts of cars), it is part of the honoring of human beings as beyond all machines that we do not overzealously try and apply this all over the place. Thus, for instance, we do not ALWAYS want coffee or tea exclusively served by machines, but also quite often by a nice human being who gets paid for doing that job. Robots are meant to make things easier for humanity--the word ‘robot’, indeed, derives from a Czech word related to ‘slave-work’--and we do not want to see a situation in which the majority of pleasant, valuable, good jobs are handed over to algorithm-driven machines. We programmers must curtail over-enthusiasm as to the application of our algorithms. The human mind, here as in all other contexts, must be put first.

"Here's a lot of cash for you--no strings attached!"   That's one sense of 'string'. As a programmer, you are aware of another sense--the sense of an array, typically of letters or characters, including possibly digits. When you add two strings,--even if they contain numbers--you expect the previous strings to be incorporated into the new one--unlike digit additions, which clearly involves transformation of the digits according to the rules of arithmetics. So these things we'll look into here, in the light of G15 PMN running on a psychologically pleasingly constructed PC, fully capable of dealing with 32-bit numbers in formidable masses. We'll touch on a more powerful way of acting on a condition than SE, which in PMN is called 'D2' (which can be read, 'in the Denial of the aforesaid, do the next 2 things', but which also has other capabilities).   And we'll have a brief but concise look at what would happen if we imagined that the G15 PMN formalism made sense if they computer had infinite capacity.   As a computer programmer, you have an influence on society that, to some extent, may be greater than the influence of many other people. Your own value decisions do matter. Your simple statement, 'That's easy to make', or the denial of it, may affect societal developments, when said in certain circumstances.   In that sense, every course in programming ought to have doses of suitably fitting elements of philosophy, including ethics.   And a key theme in ethics is this: the experience of freedom of your fellow beings is part of what makes human living worth the while; so, before you do something that affects society, look into the freedom aspect.  If you enjoy freedom in front of a personal computer, then consider that this is part of the manifold experience of freedom that is, in a sense, a universal human right, when it makes societal sense to some extent. But so often we have seen that computers can become instruments of authorities to exercise control,--too much control. And part of their control mechanism is called 'digital money'.   "No strings attached!" That's the virtue of having cash, cash that is your own cash, cash that's in your pocket, cash for which you can buy without triggering databases all over the place with a rather permanent record of your every movement. Cash is part of the fun of small-business-friendly capitalism and market economy, which is something we can see as distinct from big-business capitalism.   Cash means to have the elegance, playfulness, and joy in doing things without all the time showing up a name and an id for it. This is part of a humane society: privacy. It is part of what makes a city alive. It cannot be replaced by digital money. Digital money--money that exists by virtue of digital computation--can supplement it but all legal, responsible citizens want to be able to do things in complete freedom from surveillance. A limited James Bond-like surveillance we can accept on the basis of vital, intelligent need in each case: but the ground of the flowering in goodness for a society requires the pulse of existence without the constant measurement of each individual. According to the Heisenberg Principle, or what Niels Bohr called 'Indeterminacy', even electrons and photos resist measurement.   While we're on the theme of ethics: influential people with high status in society and in history do make deep mistakes in their thought processes sometimes. Bertrand Russell, with Alfred North Whitehead--people of intensely high status in philosophical circles in early 20th century--seemed to hope to make a complete mechanical system of thought around logic and numbers, in their PrincipiaMathematica. They had put in measures to prevent a feature called 'self-reference'. But only a few years later, Kurt Goedel was able to show that their system is either not complete, as they had hoped, or, worse, it had inner contradictions (in which its capacity to judge anything becomes zeroed out with inconistencies in every case).   However, what happened here may not have been sorted out correctly by the intelligentia of the prestigous universities and their encyclopedias and professors and much-quoted authors. As a programmer, you must look into what makes sense in terms of it being a clear idea. If the idea is confused, say so: but if it is clear to you, and in contradiction to what is hyped up as a truth in society--then that is what you say. You will get enough chances to check ideas about finite structures on the computers, against your own perceptions. You can build on that self-confidence to sometimes take careful leaps into infinity. But few have applied the right care here, as I see it: the scholar, eminent logician, and dutchman, Mr L E J Brouwer was one who called for more care when it comes to handlings of infinity in mathematics than the mainstream. Like L de Broglie in quantum theory, who went against the mainstream interpretation both early and also in the last decades of his life, Brouwer went against the mainstream attitudes on infinity in logic and called for a wholly rebuilt mathematics. If you read our example here, you may get a clear idea why this is necessary.   To get back to the question of working with personal computers--sometimes, it's like having lots of extra cash, isn't it?   Having a programming language, a computer with lots of free RAM, and some speed to it, combined with spare time for yourself--that's a sense of having a degree of limitlessness to yourself, at least if you have come to the point of mastering that programming language. Let us also add that this experience is stronger when you are used to thinking of, and using at least some of the computers you are using in the sense of 'a dialogue with yourself', rather than merely a sort of node in a perhaps vast network of nodes, of computers. For the experience of clarity, tranquility, and sense-making in our process of programming is perhaps never as strong as when we have perfect stability in the medium in which we are expressing some clear ideas.   So, a computer that is lined up to a network can be said to be in the 'online' mode. When a computer is independent from the network, your own experience of your physical surroundings is to a degree emphasized rather than de-emphasized by some decent work on the computer. The word I prefer to use for this mode of computer work is "realline" (and so I totally prefer to avoid the word 'offline', for it is a word implying a deficiency, whereas an independent, stable computer is indeed an abundance).   We'll next have a look on strings, what we in G15 PMN often call 'quotes'--whether they are short, long, or--as in a thought experiment we'll carry out--indefinitely long, in the sense of arrays. Since G15 PMN is leisurely using large 32-bit numbers in each and every position of even text arrays, we have a relaxed distinction between strings (or quotes) on the one hand, and arrays on the other. And this relaxation is actively pursued further by de-emphasizing distinctions between arrays and matrices--and so forth.   Now, in G15 Yoga6dorg assembly language--the language underlaying PMN, and which you can call on to make really fast-performing extra predefined two-letter words by following the scheme that G15 PMN invites you to follow in creating such little additions--there are quotes where there is no size of the quote as the first element of it. But if you in PMN write

  &Hello world!&   PP

then you will have created this little string or quote, the 'Hello world!', quite automatically, simply by typing it in like this, so that its size, 12, is in the first position of the array. So, in array position #0, there is the number 12. In array position #1, there is the number for the letter 'H', which in ASCII code is 72. Then follows the lowercase 'e', which has a different ASCII code, and so on, up until '!', with ASCII code 33; and after all that, just to be sure, there's the code zero, the socalled 'nilchar'. In that way, a routine like PP has two ways of working out how long the quote is--either by looking at its beginning, or by working through it until it encounters a zero (also called the 'basis' character in our vocabulary, and in the same vocabulary, for philosophical reasons, we sometimes call the number 1 of the ASCII or 32-bit type for the 'dance' character).   So a socalled "PMN quote" has these two features. There is a routine called SETLENANDNIL -- set length and nil -- that modifies a longer string into a shorter one simply by modifying the first number and inserting a nilchar, a zero, after its new length. This is part of the High-Powered PMN Terminal.   It is part of the Terminal, part of, in other words, the set of PMN words that you typically would have as the beginning of any program of some size you write yourself in G15 PMN, that you create a quote out of a number on the stack. It is called MAKENUMBER. So, for instance, you can get the PC to display '1234' in two ways:

  1234   NN

That's one way. To print out the number that's on the stack, onto the screen. The other way is to convert it into a PMN quote, and then print it out as a text:

  1234  MAKENUMBER  PP

At the stack instead is the address of the text.  To go the other way again, back to number on the stack, CN is Convert-to-Number.  When we want to have a long quote, going over several of the very slender and elegant PMN columns in our cards, then instead of writing such as &Hello world!& we write e.g.:

  LONGTXT*  Textline 1  Textline 2  Textline 3  *TXTCOMPLETE

To store the location of this text to a variable we can then write eg:

  SAMPLETXT1=  ^.

This makes a new variable called SAMPLETXT1. We then pick the pointer (the warp) to the longquote off the stack:

 SAMPLETXT1  KL

And then we can later on use such a routine as BX to show a whole long line in beautiful B9FONT by using LK on this variable. Note that there's a useful routine called CLIPTRAIL that clips away the extra blanks that tend to come with these quotes due to the relaxed syntax they have--they don't have a single character to fix the end of the quote, and in that way, anything can be quoted with ease, but rather a lineshift and this whole word *TXTCOMPLETE has to be used. But then there may be blanks you don't want in it. CLIPTRAIL handles that. Just look into the code of these long words as part of the Hipow stuff at D:23091 and up in the standard G15 platform and they document itself. Or you can use the Hipow to search for the definition of such a word by ^E99 followed by CC.   Note that such a text quote can go over many cards if you like--but the more common approach is to do it in chunks that fits the linewidth of such as the BX or RP character displaying routines. If you quickly need to display a menutext to yourself as a programmer while working in hipow, store it via B9EDIT to some cards and write e.g. ^K1 and MORE to show it. There are also really simple ways of outputting and inputting texts both from keyboard and from the cards, line by line, using robotfont associated with this MORE routine (ie, defined near it, in the PMN High-Powered Terminal: e.g. the calendar program are using these, and also the XCalc extended calculator on the utility menu).   Since you are such a high-powered programmer yourself that you read this stuff in this chapter, why don't you begin to work--as a routine--with the extra-high powered terminal that is the first part of the Calendar program? This has a number of sleek additions. The first part of the PMN-part of it is exactly the same as in the High-powered Terminal, so it still applies. But from E:21381 and onwards it has still more! It is however important for pedagogical purposes to divide up and not give all these things at once to the beginner,--so we have elementary PMN to be learned first, then the hipow, then, as you copy the calendar and, in the final column of it, you insert your own intro-text.   This is easy. For instance, if you copy the whole of e.g. 2000 cards from E20000 to L1, then you go into card L:1612 and put in eg &Extra hipow!& and PP there, in the right-hand column of that card. You simply blank out the reference to the calendar-program there, and the ZZ on that page, so that it starts straight at PMN instead of launching the program. Also, at L:1 you write 12 for disk# (instead of 5 for E, it is 12 for L), and 1102 as the new starting-card (now that it has been moved from E20000 to L1). Easy to do when you get used to going back and forth in the G15 platform with CTR-C copy and CTR-T to put in cards, CTR-L to open a card and CTR-S to save after edit. When you use e.g. G14 or H1 as a pad for your own often-started programs and often-opened cards, you bookmark each interesting card--like L:1102--by typing it with a colon. To start the L:1 program, type L%1 with the symbol G15 uses instead of percentage sign, and click on the colons and that flower-like symbol in the menu mode. The menu mode is activated by CTR-W and the edit mode by Right-Click on the mouse, and these two are used all the time, so you get them into your fingers.   It is part of the underlaying philosophy of G15 PMN to honor fairly known boundaries, or ranges, instead of trying to pretend that we have 'handled infinity' and instead of making every boundary so fluctuating that the whole platform becomes a bubble instead of something stable one can learn about and grow with.   The extra high-powered terminal contains the same PD set as the GEM image editor--a small addition to the set of PD in the high-powered terminal. At L:1102, then, when copied to the start of the L-disk, is the start of the PMN part, the ordinary high-powered PMN. At L:1382 this is extended with a variety of useful extra-routines. These connect both to numbers and text, both display and disk, and they are fairly well commented and examples of use for some of them are within the calendar program. And, as said, at L:1612 even the Extra High-Powered PMN Terminal has no more to define. It, too, is complete. So 1612 is a key number to remember. This is the stuff out of which a very huge number of applications of all sorts can be made within this context. You are of course entirely free to make all sorts of G15 PMN apps with this as beginning--just state that it is so, and get on with your own program, and if you can sell it, by all means sell it. The language is free; a language must be.    So, defined at E:21423, but at L:1424 if you copy the EXTRA hipow to the L-disk, we see ADDTEXTS:it makes use of a somewhat more general routine defined in the hipow to put one text beside one another and back into the quote.   So, if we do AD on 1234 and 1234 we get 2468. If we do the following -- 'string addition' -- we get 12341234:

  10  SZ  &1234&  S1

This stores the string 1234 to local variable I1 and the string has extra capacity, its max size is set to be 10.

  &1234&  S2

This stores 1234 as another string to local variable I2. (Remember, by the way, that SZ is to be used outside of functions. So the above will work if you type it in. If you need extra size capacity for a quote, put the SZ and the quote outside of a function, then store it to a variable with KL as we did above with the longquote.) (Also remember that although we for clarity and ease of reading we write uppercase for code in our explanations here, when you type in these programs, using Robotfont either directly into a PMN Terminal or on cards, you use lowercase for all function names). Here, we use the extra high-powered PMN terminal, which is the first part of the calendar program.   By it, let's add the strings:

  I1  I2  ADDTEXTS  I1  PP

This shows 12341234. Note that S1 and I1 and T1 and J1 and such do work outside of function definitions, even though they are called 'local variables'. This is so that it should be easy to check things without having to define a function to do so.   Let us also bring in a more advanced decision-making function--if that's the phrase I want--than 'SE'. The predefined, or PD, word 'SE' can be used e.g. to quit a loop by a keyboard touch doing something like this:

  DOINGIT=  LL:10000  SHOWIT  CK  SE  EX  1  S1  LO.

So this routine DOINGIT, as we define it, will run some kind of routine we have, supposedly, just made, called SHOWIT, and it'll keep on doing it--more than a thousand times, because the number 1 and the next line S1 puts 1 into the counter each time. But when Check Keyboard shows a touch on it, then the SE will SEe this and do the next line, which is 'EX'--in other words, exit the function. (The CK, by the way, is a standard part of the expanded core of the High-Powered PMN Terminal. These are explained mainly through examples of use, e.g. in B9edit, GEM and so on, but you can also look at the program comments and the code for it. A comment about CK is at d:23053, some dozens of cards before the PMN part of Hipow begins at d:23091. Other PDs are also commented here. Then, a more elaborate comment, sometimes, is in the code itself, which is further dozens of cards earlier.)  But what if we wanted an extra action? Then D2 is an instrument--and it very often happens that we do need such extra actions. D2 is then fed the opposite of SE: D2 can be read as 'do the next 2 lines in Denial of this'. Here:

  DOINGMORE=  LL:10000  SHOWIT  CK  N?  D2  FAREWELL  EX  1  S1  LO.

The routine FAREWALL you must make yourself. If in doubt whether a routine exists or not already as part of the High-Powered or the Extra High-Powered PMN Terminal, just start up the Terminal and type in the function name. A question-mark indicates it doesn't exist. If the computer goes up in smoke, the function does exist, but you gave it the wrong parameters ;)  Note that the N? which, when used just before D2, reads as a unit: N? switches 1 to 0 and 0 to 1, and so D2 with this becomes just as SE only that two lines are to be done, instead of just one.   But there are still more variations here. D2 can get an input that is beyond the 'yes'=1 or 'no'=0. What it then does is to jump twice the quantity of lines given, in the direction given: an input like 3 means jump six lines ahead. The word DE is related, it doesn't do twice, but otherwise is similar. So if you want to have a lot of keyboard handling--a certain action for each key pressed, and then exit--D2 may be what you want to use in this way. As this chapter is being typed into the B9edit editor, stuff like SE and D2 are deciding over the consequences after each keyclick.   Now what we'll look into next is, for those used to large programs, deceptively simple. But because the underlaying assumptions shift here--from the finite to the infinite--it must be understood that it is also enormously more complex than the most complicated program imaginable on any digital computer. So formidable is the complexity of thinking about infinity that I always find it appropriate, when talking even a little bit about it, to remind people interested in it to do it only a little bit at a time--and then do many other things, and think about other, and more finite things, before doing a next session with this type of stuff. For infinities are so hard to think about straight that they may do wierd things to a mind if it's done too much at a time--and it isn't worth it. Forgive me also if I cut short the discussion after showing a point instead of dwelling on it--after all, there are plenty of other texts from my hands dealing with this, which are quite available.   Imagine a structure, then, as an experiment in thought:   1. infinite capacity in RAM etc. Every type of infinity associated with this structure we symbolize by "...", three dots, and this ...  can be stored where we normally store 32-bit numbers   2. infinite speed is part of it   3. coherent idea of G15 PMN formalism somehow still applies  Have you imagined it? Good! Next, in this imaginary case, where "..." can be used instead of a number to mean "infinity", let us make use of our understanding of arrays to make an array called GENERATED. This has, as some types of PMN arrays have, the quantity of elements in it in the first position. (That is to say, the first element in it is #1 rather than #0, for #0 is set aside for quantity of elements.)   We make it, in our imaginary structure, in this way:

  GENERATED=  ^.  ...  SZ  GENERATED  KL

The size, that is, is set to be the "..." new type of quantity. This is an infinite array--whatever that means. Further, we are going to fill it up like this:

  GENERATE=  LL:...  I1  GENERATED  LK  KL  I1  F  GENERATED  LK  YA  LO.

SIMPLE BEGINNINGS OF THE ROBOT WARPER PROGRAM

This is the beginnings of a program: here we just set up some essential routines and check that we get a line and a triangle drawn, matrix-like, on the screen. The output is shown in the included screencopy.

  So, we are going to develop, step by step, a gradually larger and larger program, really well commented, and in edible doses. This program will enable us to have perhaps a bit of fun, if we're lucky, with a very symbolic, simple concept of some kind of robot-like equipment moving about in a kind of flatland seem from above. The beauty of the simplicity of this set-up is that we can explore the PRINCIPLES of software robotics engineering--to use a very fancy word. But I wish to say it, for simplicity is often a key to come to new insights, when it is the right type of simplicity.

  If you've looked around in our educational texts, you have perhaps recently read something about matrices. How to set big matrices up. And armed with that knowledge, as well as with a bit of experience with other sorts of bits of the G15 PMN programming language, such as adjusting variable values, and finding the warp of a function, as we call it, by the FF function,--then this will be easy ride.

  It will especially be an easy ride if you have read about, in the previous educational unit in this series, just what it takes to get going with expanding a simple included program in the G15 PMN platform, such as the Triangles program, which is at the first utility menu--easily reached by clicking around at the ':' colons at the Homepage, the G15 card, that G15 PMN greets you with, as soon as you've typed in the word CAR in the beginning.

  For we are here going to expand the Triangle program. So, when you copy a lot of cards around, back and forth, you use how to get going with card-editing really quickly. To make space for a card when you need it, between two other cards, for instance, you just copy a whole lot of bunch of them to the right. So, in the Edit mode, you press CTR-C to copy, type a more than big enough number (presuming you have nothing important stored in cards just above the present area you are using of a disk), press PgDn to go to next card, and CTR-T to put it in, followed by a SPACE-click to confirm (or ESC to not do a putting or pasting after all).

  So in the previous educational unit in this series, you got it going with the Triangle program all the way to the beginning of the disk i. And so the first card you see here is i:1479,--the screencopy is done while it's in the Edit mode. As you know, you switch between the Edit mode and the Menu mode by CTR-W and Right-Click on the mouse.

  So the first card just have some comments about what this program is going to be.

  Be sure, by the way, that the two phrases &TRIANGLES& and ZZ from the card just before it (you can use PgUp) are removed. We don't want the Triangles program to start up, we want our own program to start up, and it'll call on whatever it likes from the Triangles subroutines or functions or subprograms, in whatever way it likes.

  And to start this new program, you have modified card i:1. It also has a place for date, a place for author, and a place for name and for type of the program. When, at some time, you do modify such fields when they are, as now, at the start of a G15 assembly program, please put in hyphens (_) or some sign like that between the words and digits, and retain the completing plus (+) that indicates that this is just an inessential 'extra', a comment, not essential for the computer.

  What you modify i:1 to is, as we said in the previous educational unit, that the disk# is 9 for i, and the card number for the start of PMN code is 1092. If you like, you can browse back and forth around in these pages just to get to see how truly open source the G15 PMN language and compiler is, and how it all builds up gradually: and is compiled Just in Time, JIT, each time you run a program. (We use the word 'compilation' although it is only the first part that is compiled to G15 machine code, while the second part is converted to a quick format easily performed BY the G15 machine code: but it is not uncommon to call both of these 'compilations'; in addition, G15 may be run virtually on top of something, in which case there is a further level of performance before the actual electronics is touched.)

  By the way: in order to learn a language it is a great good practise to type stuff in, and let your fingers learn to know it, and get to know to see it on the screen as you type it in--and if you type something that has to be corrected, there's additional memorizing advantages of that, too! Of course it is also fun to get, wholesale, full open source programs like the finished Robot Warper program in as an app, but to learn, we need to look at some parts at a time, and take time to think and reflect and ponder and try out things.

  The ROBOTW program, as we also call it, first defines a matrx called SKETCH. This is set up to be exactly the same size as the type of matrix-like set of pixels that the Triangles program operates with. It means visible pixels, and while it admits to quite a lot of complexity, it will also be simple to relate to, and the routines will be fast--we can allow ourselves to go through every pixel as often as we like, without having to use G15 assembly code to do it--we can use ordinary PMN loops like LL:nnn .. LO to go through these matrices. And these are 144 in width and 100 in height and represented on the screen as you see in the output--with a black-green type of outline of square in each position, inside of which we 'paint' bright-green or moderate-toned green where we like.

  The SKETCH matrix is where we draw. But when we move a robot, we want to check whether it bumps into something--another robot, for instance. We don't want the substance of our robots to mysteriously 'overlap'. So at some point, we need to have a detector for such 'touching'. We don't have to make it just as yet: but we must think through how to do this before we program too much.

  And so we make SKETCH as the place where the Triangles routines draw. And when we have drawn all we want, and done all the detection we want, we put the SKETCH to the screen. For this, we have a routine called APPROVESKETCH.

  However, we may also want to try out things, and go back a step, and try something else: for instance, if one robot gets too close another, or an item, then we want the original sketch back. So we need a SKETCHEXTRA. This is what we have on the next card.

  We then see--at what is here numbered i:1482--that FRESHSKETCH calls on CLRTHISMANY. It is a filling up with nilchars, or zeroes,--which in our visible matrix corresponds to black. The tones are numbered 0..255, where 255 is bright green.

  One of the huge advantages of having a language that isn't insisting on just one interpretation of a data structure like a matrix, is that we can use routines made for other data structures, like an array, on them--as long as we pay attention to what we do, when we do such little 'tricks'. In i:1483, we use the array-copy routine FW, which we can think of 'create a ForWard copy of this data here, to here, and this many of it'. Note that we write 14500 as quantity, for 144x100 is within this range; and this range is again within the 15000 we defined the arrays as in the first place. Such vaste of 50 32-bit numbers here and 50 32-bit numbers there was a thing unheard of in the 1960s and for a long while. Fortunately, to program today is a luxury experience, when we combine elementary good hardcore programming in a 32-bit oriented language, with an early 21st century computer speed, a RAM size going into many millions of such numbers, and more such. To engage in very much higher speeds or very much higher capacities may be necessary for certain extremely statistical-like tasks, but it is more humane and psychologically benefitting to match the computer's capacity with the ways and modes and speeds and attention spans of the human beings in charge of these computers. And computers are just machines, not minds, they have no real intelligence although they may be cunningly programmed: and so we must never set computers to program themselves except within extremely well-defined boundaries, and never set computers to make new computers, and the same applies for robots.

  Talking about the limitations of machines, let us also mention something about the limitations of simplicity: why simplicity can be overdone.

  For instance, there is such a thing as Goedel's incompleteness work, as we talk about in the G15 PMN App section, in an essay there, and other places as well.

  Imagine that you made a formalism, somehow, in which the entire work of Goedel, that led Alan Turing to say that it seems to show that intuition is necessary in the understanding of anything, was 'expressable', if that's the word I want, by a statement this short:

 "Proof of Goedel's 2nd incompl.theorem in our Ultra-mangificent-super-simple language:  We write    singularity(gform)=f  and the machine produces    t  So this single line is a full representation and deduction and proof of Goedel's theorem."

  I hope you agree that this is nonsense: the whole point of such a theorem is that it is perceived to be a clear idea in thought. We have no use for such a formalism. Nor should we be impressed by a language that can do virtual robots in 3d by a single line, or do an over-complicated (and computationally ineffective routine for nearly sorted lists) such as 'quicksort' by one or two or three program lines.

  So simplicity can be a trap, we shouldn't pursue it at all costs. Larry Wall used to say that Perl is a mess because its data domain is a mess. Well, that's going a bit too far--the language doesn't exactly have to be 'a mess' in order to map a complicated data zone, but a language is supposed to stretch out so it meets thought. Human thought. Your mind! But it certainly should make sense. You don't write a novel, or even a short story, in just one line. A musical composition isn't finished in one nanosecond. Etc.

  Companies, and simple-minded and perhaps not altogether well-educated researchers, may line up together and speak bold words about 'Artificial Intelligence'. They do so, because they haven't spent careful time thinking through the issues. There can only be algorithms, and rules for how to make rules, that apply WITHIN a context. The whole notion of speaking about 'hyper-intelligent machines' can only come from irreflectivity. By this it doesn't mean that a noticable proportion of the population cannot be fooled, just as one can sell homebrew alcohol bottled as a twelve-year old classical Whiskey. But it is not scientific to speak of Artificial Intelligence, except so as to negate it.

  Let's walk back to the program. We were at i:1483. It has COPYSKETCH and GETSKETCH. These two allows to 'backup' and 'restore' the SKETCH. The SKETCHEXTRA can handle a matrix of the size of SKETCH. It exists for that purpose.

  In i:1484, we do something that fitted just in one card, and these lines are best read together: and so we skipped having comments inserted here. Instead, the explanation is here.

  First, we define a function PXTOSKETCH, short for 'put a new pixel of such and such tone to this place X and Y in our SKETCH.'

  You notice that it says S3 then S2 then S1. This is a storing of the three values, X, Y and tone.

  Why write S3 then S2 then S1? That is because it is easy to do so, as a convention,--to write such storage statements in the reverse sequence, as we pick numbers off the stack. On top of the stack, as the function starts, is tone. Right? And this goes into S3. Then Y goes into S2. Then X goes into S1. In other words, I1, I2, I3 will have X, Y and tone--in THAT sequence. So it is a psychologically convenient mechanism to preserve the feeling of the sequence of stuff put into a function, into a little program like PXTOSKETCH.

  Then, the predefined (PD) word YY is used to put something to the sketch. I3 is given first, that is the value. Then I1 and I2, these are the X and Y coordinates for the SKETCH. Then the word SKETCH, and LK to get the hook to the matrix itself out of that variable. Finally YY is called and there that big dot (.).

  Now, we want to override the earlier situation, where the Triangles-routines were writing straight to the screen. Fortunately, there is a variable called NORMALMATRF--short for 'holder for a warp to the NORMAL MATRField function', holder for a warp to the normal function to write to the screen. It is called MATRFIELD--all this we don't have to know, this is just a feature of the Triangle program. So by looking into the code of this program, this variable turns out to be defined there. And NORMALISEMATR makes use of this variable in just the right way.

  So by this little hocus-pocus we have, by warps--let's make note again of how useful these little things are--connected our brand new definition of a sketch to PREVIOUSLY defined functions. Because these functions were well written (we were lucky with them), we don't have to copy these functions and modify them under a new name or anything. We just have to plug the new stuff into the slots.

  Then, let's go to next card. There things are spelled out more leisurely.

  APPROVESKETCH is what we call when we want to put the finished SKETCH to the screen for all to see. So we can call various drawing routines, and it'll all get stored to SKETCH. Then we call APPROVESKETCH, and it calls repeatedly--in fact one hundred times 144 times--on MATRFIELD1. That's the original pixel-draw function made by the Triangels program. It is defined very early in that series of cards. It wants X, then Y, then tone as input--exactly the same sequence as the little function we made on the previous card.

  Let us note that at i:1485, we have LL:100 and LL:144 and we have LO and yet another LO. So this is what in all programming languages is called a 'nested loop', ie, a loop that is peacefully at home within another, socalled 'outer' loop.

  When we make any use of LL:nnn .. LO, then I1 automatically get a counter value from 1..nnn. We can also use M1, that is the same value but one less, so it starts at zero, and goes only up to nnn minus 1.

  When we have one or a couple of LL's inside one another, then the values get to I2 and some more.

  When doing any loop, it matters to take an extra deep breath and look at it. The same goes for call to a function that loops through a lot--like the FW mentioned earlier, that copies an array from somewhere to somewhere else. A slight issue with such a loop can expand into a bigger issues, because of the repetitions. So it matters that it is right.

  When dealing with X and Y stuff, it is often convenient to loop the Y in the other, for then the inmost loop will deal with the first row, the first line, with the starting-value for Y, where X varies.

  So the height is Y, and height of our matrix is here 100. The width, X, is 144. So the inmost loop is 144. This is I2. So I2 is given first, then I1. X, then Y. Alphabetical.

  Then we fetch the tone from SKETCH by using WW, which is the converse of YY. What we put into a matrix by YY we get out by WW. So I2 I1 SKETCH LK WW is one conceptual unit, we might say: it produces the tone at X=I2 and Y=I1. It doesn't matter that in other routines, X may be I1 and Y may be I2, for I1 and I2 and J1 and J2 (set by T1 and T2 instead of S1 and S2), and such, up to 9 and even X (as IX and SX), are all what we call 'local' variables. These are, in a sense, 'forgotten' as the computer exits that function, each time.

  Well, there isn't much left, we're soon ready to test these routines by drawing a line and also a triangle by them.

  First, after looking again into how the little Triangles program was made, it turned out that it would be nice to make a more compact way of creating a triangle by just one function call. This is then done in i:1486, by NEWTRIANGLE. It receives no less than six coordinates--three times the {X,Y} for each point in the triangle on the matrix in the {1..144, 1..100} range. Then SHAPETRIANGLE is the real magical core and crux of the Triangles program. When we call it it will use our new SKETCH-drawing routine, due to the work we did a couple of cards ago.

  At the next card, i:1487, the INITSCREEN just produces a heading, RP uses ROBOTFONT to Print on screen, on top right; the word NEWMATRIX readies some variables used in Triangles, and also call VW which in some implementations of G15 is required in order to show the mouse pointer. But NEWMATRIX, defined rather late in the Triangles program, sets the area to bright green. We want it dark-dark-green, and so we have copied the numbers in that routine and written them again there, with a new tone. A G15 PC should be so fast that it is hardly noticable that the screen is done over twice.

  Finally, ROBOTW is the main program. What we see at i:1488 is that this ROBOTW advices that this is just a very early, preliminary form of what we are going to make. Many more functions indeed will be defined before ROBOTW does its full job.

  Anyway, at i:1489 there is a call to our new NEWTRIANGLE and also a call to a function inside the Triangles program, namely SHAPELINES. Both of them are supposed to now draw to the sketch, rather than to the screen directly. Sometimes, in programming, one speaks of this as drawing to a 'buffer'. In some cases, one can draw to a buffer, then to another from this, and THEN to the screen, in order to provide programs that flicker less in their graphical output. However, flickering may be a good thing for those programmers who are doing hardcore programming and who are making program that stimulate the mind instead of putting them to sleep by overly much gliding motions at all points!

  The NEWTRIANGLE has tone first, while SHAPELINES has tone last. It is convenient to allow variations like this. For instance, the NEWTRIANGLE wants to do something with all the six coordinate values first--and only after that, deal with tone. But we need to look at each function definition when we write a program unless we're clearly certain about the sequence. There is no 'canonical' sequence.

  Note that SHAPELINES has the feature that it calculates slopes, and can do lines between points that aren't lined up horisontally or vertically. In terms of the matrix, we will then see a staircase-like progress of lines that aren't aligned with the X nor the Y-axis. So SHAPELINES provides additional graphical functionality beyond the typically predefined, PD words for graphical output does, in terms of the High-Powered PMN Terminal. And the Triangle-drawing stuff builds on this type of stuff.

  It is a key principle, a construction principle, we might say, of G15 PMN that nothing in the platform has been clipped from a book or another programming language and recoded here: rather, all is written simply by thinking through what is required in each case. That also means that you get first-hand programs, you get readable programs, programs that make sense if you only spend time with them, when you know something of G15 and G15 PMN as such.

  Finally, at card i:1490, it says APPROVESKETCH. If you type in lines manually without typing in APPROVESKETCH, the triangle and the line won't show. Also, if you type in the program but put a comment | bar in front of the word (or at the A, so it becomes |PPROVESKETCH), then the line and the triangle won't show either. So this is a way to check that we've been doing fruitful thinking.

  It waits until you press a key,--it reads it by the more advanced Keyboard Input routine that the High-Powered PMN Terminal provides (and this hi-pow terminal is part of the Triangles program, also). The SH shucks this key.

  And then it says &ROBOTW& and ZZ to indicate that this is the new startup. Note that if you have a finished program, that you also have tested really well, it is normal to put QU into the program at its last line. In that way, it will quit back to the CAR menu that it started from. Instead, here we get a chance to try things manually, check the stack if we like (type F then NN and it should show 123456), and then manually type QU. This while the graphics is showing.

  It is good, isn't it, that in G15 PMN there is always the sense of text ruling over the graphics: you type CAR, before it starts; then it starts in EDIT mode, fully willing to accept changes; as you do anything graphical in G15 PMN, you do it by typed in statements, or text on cards that you start; and then, having got the graphics up, you can type in still more, in the interactive mode of the language. In this way, you can learn to correct programs much much faster than in most other programming languages I know of: the fact that texts, SIMPLE texts (and not cluttered long lines with lots of commas, semicolons, colons, and such all put together in a particular sequence) rule over the computer and its graphics.

When we work with arrays of numbers, we are working with something that fits eminently well with how the RAM, the memory of the PC, is laid out--series after series of numbers. A text document, for instance, is typically stored inside the editor in an array. But then, we could structure it so that we store it in some other way: for instance, line by line, as an array of lines, --which is to say, as a matrix. A matrix has both row and columns. That’s the simple, rather intuitive idea we employ in programming. When we speak of a ‘2D’ matrix, in contrast to such as a ‘4D’ matrix, we speak of how many coordinates--row and column are two coordinates--that are required to identify a single element in the matrix. So, in a 4D matrix, we need to specify four numbers. Albert Einstein, inspired by his russian math teacher Minkowsky, fancied working with X, Y and Z in space, and T as well (or t), for time. Other physicists have challenged this simplistic way of dealing with time, considering that the whole picture is more entwined and complicated--e.g. David Bohm, with his Implicate Order idea.

  In terms of programming, a lot of attempts to make computers and their outputs in various forms get the label ‘3D’. However, a 2D matrix is often a far more useful concept than any such thing as a 3D simulation. For with each added coordinate, the amount of RAM required increases exponentially. That also means that the consumption of electricity, silicon--and money--increases exponentially, and it also looses touch with the underlaying simplicity that we want in good programming. The art of stimulating to thinking requires that we avoid fancy, glossy additions that are mere tacky things to attract the masses, and rather go for elementary features of that which really work, and does so with a respect for the importance of being somewhat conservative in how many algorithms we have to employ, and how much RAM also, and what speed of the CPU.

  In addition, a 2D matrix is as radically different from an array as a triangle is from a line: for by a 2D matrix, you can express spatial relationships, just as a triangle spans a space in 2D that can be filled, and related to, and which can express symbolic relationships. So by a 2D matrix concept, you can in some sense conquer all the dimensions--for instance, by having each node in a 2D matrix potentially linking to another 2D matrix. Still, a 2D matrix can technically be seen as merely a way of relating to an array. And indeed, this is how we typically do it in G15 PMN.o, the first thing to know about, in order to make a real good matrix--for instance to represent pixels or squares on the screen, out of which we can build symbolic representations of robots in a game-like environment (as we do elsewhere in this presentation)--we need to know how to make a sizable array, a big array. If you recall, really small arrays we can make like this:

miniarray=

&1234567&.

This we can put values into by YA and get values out of by AY. An array requires just one ‘coordinate’--the number of the position. For instance, if we make a calendar, we can store the dates of the month for the next seven days in such a little array. Each of the seven position can admit to numbers up to about 2 billion, which is the 32-bit range. Also signed 2 billion. The 32-bit range is psychologically pleasant to work with for the programmer. They are easy to think with, especially when they don’t have much more than some or six or seven digits. Psychologically, many studies have shown that the attention span, in some sense, is “seven plus minus 2 things”. These “things” can be more abstract, like groups, with training. In the 32-bit range, numbers can easily go up to 9 digits. When we program in G15 PMN, it may make sense to put cards e.g. at such ranges as allow numbers to be fairly small, say, using disk i or so, at cards from 1 up to some thousands--and these pleasant numbers convey something to you as you work with them. They are not just numbers, but they also have inherent pictures, ideas, features--including the peculiarity of prime numbers--where such as 23 is a prime number, but 22 and 24 are composed of smaller prime numbers. Prime numbers are arrythmic, we might say: for they aren’t speedily produced by any simple route procedure, at least if we speak in terms of practicalities, when they get really big: the biggest computers wouldn’t get through to more than so and so many prime numbers even if they worked on making a list for a hundred years.

Now a larger array we can make in some more steps. First we give it the name. Then we make use of the SZ predefined (PD) word in G15 PMN. This allows us to say: the next quote that we make will have the SiZe capacity as specified--which can go into the millions, if we like. Then we make the quote. This is, for empty quotes, simply done by the statement &&. Finally, we put the pointer, the warp to the quote, into the name we made. This we do by repeating the name and using the KL function. (Remember KL is to put stuff into variables, and LK is to LooK them up.) Let us call this ‘bigbig’:

bigbig=

^.

1000100

sz

&&

bigbig

kl

So, you see, ‘bigbig’ has now lots of stuff. A million and a hundred more. We have this array and we can do what we like with it, fill it up with numbers and get them out again, doing varying things--for instance, GEM Image Editor in G15 PMN Homecard has an extra PD that copies a portion of the screen to such an array, pixel by pixel. It uses this to pick up some stuff that may have been drawn to the screen eg by the use of a mouse-reading and pixel-drawing routine in a menu option in GEM.

But we can now put some structure to bigbig. We can call on some of the routines that are part of the High-Powered PMN Terminal, and which are rather universal: they are part of almost every program of some size in G15 PMN, including the Triangles program in the first utility menu. This Triangles program expands drawing lines into drawing filled triangles. It uses the screen so as to suggest a matrix-like appearance. It is also one of the more ‘commented’ programs--it has eductional comments inside it. So, if you like, you can copy the Triangles program and expand it, if you anticipate you may want to use some of its routines. It is, after all, a relatively short extension of the G15 PMN Terminal. To copy it, you could go to its start position, as shown on the utility menu, and then copy the whole lot--which includes the PMN compilation part first. It is much less than 2000 cards. So you could simply do CTR-C and type in 2000 there, and press ENTER, and go to such as i:1 and paste it in by CTR-T followed by SPACE (if you don’t have anything unsaved in that area of the i disk). Before you start the program from i:1 by having a line somewhere--perhaps you work from the card just before the Homecard G15, namely G14--and here you could point to the program by the i%1 type of statement (the % is shown more like an arrow, a flower, or a hand, in G15 PMN, though)--before all this you have got to specify the beginning of the PMN part in card i:1. For some, this will be the first time they do anything with G15 ‘pure’ assembly code. The Triangles program begins at disk e (or E), fifth in the alphabet, whereas disk i (or I) is ninth in the alphabet. So to the left of “disk#” you would modify 5 to 9 in this first card in the program. Also, it wants to know where the G15 code stops and where the G15 PMN program begins. It says 4591, in the case of Triangles. If you look at the numbers, when we move the program from 3500 to 1, it means that 1092 is the new start. So to the left of “progcard” you would write 1092. Then save it! By ctr-s, to i1. And you can now work with the program. If you wish to build on the Triangles program but have a different startup, the first thing you would do is to remove the phrase

&triangles&

zz

which is found at i:1478. Then you add new stuff to i:1479 and so on, and provide new information, a new ‘ZZ’, which specifies the name of your own program. This is what we will do when we make a simple robot warper program, to play with symbolic ideas of simple robots by means of warps, because the drawing routines, inside the Triangles program can be handy.

Later on, you can copy the program somewhere else, and perhaps wrap it up as a G15 PMN app, and offer it for the public.

It is of value to know that G15 PMN is a fixed, stable, complete package. Whatever it has of issues inside it, these are very, very few, and we can talk of how to handle these. In that way, it is something that allows us to communicate as human beings by means of learning and getting familiar with it. The knowledge we gain of it, is knowledge that will keep on being relevant. The Triangles programs will keep on being the Triangles program--and so on. And we don’t have to talk in abstraction, we can talk of concrete card numbers and so on, in such an educational unit as this.

Anyway, we were going to make bigbig into a matrix. To give it structure. In the beginning of the High-Powered Terminal, and also in the beginning of the Triangles program, and building on extra Predefined words included in the expanded G15 PMN core that is standard in these products, there is a word: WWYYMATRIX. If you have just copied the Triangles program to i:1 it is at i:1103. This word we can use this way:

1000

1000

bigbig

wwyymatrix

And that is to say that we want 1000 as width and 1000 as height of our matrix. Notice that we made the size of the array a hundred more: 1000100. A hundred more is a good rule of thumb (50 is required as extra, for the structure). Good programming doesn’t push the boundaries too hard. This reduces the chance of the PC collapsing during big loops when the program is made in a way that is a bit hastily thought through at points.

So WWYYMATRIX actually modifies ‘bigbig’ to point 50 further ahead, so that just before the place where bigbig now points, the data you gave is put in. (The other spaces are just extra, a header you can use for other things, if you wish.)

In order to get stuff into the matrix, use YY, which is part of the expanded standard set of core Predefined words in the High-Powered Terminal, and in most other big programs. In other to get stuff out of it, use WW. These work exactly like YA and AY, except that whereas YA and AY want just one number (the place in the array) to get to where the number is, the WW and YY want both X and Y position, ie, two coordinates.

Now with this somewhat more dry and formal introduction to matrixes behind you, and with the notes on how to get going with expanding one of the inbuilt programs, it is possible to get started with learning about the Simple Robot Warper program. This we can work on through many educational units, and by it even explore even a bit of pattern matching eventually. It is not necessary to understand every little sentence, or every little bit of code, to make sense of the whole, and to learn more and more. It is perfectly possible to increase understanding by going back and forth and learn something here, something there. It is an aim, though, that with the Robot Warper stuff, we’ll get on to something that is fairly entertaining AND that provides real insight into programming, and real good work with what we call hard-core programming. We’ll give our little symbolic robots tasks by means of warps, and they will go around on the screen and do their little things--and then we can improve the code, and watch out their silly little pleasing movements, how they NOW perform.

When you expand a program--and all the programs that are provided in Open Source inside the standard G15 PMN platform can be expanded, as long as you provide the normal expected acknowledgements, and provide your own program further in Open Source form--it is, fortunately, not necessary to understand more than some bits here and some bits there of the programs you build on. You simply expand with new stuff, and call some of these earlier programs as best you can, reading the comments about input and output to them carefully. For clarity, leave these programs as they are. You can rather, if you wish to modify, copy one or more to the top, give them new names there, and modify the copied versions: in that way you keep it orderly, neat, and clear, and it will be much easier to relate to what you have done later on, and for others.

In the decades to come, we will more and more see that the complexities of the libraries of ready-made program modules, embedded in much of commercial computing, is likely to reach such levels as to make it even far harder for a single programmer to get any real sense of overview over what is going on in the computer or computers. And because of the economical pressures, and intensity of computing in the world, there will be a large quantity of programmers whose main concern is to put parameters into these existing modules. They won’t have much time to do programming in the sense of creating real new code and do so in a context where they have a fair overview over, and insight into, the entire library of modules invoved.

  So we might as well distinguish between the two activities. One concerns a surfing, we might say, upon existing programs, so as to put together a little bit new stuff that is more than anything a ‘soft’ touching of existing libraries. This we can call Softcore Programming.

  Then there is programming where, perhaps to stimulate thinking, or perhaps because it is useful, or have a role in an academic writing process, no more libraries are used than absolutely necessary, and what is used, is pretty well understood. The CPU is almost ‘touched’ in this programming process. It may relate to bits directly, and avoid fancy menues, and overdone call on prebuilt editing tools and so on. It is hard core. We can call it Hardcore Programming.

A Simple Warp-Driven Screensaver

Warps are fun, and they are easy, and powerful tools in the hand of the free-thinking programmer. We're going to see how much variation can be achieved with just a few cards, a few simple functions, using warps.

  But first a series of paragraphs with more general comments.

  When we program, we are not merely playing a game: we are expressing thoughts, and watching the structure of these thoughts when clothed in the shape of a formal language, and getting feedback from the millions of tiny electronical components as to what this structure really implies; what is within our thoughts--formally speaking--is spelled out. Or it is, at least, a formal illustration of a little part of our thoughts. And so this is a dialogue in the mind, that sharps the mind, and that calls on the machinery for this dialogue to take on ever-new heights.

  But in order to have a dialogue with ourselves, engaging a machine, the machine must be well-defined; ie, it must have constraints.

  The range of the standard full whole greentone screen as defined for all G15 PCs is 1024 pixels horisontally times 768 pixels vertically.

  It is good practise to avoid pushing things all the way to the limits,--the X coordinate being max 1023 or so, is here typically set to 1000 or less. Especially when text is output, as it eats up pixels as it goes to the right.

  The sequence, by the way, to give coordinates of the screen is, in an almost universal standard, X first then Y. Horisontal first, then Vertical. X is before Y in the alphabet, and H is before V also. So the position on the line of pixels is first, and then which line of pixels, vertically, is indicated. Good to repeat and memorize this sequence; makes things easier!

  Why 1024*768? Because professional psychological stimuli is achieved by a squarish format of that kind. The widescreen is more inviting of distractions on the side of the screen; suitable for commercial ads, but not so much for professional work of many types. If you need all that much info on the computers simultaneously radiated into the room, have several computers beside one another. Better that, than stuffing it all into one computer.

  The number 1024 is one that we learn to recognise when we program much: double 2 many times and you come to it.

  The number 768 is three-fourths of it. So the 4:3 screen, or 3:4 screen, a bit wider than tall, is 1024 times 768. It was the original design of the IBM PC in the 1980s to have this format, and this was greentone for all professional works with texts: many psychological studies showed that the interaction between black and bright green is particularly conducive to good work. Of course, there wasn't all that much graphics variations at that time, and the PCs were very slow compared to what is the G15 PC assumptions. G15 PC is fast, but sticks to greentone, numbered 0..255, but with, in practise, only 64 greentone-steps assumed within this range, as this is enough to produce extremely beautiful renderings of photos of girls, waves, flowers, anything.

  You see also that the G15 platform is full of a focus on the optimistic, the young, and that which gathers the coherence of your mind. It is a youth-oriented approach, and it has preteen, teen, and postteen fashionable beauty faces, and some sections of it has got it going a bit wilder.

  In some cases, by the way, you want functions that are found eg in the Triangle Screensaver, in the large G15 GEM application, or somewhere else. You'll learn to find your way to these by using the Scan supplemental program at E99 {started within the G15 PMN High-Powered Terminal} on the beginning of the code in each case.

  For instance, to draw a rectangle that is composed of four lines instead of a filled rectangle, you can use the simple routine in G15 GEM called SQUARISH, which calls on the draw-rectangle routine RT four times, but each time so that the filled ractangle is slim as a line.

  Or, to draw triangles, you can use, and modify if you like, such as the Triangle screensaver {on top of the first utility menu page}. This uses trigonometric functions in a whole-number way to create filled triangles. Filled triangles, when drawn this way, hints of 3D, and indeed it is a quick pathway from filled triangles to emulating 3D. However we advice that unless it is of vital necessity, stick to things that are more elementary and near the flat square screen with its pixels and its essential elementary altogether clear and natural and obvious drawing algorithms.

  Now, for the screensaver, as shown in the few cards starting with i:1, as displayed.

  In the first cards, ACTION1 to ACTION7 are defined. These use only very simple, mechanical, squarely simple output routines, like RT, BX, RP and PX, and such. These make filled rectangles, or put text anywhere on the screen--BX in B9font, for instance,--while PX put a single pixel on the screen anywhere. Their input, in many cases, are by means of AF.

  So AF picks a relatively free fluctuation generated number, also called a RFFG number, or, in more imprecise speech, a 'random' number.

  Then the simplest form of a very short array is defined. It is called WARPARRAY. It can have any (meaningful) name of course.

  By FF each of the ACTION1 to ACTION7 are located, in terms of the addresses in RAM, their warps.

  Finally, a number between 1 and 7 is created by AF and AY gets the warp out of the array and PF performs it.

Getting Into Working With Warps {Also Called Pointers}, and Arrays

When you want to call a function not by name, but by its position in RAM, you do so by what conventionally was called 'pointer' but which we always call 'warp' or 'warp address' or such. There's a bunch of cards connected to this little text, but most of them are composed of texts, and there is really deliciously little to explain about them.

  The first point is that the cards, L1 to L12, this time HAVE to be performed in something like the High-Powered PMN Terminal rather than in the basic, most elementary PMN Terminal. So the utility menu you can come to by clicking at the colons in the Home Page and onwards, called D:15, has this High-Powered stuff, and it lists it as existing at D22000. That means that you can look into the source there when you want to. The source of the high-powered stuff has two parts: the first has all the PDs and such, and then, at the card number that D22000 tells you rather clearly, the PMN code itself begins--that's well over a thousand cards above D22000, by the way. So we're into D23000 something. There, at some point, is defined a very useful little function called ISWITHIN. It tells you 1 if a number is within a range set by two other numbers, and 0 if otherwise. This, as well as some predefined functions that handle warps, come in handedly when we do our little work with this program. By the way, if you want to wrap up a program so that you can start it with just one click, without having to first load in a terminal, you simply copy the cards of the terminal, append your own program, and be sure that you remove any traces of a 'ZZ' at the completion of the part you pasted in just before your program. In that way, you can also set up apps and the like.

  If you wish to type in this program, when you see two similar cards after one another, you might as well do a CTR-C and copy it, and then a CTR-T followed by Space after you have done PgDn to next card. You can start by modifying the card just before the homecard, which you come to by clicking <HOME> button then PgUp, and this is of course the G:14 card. G14, then, you can put in e.g. L:1 and a text, namely that this is a warp-example program. Then, why not also type in D%22000, so you get a pointer to the High-Powered PMN Terminal, and can start it straight from this very easily accessible page. So you save the G14 by CTR-S, then activate the mouse by CTR-W, and you can go to L1 quickly, then back to it, then to the High-Powered PMN Terminal, back and forth, until you get it to work. And do REB each time you have done an important change to disk and are out to set your foot in a new place!

  So all cards from L1 to L4 are just very easy text functions, making it easier to write small, neat, compact, beautiful functions further on. You won't need all that many comments inside a function when the names of the functions themselves work as comments. However see that the predefined function FF is used. This locates a function--and produces a number, when the function quoted (three letters or more) is found. The number it produces is, indeed, the much-wanted warp. These warps can be gathered up, put in an array, and later used to perform functions without having to again refer to them by name. The function used to perform these at that time is PF. {You can use a text-search as part of High-Powered PMN Terminal to locate comments inside the programming of these functions, when you are getting really into G15 PMN work. It takes a little bit to get used to how to do it, for instance you would search on “pf:” not just “pf”, or use some other trick to enhance exactness of the search; and the comments may be a bit tight and obscure sometimes, and then it is better to search for uses of a function inside a program that is more readable.}

  At L5 there is a funny one: goldpath= &12345&. What's all that? It is an example of a very short array. For any longer array than a dozen numbers or so, you do it in different ways. But since the G15 PMN language is dedicated through and through to 32-bit, it means that even though &12345& is a text-quote, it can handle MUCH more than just letters and digits there {although, to be precise, you can also pack stuff to 8-bit format; that's an advanced topic}. In each position of this little quote, you can put a whole big vast number up to a billion and more. And the warp addresses, or warps, are just such numbers. We are going to have a program where we let the human interactor--you, presumably--tell what's supposed to be in that array, from a list of three alternatives, for how to proceed from where one is to get a gold treasure. You type in a sequence of 5 digits, such as 3, 2, 3, 1, 3 and the program will change this array each time. Significantly, it will convert each digit you type to a full-fledged warp. We don't have to look at these warp-numbers, they are usually very huge and may vary between one G15 platform and another, or even within two compilations of the same program on the same computer. We just want them to be right within the context of each run.

  Then there's more text stuff, as known--using B9 or PP to put text to the screen, and using the &..& quote style, or the ^-style. Please note that since the dot (.) is such a highly significant symbol in G15 PMN, it should never be used at the completion of a comment, for it would look like a signal that the function is done at that point, and it may lead to funny messages if these dots are put there without attention to them. Also, always stick to the &..& stuff rather than the ^.. stuff when there's a dot in the line you wish to quote; or use the other quote-type, for quotes over several lines {talked about elsewhere}.

  At L6, we also find the 'SH'. It comes after the KK. So KK reads anything pressed on the keyboard, but in this case, we just wanted to tell the human user something, then wait for a lineshift or such, and then drop it, shuck it. So SH shucks it, throws the number on top of stack.

  At L7, we see how a function can be very nicely commented by a line with In or Input or something, and then a line with Gives or something, to tell what comes out of it. This expects a number from 1..3 but the function tells of itself, in the comments in L7, that 'wild' numbers are okay--that is to say, this one checks that the input is right or not. If not, it has quiet, well-thought ways of handling with the 'wildness'. The number is stored in I1, or we should write i1 for clarity in this text, by means of S1. As output of the function is the warp.

  In the next card, L8, we see that ISWITHIN is used to check whether i1 is in 1..3. Then the N? is used. This converts 0 to 1 and 1 to 0. It means, of course, "No?" -- and it is the Boolean NOT.

  So, in L8, there is a check as to whether i1 is 1 OR whether it is outside of range: when anyone of these conditions are satisified, the function RIGHTWARP is called. This one produces the warp of the function that talks about 'taking the next path to the right'.

  Note how easy it is to divide up thought into modules so that each module, or card, can be given attention to all on its own. This is the type of thing that makes programming more a relaxing, graceful task, and less a thing that leads to stress in mind or body.

  At L9, it is just a simple check on whether i1 is 2 or 3, and the other warps are chosen then. Having made simple short functions earlier on makes it easy to implement this type of mechanism. There are other ways of doing this, but here the emphasis is clarity, that it looks easy enough, relatively speaking.

  In L10, you see that the comment indicates that SETPATH wants two things as input, not just one: it wants part#, and it also wants--on top of stack, as it says--the path, which is 1-3. The first number is 1-5, and the second is 1-3, but wild numbers okay. Note that this is the usual way of writing about inputs to a function, and outputs also: the last thing mentioned is on top of the stack. That's also why the stack is sometimes called LIFO, Last In, First Out. For that number which is put to it last, is on top of it. It is first taken off it.

  And indeed, GETPATHWARP is used at once, without further ado. Assuming, then, that GETPATHWARP has done its work and it is now a proper good warp on the stack, we need to shuffle the stack a bit, so as to get things right. For we going to store things in the little array we defined, named GOLDPATH. For this we use the predefined word YA, and to get things off the array again we can use AY {YA/AY, same letters, opposite sequence, in parallel to KL/LK, which is used to put stuff and get stuff from single variables, rather than arrays, as here}.

  So W is a single letter function like F, but whereas F forges a duplicate of what is on top of stack, W sWitches it around. There are three such one-letter predefined functions of vital importance in all essential stack use: F, W and D. F duplicates. W switches. D doubles the second number, copies it over to the top.

  The YA function wants the array on top of the stack. Just before that, it wants the position in the stack. Just before that again, it wants the value. So you see that W is needed to put it in right sequence. We could also have put it to i1, i2, i3 or the like first, but this was the shortest way, and understandable enough, in this context.

  Note that when we progress in thinking about the program from L1 to L10 we have never anticipated a function very much; rather, we go from one definition to the next, using only PREVIOUS definitions. In addition, we take care not to define things that may already have been defined in the High-Powered PMN Terminal, when that is the context within which we run this PMN program.

  Having made a suitable number of small essential functions, we wrap it up in L11 and L12 rather elegantly.

  In L11, we have a loop--it begins with LL:5 and completes with LO. It gives some text first, and cleanses screen by CE after it. It calls on SETPATH. Note that it has a keyboard-reading word in it, KI {which is a more general word, typically used in the High-Powered PMN Terminal; however note that if you use the keyboard numbers very extensively, there are side-implementions of G15 PMN in which the KI may give a different number for a few keys--notably for the so-called "dos" version of G15 PMN}.

  After KI reads a digit from the keyboard, 48 is substracted from the number, the PD 'SU' does this. This is the ASCII thing again. 0 has ASCII value 48, 1 49, 2 50, and so on for the digits. So substracting 48 is done when we access the keyboard in this way. There are other ways of getting numbers from keyboards, especially if we call on the High-Powered PMN Terminal extensions, as we talk about elsewhere.

  In L12, we use AY rather than YA to get the warp out. The AY expects the position in the array to be told, then, on top of stack, the array itself should be indicated--in this case, GOLDPATH. {Note that for longer arrays, it is often convenient to store the place of them in a variable, in which case not just the name of variable pointing to the array is given, but also the command LK to fetch that place, --also called warp, even though it's just an array}.

  Having got the warp on stack, we finally do a PF on it. This happens five times.

A bit of Boolean Logic, and Simplistic Keyboard Input

The nuts and bolts of personal computers are not just the idea of ‘1′ and ‘0′, one and zero, or ‘pretty much electricity’ (not that much actually, just a couple of volts or so) and ‘very little electricity’, but also how we combine these 1s and 0s, or 'bits', by means of so-called Boolean AND, and Boolean OR. 

  We say 'Boolean' (or 'boolean') to distinguish digital computer versions of AND and OR, and some more like NOT, from the far richer, deeper and more nuanced versions we operate with eg in English natural language, in writing, thinking, talking, reading, reasoning.

  You might say to some friends--"Are we going to a pool, or to the real wild beach? But the beach will be an expedition!" Notice the word 'or'. It really means something exclusive in this case. The digital computer version of it would be, in this case, more XOR than OR. For the normal, much-used OR in dealing with bits is highly inclusive.

  We call these things 'boolean' to honor a philosopher, George Boole, who worked out some of these notions in the middle of the 19th century, in England; although of course people had been musing about these things in various parts of the world ever since the beginning of thought, more or less.

 Well, there's a lot more to these themes; but let's get on with our example program. For now, the key point is this: a digital computer offers you a way to check whether one or both bits are 1, by its Boolean OR. In G15 PMN, this is, conveniently enough, a two-letter predefined word, OR (we write it in this text by capital letters, although when you type it in, it's important to avoid using the capital form, although the ROBOTFONT always look rather capital {a bit like russian letters in this sense}.

 So the OR fetches the two upmost numbers on stack, assuming that they are either 0 or 1. In other programming languages, it may be other values to represent the 'yes' or 'no', the 'true' or 'false', but this is a simple rugged good classical way of doing it that really works quite well, and which is intuitively entirely easy. So OR produces 1 when both are 1 as input to it, or at least 1. Otherwise, with both 0, it produces 0. These boolean operators, as they are also called, typically presume that you only feed them with 1 or 0. {Elsewhere, we look into N? and YE, which elegantly also handle other numbers than 1 and 0 so that they can be inputted into functions expecting only a zero or a one.}

  In contrast, the Boolean AND--we just write "AN" in G15 PMN--is more demanding. It gives a yeah, a 1, only when BOTH are 1. 

  All this is fine, but what can we do with it? Well, we need to have some sort of action that is dependent on 1s and on 0s,--conditioned, we might say, by these bits. We want gates, in a way, that open given a certain condition. So you can see the meaning of the term 'conditional expression' and also, as used in electronics, 'digital gates' or 'boolean gates'. In terms of electronics, we are speaking of how such as the little components called 'transistors', made of metals that aren't quite electricity-conducting metals but halfway so--semi-conductors, we call them--and germanium and silicium are the two most well-known examples: these transistors can be used pretty much to handle what in programming languages are 'conditional expressions', ie, expressions, or statements, or commands, that perform given a certain boolean input, but not with other types of boolean input. All these long words! But our example is very easy. Let's go straight at it. The word we need, though, to act on the 1s and 0s to get a variation, in this case, is "SE". You can easily think of it as an abbreviation of the word "see". It can be thought of this way: 'Have a look at the input. Is it 1, then do what's on the next line. If not, just skip the next line.'

  Turning now to the program, we this time use disk F, cards F1, F2 and so on. An example output is shown first. What I typed isn't shown, because the program doesn't have an instruction to show what's typed. But I typed 1 and 1, then I typed 1 and 0, and finally 0 and 0. The outputs are different in each case. After the two first runs, I typed F and NN also, to check that the stack, the desk you know, has good paper-order! And it does, since 123456 is produced. This result came about by using the High-powered PMN Terminal. If you use the elementary form of G15 PMN without all the extra predefined words and all the extra high-level functions, or subprograms, in the High-Powered programs, just skip the F and NN part, for it doesn't have 123456 lying on the desk, on the stack, as a standard. But both can run these cards, for they are programmed using only elementary G15 PMN words.

  Now, if you do a lot of work with putting stuff to cards, you may want to check that the next card after the final card is properly empty: so that the G15 PMN compiler knows where to stop, and when to start your program. So here we have included a screencopy of what a socalled "nilcard" looks like. It has Ascii values 0 all over the place. This you can check, if you like, by going into the {MENU} mode, by CTR-W, and then clicking with the mouse on the folder-like symbols. Still in this mode, you can do PgUp and PgDn or CTR-L to another card, and you can click on various numbers and letters and learn something of their inner values, their ASCII values. You will also see, if you click on the digit 0, that it shows that it has value 48. In addition to the ASCII value, you will also get the 'coordinate' of the character you clicked on, namely what position on the line, and which of the 8 lines, in the large ROBOTFONT cards in the CAR editor in G15 PMN. This is a graphical approach to presenting stuff that evolved naturally together with the G15 CPU concept and the PMN programming approach. Let me also say that CTR-R brings you to the middle of the card, where the second column begins. Pressing CTR-R also allows you to test if you are using slim enough columns. G15 PMN is very strict about this: the words must be short, they must fit within these narrow columns; and then we read the columns vertically; but we have two of them, and so both sides, in a way, of the brain, have some stimulation in this. Also, the slenderness tends to suggest elegant shapes.

  Anyway, if the next card after the final card you have filled in with a new program isn't the nilcard, you can just copy the nilcard from somewhere else. For instance, go to K:1000 or L:1 or anywhere where there is a nilcard. Press CTR-C to copy it, and press lineshift or ENTER or what you call it. Then do CTR-L to open the F5 card that you want emptied. Press CTR-T to put it there, and press space to confirm.

  In the first card, which in our example is F1, but you can put it anywhere you like--of course, it is somewhat easier to make new programs where you have small-sized cardnumbers, rather than going into card-numbers involving many digits,--for you have to type them in all the time--that's part of the mind-stimulating process of programming in this way--anyway, in the first card, there are comments. These are preceeded by a vertical bar | at the first position in the column. It is a good norm also to have vertical bars right after the naming of a new function to tell what should be given to the function and what comes out of it, except where it is very obvious.

  So at F1, we have two simple functions, or programs, or algorithms, or subprograms,--call them what you like--that simply gives some text on the screen.

  In F2, we invoke a very simple form of keyboard input, one that has more advanced forms, such as KI, to handle also function-keys and that is part of the High-Powered PMN Terminal. This High-Powered stuff you can incorporate into the beginning of any program. It is the normal thing to do,--either this one, or the even more high-powered part that is at the start of the Calendar program on the home page G:15. The KK gets the ASCII value of what is typed. A space becomes 32, a capital A becomes 65, an 'a' becomes 97, and, what is significant in this case, the digit 1 gets the value 49 (0..9 has ASCII values 48..58). The operator or function, the PD, predefined word EQ, compares for equality, and produces a 1 when the two numbers it fetched from the stack are equal, otherwise a 0. So this function outputs 1 or 0, after having a wait for keyboard input. Anything typed of letters and so on will give a 0 as output, in this case. Typing 1 gives 1.

In F3, we call on this routine, the CHKINPUTFOR1, twice. We store the results in some very useful locations. We use S1 and S2 to store in location I1 and I2. What is beautiful about these so-called local variables, of which you have twenty automatically for each function, is that they don't affect the variables of other functions, as a general rule. They are like private folders or mini-desks for each function. The ease with which this can be done, in with as speedy and computationally effective results as in this case, is rare amongst programming languages; and the way done it here is not something we've seen elsewhere. You can say T1 and T2 instead of S1 and S2 but then the output is by means of using J1 and J2 instead of I1 and I2.

  So, in F4, we apply what we know about OR and AN: we get the PMN to say that 'at least one is 1' when the OR outputs a 1, and we get the PMN to say that 'all are 1' when the AN outputs 1. The SE sees to this selection, it reads the output of the OR or AN just before it--it expects a 0 or 1 on the stack. What follows after SE--and there are some others also, but this one is eminently useful--you should have a simple function call, not a quote or number or something like that. The line doesn't have to follow right after SE, by the way--you can have several blank lines after it. It is often a good practise to put a blank line in before and after a SE, when there is otherwise room, because any such conditional action is such a critical point in a program that it deserves maximal attention. Nevertheless, the exception to the rule that proves the rule, in the final column on the right side of F:4 we don't have these extra blank lines. This is because we wanted to fit in the ZZ part, that tells how the program should start up.

In the 1960s, computers the size of houses performed 8-bit and 16-bit tasks slowly, and they consumed electricity enough to power a huge factory. At this time, the most typical input and most typical output involved paper: paper with holes as input, and paper with weak character printed on them, in an extremely noisy process. The languages, insofar as they existed, had to be relatively compact and relatively well-defined. Most, like Fortran, were either very near the assembly-level, the machine code level, where one must think in terms of numbers much all the time; or else they were, like Algol, so fixed in their approach and so narrow that one couldn’t get perhaps the full functionality of the computer out of them.

  At this time, somebody who wanted to think big and abstractly, like Ole-Johan Dahl and Kristen Nygaard at the Norwegian ‘Regnecentralen’, an academic computer centre in Oslo, would normally use a narrow language like Algol; but they wanted to go beyond some of the limitations, without going nearer to the assembly level, and without making a Fortran-like language. As Nygaard much later (the late Nygaard was a friend of my father, Stein Braaten) told me, they had the code for an Algol compiler. Dahl was expert at digital computer thinking, while Nygaard had some grand visions of a language more suitable for thinking about living processes, in such as the behavioural sciences. Out of this grew the notion of ‘activities’ and ‘processes’ and an implementation of notions of being focussed on data as ‘owners’ of functions (rather than the other way around, as was typical with such as Algol, we might very roughly say). This was in 1965. In 1967, two years later, they had added hiearchies to this, that objects--as the processes were now called--could be derived from higher-level or more general objects, now called ‘classes’. The first version was called Simula, the second was Simula67. This language didn’t become all taht dominant outside of Norway, but it found its way into some academic computers and then influenced Bjarne Stroestrup to develop C++ out of C, and then the ball started rolling, we got object orientation, as it was now called, in variations of Lisp, in the new ‘purer’ language Smalltalk, and so on and so forth, to the varieties in terms of thousands of languages.

  Of course, Nygaard and Dahl, who got the socalled Turing Prize for their work around year 2000 (some years before both died, Dahl after longtime illness, and Nygaard of sudden illness) had to be proud over the influence of their work. But Nygaard wasn’t entirely convinced it had developed the right way. He had experimented, together with some people in Denmark and elsewhere, with new structures, in a language called Beta; and he also talked of invoking the theatre metaphor for yet new thinking about languages. He also found some interest, it seemed to me, in my suggestion that the notion of hierarchy couldn’t really be employed so widely as object oriented languages typically want it to be employed--I described some of my meetings with David Bohm to him, and we discussed some possibilities for a while.

  The point I wished to make is that the idea of making something better than Algol, with somewhat more exotic data structures, did make sense IN THE CONTEXT of the 1960s. What I say now, with full strength, but which a natural modesty prevented me from saying that direct face-to-face with Nygaard, is that object oriented languages haven’t got any much point anymore: they have become a way to hide the computer structure from the programmer, and there are other, and better ways, of getting the more exotic data structures we want.

  Very quietly, alongside Algol with its narrow pathways--which also developed into the much more beautiful Pascal by N Wirth--and the C language, as a structured form of assembly and little more to begin with--was Chuck Moore developing Forth at the same time, to have an easy time both interacting with a computer and programming it, while also doing such as control large telescopes; and all this on generally even smaller computers than those typically set up to have the big compilers. The point about objects--as they are called--is that these are data that own, possess, or point to actions. This couldn’t be done in Algol with any ease, nor in early type Pascal. Because these languages didn’t allow a function to be pointed to. The function could only be called by means of knowing its name, at the time the program is typed in. In Simula, however, new possibilities opened up--however only such as was approved of by the language designers. In C and Forth--two very different languages--we found the same freedom as assembly programmers have when it comes to referring to a function not by name, but by position in RAM. This might seem to be a technical thing, perhaps: but when handled with proper attention and interest, it is a door-opener to fascinating ways of programming.

  This fascination deserves a name. The name in C, as in Forth, is typically ‘pointer’. In G15 PMN we have used the name we invoked for the earlier forms of our vaguely, or very vaguely Forth-like languages: a warp. A warp is something a flower does, when it grows a sudden new lovely bud and does so not entirely obviously, but by branching out. In scifi writing, warps, or hyperwarps, or hyperjumps, are of course the jumps across regions which, in Isaac Asimov’s terms, in his Foundation, are “neither something nor nothing”, and where travel happens “between two neighbouring instances of time”, whether it concerns “a million miles, or as many lightyears”. Some might say that this is too hot a concept for something like pointer. But we need something big to compete with ‘classes’ and ‘objects’ and ‘inheritance’: that’s one point. Another point is that we need to remind ourselves of the great importance of handling these delicate things with care,--for they are dangerous unless done entirely right. A “pointer” doesn’t call on attention in the same way as a warp does. A warp can cause the PC to stop if done wrong. But when handled right, warps can be fascinating elements providing fresh energy and new ways of programming--and, yes, by the way--all the things that Nygaard wanted to put into a language can come by means of these structures, except perhaps the pre-defined control of them.

  The reason I think we shouldn’t have a pre-defined control of how these pointers, or warps, should be handled is that a programming language should be as much as possible a canvas, as I’ve said before, rather than imposing its own structure. Where things can work without it imposes its structure, then let it not impose its structure. In a way, G15 PMN has been designed with much the type of slogan in mind that J D Salinger one of his girl characters in his “Zoey and Frannie” have: that, when the poem has been made, the poet must “get off the page”. Once the programming language works, the programming language designers must “get off the language”. Leave it to itself. That even means its dominant libraries, for they are part of the meaning of the language.

When you program a Personal Computer, then you are, as it were, installing a little extra machinery into it. And that is exactly what it is made for. The underlaying simplicity of the machine, and its flexibility, its capacity to store fresh impulses in its mechanical memory, its RAM {’random access memory’, meaning that you can access any bit of it you’d like}, makes it an ideal framework for encouraging the art of thinking, stimulating to greater clarity, more structure. It can also be useful in practical tasks but it is important to realize that many human practical tasks have a complexity that goes beyond what we should try and put computers to. Driving cars is one example. Unless the driving happens in a closed tunnel with only one file and no other entities but the bus in the tunnel,--a totally well-defined context--then the complexities involved are so as to make it incorrect to apply the computer idea there. People can try it, of course; but it should be pretty obvious to one who applies both rationality and intuition, rational intellect and intuitive intellect, over some time, that computers shouldn’t meddle in many human affairs, and they should be kept pretty much out of all decision-making where the conditions are fuzzy and floating and context-dependent.

  So the personal computer is SIMPLE. That is part of its definition. If it isn’t simple, how it can it be personal? So that is the PC idea as we see it in G15 works.

  Part of the simplicity of thinking about how to program is that the PC does ONE THING AT A TIME. It can do some things like adding numbers or putting a pixel to the screen very fast compared to how we’d manually do it; and by shifting quickly between a number of tasks like that, back and forth, it can give a sense of doing things in parallel; but the point of the Personal Computer is that it has a possibility of being programmed to run clear-cut succinct, beautiful programs, also called ‘algorithms’. These are step by step instructions; and even if there are some languages for PCs that have been made and that conceal this simple truth in pompeous ideas of ‘objects’ and ‘activities’ and such, or worse, with mind-like or human-like notions blended into the ideas, so that it is spoken of ‘agents’ or ‘learning’ (and THEY speak of it without quotes!), we must stick to this one-thing-at-a-time idea if we want to be faithful to the pure concept of the computer. It has a core, a heart in a sense, which is called CPU, Central Processing Unit. In the case of the G15 approach, this CPU can be run as it were on top of a broader, perhaps less elegantly defined computer, or as a CPU somehow wired together on its own premises, the G15 CPU. We’ll look into how to program the G15 CPU for some advanced PMN programs elsewhere.

  But for now, thing of this one-thing-at-time idea. This means that when we have a task that is composed of subtasks, and each has to have its own little numbers to arrange things, and we have a single series of numbers presented to them somehow, then we are led naturally to the beautiful notion of a number stack, a digital stack, The Stack.

  So, let us imagine that in our house, there is one big desk. You are the boss. You call in somebody to do one task, and allow this person to use the desk while you watch over it. Then you order somebody else to come in ad use the same desk. You want each to clean up properly; you assume that they will, that they are responsible. But in some cases, the sequences of the tasks matter, for you want one person to build on the results of what another person did. And so, it is an advantage that there is one common desk. For one person’s completed subtask will then leave the exact desired result that the next person employed to do the next subtask can pick up.

  So, for instance, if you go into a PMN terminal, you can type in something like this to add two numbers, then multiply two different numbers, then add all this again, and print it out. Keep the numbers within the psychologically meaningful size of not exceeding something like 9 digits. That is to say, keep them within about 999,999,999,999. You can go up to plus minus 2 billion if you like, and still be within the definition of a solid good rugged socalled “32-bit” computer. {Longer numbers can be handled by special routines, though.}

  So here is what you can type in, to start with, if you are learning about stacks. The overview over the inbuilt PDs, the PreDefined words in PMN is easily accessible within the G15 platform. AD is ADdition, SU is SUbstract, MM is multiply, MO is MOdulus (remainder of a whole number division), DI is whole number division. There are ways of treating numbers that can be understood to be fractional numbers, but again, a pure conceptual Personal Computer mustn’t be cluttered with things that aren’t clean-cut digital in its core design. Still, we can do trigonometry and so on, to a fair and practical extent, as we see elsewhere. Anyhow! Try this--with or without the extra blank lines; it is a common feature between such typed-in programs, and programs run from cards, that you can have blank lines in between the statements. When you start a program from a card, it will keep compiling cards until it finds a card that starts with its socalled ‘nilchar’, which is the type of thing you see with cards that you haven’t put anything on yet; you can copy such ‘nilcard’ from anywhere to anywhere by the CTR-commands that work within the CAR editor:

23 230 ad

55 5000 mm

ad nn

How big is the stack? Big enough! But if you want thousands of things stored in RAM, use other ways--an array, or such. We look into that elsewhere in this tutorial. Another question: do you have to use the stack to communicate numbers or other things between functions? No, you can use such as variables as well. Named things. Also something we look into elsewhere.

  Now, if you want to check that a function cleans up neatly after it, it is usualy enough that you start it up in the High-Powered PMN Terminal and type either ‘nn’ directly, or more normally this:

f nn

How to make some randomized filled rectangles in G15 PMN

Each time you run the program above, which fits on two cards--in the example, k:1 and k:2 are used--it will give a somewhat different set of rectangles on top of each other. Two graphical examples are shown.

  So to start this program--to take that first, before explanation--you can either use the g:15 homepage and click on the arrow under the big PMN letters on upper left, where it says d%65000 (only that the ‘%’ shows more like a flower, or twig, or hand, which is a way for us to indicate that we do not approve too much of the overly statistical notion of talking about percentage all the time, besides it looks much like 0/0 which is meaningless arithmetic in any case; we advice the use of the ‘permille’ concept of 1/1000 instead of percentage as 1/100 in order to facilitate broader thinking about numbers, and not stay in the habit of statistical thinking of the conventional type). Or, you can use the utility menu d:15. You come to this by clicking on the colon in the MORE>>>d:10 line on the homepage g15. (Remember that any use of the mouse during the viewing of cards should happen in the MENU mode. You switch the menu mode on by CTR-W; this is also to remind ourselves that we do not want to over-rely on graphical features to operate our platform, but consider somehow text more important than graphics, and keyboard more important than mouse, except when it is really, really useful.)

  When you find the utility menu,--it is not the first one shown, but about the second one shown, after you click on the colon to right of MORE>>>--you see there that d:22000 has the High-powered PMN Terminal. This you can start by clicking on the symbol between d and 22000. This has a lot of preloaded functions. AFTER you have run the program using THIS option, you can type F and then NN as in the screenimage above, and then it will show 123456. This is a way, in that terminal (but not in the PMN when started ‘raw’ on the homepage g15), to check that your use of the G15 PMN main stack (as it is called) was correct. More about this elsewhere.

  In any case, how does it work? I’ll give you some brief comments here.

  First of all, rndsquare--a randomized square--does a bit of calculation. It is going to call on RT, the predefined word that wants x1, y1, x2, y2 and tone of bright green (from 0=black to 255=bright green) as input. The x1, y1 are the coordinates on the screen of the upper left corner. x1 is horisontal, from 0 to 1023. y1 is vertical, from 0 to 767. The x2, y2 is the bottom right corner. The screen is defined to have this size in G15 PMN as part of the tranquility of learning the art of thinking by means of a good language that works against a well-defined machine, rather than something that is changed. (Though in some robotic cases, the screen might be smaller.)

  So you see 50 and then 50 goes to x1 and y1. These are ‘put on the desktop’, the heap or stack ther of numbers,--if you’d like to imagine it. Then 500 goes to AF--which gives you A Free number up to 500, by means of calculation over the milliseconds clock with some wild formula. It is not true random but then what is? 100 is then ADded to this. So that becomes x2, you follow? Whereas y2 is set to 500 all the time.

  So, four numbers are on the stack: x1, y1, x2, y2. It remains, before RT is called to make a filled rectangle, to specify the tone, 0..255. Here, 155 AF is added to 100. That means it is never black, in this case. Then RT is shown. That completes one rectangle. The next card, K:2, just loops through this 500 times.

  In the final line, just before the ZZ that tells the PMN what to start doing after compilation, the &..& is used. We could have used a hat ^ just before but this i an alternative, and in some cases, when you want to put a space in a quote, it is exactly the way to do it. We’ll look at other ways to quote also, and how to add quotes.

Those who have the time may want to look into the description of Kurt Goedel’s famous ‘incompleteness’ work, in particular how it is playfully described at the apps page of G15 PMN, in an essay. The norskesites.org/fic3 links to the apps page, and it has an essay section, where it should be easy to find. Put very simply, a computer is finite, and a program on it is finite, and a finite program will always be incomplete in infinitely many ways, as concern the ‘perception’ of things. This means that artificial intelligence in a general sense isn’t possible: that was very clear to Alan Turing, who invented much of the computer concept exactly while trying to disprove Goedel, but instead of disproving Goedel, he only succeeded in strengthening the original proof.

  Programming, if it is to stimulate mind, must have a bit of honesty about it. It mustn’t try and convey to the human being who uses the program that it has a mind of its own.

  Instead, programming, when consciously made, can stimulate to good use of the mind while also being practical and doing tasks that otherwise would be tiresome to carry out manually.

  So, instead of ‘simulating’ mind, the approach we take in G15 PMN is to stimulate mind.

  When it comes to handling tasks that require a bit of pattern matching, and perhaps occasional batch tasks of entraining new patterns, it is possible to do this in a way that honors Goedel’s incompleteness work, and that, more importantly perhaps, in no way imply that we are giving the computer a real sense of mind. The concept that we invoke in G15 PMN in such cases is FCM: First-hand computerised mentality. This is not about simulating mind, but doing a bit of handling of fuzzy situations such as for instance robots may encounter, so that they have a context-specific set of tools that can handle this fuzziness. These involve that the programmer or programmers invest something of her own mentality into how the program is set up. It would be childish to call this ‘artificial intelligence’, of course.

  More deeply, there are ways of looking at all the data that has come around since the time of Isaac Newton, including all the gravitation and all the quantum phenomena, and take this into consideration in a worldview that doesn’t see life nor mind as machine-like. Mind calls on machines, but machines cannot capture minds. Mind is alive. A good session of programming with a good language like G15 PMN can stimulate our aliveness, and be practical, and/or fun, in terms of the resulting programs, as well.

  This philosophy of relating to computers so that they stimulate mind is also called ‘first-hand programming’. The reason we invented this concept, a long time ago, was to distinguish between programing of a kind that is merely a rather statistical manipulation of packages or masses of data that aren’t clearly visualized, and programming that intensely invokes a sense of the exact algorithms and the exact data. G15 PMN is different in key ways from all programming languages made before it, but it can be seen having more in common with Forth by C Moore than most other languages: and Mr Moore clearly did want a language that stimulates mind, in how he designed Forth. However we go a bit further than Forth in thinking through the wide set of themes connection to doing ‘stimulation, not simulation’. One of them means setting aside such as the much-hyped sort routine ‘quicksort’ because it is tainted with second-handedness and with a needless, time-consuming complexity when confronted with lists that are almost sorted already. ‘Quicksort’ presumes something about how a large list can be organized. We want to use mind in doing the organization of large list, then, as the large list is suitably ordered, the rest of the sublists are small enough that a much cleaner form of sort, the classical, pure, simple, noble ‘bubblesort’, can be used.

  The use of cards rather than files in G15 PMN is similar to some of the earliest versions of Forth, but also different. What must be realized by programmers used to working with files in such a context as Linux is that these files are organized by means of a very advanced database, and they are nothing anywhere near ‘essential’ to how a computer works. So if such files are the starting-point, the programing language is already rather second-hand: for it doesn’t really invoke a relationship to the computer directly, but presumes a giant indexing system along the lines of B+-trees and a whole set of predone programming. Similarly, any handling of parallelism by means of predefined structures such as found in many class/object/hierarchy languages of the type that also Java belongs to, is another type of second-handed-ness. To revert to assembly is not the best solution, for assembly--and perhaps never more than when we speak of Intel i386-derived assembly languages--distracts from focus on the programming process.

  Much of the complexity of underlaying operating systems, while suitable for commercial interests, really takes away the sense of empowerment that a programming language is meant to come with relative to the mind of the young student.

  The solution, again shared with original Forth, but also found in approaches taken by some of the more adventurous programming language makers such as the swiss N Wirth with his Pascal and Modula-II and Oberon, is to insist that the proper language goes all the way through to the ‘bottom’ of the PC, and that here isn’t another ‘operating system’ than it. However if this is going to be meaningful to use, not just meaningful to program, we must find out what we can leave out of the definition of the computer. Here, too, we must ask: what is first-hand, and what stimulates; and what is merely a candy for the entertainment-seeking mind, and not essential for computer science and for essential, and mind-awakening, computer use. Do we really NEED video as part of the the computer definition? Do we NEED millions of colors? Or is this merely part of the consumer hype, and not essential--nor very beneficial to mind? For video is but high-speed shifting of images, perhaps with sound-output, aimed at producing nothing but an illusion. The reality is image. Also, playback of sounds isn’t essential to what algorithmic programming is about: it is something that is intensely tied up to a clock-like process, whereas computer science and significant use of computers in general is a more timeless process. Further, the full range of stimulation, for most purposes, also entertainment, requires just one (uplifting) tonality, rather than R+G+B blended. Similarly we can focus on what a computer should have as meaningful limits in terms of speed and RAM and such, rather than being obsessed with moving these limits out of commercial greed or some kind of superstitous belief in ‘technological evolution’.

When you want to program loops in G15 PMN

A simple way to do it is by means of LL:nnn, where nnn is the number of repetitions you want. Then say what you want, and complete the loop with LO.

  If you put the stuff into card i:1 as above, then the command ^i1 followed by (on the next line) the command ‘cc’ to compile it, is enough to start it and get the output as shown above.

  In the example above--repeated after the output so it is easy to look at while also reading this text--you see that G15 PMN has two columns in each of its program cards. So the text above first defines the word ‘nice’. You see that the full stop is really, really huge, so there is no doubt that it is there. You also see that the characters as displayed there--and they are automatically considered as lowercase in these cards, unless you press SHIFT and get a dot above and to the right of this so-called ROBOTFONT (for it is suitable for low-resolution LED-displays on robotic instruments also)--they are rich in contrast, and that’s a GOOD thing for programmers. For instance, the ‘i’ is as different from ‘l’ and from the number ‘1′ as it is just about possible to get while still having a resemblance to typical English letters. It is also an optimistic font--it’s all pointing up, all over the place (except for the letter ‘z’, which has been mirrored, to reflect that it is last in the alphabet, and signifies typically a completion of something). Finally, let us also note that the letters of these cards are huge,--in fact, gigantic.

  Now all this sums up to what a programmer will want to have when truly complicated programs are made, made out of hundreds or even thousands of cards. Each card must be not just half-way right, or two-thirds right, but totally right--in a way. This exactness can be tiresome. The large font, the conciseness of the PMN expressions, the optimism of the bright green and the upward-pointing features of the funny characters, and the clear-cut contrast between the tools that the programmer works with--namely, first and foremost, text and numbers--all this adds up to elegance and meditative flow of programming and ease of correction, generally speaking. Nevertheless, every complex programming process will have moments of confusion, no matter how the language is structured, and how the routines are displayed.

  In any case, to return to description of the above: the first routine is called ‘nice’, and the second ‘lotsnice’. Lotsnice is defined like this:

lotsnice= ce ll:23 nice lo.

So, the {menu} type of thing at bottom merely reflects what mode the card editor and performer, the CAR, was in when I took this screencopy. It also says that I work in card i:1. The {menu} becomes {edit} when the mouse is right-clicked. The {edit} becomes {menu} when CTR-W is pressed. To an artist, a smooth W looks like the metaphor of a girl’s mouse.

  The CE is Clear scrEen. If you omit it, the program will still work, but it will say YES! on the upper left to show that the program compiled in well enough. Finally, on the right column, at bottom, there is the zz type of statement. This tells the compiler that when compilation is done, then start the quoted function, in this case, the new function, or word, named lotsnice.

  To print out the text in B9FONT, which we made {actually earlier on, when the main language form was called Firth234 then Lisa GJ2 FIC3, the ‘fic3′ still being the name of the language place, norskesites.org/fic3 with a mirror-site in one of the other sites in our Yoga6dorg search engine set of sites, run in the same language, which in this case is moscowsites.org/fic3), you can use the two-letter (predefined) function B9 instead of the function PP. Of course, there are more such functions to place the characters freely on the screen. And in each case, you have the source of these functions, written in the G15 native assembly-like language, and which it is natural to get to know a bit about as you progress in G15 PMN programming, for it vastly extends what you can do with PMN so that you can do anything which is within the scope of just that type of Personal Computer, the G15 PC, as we have imagined it and realized it.

Note that the ‘zz’ command is typically the very last line in any program that we compile and run, and that is isn’t something used within a program. In other words, when we make a new word, a new function, a new program, by doing something like abcdefgh= then some lines then a dot (.), that’s fine, but the ‘zz’ won’t be found between the = and the dot. Rather, the zz stands on a line all by itself, and no dot comes after it.

When you have gone through this little example you have seen a great deal of all the main features of the language: and yet there is no end to how many books we can write about programming in it. But that concerns higher structures, techniques, approaches, methods, and getting used to using the libraries of ready-made functions, and such. Fundamentally, it always looks more or less like this type of stuff, though there are a few more features, such as how to handle long-quotes (quotes over several lines) and comments and such, that can be said to be part of the ‘syntax’ of the language.

Note that the command

^i1 cc

With most programming languages, it is possible to do something in more than one way. And some ways may be appearing to be 'tricks'. However, there is no need to view some ways of doing it as tricks if they work consistently. Whether something works in PMN you can find out (when you have gained some knowledge of the whole of G15) by looking into how PMN is defined. In fact, each time you start up a G15 PMN program by clicking on it at a menu, you start a swift process that JIT, Just In Time, compiles the whole of PMN in terms of its more essential G15 code. In this way, you can both inspect what goes on in PMN, and also extend PMN with new two-letter words, new Pre-Defined--PD--words! 

Anyway, let's look into how to make a variable--in the most typical way, anyway. A number variable is the simplest and in a way, most essential example. Suppose you have a customer-list. How many customers are in the list? You may want a variable for that, and an initial value. Let us set it to 100. This could be how:

customers= ^.

100 customers kl

Then let's find out how many customers we have at present:

customers lk nn

It will now say '100'.Note that 'lk' can be read as 'LooK'. The 'kl' is the reverse sequence. It could be interpreted as 'kill the earlier value, and put this one instead!'.Also, note that we use 'nn' to print a number while a quote would be shown by 'pp'. This is the way we do it in a PMN Terminal. When running a program using various graphical positions on the screen, we have several other possibilities.

With each decade--since, say, the 1960s--algorithms have been archived, systematized, made into libraries, and, in turn, collections of such libraries have been further systematized and bundled and organized, in higher and higher levels. While this has led to an ease with which computers can be tailor-made to fit with purposes that enable people to do things with them without any much training, it has also led to a certain degree of confusion about what computers really are and what programming, indeed, really is. Surely, if programming merely is handling gigantic libraries of ready-made programs, then the distinction between using a computer and programming a computer is more or less vanishing. And while the general usefulness of computers may have gone up, the lack of contact with the essential algorithms that drive the computer has led many of those who before would have learned ‘raw’ programming to have to spend time on learning to communicate with ready-made programming instead. And programming languages themselves have been made that reflect this rather second-hand relationship to the essential computing.

  The programmer, or the person setting about to learn programming for the first time, or to learn a new programming language, perhaps one that is very different from earlier ones, must therefore think through priorities. Do you want to learn something of enduring value, that helps you to think, and to KNOW computers first-hand, and that leads you to real insights into how to make algorithms? Or is all you want to handle the computers of this year and maybe a couple of years into the future, at most, in terms of being able to steer through and configure the most-used and most-hyped and most-commercialised packages?

  The use of G15 PMN, whatever the status of G15 PMN in society, in terms of education, is to learn something about computers in a first-hand way, and to sharpen own brain, own mind, own instincts about how to structure thoughts. In a context where other people are using G15 PMN-enabled PCs, this can also be practical, even commercially practical. But even if others aren’t using such PCs, you yourself can continue to apply and extend and deepen your programming competence, and create something that works for you and your friends. This skill will be with you and G15 PMN is a finished product, defined in independence from the present status of computers, and will work in any context where there are computers above a certain minimum level of RAM size, speed, and so on. And, there are activities going on where this involves also the use of robotic extensions to G15 PMN-enabled PCs, so it can be practical in this sense, too {at some point}.

Programming languages may be similar when it comes to the simplest statements, but it is, usually, when data structures are to be defined, that they quickly branch out and become as varied as they can be. People talk in different ways--some are more declarative, others are more questioning and tentative. Some talk to direct how things should be, while others talk more so as to point out how things might be. And some people shift between modes. When it comes to creating a data structure, some programming languages want to be very actively part of your data structures. They have all sorts of predefined words, and sometimes these fit the needs we have, and at other times they are inconvenient, because our thinking have leapt lightyears ahead of what the designers of the programming language were thinking about.

  In G15 PMN, the approach we take is that we want to encourage thinking, and we don’t want to burden the programmer by knowing too many syntactical rules, too many predefined names. The computer is mostly about throwing numbers about. And so when we make a data structure, this is, whether the programming language conceals it or not, mostly about reserving some place in RAM, in the computer memory, for a bunch of numbers. Once you invite the programming language to participate in how you divide this bunch up, you will find that the programming language imposes itself in dealing with that bunch from that point on. In G15 PMN, your are encouraged to visualize arrays of numbers, and matrices of numbers, and to divide them up the way you like, the way that most fits with the program you are making.

  In G15 PMN, the most easy way to reserve place for a bunch of numbers, whether they are thought of as a series of numbers, or as a matrix of numbers somehow, is by means of the quote. Yes, quote! For what is a quote? A quote, like the text Hello world! that a simple first program could print on the screen, is of course just a series of numbers, a number for H, a number for e, a number for l, the same number again for an additional l, then a number for o, and so on, all the way to the number for ‘!’. These are the socalled ASCII numbers. They constitute the English alphabet and the most usual extra stuff like dots (.) and commas (,) and even space ( ), and space is numbered 32, and it goes all the way to 126, with capital A being 65.

  So, any quote is, in that sense, an array. The array may be huge, a million, or more, numbers. And so there is a predefined word, a two-letter word or symbol in the language, called ‘SZ’, short for size. When this is used, it is used with a number that tells how much RAM should be given to the NEXT quote that we invoke. And the next quote can even be an empty one, ie, one without any characters--assuming, then, that we somehow fill it up with suitable stuff later on in our program. In the case where we want a matrix for it, we can call on some of the simple ready-made algorithms (with longer names than just two letters, they are above the Pre-Defined or PD layer), which are preloaded when you start the PMN High-Powered Terminal by means of the utility menu, or otherwise copy and paste these routines into the start of your program. An even larger set of ready-made routines, the socalled ‘Ultra-High-Powered’ Terminal is what is in the beginning of the Calendar program on the Home Card of the G15 platform. So these extra routines do a tiny bit of formatting, some initial structuring, we might say, of all the RAM that you have set aside to some work, and given a name, usually.