Learn how to count in any numbering system

In this blog post, I will teach you how to count in any numbering system. I have also created a program that counts in any numbering system and I will show you this program in the second part of this blog post.

I have  a shared folder pertaining  to this blog post that you are free to visit and download its contents. You may visit the shared folder at the following link: Count in any numbering system. In this folder, you will find:

  • An Excel spreadsheet with two tabs, that may help you in your learning.
  • A text file that contains the source code of the program (in C# with .NET framework version 2.0) that counts in any numbering system.
  • A zip file that contains the complete Visual Studio Windows Forms C# project (that also contains the source code of the program that counts in any numbering system.)
  • An executable file, which is the Windows program that counts in any numbering system. You can copy the executable file in any folder of your Windows OS and run it. It needs no installation, but you need to have the Windows .NET framework (version 2.0 at least) in order to execute the program.

OK. First things first: How to count in any numbering system.

We (humans) use the base-10 numbering system. Why? Well, all numbering systems are equivalent, but we chose the base-10 numbering system because we have ten fingers, and we find counting in tens to be more intuitive and convenient. We are used to counting in tens, so we chose a numbering system that corresponds to this counting manner.

If we were a species with three fingers (three fingers altogether, and to keep the symmetry we might have had three hands, each hand having only finger, or only one hand with three fingers, or even two hands, one with two fingers and the other hand with only one finger, but then these two hands might be in opposite directions in order to keep the symmetry of our body) we might have chosen to use the base-3 numbering system for counting, because we would want to count in threes.

The smallest base that can exist is base-2. In base-2, we have two digits: 0, 1.

In base-3, we have three digits: 0, 1, 2.

And so on.

In base-10, we have 10 digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

In base-11, we have 11 digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A. (We use letters because we run out of number symbols. Actually we may use any symbol for any number. So, if, for example, we replace 0 with &, and 1 with *, and 2 with %, etc, we will have an equivalent representation).

In base-16, we have 16 digits:  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

And so on.

Here is how to count in any-numbering system:

Example in base-2, which means that the digits are 0, 1.

Start from 0, which is equal to infinite zeros: …000000

Increase the rightmost digit.

...000000
...000001

When the rightmost digit cannot increase any more,
set the rightmost digit to zero
and increase the second rightmost digit.

...000010

Continue to increase the rightmost digit,
keeping the other digits as they are.

...000011

When the rightmost digit cannot increase any more,
set the rightmost digit to zero
and increase the second rightmost digit.
But if the second righmost digit cannot increase anymore,
set it to zero as well
and increase the third rightmost digit.

...000100

And so on:

...000101
...000110
...000111
...001000
...001001
...001010
...001011
...001100
...001101
...001110
...001111
...010000
...010001
.........

And so on…

Example in base-3, which means that the digits are 0,1,2.

Start from 0, which is equal to infinte zeros: …000000

Increase the rightmost digit.

...000000
...000001
...000002

When the rightmost digit cannot increase any more,
set the rightmost digit to zero
and increase the second rightmost digit.

...000010

Continue to increase the rightmost digit,
keeping the other digits as they are.

...000011
...000012

When the rightmost digit cannot increase any more,
set the rightmost digit to zero
and increase the second rightmost digit.

...000020

Continue to increase the rightmost digit,
keeping the other digits as they are.

...000021
...000022

When the rightmost digit cannot increase any more,
set the rightmost digit to zero
and increase the second rightmost digit.
But if the second righmost digit cannot increase anymore,
set it to zero as well
and increase the third rightmost digit.

...000100

And so on:

...000101
...000102
...000110
...000111
...000112
...000120
...000121
...000122
...000200
...000201
...000202
...000210
...000211
...000212
...000220
...000221
...000222
...001000
...001001
...001002
...001010
...001011
...001012
...001020
...001021
...001022
...001100
...001101
...001102
...001110
...001111
...001112
...001120
...001121
...001122
...001200
...001201
...001202
...001210
...001211
...001212
...001220
...001221
...001222
...002000
...002001
...002002
...002010
...002011
...002012
...002020
...002021
...002022
...002100
...002101
...002102
...002110
...002111
...002112
...002120
...002121
...002122
...002200
...002201
...002202
...002210
...002211
...002212
...002220
...002221
...002222
...010000
...010001
.........

And so on…

Additional notes:

So now you know how to produce the numbers of any base in ascending order. There is another way to produce the numbers of any base in ascending order. This is done by writing vertically each digit column starting from the rightmost digit column. So, you create the rightmost digit column by writing each number once starting from 0 then 1 and so on. When the digits finish, you start over. So, for base 2, you write:

....0
....1
....0
....1
....0
....1
....0
....1
.....

Then you create the second rightmost column by noticing the repeating pattern of the rightmost column and matching it with one digit in the second rightmost column, starting from zero. The repeating pattern of the rightmost column is 0-1. So you create the second rightmost column as follows:

...00
...01
...10
...11
...00
...01
...10
...11
.....

As you may notice, the repeating pattern of the second rightmost column is 0-0-1-1.

So you create the third rightmost column as follows:

..000
..001
..010
..011
..100
..101
..110
..111
.....

The repeating pattern of the third rightmost column is 0-0-0-0-1-1-1-1.

And so on.

For base-3, the repeating pattern of the rightmost column would be 0-1-2. The repeating pattern of the second rightmost column would be 0-0-0-1-1-1-2-2-2. The repeating pattern of the third rightmost column would be 0-0-0-0-0-0-0-0-0-1-1-1-1-1-1-1-1-1-2-2-2-2-2-2-2-2-2. And so on.

Counting is important and base-2 and bases that are powers of 2, especially base-16, are very important when dealing with digital electronics and computers in low-level.  Let me explain why.

First of all, computers are created as large bundles of electronic switches. Switches, electronic or otherwise, have two states: off and on. So, engineers assign the number 0 to one of the states and the number 1 to the other state (in a consistent manner, of course) and can set each switch to any state or read any switch’s state. That’s how computations are made at a low-level. So, binary arithmetic is essential to enginners for the programming and operation of a computer. The state of each electronic switch is either 0 or 1, and 0 and 1 are the “binary” digits, or bits as they called in computer parlance. Just for your information, each electronic switch is made up from a few transistors, which can me made really tiny. A computer chip may contain billions of transistors.

OK, so base-2 and the corresponding arithmetic (binary arithmetic) of this numbering system is important to computers, But why is base-16 (hexadecimal arithmetic) also important? Well, the numbering systems of the powers of the same base have an important connection. I will now explain what this connection is. For example, let us take the number 2. The numbering systems that are powers of 2 are: base-2, base-4, base-8, base-16, base-32, base-64, and so on. The conversion between any of these numbering systems to another such system can be easily done.

Here is how: Let us study base-2 and base-16. suppose we have a number in base-16, for example B8. What is this number in base-2? To answer, we will represent each of the hexadecimal digits with 4 binary digits, since we need 4 binary digits to represent the highest hexadecimal digit (F in base-16 is 1111 in base-2). So, we have the number B8, and B in base-16 is 1011 in base-2, and 8 in base-16 is 1000 in base-2. The important property of numbering systems of powers of the same base allows us to find a number’s equal in another such base, as follows: We substitute each digit from the higher base to the equivalent digits of the lower base, or we group the digits of the lower base to the equibalent digits of the higher base. In the case of the base-16 number B8, it is equal to 10111000 in base-2, where the first four binary digits correspond to B and the next 4 binary digits correspond to 8.

Another example: Given the base-2 number 110100011, what is the equivalent base-16 number? Well we will group the digits by four’s, starting from the right and adding leading zeros if we need to. So our number becomes: 0001 1010 0011. Substituting each group of 4 digits with its hexadecimal equivalent gives us the base-16 number 1A3.

This property is very important to computing and one of the reasons engineers chose to represent information in bytes. Each byte is an ordered set of 8 bits. By choosing bytes to be comprised of 8 bits each, it makes their representation very easy: Each byte can be represented by two hexadecimal digits. So a byte with the following value in bits: 00100100, can be represented as 24 in hexadecimal (base-16).

I found that knowing how to count in base-2 was enough to solve any IP (Internet Protocol) subnetting problem that I ever encountered! Of course, it will be very beneficial to you if you learn how to do other operations as well (beyond counting, like addition, subtraction, multiplication, division, transformation of a number from one base to another). And, if you will be dealing with computers, you may often encounter base-2 and base-16 number representations.

My program which counts in any numbering system

I created a program in C# that counts in any numbering system. I will present the code below and you can also download the code or even the complete Visual Studio project from the link I provide in the beginning of this blog post.

If you want to recreate the project yourself, just create a new project in Visual Studio as a Windows Forms C# application. In a form place two textboxes, a button and a DataGridView. You may also place two labels, to show what each textbox use is. And then, use my code as the form’s code.

You, may see what the form looks like below:

In the first textbox, you enter the base for which you want to count. Counting will start from 0 up to the number you want. You must specify this number in its base-10 representation in the second textbox. When you press the button, the program will create two columns in the datagridview. The first column will contain the numbers in base-10 for your reference and the second column will contain the equivalent numbers in the base you specified in the first textbox.

In the code you will see that there is a string (array of characters) called strDigitSymbols. These are the digits that the program uses to construct the numbers in the second datagridview column. So, even if the program “knows” for sure it “wants” to use a 0 or a 1 in the second gridcolumn, it will never put 0 or 1, but instead it will put  strDigitSymbols.Substring(0, 1) instead of 0 and strDigitSymbols.Substring(0, 1) instead of 1. This is because I want to let the user specify alternate symbols, should she wish to do so. Thus, whereas the “normal” strDigitSymbols would be “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”, the user is allowed to replace it with whatever string she wishes, for example “%#*@(F4SL!)-+0=”, No, this is not swearing, it is a string with 15 characters, which means that the program can count for bases up to base-15. The string I have put in the program contains 36 characters, which means that the program, as is, can count up to base-36. You can add more digits to the string, so you can request counting in even larger bases. The program can count up to the base that has the same number as the number of digits that exist in strDigitNumbers.

As for the first datagridview column, it is in base-10 for your reference and does not look in the strDigitSymbols to get its symbols. The program uses regular good old decimal digits for the first datagridview column.

Here is the code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Count
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            const string strDigitSymbols = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

            dataGridView1.Rows.Clear();
            dataGridView1.Columns.Clear();
            dataGridView1.Refresh();

            bool isNumerical;

            int intBase = 0;

            isNumerical = false;
            isNumerical = int.TryParse(textBox1.Text, out intBase);
            if (!isNumerical)
            {
                MessageBox.Show("The base number must be an integer equal or greater than 2", "Error in the base number: Not an integer.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            if (intBase < 2) { MessageBox.Show("The base number cannot be less than 2.", "Error in the base number: Too small.", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } if (intBase > strDigitSymbols.Length)
            {
                MessageBox.Show("There are not enough digit symbols to represent the numbers for the base number you requested.", "Error in the base number: Too big.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            int intMaximumCount = 0;

            isNumerical = false;
            isNumerical = int.TryParse(textBox2.Text, out intMaximumCount);
            if (!isNumerical)
            {
                MessageBox.Show("The number in base-10 to count up to must be a positive integer", "Error in the count number: Not an integer.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            dataGridView1.Columns.Add("Base 10", "Base 10");
            dataGridView1.Columns.Add("Requested Base", "Requested Base");

            dataGridView1.Columns["Base 10"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.BottomRight;
            dataGridView1.Columns["Requested Base"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.BottomRight;

            dataGridView1.Columns["Base 10"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.BottomRight;
            dataGridView1.Columns["Requested Base"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.BottomRight;

            string strPreviousNumber = strDigitSymbols.Substring(0, 1);

            dataGridView1.Rows.Add(0, strPreviousNumber);

            string strNextNumber;
            string strDigit;
            string strNextDigit;
            int i;
            bool blnFinished = false;

            for (int intCount = 1; intCount <= intMaximumCount; intCount++)
            {

                // We begin each for iteration with the strPreviousNumber set at the end of the pevious for iteration.
                // The goal of each for iteration is to find the strNextNumber, which is the number that succeds the strPreviousNumber.

                strNextNumber = "";
                strDigit = "";
                strNextDigit = "";
                i = 0;
                blnFinished = false;

                // We will get each digit of the previous number starting from the right of the previous number,
                // using i as the counter to access the digits of the previous number.

                while (true)
                {
                    // Get next digit of the previous number from the left.

                    strDigit = strPreviousNumber.Substring(strPreviousNumber.Length - 1 - i, 1);

                    // For the digit obtained, find the coresponding digit that succeeds it,
                    // using j as the counter to scan strDigitSymbols.

                    for (int j = 0; j <= intBase - 1; j++)
                    {
                        if (strDigit == strDigitSymbols.Substring(j, 1))
                        {
                            // We found the digit and now we will take the corresponding digit that suceeds it and then we will break from the inner for loop.

                            if (j < intBase - 1) { // If we are here, it means that we have the "normal" case where the next digit is greater than the previous digit. // Example in Base-10: strDigit = "6", thus strNextDigit = "7". // Because this kind of incementation will happen, we will set blnFinished to true, in order to break from the while loop. strNextDigit = strDigitSymbols.Substring(j + 1, 1); if (strPreviousNumber.Length - 1 - i > 0)
                                {
                                    // If we are here, it means that there are more digits of the previous number to the left of the digit we are processing.

                                    strNextNumber = strPreviousNumber.Substring(0, strPreviousNumber.Length - 1 - i) + strNextDigit + strNextNumber;
                                }
                                else
                                {
                                    // If we are here, it means that there no are more digits of the previous number to the left of the digit we are processing.

                                    strNextNumber = strNextDigit + strNextNumber;
                                }

                                // We finished processing and we need to break from the while loop.

                                blnFinished = true;
                            }

                            if (j == intBase - 1)
                            {
                                // If we are here, it means that the next digit is the first in strDigitSymbols.
                                // Example in Base-10: strDigit = "9", thus strNextDigit = "0".\
                                // Because this kind of incementation will happen, we will not set blnFinished to true, in order to continue looping in the while loop.

                                strNextDigit = strDigitSymbols.Substring(0, 1);
                                strNextNumber = strNextDigit + strNextNumber;
                            }

                            break; // Break from the inner for loop.

                        } // End of the outer if statement.

                    } // End of the inner for loop.

                    if (blnFinished == true)
                    {
                        break; // Break from the while loop.
                    }

                    i++;

                    if (i == strPreviousNumber.Length)
                    {
                        break; // Break from the while loop because there are no more digits to process.
                    }

                } // End of the while loop.

                if (blnFinished == false)
                {
                    // If we are here, it means that all digits have been turned to zero,
                    // so we need to add a "1" in front of all these zeros.
                    // Example in Base-10: strPreviousNumber = "9999", thus strNextNumber = "10000".

                    strNextNumber = strDigitSymbols.Substring(1, 1) + strNextNumber;
                }

                dataGridView1.Rows.Add(intCount, strNextNumber);

                // We begin each for iteration with the strPreviousNumber set at the end of the pevious for iteration.
                // The goal of each for iteration is to find the strNextNumber, which is the number that succeds the strPreviousNumber.

                strPreviousNumber = strNextNumber;

            } // End of the for loop.

        } // End of the button1_Click.

    } // End of the class.

} // End of the namespace.

The outer for loop is used to count from 0 to the decimal number in the second textbox. This represents up to how many numbers we will count. The counter for this for loop is a regular decimal numbers and is used to populate the first datagridview column for your reference. In each outer for loop iteration, the program finds the number that will go in the second datagridview column, based in the base you requested in the first textbox. How does the program find the number in the requested base? Well, the first number is 0, or, rather, the first number in strDigitSymbols. In each outer for loop iteration it uses the knowledge of  what the previous number was and it scans the previous number’s digits as well as the strDigitSymbols digits, to deduce the “current” number.

The program never breaks form the outer for loop. The loop continues until it reaches the number you have specified in the second textbox.

In each for loop iteration, the program uses a while loop to scan the digits of the previous  and an inner for loop to scan the strDigitSymbols. This way, the program can deduce the next number in the sequence.

The program is heavily commented, so you may understand its inner workings.

Advertisements
Posted in Development

Ellis Island in perpetuity

Tl;dr: When speaking about a Greek male, use his name including the final “s” in his name. When speaking to a Greek male, address him by omitting the final “s” in his name. When you ask a Greek male “What’s your name?”, expect him to include the final ”s” in his name. When you ask a Greek male “What do they call you?”, expect him to omit the final “s” in his name. All these rules follow from the Greek language grammar and are valid for both first and last names.

I think that you must be very puzzled after reading the title and the abstract (tl;dr). What does Ellis Island, perpetuity, and some obscure Greek grammar rules about name calling have to do with each other?

Well, let me explain.

When I watch American movies or American TV series, I sometimes look at the credits. And sometimes I find Greek names there. And other times I find names that might as well be Greek, but I am not sure. Obviously, Greek names are spelled according to the grammatical rules of the Greek language. If I find small discrepancies and deviations from the Greek grammar in a name, I cannot be 100% sure this is a Greek name.

But I have a theory as to why some of these names, that might be Greek, actually are.

Let me use an example. Suppose I watch a movie and in the credits I see the name “John Athanasio”. In such a case, I immediately start shouting: “Ellis Island! Ellis Island!”. Why do I do that and what do I mean?

To cut a long story short, I make the assumption that in the old days, a Greek person whose first name was “Athanasios” came to America crossing the ocean in a boat, being miserable, tired and malnourished. Before arriving at the States, he was taken to Ellis Island to be examined and to be given new identification papers.

Athanasios, unable to speak the English language, barely understood what was happening around him. At some point, the officers there wanted to provide him with identification papers, in order to release him to New York, his new home.

So, they the officers called an officer or interpreter who spoke Greek, to help them communicate with Athanasios.

Perhaps, there was no officer there who actually spoke Greek. There might have been someone there who only knew how to formulate the most basic questions in Greek.

Anyway, the translator would try to communicate with Athanasios. So, what would the translator ask Athanasios? The translator would first ask for Athanasios’ name.

Well, here we have a problem. How would the translator ask Athanasios about his name?

He could ask Athanasios in Greek: “What’s your name”. Or he could ask Athanasios in Greek: “What do they call you?”.

In English, the most common phrase to ask for the other person’s name is “What’s your name”. If Athanasios was literally asked that in Greek, he would answer “Athanasios”.

In Greek, the most common phrase to ask for the other person’s name is “What do they call you?”. If Athanasios was literally asked that in Greek, he would answer “Athanasio”. Please note the omission of the final “s”.

I assume that the translator had asked a Greek person how to say “What’s your name”. The Greek person told him to say “What do they call you?”. This answer is correct in the respect that, the most common way to say that in English is translated to the most common way to say that in Greek.

But the answer is incorrect in the respect that it is not literal.

“What is your name?” literally translated in Greek yields the response: “Athanasios”. “What do they call you?” literally translated in Greek yields the response: “Athanasio”. Again, please note the omission of the final “s”.

To yield the desired response, the translator should have been literally asking “What is your name?” in Greek, which, by the way, in Greek, is less frequent and more awkward than “What do they call you?”.

Suppose we have a Greek male whose name is “Athanasios. ”When another native Greek wants to find this male Greek’s name, they ask him: “What do they call you?”. He will answer: “Athanasio”. Then they will know that his name is ”Athanasios”.

I suppose that level of sophistication eluded the translators in Ellis Island. Perhaps they had a few “canned” questions translated in many languages. And, unfortunately, the person that translated “What’s your name?” in Greek, should have had the foresight to insist on translating not the question “What’s your name?” but the question “What do they call you?”.

This is because “What do they call you?” yields the correct name, instead of “What’s your name?”, which yields the name without the final “s”.

So, poor Athanasios, disoriented and tired, at some point in his Ellis Island stay, heard a few words in his native language: “What do they call you?”. Rejoicing, he replied: “Athanasio!”.

Scribble, scribble, scribble… Inscribed. Papers ready.

Now, you might think that my fictitious story is quite unrealistic.

First of all, you would think that the officers in Ellis Island did not only want the first name of Athanasios, but also his last name. And, of course, you would be right in your thinking. I just used only the first name as a tool to make emphasis. Writers are allowed to do that.

Ok, so more realistically: Suppose Athanasios full name is Athanasios Samaras, a common first name and last name in Greece. So, they ask Athanasios: “What do they call you?”. Rejoicing, he replied: “Athanasio Samara!”.

Scribble, scribble, scribble… Ok, you know the rest.

Please notice the absence of the final “s” from both the first and the last name of Athanasios.

By now, you might have guessed how the story ends and you might also have another objection.

Athanasios goes out into the world (of New York) and after many years of struggles, he manages to become a respected member of the community. But everywhere he went, people looked at his papers and told him not to confuse them: “Don’t confuse us! You said your name is ‘Athanasios’, but your papers write ‘Athanasio’. Be careful, or we might think you are a liar.”

So, poor Athanasios, desperately trying to fit in, would gladly accept what his papers were saying and would also gladly repeat it.

And after many years, he had children and grand children and so on, and they inherited his legacy and story and name, and yes, first name as their last name!

This might have been your objection all along: How come a first name can become a last name?

Obviously, most probably, the descendants of Athanasios would have inherited his last name: “Samaras”, or rather, “Samara”, as it was erroneously written down in Ellis Island. But there is also the chance that Athanasios was so important to his family tree and to others in the community, that knew his family tree, that his family tree started being identified by him. After all, he was the first one in America.

So, sometimes it just so happens that the family may also change its last name in order to denote the first name of the man who started the family tree in America.

Recapitulation: The correct way to write and say the name is “Athanasios Samaras”. The question: “What’s your name?” in Greek, yields the answer: “Athanasios Samaras.” The question: “What’s your name?”, yields the answer: “Athanasio Samara.” So, when a Greek hears the response “Athanasio Samara” they know that his name is “Athanasios Samaras”. The problem is that, usually, the question in English for someone’s name is “What’s your name?” and the question in Greek for someone’s name is “What do they call you?”.

I just want to add that it is nice to have foresight and empathy. It is nice to think ahead and above and beyond. If a Greek person was asked to provide canned questions to the officers at Ellis Island, this person should have had the foresight to go against the normal way to speak Greek, providing the phrase “What’s your name?” in Greek, instead of the phrase “What’s your name?” in Greek.

But people aren’t usually so perceptive or caring.

Posted in Management

Individual bit manipulation techniques in assembly

The unit of information is the bit. It takes only one binary digit, either the value 0 or the value 1. A byte is comprised of 8 bits.

People created the byte as an ordered set of 8 bits. And they used the byte as the unit of addressable information. By that, I mean that each memory address in a computer points to a byte, not a bit.

So, memory address number 0 points to the first byte in memory. Memory address number 1 points to the second byte in memory. And so on. And the same holds true for storage. In storage, whole bytes are stored and retrieved, not individual bits.

This is for efficiency. Thus, a byte is treated as the smallest bundle of information. I guess, when people first created the bundles of information that they would use, they made an ingenious decision.

The unit of information was the bit, but to use a small ordered bundle of bits to hold an encoding of a letter or number or punctuation symbol, they would need more than four bits. This is because 4 bits correspond to 2^4=16 different permutations. And the English alphabet alone is 26 letters. Add 10 for the individual digits of the numbers (0 to 9) and add more for the punctuation symbols and other control characters that they needed for the operation of the computer (line feeds, etc.), people saw that 2^7=128 permutations were needed, which correspond to 7 bits per byte, since one byte would correspond to a letter or number or punctuation symbol or control character.

Electronic components were scarce the days those decisions were made. So 7 bits per byte would be perfectly adequate. But people made the ingenious decision to use 8 bits per byte. 8 is a power of 2, so people could calculate sizes in either bits or bytes and use the same base (2). Also, a byte could represent more symbols of information (2^8=256 permutations). Another huge reason that a byte was made to comprise of 8 bits was that in this way a byte could be represented with two hexadecimal numbers. Let me give you an example. The byte 10011110 can be represented as 9E in hexadecimal notation, since 1001 in binary is 9 in hexadecimal, and 1110 in binary is E in hexadecimal.

So, people used the concept of the byte as an ordered set of 8 bits to hold the smallest amount of information that they would address or store. A byte (which is comprised of 8 bits) would represent a character or a number from 0 to 9 or a punctuation symbol or a computer control character or another graphical symbol from a small set of predefined symbols. And of course, if a single byte would be considered to contain a purely numeric value, this would be from 00000000 in binary or 0 in decimal to 11111111 in binary or 255 in decimal.

According to all the above, it will be no surprise to learn that assembly commands also operate on full bytes. So, how will you be able to manipulate a byte’s individual bits, if the need arises?

In this blog post, I will teach you exactly that. I will show you how to use assembly commands to manipulate each individual bit of a byte. All we need in order to understand the concepts, is to study the truth tables of AND, OR, and XOR.

AND

Truth table for AND
-------------------------------------
Input bit   Input bit   Resulting bit
0           0           0
0           1           0
1           0           0
1           1           1

From the above table, we can gather the following:

If you AND any bit with 0, the result is 0.

If you AND any bit with 1, the result is the bit.

Therefore, AND can be used to set any bit of a byte to 0, regardless of the bit’s previous value.

Here is how: Suppose we have a byte and we want to set one or more of its bits to 0. All we need to do is to AND the byte with a byte that has 0’s in the bit positions that we want to set to 0 and 1’s in the bit positions that we want to remain unchanged.

Example question: Given the byte 10110010, set both the second bit from the right and the fourth bit from the right to 0.

Answer:

MOV AL, 10110010b
AND AL, 11110101b

The result is in AL (and it should be equal to 10110000).

(In the two assembly commands above, please note the suffix b, which stands for “binary”, and is used to denote that the byte is given in its 8 binary bits form.)

OR

Truth table for OR
-------------------------------------
Input bit   Input bit   Resulting bit
0           0           0
0           1           1
1           0           1
1           1           1

From the above table, we can gather the following:

If you OR any bit with 0, the result is the bit.

If you OR any bit with 1, the result is 1.

Therefore, OR can be used to set any bit of a byte to 1, regardless of the bit’s previous value.

Here is how: Suppose we have a byte and we want to set one or more of its bits to 1. All we need to do is to OR the byte with a byte that has 1’s in the bit positions that we want to set to 1 and 0’s in the bit positions that we want to remain unchanged.

Example question: Given the byte 10110010, set both the second bit from the right and the fourth bit from the right to 1.

Answer:

MOV AL, 10110010b
OR AL, 00001010b

The result is in AL (and it should be equal to 10111010).

XOR

Truth table for XOR
-------------------------------------
Input bit   Input bit   Resulting bit
0           0           0
0           1           1
1           0           1
1           1           0

From the above table, we can gather the following:

If you XOR any bit with 0, the result is the bit.

If you XOR any bit with 1, the result is the bit flipped.

Therefore, XOR can be used to flip any bit of a byte.

Here is how: Suppose we have a byte and we want to flip one or more of its bits. All we need to do is to XOR the byte with a byte that has 1’s in the bit positions that we want to flip and 0’s in the bit positions that we want to remain unchanged.

Example question: Given the byte 10110010, flip both the second bit from the right and the fourth bit from the right.

Answer:

MOV AL, 10110010b
AND AL, 00001010b

The result is in AL (and it should be equal to 10111000).

Conclusion

With AND, OR, and XOR, we can manipulate individual bits, even though these commands (as all assembly commands) operate on full bytes.

All you have to remember is these six facts:

• AND a bit with 0 and the result is 0.
• OR a bit with 1 and the result is 1.
• XOR a bit with 1 and the bit is flipped.
• AND a bit with 1 and the result is the original bit.
• OR a bit with 0 and the result is the original bit.
• XOR a bit with 0 and the result is the original bit.

I cannot let you leave like this. Here is one more example for the road:

Example question: Write a program that transforms the byte stored in the AL register. The byte should be transformed as follows: Its first bit from the right must be set to 0. Its second bit from the right must be set to 1. Its third bit from the right must be flipped. That’s it. Let’s roll. And let’s be careful out there.

Answer: These transformations cannot be performed with one operation. We will need three distinct operations. Here they are:

AND AL, 11111110b
OR AL, 00000010b
XOR AL, 00000100b

And I hope that you find obvious the fact that these operations (assembly commands) can be performed in any order. After all three operations are performed, the result will be in the AL register.

Posted in Development

The importance of “A living programmable biocomputing device based on RNA”

Please visit A living programmable biocomputing device based on RNA

Quoting:

“…have developed a living programmable “ribocomputing” device…

…based on networks of precisely designed, self-assembling synthetic RNAs (ribonucleic acid).

The RNAs can sense multiple biosignals and make logical decisions to control protein production with high precision.”

This will lead to numerous highly effective drugs that will operate “within the cell” and will be able to correct the deficiencies of each individual’s DNA.

Here is how things work.

  • The human body is made up of cells.
  • Each individual cell has a nucleus.
  • Inside the nucleus exists a DNA molecule.
  • This DNA molecule is exactly the same in every nucleus, in every cell.
  • This DNA molecule contains the instructions on how the cell will produce proteins.
  • Proteins are the structural and functional ingredients of the human body.
  • The STRUCTURAL and FUNCTIONAL ingredients of the human body.
  • This means that proteins control how the body is structured and how the body functions.
  • So, proteins control everything!
  • And the “recipe” for their formation is contained in the DNA.

So, if the DNA molecule of a person has a defect, the corresponding protein that will be produced from that DNA part will be defective and the corresponding structural or functioning part of the human body will suffer.

Now, these drugs will be made such as to control the protein formation by bypassing the defective DNA part. For these specific drugs, the tell-tale sign, from which they discover the anomaly, is found in the RNA of the cell.

These researchers have made very important progress.

Posted in Science

The most important facts about code reuse

Code reuse can happen in two levels, one simple and one advanced.

At the simple level, you create a function and you use that function instead of copying and pasting.

At the advanced level, in OOP you use inheritance, whereas in functional programming you use function composition.

Posted in Development

And justice for all

My late father went to court on several occasions, either as a witness or as the accused. I will tell you about these court battles in other blog posts, but they were mostly unimportant.

What I want to point out in this blog post is quite important. When my late father came back from the court one day, he told me that he went to the court quite early that day. The “court” here in Athens,. Greece is in a large space where a lot of court buildings are located. Being there early, he killed his time by strolling around the court buildings. What he noticed, saddened him.

And when he came home, he told me about it. He told me that all the counters in the court rooms were set up to point to 666.

As I understand it, each court building has a lot of court rooms, and each court room has an electronic counter that denotes the number of the case being in session at the time. One would expect that when the court is not in operation, each counter may display 000, or an arbitrary number, or the number of the last case that was handled, or nothing.

But in the court rooms in Athens, Greece, the number all counters displayed when not in operation was 666.

What does that mean? Well, it means that Masons control the court system and the judicial system. It means that Masons favor other Masons when it comes to court rulings.

Why do Masons pick the number 666 as one of their symbols? Well, they do it for many reasons, and I will not claim that I know all of them. But 666 is a number that has a lot of “powers”. One of its “powers” is that it is made from the number 6 repeated three times. And from ancient times comes the notion that when you repeat something three times, you augment its power.

So, what are the “powers” of the number 6? Well, first and most of all, 6 is the first perfect number. A perfect number is a number that is equal to the sum of its divisors. Indeed, 6’s divisors are 1, 2, and 3. And 1+2+3 = 6.

Another thing about 6 is its shape. It resembles a swirl and a spiral. A spiral corresponds to an enormous body of mathematical knowledge and “power” that to analyze would need a very lengthy blog post. I believe that the Masons would agree with me if I said that the mathematical analysis of the spiral would resemble the mathematical analysis of the Divine.

There is another thing about the spiral shape that I think Masons adore.  A spiral depicts what I call “intelligent augmentation”. Let me explain. Take a snake. Put it on the floor. Observe it. It is just something that is long. And what will happen to it when it needs to grow? It will grow mostly in the direction that already defines it. So, it will grow by becoming longer. Well, this method of augmentation, this method of progress, may be a little bit “naive”. The snake keeps getting bigger and bigger by becoming longer and longer, and this may be considered as “obvious”, “easy”, “naive”, “messy”.

Now take a snail. Put it on the floor. Observe it. It has a spiral shape. Way more advanced than a straight line, which is the shape of the snake. And what will happen to it when it needs to grow? The spiral will grow, but it will do so in a way that the augmentation will not consume space awkwardly. Whereas the snake growth is a an embarrassment, the snail growth constitutes a clever progress, that respects resources, the resources, here, being space. Snail growth, snail augmentation happens with divine economy.

Now, Masons study these and other things and use them as symbols and guidance. They also try to sneak them wherever they can. One thing that I do not like about Masons is that they are always secretive and sneaky. But I also understand that they had to be like that in order to survive.

You see, when Christianity took over the world, a huge body of knowledge and beliefs were deemed opposite to Christianity’s teachings. Masons tried to preserve that knowledge by hiding it in their sects. Masons convened secretively and each passed the forbidden knowledge to the other Masons. They also held secrets on architectural methods that allowed them to obtain lucrative jobs in the building industry, constructing the most difficult structures like cathedrals and bridges.

Masons were able to thrive because of their secrecy. Because other people did not know the Masons’ true beliefs, they did not turn against them. It is not that the Masons beliefs were incorrect. But their beliefs were and remain politically and religiously incorrect , according to the beliefs of the majority of the people in the society.

By hiding their true identity, beliefs and ideology,  and also their tricks of the trade when it came to architecture and scientific knowledge, Masons were not only able to function as accepted members of each community, but they also became very rich.

The problem is that their secrecy and their wealth were always benefiting only them as opposed to the society as a whole. What started as a genuine community that was trying to survive the menace of early Christianity, later became a cancer that is found inside every modern society.

Nowadays, Masons are a closed, powerful community that stops at nothing in order to protect their interests. And the judicial system is their playground. Masons are everywhere and they win trials just because of their influence and connections. Masons have made justice disappear from the courtrooms.

Posted in Politics

Two kinds of people

There are two kinds of people:
People who care about others and people who care about themselves.
People who care about others are those that should become politicians.
People who care about themselves are those that do become politicians.

There are two kinds of people:
People who care about their obligations and people who care about their rights.
People who care about their obligations are those that should become entrepreneurs.
People who care about their rights are those that do become entrepreneurs.

Posted in Management