Programming Fundamentals: Conditions

Programming

042717_1212_Programming1.png

The first article in this series of posts talked about how programs consist of instructions written in programming languages. When we write instructions, we are telling the computer what to do, and the computer executes these instructions in the order that we write them. Our programs will be rather basic though if we don’t allow for branching, the ability to execute certain instructions based on some condition.

A conditional statement is an instruction that allows a computer to decide what to do based on a condition. A condition is anything that can be resolved to either being true or false. Many programming languages include a data type known as Boolean value that is used to store a true or false value. Any data type can usually be resolved to be either true or false, with a value of 0 representing false, and anything else equating to true.

It is not just values that are evaluated, we can also use mathematical expressions as conditions, such as checking x > 5, a + b = 6. We are also not restricted to evaluating a single condition, with the use of Boolean logic we can create complex conditions using AND, OR, and use NOT to allow a condition to be checked against something not being true. AND and OR allow us to combine multiple conditions, using the examples previously described we could write a conditional statement that states that x > 5 AND a + b = 6, which means that both x must be greater than 5 and the variables a and b must equal 6 for the condition to be true. OR on the other hand requires that only one of the conditions, x > 5, OR a + b = 6 equate to true for the whole condition to be considered true.

A programming language can be looked at in the same way as any spoken language, we must learn the words and rules that govern the language, the syntax, to use it. Each programming language will have a set of reserved words and define a structure we must follow for the computer to be able to understand the instructions we write. A conditional statement is an important concept, and is thus implemented into all languages, otherwise there would be no branching. Most languages implement a conditional statement using the word if. A conditional statement will look something like the following:

If (condition) then

    Instructions to do something

In the above case, we would test a condition and then proceed to execute some code. Additionally, another reserved word else, is associated with conditional statements.

If (condition) then

    Instructions to do something

Else

    Instructions to do something else

The inclusion of the word else means that we have the option to branch out and execute instructions dependent on the evaluation of the condition. In the first example, instructions would be executed, if and only if the condition evaluated to true. In this second example, the computer gains the ability to execute instructions if the condition does not evaluate to true. A third example shown below, makes use of the words else if.

If (condition) then

    Instructions to do something

Else if (condition) then

    Instructions to do something else

The key difference between the 2nd and 3rd examples is that instructions in the 3rd example are dependent again upon some condition evaluating to true. In the 2nd example the instructions after the else word are executed every time the if condition evaluates to false. In the 3rd example though, there is chance that both instructions in the if and else if sections aren’t executed if both conditions evaluate to false. Also, there are no restrictions upon the amount of else if conditions you can use. By this I mean we could have code that looked like the following:

If (condition) then

    Instructions to do something

Else if (condition) then

    Instructions to do something else

Else if (condition) then

    Instructions to do something else

Else if (condition) then

    Instructions to do something else


Although we can use as many else if statements as we want, we cannot use else repeatedly, as the computer would be unable to determine which else’s section of instructions to execute.

Therefore, conditions give us incredible opportunities to write more complex code by allowing us to execute instructions based on conditions defined by us whether that’s checking the value of a variable, or evaluating a mathematical expression. We can control the flow of execution of our program, and ensure instructions are only executed when we want them to be. Conditions are not strictly limited to use in conditional statements, such as if statements, and play a big role in the ability to repeat the execution of an instruction, or set of instructions. The next article will expand the use of conditions, by describing their use in relation to repetition.

Programming Fundamentals: Data Structures

Programming

041717_1636_Programming1.jpg

The last article introduced our first fundamental concept, the variable, and explained that variables are a named memory location for which we want to store a specific type of data, more on variables can be read here. Variables are useful for storing a single value, a single piece of data of some type, however you may want to store more than one piece of data, and that requires the use of a data structure.

Before describing data structures though I would like to look back briefly at data types. As discussed in the previous article I explained how we must declare a type for the data we want to store in a variable, so we can give meaning to the data, which we know is essentially a sequence of binary digits, through the operations that can be performed on that data.

For example, if we look at a common data type, an integer, which is used to store whole numbers, we can perform typical operations on these numbers such as addition, subtraction, division, and multiplication. Therefore, the type integer, states that the binary number stored represents a whole number, as well as describing the operations that can be performed, mathematical operations.

All programming languages have a set of basic types, defined within the language itself, known as primitive types such as: integers (whole numbers), float-pointing (decimal numbers), and char (characters). We frequently use these types, and the operations that go with them, but many languages also give us the opportunity to define our own types, known as user-defined types. What this means is that we can store our own data and describe what operations we can carry out on that data with the help of certain data structures.

Data structures are then in many ways like data types. They are created in an analogous way to variables, requiring a name, specifying the data structure in use (more on this later), as well as the type of data it can store. What makes them different though is that they store more than one value, for example a data structure can store one integer, or it could store 100 integers, or it could be created to store 50 floating-point values, or any number of any type, both primitive, or user-defined. The operations of data structure are also different, instead of providing us a means in which to operate on the type of data it stores, they instead provide operations that can be carried out on all the data, also known as an element, stored within the structure. The operations commonly associated with data structures include:

  • Traversing: accessing all the data elements once and only once in the data structure and doing something with that data, such as updating all elements, or outputting them to the screen.
  • Inserting: adding new data to the data structure.
  • Deleting: deleting data that already exists in the data structure.
  • Merging: merge two data structures together.
  • Searching: attempt to the find location of a data element within the data structure, if it exists.
  • Sorting: order the data within the data structure, in some way, which usually depends upon the type of data being stored, i.e. numbers arranged smallest to largest.

We use data structures to store more than one element of data, the data we store is intended to be traversed, organised, sorted, and searched, and they allow insertion and deletion in as efficient a way as possible. Efficiency is determined by the design of the data structure, but also efficiency of a program can be determined in the choice of structure we use.

There are a broad range of data structures but they typically fall into two groups: linear and non-linear, both of which affect the way we interact with the data stored in the structure.

With linear data structures the data stored with them is stored sequentially, that means if we start at the 1st element in the structure, and want to get to the 4th element we must first traverse to the 2nd, then traverse from 2nd to 3rd, then finally from 3rd to 4th.

This isn’t the case with non-linear data structures, we don’t have to traverse through the data elements linearly, one after another. Elements of data can be linked to more than one element. This is achieved by having our data type not only store the data we want but also values containing addresses to other types which hold data and addresses, also commonly known as a node. This means we don’t necessarily have a 1st, 2nd, 3rd, 4th data element instead we have a root, which is the first node in our data structure, and this could store addresses that point to many different elements.

As previously mentioned deciding what data structure to use is important, and can have a huge effect on the overall efficiency of your program. Both in how the data structure is implemented in memory, and how the data is stored in that structure, linear or non-linear.

The main thing to take away from this article is to understand how they work, so that you know in what situation you can apply each one. This requires understanding a wide variety of different data structures and how they are implemented for each programming language, which can differ. This article is just an overview on data structures, so I will forgo any details regarding specifics, in favour of discussing them in detail in future posts.

To conclude a data structure is like a data type, but instead of defining operations to be that relate to the data itself, it instead allows storing of more than one piece of data, and defines operations that relate to the data it stores. We can create a data structure much like a variable by defining the data structure we want to use, the type to be stored within it, and a name to identify the address of the memory the data will be stored.

With variables and data structures discussed the following articles will focus back on concepts related to writing programs. How we can alter the instructions being executed using conditions, repeat instructions with the help of loops, and finally the organisation of instructions using functions. The next article will focus on the conditions, and how they help expand the potential of our programs.

Programming Fundamentals: Variables

Programming

memory-1761599_1920

The previous article gave a gentle introduction to creating programs, by explaining what they are, and how to go about writing them, using a set of basic principles, which can be read here. In this article, we will look at the first concept mentioned, the variable. Hopefully by the end of this article you will know all about what they are, and why we use them.

Before looking at variables we need to know a few things about memory. Memory is what we use in computers to store data, such as audio, and images, as well as programs. There are two main types: main memory, and secondary memory. Secondary memory such as hard drives (HDDs) and solid state drives (SSDs) are used to permanently store data when our computer is not switched on.

On the other hand, main memory is used to store the data and programs that we are currently using. When we open a program on our computer such as a web browser, this program will be stored in main memory. The specifics are not important, but I will say it’s done because main memory is a lot faster than secondary memory. Either way, main memory is divided into cells whereby each cell has its own unique address. These addresses are used to locate the cell, and get access to whatever is stored in it.

When we write programs, we will often need to store data in memory, and to do this we would need to know the address of cells which are not currently holding any data, and then proceed to use that address to store the type of data we want. An address can be a large value in the range of 0 to 4,294,967,295, which is a lot of potential locations. Imagine having to remember every address we have our data stored in, and if we had to access it frequently it would be rather boring to keep writing these large values out over and over again.

Fortunately, we are lucky in that the operating system, the program that tells the hardware in our computer what to do, works out what locations are free, and stores the data for us. All we need to do is tell the computer we want to store something and provide a name that we use as an identifier to access a unique location. The operating system makes an association between an address and the name we provide. The name is then used by us, and the operating system knows which address to look for.

After telling the computer we want to store the data, and giving it a name we then need to state what type of data it is we intend to store in that location.

Again though, before going any further it seems we need to take a slight detour and look at how data is stored in a computer. When it comes down to it computers only understand what is known as binary, 0s and 1s, and nothing else. Binary numbers are a sequence of 0s and 1s, for example, 010010, 01, 0, 0100111010, etc. I know in the previous article I said that computers understand programming languages, and well in a way they kind of do. They can take instructions given in these languages, and convert them down into binary, so that they can be executed, so I only half lied!

Instructions and any type of data: images, text, words, numbers, etc, are all stored in memory as binary. By writing out the type of data we want to store we are telling the computer how to treat the binary numbers stored at that location. Taking another example 010, what does this even mean? Not a whole lot, unless we give meaning to it.

We could give this sequence any meaning, for instance, we may decide that the digit furthest to the left represents red, the second green, and the third blue. Therefore, if we had 000, this could represent black (no colour), 111 white (using all the colours), 100 red, 010 green, and 001 blue. However, we could treat these numbers any way we want, the important thing here is that binary numbers represent all the data stored in our computer.

Therefore, when we declare the type for our variable we are telling the computer what data we want to store at a specific location, and then when we go to use that data the program knows what to do with it. A variable can then be described as

A named memory location for which we want to store a specific type of data

The location of where this data is being stored is within main memory, and this means the data we want to store won’t be stored permanently. Variables are intended to store temporary data needed by the instructions in our programs.

This may seem confusing, why would we want to store data that we are only going to lose when the computer is turned off? Well when writing our instructions for a program we will want to store data which our instructions will use. All programs will have input, this could be listening to a user pressing a key, typing in text, or moving a mouse, and then we want the program to respond to us in some way, provide an output. The input passed to our program needs to be stored somewhere so other instructions can make use of it.

Additionally, the instructions we write might require the storing of data. For instance, if we want to add two numbers up we could then store the result of this in a variable. We could then use another instruction to take that variable and output it to our screen so we can see the result, think of your calculator. This means that variables allow us to temporarily store data so that we can use the data at a later date in our program, but once we close our program, the data in those variables is lost.

Finally, I think it’s worth mentioning that variables are not fixed. What I mean by this is that we are able to change the data being stored at that location. If we had the variable called number we could write an instruction that adds two numbers together, 5 + 2, storing the result of this in number, the value stored being 7. Later in our program we could then add up two new numbers 6 + 8, and then store the result in the same variable, same memory location, which will overwrite the data already stored there. If we want to keep the previous value, then we could just create a new variable, say number2, and store our result of 6 + 8 in there instead. Note you should be using better variables names than the ones I have mentioned!

To sum up then, a variable is intended to be a temporary place to store data, which is stored in main memory at a unique address. We access that data by giving our variable a name, which the operating system then uses to retrieve data from that location. Variables are used alongside instructions in the programs we write to allow us to keep hold of data input by a user, or to store data we want to use at other points in our program, by other instructions. The data stored in these variables can be overwritten, and if we want to store more data we can simply create more variables.

Sometimes when we want to store a lot of values it’s better to store them within a data structure, as opposed to creating more variables. The next article will explore the use of data structures, how they are similar, yet different from variables, and look briefly at the different types of data structures.

Programming Fundamentals: Introduction

Programming

041017_1920_Programming1.jpg

Programming can seem quite complicated, and in some cases, it is, but that doesn’t mean that only geniuses can learn to do it. Starting our journey to becoming a programmer lies in understanding the principles behind writing code, which are rather simple. Before delving into these principles though, let’s make sure we all understand what a program is.

So, what exactly is a program, and what is it that these programmers do to make all the cool apps we use on our smartphones? Well fundamentally a program is a set of instructions that tells a computer to do something. A programmer’s job is to create programs, that is to give the computer instructions so that the computer can be used to carry out a specific task. Programs can be quite complex, but it is worth keeping in mind that no matter what you are programming, the basic concept applies, write instructions to tell the computer what to do. The instructions given to the computer are communicated in a way a machine can understand, and this is done using a programming language.

There are many programming languages that allow us to create programs for a computer, but each can differ in many ways. The main reasons being the purpose of the language, what types of programs the language was built to make, and what words make up that language. Regardless of these reasons there exists a set of core principles, that extend across all languages, and are therefore important to understand if wanting to learn anyone one of them.

Before discussing what, these principles are I thought it would be best to show a simple example of a set instructions written in English that we would give to someone who wanted to make a cup of tea, and then discuss why these instructions are not useful to a computer, and how these instructions could be translated into something that could be understood by one. The instructions for making a cup of tea can be described as:

  1. Place teabag in cup
  2. Add sugar
  3. Pour hot water
  4. Leave to brew
  5. Remove tea bag
  6. Add milk
  7. Stir

As you look at these instructions you may be wondering why we cannot simply give these instructions to a computer, and well it’s because computers are too dumb to understand them. A computer needs very simple and specific instructions to do anything, and our language is just too complicated. So, if that’s the case, then how can we translate the instructions above into something the computer understands? Well let’s pick apart these instructions and find out. Although a computer isn’t very good at understanding our language they are very good at understanding certain things: data, conditions, repetition, and functions.

Data is just a word that means information that a computer can use or store. A computer can store lots of different types of data: images, numbers, audio, words, and so forth. When we want to write a program, we will want to use or store data. In the above example, we can see a lot of information that is required for us to be able to make a cup of tea. We need to be aware of the amount of tea bags, hot water, sugar, and milk we have available. We can use variables to store this type of information, a single value that represents something we would like store.

Sometimes we may want to store more than a single value. Like a cupboard in our kitchen that stores all our cups, when writing a program, we may want to store lots of values of the same type of data. Data structures are a method that allow us to store a cupboard full of cups in our program.

When referring to the example if we look at instruction 3. Pour hot water. We know ourselves that this action means to pour water from the kettle into the cup, and because we can see the size of the cup and the water filling up the space in that cup we know that once the water nears the top of the cup we should stop pouring as not to spill it everywhere. Computers cannot do this naturally, but can be told to do so. We can use conditions to tell the computer that we want to execute certain instructions based on some condition that can make use of a variable, such as if we have any sugar then add sugar to the cup.

Additionally, pouring water, milk, or stirring are all events that involve repetition of an action, which is carried out, until a condition is met. We would keep adding sugar until the brew was sweet enough for our taste, we would pour the water in until it wasn’t far of the top of the cup, we would add milk until we got the colour we wanted, and we would stir until the sugar had dissolved. Computers can be told to carry out instructions repeatedly using a condition that specifies how many times we repeat a set of instructions.

What if we wanted to make tea for 3 of our friends? We would have to repeat the set of instructions 3 times for each person, meaning we would have 21 instructions to carry out, most of these are repeating the same steps. To make it easier for us to tell the computer to carry out a repeated set of instructions, we can place them in functions. To make tea for 3 friends we would need to use repetition to call the function three times to execute all the instructions, based on the condition that all 3 of our friends had a cup of tea.

Finally, instructions provided to make a cup of tea, require that we follow them in order from step 1 to 7. At least with this example we could alter the order in which add the various components of a cup of tea: water, milk, tea, and sugar. However, we must be sure that the water is hot before we add it, and that all ingredients are placed in the cup before stirring. Writing programs works the same way, we must ensure that our instructions are written out in the correct order, otherwise things are bound to go wrong, or not work at all.

As you can see writing programs comes down to writing instructions using a programming language, where these instructions are used to tell the computer to do something. There exist many languages, which each have their purpose, but underlying all of them is a set of principles that if understood allow you to write programs no matter the language. Computers cannot understand the complexities of our language, but they are able of understanding certain things.

  • They can use and store information, as a single value, or as multiple.
  • They can be told to carry out a set of instructions based on a certain condition, and can use a condition as the basis of repeating a set of instructions multiple times.
  • Finally, instructions that we want executed multiple times can be placed in functions, removing the need to write the same instructions multiple times.

This article has provided a basic overview of a program, programming, and the fundamentals, and how they apply to a simple example of making a cup of tea. The next article will discuss more in depth the concept of variables, their uses, and their importance in the role of creating programs.