Here are some of my more interesting PostScript diagrams and pages. All were created as PostScript code using a text editor (and formatter). Almost all use abstraction in the form of a runtime system and an intermediate language so that the intermediate language can be generated from other programs (Delphi, ASP, ASP.NET, Python, Prolog, etc.) without that language knowing too much about PostScript.

Note that many of the pages that have text have 96 lines of common routines. The lines include lots of blank lines for readability.

In 2009 I designed a logo for the Sunshine Squares square dancing club in Statesboro, GA. After designing the logo in my head, I used PostScript to create the logo. I also obtained the domain name and started to put together a web site for them, at http://www.SunshineSquares.com. Then, I used the PostScript code to create business cards using code I developed years before for doing business cards.

In 2009, to create an spinning Benham disk, I wrote a PostScript program to create 36 Benham disks, in increments of 10 degrees rotation from 0 to 360 degrees (0 and 360 being the same, of course). Then I used animated GIF software to combine them. The animation would not go fast enough to see the Fechner colors, so I tried using them in a Flash/ActionScript animation object, but that was not fast enough later. I'll get back to it eventually.

One of my journal articles showed how to create a runtime system and translation scheme to take any grammar in the from of EBNF and convert it into a corresponding syntax diagrams using an intermediate code that can be interpreted using PostScript (287 lines).

I have never had business cards from any organization for which I have worked. I just print my own with my PostScript file, modified as needed. The tick marks were used to line up the paper cutter before laser perforated business cards were available. (265 lines)

I still make my own workout cards so I can have the workout machines listed just as I like to see them. (200 lines)

I created mailing labels and used the intermediate language to generate mailing labels from Windows programs. (188 lines)

I switched to the Dvorak keyboard layout in 2002. Companies were charging $10 for key-cap labels, so I created a PostScript file to put the keycap labels on mailing labels then used a scissors to cut them out and put them on the keycaps. (165 lines)

In about 2001, I researched scanned input forms for custom exams - for sections where students were not in front of a computer in the classroom. I wanted to create my own customized Scantron sheets with printed questions, etc. The Director of IT told me it would not work. But after I created the forms that looked almost like the official ones, they did, in fact, work. They were also used at the next University.

At the time when I was into war games, I created a PostScript file to output a hex grid. (75 lines)

To teach the Towers of Hanoi problem to high school students, I created a PostScript program to allow them to cut out their own disks to be used to learn the game. (45 lines)

The business card model was used to create a card trick whereby a number from 1 to 30 is guessed based on the participant responses. (184 lines)

Here is a cutout that can be folded and taped to create a paper Egyptian pyramid. The image is rectangular but the pyramid makes on optical illusion making the paper appear not straight. (105 lines)

To see the fonts on the printer, this PostScript file printed a page for every font in the printer. Or, just one named font could be printed. I also created my own font for DOS fixed-font text as it was not available in PostScript. (51 lines)

Here is a time sheet for hours worked by my student workers. Since it looked just like the official one, they agreed to accept it. The runtime system allowed my software that tracked student hours to generate these time sheets already filled in. (185 lines)

The Wilkes University flying "W" logo was pretty simple. (156 lines)

The Shenandoah University logo could be put anywhere in any size or rotation. (435 lines)

Here is the Shenandoah University watermark, make darker so it is visible. (372 lines)

For my monthly newsletter, I created the PostScript for the top banner and then interfaced it to my word processor (which had hooks for including PostScript). (458 lines)

At the time when boot disks were still used in the computer labs, I created boot disk labels for the boot disks. (513 lines)

After writing a minesweeper game for DOS, I created custom floppy disk labels. (194 lines)

Here are some experiments with fonts. (79 lines)

Paper rosters can be very useful for classroom use. Most of the lines for the roster are the data which was generated from my classroom management system. Portrait mode allowed more students to be on one sheet of paper. (653 lines)

I created some piano keyboard routines to put a keyboard anywhere on the page, add text to any key, and shade that key. Close up are the sol-fesh syllables for each scale (in this case the key of D). (95 lines)

Why pay for music pages when you can create your own? I created a PostScript file for a number of musical staff styles for various purposes. (88 lines)

Exercise sheets for solving linear programming problems for management science class. (105 lines)

If you have ever taken a traditional accounting course, you may have used a form similar to this one. (256 lines)

Here are some projects for which I could not easily find images.

• The method of compressing/decompressing images for PostScript (journal article).
• The method for previewing pages at 2, 4, 8, or 16 logical pages per physical page.
• A custom PCFont to show DOS text screen images in PostScript output.
• A custom calendar system for creating printed calendars.
• Custom letter output so that the mailing and return address show through the envelope windows.

I used PostScript in a few of my many publication articles.

[69] Snyder, R. (1999). Using Delphi to convert screen images to compressed PostScript using a run-length encoding scheme. The Journal of Computing in Small Colleges. Vol. 14. No. 2.

Abstract: This paper describes the use of Borland Delphi to convert screen images to a compressed encapsulated PostScript form using a run-length encoding scheme. The savings in bytes is significant, both in terms of the disk space required for storage and the time to transmit the file over a communications line. To facilitate understanding of the PostScript decompression code, Delphi Pascal is used as pseudo code. The design and implementation issues covered serve as a useful introduction to considerations in compression, graphics file formats, and programming in general.

[56] Snyder, R. (1998). Teaching the PostScript model using Excel Basic to create PostScript programs. The Journal of Computing in Small Colleges. Vol. 13. No. 3.

Abstract: To most users, the PostScript page description model is a black box whose innards are never seen. However, a simple understanding of the PostScript page description model can provide a model useful in both using PostScript printers and in diagnosing local and remote printer problems involving PostScript printers. This paper presents a simple PostScript program and then develops an Excel Basic program that outputs that PostScript program. Both programs are excellent for teaching beginning computer users about the PostScript model and for creating interesting and more advanced programming projects for more experienced users.

[6] Snyder, R. (1991). Specifying textual to graphical conversion. Journal of Systems and Software. Vol. 16. No. 1.

Abstract: Textual forms provide a way to specify, document, manipulate, and store formal concepts using conventional editing techniques. Graphical representations are useful for visualization and visual specification systems. This paper describes the use of Prolog to specify the automatic conversion of textual specifications into graphical form. The central example is converting Extended Backus-Naur Form (EBNF) grammars into syntax diagrams. The conversion is simplified by a relocatable intermediate code called T-code that can represent syntax diagrams as a linear sequence of simple graphics instructions. An efficient solution to this problem provides support for higher-level specifications systems requiring real-time visualization. An implementation of the translation method created the syntax diagrams in this paper. Note: Though not in the abstract, the paper shows how the TCode is converted to PostScript for the diagrams in the paper.