Processing vs. Personalizing

   Pathagoras is programmed to handle two ‘types’ of text. The first type we call 'process text', typically large blocks of text in a template marked out with '<<' and '>>' boundaries that either stays or goes, depending upon the answer to a question. The second type is 'variable' text, typically short answers, like a name, location, pronoun, etc., represented in the document with generic words surrounded by square brackets. Variables are typically saved as a permanent record. Variables can be recalled for use in other documents that contain those variables. 'Process' text  choices are not preserved (except of course in the document that you created) for reuse on a repetitive basis).


   Document assembly typically involves 2 steps.

Processing -- Selecting or discarding the text blocks that will make up the initial draft of the document.

Personalizing -- Assigning specific values to the variables. If 'processing'  occurs first, only the relevant variables will be present in the 'processed' document.

   To become most efficient in using Pathagoras, it is imperative that you understand the difference between 'processing' and 'personalizing' a document and the order in which these two modules are optimally called.



   'Document processing' includes those steps you take to arrive at the first perfect rough draft of your document. Processing a document involves

1.assembling building blocks from source text (discussed below) and

2.answering Options/Optional/Repeats questions that appear in the source text.

NOTE: Options/Optional and Repeats questions will be automatically processed when you assemble a document using specific tools provided by Pathagoras. This happens because Pathagoras is programmed not only to display the requested text but to hunt for text inside of '<<' and '>>' boundaries and act upon the text found therein. This is the 'secret sauce' to Pathagoras operations.

   Many customers who are not yet familiar with the 'flow' of document assembly with Pathagoras may begin a document assembly project by recalling the original source text onto the editing screen, and process that original. That, of course, is the way they undertook a project in 'pre-Pathagoras' times. We need to 'break' you of that habit. If you forget where you are, you might accidentally save over the original. That is not fun. If you want to get the benefit of the program's automated features you must 'assemble' your document either through the Document Assembly/Clause Selection screens or via DropDown Lists.

  Note: if you are composing source text and want to process it for testing purposes, that is perfectly fine. Read this section about testing.)

   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*>>, <<*Repeat*>> or <<document call>> blocks that may have been brought onto the editing screen. If found, they are processed.

   The various commands can cause existing text to be deleted,as would be the case of 'No' to an Optional command, or a 'non'-selection of an Options choice, voiding the document of certain irrelevant variables. A command may call in new text, and that new text may contain variables that were not present in the originally called block.

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

   Processing is iterative. If the commands bring in more text, that new text is processed as well. It continues unabated until Pathagoras has determined that there are no <<*Options*>>, <<*Optional*>>, <<*Repeats*>> or <<text>> blocks to process.


   Only when the document is fully 'processed' (i.e., you have a 'perfect' rough draft of the document), does it then make sense to 'personalize' the document. It's at that stage that your document contains the proper variables (including variables incremented by the Repeat processing) for completion.

   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? Am I allowed?

   Of course you are allowed. Pathagoras lets you process your document in any way you wish. But if you follow the advice in this article, you will likely save time and effort.

Can the two steps be combined in a single keystroke?

   Yes, and many have done this. To set this up, press <Alt-D> to display the Instant Database. Press the red Power Tools button and then More Tools. Scan the resulting screen for various options (including the one called 'Process Document before completing variables.' So, what's the drawback? Not much, except that you may forget that <Alt-P> exists when you just want to process a document (or when you are teaching Pathagoras to others who may never know that the <Alt-P> function ever existed).

So when do I set up text for 'processing' and when for 'personalizing'?

   Generally, the larger the block of text, and the less 'personal' it is, the more likely it is that you are going to set it up as process (i.e., <<*Options*/*Optional* . . .) text. Large swaths of text don't make very good variables, and you don't typically intend to save large blocks of text for reuse in other documents in the same way you want to save a name, address, etc. (i.e., variables) in a record for reuse across a wide variety of document.

   But there are 'cross-over' terms that you can set up as either process text or as variables. The most 'classic' examples are those words and phrases that deal with sex and number. Should "he/she/they' be set up as the variable [he/she/they] or as process text <<*Options*he/she/they>>. The answer to the former is stored as a re-callable record (i.e., as a variable) and can be recalled for any number of future documents for that client; the latter is not saved outside the document and cannot be used for future documents. The answer to the question, therefore, lies in that explanation. If you plan to reuse the information, present it as a variable. Otherwise, you can just set it up as 'process' text for the particular document. And keep in mind, whatever you decide, if you later change your mind, its a simple switch.