In early 2000, I became interested in writing a JavaScript application that would generate bibliographic citations for government documents (DocsCite - http://www.asu.edu/lib/hayden/govdocs/docscite/docscite.htm). In part, I was interested in exploring the use of automation to see where it can help and extend what we do as reference librarians. In addition, I wanted to learn JavaScript. JavaScript is a computer language that enables authors to design interactive Web sites.

The work is based on a program by Scott Salzman, Systems Librarian at Furman University in South Carolina. He had been developing a similar application and generously allowed me to use and modify his code. He also offered encouragement and suggestions throughout development of DocsCite.

A search on the Internet turned up three other citation generators. Robert J. Tiess created an experimental program Webcite <http://members.tripod.com/~rtiess/Webcite.htm>, which builds MLA citations. The Turabian Citation Generator <http://jove.prohosting.com/~turabian/> creates citations for footnotes and bibliographies in that style. Copyrighted by Lyle Flint, StyleWizard.com <http://www.stylewizard.com/> generates bibliographic citations in the APA format. The home page notes that the MLA format will be available soon.

DocsCite differs from those citation generators because the others do not focus on government publications. Further, with the exception of StyleWizard.com, they are limited to generating bibliographic citations from one style manual. When complete, DocsCite will handle MLA, APA, Chicago/Turabian, and the Garner/GODORT formats.

Currently, DocsCite creates bibliographic citations in the APA and MLA formats for government publications. The patron first sees a page formatted in frames. On entry, only the top frame displays content. It contains two pull down menus, one for the style manual and the other for the format of the document (Print/Microform, Document on a CD-ROM, Citation for the entire CD-ROM, and an Internet document). When an entry is selected in both boxes and the search button clicked, the program generates a form specific to the selections in the lower frame (figure 1). After the user fills out the boxes and clicks the "Submit Citation" button (at the bottom of the input form) an error checking routine may notify them through an alert box that a required field is blank. When everything is complete, a separate window opens with the formatted bibliographic citation (figure 2).

At the beginning of creating DocsCite, I naively thought that learning JavaScript would present the most challenge because my programming background is limited. I had a class in Fortran in the mid-1970s. In the mid-1980s I had Basic as part of a course and took a class in Pascal. As time went on and I became more comfortable with the language, designing the user interface emerged as the most difficult issue. That also became the most interesting aspect. This section traces that development.

Figure 3 shows part of the prototype created as proof of concept and as a vehicle to learn JavaScript. As can be seen, the page can generate a citation in MLA, APA, and Chicago/Turabian formats. I modified Salzman’s error-checking code to help ensure that the user completes all needed information. Visible at the bottom of the figure is the selection where the user indicates whether the format of the document is physical or online. Those sections later became a major concern in designing the user interface. Because the prototype was mainly for my use, I did not worry about the design of the interface and wrote a plain page.

To write the prototype, I studied the style manuals in order to produce the citations. I learned that each applies a different philosophy. For example, unlike the others, the Garner/GODORT style includes the SuDoc number as part of the citation. Because of differences like this, I decided to create a separate page for each style manual. Separate pages would enable DocsCite to reflect the differing requirements more easily and would be easier to maintain than one large page.

The first style developed was MLA. The layout of the interface can be described as "Baroque," which is "marked by the use of complex forms." As can be seen in figure 4, the user was required to select a physical or Web format and then make their way through a gauntlet of options. For example, if the publication resided on a CD-ROM, a user would have to know to also select the physical format. Unless all the entries under that section were completed, the error routine would inform the user to provide more information - a further frustration. In an attempt to help, I changed the font color of the field names to maroon. I hoped that the color would guide the user to the input box. Although adding a festive air, this change did not reduce the clutter. To further confuse matters, the help information was below the form on the same page.

They say, "If it ain’t Baroque, don’t fix it." Since it was Baroque, I e-mailed one of my sisters (a technical writer, photographer and former typesetter) for ideas on the page design. Her layout simplified the page by realigning the field labels and other elements in relation to the input boxes, editing the labels, and moving the help information to a separate page (figure 5). She also mentioned seeing reference to a way to hide unneeded fields. Displaying only the required fields for a given format further simplifies the user interface. For example, a citation for a paper document does not require a URL or date viewed.

Based on her layout and thoughts, my next effort was to experiment with layers. Layers are like a stack of overhead transparencies. Separate sheets contain different sections of the form. The user’s selections determine which sheets are employed. In my trial I soon learned that Netscape and the Internet Explorer differ in how they refer to elements in different layers. Continuing that track would have required DocsCite either to work for only one browser or to recognize which browser was viewing the page and to adjust accordingly. Although possible, it was more complex than my skills or available time allowed.

During this entire effort I was in contact with Salzman. He had been urging me to use frames as the method to manage the interface. He noted that using frames was a simpler solution than layers and would accomplish the goal of controlling which fields appeared on the form. I resisted that idea because I thought frames generally clutter a page, detracting from its content. When the layers avenue failed, I finally took his advice.

There are three windows in the frameset, one hidden below the screen (figure 6). The top window contains the ASU Libraries header as well as the menus for the style manual and the format of the document. After selecting the style manual and the format of the document the user clicks the "Submit" button. With that click, a page written for that manual loads in the hidden window (step 1 in the figure).

The page in the hidden window contains the code for creating the input form, error checking, and producing the citation. Upon loading, it checks the selected document format in the top window (step 2). It then writes preformatted HTML, specific to that format, to the bottom visible window (step 3). When the user clicks the "Submit Citation" button (step 4), the JavaScript code checks for errors. Finding none, it formats the input from the fields into the bibliographic citation and writes the citation to a new window in HTML (step 5).

DocsCite is a work in progress. The next steps will be developing modules for the Chicago/Turabian and the Garner/GODORT style manuals. In addition, sections for legal citations and congressional documents will be created. Finally, the user interface is still not quite right and will take more work.

JavaScript is a useful tool in developing Web resources. For example, it is used to check that a user has completed a form before forwarding it for further processing. Nevertheless, in developing DocsCite, I learned that using JavaScript does not automatically guarantee a successful page. Designing the user interface has been, and will continue to be, a tougher problem than writing the JavaScript code.

Currently, DocsCite extends what reference librarians do by automating the mechanics of formatting a bibliographic citation, i.e., what to underline and where to place various elements. It may never be able to handle all of the intricacies of a citation question. Recently, a colleague wanted to know how to cite the Congressional Record. We assembled the citation fairly easily and continued to chat. She noted that the citation dealt with someone’s testimony before Congress. Although she was under the impression that all testimony was in the Congressional Record, I knew that it did not include hearings where the discussion probably took place. I quickly found the hearing, verified with her that it was the right one, and we built the correct citation. I was working on DocsCite at the time and wondered if I could ever give it a level of sophistication to recognize when a patron is referring to a wrong source.