Good techniques to keep track of error-freeness without ending up having to proof-read all of a long finished text?

This is a problem that I've had, but I assume that it's in fact quite common problem.

The problem is:

  • You write your text (e.g. a research publication) and in the first passes, you blend adding information and checking references and grammar. It's possible that you also overlook checking grammar thinking that "well I will come to it later, once I figure out that the information given works".
  • Now, you possibly lose track of what you've checked and what you haven't, since you multitask many things.
  • If you continue doing this to the end of the text you will soon have, say, 150 pages of text where you cannot tell anymore which parts have been checked up to what point. And now you need to check the full 150 pages.
  • But it's possible that you couldn't have checked them earlier, since you were having this multitasking going on.

So how does one merge checking and producing text, so that it doesn't end up like this?

  • 1
    In programming, the solution is 'versioning' where back-ups are created with clear dates, and some documentation to say what sections have been edited.
    – wetcircuit
    Nov 13 '21 at 15:42
  • You can't assume you got all the mistakes in a section after you check it.
    – JRE
    Nov 16 '21 at 8:00
  • 2
    Does this answer your question? Are there techniques that would minimize need to proof-read?
    – Blub
    Nov 16 '21 at 8:27
  • I'm voting to leave open as I feel this question is more specific (and with better answers) than the proposed duplicate, which doesn't really cover the specific scenario asked about here. Nov 21 '21 at 15:57

Give Up And Go Over It Again (and again, and again):

If you are going through a long text and you keep fixing stuff, adding details, and cleaning up issues, then it doesn't matter if you got it all or not. You need to do it again.

One of the keys to great writing is re-writing. Editing and proof-reading and fact-checking and the list goes on and on. If you go through your work and find no issues, then GREAT! It means it's time to send it to an editor, or beta readers. They'll tell you what you missed, and then you can start all over fixing the issues they bring up.

A good word processing program will tell you where you left off last in the story (or at least you last edit). So this will at least tell you where you are in the process. But short of being very strict and only doing one kind of editing in a pass (like grammar), you'll keep finding things as you go along that need to be fixed until it's as good as you can reasonably make it.

Do you really want to create something that is 150 pages long and not have it be as good as you can get it?

  • No I think it's highly inefficient to seek errors in < 5% range from 100% of material. Because then you spend > 19x time for seeking <5% of errors. Compared to if you could have seen the < 5% errors without going through the entire text.
    – mavavilj
    Nov 16 '21 at 6:25
  • @mavavilj Don't worry, you won't get to less than 5% of errors no matter how hard you try. But if every time you go through your work, you are fixing more and more stuff, you probably haven't gone through it enough.
    – DWKraus
    Nov 16 '21 at 19:12
  • @mavavilj No offense, I've learned the hard way that when it comes to editing, enough is never enough. You might also want to let the work "rest" between cycles of editing, so the things that are wrong aren't fresh in your mind. They stand out better when you can see them from a distance.
    – DWKraus
    Nov 16 '21 at 19:52
  • @mavavilj I've written a scientific master's thesis and a couple novels in your page range, and the general rule seems to apply to both. The beta readers are a little different (an academic advisor vs a recreational reader). If your advisor has different ideas, though, go with what they say. I do acknowledge that from a practical standpoint, you eventually have to stop at some point and say enough. What kind of research is it? That can affect the requirements.
    – DWKraus
    Nov 16 '21 at 20:24
  • I don't know. I was thinking that approximating error-freeness in chunks would "mathematically" offer a higher chance of minimizing error. Rather than interpolate over the entire text. So i.e. one should aim to check problems "per chunk" of text. However the problem with this is that the chunks may not be independent (are referenced elsewhere in the text).
    – mavavilj
    Nov 17 '21 at 8:01

Use your source-control system to help

The files that have the most (and most recent) churn should be evident from your change history in Git, Subversion or whichever other source-control you use for your text. (If you don't have change control - why not?) That should help guide you to the files that need most attention.

But still read the whole thing from time to time

Although you can focus on copy-editing the files with most change, that might lull you into a false sense of security, because it's quite likely that a section you've not touched for weeks is dependent on the structure elsewhere.

As a straightforward example, if you've changed the number of factors feeding into an argument in the main text, you might find that your summary and conclusions no longer reflect the main body of the work. Real-life examples tend to be more subtle than that, and cause your sections/chapters to depend on each other.

Don't forget to read the rendered (print-ready) output from time to time, to pick up on formatting issues that aren't obvious from the source files.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.