[texhax] TeX and make

[Niall Mansfield]

Michael,

  > From: Michael Dexter <dexter at bsdfund.org>
  > Subject: [texhax] TeX and make
  > The question came up of how TeX plays friendly with make and incremental 
  > compiling. 

This question comes up regularly.  There are two answers:

1. LaTeX (we don't use TeX per se) on a useful but 8-year old server
   can process one of our books, 750 pages long, in
   36 seconds.  In fact this involves running LaTeX three times
   (for indexing reasons), so it's typesetting 60 pages/second.
   (Even more, in fact, because the 36s includes index processing,
   which is done twice.)
   On a recent laptop it runs at twice this speed, say 100pp/s,
   and on a fast new server you might get twice this again.

   This high speed means that in practice you don't need subsidiary
   .o files or the like for normal typesetting tasks.  It would be
   *nice* to have something like that, but given that the hardware
   is continually removing the imperative, I don't think it's likely.

2. In the Old Days, when running on Sun 3/50's and the like, it
   *was* necessary to divide LaTeX processing into chunks.  Here's
   how we did it.  The same approach works today.  It means you
   can typically process a chapter (30 pages, say) in less than a second.

	- Treat each chapter as a separate document.  You glue
	  the individual PDFs together at the end, to form
	  the complete book.

	- Run LaTeX on each chapter, to get an estimate of
	  its extent (i.e. no. of pages in it).

	- Compile a table of start page numbers for each 
	  chapter.  (We combined this with other definitions
	  for each chapter, so we could easily move chapters
	  within the book.)  Here's an example.
	  (See www.uit.co.uk/latex/latex-and-make-example.tex
	  for a longer example.)

	\definechap{TOOLKITS}{6}{149}{Look and Feel --- Toolkits}{`Look And Feel' Part 1 --- Toolkits for Application Programs}

	  This is Chap 6, and it starts on p149.  (\definechap
	  is our own macro.)

	- We used Imake to reduce the tedium of writing
	  the dependencies for each Make target, i.e. for
	  each chapter.

   Then we could say, e.g. "make TOOLKITS", to
   LaTeX that chapter, and incorporate the necessary
   bits of TOOLKITS.aux and TOOLKITS.idx etc. into the overall
   .aux and .idx, for cross-refs, indexing, etc.

   The obvious problem here is that tracking page numbers is manual.
   While tedious, this was unimportant in real life.  (a) By the time you're anywhere
   near a final draft of a book, your material is very stable, and pagination
   is unlikely to change.  (b) Even if it does, changing the table isn't a
   big deal.  But I'm sure it could be automated by programmers cleverer
   than me.

	Niall Mansfield