On the subject of good tricks, I like to put this debugging snippet in all my Makefiles. It supports typing `make print-VAR1 print-VAR2` and it'll dump the values of VAR1 and VAR2 (this could be extended to also show `$(flavor $star)` and `$(origin $star)` and other little details, but usually I just simply want the final value).

    define newline # a literal \n


    endef
    # Makefile debugging trick:
    # call print-VARIABLE to see the runtime value of any variable
    # (hardened a bit against some special characters appearing in the output)
    print-%:
            @echo '$*=$(subst ','\'',$(subst $(newline),\n,$($*)))'
    .PHONY: print-*

I like to use a `showconfig` rule so that `make showconfig` will display all public vars and give their default values. It ends up being a little like `./configure --help`. But I see now that I could tighten that up a bit with the above rule and something like `showconfig: print-VAR1 print-VARX`. Thanks!

That sound pretty cool!

I eventually did something similar to that and built something alike to `make -p`, by hand, that was also a bit like `./configure` or CMakeCache.txt. It could then be read back into `make` and bypass a fair bit of configuration testing work (it's much faster on cygwin anyways). I got a bit too nervous at the automagical complexity though and never made a pull request (plus I only just fixed it to work on the old version of make that ships with macOS). But I thought perhaps you might find this fascinating for the levels of make hackery to try to untangle: https://github.com/JuliaLang/julia/compare/master...vtjnash:...

Make is useful, but I really wish the implementation had evolved over the years, making stuff like this natural.

As an example, python has doc strings accessible via __doc__

  $ python
  >>> class foo:
  ...   '''description of foo'''
  ... 
  >>> foo.__doc__
  'description of foo'
  >>>

That's awesome! I've always been annoyed that there isn't a built-in `ls` like feature, but this is a really clean solution.

    make -p

the main problem is that make itself doesn't support a concept of "hidden files". also a problem is that GNU make comes with lots of implicit rules, so you really need something like make -R -r -p for this to remotely work.

> make -R -r -p

I tried that on a small Makefile with 4 simple rules, and it spit out 2436 lines of diagnostic information. Which to be fair is less then `make -p`'s 8687 lines, but it's still completely useless to me.

I learned about this trick from the same blog post. I tweaked a little to suit my needs. But wow, it is such a game changer. This means all you need to write in auxiliary docs is 'make help'. That's it.

This is a great trick, thanks! Much appreciated.

This is great, thanks!