• Herman Hollerith from National Institute of Standards and Technology Virtual Museum
• Insurance and the Tabulator Era in a paper by JoAnne Yates
• IBM Punch Card Systems in the U.S. Army by Charles M. Province
• IBM Punch Card System (1950s - 1960s) at Computer Museum of America
• Punched Card Equipments from Fédération des Equipes Bull
  (with background noise sampled from a Bull card sorter)
• The Undead from Wired 7.03

We shall consider keys that are 32-bit nonnegative integers and we shall treat them as four-digit integers with radix 256: if

Given any integer n in the interval [0,2³² ), we can compute the corresponding b₀ , b₁ , b₂ , b₃ by the straight-line program

• the bitwise AND operator &
  that is often used to mask off some set of bits
  (m & 255 sets to zero all but the low-order 8 bits of m)

• the right shift operator >>
  that performs a right shift of its left operand
  by the number of bit positions given by its right operand.

• Bitwise Operators in Programming in C by A. D. Marshall,
• The logical functions and The shift instructions in TUTORIAL C by Gordon Dodrill.

Radix sorting linked lists

stack *rsort(stack *my_stack)
{
  int shift, i;
  stack *bucket[256];
  stack_object *first;

  for(shift=0; shift<32; shift+=8)
    {
      for(i=0; i<256; i++)
        bucket[i]=create_stack();
      while(!(stack_is_empty(my_stack)))
        {
          first=top_of_stack(my_stack);
          push_on_stack(first,bucket[((first->key)>>shift)&255]);
          pop_stack(my_stack);
        }

      for(i=255; i>=0; i--)
        while(!(stack_is_empty(bucket[i])))
          {
            first=top_of_stack(bucket[i]);
            push_on_stack(first,my_stack);
            pop_stack(bucket[i]);
          }
    }
  return my_stack;
}

Radix sorting arrays

void rsort(record a[], int n)
{
  int i,j;
  int shift;
  record temp[MAXLENGTH];
  int bucket_size[256], first_in_bucket[256];
 
  for(shift=0; shift<32; shift+=8)
    {
      /* compute the size of each bucket and
         copy each record from array a to array temp */
      for(i=0; i<256; i++)
        bucket_size[i]=0;
      for(j=0; j<n; j++)
        {
          i=(a[j].key>>shift)&255;
          bucket_size[i]++;
          temp[j]=a[j];
        }

      /* mark off the beginning of each bucket */
      first_in_bucket[0]=0;
      for(i=1; i<256; i++)
        first_in_bucket[i]=first_in_bucket[i-1]+bucket_size[i-1];

      /* copy each record from array temp to its bucket in array a */
      for(j=0; j<n; j++)
        {
          i=(temp[j].key>>shift)&255;
          a[first_in_bucket[i]]=temp[j];
          first_in_bucket[i]++;
        }
    }
}