Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise.
If this question can be reworded to fit the rules in the help center, please edit the question.

Looks like call-by-name in the term-substitution sense can be implemented as a combination of lazy evaluation (available in Haskell, Scala, various Lisps) and dynamic scoping (available in Haskell, various other Lisps).
–
Jon PurdyDec 1 '13 at 20:43

1

@JonPurdy Haskell is call by name, it just also shares the result. This invalidates the term-substitution way of thinking though. You can force reevaluation simply by wrapping the argument in a trivial lambda \_ -> a when called will eval a each time.
–
jozefgDec 2 '13 at 4:16

Would I use it?

I see no reason to, even considering the advantages put forward. Pointers and short-circuit evaluation prevent expression evaluation as much as I need it, and I'm quite happy with the semantic models I use regularly.

eval() is just about as insecure as you can get. Unless you have a language in mind that can sandbox the eval'd statement (which would then mean it's nowhere near as flexible), which you really need to indicate.
–
IzkataSep 6 '12 at 18:06

Notice how I'm passing the name of the function add in as a parameter in the apply function, just like I would with any other variable. The f function isn't evaluated at the time of declaration, simply because it can't be evaluated; its body doesn't exist at declaration. But this opens up for so many possibilities in terms of reducing boilerplate code. Like say you have 2 functions/methods that both do the exact same thing, apart from just one very specific line; instead of having to write the exact same thing twice, you can write it once, and then pass the one line of code that stands out, by name.

If I hadn't used C#'s ability to pass by name, in the form of higher order functions, I would've had to write the code in the PostHelper twice, with the one minor change that one says UploadString, and the other says UploadStringAsync, doing like I did saves me repeated code, and it even lets me expand it later if I want to add more variations of the method. Because clientFunction is evaluated lazily I can make my code much more scalable.

Indeed we are saying that pass by name uses textual substitution or otherwise macro substitution.

If we are using pass by value or pass by reference we are merely passing values or addresses, but we can't pass an expression such as i*x[i]; (in pass by reference it evaluated into a temporary location whose address is passed ), but it is possible with pass by name.

For example if we want to perform the sum of the expression i*x[i] where i varies from 1 to 5 using a function, we can write a function that uses pass by reference as written below (don't mind the syntax)