1. 3.5 Programming paradigms
Part 3

2. Declarative Languages
In declarative languages, the programmer can simply state what is wanted, having declared a set of facts and rules.
In the following example coded in prolog, the query male (x) searches and returns all those that are male.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

3. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Example:
We have the following facts.
female(jane).
female(anne).
female(sandip).
male(charnjit).
male(jaz).
male(tom).
parent(jane,mary).
parent(jane, rajinder).
parent(charnjit, mary).
parent(charnjit, rajinder).
parent(sandip, atif).
parent(jaz, atif).
The output of male(x) will be
X = charnjit
X = jaz
X = tom No
“No” means that there are no more results.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

4. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Goals
Looking in the database for male(X) is known as looking for a GOAL
A goal is a statement that we are trying to prove whether or not it is True or False.
If we add the rule
father(X, Y) :- parent(X, Y), male(X)
This rule states that X is father of Y if (the :- symbol) X is a parent of Y AND (the comma) X is male.
This means that father is a predicate, and X & Y are arguments
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

5. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Instantiation
Instantiation means assigning a value to a variable.
Example:
The query male(X) instantiates X to charnjit.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

6. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Backtracking
Backtracking is the going back to a previously found successful match in order to continue a search.
If the goal (search) fails on the last part of a rule the language will backtrack to where the failed variable was first found and it will move the variable onto the next record.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

7. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Example:
Consider
female(jane).
female(anne).
female(sandip).
male(charnjit).
male(jaz).
male(tom).
parent(jane,mary).
parent(jane, rajinder).
parent(charnjit, mary).
parent(charnjit, rajinder).
parent(sandip, atif).
parent(jaz, atif).
father(X, Y) :- parent(X, Y), male(X).
The last rule states that X is father of Y if (the :- symbol) X is a parent of Y AND (the comma) X is male.
To find the father of rajinder (goal) we use the rule father(X, rajinder)
X is instantiated to jane, and the rule male(jane) is applied, which gives a False.
Prolog backtracks to find a match for the rule male(x) until it becomes True at Charnijt.
Now prolog applies again the whole rule which returns a TRUE so it outputs Charnjit.
Then the program continies looking for any other matches, and finds none, so it returns No
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

8. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Low level languages
Low level languages represent binary with mnemonics, such as…
ADD = 001 (a command)
NUM1 = (an address)
An Assembler translates the mnemonics (using a table) to produce machine code
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

9. Memory addressing techniques
An instruction in memory consists of an opcode and an operand. The operand is the data on which the operation should be applied. The method used to locate said data is known as memory addressing.
There are 5 major techniques of memory addressing
Immediate addressing
Direct addressing
Indirect addressing
Indexed addressing
Relative addressing

10. Immediate addressing
Immediate addressing is so-named because the value to be stored in memory immediately follows the operation code in memory.
For example, if you wanted to add 3 to the contents of the accumulator, this would simply be: ADD 0011
The opcode is ADD and the actual data is (binary 3)
Advantage
It is very fast since the value to be loaded is included in the instruction.
Disadvantage
The data cannot be used by other instructions
In our example, the value 3 would have to be repeated in every instruction that needs it
It is difficult to change the value.

11. Direct Addressing
Direct addressing points to a location in memory that holds the data.
E.g. ADD 0101 means that “go and find whatever is in memory address 5 and add it to the accumulator.”
Advantage:
It is simple to use because you don’t need to know the data in the memory location
Disadvantage
The number of memory addresses that can be accessed is limited by the number of bits available for the operand.
If the operand was a 16 bit number, 216 memory locations can be addressed giving us 64KB of memory which isn’t a lot.

12. Indirect addressing
Indirect addressing points to a memory location that holds another memory location that holds the data to be used.
E.g, ADD 1011 means “go to memory location 11 where you’ll find another memory location; go to this other address and use the value found there”
Advantage
It allows access to larger memory addresses as the full size of register is used for an address.

13. Indexed Addressing
Indexed Addressing uses a special register called the index register
The value of the index register is incremented each time it is referred to
The memory address given in the instruction is then adjusted according to the value of the register.
Advantage
The same instruction can be repeated but applied to a different memory location each time.
This is useful for processing an array, which would be stored in a contiguous block of memory.

14. Indexed addressing: example
suppose we wanted to add up every number in an array. Normally, we would execute:
ADD0001
ADD0010
ADD0011
etc.
However, the operator is the same (“ADD”), only the operand changes. This means we could repeat the same instruction and use the index register to increment the memory address.

15. Relative addressing
When we write a program, we don’t know where in memory it will be held during execution, but we do know that it will go into memory as a single block.
In relative addressing, all memory addresses are relative to the first one.
Example: ****
If the first instruction in a program is ADD 100, all subsequent addresses will be relative to 0100.
This means that if the next instruction is ADD 010, the memory address that is accessed is =110.

16. Methods of defining syntax
Each language uses a different set of rules to define its syntax.
E.g. a Visual Basic compiler would not understand C++ syntax and vice versa.
The RULES of a language are specified using Backus Naur Form (BNF) or syntax diagrams.

17. Backus – Naur Form (BNF)
It is an internationally accepted notation language to define the syntax of a system or programming language. Note that It is necessary to unambiguously define the syntax of a computer language.
Suppose we wanted to define a digit using BNF.
we say <digit> ::= 0|1|2|3|4|5|6|7|8|9
Brackets < > mean ‘can be defined further’
::= means ‘is defined to be’
| means ‘or’
We could then define an integer as follows. <integer> ::= <digit> | <digit><integer>
This allows an integer to be a single digit or a digit followed by an integer. This part of the definition is recursive. It allows any number of digits.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

18. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
BNF Example.
Defining of a staff code being entered into a database.
<DIGIT> ::= 0|1|2|3|4|5|6|7|8|9
<LETTER> ::= A|B|C|D|E
<STAFF_CODE> ::= <LETTER><DIGIT> | <STAFF_CODE><DIGIT>
This means “a staff code can be a letter and then any number of digits.” SO
D4, E644678, A564 would all be valid staff codes.
The following examples would be invalid staff codes:
Hf – because H is not defined to be a letter
d4 – because a lowercase ‘d’ is not defined to be a letter
A56E – because you can only have a letter at the beginning of a staff code
AD574 – because the definition only allows a single letter at the beginning of a staff code.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

19. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
BNF Example 2
Defining a variable (which is which is a sequence of one or more characters starting with a letter)
<variable> ::= <letter>|<variable><character>
<character> ::= <letter>|<digit>|<under-score>
<letter> ::= <uppercase>|<lowercase>
<uppercase> ::= A|B|C|D|E|F|G|H|I|J|K|ZL|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
<lowercase> ::= a|b|c|d|e|f|g|h|i|j|k|zl|m|n|o|p|q|r|s|t|u|v|w|x|y|z
<digit> ::= 0|1|2|3|4|5|6|7|8|9
<under-score> ::= _
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

20. VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Syntax diagrams
Syntax diagrams are diagrammatic way of representing a BNF definition.
The staff code example from slide no. 18 would be represented as follows
LETTER
DIGIT
STAFF_CODE
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

21. Example 3: Signed integer
BNF for Integer (signed or unsigned)
<integer> ::= <unsigned integer>|<signed integer>
<signed integer> ::= + <unsigned integer>| - <unsigned integer>
<unsigned integer> ::= <digit>|<digit><unsigned integer>
<digit> ::= 0|1|2|3|4|5|6|7|8|9
To add a sign to the integer you just add signs !
Syntax diagram for signed integer
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi
Digit
Digit + -

22. Reverse Polish notation
Reverse Polish Notation is an unambiguous method of writing mathematical expressions without brackets.
Adding two numbers is written as A + B
This is called infix notation as the operator is in between the operands
To multiply the result by two, we’d write 2 * (A + B)
We need brackets to make sure it’s done in the right order.
Polish notation avoids brackets by putting each operator before its operands. A + B would become +AB and 2 * (A + B) becomes *2+AB
Reverse polish notation is simply polish notation written the other way around.
So those examples would be AB+ and AB+2*. This can be read as ‘take the numbers A and B and add them together, then take the result and the number 2 and multiply them together.’
Reverse polish notation puts each operator after its operands.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

23. Converting between Reverse polish and Infix notations
Binary tree diagrams can be used to convert between normal infix notation and reverse polish notation.
A binary tree is a tree data structure in which each node has at most two child nodes, usually distinguished as "left" and "right".
Nodes with children are parent nodes, and child nodes may contain references to their parents.
VCN CIE COMPUTING 9691/3 ::: Compiled by Benjamin Muganzi

24. Traversing a binary tree
Traversing a tree: IN-ORDER (infix) Using this method, we must visit the tree in this order:
Visit the left sub-tree.
Visit the root node.
Visit the right sub-tree.
So we would have DBEAC
Traversing a tree: POST-ORDER Using this method, need to:
Using our binary tree, the order that we would be: D E B C A

25. Converting… Consider the: 3 * (6 + 2) - 4 / (3 + 7)
If we wanted to get the infix notation from a binary tree, we would follow this algorithm, which is known as 'in-order':
1) Traverse the left sub-tree
2) Visit the root
3) Traverse the right sub-tree
This would give us: 3 * (6 + 2) - 4 / (3 + 7)

26. Converting
If we wanted to get the reverse polish notation, we would follow this algorithm, which is known as ‘post-order':
1) Traverse the left sub-tree
2) Traverse the right sub-tree
3) Visit the root
This would give us: * /  

27. Using stacks Stacks are also associated with reverse polish notation.
They can be used to evaluate expressions using the following algorithm
Read expression from left to right
If a number is encountered, PUSH it onto stack
If an operator is encountered, POP two number from stack and carry out operation
PUSH result onto stack
End if last item in expression has been dealt with.

28. Example: using stacks 1 2
We have the expression * / -
The numbers 6, 4 and 5 are encountered so they are PUSHED to the stack one by one.
Then an operator is encountered: + The top two numbers are POPPED (4 and 5) and the operation carried out on them, the result is PUSHED to the stack (9)
Another operator is encountered: * This is applied to the two items POPPED from the stack (9 and 6). The result is PUSHED onto the stack
The numbers 25, 2 and 3 are PUSHED onto the stack as they are encountered
The ‘+’ is encountered so the 3 and 2 are POPPED, added together and the result is PUSHED (5)
The 5 and 25 are POPPED and divided (notice the order of the operands) and the result, 5, is PUSHED.
Finally, the 5 and 54 and POPPED and subtracted and the result is PUSHED back onto the stack. This is our final answer. Again, notice that the first operand to be POPPED is placed to the right of the operator i.e 4 3 6 5 7