Question

What sort of evaluation involves the evaluation of expressions in each part of a compound, conditional Boolean expression only as much as necessary to determine whether the expression is false? a. sequence b. sequential c. short-circuit d. smart

Answer 1

The answer to this problem clearly, is the option c) short - circuit evaluation method.

But let me first clearly explain about each and every option and why the other ones are incorrect.

The other options provided are not exactly considered as types of evaluation methods for any Boolean expression.

They have more to do with various other domains than with being a form of evaluation procedure for the Boolean expressions.

For example, a) sequence has more to do with the arrangement of any abstract data type in a given manner (one after the other in a cascaded format)

Whereas, b) sequential evaluation may be referred to as the evaluation of a particularly specific given Boolean expression in a sequential manner i.e. from LHS to RHS traversing over the expression and simultaneously evaluating whatever we keep on encountering at the same time (i.e. the generic process that is normally followed in most cases by the compilers and IDE to evaluate a given Boolean conditional expression.

And, d) smart is generally used in the domains of managerial roles and project / program management techniques as a form of goal - setting criterion. It follows the order of Specific, Manageable, Achievable (Attainable), Relevant / Realistic, and Time-Bound (which basically signifies the characteristics of how the goal should ideally be). Therefore, does not have much to do with being a procedure to evaluate the Boolean conditional expressions.

Now, finally coming back to the actual answer to your problem which is option c) Short - circuit :-

Short - circuit evaluation basically refers to a method of evaluating the Boolean conditional expressions. This method is made to be followed by the compiler during specific use-cases (I've attached the examples for the same down below for a clearer understanding)

It is also generally referred to as Minimal evaluation or McCarthy evaluation method. In this method, the expression being evaluated from the LHS to the RHS gets abruptly stopped mid-way itself as soon as the current condition being evaluated returns false (or becomes untrue).

These are generally used when checking for multiple conditions within the same if() or while() or do-while() statements which are compounded together by logical AND (&&) / logical OR (||). And as and when any one of these conditions negates (returns false), the evaluation stops then and there itself and the further remaining expression is not even evaluated anymore.

So, here you can generally bring the fact that the order in which you choose to write the conditional statements can make a huge difference to your own advantage as well. This is said to be a good programming practice.

For examples :-

1)

*compounded by AND && -> anyone is False, others are not evaluated at all*

(q != 0) && (a / q > 75)     // this expression will run even when q == 0 (because as soon as the 1st condition q != 0 becomes false, then the 2nd condition (dividing by 0) is not even evaluated)

(a / q > 75) && (q != 0)     // this expression will lead to a runtime arithmetic exception when q == 0 (because we start by checking the 1st condition (which is division by 0) and that itself crashes the program and leads to a runtime exceptional case)

2)

*compounded by OR || -> anyone is True, others are not evaluated at all*

if (p == q || r == s || t == u)    
{
    // Do some tasks
}

If 1st condition (p == q) becomes true, then other 2 are never evaluated at all. However, if p != q then 2nd condition (r == s) is checked and if this is true, 3rd condition is never evaluated and if even the 2nd condition is false, then the 3rd condition (t == u) would solely determine whether the if() block gets executed or not based on its own result.

3)

*compounded by OR || -> anyone is True, others are not evaluated at all*

if (isValid() || areComplements() || isTrue())     
{
    // Do something
}

Again similarly, if isValid() method returns true, then the other 2 methods are never evaluated and their outcome would matter only if the preceding methods return false and so on..

So hope you get the concept behind Short - Circuit Evaluation methods thoroughly.

And hence, the answer to the given problem will be option c) short - circuit