THE CORE MEMORY FORUM
December 11, 2017, 05:13:57 pm *
Welcome, Guest. Please login or register.

Login with username, password and session length
News:
 
   Home   Help Search Login Register  
Pages: [1]   Go Down
  Print  
Author Topic: NCR Proprietary Programming Languages  (Read 43833 times)
Aleksandrs Guba
Administrator
Jr. Member
*****
Posts: 80


« on: March 20, 2008, 06:56:57 pm »

These, in what I believe, are NCR proprietary programming languages:

- Language H - First compiler for it was produced for the National-Elliott 405 M;
- NEAT* - Autocoder for NCR 304 & NCR 315;
- BEST - a higher level pre-processor language that produced NEAT code;
- NEAT COBOL - NCR's COBOL which translated to NEAT/NEATA for the National 304;
- NCR RPG - NCR's Report Generator;
- NCR BASIC - NCR's Beginner's All-purpose Symbolic Instructions Code;
- NEAT IV - NCR Autocoder;
- NEAT V - NCR Autocoder version 5;
- NEAT/3 - Advanced version of the NCR Autocoder;
- NEAT/399 - Version of the NCR Autocoder for the NCR 399 minicomputer;
- NEAT/S - Version of the NCR Autocoder for the NCR Century 50;
- NCR IMOS COBOL - Version of American National Standard COBOL 1974 for the NCR computers with IMOS OS;
- NEAT/VE - Advanced version of NEAT, running on the NCR VRX/E OS;
- NEAT/VS - Advanced version of NEAT;
- NEAT/C - Macro level Assembler, used for VRX and VLX.

(*) NEAT stands for "National's Electronic Autocoding Technique".

Is that true?
« Last Edit: May 23, 2009, 08:58:27 am by Aleksandrs Guba » Logged
uglytuna
Newbie
*
Posts: 29


« Reply #1 on: March 21, 2008, 04:47:22 am »

NEAT was the assembler language for the NCR 315.

Herb
Logged
Aleksandrs Guba
Administrator
Jr. Member
*****
Posts: 80


« Reply #2 on: March 23, 2008, 08:33:41 pm »

LANGUAGE H

"Produced by National-Elliott, it was commendable because operated in a region where COBOL was weak, i.e. on a small machine. Little effort is being made to provide such languages for small machines and yet the small user needs them every bit as much as the large.

The first compiler for Language H was produced in August 1961 for the National-Elliott 405 M. Its revision, expected to be ready by May 1962, would contain 23,000 1-address instructions. Operational procedures are reduced to a minimum, the instructions being as fully boot-strapped as possible. Comprehensive checking is done on the first run through with the Compiler, after which the object program is printed out together with a list of errors and a "map" of the immediate access store, invaluable in debugging. It was pointed out that this number of instructions would be the equivalent of 11,000 3-address instructions in the FACT compiler, i.e. it was about 1/20 of the size of FACT, but for this it would do 1/18 as much work. Another interesting comparison was made of the expansion ratio between the number of instructions in the source language and the resulting number of instructions in the object language: Language H has an expansion ratio of 4, FACT one of 35".


The Computer Bulletin. September, 1962.


Aleksandrs
« Last Edit: March 23, 2008, 09:45:11 pm by Aleksandrs Guba » Logged
Aleksandrs Guba
Administrator
Jr. Member
*****
Posts: 80


« Reply #3 on: March 23, 2008, 08:46:11 pm »



NCR NEAT

"NCR language similar to Autocoder, used extensively in banking systems, approaching near 4gl status by the mid-1970s.

PROGRAMMING AND NUMERICAL SYSTEM

    Internal number system        Binary Coded Decimal
    Alphanum char/word            10
    Alphanum char/word            5 - 60

    Words/instruction                1/2 - 6
    Instructions decoded           83 one address
                                           37 three address w/variations
    Arithmetic system             Floating point
     MICROFLOW provides exponents in range of -50 to + 49 and automatic normalizing of result
                                         Fixed point
     Automatic alignment takes place
    Instruction typeOne address (MICROFLOW)
     (Scientific-type)
                                         Three address (Multi-address)
     (Business-type)
    Number range- (1 - 10-10) to + (1 - 10-10)
   
Instruction word format

The command structure of the 304 system is unique in a number of aspects. The instructions are basically 3 address plus a number of other functions or capabilities that are built into the execution of the instruction. The basic instruction word format for arithmetical operations such as add, subtract, etc., is illustrated:

      9      8     7     6     5     4     3     2     1     0
    +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
    |  Op |         A       |        B        |        C        |
    +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
    +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
    |  V  |  M  |  S  |  R  | A1  |  Ar |  Bl |  Br |  Cl |  Cr |
    +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
     
    Op    = Operation Code
     A     = Address of Operand
     B     = Address of Operand
     C     = Putaway or Jump Address
     V     = Variation.& Self-Linking designator
     M     = Auto-monitor level
     S     = Combinations of A, B, or C to be relative to Index Register
     R      = Index Register
     A1, Ar = left and right field of A Address
     B1, Br = left and right field of B Address
     C1, Cr = left and right field of C Address

The programmer in translating procedures for the 304 System will use the NEAT (National"s Electronic Autocoding Technique) format. The programmer might write the following to add the Old Quantity on Hand to the Number Received to arrive at the New Quantity on Hand:

     ADD (V) (R) OQOH QREC NQOH

The NEAT assembly process will translate the NEAT format into the necessary absolute machine language. It could be considered that all instructions in the basic 304 Command List are automatic built-in subroutines. There are a number of operation codes that were designed specifically for business data processing such as Edit, Merge, Move, Sift (or table look-up), and Summarize that are powerful instructions and in some cases are self-incrementing.

As an example, the Merge instruction will serve to illustrate the nature of these business-type operations. Specified in NEAT format would be the following mnemonic designators and parameters:

Designate first word, first item, each string Number of items in each string Relative position of Major Key (if any), within item Relative position of Minor Key within item Number of keys (1 or 2) for the Merge Length of each item Specify three exits (Cutoff Merge only) NEAT (National’s Electronic Autocoding Technique) was in operation before the first deliveries of the National 304 System. This system enables systematic organization in the approach to a problem, an assembly compiler and a complete library of generators, service programs, and subroutines. COBOL or COBOL-like language will become part of the system in a reasonable time.

Each instruction may be relative to one of 10 Relative Index Registers. The particular Index Register and the portions of the instruction which are to be relative are specified within the instruction."


Weik, Martin H. "A Third Survey of Domestic Electronic Digital Computing Systems" Rpt 1115, BRL, Maryland, 1961.


Aleksandrs
Logged
Rod Clark
Newbie
*
Posts: 1


« Reply #4 on: April 27, 2008, 03:07:59 pm »

Another NCR programming language was BEST. I used this language in the 70s plus NEAT/2 & NEAT/3. It was a higher level pre-processor language that produced NEAT code. It comprised of English like function sheets containing questions & "fill in the boxes" answer boxes. Examples of the "functions" were master file update, collate & own code (ie. you wrote your own NEAT code). I have been googling for any reference to the BEST language & stumbled across your web site. Great site. I'll be back!
Logged
uglytuna
Newbie
*
Posts: 29


« Reply #5 on: April 28, 2008, 08:32:31 pm »

BEST was a high level macro language.  By filling out the BEST forms you could knock together a “standard” program very fast.  Standard programs basically followed the Input, Process, Report, and  Output batch programming methodology of the day.  And, since it created Neat/3 source and object, it was relatively easy to patch for quick testing.
Logged
uglytuna
Newbie
*
Posts: 29


« Reply #6 on: April 28, 2008, 09:28:39 pm »

Back in the mid-seventies, an NCR Systems Analyst named Leonard LaFrance wrote a White Paper on a conceptual high-level language he called “PASS/3.”  Back in those days you had to write a White Paper as one of the requirements to be promoted to a Level IV Systems Analyst.  For some reason NCR management rejected his paper.  Leonard decided that the only way that he could bring his idea to fruition would be to quit and form his own company.  So, Century Analyses was born to develop and sell PASS/3 directly to NCR customers.

I was a Level IV Analyst working in southern California with another Level IV named Herb Griffith when NCR sold a large Century system to a new customer, Buffum’s Department Stores.  I was responsible for installing our Credit Management System and Delinquent Account Collection system (CMS/DAC), and Herb was responsible for highly customized Sales Audit and Sales Analysis systems.  Herb brought in Leonard, who had recently left NCR, and the two of them wrote a large part of the Sales systems using PASS/3.  The language was easy to use, very flexible, and produced very efficient and fast object code.

Buffum’s turned out to be a very successful installation for NCR, and Century Analyses grew and prospered and continued to improve and enhance PASS/3.  Over the years both Herb and I went on to use it to develop systems for several other customers.

Logged
uglytuna
Newbie
*
Posts: 29


« Reply #7 on: April 28, 2008, 09:46:59 pm »

When NCR released NEAT/3 with the Century 100, several macro languages were made available.  I think they were called Paper Tape Regiment, Card Regiment, and Reporter.  There also may have been others and I may have the names wrong, but I believe that they were the first attempts at a macro language by NCR.  As I recall they were difficult to use, produced inefficient code, and the first few versions were quite buggy.  But they did help sell Century’s to new customers who were somewhat leery of using a new proprietary assembly language
Logged
Neat3Century
Newbie
*
Posts: 2


« Reply #8 on: May 10, 2008, 01:03:30 am »

I operated a NCR century computer in the early 1970s and we had to learn Neat/3 as our language. I recently found some old instruction sheets that list the console as NCR CENTURY 50. I thought the computer we used was a 300 series, but maybe it still used an older console. We input our programs and any run instructions on punch cards. We used 2 5 stack disk packs and input with magnet tapes.
Logged
jimw501x
Newbie
*
Posts: 1


« Reply #9 on: May 21, 2009, 04:08:08 pm »

At the NCR Rancho Bernardo plant the language used for VRX and VLX was an assembler known as NEAT/C. It was a macro level assembler
that was used to code the VRX and VLX OS's.
« Last Edit: August 02, 2009, 06:12:01 pm by jimw501x » Logged
wally
Newbie
*
Posts: 43


« Reply #10 on: August 02, 2009, 02:27:36 pm »

Does anyone know, wether there are connections between the development of NCR IMOS Cobol and RM-COBOL of Ryan McFarland.  I have something far back in my mind, but I'm not sure. In the 70ies and 80ies I used NCR IMOS Cobol under NCR IMOS III on the NCR 8200 series. And later I used RM-Cobol under AT&T Unix IV O/S on the NCR Tower 32/650.
Wally (Walter Meyer)
« Last Edit: August 02, 2009, 02:33:13 pm by wally » Logged
uglytuna
Newbie
*
Posts: 29


« Reply #11 on: January 31, 2010, 10:51:51 pm »

NCR IMOS Cobol and RM-COBOL were similar in many ways, the most important being they were both ports of Standard Cobol-74.  As such, they would both compile any source statement that was compliant to that standard.  The caveat being of course that a Cobol-74 source file from any vendor almost always had non-standard command extensions, making any port between vendors full of "opportunities" if you get my meaning.  But basically, if you had worked with IMOS Cobol, RM-COBOL was a no brainer.  Since RM-COBOL was used on many Unix computers at the time, NCR contracted with Ryan McFarland to port it to the Tower.  Sales on the Tower took off, and the rest is history.

Even though both Cobol compilers were compliant to the standard, they also had many non-standard “extensions” that could only be called proprietary.  These statements were usually dealing with our hardware or legacy system.  However, with that said, it still would be a long stretch to list them as NCR proprietary programming languages.

Closer to “proprietary” would be our Cobol-68 language where you could “Enter Neat” and include NEAT/3 code (including level-3) and make the computer stand on its nose.  Although very effective, it was so non-standard that it made our version of Cobol-68 the laughing stock of the snooty Standards folks.  Too bad, we loved it and used it when appropriate.
Logged
wally
Newbie
*
Posts: 43


« Reply #12 on: February 01, 2010, 01:02:23 am »

Thank you for the information.
Regards Wally.
Logged
Pages: [1]   Go Up
  Print  
 
Jump to:  

Powered by SMF 1.1.4 | SMF © 2006-2007, Simple Machines LLC
Page created in 0.061 seconds with 16 queries.