I haven't been doing Lisp in a looong time. But in other languages, I do find it annoying that my own code has to abide by certain rules that the implementers of the language do not have.

For example, most languages have "if" statements, but I can't define my own "unless" statement. I have to make do with "if not". In Lisp, it's pretty trivial to make an "unless" that works just like "if" does (except for the negation, of course).

In practice, I'm working on a pretty large Java code base right now, and if I have the need to pass around a value that is evaluated "later", then I have to pass around a lambda expression, and the syntax makes it very clear that there is a lambda expression here. For example, if I want to pass a boolean and a number and I want to make sure that the number isn't computed unless the boolean is true, then I have to write, in Java:

    someMethod(b, () -> a + 5);

Here, "b" would be the boolean, and "() -> a + 5" is the lambda expression that allows "someMethod" to avoid evaluating it in the first place.

In Lisp, I can pass a lambda, too:

    (someFunction b (lambda () (+ a 5))

But I can also define a macro, so that I can call it like this:

    (someMacro b (+ a 5))

Much less ceremony. It does, of course, however, require that you know that this is a macro and that it has special evaluation rules. If you need someFunction/someMacro often in your code base, then it makes sense to go for the macro, and your fellow devs will learn how it works. But if there are just one or two spots in the code base, it might be better to go with someFunc and the lambda because then it will be obvious how it works.

I've basically resigned myself to passing around lambdas all over the place, but it doesn't make me happy.