when evaluating the procedure:

```
(define (p) (p))

(define (test x y)
   (if (= x 0)
       0
       y))
```

by evaluating:

```
(test 0 (p))
```

under both normal order and applicative order evaluation, you will see;

## applicative order

under applicative order evaluation, we would first fully evaluate any arguments to a procedure, then evaluate the procedure with those values.

to evaluate `(test 0 (p)` we would first need to evaluate `0` and `(p)`

`0` is a primitive value, and thus evaluates to the value `0`.

`(p)` is a procedure in the global environment, defined as `(p)`. we would recieve a value of `(p)`, which according to our evaluation strategy would need to be fully evaluated before we can continue evaluating `(test 0 (p))`. this would create an infinite loop as we would never reach a value of `(p)` that doesnt require further evaluation, and our program will hang.

## normal order

under normal order, we do not evaluate arguments until they are needed. thus, to evaluate `(test 0 (p))`, the following steps are taken:

```
(test 0 (p))

(if (= 0 0) 0 (p))

(if #t 0 (p))

0
```

the first line is our initial procedure application
the second is our definition of `test`, with the substitutions `x` -> `0` and `y` -> `(p)`.
the special form `if` will only evaluate the third argument, if the first (the predicate) is false.
the third line is the aftermath of evaluating `(= 0 0)` in order to check the value of our predicate, which is `true`.
the fourth line is the result of the `if` procedure, returning `0`.

notably, as we are following normal order application, we never needed to evaluate `(p)` (thus avoiding hanging our program). however had the predicate to the `if` procedure returned `false`, we would then need to evaluate `(p)` to find a value for the wider `if` application, and enter a loop.