Day 3:

Ok, today i have less time to dive into this madness, so instead of trying to make something work, i think what i might need is to understand the basics of the language.

In fact, the language compared to other has very few "functionalities", the manual in fact says 

"INTERCAL’s main advantage over other programming languages is its strict simplicity. It has few capabilities, and thus there are few restrictions to be kept in mind."

But because of fear i didn't dive into all of the basics.

[This episode may be a little more boring, i'm sorry but i have to understand something before going on, otherwise we will just stay stuck here. This episode will be a bit technical]

Variables

INTERCAL allows as variables only two types:

-) 16-bit unsigned integers, wich means the ram memory stores this number as a sequence of 16 bit, and so these kind of variables can be only numbers between 0 and 65535

-) 32-bit unsigned integers, wich means ram memory stores them  with 32 bits, and so they can be a number between 0 and 4294967295

16-bit is declared with '.' and 32-bit with ':'

Constants

The number we used until now, they were written as '#' followed by the number.

However the manual states that variables can be only 16-bit values, and so we cannot write #65536 because it cannot be rapresented with only 16-bits

[Note: how do we get 32-bit values then? i'm not yer sure, but i think we will use the binary operations explained later]

Arrays

For non programmers this may be a new concept, but it's pretty simple. An Array is a "list" of elements, all of the same type, and they are stored consequently in memory, to each of them is assigned an intex, usually index starts from 0, so the first element of the array has index 0.

However INTERCAL starts from 1.

An array is declared with the ',' symbol if the elements are 16-bit numbers and ';' if the elements are 32-bit numbers.

--------------------------------------------------------------

Binary operators:

Now, this section is twice as a nightmare for me, because i not only have to deal with INTERCAL's bullshit, but also with all the knowledge i don't have because i didn't use to program that much in 1972.

There are two binary operators:

-Interleave, symbol: ȼ, also called 'mingle' (i imagine how much funny this must have been in '72, they probably laughed their asses off so much because of calling this operator "mingle").

-Select, symbol: ~

--------------------------------------------------------------

Minor symbol problems:

These two symbols are not present on a normal european keyboard, i know that ~ is on american keyboard, i know it because i already had problems with it in the past, so i already knew the code for it. While i never had problems with ȼ so i had to search a bit around to discover what the code is.

To input those to you need to press down "alt" key (if you're on an Apple machine...i have many things to tell you, but how to type ~ and ȼ is not part of them), and then input a code with the numpad.

~ = Alt + 126  |  ȼ = Alt + 572

Since binary operators seem a bit complicated we will go trough them one at a time, so i'll start with the mingle:

--------------------------------------------------------------

Mingle:

To start i will just show you what the maual says:

"The interleave operator takes two 16-bit values and produces a 32-bit result by alternating the bits of the

operands. Thus, #65535c/#0 has the 32-bit binary form 101010....10 or 2863311530 decimal, while #0c/#65535

= 0101....01 binary = 1431655765 decimal, and #255c/#255 is equivalent to #65535."

Ok, fellow programmers may realize this is not complicated, is just a weird way to do things, for non programmers, let me explain you:

a 16-bit value looks like this: 1001110101100101

Meaning it is a series of 1s and 0s, 16 of them. the 'mingle' operator takes two of these kind, an "combines" them into a 32-bit number.

How it combines them? 

Let's talk with 4-bits numbers, so it's easier, 4 in binary is 0100, while 1 in binary is 0001. if we do 4ȼ1 it means 0100ȼ0001, what the mingle does is combine these two into a number twice the size, so the result will be 8-bits. To do this, it takes the first bit from the first operand, then the second but from the second bit from the second operand, the third from the first operand again, the fourth from the second operand again, so 0100ȼ0001 becomes 00100001 wich is 33 in decimal.

let's do another example not related to binary numbers just to show the process, let's say we do 1234ȼ5678, what we get is 15263748 clear? ok, hope it is, let's go on with some considerations:

1) when we do the ȼ operation with two 16-bits numbers, everything is fine

2) when we do the ȼ operation with two 32-bits numbers, we will get an overflow, and so we will have a somehow "different operation", this is because, if we do :1ȼ:2 we would have a result wich is twice the size of 32-bits, so 64-bits, wich in INTERCAL doesn't exist, so what (i suppose) will happend is that the operation is done up to the 32nd bit, and the rest is just truncated.

3) this operation is very useless, however, since we don't have sum and multiplication, we should be using those binary operations to get the "same results", because eventually, when we become very good at it, we should stop using the standard INTERCAL subroutines and do it by ourselves.

Select

The select operator is ~, and the manual says a lot about it...

"The select operator takes from the first operand whichever bits correspond to 1’s in the second operand,

and packs these bits to the right in the result" 

and then on the left is all zeroes.

Let's try to explain with another example:

Let's way we want to do 1100~0110 what we get is 0010

I can't explain with different numbers, because it strictly has to do with 1s and 0s, so, i'll show it in another way, i will wrtie the operation just told, with writing underneath the position of each bit into the value, so

1100~0110

1234 1234

what we do is, we go see what positions are occupied by 1s in the second operand, wich are the positions 2 and 3, we take the bits in those positions in the first operands, wich are 0 for position 2 and 1 for position 3, we write them and we add zeros on the left to complete the 4-bit so we have 0010.

btw this is how the manual explains this:

Hope the picture is showing, otherwise you can find it on the english page of wikipedia regarding intercal, wich is at this link

https://en.wikipedia.org/wiki/INTERCAL#/media/File:INTERCAL_Circuitous_Diagram.svg

(as an informatics and cybersecurity fan i suggest to not open links you find laying around, i leave it because i know it's just the wikipedia link, but honestly, you shouldn't open it, just search it by yourself)

Conclusion:

So after this there are the logical operators, and honestly i don't have the patience to go trough them now, i will leave them for when i am more mentally prepared.

So, goodbye, this (boring) episode is over, tomorrow we will do something more interesting, i'll try to start with coding directly.