Imagine trying to learn a programming language that combines the symbolic density of LISP, the stack-based logic of Forth, the macro capabilities of UNIX shell scripting, and a syntax that uses punctuation marks where other languages use English words. Now imagine that your only documentation is a handful of technical reports from 1978 and a textbook that has been out of print for forty years.

Welcome to SAM76.

For students in early interpreter coursework—particularly those studying the history of programming languages or the design of macro processors—SAM76 presents a unique challenge. This article provides guidance for navigating SAM76 homework assignments, drawing on original documentation from the CP/M archives, the Dr. Dobb’s Journal article that introduced the language, and the surviving SAM76 handbook .

What Is SAM76, Really?

Before diving into homework strategies, it helps to understand what SAM76 actually is. Developed by Claude A. R. Kagan in the late 1970s, SAM76 is a macro programming language designed to run on very small computer systems—initially CP/M machines with as little as 8K of RAM . The language was inspired by two earlier macro processors: Strachey’s GPM (General Purpose Macro Generator) and McIlroy and Morris’s M6 macro processor at Bell Labs .

Kagan had five design goals, all of which directly impact how students need to think about the language:

1. Syntactic and semantic purity (meaning the rules are consistent, if unfamiliar)
2. Minimum keyboarding for powerful results (heavy use of symbols over words)
3. Fit in very small computers (efficient, but cryptic)
4. Interactive editing, testing, and execution (designed for a REPL)
5. Allowing “strange things” with predictable results (powerful, but dangerous) 

For coursework, the most important implication is that SAM76 was never designed to be “beginner friendly” in the way that BASIC or Pascal were. It was designed for users who knew exactly what they wanted to do and wanted to do it with minimal typing.

The Three Syntaxes: S, M, and A

One of the first hurdles in SAM76 homework is understanding that the language actually contains three different syntax systems, each with its own evaluation rules. This is not a bug; it was an intentional design feature that allowed SAM76 to remain compatible with M6 while adding new capabilities .

S Syntax (Strachey-derived)

The “S” syntax follows Strachey’s GPM model. It uses the forward slash (/) as a terminator and distinguishes between active and neutral function calls:

• Active: #function,arguments/ — The function executes and its return value becomes part of the expression.
• Neutral: \function,arguments/ — The function executes differently, often just displaying a value without returning it for further evaluation.

Here is a working example from the Dr. Dobb’s Journal article that demonstrates defining a macro to square a number:

text

#DT,SQ,[q1 * q1]/   Defines SQ as text containing the expression
#FT,SQ,5/           Fetches SQ with partition 5 — returns 25

The DT (Define Text) function stores the string [q1 * q1] as a macro named SQ. The q1 is a dummy variable (partition) that gets replaced when the macro is fetched. When you call #FT,SQ,5/, the 5 replaces q1, yielding 5 * 5 = 25 .

M Syntax (M6-compatible)

The “M” syntax maintains compatibility with the M6 macro processor from Bell Labs. Instead of forward slashes, it uses colons (:) and semicolons (;). The same squaring macro written in M syntax looks like this:

text

#DT,SO,(#MD,jq1,q1:):   Define text using M6 notation
#PT,SO,q1:              Partition the text
#SO,5:                  25

The key difference for homework purposes is that S syntax searches resident functions first (the built-in ones), while M syntax searches user-defined functions first. This affects how you need to think about name conflicts and evaluation order .

A Syntax (Arithmetic Infix)

The “A” syntax is the arithmetic subsystem that allows conventional infix notation like 5 + 5 * (144/12). This system has its own evaluation rules and is invoked when SAM76 detects arithmetic operators .

Homework Tip: When you see an expression that mixes arithmetic with macro calls, remember that the A syntax operates within the framework of whichever syntax (S or M) you are using. The infix evaluation happens after macro expansion, not before.

Core Functions You Will Encounter

Based on the original SAM76 updates and the surviving documentation, here are the functions most likely to appear in early interpreter homework:

The XU Family (Xperimental User Functions)

The xu primitive is a gateway to a family of experimental functions that manipulate memory, files, and communications. These appear frequently in assignments about interpreter internals .

Function	Purpose	Example
xu,fm,x1,x2,s0	Fetch memory contents between x1 and x2	#xu,fm,1000,2000,>>/
xu,sum,x1,x2	Return arithmetic sum of memory cells	#xu,sum,8000,8FFF/
xu,mm,x1,x2,x3	Move memory block	#xu,mm,1000,1FFF,2000/
xu,rcv,5,9000	Receive checksummed object code	%nud,xu,rcv,5,9000/=

The nud function (null display) is frequently used with xu functions to display results without causing evaluation errors due to workspace limitations .

Channel Control Functions

SAM76’s I/O system uses two communication groups. Group 1 normally interacts with the user console; Group 2 interacts with reader/punch devices .

Key functions include:

• sic,sym — Select Input Channel (assigns Group 1 or 2 functions to a channel)
• soc,sym — Select Output Channel
• lic,s0 — List Input Channels (returns names like CON, RDR, FIL, USR)
• loc,s0 — List Output Channels (CON, PUN, FIL, USR, LST)

Homework Tip: When an assignment asks about redirecting I/O or implementing device independence, these channel control functions are the answer. SAM76’s design explicitly limited simultaneous file access to one input and one output file, as “very little need for simultaneous access” was assumed .

File Functions

The disk overlay provides file operations that are surprisingly modern in concept:

• dif,filename — Designate Input File (opens for reading)
• dof,filename — Designate Output File (opens for writing)
• rfr — Read File Record (returns 128 characters typically)
• wfr,s — Write File Record
• sfe,s — Set File Extension
• qfs,filename — Query File Size (returns number of 256-byte records)

Note: Files must be explicitly closed with %dof/= (no arguments) or data may be lost. The ex exit function does not close files automatically .

Common Homework Pitfalls and Solutions

Pitfall 1: Confusing Active and Neutral Evaluation

Students frequently expect a function to return a value when it actually modifies state, or vice versa. The documentation emphasizes that “null valued functions” (those that don’t return a value) behave differently depending on whether they are called actively or neutrally .

Solution: Before using any function, check whether it is described as “valued” (returns a value) or “null valued” (performs an action). For example, wfr,s (Write File Record) is null valued—it writes but returns nothing.

Pitfall 2: Workspace Limitations

The original SAM76 interpreter had severe memory constraints. The documentation explicitly warns that “use of some of the foregoing value returning functions would fail due to lack of sufficient user work space for storage prior to evaluation” .

Solution: Use the nud (null display) function to avoid workspace overflow: %nud,xu,fm,100,200,/=.

Pitfall 3: Forgetting to Terminate Expressions

Unlike modern languages where newlines terminate statements, SAM76 uses explicit terminators: / for S syntax, : for M syntax, and ; as an alternative in some contexts.

Solution: Treat terminators like semicolons in C or Java—they are not optional.

Approaching the Interpreter Coursework Assignment

If you have been given a SAM76 homework assignment in an early interpreter course, here is a structured approach:

Step 1: Identify the Syntax Context

Is the assignment using S syntax, M syntax, or both? The evaluation rules differ. Look for the terminator characters (/ vs : vs ;) as your first clue.

Step 2: Map the Problem to SAM76 Primitives

SAM76 has no “print” statement in the conventional sense. Output is handled by os (Output String) or channel assignments. Input uses is (Input String). File operations require opening channels first.

Step 3: Consider the Evaluation Order

Remember that for S syntax: resident functions are searched first. For M syntax: user-defined functions are searched first. This affects whether a macro will override a built-in function.

Step 4: Test Incrementally

The interpreter was designed for interactive use. Build your solution piece by piece, testing each function before combining them.

Step 5: Document Your Assumptions

Given the scarcity of SAM76 documentation, your instructor will likely be more interested in your understanding of macro evaluation principles than in perfect syntax. Explain what you expect each function to do and why.

Conclusion

SAM76 is a challenging language for homework because it deliberately violates many assumptions that students bring from modern programming. It has no explicit “hello world” example in most documentation because output is a function you assign to channels. It has no clear distinction between code and data because macros are text that gets evaluated. It has three syntax systems because compatibility and innovation were both priorities.

But that is precisely why SAM76 appears in interpreter coursework: it forces students to think about evaluation order, macro expansion, workspace management, and the relationship between syntax and semantics. The language may be obscure, but the concepts it teaches are fundamental.

And if you get stuck? Remember what the 1978 documentation advised: “judicious use of the nud and sem functions should be considered” . Sometimes the best way out is to display nothing at all.

---

References

1. SAM76 Language Update No. 5, September 1978. CP/M Archives. 
2. The SAM76 Language Handbook, 2nd ed. Kagan, Claude A. R. SAM76 Inc., 1979. 
3. SAM76 Wikipedia entry (2016 version). 
4. SAM76 Language documentation, CP/M User Group archives. 
5. Kagan, Claude A. R. “The SAM76 Language.” Dr. Dobb’s Journal of Computer Calisthenics & Orthodontia, No. 21.