Examples of Complex Problems, Real Solutions – Part 1

In the traditional legal office environment, attorneys generally relied on secretarial and document support staff to do the work of creating and editing documents, which was considered a clerical task. As attorneys increasingly became computer users, they relied on the same staff for assistance with the more technical issues that complex software presents. Predictably, this didn’t work, and secretarial and document support staff numbers have diminished greatly.

In today’s environment, many attorneys have reasonably good computer skills; however, most are not “techies.” With modern office programs, there are tremendous opportunities for efficiency, but to know many of them and to be truly efficient requires being a techie.

A person with real technical skills as well as document skills is much more valuable than a traditional document support staffer. This post examines a few examples of situations where this is evident.


Numbering in Word

Numbering paragraphs in Word has vexed many people over the years. The simple fact is that it is a complex subject. There are so many ways that someone might want to number items in a document, and so many ways that Word supports numbering, that the interface cannot effectively present them all.

Traditionally, a firm’s technology department would set up a few numbering schemes that are common in that firm’s documents, and train the users to apply the numbering using the firm’s unique method. The users could thus handle the customary documents.

Now, however, it is common for attorneys to share documents with clients and with other attorneys from different firms. Since different firms have different methods of applying numbering, users face unfamiliar schemes.

To meet this challenge requires understanding how numbering works in Word, which is, as I’ve stated, a complex topic. Many traditional support staff users simply cannot handle it, telling attorneys that a document must be reformatted to the firm’s template, or that the document is “corrupt” or “unstable,” or some such excuse.

Understanding Word numbering requires study and training in how software works—data structures, lists, objects, etc. A highly skilled person who has studied computer science and Word can handle the challenges that numbering presents.

See separate blog post on numbering for more detail.

Find and replace using patterns

Word has a feature in its Find and Replace function called “wildcards.” It is infinitely useful in common document editing scenarios, yet it is almost completely unknown and likely unknowable to the traditional document support staffer.

Wildcards are a way of finding and replacing using patterns, rather than literal text. You search for a pattern, and replace, optionally preserving part of the specific text you find.

Since a pattern will cover many text items, it’s a way of doing multiple things at once.

Examples of where wildcards can dramatically improve efficiency:

  • Cleaning up a document converted from PDF. These documents have paragraphs broken up by hard returns in the middle of sentences (among other recurring patterns). A wildcard expression (representing the pattern of a character not typically found at the end of a paragraph—e.g., not a period or semicolon—followed by a paragraph mark) can be used to find and fix these.
  • Spaces. A wildcard can match extra spaces or not enough spaces. You don’t need to look for, literally, “two spaces.” You can look for “two or more” or “less than two.” (Examples: 1. You want two spaces at the end of sentences. Look for [period][one space][capital letter]; replace with [period][two spaces][the capital letter you found]. 2. You want to remove extra spaces in mid-sentence. Look for [not a period][two or more spaces]; replace with [the not-a-period you found][one space].)
    Without using wildcards, this stuff is maddeningly repetitive. You can hear traditional word processors hacking away at their keyboards for long stretches. “Whack!-boom-boom. Whack!-boom-boom. Whack!-boom-boom. Whoops!” That’s what it sounds like.
  • Defined terms. A wildcard expression can represent a pair of quotation marks and the text between them. (Advanced: I’ve written macros to find all quoted terms in a document, and format them, or output the terms and their locations to another document, which can be used as a helper in checking the defined terms.)

There are many other situations where wildcards are useful, many of which will be specific to a particular document. Being able to think in wildcards is invaluable, in terms of both speed and accuracy.

Track changes

Track Changes is another tremendously useful and efficient feature in Word that is underused in firms, likely due to skills limitations. Like numbering and wildcards, it is complex enough that it is optimally suited for educated users. Computer science knowledge (particularly the concepts of objects and scope) helps in mastering it.

When you use track changes, Word keeps track of the type of change you made (insertion, deletion, formatting, etc.), when you made it, and who made it (using the author information that is set at the scope, or level, of the entire MS Office suite).

Track changes are stored in the document as “Revision” objects. They contain the who-what-when data outlined above. What they do not contain, unlike simpler comparison programs, is presentation information, i.e., the color and other appearance attributes of the tracking itself, seen on screen and in print. This formatting is generated by the Word program at runtime, based on user-level settings (set through the Track Changes Options dialog box).

Therefore, it is a mistake to think that track changes in any document will look the same to another user. Don’t say, “My changes are in red,” or something like that. Understand that each user has the ability to view changes their own way. The data in the track changes, however (who, what, when), is always there.

Unlike a simple redline from a comparison program, you can get markup from numerous colleagues, and review and accept or reject each item of markup, all without disturbing the format of your document. Not disturbing the format also means you don’t need to keep markup out of your main document and duplicate changes from a redline. Just version up and do markup directly in the document.

Converting documents

Converting a document (typically from a PDF) involves so many skills, it is a tour de force for a truly skilled person. Even though you might consider it low-end as far as document work, the difference between the modern approach and the traditional approach will result in significant time savings.

(Advanced: One of the primary time drains in converting documents is reapplying character-level formatting after the plain text of the original is pasted into the new document. I’ve written code that preserves the character-level formatting without bringing over any of the paragraph-level formatting.)

Programming perspective

Almost everything in Word that can be done from the user interface can also be done from a programming interface, and, not surprisingly, much faster.

All of the above examples—numbering, wildcards, track changes, conversions—can be programmed to a great extent. Someone who understands the software and the document requirements, as well as knows how to program, can do such things as:

  • Create numbering outlines on the fly (where a document requires more than one simple list), or edit an existing outline;
  • Programmatically find and replace text, including patterns;
  • Manipulate track changes (e.g., accept all changes from a certain time frame, reject all changes for certain sections, etc.);
  • Automate much of the conversion process.

There are many more examples of the vast benefits of the modern model. More on this soon.

2 thoughts on “Examples of Complex Problems, Real Solutions – Part 1”

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>