by Troy R. Bishop



The use of any reference system to structure references to data in computer files, unless the reference is in terms of the exact byte being referred to, always involves a mapping. The mapping is from the identity of the data item as sensed directly by the computer system, which is in the native computer reference, to the desired identity of the data item in the target reference system.

The need to accurately assess which reference system applies to a given situation is not limited to text labeling.

For example, in the creation and subsequent fulfillment of specifications for IT work, there must be a conversion of requirements from the user's concept system to the provider's concept system.

The SRT concept of "changing the way one counts" is natural in a User Specification, but not right for a Provider Specification, or IT Specification. A Provider Specification is drawn up by the IT Provider to enunciate the IT provider's interpretation, in IT terms, of the User Specification. When approved by the user, the IT Specification serves as the approved technical specification to which the IT provider works and delivers. When the system is ready for delivery, the IT Provider tests it against the IT Specification and, when it passes, calls upon the user to test it to the User Specification, thus making sure, even though it passed the agreed-on technical spec, that it also passes the originating functional requirement.

To cast computer data into any reference system, no matter what reference system it is, is simply a mapping. In its simplest form, the mapping is either a simple expression, where no anomalies exist -- or a lookup table, where linear mapping is to be performed -- or even complex nonlinear schemes of multidimensional coded arrays as in the case of the UBF (Urantia Book Fellowship) reference system used by Uversa Press, where more elaborate mappings are implemented.

But implementing a reference marking system is always a mapping. To mark in a reference system is simply to map and mark. It has nothing to do with altering ordinality, or the series of real integers, as the user term for the requirement might suggest -- at least in the world of IT, but it has everything to do with counting in the world of clients, or users. In the universe of text that bears markings that have been mapped, for example, to the Uversa Press user specifications, the counting is linear with respect to the markings but not with respect to the text units as they are accessed by the computer.

The concept of "mapping," not "counting," is necessary for the IT Provider to keep in mind in order to realize a more orderly analysis and development of the taxonomy required in the properties and methods of the servicing OOP Objects required to accomplish this mapping. And it turns out that the taxonomy and accompanying nomenclature inherent in the requirements of the Uversa Press Reference Numbering System or the Standard Reference Numbering System, apart from the capabilities they might give the reader, become a lot to handle, more than would be expected by the IT Specialist before work is in progress.


There is a dimension of complexity in the needs within the computer system processing of Urantia Book text records and data that arises from an unexpected source and is not apparent in preliminary considerations. It hits one when one is far in. But one has to be aware of this to some degree to navigate properly and thus produce the required system.

If Web pages to be produced by computer data processing are to be completely static, with no functional interactive role whatever -- and if, further, no anomalies exist in the mapping specification, then nothing more need be said.

But our mapping specification already has two anomalies in it, the "Orphan Acknowledgment Anomaly" in Paper 0, and the "Skipped Section Anomaly" in Paper 139.

Though they number only two, these two have imposed a need to check every transaction, whether it be reading records, writing records, or dealing with data derived from such sources, to see whether it is one of those two instances. This involves examining each one of millions of transactions as they occur to see if the data is, or involves, one of those two instances. It hardly seems worthwhile to implement an extra dimension into a mapping array or do something similar for the entire set of records in The Urantia Book to spot and correct for these two instances.

As further mapping anomalies are injected into the reference system and the "one increment in number per one indented line" algorithm is left further behind, an additional layer of mapping is required over all transactions and units, as I implemented in the ubf reference numbering system.

In terms of specifying the elementary, or the least, computer data units from text files, to be used as addressable (or mobilizable in superunits) units in the desired reference system, one must first apply a mapping to the computer data to convert references between the basic data units (records) of the computer reference system and the basic data units (native paragraph, paper title, and section title) of the target reference system.

"Exemplar" is the name of the reference frame that refers to data units (records) by their true machine sequential location. This is the inherent reference system of exemplar files. For example, exe 20:3:2. The basic reference system to which exemplar data is first mapped, in the first step into non-physical reference frames, is the reference system of the First Printing of The Urantia Book, known as the "Absolute" reference system. The Absolute, or Abs, reference system is identical to the Exemplar reference system except that the Acknowledgment Heading of Paper 0 is present in the Exemplar system but not given a reference existence in the Absolute system, and no references to Section 10 exist in the Absolute Reference System, every section in the Absolute Reference System above Section 9 being one number higher than in the Exemplar Reference System.

An attempt to go straight from the computer data (exemplar reference system) to the target labeling (target reference system) without having the Absolute Reference System in the coding as an intermediate normalizer, at least in concept, for the references to be mapped, will be to some degree haphazard and convoluted.


These problems, and the more complex ones described below, have been solved and the solutions encapsulated in OOP objects as a re-usable code library, ubdslib. These objects can routinely service all reference conversion needs, including mapping from the native computer data reference system to the Standard Reference Numbering System.

They are licensed for public usage and freely available for viewing or download at urantia book programming dot com ( )

Understanding the reference frame to which certain variables in these objects apply solely from examining their names can be hard at first, since I developed them for my own use and only later added documentation, but added little narrative description (though each OOP Object has a description of the embedded metrics in its preliminary comments). The variable names were all developed for maximum self-identification. But the scenario in which they must be applied is so deceptively complex and almost recursive-appearing in nature that they just have to be learned.

"lineNumber" might mean "lineNumberInPage" or it might mean "lineNumberInSection." I had no trouble using them, because it is usually clear from the name or purpose of the method what the arguments are. For example, the hypothetical method in the exemplarMap object, exemplarSectionContainingLine (paperNumber, lineNumber) is certainly lineNumberInPaper, since the section number is what is sought and is not known. And the corresponding hypothetical method in the absMap object, absSectionContainingLine (paperNumber, lineNumber), will provide identical returns to the former example, except for sections in Paper 139 above Section 9.

I could describe the other OOP Objects in ubdslib, but that is not the purpose here. They are servicing objects. For example, the language object provides the ISO 639-2/T 3-digit language codes and language names, as well as script codes, script names, and direction of text flow, for all of the world's languages.

The language object is used in Urantia Book Codifier and in all of the places where UBDS Book Codes are used in the UBDS, from the lookup keys for the language selection controls in The Multilingual Urantia Book to Urantia Book Codifier's dropdown listbox that provides a selectable list of all of the world's languages and their codes, from which the languageCode and languageCode3 prefixes are drawn to embed into the file name of every file of every kind -- exemplar, working, and multilingual, for example -- throughout the system.

The UBDS Book Codes file, functioning similarly to an ISBN Code catalog, serves as the assignment and recording register for Urantia Book Codes for every edition of The Urantia Book ever printed or published online or ever anticipated. This book, programmatically accessed as a Javascript include file, is used, to mention just one example, by The Multilingual Urantia Book to provide the choices and labeling for the contents of the language selection listboxes.

The computer code of all of the ubdslib objects is browsable from the main menu at urantia book programming dot com and is also downloadable there.


The complexities that appear once coding is in progress arise from the fact that though only a single reference system might be used to mark the text, several reference systems are required to be used, some only internally, to carry out the dynamic purposes of the HTML pages.

For example, to realize greater speed at runtime, I use the DOM to create an array of pointers to every line in the paper, regardless of line type. This eliminates the time-consuming need to acquire these pointers time after time. But the coded quantities identifying these DOM elements are several for each element, identifying the element in multiple frames of reference.

Back in the Uversa Press Reference Numbering days (a couple of weeks ago for me), I also created pointers to every cluster of abs paragraphs defined on a per-case basis as a ubf (Urantia Book Fellowship) paragraph. This was another reference system. Also, for side-by-side paragraph dynamic alignment, I used an implied reference system in which every unit to be aligned was an item: paper title, section title, acknowledgment heading, or ubf paragraph (or superparagraph). Then, for automatic scrolling when going to results in the search mode, I used an implied reference system indexed on absolute paragraph number in paper, because these were the units based on which I could scroll (and back up every time about 50 pixels, for visual orientation).

With all these reference systems embodied in anchors and labels in the HTML pages, and with all the methods required to determine the reference value in the various reference systems, some of which were references to references, the variable naming and method naming became something that required meticulous attention. Every reference object and its methods and method arguments dealt with the same things -- for example, line number -- except in a difference reference system. Variable names were sometimes long, and the namespace, in which method names and variable names can collide (in Javascript) and cause trouble, was preserved by putting a prefix on corresponding properties in different objects.

These are the fuller-blown complexities, onto which anomalies must be mapped.

If one sets up to implement complex anomalies throughout The Urantia Book, such as the clustering of the ubf reference system, or the anomalies currently proposed for the prayers in Paper 48 and Paper 144, this is accomplished by adding a further indexing dimension to the mapping array and in addition by coding things like clustering by techniques such as numeric signs. Naturally, in an anomaly set of only 2 or so, special-case logic is sufficient, and the complex mapping can be discarded. In the proposal for the 4 sets of prayers, it gets more complicated.

A fortuitous code-recycling phenomenon occurred when converting from marking in the Ubf reference system to marking in the Std reference system. A programming procedure in The Multilingual Urantia Book now (as implemented in connection with the conversion) marks only the first line in a prayer, and in all lists, marking the succeeding component lines more subtly or -- selectably -- not at all. This is implemented by using the discarded ubf mapping -- not for determining label values for marking, but for making mark-or-not-mark decisions and also for determining list, and prayer, component-line formatting, including label text color and vertical line spacing.