HOME-
PATHAGORAS™ Users' Guide, Part 4
Comments would be greatly appreciated to improve the usefulness of the text below and of the program.
  Section A. Document Assembly:
General Discussion & Concepts; Definitions

While the contents of this section of the Guide are still valid and accurate, the information has been reorganized with more illustrations and step-by-step guidance in a MiniManual that can be viewed at this link:

Document Assembly.

If you wish to proceed to a particular subject, please click
on one of the below links:
Definitions
Assembly Basics
-----------------


Summary:
 
  PATHAGORAS' powerful document assembly features are designed to make creating libraries and books of boilerplate clauses, and moving text into and out of those libraries a quick, easy and predictable process. Following the Quick-Tutorials, this Part A will provide an overview of the document assembly process along with some key definitions. The remaining sections of Part 4 will provide greater detail about the steps and the screenage associated with Pathagoras' style of document assembly.
Document Assembly: A 30-second tutorial
  1. Click the 'Document Assembly' icon to display the Libraries & Books screen.
  2. Select a book from which you wish to assemble clauses.
  3. Click <Next>.
  4. Select the desired clauses from the Clause Selection display.
  5. Click <Next>. The document is assembled, ready to be personalized.
Personalizing an Assembled Document: A 1-minute tutorial
     Assuming the assembled document contains variables have been associated with an InstantDatabase mask:
  1. Press <Alt-D> to display the InstantDatabase screen.
  2. Complete the 'Replace With' boxes with the appropriate personal data.
  3. Click <Next>. Done!
     If the document has no associated mask, but does contain variables that are denoted by brackets, e.g., [Customer], [Address], etc.
  1. Press <Alt-D> to display the InstantDatabase screen.
  2. Click the <Scan> button to read the bracketed variables onto the InstantDatabase screen.
  3. Complete the 'Replace With' boxes with the appropriate personal data.
  4. Click <Next>. Done!
Adding text to a glossary of clauses: A 30-second tutorial
  1. Highlight the text you want to add to the glossary.
  2. Press <Alt-G>. The "TermWorks" screen will appear.
  3. Provide a name and a subject for the new term.
  4. To insert term into your 'General (#1) glossary, click the left-most button titled <Add to Position #1 Glossary>
  5. To insert term into another (not #1) glossary, click the <Other Glossary> button. Check the  appropriate glossary(ies) from list, and then click <Next>. Done!

Document Assembly: General
     Document assembly is the process by which separate pieces of text and information are brought together to form a complete, final product.

     At its most rudimentary level, document assembly can consist of cutting and pasting text and other information from a variety of sources (e.g., previously written documents; text found in other sources; databases of clients' or customers' personal information, etc.) This method, however, is little better than hand typing a complete document from scratch, and it is not much faster.

     PATHAGORAS enables a user to store commonly used phrases in well organized and indexed 'books and libraries' so that standard clauses can be rapidly located and then inserted into a  document in progress.

    Typically an assembled document will contain variables (placeholders) which need to be identified and then replaced with personal information.   PATHAGORAS enables the user to accomplish this in a quick and intuitive fashion.

   All document assembly programs have the three aspects discussed below at their core. How the various programs approach each aspect is what makes one program better (or worse) for your office. PATHAGORAS uses a direct, always-on and always-active approach to the process. There are no separate programs to load. So long as Word is active, all libraries and books are instantly available to the user.  Whether you are assembling an entire document or requesting a single clause, no program requires fewer steps to get you from here to there.

    (One quick diversion: "Document Assembly" (the module which is the subject of this section of the User's Guide) and "Document Management" (the PathSmart and SaveSmart modules discussed in Parts 2 and 3 of this guide) are not the same. Conceptually, they work hand in glove: documents that are created via PATHAGORAS' document assembly tools can be quickly and logically saved with PATHAGORAS' document management tools. But are distinct from each other and each use different screenage. PATHAGORAS is the only major program that combines the two into a single program. To maximize the benefits of the two, it is important to learn their differences. This will become apparent as the user actually begins to assemble and then save documents. See more at this link.)

1.  Creating of the source clauses. Some document assembly programs limit you to the text that ships with their programs. Overall, these programs are easier to learn because there is no learning curve associated with creating and storing the underlying books and libraries of clauses. You simply use what you have purchased.  But that is not satisfactory to those who want to use their own text.

PATHAGORAS uses your clauses (and does not directly market any text whatsoever).

Clauses for libraries and books used by PATHAGORAS can be created from scratch. Most  likely, text for your clauses will come from documents which already exists within your computer.

PATHAGORAS requires relatively little in the way of prep time.   While other programs require the creation of fields, variable completion wizards, Boolean choices, listing of options and other sometimes frustrating and challenging tasks before you even get started, none of this is required by PATHAGORAS. There is some setup work to be done, for sure, but with PATHAGORAS you can stop at any stage of the setup, and go right into full use of the system. That way you can check your work and make sure that you are heading in the right direction.

PATHAGORAS provides several methods for creating and moving text into your various books of clauses. (See below for definition of a book.):
a. Pehaps the easiest method of moving individual blocks of text into a book is PATHAGORAS unique 'highlight & add' technique using 'Term Works.' See Part 4d of this Guide ('Adding Text to Your Books') for a fuller discussion of 'Term Works.' Or go straight to the Term Works Manual' 
b. If you want to take a complete, existing, document (a Contract or a Proposal, perhaps), and quickly break it up into its component pieces, use either the "Instant Book" or "Bulk Add" tools. These are actually document "disassembly" tools that you should use to quickly create new, fully functional 'books.' You simply Indicate (by paragraph marks or by a unique character sets of your choosing) the points where each clause begins and ends. Click the appropriate "Go" button and new clauses are created. The result is a fully functional document assembly book. The above links will take you to more detailed and highly illustrated manuals regarding each of these tools:

PATHAGORAS provides several methods for 'neutering' the text as (or after) you add it to your books and libraries. 'Neutering' is an important aspect in preparing source text. It is done so that the final, reassembled document can be easily personalized.  These concepts and techniques are more fully discuss in paragraph 3 below, and its references.

2. The document assembly engine. This includes the screens that the user sees as well as the behind the scenes activity and the underlying programming. For purposes of this discussion, it will mean the screenage which takes the user through the process of assembling pieces of raw text and data into a complete, usable document.

The document assembly engine is definitely the most complex of the three aspects. The discussion of this aspect of PATHAGORAS will command the majority of the space in this Part 4 of the Users' Guide.

3. Personalizing the final product.   The assembled document rarely is fully usable immediately after it has been created. There are names and addresses to add; jurisdictions to choose among; sizes, colors or other selections to make. A complete document assembly system must allow the user to create place holders (variables) for the great variety of information that even the simplest of documents calls for. It must also provide an easy way to substitute personal data for those variables. (Of course, after the document is assembled, one could simply fill in the data by hand at the various locations using Word's search and replace functions. But that can be an excruciatingly slow and inexact process.)

PATHAGORAS provides a variety of clever and easy to use tools to help transform an assembled, but still generic, document into one for a specific client or customer.  These tools are more fully discussed in links found in Part 4f of this Guide, but here is a brief summary of them:

InstantDatabase:  This is a very sophisticated, yet easy to use feature which allows the user to replace up to 30 separate variables in a single pass. The user can also easily save the client's or customer's data for reuse in later documents created  for the same client/customer. Click here to display the IDB Manual.

GotForms?:  The GotForms? module provides the easiest 'forms creating' and 'forms-filling' method on the market. Many 3rd party forms providers mark variable locations using brackets and underlines. Pathagoras takes advantage of that fact with this module. No matter the level of sophistication of your system even at the very beginning, the answer to the question "GotForms?" is almost always 'Yes!" The ease and simplicity of this feature will 'blow you away.' Click here to display the GotForms? Manual.

Directly link to Access, Word and to ODBC compatible databases:  This requires knowledge of linking databases to documents, and is an 'advanced level' feature. If you have a well developed database of client information, it is certainly worth the effort.  See Part 6 of the Guide.

Indirectly link to other proprietary databases:  You can indirectly link PATHAGORAS' InstantDatabase system to a variety of proprietary database systems (such as TimeMatters, Amicus Attorney and others).  Again, this is an 'advanced level' feature.  It takes some setup time, but the later time savings pays back the setup effort hundreds of times over.

Assembly Basics using  PATHAGORAS .

     1.   On command,  PATHAGORAS reads the names of every document or clause from a selected source.  PATHAGORAS then sorts those names alphabetically and presents them to the user on a CheckBox screen. (The CheckBox screen is an overlay screen which  the names of each clause next to a checkbox.) (See figure 10, below.)

     2.   The user then 'checks off' the clauses which will constitute the final product. After the selections are made, the user presses the <Assemble Clauses> button.

     3.   PATHAGORAS locates each clause from its source and moves it into the new document.  The process is automatic and practically instant.

     4.   After assembly, the user would then personalize the document, replacing the variables which existed in the source clauses with the client's or customer's personal information.

    The Clause Selection screen is likely to serve as your most common access point to PATHAGORAS document assembly. It is easy to use and very fast in assembling a large quantity of separate clauses.  PATHAGORAS also provides several alternative, and equally impressive, methods of document creation. These alternative methods are more fully discussed in Part 4e of this guide, but here is a sampling:

One clause at a time with <Alt-G>: As you may have seen in other sections in this Guide, the key combination <Alt-G> is PATHAGORAS ' universal trigger key. For document assembly purposes, you can add text to a new or existing document one clause at a time by typing the name of the desired clause or term followed immediately by a press of <Alt-G>. This method is most useful for when you are calling an address from a general glossary, or need that 'one-last-clause inserted into an almost complete document.

From a hand typed list:  You can assemble documents from a list of clauses that you power type onto the screen. This gives you more control over the order in which clauses come in.  If the clause names follow the 'Prefix/Suffix' Naming Convention discussed in Part 4e, you can 'power type' onto the editing screen just the suffixes. Provide the prefix at the end of the list. A press of <Alt-G> brings together all of the desired clauses. Fast typists typically prefer this method over the Clause Selection screen.)

From clause-sets: You can pre-assemble standard documents into clause-sets. A clause set is simply a collection of links (still plain text) to a series of clauses that, when assembled, would constitute a complete document. The list is saved with a descriptive name. It can be used (and reused) to quickly build the same basic document over and over as needed.
     The specifics on how clauses get into the various books and libraries, and how they are later moved from the books into the document during the assembly process and personalized for a specific client or customer is the subject of the rest of this Part 4. But first, some critical definitions as used in the rest of this Users' Guide are provided below:
       
 Definitions:
    Document Assembly is the process of creating a complete document from bits and pieces of data.

     "Book." The place where original clauses  (i.e., the text that will ultimately be pulled into a final document) are stored is called a 'book.'  PATHAGORAS  works with two kinds of books: 'glossaries' and 'folders.'  Each are discussed below.

    "Library." A library is a collection of up to 10 books. Typically, a library contains books within a particular, but broad, subject area. For example, in a law office, perhaps 'Family Law' would be one library, and 'estate planning' another.  The books comprising the 'Family Law' library might include divorce, property settlement agreements, adoptions, etc. Books under an 'Estate Planning' library might include wills, trusts, guardianship, etc.

    PATHAGORAS supports an unlimited number of libraries, and therefore an unlimited number of books. As a practical matter, any one user will have a finite number of clauses, but no user is limited by the system.
     "Glossary." A "glossary" is a collection of elements used to assemble a document. It is a type of book that might be part or a particular library. The elements can be boilerplate clauses, sentences, paragraphs, signature blocks, addresses, pictures, or anything else. They are all are stored within a single document, making for easier editing and transportability (in case you want to take it home to edit). A glossary is typically 'specific subject' oriented. So, using the examples given two paragraphs above, the divorce, property settlement agreements and adoptions books would be separte glossaries. A PATHAGORAS glossary is a pure Word document.  It is simply organized and labeled in such a way that PATHAGORAS can directly access its individual components.

    "Folder of Terms." A 'folder of terms' is the other type of book. It is simply a standard Word folder. Each item in the folder is a standard Word document and each one represents a single clause of a potential assembled document. A "folder of terms" is not the 'opposite' of a glossary, but merely its counterpart. Like a glossary a the 'folder of clauses' contains a collection of clauses of the potential document.  But, a glossary contains all subsidiary elements in a single, easily transportable document, whereas with the 'folder of terms,' each term is a separate document.

Part B of this Section 4 will discuss the two main document assembly screens.
Part C of Section 4 will discuss the engine behind the surface: the Settings screen.
Part D will guide you through the steps needed to create your own document assembly system.
Part E discusses alternative document assembly methods.
Part F demonstrates how to personalize a document or form for a specific client or customer.
Part G takes you step-by-step through the process of adding 'books' to your libraries.
View Part 1 of Users' Guide (Introduction)
View Part 2 of Users' Guide (PathSmart module)
Return to Part 3 of Users' Guide (SaveSmart module)
Continue with Part 5 of Users' Guide (Glossary module)
View Part 6 of Users' Guide (Database Link module)
View Part 7 of Users' Guide (Other Features)

Revised 1/29/05