Processing vs. Personalizing

   Document assembly using Pathagoras typically involved 2 steps:

Processing -- Selecting or discarding the text blocks that will make up the initial draft of the document. Whether a clause appears in the initial draft of the assembled document Call the clause from a Drop Down List, a 'book' using the Clause Selection Screen or by typing the clause name to the screen followed by <Alt-G>. is either based on affirmative selections of a specific clause by the user, or as a result of programmatic decisions made from values provided by the user. The 'result' of processing is a usable rough draft of the document which contains the desired substantive text. It still contains [variables], but it should contain only those variables that are pertinent to the desired document.

Personalizing -- Assigning specific values to the variables that remain in the document after it has been 'processed.'

   To become most efficient in using Pathagoras, it is imperative that you understand the difference between 'processing' and 'personalizing' a document.


   'Document processing' includes those steps you take to arrive at the first 'good' draft of your document. Processing a document involves (1) assembling the document building blocks from source text (discussed below) and (2) answering Options/Optional/Repeats questions that appear in the source text. These Options/Optional and Repeats questions will automatically be presented when you have 'properly 'assembled your document.

   Many customers who are not yet familiar with the 'flow' of document assembly with Pathagoras will begin a document assembly project by recalling the source text onto the editing screen. That, of course, is the way they undertook a project in 'pre-Pathagoras' times. We need to 'break' you of that habit.

   When you recall the original document, the text will just 'sit there' until you do something to cause a change.  That is on purpose. Pathagoras thinks you simply want to edit the source text. Our take: never use the source text itself for active document assembly. Use the source text only to correct a typo or to add additional automation features.

   It simply is too easy to accidentally overwrite the original when you start a document assembly session with a source document. So, Pathagoras requires that you 'assemble' your document to get the benefit of the program's automated features.

   When you assemble your documents using the tools that Pathagoras provides (via DropDown List or Clause Selection screen), the process is active and automatic. Any <<*Options/Optional/Repeats*>> blocks present in the source text are 'processed' as you desire. You end up with a 'perfect' initial draft, just what you were looking for.

You know that you are looking at an assembled document because 'Document 1', 'Document 2', etc. shows at the top of the editing screen, indicating a new document -- one that you cannot accidentally overwrite the original if you press 'Save'.

You know that you are looking at the 'source' document because its name shows at the top of the editing screen.

   There are two primary methods to assemble documents using Pathagoras:

 (1) Selecting documents or clauses from the Clause Selection Screen.

This is the 'classic' assembly process involving a click of the Document Assembly button, the selection of the proper library and then book from the library. When you click the Next button, the available clauses appear in the left panel. Select the desired documents/clauses and move them to the right ("Selected") panel. Another click of the Next button and the selected items are instantly assembled.

 (2) DropDown Lists

If you have assigned a folder to one of your up-to-10 DropDown Lists, just click the list, point to the desired clause or document and click. The selected item is instantly brought into your editing screen.

   When a document or clause is 'assembled' via any of the above techniques, Pathagoras is not done. Pathagoras searches for the existence of any <<*Options*>>, <<*Optional*>>, <<*Repeats*>> or <<text>> blocks that may have been brought onto the editing screen, and processes them.

   Each assembly command calls in more text. That text adds more variables to your document (or processing the text at hand might remove variables because the text is 'processed away' (e.g., answering 'no' to an <<*Optional*>> text block deletes the text block).

   If the text processing involves responding to Repeats that contains variables within the scope of the <<*Repeat*>> block, variables will be added, each incremented by the designated number of repeats: [Buyer@1], [Buyer@2], etc.

   If the <<*Options*>> or <<*Optional*>> blocks themselves bring in any more text, that new text is processed as well.

   Processing continues unabated until Pathagoras has determined that there are no <<*Options*>>, <<*Optional*>>, <<*Repeats*>> or <<text>> blocks to process.

   A third 'assembly' method does exist. It is the <Alt-G> hot-key. If you type the name of a document or clause onto your editing screen (and if that the document or clause is currently located in one of the "Order of Search" locations), Pathagoras will instantly bring the selected item into your editing screen. However, we 'demote' this tool to this footnote, not because it is not exceptionally powerful and tremendously useful. However, we want to emphasize the Clause Selection Screen and the DropDown Lists as the primary and preferred document assembly tools. By all means, if you know how to use and like Alt-G, go for it. Read more here.


   When the document is fully 'processed' (i.e., you have a 'good' rough draft of the document with the clauses that you ultimately want), then 'personalizing' the document can begin.  Your document contains not only the proper base language, but the proper variables (including variables incremented by the Repeat processing).

   If you are satisfied that you have a great base document, press <Alt-D> to bring up the Instant Database screen. Click the Scan button (or a Mask or an existing record) and Pathagoras will hunt for and display in the left-hand column all bracketed variables contained in the document. Provide replacement values at the right. Click the Next button and all variables are quickly replaced with their respective 'personal' text. (You will also be asked if you want to save the variable-to-values pairings to an Instant Database record. You typically should say 'Yes.')

What if I want to replace my variables first? What is the 'logic' behind 'process then personalize' order?

   Actually, there is a method to the madness. If document processing starts with <Alt-D>, the user is made to complete all variables that reside in the original 'unprocessed' document. However, as noted above, some variables could appear in the 'original' text that will be deleted when 'No' is the response to and <<*Optional*>> text question.  Further, since new text (i.e., text that does not appear in the unprocessed document) that contains variables might be added to the document under construction by a call to an 'outside' document, you would have to run <Alt-D> again to pick up those new variables. So, to avoid the 'double' work, assemble the document first and let it be 'processed.' Then personalize it.

So when I call up one of my documents, it just sits there. Why is that?

   Probably because you have displayed the original document as opposed to assembling the document. Remember what we said at the very top. Document assembly is performed by the methods discussed in the very first section. Document assembly should never be performed using an original document. Read, and heed, this warning:

Never use an original document as your base for a document assembly session.

   So long as you abide by the above rule, you will not accidentally overwrite your source documents. (We are sure that it has never happened to you, but some people occasionally forget to save the edited documents under a new name. The original document is therefore lost. When you heed BIG WARNING #1, and follow the document assembly steps stated above, you minimize the chances of that occurring.

   When a document is brought onto the screen using Pathagoras tools you will always be working on an exact copy of the original How do you know it is a copy? Look for the 'name' of the document in the upper left-hand corner of the screen. It will be named "Document1", "Document5", etc.

   If you find yourself working on the original for other than source editing purposes, you should rethink your process, and implement the tools provided by the program. If you do nothing else in your early days with the program you should at least "Create your First Library" and "Shelve your First Book" and call up copies of documents from your various books. If you find yourself working primarily on complete documents or templates, consider our exceptionally popular DropDown Lists.

   So if you use Document Assembly Clause Selection Screen and DropDown Lists for your primary assembly, you won't get into 'trouble.' (Of course, if you are composing source text and want to process it for testing purposes, that is perfectly fine. Read this section about testing.)

Created with Help & Manual 7 and styled with Premium Pack Version 2.70 © by EC Software