You apparently tag *while* you are typing the original source. So, for example: Bezier or Special Cases, or See ]
If I know I will be including several large code fragments or tables, I will *plan* on importing them as separate flows so they can be efficiently handled as separate entities. E.g., anything more than ~10 lines of code warrants being set off from the main body of text as a "figure" -- to help ensure it stays together, visually, and doesn't get split up over different pages (in much the same way that a table wants to be a cohesive entity -- not just columns of text *within* the regular body of text).
So, how are you *proofing* the result? *Hoping* you got it right when you were typing all that ASCII text *prior* to importing it to your WYSIWYG previewer? *Hoping* you remembered to use "open double quote" and "close double quote" to bracket ?Bézier? instead of straight double quotes ("Bézier") or, worse, half-and-half (?Bézier" or "Bézier?)
Or, do you zoom around the entire document on "high magnification" hoping you catch everything one "peep-hole" at a time?
So, you are doing all your tagging *before* seeing it typeset. Oh My! instead of benefiting from a GUI to apply tags as needed.
I.e., "emphasis", "heading", "footnote", "code", etc. don't exist for me *until* layout. If I import a piece of code, it *is* a legitimate ".c" file -- not "source code adorned with layout/formatting info".
What's your obsession with "trusting your typesetting system"? I trust mine as well! Difference is, you apparently choose to type in all those tags *before* the "input" has been typeset. And, you're thrilled that this isn't corrupted as it is rendered "typographically".
Mine isn't either! I just don't spend time typing "\vfill\eject" when I want to insert a page break. Or, "\line{\hfil Flush right}" to cram something against the right margin ("padded left").
I.e., you can read the *content* of one of my documents "as a normal human being" before it is imported. No concern over "Gee, what does '\hrule' mean?"
If you find something that needs to be corrected while proofing the *typeset* rendering of the document, do you correct it
*in* that WYSIWYG? Or, do you have to re-open the "source" document, locate the corresponding portion that contains the text/tag/formatting that you want to alter, tweek that, flush it to disk and then "refresh" the WYSIWYG rendering? *When* you correct it, how do you readily verify that you've corrected it correctly? E.g., in my original document, the footnote: Unqualified, the term ?Bézier?, herein, shall refer to cubic Bézier curves did not contain quotes around the first Bezier reference. They were added while previewing the typeset version ("Crap! I need to quote that!"). And, I had to make sure I wasn't quoting with the "wrong" quotation marks. Just zoom in (TO OVERCOME THE LIMITATIONS OF THE MONITOR) so you can see that you are typing '?' and '?' and NOT '"'. Or, open the *source* document and type "\lq\lq" and "\rq\rq" [I'd rather *see* the effects of what I'm typing *while* I'm typing it -- instead of having to "refresh" the rendering and remembering to double-check that (along with any other changes I may have made)] *I* can "zoom in" (and out!) too! But, each time you do that, takes time and effort. And, takes time for you to "get your bearings". Should I "zoom out" so I can see how any text I am inserting effects the layout of other objects around it, on the page. Then, zoom in to verify that I have typed what I *think* I was typing?How do you add callouts to your illustrations? To as great an extent as is possible, I *don't* include text in "images" that I import (hard to do with schematic fragments!)
E.g., all of my Bezier curve examples are created in Mathematica and imported without any text annotating the points, coordinates, axis, etc. Instead, these are pasted on as callouts *after* the image has been imported. This allows me to ensure that the designations for each point appear in the same "font" and representation that they are referenced as in the body text.
[One problem has been getting Mathematica to use the same "colors" that the publishing program uses! :< ]It also lets me change my mind as to how I want to reference them without having to revisit Mathematica to "tweek" the image I've asked it to generate. For example, I originally labeled the points A, C1, C2 and B (A and B being endpoints while C1 & C2 were control points). When I typeset the equations for the curve, it was much easier to change this to P0, P1, P2, P3 -- as the curve could be expressed as a linear combination weighted Pi. I could make that change
*within* the publishing program without requiring any changes to the "image" onto which they were laid.From your descriptions and my *assumptions* as to how you work, I gather you don't spend much time preparing these sorts of documents. That it's more of an "accessory" activity for you. Someone else gives you a formal specification that you can just *read*. Someone else prepares the final documentation for the user.
*Your* documentation can fit in comments in source files, etc.I tend to produce about 4 pages of formal documentation for each page of code: a page of spec, a page of "documentation" (explanations of the implementation, etc.), a page of test strategy and a page of "user documentation". Some subsystems tip this balance one way or the other but it tends to average out over the course of a project (hardware projects have different sorts of documents but similar "effort weights")
[Of course, this lets me make my source code "more dense" because I can move any lengthy descriptions, explanations, derivations, etc. out of the commentary and *assume* anyone reading the code already understands the requirements, theory and structure laid out in those documents. The source code is then "just an implementation" :> ]So, I can spend 30 pages describing characteristics of cubic Bezier curves that my code relies upon -- and, then never have to explain *why* I am doing something *in* the code that relies on those objects.
Of course, preparing such documents is a lot more "expensive" than just adding commentary to some source. But, the goal of documentation is to ensure folks *understand* the issues being presented -- not just a "check off" item that you can claim you have satisfied.
[To that end, my introduction of multimedia and interactive "demos" to the documentation will hopefully be a net asset. Provide a richer means of presenting concepts instead of just relying on lots of glyphs on paper...]