The below document will sound to many like a sales pitch. This is one of only a handful of pages that have that flavor, and it is one that actually derived from promotional literature. But we have kept it more or less intact because of (1) it actually is a pretty good description of Pathagoras' approach to document logic as compared to its competitors and (2) is a good description of Pathagoras' actual work flow..
How do some programs seem to 'know' that if Condition A exists, then clauses 1, 2 and 3 should be inserted (or that new sub-question C should be posed to the end user), but if Condition B exists, only clause 2 and 4 should be inserted (or sub-question B posed to the end user)? Do these programs somehow possess an intuition-like quality?
Well . . . . no. Of course not.
They 'know' what to do because somebody sat down and coded the appropriate logic into the document necessary to make those 'decisions.'
'Document logic' (also called "Menu Driven Document Assembly") is a wonderful tool. It can make the document assembly process much easier than the alternative of having to select, copy and paste in each clause one-at-a-time (or manually highlight unnecessary text and delete it).
It is document logic that can make or break a document assembly program. If easy, the program has 'legs'. If not, it flounders, and seemingly good software becomes shelf-ware.
Document logic can be tough. It requires an understanding of a new 'language' and syntax. It demands lots of testing to make sure that everything is properly constructed. Nowhere is "GIGO" (garbage in, garbage out) more applicable.
But how 'tough' depends totally upon the design of the program. Is logic creation and display an integral part of the document or is it accomplished in third party screens. Will the program even meaningfully function without programming of document logic. Is it an all or nothing proposition. Pathagoras stands alone in being able to answer those questions in the most positive way possible. Document logic is inserted at the document level, and is always visible and understandable. Inserting logic is not mandatory for meaningful function, and you can (and are encouraged) to start 'small' and then add to your document as you see fit.
Some document automation programs require programming of document logic as a necessary part of the programs initial setup. You are taken to third party screenage to compose questions and create variables in a vacuum. (Watch their on-line videos. You will see what we mean.) Further, if you don't accomplish this step up front, there is no action! That drives many people to forgo document assembly from the 'get go.' Even those programs that tout 'plain text, no programming' (our un-copyrighted by-line since 1999) cannot accomplish this inside a Word document. You create your questions totally outside of Word and then have to manually insert fields into your Word document where you want variables to appear or logic to take place. Their base documents are full of fields with tons of internal (invisible) coding that you cannot change from within Word. It's all proprietary, and not transportable.
Not so with Pathagoras. If you want to 'code' your document for logic, it's there. You can add as much or as little (including none) as you want to try, but all other features of the program (variables, Instant Database, DropDown Lists, etc.) still perform to your needs and expectation.. Don't want or need to insert logic into your project for now, don't worry about it.
Because Pathagoras is 'plain text,' the form of document logic it implements (and your ability to create and edit the logic equations on the face of the document) is unparalleled Here are some of the benefits inherent with plain text document logic:
•You can see the logic equation by just looking at the document. Everything is facial. This is exclusive to Pathagoras.(Other programs take you outside of Word to their proprietary screens where you create the logic, totally outside of the context of the document. Yes, you will eventually be returned to Word, but then you will outside of the context of the program.)
•You can edit the logic equation on the face of the document itself. You don't have to activate a secret decoder, or go to remote sections of your document.
•You can test bits and pieces of document logic by simply highlighting, cutting and pasting the section you want to test into a new document. (Other programs require a link to an ancillary document, or require that you embed additional code from the parent document into the snippet being tested. This inhibits this kind of 'small snippet' testing.)
•You can even edit your logic equations on a machine on which Pathagoras has not been installed! (Of course, to test your work, you will need a Pathagoras computer.)
•Because only plain text characters are used, you can 'paint' the various elements of the equation so they stand out and apart from each other. Pathagoras even has a built in 'painter' that will do this for you (accessible by pressing <Alt-Q>). The colors are to make things easier to see. They are not integral or necessary. The colors will not be carried into any final document. (On the following pages, you will see 'painted' elements of various equations. As stated, the colors are for illustration and sample purposes. They will be helpful to you, but are not required for coding, can be copied from the Internet into your documents for testing.)
•Document logic can be implemented from the simplest to the most complex levels. It is not an all or nothing proposition with Pathagoras. Start simple and the build to as fancy and complex as you want.
•It is totally 'transportable'. You can see the logic in the document. If Pathagoras ceased to exist, the documents themselves display your logic on the face of the document at the location of the 'logoc.' Whether the choices are single words like this: <<*Options*apples/bananas/cherries>> or they extend over multiple pages, it is easy for you (or another) to figure out what you have done and intend.
Let's examine several 'document logic' approaches offered by Pathagoras, from the simplest to the most complex.