Lesson 13 – Anonymous words and words as parameters

A bit more word related stuff

Before we begin to explore the namespace a (arrays) further, we first need to explain a bit more about words.

When we define a word we start with the : (colon word) and end with the ; (semi colon word). 8th will compile the word and after that the word can be invoked by other parts of your code.

We call this kind of words named words, because you give them an explicit name.

Anonymous words

In some cases it is handy to have a word definition without giving that definition a name. For such cases there are anonymous words.

Just as the colon and semi colon words begin and end the definition of a named word, the opening and closing parentheses words begin and end an anonymous word, like so:
       (  “Hi there “  .  cr  )

Note that these are all 8th words and must be space delimited!

Callback words – words used as parameters for another word

Sometimes an 8th word is needed as a parameter by another word.

If you would write down such a helper word right away, things go awry, because then that helper word is being invoked instead of passed as a parameter.

Example 1

• imagine we want to use an arbitrary word x which in turn needs a helper word y during the execution of that word x
• suppose that the SED of word x is \ helperword –

If we now wish to invoke x and do something like this:
y x

the following happens:

• 8th will invoke the word y instead of handing it to x as a parameter
• then x expects a parameter (the word y) to be on the stack, which won’t be the case

But that is not what we want at all! In order to prevent 8th from invoking the word y, we need to tell 8th that it should hand over the definition of y to x.

Especially for such cases there is the  ‘  (single quote) word.

Example 2

So now we can invoke x using the helper word y like so:
‘   y   x

and everything works well!

Note that the   ‘   word must be a plain quote.  (Microsoft Word shows it here as a bottom up comma. For code always use a plain tekst editor). The same applies to double quotes.

Anonymous word used as a callback

Because of the nature of anonymous words, you can also define a helper word as mentioned above as an anonymous word.

In that case you don’t need to quote the anonymous word.

So now we can invoke x using an anonymous helper word like so:
(  “Value = “  .  .  cr  ) x

How to invoke a helper word y from a word x

There is a word called w:exec which can be used to invoke another word.

Example

To complete the picture we now create a small program demonstrating the different features we talked about.

We will put a numeric item on the stack and show the result of adding 100 to it.

We do this in 3 different ways. Here is the output:

More info about 8th

Central website for 8th is: http://8th-dev.com

YouTube Channel here: https://goo.gl/DscYVD

BLOG here: http://goo.gl/n1NocJ

Lesson 12 – Using arrays in 8th – part 1

Arrays

An array is a special form of a variable.

Instead of just 1 value, you can store a lot of values in it. It has a bunch of slots.

Normally you would require a separate name for each slot. But when you use an array, you only need the name of the variable containing that array and the index of the specific slot where a specific value is (or will be) stored.

Define an empty array

Defining an empty array can be done like so:

[] var, arr1

It seems like we just define a normal variable arr1 here. However, note that the [] we push onto the stack first is an empty array!

Note that [] is not a single character but the 2 characters [ and ] concatenated.

Define an array with initial values

You can also define an array with initial values, like so:

[100, 200, 300] var, arr2

What is a variable and what is an array?

In effect an 8th variable is a pointer to a “value”. The variable itself has no specific type, the value it points to has a type.

Using the @ word, you dereference the variable and point now directly to the value which has a specific type.

When the value pointed to happens to be an array, a specific action is required to get the desired array element.

In effect an array is a series of pointers to each array element. An array is a type itself. However, the array elements can be of different types. 

So first we have to “find”a specific array element before we can establish the type of that element.

Using the a:@ word in combination with an array index number we can now dereference the array element itself.

Dereferencing an array and it’s elements

This is the tricky part of arrays in 8th.

In languages like C or Java, you can reference array elements like so:

arr1[3]

We would expect that we could retrieve the same in 8th something like so:

arr1 3

However that is NOT the case! In 8th we must dereference the variable first using @ and then dereference the array element using an index and  the a:@ word:

arr1 @ 3 a:@

So, effectively:

1. you first dereference the variable that holds your array using @
2. then you use the number of the element to be retrieved from that array (3 in this example)
3. and finally you use the a:@ word to retrieve the corresponding element value

You could compare it with a chest of drawers. When you need something in drawer 3:

1. you must first reference (go to) the specific chest (array)
2. then you use the number of the drawer (here the number 3)
3. and finally you open that drawer and retrieve it’s contents

An example to show what happens:

Explanation of each step:

1. .s                                   \ show that stack is empty
2. [10, 11, 12, 13] var, a      \ define an array named a with 4 elements
3. .s                                   \ show that stack is empty
4. a @ . cr                          \ here we dereference the variable and get the value
5. [10,11,12,13]                   \ it appears that that value is a 4 element array
6. .s                                   \ show that stack is empty
7. a @ 3 a:@ . cr                \ now we dereference the array element 3 using the word a:@
8.                                       \ it appears that element 3 is the number 13, which means that
9.                                       \ 8th uses index 0 (zero) for the first element!
10. .s                                   \ shows that the stack keeps the reference to the variable a
11.                                       \ please have a look in the manual for the SED of a:@

Because the reference is left on the stack (in step 7) you could go on referencing other elements like so:

     0 a:@ . cr      \ This would fetch array element 0 (zero) which is the first element: 10.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Lesson 11 – 8th general program structure

More than a REPL is needed

So far we only have shown the REPL, the interactive 8th console.

In order to create complete programs we need to expand our possibilities a bit.

Using a text editor

We will need a (simple) text editor to write an 8th program.

These days there are all kinds of advanced tools, like IDE’s (Interactive Development Environment). However, for our purposes we only need a simple editor.

The editor I am using is called Textpad and costs a little. I also created a simple, but nice looking 8th syntax highlighter for it. You can ask in the 8th forum about this.

A few possible (free) editors (in no specific order):

• Windows Notepad (built in in Windows - free)
• TextPad Editor https://www.textpad.com/ ($27 as of jan. 19 2016))
• Crimson Editor http://www.crimsoneditor.com/ (free)
• ConText Editor http://www.contexteditor.org/index.php (free)
• PsPad Editor http://www.pspad.com/ (free)
• NotePad++ Editor https://notepad-plus-plus.org/ (free)
• Emacs https://www.gnu.org/software/emacs/ (free)
• EmacsW32 especially for Windows users http://www.emacswiki.org/emacs/EmacsW32 (free)
• VIM http://www.vim.org/ (free)

NOTE stay away from text processing programs like MS Word, Wordpad, Open Office, Libre Office etc. Those “editors” make heavy use of markup language. But we need a strict plain text editor for programming purposes!

Program structure in 8th

• if we reference a variable x from within a word w we have defined, that variable x must have been defined before the definition of word w
• if we reference a word w1 from within a word w2 we have defined, that word w1  must have been defined before the definition of word w2 (there is a special case (deferred words) which we will explain later)
• at the end of a program you should define the special word app:main which is the word invoked automatically when your 8th program starts
• the app:main definition should normally end with the bye word. For this rule there are 2 valid exceptions:
• in GUI apps quitting 8th will be done elsewhere in the program; you must leave out bye there
• for debugging reasons; from version 16.01 onwards there will be a word available to start the REPL; you could then use that word, instead of bye to debug your program

Work flow

1. open your text editor
2. open a command prompt / terminal
3. switch to the directory where your source is stored
4. create, add or modify a small piece of code in the text editor; never change big pieces of your program at once, because then it is very difficult to track bugs
5. start your program in the command prompt / terminal:    8th   progname.8th
6. check the results of your program
7. go back to step 4

Our first program

In the text editor I now show you the first (very simple) program:

We then open a Command Prompt or Terminal, change to the directory where the source is located and then start the program:

Namespaces revisited

In the program we used the with: word. Doing so, 8th will search for words and variables  in this namespace as well.

If you don’t use with: you will need to qualify the defined words / variables in such a namespace. In this example case: @arie.space:squared

NOTE that it is possible to have the same word or variable name in different namespaces. In that case the word found first (in the search order of 8th) will prevail!

Conclusion

Of course this is just the beginning. You should get acquainted with this stuff and try out small snippets of code.

Do not hesitate to sprinkle .s words throughout your code. That way you can easily see what is happening on the stack!

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

You can watch the complementary video here: https://youtu.be/SmiRwTNWkSs

Lesson 10 – Create your own words in 8th

A first step towards real programming in 8th

In every programming language there is something like a subroutine, procedure and/or function. I will call this lot “function” hereafter.

Such functions consist of a piece of code in that language. In many cases you can have local variables in such functions.

On entry such functions can get input arguments / parameters. Also in some cases some output can be returned and / or printed in one or another way.

Functions in 8th are called words

In 8th there is an equivalent to functions, called words.

Since, as we already know, 8th is built around the stack concept, almost all words fetch their input from the stack and push their result(s) back onto the stack.

Since 8th does not have local variables, we should use namespaces to create manageable subsets of words and variables.

Unspoken rules when defining words

When we define a word ourselves a set of “rules” should be followed:

1. define your own words in a separate namespace (previous lesson)
2. create documentation, at least in the form of a SED
3. keep your word short
4. your word should comprise a small, easy to understand, task
5. your word should be as readable as possible

How to define a word

In order to create a new 8th word, we need 2 more words:

• : (the colon) to start a word definition
• ; (the semi colon) to end a word definition

So a word definition in it’s bare form looks like this:
: <name> <code> ;

NOTE that every 8th word must be space delimited, including these 2 words!

A first example

We will create a word add3 that adds 3 to it’s input argument and prints the result.

The SED would be:
add3 \ n –

and the definition:
: add3 3 + . cr ;

The reason that add3 does not leave any output on the stack is because the . word consumes the result of the + word. If you are in doubt you should look up the SEDs of these words!

Have a look at the REPL output:

Check that stack is empty.




Define add3.


Execute add3 with input 5.

Output is 8.



Stack is empty again.

Check the unspoken rules

As far as I can tell this word adheres to rules # 2, 3, 4 and 5 but not to rule # 1.

We can check that it is defined in the default namespace user.

When we execute words/ G: we will discover that add3 has been defined in namespace G.

Second example – using our own namespace

In this example we will use our own namespace myspace.

Check that stack is empty.



Switch to namespace myspace.
Define add3 word.

Test add3 with input 7.
Result is 10.


Check that stack is empty.

List all words in myspace.



Only one word namely add3 found in namespace myspace.

Some remarks about namespaces

You can also switch to already existing namespaces (not only new ones) like G:
ns: G

When you are in some namespace you may need to qualify your word name with the namespace it has been defined in, like: myspace:add3

Conclusion

It is very easy to define one’s own words.

But try to remember the unspoken rules. Not only they guide you to good coding habits, but they also protect you from very nasty errors, which are almost impossible to debug.

In my examples I showed the stack before and after execution. That was for a good reason.

You should not be ashamed to have a pencil and paper next to you when writing and testing a program. You should write down the expected contents of the stack before and after executing each and every (intermediate) word.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/
Corresponding YouTube videos here: https://goo.gl/6Ti2pI

Lesson 9 – Variables and namespaces in 8th

Global variables are undesired

In the programming world there is consensus about the rule that global variables should be avoided.

Global means that a variable can be seen and manipulated from any part of a program.

It is far better to have local variables. These can only be seen and manipulated in a specific small part of a program.

Variables in 8th

As we said in a previous lesson we have a special solution for this in 8th.
When we normally define variables (like we did before) these variables will be part of the namespace user which is the namespace where 8th stores variables and words by default. Example:

In line 1 we define the numeric variable named chris.

In line 2 we push the variable itself (not the contents of it) on the stack.

In line 3 you can see that the variable effectively is called user:chris.

Creating variables in your own 8th namespace

In 8th you can create your own namespaces freely. Example:

In line 1 we create and make active a new namespace called myspace using the ns: word.
For now this means that variables defined after making this myspace active, will be part of this namespace.

In line 2 we define a new variable named mike.

In line 3 we push the variable mike (the definition, not the contents) on the stack and display the stack

In line 4 we can see that mike now belongs to the namespace myspace, so the qualified name is myspace:mike

Qualifying names

In general it is best practice to qualify variables and words by namespace, like myspace:mike in the previous paragraph.

That way it is always clear what you mean.

The same applies to words. So it is better to use n:+ for addition than barely +.

Further use of namespaces

In a next lesson we will see that we can also create pieces of our own code, which will be called words, as is the case with standard 8th word definitions.

Those words can also be put in a desired (and/or self created) namespace.

Using standard (default) 8th namespaces

When you create new words or variables that rightly belong to one of the standard namespaces already defined in 8th, you can define your own stuff there.

However, in almost any case it is better to create your own separate namespaces. The main reason to do so is that the names you choose for your words or variables might already be taken by standard 8th.

Also you’d have to check with each and every new 8th version if new conflicting names exist.

Unique namespaces best practice

Namespace names can be split in multiple parts using dots between the parts.

Here we see that the namespace consists of 2 parts, @john and space1.

This is BTW a very nice naming convention for your own namespaces.

Use your own name preceded by 1 or 2 weird characters (like @) as a prefix and only create namespaces with that unique prefix.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/
Corresponding YouTube videos here: https://goo.gl/6Ti2pI

Lesson 8 – Variables in 8th

Two ways to initialize a variable

In 8th there are 2 words: var and var, which initialize a variable.

Retrieving a variable is done with the @ word.

var initializes a numeric variable giving it the initial value 0 (zero):
SED:  var \ <name> --

Example: 

 var, intializes a variable with the value in TOS at the time the variable is defined:
SED:  var, \ x <name> --

Example 1:

 So, x (from SED) has the value “my value” and <name> (from SED) is y.

Example 2:

Now we have redefined the variable y (in the same REPL session):

Note that:
• 8th explicitly shows that we overwrite the previous definition of the variable
• we redefined the variable with an other datatype, which is not a problem in 8th

Setting variables

You can set an already defined variable to a given value, using the ! word.
Example:









Note again that a variable can take values of any 8th datatype!

Characteristics of 8th variables

• 8th variables are “just containers”. Variables do NOT have a datatype. However the contents (or value) of variables always have a valid 8th datatype
• 8th variables are ALWAYS GLOBAL to the namespace they are defined in
• usage of variables should be MINIMIZED. In almost all cases you can do most of the work using the stack only.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

Watch complementary video here

Lesson 7 – Get help in 8th

Getting help with 8th

If you have looked into the 8th manual, you’ll be aware of the fact that there are a lot of words (functions) defined in 8th.

In order to find information quickly, there are a few helper words to accomplish that.

Extended SED (Stack Effect Diagram)

First we need to complete your understanding of SED’s.

Because SED’s are used to document the behaviour of words we need to extend it a little. We saw that:
• The items before the dashes are the “input” items on the stack
• The items behind the dashes are the “output” items on the stack

However, there are also words that take information directly from the REPL. In that case there is a special form of “input item” in angle brackets. Such item has to follow the word immediately.

The word help

help \ <name> --
Example: help apropos

The result is the documentation for the specific 8th word apropos.

NOTE: <name> must be a valid 8th word

The word apropos

apropos \ <text> -- 
Example: apropos  cls

The result of this is a list of documentation sets on all the words having the piece of text “cls” in their documentation.

NOTE: <text> is just a piece of text which is searched for in the documentation of all 8th words.

The word words/

words/ \ <filter> --

Example 1: words/ n:

   The result of this is a list starting with the number of words matching the filter (in this case we
   request all words in the n: namespace) followed by the individual matching words

Example 2: words/ cls

 






Here we see multiple results.

Showing the contents of the stack

Last but not least there is the .s word, which we saw earlier.

That word is definitively very important to know what is going on in your program.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

Watch the complementary video here

Lesson 6 – A look at datatypes and namespaces in 8th

Updated version of this lesson

Because of a few breaking changes in 8th, this lesson uses some new specs:

• before 16.02 new words and variables were stored by default in class G 
• from 16.02 onward they will be stored in the default namespace called user
• Before 16.03 the term class  and cls: was used
• From 16.03 onward we use the term namespace and namespace ns: instead

A last remark on calculations

In the previous lesson I used the term operator for the + - * and / word. As far as 8th is concerned these words are not special. Those words just happen to act as operators.

Datatypes

So far we have only used (whole) numbers in our examples.

In 8th there are a few basic datatypes:

• Numbers;    some examples:
• -11.3   gives -11.30000 (float)
• 22.3e-3 gives   0.02230 (e notation)
• 22.3E-3 gives   0.02230 (e notation)
• 12      gives   12      (integer)
• 0xff    gives  255      (hex)
• 0Xfe    gives  254      (hex)
• $10     gives   16      (hex)
• &77     gives   63      (octal)
• %1111   gives   15      (binary)
• #123    gives  123      (# forces decimal base)
• Strings like “The big brown fox”. The \ (backslash) may be used as an escape character for:
• "       double-quote    ASCII 34
• a       alarm           ASCII  7
• b       backspace       ASCII  8
• f       formfeed        ASCII 12
• n       newline         ASCII 10
• r       carriage-return ASCII 13
• t       tab             ASCII  9
• v       vertical tab    ASCII 11
• x       next 2 chars are hex digits (\x20 is space)
• u       next 4 chars are hex digits (\u201c is “)

But there are a lot more (and more advanced) datatypes as well.

8th namespaces

As you may know, a lot of programming languages have namespaces.

A namespace is what it says, a separate space for names. That means that you can use the same name for different words or variables, but then they have to be in different namespaces.

In 8th, when you define a word or create a variable, these will always be defined in some namespace.

If you don’t specify in which namespace, they will be stored in the default namespace named user.

An example to clear the fog

The datatype number belongs to the namespace n.

All words related to numbers are grouped together in that namespace. That means the following:
• words like   +   -   *   etc. are defined in the n namespace
• those words are actually the words   n:+   n:-   n:*
• the n is the namespace, the colon : separates the word from the namespace
• this allows that there are other words called   +   *  -  in another namespace!

An example of a word having the same name in another namespace is   s:+   The namespace s is the “string” namespace and   s:+   happens to be string concatenation.

Standard namespaces in 8th

There are a lot of namespaces already defined in 8th. We will encounter them later. Have a look in the 8th manual!

You, being the developer may freely add new words to an existing namespace.

User defined namespaces in 8th

The developer may also freely define new namespaces.

That way a neat way exists to separate different pieces of code and avoid clutter and duplicate names.

This is especially important because 8th does not have the concept of local variables. You could say: namespaces are the 8th way of having local variables.

Intermezzo

When we wish to print the item at TOS (Top Of the Stack) we can use the  .  (dot) word.

In order to print a newline we use the   cr   word.

Without cr the next prompt is “glued” to the output.



With cr the line is terminated neatly.

Representation of a namespace

Internally a namespace is represented by a unique number.

It is easy to determine the namespace for a given item using the word >kind like so:

• 1 >kind . cr     \ gives 1 (represents the n namespace)
• “abc” >kind . cr \ gives 2 (represents the s namespace)

More info about 8th

There is a central website for 8th here: http://8th-dev.com/
Correspondig videos: https://goo.gl/DscYVD

Lesson 5 – Easy calculations in 8th

Infix notation

When we learn to calculate in school, we learn the infix method.

Example:     2 + 3     (which is 5).

In this example the + operator is between the 2 numbers to be added together.

Postfix notation as used in 8th

In 8th (and other Forth dialects) we always use postfix.

Example:     2 3 +      (which is 5).

The SED of + is \ x y – z which means: + takes 2 values (x and y) from the stack, calculates the sum (z), and puts that result back on the stack.

As we saw earlier when we enter 2 3 these two items are put on the stack. Look at the REPL:

Here we enter the two data values 2 and 3 on the stack.


Here you see these 2 values (right hand column).

Now we execute the + word.

The original items are gone and the result value of + is now on the stack.




8th allows us to enter such expressions differently:

All these 3 methods are equal as 8th is concerned.

More calculation operators

Now we have seen one calculating word in action it should be easy to try other words as well. We will show you a few in the REPL.

Subtract using the – word
SED of – is \ x y – z where z = x – y.

Multiply using the * word
SED of * is \ x y – z where z = x * y.

Divide using the / word
SED of / is \ x y – z where z = x / y.

As you can see in those examples we can also issue the .s word on the same line as well. 8th really doesn’t matter!

Operator precedence

In most programming languages there is an impressive chart of the operator precedence rules. That chart tells you what to expect when you enter an expression like this: 24 - 8 / 2 + 3 * 4

In most languages the rules say:  first multiply, then divide, then add and subtract. So the result would be (step 1) 24 - 8 / 2 + 12 = (step 2) 24 - 4 + 12 = (step 3) 32.

In 8th we don’t need such a chart, since it is chrystal clear what is going to happen:
24 8 2 / - 3 4 * +

When 8th evaluates this it evaluates from left to right:
1. evaluate 8 2 / and put 4 back. So the resulting expression is: 24 4 – 3 4 * +
2. evaluate 24 4 – and put 20 back. So the resulting expression is: 20 3 4 * +
3. evaluate 3 4 * and put 12 back. So the resulting expression is: 20 12 +
4. evaluate 20 12 + and put 32 back. The result 32 is left on the stack.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

Watch the complimentary video here

Lesson 4 – Explaining the implementation of the stack

Further explanation of the .s word

In the previous lesson we saw the .s word in action in order to show the contents of the stack. In reality the stack uses pointers. In the picture you see what happens when dup duplicates an item on the stack.

When dup copies Item 3 it only copies the pointer to Item 3. So after the dup, both topmost items contain equal pointers to the memory address of Item 3.

How does it look in the 8th REPL?

We’ll now show you the same thing in the 8th REPL.

The columns in each line in the output of .s have this meaning:
1. index of the item. Item at the bottom always has index 1 and so on.
2. class of the item. We’ll explain that later. (n: is numeric)
3. memory address where this stack item points to
4. reference count for this item
5. value of this item

This picture makes it clear that after the dup the 2 topmost items point to the same memory address.

Also after the dup the reference count was incremented from 1 to 2.

Why reference counting?

Reference counting is the means 8th uses to know when an item can be disposed off, namely when the reference count has become zero.

The process to remove such unused stuff is called garbage collection. It save the programmer a lot of manual work.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

Watch the complementary video here

Lesson 3 - Manipulate the stack

Introduction to the SED (Stack Effect Diagram)

In order to know what a specific 8th word does with the stack, there is a special kind of documentation, called a Stack Effect Diagram for each 8th word.

We always precede the SED with a \ (this is the 8th word to start a comment).

Then follow the relevant items on the stack before the word is invoked. Behind that is  a double dash – which in turn is followed by the relevant items on the stack after executing the word.

The next paragraphs explain some 8th words together with their SED.

drop \ x – 
Remove the item at TOS.  You can see that in the SED. Before executing the word drop the item x is at TOS and afterwards it is completely gone.

2drop \ x y –
Same as drop, but now 2 items are dropped.

dup \ x – x x
Duplicate the item on TOS.

2dup \ x y – x y x y
Same as dup, but now 2 items are duplicated.

nip \ x y – y
Remove the second item on the stack.

over \ x y – x y x
Copy the second item on the stack to TOS.

swap \ x y – y x
Exchange the two topmost items on the stack.

tuck \ x y – y x y
Copy the item at TOS and put it in third position.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

Watch the complementary video here

Lesson 2 - Using the data stack

What is a stack?

To explain what a stack is and how it can be used, I drew this picture.

Imagine a vertical round pole fixed to the middle of a round bottom plate.

Also imagine round items that can be put on the stack, because those imaginary items have a round hole in it to fit around the pole.

At first the stack is empty.

You then can put item 1 on the stack, by pushing it over the pole, until it rests at the bottom plate.

When you then push item 2 on the stack in the same way, item 2 is right on top of item 1. Item 3 can then be pushed onto item 2.

When you want to remove item 3 in the picture, there is no problem. However, when you want to remove item 2 or item 1, you first have to remove all items on top from the stack before you can do that!

How is the stack used in 8th?

The stack is only used to temporarily store individual data items. Therefore it is often called the data stack.

In 8th we call all native and all self defined functions or procudures words.

There are quite a lot of words which can manipulate the stack.

Pushing items on the stack in 8th

The .s word shows the current contents of the stack. Right now it is empty.
Now we enter the values 1, 2 and 3.

With .s we now can see that 1 is at the bottom of the stack and 3 at the top (TOS).
When we enter another value (4) that item lands at TOS.

Instead of entering 3 values in a row, we could also enter those values one by one. It makes no difference.

With the reset word we clear the stack. All items are removed.
Afterwards the stack is empty again.

More info about 8th

There is a central website for 8th here: http://8th-dev.com/

Video

Watch the complementary video here

Lesson 1 - Introduction

What is the aim of this video series?

Being very impressed with 8th and it's capabilities, I decided that the world should know about it.

What I hope to achieve with these short and to-the-point video lessons is:

• teach you 8th bit by bit

• maybe "convert" you to 8th 

The setup for each video will be exactly the same:

• on the left side there is the 8th REPL for interactive development

• sometimes on the left side there is also an editor window for program source

• on the right side I display what I am telling about (this text area)

What is 8th?

8th is a remarkable development tool and programming language.

With only this tool (nothing else needed) one can develop:

1. mobile, desktop, server and embeddable apps

2. using a built-in cross-platform GUI with very easy specification

3. very fast, because there is a REPL

4. secure, encrypted apps

5. cost effective (only 8th is needed; no other tools)

Is 8th expensive?

No. 8th is a commercial product, but it is really cheap.

After buying a license, you can develop apps and deliver the same app to multiple platforms. There are no extra license fees per platform or per sold app.

Free version of 8th

There is also a free version of 8th.  The only restriction it has is that you cannot create encrypted apps.

Where can I find 8th?

There is a central website for 8th here: http://8th-dev.com/

Where can I contact the 8th community?

There is a nice and friendly forum here: http://8th-dev.com/forum/

The main developer of 8th is almost always around on the forum, except for the few moments that he sleeps. He always answers each question promptly. Bug fixes are done lightning fast, which is a real blessing.

How is 8th related to other programming languages?

In 1968, while employed at the United States National Radio Astronomy Observatory (NRAO), Charles Moore invented the initial version of the Forth language to help control radio telescopes.

Forth has been used for many purposes, mostly as an embedded language in high end devices. It was (is) used by NASA and the DOD im America.

Forth is a stack based language and has very tight control over the hardware it runs on.

8th is a descendant of Forth, but has much more to offer. Also 8th is much easier to use, because it operates on a higher abstraction level than most Forth dialects.

Video

Watch the complementary video here

BLOG and VLOG as a team!

In the previous post I told you about my 8th video channel on YouTube here

Now I have decided to keep this BLOG in sync with that YouTube VLOG, using the documents I show in the video. That way people can watch the video and also read the document I show there at their own pace.

Because there are already 8 video's on YouTube, I will start to create 8 new posts first.
Each post is called a "lesson".

See you in the next BLOG or VLOG post!

Have a look at the new 8th Video Series on Youtube

Since the last post, I've been busy creating 8th video lessons on YouTube.

Personally, when I am in the process of learning something, I alway look out for videos on the subject. In a lot of cases they can give you a head start.

Because this BLOG has so much overlap with the VLOG on YouTube, I will concentrate on the VLOG for now.

I hope to come back here later. In that case I will post about more advanced 8th subjects.

Please follow me on YouTube for now!  https://www.youtube.com/channel/UCcwRyVDxU-lMfWgz_10DudA