This was the machine I programmed at my first paying job. I was 16 in 1970, and had a summer job at Singer/Friden, leading to continued summer/part-time employment through the rest of my high school and undergraduate college years -- working both for Singer Business Machines, and later at other companies with and for individuals I had met at Singer. In addition to the 5610, I also programmed older Singer/Friden machines (e.g., the 5015 and 5023, programmed with a wired patch panel), and the later model 5800, introduced in 1971 or 1972. From the programmer's perspective, I think the 5610 is best described as a high-end programmable calculator connected to an automatic typewriter (literally, a Friden 2205 Flexowriter, which was also sold as a stand-alone product). The 5610 processor "looked" like a calculator in that it had no generally addressable memory. Instead, it had an "accumulator" -- or maybe it was a stack of 3-5 registers -- that you did math with, plus 70 "memory registers" that could hold decimal numbers (8 digits left of decimal point, 6 to the right, as I recall). It had a separate program store, which could be loaded from paper tape. The program itself was written directly in machine language, but the 5610 machine language was similar to assembly language on other computers. Instructions consisted of a single letter "op code" and an operand. Instructions were such things as, "Load register 23 into the accumulator", "Add register 17 to accumulator, "Store accumulator to register 54", "Read number from keyboard", or "Print number (or character) on typewriter." A program consisted of a set of "sequences" of these instructions. "Sequences" were just that: a series of instructions to be executed one after another. Sequences were identified with a one-character label that was itself coded in an instruction at the beginning of the sequence, and there was a way to execute a particular sequence by selecting that letter on the Flexowriter. Program flow could be altered with unconditional or conditional "Branch" instructions which would transfer execution to the start of a new sequence. If I remember correctly, coding a sequence label in the program terminated the previous sequence; it did not automatically flow from one sequence into the next. Each instruction was one to several bytes (characters) long for the op code and operand, and the total program could be up to slightly more than 1000 bytes, total. As I recall, there was just one way to load a program, and that was to clear the current program and replace it entirely with a new one input from the Flexowriter. This was almost always done by first manually punching the program into a paper tape, then reading it in using the Flexowriter's paper tape reader. Programming tools included a "super-dup" program -- a short program you'd load into the 5610 that had some very simple editing capabilities. With this program, you could read and repunch a program tape, with some ability to make changes during the duplication process. I also recall physically cutting and splicing paper tape with a patch-kit, to make emergency bug fixes. When you were ready to deliver your program to the customer, you'd repunch it onto mylar tape, instead of paper, so that it would be more durable. I also seem to recall advising customers to keep the mylar tape in a safe place, and to make their own paper-tape copies for everyday use. There was also a program that would read a program tape, and print out the instructions one per line, looking a little more like an assembly program listing. This was rarely used, though, because it was much quicker to just print the raw program from the tape on the typewriter, and almost as easy to read that raw printout as it was to read a formatted listing. The later 5800 Computyper had a similar architecture, but had a faster, "slicker" typewriter and paper tape reader/punch, looking more like something that belonged in the 70s instead of the 40s or 50s. The main advancement in the 5800 was the inclusion of a "mag-stripe ledger card" sub-system. This was a separate I/O device besides the typewriter/paper-tape device. It had a slot into which you could insert 8.5"x11" ledger cards. These ledger cards were made of light card stock, and had a magnetic tape glued in the margin, much like the magnetic stripe on the back of credit cards today. The 5800 could read data from this magnetic stripe when a card was inserted, and then rewrite it with updates when the card was ejected. Since the mag-stripe ran down the 11" side of the card, it could hold a reasonable amount of data -- usually details for a customer account (name, address, balance due, etc.) or inventory item (part number, description, price, quantity on hand, etc.). Besides the magnetic stripe reader/writer, the mag-stripe ledger card subsystem also included a printer, so when the account was updated, a new line could be printed on the card to record the transaction in a human-readable form, as well as updating the data on the mag-stripe. This led to interesting issues, like recording on the mag-stripe how many lines had been previously printed on that card, so the program could position it correctly in the printer the next time it was inserted. As you might imagine, the complexities of keeping your computer files spread across hundreds of separate ledger cards, and trying to keep the data printed on the cards synced with the data recorded on the mag stripes was a challenge. Cards would get spoiled -- torn, or coffee spilled on them -- and need to be replaced with data reconstructed, etc. Programming the 5800 was very similar to programming the 5610 -- much like a high-end programmable calculator, again -- with one exception. There was a general "data transfer" command that let you select an input device and one or more output devices, and then initiate a block transfer of data from one to the other. This was used for all I/O, and got particularly complex when communicating to the "intelligent" mag-stripe ledger card subsystem. All in all, working with these somewhat bizarre Singer/Friden machines was an interesting introduction to computer technology for a budding software engineer, when what they were teaching us in school was Fortran, Cobol and IBM 360s. Good times, and fun memories!

I was a “systems salesman “ with Friden in the early 1960s selling Flexowriters and Computypers. The original Computypers actually had a Friden mechanical rotary calculator in the cabinet to do the calculations They were not “electronic” until about 1965.

This computyper was manufactured before 1969, because I used it in 1966 and 1967 for invoicing at Philco Ford in North Wales, PA. It was placed at the back of our office because of the noise level, but I liked using it. I was 21 years old at the time and this was the first piece of automated office equipment I’d used. The photo brings back fond memories. Thank you.

I was trained to repair this machine in the International Training school Berg an Dal Nijmegan, Holland. The course was about a month long. There was an exam at the end of each weeks training and if you didn't pass you had a problem! I think the tutor was Jan Ke Boom or similar. I have class photos taken at the time. I found it very difficult to repair primarily because of the delay-line memory. all data was moving all of the time!

I loved this machine. I used it in the 1970 for billing and credits., we just put a minus sign in front of the totals to send our credits out. It was noisy but I loved it.

I love this machine, I love programming language SWITH, like mini Assembler, with priferal units, readers and punch tapes. We received this machine with all perriferals and documentations at Labs - Catedra de Informatica a ASE, Bucharest, For teaching students. I created many Informatic systems, like retribution , analysa statistica a quality industrial production etch.

I purchased a Friden 5610 Computyper surplus from Mountain Home Air Base in 1976. The 5610 was a 650 lb. desk with a electric typewriter and was not functioning, I found an open diode in the circuit and forced it into an error loop and was able to have it print out from this error loop. My interest sparked by this amazing machine, I found a service tech. in Boise, Idaho and found out that there was only one 5610 in the state of Idaho. He agreed to sell me the tech manual if I would purchase all his supplies. While studying the manual I discovered the unit had 44 commands, 70 storage registers and math co-processor with 5 registers. I proceeded to write my first accounts receivable program in machine code then using function keys to activate each routine and stored it to paper tape so I could run the program by loading it from the stored paper tape. A good predecessor to the computers in 1978.

"I am currently working with a student at the University of Iowa on restoring a Singer/Friden model 2201 Flexowriter that is visually similar to the 2205 Flexowriter that is part of this object. It was used by a bank in Coralville Iowa to type dunning form letters to people who owed money in the late 1960s and into the 1970s., when it was replaced by a computer. I am putting up a web site with photos of the innards, connections to the relevant patents and other documentation. See: http://www.cs.uiowa.edu/~jones/flexo/ for the current state of this effort."

I operated a flexowriter computyper way back in 1970-1973 at Merchant & Evans, a firedoor manufacturer in south Philadelphia. I remember it had two different maybe 6 X 8 inch blocks, I forget what they were called, but one was for accounts receivable and the other for accounts payable. But I remember when it would break down, I had to call IBM to send someone out to fix it. So, it was interesting reading up on my old machine. They also had a bookkeeping machine that was gigantic and when it was on and running, every time it would hit the tab stops the whole office shook. Lol!

Used at foreign trade companies Czechoslovakia 1969-1976. Interesting wired memory 4kB-16kB. All programme created in machine code language. Very favourite reliable product. I have serviced these machines that time.

"I am a former Singer/Friden Technician who was factory trained on the 5610. You couldn't purchase a 5610 without a Flexowriter as it was it's primary I/O and print station. Input was from keyboard or paper tape reader. Output was to the print station or paper tape punch. Auxillary / peripheral units were available. These include a high speed paper tape reader, paper tape punch, IBM Card Reader, and an interface unit for an IBM 026 Card Punch. Memory for the 5610 was an acoustical delay line. It was approximately 50' of piano wire spooled on nylon spacers.It provided 1100 characters of storage. (7 ascii bits to a character) A bit was a 4 nanosecond twist placed upon the wire that "rang " around the spool and had to be regenerated when it reached the end. Data reads were destructive. When you took a character off the delay line a "marker " character was put in it's place, When the delay line "wrapped " to the marker the character was put back in place of the marker.The 5610 was primarily used in accounting , billing, and inventory applications I also had themon Kennedy Space Center, Patrick A.F.B., and Postal Sort Stations A typical installation cost about $24000. in 1969. The Flexowriter could be purchased as a separate stand-alone type station for about $2200."

"I love this computer machine. I did programming in SWIFT, retribution, accounting, and teach students about this operating, programming andpaper tape used at ASE Bucharest"