Product and programming examples in Genera

avv-pane-test

Classification: application example for an explicit Accepting Values pane.

The framework's pretty name is Test, while its visible title pane reads Test Frame; its direct Select key is A. It also has an Accepting Values pane labeled AVV Should Be Here, a display, and a Listener. The pane edits three frame state variables directly:

Its only application command, Show State, prints the three current values. The command table also inherits full colon commands, standard arguments and scrolling, and the Accepting Values pane commands; it defines no single-character command accelerators.

Source-only finding: the later accept-two definition in the same file also claims Select A. The effective registration after evaluating the complete file is a runtime question; this page does not promise that Select A will reach avv-pane-test in a combined load.

accept-two

Classification: application example for the default program-state Accepting Values handler.

The frame exposes three editable single-float state variables—First month 200.0, Second month 50.0, and Third month 100.0—in a generated Accepting Values pane. A title, ordinary display, and four-line interactor complete the layout. Its only application command, Summarize Data, prints the quarterly sum and mean. Unlike avv-pane-test, this example demonstrates that prompt, type, and initial value metadata on state variables are sufficient for the standard pane handler.

It also declares Select A. Its command table inherits the colon full command, standard arguments, input editor compatibility, and Accepting Values pane command tables; it has no fixed command accelerators of its own. The duplicate Select registration is the same unresolved combined-load issue noted above.

calculator

Classification: application example and advanced Dynamic Windows programming tutorial.

The calculator deliberately has no ordinary command-menu pane. A display pane is painted as a four-by-four keypad, and each displayed oval is installed as a command presentation. The value pane shows the current floating-point number. Select + opens the frame.

Every digit and arithmetic operator works both as a one-key accelerator and as a left-selected displayed key. . enters the fractional state. Return or the Enter oval pushes the displayed value. An arithmetic operator pops the previous value, using 0.0 if the stack is empty, applies the selected Common Lisp function to that value and the current display, and begins a new entry. The state machine distinguishes a new value that should push the old display, a post-Enter value that must not push it again, continued integer entry, and a numeric fractional-place multiplier.

There is no clear, backspace, sign-change, memory, precedence, or error-recovery control in this example. Operations are immediate stack operations, not an infix expression evaluator. The source explicitly calls the custom command-menu handler support advanced and undocumented; this is an implementation teaching sample, not a finished desk calculator.

employee-editor

Classification: application example tied to the User Interface Application Example chapter of Programming the User Interface.

Select * opens a four-pane frame: title, employee display, command menu, and a four-line interactor. Loading the file creates two sample employee Flavor instances and adds them to a global list. The frame itself has no inherited command tables and no fixed accelerators.

The direct middle-button action is intentionally contrasted with the command-based translator. The source calls the direct mutation dangerous because it bypasses the program command loop. That makes the file a compact lesson in why presentation actions and presentation-to-command translators are not behaviorally equivalent.

life

Classification: final application-example stage of a four-file Common Lisp Life tutorial.

Select Square opens a Life title, graphics display, and ten-line Listener. The frame owns a nominal 30-cell-axis board and next-generation board. Live cells are drawn as 5-by-5 filled rectangles. The update implements the familiar Life rule: birth with three neighbors and survival with two or three.

There is no application-specific cell-click gesture or run-until-stopped control. The frame inherits colon commands, standard arguments, and input-editor compatibility but defines no single-key command accelerators.

The complete staged lesson is important context:

1. common-lisp-life supplies global arrays and text-oriented functions;
2. common-lisp-life-with-graphics replaces the display with raster rectangles;
3. common-lisp-life-with-commands adds the global Play Life command, defaulting to three generations; and
4. common-lisp-life-with-program-framework encapsulates board state and UI in the life frame, with Step defaulting to one generation.

Those are successive source lessons, not four independent Life products.

Accepting Values function examples

Classification: three callable tutorials, not program frames.

accepting-values.lisp supplies:

• CHOOSE-DISPLAY-METHOD, whose Redisplay method choice is None, String, or Function and whose second field appears conditionally;
• READ-ROWS-OF-NUMBERS, which maintains a dynamically growing list of integer sequences and always offers one additional row; and
• EIGHT-PUZZLE, which displays a 3-by-3 array and makes only numbered cells adjacent to the blank into Accepting Values command buttons. Selecting one moves it toward the blank, with mouse documentation saying Up, Down, Left, or Right.

EIGHT-PUZZLE returns the resulting array but contains no solved-state detector, move counter, reset command, or victory display. It demonstrates command buttons and redisplay, not a completed puzzle game.

Audio examples (audio-examples)

Classification: callable hardware tutorials and performance tests.

SINE-WAVE, SAW-WAVE, and SQUARE-WAVE accept a frequency, program the audio facility, and continue until any character is typed. %BEEP-IGNORING-MOST-ISSUES accepts frequency and duration; its name and comments explicitly warn that it omits conditions required of a production beep implementation. PLAY-AUDIO-SAMPLE-ARRAY wires and plays a bounded sample array. PLAY-DISK-FILE uses eight tuned, 40-page buffers and direct FEP disk DMA because its comments say ordinary LMFS overhead is too high for the required sample rate. POLYPHONIC-MUSE accepts one through six voices, defaults to four, and produces a random diatonic walk until keyboard input.

These require Genera audio microcode/facilities, suitable hardware emulation, and—for disk playback—a compatible FEP file. No such path is established in the Open Genera harness. They must not be described as silent pure-Lisp demonstrations.

Constraint-frame language stages

Classification: window-layout tests and tutorial source.

constraint-frame-language1, constraint-frame-language2, and constraint-frame-language3 build progressively more elaborate TV constraint frames rather than Dynamic Windows program frameworks. Stage 1 defines several configurations, including configurations explicitly named or commented as buggy, and instructs the programmer to call TEST from a small Listener. Stage 2 focuses the pane and constraint arrangement. Stage 3 calls TEST-MENU and compares menu sizing with short and long item sets. The user operates the generated menus with ordinary TV menu selection; no example-specific keybinding is defined.

These files are valuable regression fixtures for constraint calculation. Their intentionally problematic configurations must not be normalized into a claim that every layout is a supported application design.

Flavor Life

Classification: object-system tutorial.

flavor-life.lisp reimplements Life to demonstrate DEFFLAVOR, generic functions, methods, component Flavors, :AND method combination, message sending, and arrays. PLAY-LIFE-GAME accepts an optional generation count whose source default is 10. It creates/selects a Game of Life window, builds a random board, animates the requested generations, waits briefly, and buries the window. There is no command menu or in-game mouse editing. The source explicitly values clarity about Flavors over Life performance.

Gabriel benchmark suite (gabriel-benchmarks)

Classification: performance benchmark, not a visible application.

The Common Lisp translation identifies itself as the Richard Gabriel suite used to produce Symbolics benchmark values. RUN-SERIES writes implementation information and results to a stream; RUN-SERIES-TO-FILE targets the FEP file system to avoid network disruption while scheduling is inhibited. The file includes the classic Tak/Stak/Ctak/Takl/Takr, Boyer, Browse, destructive-list, Traverse, Deriv/DDeriv, Div2, FFT, Puzzle, Triang, file/terminal I/O, and polynomial families. Its suite runner excludes the I/O benchmarks from the normal series.

Unlike the collection-wide rights assumptions one might otherwise infer, this exact benchmark source explicitly identifies itself as public domain. That statement is specific to this file and does not propagate to neighboring examples.

Performance results would be properties of the exact VLM, world, scheduler, host, and timing path. The presence of the source is not a benchmark result, and this museum has not published one.

Hardcopy font catalog (hardcopy-stream-example)

Classification: printer-output tutorial.

FONT-CATALOG-PAGE accepts a font and optional printer, creates a hardcopy stream, and prints catalog pages that alternate characters 32 through 126 between FIX9 and the chosen font, with boxes and headings. Its observable result is printer output, not a screen font sheet. Running it can queue or produce physical output, so a future test needs a disposable file-backed or otherwise non-destructive printer target. See hardcopy, press, printing, and plot output.

Incremental-redisplay tests

Classification: interactive redisplay tests.

REDISPLAY-TEST-1 performs three redisplays, pausing for one character before each mutation, and returns the redisplayer. REDISPLAY-TEST-2 and 2A share a helper that performs four redisplays separated by characters; they contrast ordinary redisplayable output with independently redisplayable formatting. The tests mutate global symbols and the global list *L*. Their controls are simply “type one character to advance,” not a command table.

File-server initialization example

Classification: operational/site template; unsafe to run unchanged.

file-server-init-file.text is a historical initialization sample, not an inert tutorial page. It configures and secures file, print, and download services; tunes virtual-memory and buffer state; establishes automatic bug reporting; and contains site-specific assumptions and names. Evaluating a translated copy can start services, alter access policy, and persist machine state. Its value is as an example of site operations, and any live study requires a line-by-line side-effect review in an isolated disposable world.

Server Finger

Classification: substantial network/service sample.

server-finger.lisp scans configured namespaces and Lisp Machines, caches user, idle, location, and last-seen information, can maintain a local disk copy, schedules background refreshes, augments the name-server path, and defines a :SITE-NAMES byte-stream server. Its user query paths include individual names and Busy, Idle, and All-style summaries. The default background refresh interval in the source is ten minutes, while a later initialization path starts with fifteen minutes.

This file changes global network service behavior and can start processes and write its database. It is not the same as the smaller Statice finger-hack example below, and it must never be loaded merely to see what it does on a museum network.

Teach Zmacs

Classification: interactive editor tutorial plus global keymap extension.

The global Teach Zmacs command copies the master tutorial to teach-zmacs-copy.text in the user's home directory and opens the copy in Zmacs. If a matching copy is already being edited, it asks whether to continue. Loading the source also installs Triangle as “next section” and Square as “previous section” in the global Zmacs command table. Those macros search for section separators and recenter the buffer.

The load-time global key mutation and user-file copy are real side effects. The collection stores the implementation, short information text, and master lesson as teach-zmacs.lisp, teach-zmacs-info.text, and teach-zmacs-master.text. The tutorial text is licensed documentation and remains untracked; its recovery evidence is discussed in Genera on-line documentation recovery.

cryptarithmetic

Classification: interactive constraint-solving application example.

The Cryptarithmetic Solver frame has panes for letter possibilities, the current problem and solver status, guesses, search statistics, suggested problems, commands, and a four-line interactor. Its application commands are:

Suggested problems are presentations with four intended gestures: left uses clues and search, middle ignores clues and searches, Shift-left uses clues without search, and Shift-middle uses neither clues nor search. Left-selecting an ordinary displayed problem solves it without clues and with search.

Source-only discrepancy: Solve Problem explicitly ignores its do-search argument and passes literal true to the solver. The two “without search” gesture variants therefore build different commands but appear to execute the same search path. This is a high-confidence source finding and an explicit runtime TODO. The letter-possibilities pane also repeats its redisplay-function option with two different values; its effective macro-expanded behavior should be observed rather than inferred from keyword order.

DIAL-DEMO

Classification: minimal Joshua object/attached-action tutorial.

Select Circle opens a semicircular 0-to-100 dial above a fifteen-line Listener. The frame defines no application commands. The programmer enters ordinary Joshua forms in the Listener to assert or retract the speed slot of one object. An attached action erases the old pointer and draws the new one as the predication's truth value changes.

Numeric values outside 0 through 100 are clamped only for drawing; the source does not claim that the stored Joshua value is rewritten. This example demonstrates the connection between logical object state and incremental display behavior, not a general instrument-control application.

ht-demo

Classification: interactive expert-system application example.

The Hardware Troubleshooter presents the standard five-component “polybox” circuit: two adders, three multipliers, five input ports, and two output ports. Its panes show the circuit, solver status, observation/simulation conflicts, reasoning, commands, title, and interactor.

Presentation gestures provide a second control surface: middle explains; left sets a port or the default set; Shift-left resets values; Shift-middle resets simulation or diagnosis according to the presentation type; and Control-Shift-left simulates or diagnoses according to the selected object. Same-gesture pairs are dispatched by typed presentation testers, not two unconditional commands.

The separate ht-example-modelled file implements the polybox with Joshua object types, LTMS dependencies, and user-level ATMS-style candidate calculation. The frame source itself says it needs a switch for the modelled version; no such visible switch is defined. This dossier therefore does not claim that ht-demo can toggle between the two implementations.

modelling-tutor

Classification: interactive, stepwise Joshua programming tutorial.

The Modelling Tutor frame shows six coordinated technical views: Joshua's database contents, the example's backing model, an evaluated Lisp session, a forward-trigger view, and backward variable- and constant-trigger views. A title, command menu, and four-line interactor complete the layout.

Each lesson step prints original commentary, optionally prints and evaluates one form, redisplays the relevant panes, visually grays panes that are temporarily irrelevant, and waits for one raw character before advancing. The source records a UI bug: the blinking cursor remains in the interactor rather than the Lisp-display pane that accepts the character. The tutorials also deliberately undefine rules and clear the database as they proceed, so their state is not a passive slideshow.

blocks-demo

Classification: interactive planning application example.

The Blocks World frame shows a graphical block world and robot hand, reasoning goals, the generated robot program, commands, title, and interactor. It uses a domain-independent planner that first attempts linear refinement and can fall back to STRIPS-style replanning.

Left-clicking a displayed block starts a partially filled Put Block command; middle-clicking starts Clear Block. Both leave remaining arguments editable. The demo counts bounded stack-overflow recoveries, reports planning failures, and shows the actual goal and program rather than merely teleporting blocks.

jericho-demo-suite

Classification: umbrella application, test runner, and demo chooser.

Select J or the global Demonstrate Joshua command opens Jericho. Its title is itself a presentation action that opens a chooser. Choose Demo selects one of seven configurations:

1. Introduction;
2. Factory Simulation;
3. Modelling Tutor;
4. N Queens Solver;
5. Hardware Trouble Shooter;
6. Blocks World Planner; or
7. Cryptarithmetic Solver.

The six application configurations embed the corresponding program frame and run its own command top level; the introduction has a picture, title, and interactor. Three local developer commands—Eval Form, Refresh Screen, and Clear History—are normally secret rather than advertised demo controls. Eval Form accepts a confirmed Lisp form and evaluates it, so it is a debugging escape hatch, not a safe public feature. Its implementation evaluates the confirmed form and then tries to print the result to a pane named demo-interactor; the Jericho framework instead defines interactor, and no active demo-interactor definition appears in the inspected catalog. Evaluation may therefore occur before result display or command completion fails. Reaching this command at run time and establishing its exact failure behavior remain TODOs.

Two additional global controls exercise the registered test layer: Test Joshua selects tests or All, clears between them, and reports pass/fail totals; Benchmark Joshua selects benchmarks or All, defaults to three iterations, and reports timing plus rule, merge, and matcher activity. DIAL-DEMO is not one of the seven chooser configurations.

n-queens

Classification: interactive LTMS constraint/search application example.

The N Queens frame has a chessboard, statistics, a scrolling solution list, commands, title, and interactor. The board defaults to five by five.

The solver uses Joshua's TMS as search control without application rules, records solutions and contradictions, and prints standard chess coordinates only for an eight-by-eight board. It loads a CHESS15 font for queen glyphs. The board cells are not defined as application command gestures; board size and solve policy are entered through commands.

n-queens-backward and n-queens-mixed are separate source lessons, not this frame. The former is a Prolog-style backward-rule permutation search and warns about stack growth; the latter combines Lisp with forward and backward rules.

widgetsim

Classification: interactive rule/object simulation application example.

The Factory Simulator displays a production model, produced output, a three-by-three production-time matrix, a two-column command menu, title, and four-line Listener. Initialization creates three buffers, three factories, and three widget types. The simulation limit defaults to 20 time steps; new input widgets are random.

The Modify gesture on a displayed production-matrix entry invokes Set Production Matrix Entry. The source identifies a race in the output rule when two items finish simultaneously. Runtime work should therefore check both the visible matrix editing and this simultaneous-completion case rather than presenting the simulator as a validated manufacturing model.

Other Joshua example modules

The rest of joshua/examples/ supplies substrate, callable examples, tests, and alternative algorithms. They are accounted for here so the seven Jericho choices do not erase the rest of the collection.

books

Classification: interactive persistent-database application example.

Select Page opens Books, a simple bookkeeping frame backed by a Statice schema with accounts, entries, and budget items. Its display switches among account activity, budget, summary, or No current account; a command menu and four-line interactor complete the frame. It inherits full colon commands, standard arguments, and standard scrolling, but installs no fixed key accelerators. The source says the programmer must first create a database and account entities.

Selecting a displayed entry invokes a direct Modify Entry action. An Accepting Values window edits date, description, optional budget item, amount, balance, and remarks inside a transaction, then redisplays.

This is intentionally concrete rather than generic. The source hardcodes a historical database portal, treats a checking account specially, assumes a recurring 185.00 amount for payment calculations, names a special Checkbook account in summaries, and supplies a site-style default backup pathname. Empty accounts can also reach code that expects a last entry. Show Summary tells the user to specify a range when none is set but then continues into comparisons that use the missing dates; the top level catches serious errors and retries only a bounded number of times. A faithful demonstration therefore needs a researcher-created schema/data fixture and should preserve these historical assumptions as findings, not silently repair them.

The hardcopy and dump commands produce external artifacts. They must be directed to disposable targets, and the backing DBFS database must be a rights-clear test store, not a purchased or historical database.

Other Statice example files

The fresh world had no Statice, DBFS, or related packages or loaded systems. The exact Browser, server, backup, and schema boundaries are documented in the Statice dossier.

Registered major demos

Registered test and static-display demos

Counting both category registrations, the tables account for all 47 literal DEF-COLOR-DEMO forms: 3 in aos-hacks, 1 in curve, 2 in fog, 15 in hacks, 1 in spheres-demo, 24 in test-patterns, and 1 in testpat. mirror supplies the wandering-window implementation and fog-figures supplies many encoded figure paths, but neither adds a selector entry.

The fresh runtime had a 24-bit X screen but no registered Genera Color screen; the Color Editor entry point was absent, and a disconnected system load failed. This is why there is no claim that 24-bit X depth alone makes these indexed-map and overlay demos work. See the Color systems dossier for the exact screen/map models and runtime record.

Top-level and nested example applications

Aggregate exports example surface

examples/exports.lisp is executable configuration, not a passive list. Loading it constructs accounts and realms, exports source and document trees, installs computed handlers, and conditionally initializes other systems. It does not unconditionally perform the final service-enable call, but it prepares a large historically unsafe surface.

The complete endpoint/file-level evidence and security analysis lives in CL-HTTP and contributed Web systems. A fresh isolated probe found all nine principal systems and ten packages absent. A future experiment must load only a hand-selected harmless endpoint behind a loopback-only client/server fixture; the aggregate export file is specifically excluded.