Misplaced Pages

#270729

78-512: In the 1970s, the Burroughs Corporation was organized into three divisions with very different product line architectures for high-end, mid-range, and entry-level business computer systems. Each division's product line grew from a different concept for how to optimize a computer's instruction set for particular programming languages. "Burroughs Large Systems" referred to all of these large-system product lines together, in contrast to

156-673: A middleware program and is written in DCALGOL (Data Communications ALGOL). As stated above, the MCS received messages from queues maintained by the Datacom Control Stack (DCC) and forwarded these messages to the appropriate application/function for processing. One of the original MCS's was CANDE (Command AND Edit) which was developed as the online program development environment. The University of Otago in New Zealand developed

234-516: A California-based private investment firm, which incorporated it as Burroughs Payment Systems, Inc. (later just Burroughs, Inc. ), based in Plymouth, Michigan . Burroughs B205 hardware has appeared as props in many Hollywood television and film productions from the late 1950s. For example, a B205 console was often shown in the television series Batman as the Bat Computer ; also as

312-453: A block is specifically marked to allow those instructions. Such marking of blocks provide a multi-level protection mechanism. NEWP programs that contain unsafe constructs are initially non-executable. The security administrator of a system is able to "bless" such programs and make them executable, but normal users are not able to do this. (Even "privileged users", who normally have essentially root privilege, may be unable to do this depending on

390-672: A complete line of products for its customers, including Burroughs-designed printers, disk drives , tape drives , computer printing paper and typewriter ribbons . The Burroughs Corporation developed three highly innovative architectures , based on the design philosophy of " language-directed design ". Their machine instruction sets favored one or many high level programming languages , such as ALGOL , COBOL or FORTRAN . All three architectures were considered mainframe class machines: Many computer scientists consider these series of computers to be technologically groundbreaking. Stack oriented processors, with 48 bit word length where each word

468-697: A completed system. The central concept of virtual memory appeared in the designs of the Ferranti Atlas and the Rice Institute Computer , and the central concepts of descriptors and tagged architecture appeared in the design of the Rice Institute Computer in the late 1950s. However, even if those designs had a direct influence on Burroughs, the architectures of the B5000, B6500 and B8500 were very different from those of

546-424: A concern, most of the preprocessing constructs were made available in the user level of ALGOL. Only the unsafe constructs and the direct processing of the database description file remain restricted to DMALGOL. In many early systems and languages, programmers were often told not to make their routines too small. Procedure calls and returns were expensive, because a number of operations had to be performed to maintain

624-429: A great performance advantage in a server since you don't need to start up another user process and thus create a new stack each time a user attaches to the system. Thus you can efficiently service users (whether they require state or not) with MCSs. MCSs also provide the backbone of large-scale transaction processing. Around 1988 an implementation of TCP/IP was developed principally for a U.S. government customer utilizing

702-566: A much smaller machine called "the portable". Two models were released, the Class 8 (without subtraction) and the Class 9 with subtraction capability. Later models continued to be released with the P600 and top-of-the-range P612 offered some limited programmability based upon the position of the movable carriage. The range was further extended by the inclusion of the Series J ten-key machines which provided

780-411: A newer, mostly untried language was adopted, ALGOL-60 . The ALGOL dialect chosen for the B5000 was Elliott ALGOL , first designed and implemented by C. A. R. Hoare on an Elliott 503 . This was a practical extension of ALGOL with I/O instructions (which ALGOL had ignored) and powerful string processing instructions. Hoare's famous Turing Award lecture was on this subject. Thus the B5000 was based on

858-560: A preprocessor. The EVENT data type facilitates coordination between processes, and ON FAULT blocks enable handling program faults. The user level of ALGOL does not include many of the insecure constructs needed by the operating system and other system software. Two levels of language extensions provide the additional constructs: ESPOL and NEWP for writing the MCP and closely related software, and DCALGOL and DMALGOL to provide more specific extensions for specific kinds of system software. Originally,

SECTION 10

#1732787070271

936-412: A process (task or thread) and tasks can become blocked waiting on resource requests (which includes waiting for a processor to run on if the task has been interrupted because of preemptive multitasking). User programs cannot issue an IP1, IP2 or MVST, and there is only one place in the operating system where this is done. So a process switch proceeds something like this – a process requests a resource that

1014-616: A processing perspective no changes were required to the MCS software to handle different types of gateway hardware, be it any of the 5 styles of DCP or the ICP or ICP/CP2000 combinations. Apart from being a message delivery service, an MCS is an intermediate level of security between operating system code (in NEWP) and user programs (in ALGOL, or other application languages including COBOL, FORTRAN, and, in later days, JAVA). An MCS may be considered to be

1092-428: A program, not the dynamic call nesting. The visibility rules of ALGOL, a language designed for single pass compilers, mean that only variables declared before the current position are visible at that part of the code, thus the requirement for forward declarations. All variables declared in enclosing blocks are visible. Another case is that variables of the same name may be declared in inner blocks and these effectively hide

1170-465: A single finger calculation facility, and the Class 5 (later called Series C) key-driven calculators in both manual and electrical assisted comptometers . In the late 1960s, the Burroughs sponsored "nixi-tube" provided an electronic display calculator. Burroughs developed a range of adding machines with different capabilities, gradually increasing in their capabilities. A revolutionary adding machine

1248-619: A skinny program development environment equivalent to CANDE which they called SCREAM/6700 in the same time that IBM was offering a remote time-sharing/program development service known as CALL/360 which ran on IBM 360 series systems. Another MCS named COMS was introduced around 1984 and developed as a high performance transaction processing control system. There were predecessor transaction processing environments which included GEMCOS (GEneralized Message COntrol System), and an Australian Burroughs subsidiary developed MCS called TPMCS (Transaction Processing MCS). The transaction processing MCS's supported

1326-698: A time, the combined company retained the Burroughs processors as the A- and V-systems lines. As the market for large systems shifted from proprietary architectures to common servers, the company eventually dropped the V-Series line, although customers continued to use V-series systems as of 2010 . As of 2017 Unisys continues to develop and market the A-Series, now known as ClearPath. In 2010, Unisys sold off its Payment Systems Division to Marlin Equity Partners ,

1404-445: A very powerful language. Donald Knuth had previously implemented ALGOL 58 on an earlier Burroughs machine during the three months of his summer break, and he was peripherally involved in the B5000 design as a consultant. Many wrote ALGOL off, mistakenly believing that high-level languages could not have the same power as assembler, and thus not realizing ALGOL's potential as a systems programming language. The Burroughs ALGOL compiler

1482-471: Is a preemptive context switch. The operating system determines the first process in the ready queue and invokes the instruction move_stack, which makes the process at the head of the ready queue active. Stack performance was considered to be slow compared to register-based architectures, for example, such an architecture had been considered and rejected for the System/360 . One way to increase system speed

1560-437: Is called BDMSALGOL and included verbs like "FIND", "LOCK", "STORE", "GET", and "PUT" for database access and record manipulation. Additionally, the verbs "BEGINTRANSACTION" and "ENDTRANSACTION" were also implemented to solve the deadlock situation when multiple processes accessed and updated the same structures. Roy Guck of Burroughs was one of the main developers of DMSII . In later years, with compiler code size being less of

1638-406: Is not immediately available, maybe a read of a record of a file from a block which is not currently in memory, or the system timer has triggered an interrupt. The operating system code is entered and run on top of the user stack. It turns off user process timers. The current process is placed in the appropriate queue for the resource being requested, or the ready queue waiting for the processor if this

SECTION 20

#1732787070271

1716-401: Is on a single chip. It was a valid point in the 1970s when more complex architectures such as the B5000 required too many transistors to fit on a single chip. However, this is not the case today and every B5000 successor machine now fits on a single chip as well as the performance support techniques such as caches and instruction pipelines. In fact, the A Series line of B5000 successors included

1794-470: Is that circa 1976, John McClintock of Burroughs (the software engineer developing NEWP) named the language "NEWP" after being asked, yet again, "does it have a name yet": answering "nyoooop", he adopted that as a name. NEWP, too, was a subset ALGOL extension, but it was more secure than ESPOL, and dropped some little-used complexities of ALGOL. In fact, all unsafe constructs are rejected by the NEWP compiler unless

1872-472: Is the latest technique, and programmers do not have to adjust their code for it to run faster – they do not even need to recompile, thus protecting software investment. Some programs have been known to run for years over many processor upgrades. Such speed up is limited on register-based machines. Another point for speed as promoted by the RISC designers was that processor speed is considerably faster if everything

1950-429: Is to keep data as close to the processor as possible. In the B5000 stack, this was done by assigning the top two positions of the stack to two registers A and B. Most operations are performed on those two top of stack positions. On faster machines past the B5000, more of the stack may be kept in registers or cache near the processor. Thus the designers of the current successors to the B5000 systems can optimize in whatever

2028-483: Is used to provide tailored access routines for DMSII databases. After a database is defined using the Data Access and Structure Definition Language (DASDL), the schema is translated by the preprocessor into tailored DMALGOL access routines and then compiled. This means that, unlike in other DBMS implementations, there is often no need for database-specific if/then/else code at run-time. In the 1970s, this "tailoring"

2106-480: The COBOL -optimized Medium Systems (B2000, B3000, and B4000) or the flexible-architecture Small Systems (B1000). Founded in the 1880s, Burroughs was the oldest continuously operating company in computing ( Elliott Brothers was founded before Burroughs, but did not make computing devices in the 19th century). By the late 1950s its computing equipment was still limited to electromechanical accounting machines such as

2184-686: The Datatron 205 and was working on the Datatron 220. The first major computer product that came from this marriage was the B205 tube computer. In 1968 the L and TC series range was produced (e.g. the TC500 —Terminal Computer 500) which had a golf ball printer and in the beginning a 1K (64 bit) disk memory . These were popular as branch terminals to the B5500/6500/6700 systems , and sold well in

2262-467: The Sensimatic . It had nothing to compete with its traditional rivals IBM and NCR , who had started to produce larger-scale computers, or with recently founded Univac . In 1956, they purchased ElectroData Corporation and rebranded its design as the B205. Burroughs' first internally developed machine, the B5000, was designed in 1961 and Burroughs sought to address its late entry in the market with

2340-627: The Atlas and the Rice machine; they are also very different from each other. The first of the Burroughs large systems was the B5000. Designed in 1961, it was a second-generation computer using discrete transistor logic and magnetic-core memory , followed by the B5500 and B5700. The first machines to replace the B5000 architecture were the B6500 and B7500. The successor machines to the B6500 and B7500 followed

2418-496: The B5000 MCP operating system was written in an extension of extended ALGOL called ESPOL (Executive Systems Programming Oriented Language). This was replaced in the mid-to-late 70s by a language called NEWP . Though NEWP probably just meant "New Programming language", legends surround the name. A common (perhaps apocryphal) story within Burroughs at the time suggested it came from " No Executive Washroom Privileges ." Another story

Burroughs Large Systems - Misplaced Pages Continue

2496-637: The B6500 communicated by messages in memory, essentially packets in today's terms, and the MCS did the B6500-side processing of those messages. In the early years the DCP did have an assembler (Dacoma), an application program called DCPProgen written in B6500 ALGOL. Later the NDL (Network Definition Language) compiler generated the DCP code and NDF (network definition file). Ultimately, a further update resulted in

2574-569: The B6700. The third and largest line, the B8500, had no commercial success. In addition to a proprietary CMOS processor design, Unisys also uses Intel Xeon processors and runs MCP , Microsoft Windows and Linux operating systems on their Libra servers; the use of custom chips was gradually eliminated, and by 2018 the Libra servers had been strictly commodity Intel for some years. The first member of

2652-944: The Burroughs Adding Machine Company was renamed the Burroughs Corporation and began moving into digital computer products, initially for banking institutions. This move began with Burroughs' purchase in June 1956, of the ElectroData Corporation in Pasadena, California , a spinoff of the Consolidated Engineering Corporation which had designed test instruments and had a cooperative relationship with Caltech in Pasadena. ElectroData had built

2730-489: The Bxx00 models were replaced by the A Series models, the differences were retained but no longer readily identifiable by model number. The Burroughs large systems implement ALGOL-derived stack architectures . The B5000 was the first stack-based system. While B5000 was specifically designed to support ALGOL, this was only a starting point. Other business-oriented languages such as COBOL were also well supported, most notably by

2808-571: The CP2000 distributed communications processor as the protocol host. Two to three years later, the TCP/IP implementation was rewritten to be host/server based with significant performance and functionality improvements. In the same general time frame an implementation of the OSI protocol stacks was made, principally on the CP2000, but a large supporting infrastructure was implemented on the main system. All of

2886-402: The DCP via an internal bus to the relevant MCP Datacom Control (DCC) DCP process stack. One DCC process was initiated for each DCP configured on the system. The DCP Process stack would then ensure that the inbound message was queued for delivery to the MCS identified to handle traffic from the particular source device and return any response to the DCP for delivery to the destination device. From

2964-823: The East Coast operations, based in Tredyffrin, Pennsylvania , handled the larger B7x00 line. All machines from both lines were fully object-compatible, meaning a program compiled on one could be executed on another. Newer and larger models had instructions which were not supported on older and slower models, but the hardware, when encountering an unrecognized instruction, invoked an operating system function which interpreted it. Other differences include how process switching and I/O were handled, and maintenance and cold-starting functionality. Larger systems included hardware process scheduling and more capable input/output modules, and more highly functional maintenance processors. When

3042-718: The Libra 100 through the Libra 500, with the Libra 590 being announced in 2005. Later Libras, including the 590, also incorporate Intel Xeon processors and can run the Burroughs large systems architecture in emulation as well as on the MCP CMOS processors. It is unclear if Unisys will continue development of new MCP CMOS ASICs. 1-2 HDUs (I/O), 1-2 APs, 1-4 CPUs, Soft implementation of NUMA memory allowed CPUs to float from memory space to memory space. Hardware and software design, development, and manufacturing were split between two primary locations, in Orange County, California , and

3120-565: The OSI standard defined applications were implemented including X.400 mail hosting and X.500 directory services. Another variant of ALGOL is DMALGOL (Data Management ALGOL). DMALGOL is ALGOL extended for compiling the DMSII database software from database description files created by the DASDL (Data Access and Structure Definition Language) compiler. Database designers and administrators compile database descriptions to generate DMALGOL code tailored for

3198-775: The T field of an Operand Call or Descriptor Call syllable is relative to the Program Reference Table (PRT). For subroutines, the type of addressing is dependent on the high three bits of T and on the Mark Stack FlipFlop (MSFF), as shown in B5x00 Relative Addressing . The B5000 was designed to exclusively support high-level languages. This was at a time when such languages were just coming to prominence with FORTRAN and then COBOL . FORTRAN and COBOL were considered weaker languages by some, when it comes to modern software techniques, so

Burroughs Large Systems - Misplaced Pages Continue

3276-484: The ability for direct subtraction. Burroughs released the Class 3 and Class 4 adding machines which were built after the purchase of the Pike Adding Machine Company around 1910. These machines provided a significant improvement over the older models because operators could view the printing on the paper tape. The machines were called "the visible" for this improvement. In 1925 Burroughs released

3354-552: The banking sector, where they were often connected to non-Burroughs mainframes. In conjunction with these products, Burroughs also manufactured an extensive range of cheque processing equipment, normally attached as terminals to a medium systems such as B200/B300 and larger systems such as a B2700 or B1700 . In the 1950s, Burroughs worked with the Federal Reserve Bank on the development and computer processing of magnetic ink character recognition (MICR) especially for

3432-480: The company moved to Detroit and changed its name to the Burroughs Adding Machine Company. It was soon the biggest adding machine company in America. The adding machine range began with the basic, hand-cranked Class 1 which was only capable of adding. The design included some revolutionary features, foremost of which was the dashpot which governed the speed at which the operating lever could be pulled so allowing

3510-468: The configuration chosen by the site.) While NEWP can be used to write general programs and has a number of features designed for large software projects, it does not support everything ALGOL does. NEWP has a number of facilities to enable large-scale software projects, such as the operating system, including named interfaces (functions and data), groups of interfaces, modules, and super-modules. Modules group data and functions together, allowing easy access to

3588-479: The data as global within the module. Interfaces allow a module to import and export functions and data. Super-modules allow modules to be grouped. In the original implementation, the system used an attached specialized data communications processor (DCP) to handle the input and output of messages from/to remote devices. This was a 24-bit minicomputer with a conventional register architecture and hardware I/O capability to handle thousands of remote terminals. The DCP and

3666-577: The delivery of application data to online production environments and the return of responses to remote users/devices/systems. MCSs are items of software worth noting – they control user sessions and provide keeping track of user state without having to run per-user processes since a single MCS stack can be shared by many users. Load balancing can also be achieved at the MCS level. For example, saying that you want to handle 30 users per stack, in which case if you have 31 to 60 users, you have two stacks, 61 to 90 users, three stacks, etc. This gives B5000 machines

3744-505: The development of the NDLII language and compiler which were used in conjunction with the model 4 and 5 DCPs. There was one ALGOL function for each kind of DCP instruction, and if you called that function, then the corresponding DCP instruction bits would be emitted to the output. A DCP program was an ALGOL program comprising nothing but a long list of calls on these functions, one for each assembly language statement. Essentially ALGOL acted like

3822-403: The final total were printed on a roll of paper at the rear, so there was no danger of the operator writing down the wrong answer and there was a copy of the calculation which could be checked later if necessary. The Class 2 machine, called the "duplex" and built in the same basic style, provided a means of keeping two separate totals. The Class 6 machine was built for bookkeeping work and provided

3900-456: The first computers in the only line of Burroughs systems to survive to the present day. While they were inspired by the B5000, they had a totally new architecture. Among the most important differences were Among other customers of the B6700 and B7700 were all five New Zealand universities in 1971. The B8500 line derives from the D825, a military computer that was inspired by the B5000. The B8500

3978-409: The first series, the B5000, was designed beginning in 1961 by a team under the leadership of Robert (Bob) Barton . It had an unusual architecture. It has been listed by the computing scientist John Mashey as one of the architectures that he admires the most. "I always thought it was one of the most innovative examples of combined hardware/software design I've seen, and far ahead of its time." The B5000

SECTION 50

#1732787070271

4056-502: The first single chip mainframe, the Micro-A of the late 1980s. This "mainframe" chip (named SCAMP for Single-Chip A-series Mainframe Processor) sat on an Intel-based plug-in PC board. Here is an example of how programs map to the stack structure Each stack frame corresponds to a lexical level in the current execution environment. As you can see, lexical level is the static textual nesting of

4134-616: The flight computer in Lost in Space . B205 tape drives were often seen in series such as The Time Tunnel and Voyage to the Bottom of the Sea . Burroughs equipment was also featured in the movie The Angry Red Planet . Elliott 503 The Elliott 503 was a transistorized computer introduced by Elliott Brothers in 1963. It was software-compatible with the earlier Elliott 803 but

4212-545: The generation method frequently nested procedure within procedure. Procedures can be invoked in four ways – normal, call, process, and run. Burroughs Corporation The Burroughs Corporation was a major American manufacturer of business equipment. The company was founded in 1886 as the American Arithmometer Company by William Seward Burroughs . In 1986, it merged with Sperry UNIVAC to form Unisys . The company's history paralleled many of

4290-462: The hardware development trends to re-implement the architectures in new logic over the next 25 years, with the B6500, B7500, B6700, B7700, B6800, B7800, B5900, B7900 and finally the Burroughs A series. After a merger in which Burroughs acquired Sperry Corporation and changed its name to Unisys , the company continued to develop new machines based on the MCP CMOS ASIC . These machines were

4368-510: The ledger card. This balance was read into the accumulator when the card was inserted into the carriage. The Sensitronic was followed by the E1000, E2000, E3000, E4000, E6000 and the E8000, which were computer systems supporting card reader/punches and a line printer . Later, Burroughs was selling more than adding machines, including typewriters. The biggest shift in company history came in 1953:

4446-481: The macro pass of a macro assembler. The first pass was the ALGOL compiler; the second pass was running the resulting program (on the B6500) which would then emit the binary for the DCP. Starting in the early 1980's, the DCP technology was replaced by the ICP (Integrated Communications Processor) which provided LAN based connectivity for the mainframe system. Remote devices, and remote servers/mainframes, were connected to

4524-712: The major developments in computing . At its start, it produced mechanical adding machines , and later moved into programmable ledgers and then computers. It was one of the largest producers of mainframe computers in the world, also producing related equipment including typewriters and printers . In 1886, the American Arithmometer Company was established in St. Louis , Missouri , to produce and sell an adding machine invented by William Seward Burroughs (grandfather of Beat Generation author William S. Burroughs ). In 1904, six years after Burroughs' death,

4602-413: The mechanism to operate consistently correctly. The machine also had a full-keyboard with a separate column of keys 1 to 9 for each decade where the keys latch when pressed, with interlocking which prevented more than one key in any decade from being latched. The latching allowed the operator to quickly check that the correct number had been entered before pulling the operating lever. The numbers entered and

4680-469: The needs of software taken into consideration. This was a large departure from the computer system design of the time, where a processor and its instruction set would be designed and then handed over to the software people. The B5000, B5500 and B5700 in Word Mode has two different addressing modes, depending on whether it is executing a main program (SALF off) or a subroutine (SALF on). For a main program,

4758-704: The network via freestanding devices called CP2000s. The CP2000s were designed to provide network node support in a distributed network wherein the nodes were connected using the BNAV2 (Burroughs Network Architecture Version 2) networking technology. BNAV2 was a Burroughs functional equivalent of the IBM SNA product and did support interoperation with IBM environments in both PUT2 and PUT5 transport modes. The change in external datacommunications hardware did not require any change to existing MCS (Message Control System (discussed below)) software. On input, messages were passed from

SECTION 60

#1732787070271

4836-447: The outer variables which become inaccessible. Lexical nesting is static, unrelated to execution nesting with recursion, etc. so it is very rare to find a procedure nested more than five levels deep, and it could be argued that such programs would be poorly structured. B5000 machines allow nesting of up to 32 levels. This could cause difficulty for some systems that generated Algol source as output (tailored to solve some special problem) if

4914-485: The outskirts of Philadelphia . The initial Large Systems Plant, which developed the B5000 and B5500, was located in Pasadena, California but moved to City of Industry, California , where it developed the B6500. The Orange County location, which was based in a plant in Mission Viejo, California but at times included facilities in nearby Irvine and Lake Forest , was responsible for the smaller B6x00 line, while

4992-413: The powerful string operators which were included for the development of fast compilers. The ALGOL used on the B5000 is an extended ALGOL subset. It includes powerful string manipulation instructions but excludes certain ALGOL constructs, notably unspecified formal parameters. A DEFINE mechanism serves a similar purpose to the #defines found in C, but is fully integrated into the language rather than being

5070-564: The processing of bank cheques. Burroughs made special MICR/OCR sorter/readers which attached to their medium systems line of computers ( 2700/3700/4700 ) and B200/B300 systems and this entrenched the company in the computer side of the banking industry. Burroughs was one of the nine major United States computer companies in the 1960s, with IBM the largest, Honeywell , NCR Corporation , Control Data Corporation (CDC), General Electric (GE), Digital Equipment Corporation (DEC), RCA and Sperry Rand ( UNIVAC line). In terms of sales, Burroughs

5148-400: The source code from the punched cards , and they had the fastest card readers in the industry. The powerful Burroughs COBOL compiler was also a one-pass compiler and equally fast. A 4000-card COBOL program compiled as fast as the 1000-card/minute readers could read the code. The program was ready to use as soon as the cards went through the reader. The B6500 (delivery in 1969) and B7500 were

5226-475: The source code, so compilers (and even assemblers) usually needed to read the source code more than once. The Burroughs ALGOL syntax, unlike the official language, requires that each variable (or other object) be declared before it is used, so it is feasible to write an ALGOL compiler that reads the data only once. This concept has profound theoretical implications, but it also permits very fast compiling. Burroughs large systems could compile as fast as they could read

5304-488: The stack. The B5000 was designed as a stack machine – all program data except for arrays (which include strings and objects) was kept on the stack. This meant that stack operations were optimized for efficiency. As a stack-oriented machine, there are no programmer addressable registers. Multitasking is also very efficient on the B5000 and B6500 lines. There are specific instruction to perform process switches: Each stack and associated Program Reference Table (PRT) represents

5382-522: The strategy of a completely different design based on the most advanced computing ideas available at the time. While the B5000 architecture is dead, it inspired the B6500 (and subsequent B6700 and B7700). Computers using that architecture were still in production as the Unisys ClearPath Libra servers which run an evolved but compatible version of the MCP operating system first introduced with

5460-620: The tables and indexes specified. Administrators never need to write DMALGOL themselves. Normal user-level programs obtain database access by using code written in application languages, mainly ALGOL and COBOL, extended with database instructions and transaction processing directives. The most notable feature of DMALGOL is its preprocessing mechanisms to generate code for handling tables and indices. DMALGOL preprocessing includes variables and loops, and can generate names based on compile-time variables. This enables tailoring far beyond what can be done by preprocessing facilities which lack loops. DMALGOL

5538-559: Was always a distant second to IBM . In fact, IBM's market share was so much larger than all of the others that this group was often referred to as "IBM and the Seven Dwarves." By 1972 when GE and RCA were no longer in the mainframe business, the remaining five companies behind IBM became known as the BUNCH , an acronym based on their initials. At the same time, Burroughs was very much a competitor. Like IBM, Burroughs tried to supply

5616-429: Was defined as data or program contributed significantly to a secure operating environment, long before spyware and viruses affected computing. The modularity of these large systems was unique: multiple CPUs , multiple memory modules and multiple I/O and Data Comm processors permitted incremental and cost effective growth of system performance and reliability. In industries like banking, where continuous operations

5694-411: Was designed in the 1960s as an attempt to merge the B5500 and the D825 designs. The system used monolithic integrated circuits with magnetic thin-film memory . The architecture employed a 48-bit word, stack, and descriptors like the B5500, but was not advertised as being upward-compatible. The B8500 could never be gotten to work reliably, and the project was canceled after 1970, never having delivered

5772-416: Was mandatory, Burroughs Large Systems penetrated nearly every large bank, including the Federal Reserve Bank . Burroughs built the backbone switching systems for Society for Worldwide Interbank Financial Telecommunication (SWIFT) which sent its first message in 1977. Unisys is still the provider to SWIFT today. In September 1986, Burroughs Corporation merged with Sperry Corporation to form Unisys . For

5850-552: Was succeeded by the B5500, which used disks rather than drum storage, and the B5700, which allowed multiple CPUs to be clustered around shared disk. While there was no successor to the B5700, the B5000 line heavily influenced the design of the B6500, and Burroughs ported the Master Control Program ( MCP ) to that machine. The B5000 was unusual at the time in that the architecture and instruction set were designed with

5928-459: Was the Sensimatic , which was able to perform many business functions semi-automatically. It had a moving programmable carriage to maintain ledgers . It could store 9, 18 or 27 balances during the ledger posting operations and worked with a mechanical adder named a Crossfooter. The Sensimatic developed into the Sensitronic which could store balances on a magnetic stripe which was part of

6006-411: Was used very extensively to reduce the code footprint and execution time. It became much less used in later years, partly because low-level fine tuning for memory and speed became less critical, and partly because eliminating the preprocessing made coding simpler and thus enabled more important optimizations. An applications version of ALGOL to support the accessing of databases from application programs

6084-649: Was very fast — this impressed the Dutch scientist Edsger Dijkstra when he submitted a program to be compiled at the B5000 Pasadena plant. His deck of cards was compiled almost immediately and he immediately wanted several machines for his university, Eindhoven University of Technology in the Netherlands. The compiler was fast for several reasons, but the primary reason was that it was a one-pass compiler . Early computers did not have enough memory to store

#270729