Home > Project Documentation > Documentation for Encoders

Encode a Date

roseList documents mentioning Encode a Date

Introduction

This manual provides instructions for encoders, editors, and contributors working on MoEML’s XML documents. It includes information about encoding dates. Because of the place and time with which this project is particularly concerned, we find ourselves dealing with several specific problems when recording and encoding dates.1 For those interested in the mechanics of date-rendering within the project, the XSLT code we use can be examined. Please do not hesitate to contact the MoEML team for additional assistance.
Because MoEML’s practices are always being updated, please refer back to this manual frequently.
  • Dating in XML is normally done using the proleptic Gregorian calendar (i.e. the Gregorian calendar, extended back indefinitely, even though it was not invented until the sixteenth century).
  • The Julian calendar was in use throughout Europe until 1582; thereafter, various countries switched to the Gregorian calendar at different points, with England making the transition in 1752.
  • Because the Julian and Gregorian calendars handle leap years differently, there was a slow drift over the centuries, so that by (for instance) 1600, there was a difference of 10 days; 1 September 1600 (Julian) was 11 September 1600 (Gregorian).
  • In England from 1155 to 1752, the start of the year was 25 March, so for example 1 February 1600 (Julian) was 11 February 1601 (Gregorian).
  • Historians and writers are accustomed to using the distinction Old Style (O.S.) and New Style (N.S.) to distinguish two types of dating, but they apparently use this indiscriminately to handle two types of difference: the leap-day drift, and the beginning-of-the-year problem. Therefore, we see formulations like 25 October (7 November, New Style) (accounting for leap-day drift), 3 January 1601 (O.S.) (in which it is not clear whether the leap-day drift, year, or both are accounted for), and 3 January 1601/2 (N.S.) (which appears to handle the year discrepancy without making any mention of the leap-day drift).
In other words, the current conventions for expressing date/calendar confusion are all over the map. In the case of English dates prior to 1752, however, we generally find that the Julian calendar is used, and we can usually deduce the exact date in the Julian calendar. From that, an algorithm can calculate the corresponding date or date range in the Gregorian calendar; with that, we can properly know what we are talking about. (See Cheney xii-xiii for a short discussion of the problem and the need to be clear in articulating what day is meant by a date.2)
However, even if it is clear that a source follows the Julian calendar, it is not always clear whether the source considers January 1 or March 23 as the beginning of the new year. MoEML thus disambiguates the Julian calendar into three distinct reckonings:
  1. "julianJan": the source considers January 1 the start of the new year.
  2. "julianMar": the source considers March 25 the start of the new year.
  3. "julianSic": we cannot be certain whether the source considers January 1 or March 25 as the start of the new year.

When to Encode a Date

Use judgment when deciding whether to tag a date or not. Ask whether the date will be useful to researchers of early modern London. For example, dates worth tagging include
  • life dates of people in the personography database (usually encoded with <birth>, <death> and <floruit>),
  • dates of important events in articles, transcriptions, and encyclopedia entries, and
  • dates of publications in the bibliography database.

Encoding Julian Dates

If you are used to encoding dates in TEI, you will have seen lots of examples that look like this:
<date when="1252-08-05">5 August 1252</date>
where the @when attribute follows the W3C pattern of yyyy-mm-dd and can be truncated to yyyy-mm or just yyyy. What you might not have realized is that this date implicitly uses the Gregorian calendar. This is because the @when attribute is defined as a W3C date datatype, and that datatype is explicitly defined as a Gregorian date.
Most dates prior to 1752 in our texts, however, are not Gregorian dates; they are (explicitly or implicitly) Julian dates. The first task, then, is to determine whether or not the author considers January 1 or March 25 the beginning of the new year. In this case, it is unclear, so we use "julianSic". When we are trying to encode a Julian date, there are two aspects of the date that must be marked as Julian. First of all, there is the text in the <date> tag itself: here 5 August 1252. To clarify that this is a Julian date, we need to add the @calendar attribute. This attribute points at a <calendar> element somewhere, which explains the details of the calendar. In our case, that is in the file /db/data/boilerplate/includes.xml, but for our purposes, we can point to it using our standard method with the mol prefix:
<date when="1252-08-05" calendar="mol:julianSic" datingMethod="mol:julianSic">5 August
              1252</date>
That clarifies that the text of the date is in the Julian calendar. But this is technically incorrect because of the @when attribute. We cannot put a Julian date in a @when attribute, because the datatype of that attribute is a Gregorian date. So we have to use a different attribute, @when-custom:
<date when-custom="1252-08-05" calendar="mol:julianSic">5 August 1252</date>
This tells any processor or human reader that the value "1252-08-05" is some weird kind of date, which is not Gregorian, but it does not say exactly what type of date it is. So we have to add another attribute to explain that it is a Julian date. This attribute is @datingMethod:
<date when-custom="1252-08-05" datingMethod="mol:julianSic" calendar="mol:julianSic">5 August
              1252</date>
It may seem as though you are duplicating work here since both @calendar and @datingMethod point at the same <calendar>, but each attribute makes a statement about a different thing: @datingMethod tells us about the value of @when-custom, @notBefore-custom, and all other @*-custom attributes, while @calendar refers to the string of text inside the tag itself. Both are usually necessary, and they might occasionally be different. Consider the following example:
<date notBefore-custom="1553-07-06" notAfter-custom="1558-11-17" datingMethod="mol:julianSic" calendar="mol:regnal">raigne of Queene Marie</date>
In this example, the author uses the regnal calendar; the encoder, however, supplies an equivalent date in the JulianSic calendar. Thus, @calendar="mol:regnal" indicates that the text content of the element (raigne of Queene Marie) is a regnal date, while @datingMethod="mol:julian" indicates that the values supplied for the attributes @notBefore-custom and @notAfter-custom are Julian dates.
Note that if a date is unambiguously Gregorian, there is no need to make any reference to the calendar. This is the case with most dates after 1752 in England. In other words, this:
<date when="1959-08-05">5 August 1959</date>
is clearly a Gregorian date (both its text and its @when attribute). In our project, we make a point of adding @calendar="mol:gregorian" to any Gregorian date prior to 1752 for the sake of clarity, and we prompt you to check that any date before 1752 has the appropriate calendar settings through a Schematron warning. All dates after 1752 are assumed to be Gregorian unless otherwise specified.

Encoding Regnal Dates

Often, early modern authors will describe a period of time in relation to the ruling sovereign. For instance, Stow describes:
It was there, I say, hanged on iron hookes many yeeres, till the third of King Edward the sixt, that one Gap in transcription. Reason: Editorial omission for reasons of length or relevance. Use only in quotations in born-digital documents.[…]
Dates phrased in such a way are called regnal dates and should be tagged appropriately.
However, since the start and end dates of reigns can be contentious (see Cheney for further detail), we tag regnal dates using a special combination of @datingMethod and @calendar. Recall that @calendar always refers to the textual content of the date, whereas @datingMethod refers to the system used to resolve the content of the date into a processable format. In the case of regnal dates, we use @datingMethod="mol:regnal" and @calendar="mol:regnal". The @datingMethod attribute must point to a specific @xml:id as encoded in the Index of Regnal Dates.
To encode the above example from Stow:
<p>It was there, I say, hanged on iron
               <lb/>hookes many yeeres, till the <date when-custom="r_EDWA4_03" calendar="mol:regnal" datingMethod="mol:regnal">third of
                 <lb/><name ref="mol:EDWA4">King <hi>Edward</hi> the sixt</name></date> <gap reason="editorial"/> </p>
Note that the value of the @when-custom attribute is not a proper date, but is, instead, a reference to a range of dates (currently rendered as a row in the Index of Regnal Dates) for the third year of Edward VI’s reign.

The Range of Dating Elements

So far, we have discussed only the <date> element, but we also use at least three other types of dating element, <birth>, <death>, and <floruit>. These appear only in the personography, inside <person> elements. They behave exactly like <date> elements, except that they usually have no textual content, because they are not transcribing an original source text; they are more like database fields. So you might see
<person xml:id="LYLY1">
              <persName type="hist">
                <reg>Lyly, John</reg>John Lyly</persName>
              <birth when-custom="1554" datingMethod="mol:julianSic"/>
              <death when-custom="1606" datingMethod="mol:julianSic"/>
              <!-- Biographical information goes here -->
            </person>
There are also other elements which make use of the dating attributes (@when, @when-custom etc.) In all cases, the same rules apply: use the @calendar attribute to explain the calendar of the textual content of the element and use the @datingMethod attribute to explain the calendar of the custom attributes.

Attributes for Date Ranges

Up to now, we have focused on the @when and @when-custom attributes, which are useful when encoding a precise date. But there are other attributes you will need to use when encoding a duration or an imprecise date. First, let us look at a duration. Imagine that you want to encode a period of time from the beginning of the year to the end of April. You can do this using the @from and @to attributes:
<date from="2011-04-30" to="2012-01-01"/>
This example is a modern Gregorian date. What if it were Julian? Well, we have to use the equivalent *-custom attributes, like this:
<date from-custom="1600-04-30" to-custom="1600-01-01" datingMethod="mol:julianSic"/>
Do not forget to include the @datingMethod attribute. Note that in the Julian calendar in use in England between 1155 and 1752, January 1 through March 24 may have belonged to the preceding year, if the beginning of the year was regularized to March 25 ("julianMar"). This example will render a number of possible dates that covers all cases.
The case of a duration is less likely to come up in our project than the case of a date range. This is the situation where the date of something cannot be precisely pinned down, but you know that it happened between one point in time and another. You can encode this using @notBefore and @notAfter, and their sidekicks @notBefore-custom and @notAfter-custom. Here is an example from Cuthbert Burbage’s personography entry:
<birth notBefore-custom="1564" notAfter-custom="1565" datingMethod="mol:julianSic"/> <death when-custom="1636" datingMethod="mol:julianSic"/>
This example represents a situation in which we know that Burbage was not alive at the beginning of 1564, and we know that he was definitely alive by the end of 1565, but we do not know precisely when he was born.
The not* attributes do not have to be used in pairs. If you know someone was definitely dead by 1600, but you have no idea of the last time he was known to be alive, you might just use @notAfter-custom, without its partner @notBefore-custom.
Note that we do not use the @calendar attribute when there is no textual content in the element.

Examples

Here are some examples of date encoding from our own texts. The surrounding XML has been simplified for the sake of clarity.
<p><gap reason="editorial"/> William of Malſmebery, hath that <date when-custom="0994" datingMethod="mol:julianSic" calendar="mol:julianSic"> about the yeare of Chriſt,
              994</date>. the Londoners, ſhut vp their gates <gap reason="editorial"/></p>
<p><gap reason="editorial"/> <date when-custom="r_EDWA4_17" datingMethod="mol:regnal" calendar="mol:regnal">In the 17. of Edward the 4</date>.
              Ralfe Ioceline, Mayor, cauſed parte of the wall aboute the Citie of London, to be
              rapayred <gap reason="editorial"/></p>
. Note that in the above example, we express both the textual content and the date values of the element using the "mol:regnal" value.
<date when-custom="1545" datingMethod="mol:julianSic" calendar="mol:julianSic" precision="low">about the yeare 1545</date>
Here, we use the @precision attribute (described below) to signify that the date is imprecise.

Uncertainty, Imprecision, and Evidence

There are many situations in which there is uncertainty about the correctness of a date (for instance, if the date comes from a source which cannot be wholly trusted, and there is no supporting evidence). In this case, you can use the @cert attribute on the date element, like this:
<date when-custom="1601" cert="low" datingMethod="mol:julianSic" calendar="mol:julianSic">1601</date>
The acceptable values are "high", "medium", "low", and "unknown". We do not normally use "high", since the absence of the attribute is assumed to signify a high degree of certainty.
In addition to uncertainty, you may find that you need to encode a date which is imprecise; for instance, the beginning of the last century. There are two ways to do this; one is using the @notBefore and @notAfter attributes discussed above, and the other is to use the @precision attribute. The values for the @precision attribute are the same as those for the @cert attribute shown above.
When a date is surmised or calculated based on some other occurrence (such as a birth date that can be approximated based on a baptismal record), the nature of the evidence can be encoded with the @evidence attribute:
<birth notAfter-custom="1598" datingMethod="mol:julianSic" evidence="baptism"/>
Note that the list of values for @evidence is not fixed at this time; as we continue to develop our system of encoding dates, a set of useful values will emerge and these will be standardized and constrained through the schema.

How Dates are Rendered

As transcribers and encoders, you do not need to worry about how dates are rendered, generally, but it helps to have an idea of what will happen. These are the general rules:
  • In the case of dating elements with textual content (such as some of the examples in the sections above), the textual content of the date will be shown on the page.
  • In the case of dates with no textual content (such as the <birth>, <death> and <floruit> elements used in the personography), the date or date range encoded in the attributes will be rendered into a form which complies with our house style rules.
  • In all cases where dating attributes provide a Julian date, a mouseover popup will be created which explains the fact that the date is Julian, and provides a conversion of the date or range into an equivalent rendering in the proleptic Gregorian calendar.
  • If the date element has a @cert attribute with a value which is not "high", then the date rendering will be followed by a question mark to indicate the uncertainty.
  • If the date element has a @precision attribute with a value which is not "high", then the date rendering will be preceded by c. (circa).

Notes

  1. Note that other projects dealing with the early modern period may use different conventions for recording and encoding dates. For example, Early Modern London Theatres (EMLoT) normalizes the beginning of the Julian year to January 1st whereas we disambiguate the various possible start dates for the beginning of the year. (TLG)↑
  2. Thoughout this work the terms of Old Style and New Style are used with the primary meanings attached to them by the Oxford English Dictionary; that is to say, by Old Style we mean the Julian calendar and by New Style the Gregorian, irrespective of the date adopted for the beginning of the year where these systems are in use. The practice of historians, both in England and on the Continent, has varied in the past, resulting in some confusion. To use New Style, as is often done, to denote simply the historical year, which begins on 1 January is, strictly speaking, incorrect and to be avoided. If the reader will consider the variations in the practice of England, Scotland, and France between the years 1600 and 1752, he [or she] will realize at once the danger of laxity in this matter (Cheney xii-xiii).↑

References

Cite this page

MLA citation

Holmes, Martin D., and Janelle Jenstad. Encode a Date. The Map of Early Modern London, edited by Janelle Jenstad, U of Victoria, 26 Jun. 2020, mapoflondon.uvic.ca/encoding_dates.htm.

Chicago citation

Holmes, Martin D., and Janelle Jenstad. Encode a Date. The Map of Early Modern London. Ed. Janelle Jenstad. Victoria: University of Victoria. Accessed June 26, 2020. https://mapoflondon.uvic.ca/encoding_dates.htm.

APA citation

Holmes, M. D., & Jenstad, J. 2020. Encode a Date. In J. Jenstad (Ed), The Map of Early Modern London. Victoria: University of Victoria. Retrieved from https://mapoflondon.uvic.ca/encoding_dates.htm.

RIS file (for RefMan, EndNote etc.)

Provider: University of Victoria
Database: The Map of Early Modern London
Content: text/plain; charset="utf-8"

TY  - ELEC
A1  - Holmes, Martin
A1  - Jenstad, Janelle
ED  - Jenstad, Janelle
T1  - Encode a Date
T2  - The Map of Early Modern London
PY  - 2020
DA  - 2020/06/26
CY  - Victoria
PB  - University of Victoria
LA  - English
UR  - https://mapoflondon.uvic.ca/encoding_dates.htm
UR  - https://mapoflondon.uvic.ca/xml/standalone/encoding_dates.xml
ER  -

RefWorks

RT Web Page
SR Electronic(1)
A1 Holmes, Martin
A1 Jenstad, Janelle
A6 Jenstad, Janelle
T1 Encode a Date
T2 The Map of Early Modern London
WP 2020
FD 2020/06/26
RD 2020/06/26
PP Victoria
PB University of Victoria
LA English
OL English
LK https://mapoflondon.uvic.ca/encoding_dates.htm

TEI citation

<bibl type="mla"><author><name ref="#HOLM3"><surname>Holmes</surname>, <forename>Martin</forename> <forename>D.</forename></name></author>, and <author><name ref="#JENS1"><forename>Janelle</forename> <surname>Jenstad</surname></name></author>. <title level="a">Encode a Date</title>. <title level="m">The Map of Early Modern London</title>, edited by <editor><name ref="#JENS1"><forename>Janelle</forename> <surname>Jenstad</surname></name></editor>, <publisher>U of Victoria</publisher>, <date when="2020-06-26">26 Jun. 2020</date>, <ref target="https://mapoflondon.uvic.ca/encoding_dates.htm">mapoflondon.uvic.ca/encoding_dates.htm</ref>.</bibl>

Personography