Interpretation of Data


How do computers store, process and interpret data? In this post we will explore through the medium of simple programs how this happens.

Disclaimers and license

Moodle™ is a registered trademark of ‘Martin Dougiamas’ –

Ubuntu® is a registered trademark of Canonical Ltd –

Other names / logos can be trademarks of their respective owners. Please review their website for details.

I am independent from the organisations listed above and am in no way writing for or endorsed by them.

All code presented has been written by myself. Please feel free to copy and adapt for ‘educational’ purposes only.

Before we start

To understand how data can be processed and interpreted by a computer, we really need to understand at a basic level what a CPU (Central Processing Unit) actually does (or at least one following the Von Neumann architecture – When running it operates the ‘Instruction cycle’, which it repeats over and over again, its cyclic – This in effect gets data and instructions (what to do with the data) from memory, processes it and puts the result back in memory.

Software that is written in a programming language is those ‘instructions’ and may contain data as well as instructions on where the data can be found or inputted by the user. Because CPU instructions are primitive and from a CPU’s point of view, just a number, this is difficult for humans to understand and time consuming to create. Thus there is different ‘levels’ of programming language called ‘generations’. Generally the higher the generation the more powerful the individual syntax elements are and they are easier for humans to understand.

In this post, I will be using ‘C’ which is a third generation language – This is translated by a ‘compiler’ into ‘assembler’ for the CPU you are using. Assembler is a second generation language that is assembled into a first generation language (in effect binary numbers) by an ‘assembler’ to create ‘machine code’ – It is these binary numbers that are the ‘switch states’ that set-up the CPU to perform a given action – an instruction – this ‘set-up’ is undertaken by ‘microcode’ –

Thus instructions created by a software engineer to solve a given problem are performed by a CPU so that you, the user, get the job you want ‘done’.


‘C’ has the capability to be powerful enough in its functionality and syntax that its possible to illustrate stored data being interpreted in different ways. Thus I’ve chosen it to illustrate this post. It can allow a given variable to be explicitly different types at the same time and to know where it is stored in memory, along with its exact size in bytes.

‘C’ is also as close to ‘assembler’ as possible and yet not be too hard to understand.

The concept

Imagine computer memory as boxes that are arranged in a given way, store one byte each and have a unique identifier – an address. Just like the dwellings we live in have an address.

How the C 'union' used in the fab programs maps to memory

With a ‘union’ in C, we can look at the memory in two different ways. Here, either as a number ‘an integer’ or a single character. The size of the integer can vary between CPU’s and operating systems on them. Here I’ve shown it as four bytes (green boxes), thus being capable of storing a number between −2147483648 and 2147483647 or 0 and 4294967295 if unsigned (no indication of positive or negative). The yellow box is a single byte, for us it will be an ASCII character (UTF-8 characters are two bytes). Both the green and yellow boxes – the individual bytes – ‘map’ to the real memory. Each memory box, being a byte here, has an address. This ‘address’ is represented as a number, also from the CPU’s perspective in binary, for humans this is usually stated as a hexadecimal number (base 16).

Please see, and This is why you see in advertising for both CPU’s and Operating Systems, 32 and 64 bit, one element is the amount of memory that the CPU can use, with 32 bit this will be up to 4 Gigabytes and for 64 bit, up to 16 Exabytes.

FAB one

The first program ‘fab’ is:

fab.c source code

it defines the ‘union’ I have described. The first bit like ‘unsigned int’ is the ‘data type’ ( which states what ‘type’ the variable, in this case called ‘b’, should be represented. It is ‘unsigned’ so will always be a positive number.

Then the ‘main’ function places the number ‘97’ into the ‘integer’ representation of the memory. Ninety seven is the ASCII ( decimal number for the character ‘a’. Then we loop around stating what the ‘char’ (character) representation of the memory is using the function ‘printf’ and then increment the integer representation by one each time with ‘fab.b++’. This should then output ‘abc’.

On line 14, ‘printf(“\n”);’ says to output a new line.

From line 16 to 21, we have another loop that places sequentially the numbers, 102, 97 and 98 into the integer representation and in the same way as before, state the character representation. This should output ‘fab’.

Finally on line ‘23’, ‘return 0;’ exits the program with the return value of ‘0’ (exit code) which tells the operating system that the program ran correctly.

To show this we first need to ‘compile’ our program using a compiler to transform the human readable ‘source code’ above into the ‘machine code’ that the CPU needs. For this I’m using the compiler ‘gcc’ ( on my Raspberry Pi B+ called ‘Matilda’:

fab.c output on the console

The first line ‘gcc fab.c -o fab’ says to compile the source code file ‘fab.c’ into the runnable file (executable). Then we have the rest as expected.


Our second program ‘fab2’ is:

fab2.c source code

where on lines 9 to 14 we find out how big the representations are and where they are stored in memory, their ‘address’.

From lines 16 to 28, as before. Lines 30 to 35 places a character in the memory address ‘pointed to’ by ‘bp’ and then increments ‘bp’ by one byte (as its an ‘unsigned char’ pointer, so one ‘byte’). So ‘unsigned char *bp = &fab.c;’ means that ‘bp’ will be assigned the memory ‘address of’ the variable ‘fab.c’. The actual character is determined by adding the loop variable ‘bpi’ value to the number ninety seven. Therefore, if ‘b’ is 4 bytes then we will have ‘abcd’ in memory. The ‘printf’ function should tell us this on line 33, where ‘printf(“%p has %c\n”, bp, *bp);’ states at ‘bp’ address we have the character of ‘x’ pointed to by ‘bp’, thus:

fab2.c memory storage

Then when the pointer ‘bp’ is incremented with ‘bp++’ then we will see the character ‘b’ in the next memory location which was put there by ‘*bp = bpi + 97;’. This means place in the memory address stated by ‘bp’ the value of adding ‘bpi’ (being ‘1’ at this point) to the number ‘97’, so ‘98’ and thus that is the character ‘b’ in ASCII.

Don’t worry if this is complex, C pointers and their arithmetic can be quite difficult!

So, we then get the output:

fab2.c output on the console

we can see that our ‘union’ called ‘fab’ is as big as the biggest data type it contains, the variable ‘b’. That both ‘b’ and ‘c’ are at the same memory location. Finally, we can see the ‘abcd’ in memory that I’ve already described.

If we now compile and run the same program on a 64bit PC that is running ‘Ubuntu 19.10’ (same Debian based Linux operating system as ‘Raspbian’ on the Raspberry Pi) then we get:

fab2.c output on Ubuntu 19.10

So different memory addresses but the same size of integer for the data type ‘unsigned int’.

FAB Three

Our third and last program ‘fab3.c’ is only slightly different to ‘fab2.c’:

fab3.c source code

In that on line ‘4’ the ‘unsigned int’ has changed to an ‘unsigned long’. This means that it should be bigger, however on the Raspberry Pi I’m using it is not, its the same as the ‘unsigned int’:

fab3.c output on the console

and yet on the Ubuntu 19.10 machine it is double the size:

fab3.c on Ubuntu 19.10

and looking at again we see that they are both different. This is one of the ‘headaches’ for software engineers in needing to support different CPU’s / operating systems and still have reliable code. You will also notice that the program has already been written in such a way to cope with this without change as ‘b’ now has ‘abcdefgh’.

So by one small change in a simple program we can see the importance of accuracy and understanding in code to produce the intended result. It is perhaps the human condition where we are good at being dynamic, adaptable and creative with the skill to think and make software and yet do make mistakes, that ‘bugs’ in software can happen.

FAB Summary

You will see with all three programs that data is being read, processed and stored. There is input and output. The ‘instruction cycle’ is happening between the CPU and memory. A CPU has hardware (the address and data lines) that select the memory addresses and send the actual data to and from memory.


How computers process data can be controlled by software. It gives us the ability to get a machine to store all data as one thing, binary, and yet process it in so many different ways according to the purpose it is needed for. This is why we have different file types such as text (txt), image (jpg, png…), sound (mp3, flac…), video (mp4, avi…), the data is all binary but how it is processed is the key to making it useful.

But what about humans, how do we look at and perceive data? Can we go back and look at something from the past and look at it in a different way from a changed perspective?

When you’re writing, using or conducting a Moodle course how can you look at the ‘data’ differently? Does that view allow you to make things better or could it even make things worse?

Gareth Barnard
Latest posts by Gareth Barnard (see all)

Gareth Barnard

Gareth is a developer of numerous Moodle Themes including Essential (the most popular Moodle Theme ever), Shoelace, and other modules such as course formats.

2 thoughts on “Interpretation of Data

  • 16th January 2020 at 11:21 pm

    OK, so I loved the train image, but then started reading and quickly got lost.
    This is my fault, not yours!
    Unfortunately I had a very bad maths experience / teacher in that critical 12-13 year old period, and I never recovered.
    I guess I could ‘go back to school’ and learn maths properly, but I suppose I ‘cope’ with this, in the same way that many people cope with being dyslexic, or have other learning difficulties … one finds strategies and workarounds.
    This can be effective most of the time. I mean, I can do things with a spreadsheet as well as the next man.
    But computer programming, well that exposes my fundamental maths weakness.
    It’s too late for me, but for any younger readers here, put the effort into your maths learning, because it can pay off in so many ways in these technology driven days.

    • blank
      17th January 2020 at 2:56 am

      Thanks Stu,

      I was not really sure what image I could use for this post, so the ‘Union of South Africa’ train image is a still from a video I took of it last year. I can post the link on YouTube if you want?

      Maths has never been my strong point either. Computing is actually different to maths, I believe that it is a science and an ‘art form’ in its own right. Really here what I’m describing is the index to an address book, where a number can mean one thing in one book and another in another.

      I believe that to understand programming you need to understand how computers work and are built as devices, their structure. How (like a railway) their paths and switches (points / turnouts) are orchestrated to get the data from one place to another (travel on a train from on station to the next). And be a problem solver. If you can problem solve and have an eye for detail, then you can program.

Add a reply or comment...