Many problems can be solved with either macros or higher-order-functions. The advantage of macros is two-fold (macros also have disadvantages, and Lisp allows you to use either solution; deciding which to use is often a matter of taste):

1. Syntax can be more familiar

2. Performance (to the extent that there is overhead for functions-calling-functions).

For example, let's consider a hypothetical lispy language that doesn't have a short-circuiting "and" operator. Macros would let you implement something to used like this:

  (and (foo x) (bar y))

Higher order functions would require you to do something more like:

  (and (lambda () (foo x) (lambda () (bar y))

More noise, and more work for the optimizer (or in the worst-case, more work at run-time). Languages that rely heavily on higher-order-functions will tend to have terser syntax for anonymous functions. For example in javascript you might do:

  and(()=>foo(x), ()=>bar(y))