MARC Reader: a HyperCard script to demystify the MARC record

The purpose of this article is to demystify the MARC record and list a short HyperCard script that translates a MARC record into an easy-to-read format. Furthermore, this article demonstrates that advanced library applications can be created with simple, readily-available tools; with HyperCard and a bit of investigation any librarian can create their own electronic card catalog.

A copy of the MARC Reader HyperCard stack is available at http://infomotions.com/musings/marc-reader/marc-reader.hqx .

About the MARC record

Since the late '60s, when cataloging information was stored on tape, the MARC record has been the standard format for transferring cataloging information. ("MARC" is an acronym for machine readable cataloging.) Even though it has been a standard for more than two decades, the majority of librarians do not know how to read it.

On one hand, the confusion about the MARC record is comprehensible. At first glance, an unformatted MARC record looks like computer garbage or telecommunications line noise.

After further investigation, the MARC record is a highly structured piece of information. It is like a sentence with a subject, predicate, objects, separated with commas, semicolons, and one period. In data structure language, the MARC record is a hybrid sequential/random access record.

The structure of a MARC record

The MARC record is made up of three parts: the leader, the directory, the bibliographic data. The leader (or subject in our analogy) is always represented by the first 24 characters of each record. The numbers and letters within the leader describe the record's characteristics. For example, the length of the record is in positions 1 to 5. The type of material the record represents (authority, bibliographic, holdings, et cetera) is signified by the character at position 7. More importantly, the characters from positions 13 to 17 represent the base. The base is a number pointing to the position in the record where the bibliographic information begins. See Figure 1.

Figure 1. This is MARC record in raw, communications format. The leader is contained in the first 24 characters. The directory starts at the 25th character and continues until the "ocm". The bibliographic section begins after the directory and continues to the end of the example. The mysterious looking rectangles represent the field delimiters, ASCII codes 29, 30, and 31.

The directory is the second part of a MARC record. (It is the predicate in our analogy.) The directory describes the record's bibliographic information with directory entries. Each entry lists the types of bibliographic information (items called "tags"), how long the bibliographic information is, and where the information is stored in relation to the base. The end of the directory and all variable length fields are marked with a special character, the ASCII character 30.

The last part of a MARC record is the bibliographic information. (It is the object in our sentence analogy.) It is simply all the information (and more) on a catalog card. Each part of the bibliographic information is separated from the rest with the ASCII character 30. Within most of the bibliographic fields are indicators and subfields describing in more detail the fields themselves. The subfields are delimited from the rest of the field with the ASCII character 31.

The end of a MARC record is punctuated with an end-of-record mark, ASCII character 29. The ASCII characters 31, 30, and 29 represent our commas, semicolons, and periods, respectively.

The script

The appendix lists a script from a HyperCard program I call "The MARC Reader". It:

1. reads a single MARC record,
2. displays the raw data in a field,
3. parses out the leader, length, and base,
4. reads the directory and puts it into another field, and
5. reads and displays the bibliographic data in an easy-to-read format.

The fundamental purpose of The MARC Reader is to demystify the MARC record. It is based on Frederick J. Raithel's article in Small Computers in Libraries 1 and Walt Crawford's tome, MARC for Library Use: Understanding Integrated USMARC .2 (Note: The MARC Reader is designed to read a single, stand-alone MARC record. Many times MARC records are concatenated together. You can easily modify The MARC Reader to contend with this contingency.)

This is how to get The MARC Reader to work for you. You will need HyperCard 2.0 and at least one MARC record. Then:

1. Create a new HyperCard 2.0 stack.
2. Create two scrolling card fields.
3. Name the first card field "theField". Set its font to something like Monaco 9. Size it to take up most of the screen.
4. Name the second card field "theDirectory". Hide it.
5. Create a card button called "Read MARC" and enter the script from the appendix into this button.

After clicking "Read MARC" and selecting a MARC record, the file will be reformatted and look something like Figure 2.

Figure 2. After running the script contained in the button "Read MARC" your MARC record will look something like the above illustration. This is called a tagged format.

The MARC Reader represents the beginning of an automated catalog. With this program and your data it would be a trivial matter to create new cards for each new record and parse the data into individual fields. This exciting exercise is left up to you.

References

1. Raithel, F.J., "READMARC: A simple BASIC program to read MARC bibliographic records," Small Computers in Libraries (April 1987):33-36.
2. Walt Crawford, MARC for Library Use: Understanding Integrated USMARC, Second edition. New York: G.K. Hall & Co., 1989.

Appendix: The MARC Reader script

on mouseUp
  
  -- initialize some variables
  put the numToChar of 29 into endOfFile       -- ASCII 29 is the end of file mark
  put the numToChar of 30 into endOfField      -- ASCII 30 is the end of subfield mark
  put the numToChar of 31 into endOfSubfield   -- ASCII 31 is the end of file mark
  put 24 into thePointer                       -- the begining of the directory
  put empty into card field theField           -- a window to see the record
  put empty into card field theDirectory       -- a storage place for the directory data
  
  -- retrieve the raw data
  answer file "What record do you want to read?"
  if it is empty then exit mouseUp
  put it into theFile
  open file theFile
  read from file theFile until endOfFile
  put it into theRawData
  close file theFile
  
  lock screen
  set cursor to watch
  
  put return & "This is MARC record, " & theFile & "." & return  into card field theField
  
  -- read and display the raw data
  put return & "This is the raw data." & return after card field theField
  put theRawData after card field theField
  
  -- read and display the LEADER. it is stored in the first 24 characters
  repeat with i = 1 to 24
    put char i of theRawData after theLeader
  end repeat
  put return & return & "The leader is " & theLeader after card field theField
  
  -- read and display the LENGTH. it is stored in the first five characters
  repeat with i = 1 to 5
    put char i of theRawData after theLength
  end repeat
  put return & "The length is " & the value of (theLength) after card field theField
  
  -- read and display the BASE. it is stored in characters 13 through 17
  repeat with i = 13 to 17
    put char i of theRawData after theBase
  end repeat
  put the value of (theBase) into theBase
  put return & "The base is " & theBase after card field theField
  
  -- read and display the directory
  put "Reading the directory...please wait."
  put return & return & "MARC tag    Field offset     Offset" after card field theField
  put return &          "--------    ------------     ------" after card field theField
  
  repeat forever
    
    -- read the tag
    put empty into theTag
    repeat with i = 1 to 3
      if theCharacter is endOfField then exit repeat
      add 1 to thePointer
      put char thePointer of theRawData into theCharacter
      put theCharacter after theTag
    end repeat
    
    -- exit the repeat loop if the end of field mark was found
    if theCharacter is endOfField then exit repeat
    put return & theTag after card field theField
    
    -- read the field offset
    put empty into theFieldOffset
    repeat with i = 1 to 4
      if theCharacter is endOfField then exit repeat
      add 1 to thePointer
      put char thePointer of theRawData into theCharacter
      put theCharacter after theFieldOffset
    end repeat
    put "         " & theFieldOffset after card field theField
    
    -- read the offset
    put empty into theOffset
    repeat with i = 1 to 5
      if theCharacter is endOfField then exit repeat
      add 1 to thePointer
      put char thePointer of theRawData into theCharacter
      put theCharacter after theOffset
    end repeat
    put "             " & theOffset after card field theField
    
    -- store the directory
    put theTag & "," & theFieldOffset & "," & theOffset & return after card field theDirectory
    
  end repeat
  
  -- read and display the bibliographic data
  put "Reading the bibliographic data...please wait."
  put return & return & "This is the bibliographic data." & return & return after card field theField
  put the number of lines in card field theDirectory into theNumberOfLines
  repeat with i = 1 to theNumberOfLines
    put item 1 of line i of card field theDirectory into theTag
    put the value of (item 2 of line i of card field theDirectory) into theFieldOffset
    put the value of (item 3 of line i of card field theDirectory) + theBase into theOffset
    put empty into theExtractedData
    repeat with j = 1 to theFieldOffset
      put char j + theOffset of theRawData after theExtractedData
    end repeat
    put theTag & "  " & theExtractedData & return after card field theField
  end repeat
  
  put return & return & return after card field theField
  
  hide message
  
end mouseUp