After an algorithmic problem is decomposed into subproblems, we can abstract the subproblems as functions. A function is like a sub-algorithm. Similar to an algorithm, a function is specified by the input property, and the desired input-output relation.

To use a function in the main algorithm, the user need to know only the specification of the function- the function name, the input property, and the input-output relation. The user must ensure that the inputs passed to the function will satisfy the specified property and can assume that the outputs from the function satisfy the input-output relation. Thus, users of the function need only to know what the function does, and not how it is done by the function. The function can be used a "black box" in solving other problems.
Ultimately, someone implements .the function using an algorithm. However, users of the function need not know about the algorithm used to implement the function. It is hidden from the users. There is no need for the users to know how the function is implemented in order to use it.
An algorithm used to implement a function may maintain its own variables. These' variables are local to the function in the sense that they are not visible to the user of t~e function. Consequently, the user has fewer variables to maintain in the main algorithm, reducing the clutter of the main algorithm.
 

A sequential statement is composed of a sequence of statements. The statements in the sequence are executed one after another, in the same order as they are written in the algorithm, and the control flow is said to be sequential. Let S1 and S2 be statements. A sequential statement composed of S1 and S2 is written as
S1
S2
In order to execute the sequential statement, first do S 1and then do S2. The sequential statement given above can be represented in a flowchart. The arrow from S 1 to S2 indicates that S1is executed, and after that, S2 is executed.

Let the' input property be P, and the input-output relation be Q', for a problem. If statement S solves the problem, it is written as
1. '-- P
2. S
3. -- Q
If we decompose the problem into two components, we need to compose S as a sequence of two statements S 1 and S2 such that the input-output relation of S 1, say R, is the input property of S2.
1. -- p
2. Sl
3. -- R
4.. S2
5. -- Q

1. right_angled(a, b, c)
2. -- inputs:
3. -- outputs: result = true if c2=a2+b2
4. result = false , otherwise
5. if square (c) = square (a) + square (b)
6. result := true
7. else
8. result := false

Alternative statement analyses the problem into two cases. Case analysis statement generalizes it to multiple cases. Case analysis splits the problem into an exhaustive set of disjoint cases. For each case, the problem is solved independently. If C1, C2, and C3 are conditions, and S1, S2, S3 and S4 are statements, a 4-case analysis statement has the form,
1. case C1
2. S1
3. case C2
4. S2
5. case C3
6. S3
7. else
8. S4
The conditions C1, C2, and C3 are evaluated in turn. For the first condition that evaluates to true, the corresponding statement is executed, and the case analysis statement ends. If none of the conditions evaluates to true, then the default case S4 is executed.
(i) The cases are exhaustive: at least one of the cases is true. If all conditions are false, the default case is true.
(ii) The cases are disjoint: only one of the cases is true. Though it is possible for more than one condition to be true, the case analysis always executes only one case, the first one that is true. If the three conditions are disjoint, then the four cases are (1) C1, (2) C2, (3) C3, (4) (not C1) and (not C2) and (not C3).

There are mainly three different notations for representing algorithms.
(i) A programming language is a notation for expressing algorithms to be executed by computers . 
(ii) Pseudo code is a notation similar. to programming languages. Algorithms expressed in pseudo code are not intended to be executed by computers, but for communication among people.
(iii) Flowchart is a diagrammatic notation for representing algorithms. They give a visual intuition of the flow of control, when the algorithm is executed.