A simple methodology for specifying the logical behaviours of an information system’s business components

The main goal of this methodology is to specify business logic in a way that can be understood by both the business people who use information systems and by the technical people who build them.

Even though pseudo code is not the only way of achieving that goal, it is the way that is described here given its common use and high level of understanding amongst its users.

Pseudo code is often referred to as structured English as it is based on a very simple subset of the English language.  Pseudo code results in logic specifications that are not only clear but also complete.  The translation of good pseudo code into real code (what computer programmers produce) is mostly a mechanical task.

Because it is all about the business, all pseudo code should be formulated using the vocabulary of the business domain instead of the vocabulary of the information technology.

For example, “Get the next line item that is part of the order.” is a good way of phrasing an action in pseudo code as it uses terms that mean something to the business people.

However, “Increase current line item number by one and read the line item record for current line item number.” is not a good way of phrasing the same action in pseudo code as it uses terms that mean something only to the technical people who will develop and implement the logic.

Only three (3) general programming constructs are required to specify the flow of control in pseudo code:

Selections are further subdivided into two (2) more refined constructs:

Iterations are further subdivided into three (3) more refined constructs:

Counting the “sequences” construct, the two “selections” ones and the three “iterations” ones, six (6) basic programming constructs are available for specifying the flow of control in pseudo code.   Each one of these constructs can be embedded inside any other construct.

Apart from well chosen key words and symbols, pseudo code does not follow a rigorous notation since it is meant to be read and understood by people, not by computers.

The methodology presented in this document is not a universal standard.   Such a universal standard for pseudo code does not exist.   However, the methodology presented here, for specifying logic in the form of pseudo code, has proven itself useful in many projects and is easy to learn and use.

A sequential construct is specified by writing one action after another, each action on a line by itself, and all actions aligned with the same left indent.

The actions are performed in the sequence (top to bottom) that they are written.

Here is an example of a sequential series of actions:

The selection of one series of actions over another, depending on the existence or inexistence of a condition, is specified as follows:

In the above syntax, the bolded “if” and “else” words are key words indicating the beginning of the two clauses of that construct.  The “else” clause is optional.  The condition to be tested is put inside parentheses.  The two alternate courses of actions are expressed as separate sequences (that is the first kind of construct) of actions listed inside a matching pair of curled brackets.  Here is an example of an “if ... else” selection of actions:

The selection of one series of actions out of many potential ones, depending on the data value returned by an expression, is specified as follows:

In the above syntax, the bolded “case” and “default” words are key words indicating the beginning of alternate courses of actions corresponding to different values that the expression to evaluate can take.  There can be as many “case” clauses as required and the “default” clause is optional.  The order in which those clauses are specified is important as it is the first one having the right value that gets the control; any following clause gets bypassed whether it has the right value or not.  The “switch” key word marks the beginning of a series of cases referring to the same expression.  The expression to be evaluated is put inside parentheses.  Here is an example of a “case” selection of actions:

The execution of a group of related actions a certain number of times is specified as follows:

In the above syntax, the bolded “for” word is a key word indicating the beginning of a series of actions to be performed iteratively a specific number of times, as specified by the iteration expression.  This programming construct is often called a “counting” loop.  The iteration expression appearing inside parentheses determines the exact number of times that the actions within the loop will be executed.  Here is an example of a “for” iteration of actions:

The execution of a group of related actions while a certain condition exists is specified as follows:

In the above syntax, the bolded “while” word is a key word indicating the beginning of a series of actions to be performed iteratively as long as the condition to be tested exists.  The condition is tested before any action gets executed within one iteration.  The series of actions is performed until the condition is not true any more.  The condition to be tested is put inside parentheses.  Here is an example of a “while” iteration of actions:

The execution of a group of related actions until a certain condition becomes true is specified as follows:

In the above syntax, the bolded “do” word is a key word indicating the beginning of a series of actions to be performed iteratively until the condition to be tested becomes true.  The sequence of actions is performed at least once as the condition is tested only after one iteration.  The series of actions is performed until the condition becomes true.  The condition to be tested is put inside parentheses.  Here is an example of a “do ... until” iteration of actions: