Assembler (Singer Friden System 10)

Overview

Assembler for the Singer Friden System Ten is the native machine-level language of one of the earliest computers purpose-built for retail point-of-sale data collection. The System Ten was not a general-purpose scientific or business mainframe adapted for retail; it was designed from the outset to sit behind a store’s cash registers, gather transaction data in real time, and manage inventory — and its instruction set, character format, and assembler reflect that origin.

The machine was a decimal, character-oriented computer rather than a binary word machine. It stored and manipulated data as 6-bit BCD (binary-coded decimal) characters and performed arithmetic directly in decimal, which suited the punched-tape and accounting-machine heritage of its manufacturer far more naturally than it suited scientific computation. Programmers wrote directly against this character-and-decimal model in assembler, since System Ten had no general-purpose high-level language of its own in its early years.

History & Origins

Singer Corporation — the sewing-machine company — needed a way to track stock and sales across its national network of retail stores in real time. Under CEO Donald P. Kircher, Singer invited several established computer manufacturers to bid on building a machine that could connect to multiple store tills and serve as a central point for collecting that data. IBM and NCR both declined the project.

Singer instead acquired Friden, Inc. in 1965. Friden was a well-regarded maker of desktop calculators and paper-tape-driven accounting machines based in San Leandro, California, and its engineering team, reorganized as Singer Business Machines, built the computer Singer wanted. The project was internally named the Business Data Processor before being renamed System Ten ahead of launch.

System Ten launched across Europe on 2 April 1970, with customer deliveries beginning that September. Adoption was fast for a specialized business machine: by October 1971 Singer reported more than 150 installations complete, with roughly 600 further orders on the books.

Design Philosophy

System Ten’s defining architectural idea was logical partitioning — an early precursor to what would later be called multiprogramming or virtual machines. Rather than running one program at a time under a scheduling operating system, the machine divided its memory into up to 20 independent partitions, each with its own dedicated memory (up to 10 kilobytes per partition in early configurations) and access to a shared common area. Each partition could drive up to ten I/O devices — tills, tape units, printers — depending on the partition’s assigned role. There was no scheduling OS in the conventional sense; the partition structure itself was the concurrency model, and assembler programs were written and assembled to run inside a given partition.

Two CPU implementations existed: the original Model 20, with a spare instruction set of just 13 instructions, and the later Model 21, which extended this to 16 instructions. A programmer writing System Ten assembler was working close to the metal of a machine whose “words” were decimal digits encoded as 6-bit characters, not binary integers — closer in spirit to a programmable calculator or accounting machine than to a contemporary scientific minicomputer.

Key Features

• Decimal, character-native operation. Data was represented and manipulated as 6-bit BCD characters throughout, with arithmetic performed in decimal rather than binary — a natural fit for financial and inventory figures, and consistent with Friden’s calculator heritage.
• A macro assembler with an unusually capable macro facility. The assembler’s macro language was reportedly built on an underlying string-matching and parsing facility rather than simple textual substitution — closer to a small language-processing engine than a typical assembler macro preprocessor of the era, though the specific engineering details are not well documented in surviving public sources.
• Partition-based concurrency. Up to 20 independently addressed memory partitions, each running its own assembler program and each capable of driving its own set of peripherals, stood in for a conventional multiprogramming operating system.
• A table-processing facility. Alongside raw assembler, System Ten offered a “table processor” approach aimed at making common data-handling tasks easier to write without dropping to instruction-level code.
• A later RPG/RPG II compiler. As a second-generation assembler was introduced, Singer added an RPG/RPG II compiler, giving System Ten sites a report-generation option more familiar to programmers coming from IBM-style business computing.

Evolution

System Ten’s software evolved in step with its hardware. The original Model 20 processor and its 13-instruction set were joined by the Model 21, with 16 instructions, and — per the service manual covering both models — the two continued to be documented and supported together at least through January 1975. On the software side, an initial, relatively spare assembler-and-macro environment was followed by a second-generation assembler that brought RPG/RPG II support to the platform, broadening it beyond hand-written assembler and the table processor for everyday business report work.

Singer exited the computer business in 1976, selling Singer Business Machines to International Computers Limited (ICL), a major British computer manufacturer. At the time of the sale, ICL estimated roughly 8,000 System Ten units were in active use worldwide — a substantial installed base for what had begun as an internal retail tool. ICL continued to support and sell the line as the ICL System Ten, then carried the architecture forward into the ICL System 25. The final iteration of that lineage, in 1988, added a Motorola 68020 processor capable of running Unix, closing out roughly two decades of continuous development from the original Friden-derived design.

Current Relevance

System Ten assembler has no practical use today; the hardware it targeted has been out of production for decades, and no emulator for the platform is publicly known to exist. It survives almost entirely as a subject of retrocomputing and business-computing history interest — the Australian Computer Museum Society and the UK’s Computer Conservation Society (via the BCS) have both hosted discussions and preservation efforts around the machine, and original service manuals and reference documentation for the Models 20 and 21 processors have been scanned and archived by volunteers at sites such as Bitsavers.

Why It Matters

System Ten is a useful reminder that not every influential early computer looked like a scientific mainframe or a hobbyist microcomputer. It was purpose-built around a business problem — real-time retail data collection across many store locations — and its architecture (decimal character data, logical partitioning in place of an operating system, a store-till-oriented I/O model) followed directly from that problem rather than from academic computer-science trends of the era. Its commercial success, an installed base large enough that ICL judged the acquisition worthwhile in 1976 and continued the architecture for another twelve years afterward, shows that a decimal, character-oriented assembler machine designed narrowly for retail and business data processing could have a long and profitable life outside the binary, general-purpose mainstream of computing history.