Explain the key features of procedural programs (P1)

Functions / Procedures
Procedural programming is a fundamental style of programming, also known as a programming paradigm; the basic concept in this paradigm is the procedure (also known as a function, a method, a routine or a subroutine.) A procedure holds a set of instructions to be executed by a computer one after the other, during a program’s execution, a procedure can call any other procedure, including itself.
Using functions and procedures also creates modularization within the code, allowing it to be split down into smaller reusable segments increasing the overall efficiency of the program, saving memory whilst looking clean.
Functions are almost identical to procedures regarding their practicality however share one distinct feature which contrasts the two. Procedures execute the code In the order which they are written, functions do the same although return a value at the end of the block, allowing the program to display any form of error codes to the user if the function was not successful. This one distinct feature is one of the only differences between the two
Example:
#include <iostream>
using namespace std;

int  add(int a, int b);

int main()
{
	int x = 0;
	int y = 0;
	int sum = 0;
	cout << "Enter first number: ";
	cin >> x;
	cout << "Enter second number: ";
	cin >> y;
	sum = add(x,y);
	cout << "The sum of " << x << " and " << y << " is " << sum << endl;

	return 0;
}
int add(int a, int b)
{
	int c = a + b;
	return c;
}

(Int main and int add are both functions)
Pre-defied functions
Pre-defined functions, are features built in to a programming language to make programming easier, examples of pre-defined functions are functions for string manipulation, mathematical operations and file access. Unlike standard functions the user has no input in the way that they execute.
Example:
Variables
Procedural languages use variables to represent an address in memory and the data held in that address, variables can have the property of scope; scope refers to the sections of a program that can and can’t access the data a variable represents. A variable can be either local or global in scope
Local Variables
A local variable can only be accessed by the function it is initialised in, it cannot be called anywhere except its origins, doing so would create errors within the code.
The below example shows the variables declared inside the function in which they are unique to, calling these variables within this function would be completely acceptable and would cause no errors, calling it in another function would not work.
Example:
void Circle()
{
  int pi=3.141592
  int radius=0
}

Global Variables
Global variables are declared outside of all functions usually residing after the calling of libraries. Unlike local variables, global variables can be accessed anywhere in a program. The feasibility of global variables are somewhat similar to functions as they save memory from their reusability. However they do present problems when used in conjunction with local variables, for this reason they are usually a taboo to use.
Example:
#include <iostream>
using namespace std;
int a=3
int main()
{
   a++;
}

Parameter Passing
Variables can also be passed to other functions; variables that are passed to other functions are called arguments, a function has to be defined with variables called parameters in order to accept arguments. The passing of arguments to parameters is called parameter passing.
Programming Libraries
Programming libraries also allow a programmer to reuse code by writing subroutines that can be easily called on.



Modular Design
Modular design is a method of designing procedural programs by separating individual functions so that each function carries out a specific task, this can make development and maintenance easier as well as allowing code to be reused. Procedural programming languages commonly feature a library of pre-defined functions for common operations.
Control Structures
Control structures are the basic elements in a program that dictate the direction a program takes, these elements include loops, statements, and  conditional statements.
Loops
 A loop is a type of control structure that contains a series of statements to be executed a specified amount of times or until a certain condition is met.  There a few types of loops examples being for loops, while loops and do-while loops otherwise known as fixed, pre-check and post-check.
-Fixed loop
A for loop is a type of loop that executes until the loop counter meets the predefined value. Unlike a while loop or a do while loop, the number of iterations is known before the loop is executed
-Pre-check
A while loop is a type of loop that executes as long as a condition is true
-Post-check
a do-while loop is similar to a while loop, the difference is that a do-while loop executes at least once before evaluating a condition to see if it is true, this is known as a post-check loop
Breakpoint ****
Conditional commands****
-The If Construct
This is a type of conditional command  used to control program flow in many programming languages, after the If, the computer evaluates a condition to determine whether it is true or false, if it is true, then conditions following the statement immediately are executed, if the condition evaluates as false, conditions following the next branch are executed. The If construct generally follows an if-then-else format, although not all languages may implement this explicitly, for example C and C++.
Example:
-Case and Switch
This is another type of conditional command that is used to control program flow in many programming languages, a case and switch construct compares an inputted value to a set of predefined values and switch the flow of the program based on the first condition that matches, generally there is a default statement that is executed if there is no match found.
Example:
-Boolean operators
A data type that can either be true or false is called a Boolean value *****


Procedural programming languages
Examples of procedural programming languages are C, Pascal, COBOL and FORTRAN.

Explain why modular elements are important for procedural programming (M1)
Modular programming is the practice of breaking down each function of a program into separate pieces; this allows each element to carry out a specific task with as little external dependencies as possible. Modular elements are important for procedural programming because it increases code reusability, maintainability and allows easier collaboration between programmers. This is because each module can be developed separately and updated without affecting the rest of the system, another advantage of modular design is that a programmer does not need to know about other modules and thus need not worry about their code affecting the rest of the system, focusing on their module instead.
Top down programming

D1 – Evaluate the suitability of procedural programs for graphical applications
A long time ago, in the infancy of computers, computers were hooked to teletype machines which were essentially typewriters. These primitive machines were only capable of the most simple graphics; characters.
Below is an example of the graphics you could get from one of these machines.
   |\_/|        ************************************    (\_/)
  / @ @ \       *           Jacob Knight           *   (='.'=)
 ( > º < )      *        Professional cunt         *   (")_(")
  `>>x<<´       *  (jacobknight101@hotmail.co.uk)  *
  /  O  \       ************************************


Its dominance was further enhanced by the rising popularity of graphical user interfaces, which rely heavily upon object-oriented programming techniques. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective-C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP).

Are procedural languages suitable for graphical applications?
Well, let’s have a look at some popular widget toolkits (native and cross platform). The majority of GUI libraries or APIs are written in an object oriented language, Qt, WxWidgets, MFC  (Microsoft Foundation Classes, Windows Forms, Cocoa etc, therefore they must be interfaced with an object oriented language. The only non-object oriented GUI libraries or APIs are GTK+, Elementary and the Win API (which is notoriously complex to develop for, thus the existence of MFC and Windows Forms).
So it seems pretty clear that object oriented languages are the preferred choice for GUIs, because in object oriented language there are constructs which simplify managing the many