Perhaps the most fundamental concept in computing is the concept of an algorithm. An algorithm is a finite set of unamniguous and precise instructions that
It is an abstract computer program, if you will.
Clearly, the problem with this definition is what it means to be "executable". The concept of an algorithm is often explained by drawing an analogy with recipes (for example, a recipe to make rice-and-peas (http://www.foodnetwork.com/recipes/bobby-flay/jamaican-rice-and-peas-recipe/index.html). However, there are many well-written recipes in which the steps are not executable by every cook. For example, not all of us know what to do when we are told to "deglaze the pan with white wine".
Fortunately, in the context of computing, we can define what we mean by an executable step, and we discuss this in detail in the sub-module entitled "Algorithms".
Nor surprisingly, there are often many different algorithms to achieve a particular task. For example, there are at least four well-understood algorithms for sorting a list. The question therefore naturally arises whether we can compare different algorithms in some abstract, mathematical way, for example to determine whether one runs faster than an other. The answer is that we can and the branch of discrete mathematics that allows us to do so is called "Complexity Analysis". In complexity analysis we express the running time of an algorithm in terms of the size of the input. Thus, we can express the running time of a sorting algorithm in terms of the numbers of items in the list to be sorted. The sub-module "Complexity Analysis" provides more detail.
As we shall see as well, in calculating the complexity of an algorithm, we ignore a number of factors. As a result, complexity analysis is not necessarily the best way to compare two algorithms, and in some cases, we may want to turn to alternative ways of comparing algorithms. One option is to conduct a timing experiment. In a timing experiment, we implement the different algorithms in a programming language and then measure the time that each takes to run. As your term project for this course, you will conduct some timing experiments for different sorting algorithms, and compare the results from your timing experiments with the results from a complexity analysis.
Many of the concepts introduced in this module will be discussed in far greater detail in subsequent courses, including the Data Structures course and the Analysis of Algorithms course. In this module, we will merely scratch the surface, and we will for example only discuss iterative algorithms, and ignore recursive algorithms.