# Scala Principles in a Nutshell (Part II)

Every computation in `Scala` is treated like a mathematical function, and the evaluation of these functions is made following the `Substitution Model` which has many strategies, two of them are:

##### Call-by-value Strategy

This is the strategy by default, the arguments of the function are evaluated before the function itself, like this example:

`def test(x:Int, y:Int) = x+x`

``````test(7,2*4)
test(7,8)
7+7
14
``````
##### Call-by-name Strategy

In this case, the arguments aren’t evaluated before the function is called, they are evaluated whenever they appear in the function, like this:

`def test(x:=>Int, y:=>Int) = x+x`

``````test(7,2*4)
7+7
14
``````

#### And…what is this for?

Saving time. In the previous examples, the `call-by-name` strategy is faster because it has fewer evaluations than the `call-by-value` strategy.

#### This strategies also apply to values?

Yes, they do.

The `def` form uses `call-by-name` strategy and the right part of the assignation is evaluated with each use of the value.

The `val` form uses `call-by-value` strategy and the right part of the assignation is evaluated in the definition itself.

For example, if we define this function:

`def loop: Boolean = loop`

And then we make this assignation:

`def x = loop`

We cause an infinity loop only if x is used in the rest of the code.

On the other hand, if we make this assignation:

`val x = loop`

This definition already causes an infinity loop.