The Burroughs Large Systems Group produced a family of large 48-bit mainframes using stack machine instruction sets with dense syllables. The first machine in the family was the B5000 in 1961, which was optimized for compiling ALGOL 60 programs extremely well, using single-pass compilers. The B5000 evolved into the B5500 (disk rather than drum) and the B5700 (up to four systems running as a cluster). Subsequent major redesigns include the B6500/B6700 line and its successors, as well as the separate B8500 line.

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 the COBOL-optimized Medium Systems (B2000, B3000, and B4000) or the flexible-architecture Small Systems (B1000).

Background
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 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 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 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.

B5000, B5500, and B5700
The first member of 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 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.

Features
 Hardware was designed to support software requirements
 Hardware designed to exclusively support high-level programming languages
 Simplified instruction set
 No Assembly language or assembler; all system software written in an extended variety of ALGOL 60 named ESPOL. However, ESPOL had statements for each of the syllables in the architecture.
 Partially data-driven tagged and descriptor-based design
 Few programmer accessible registers
 Stack machine where all operations use the stack rather than explicit operands. This approach has by now fallen out of favor.
 All interrupts and procedure calls use the stack
 Support for other languages such as COBOL
 Powerful string manipulation
 All code automatically reentrant: programmers don't have to do anything more to have any code in any language spread across processors than to use just the two shown simple primitives.
 Support for an operating system (MCP, Master Control Program)
 Support for asymmetric (master/slave) multiprocessing
 An attempt at a secure architecture prohibiting unauthorized access of data or disruptions to operations
 Early error-detection supporting development and testing of software
 A commercial implementation virtual memory, preceded only by the Ferranti Atlas.
 First segmented memory model

System design
The B5000 was unusual at the time in that the architecture and instruction set were designed with 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, 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.

Language support
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 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 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 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 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 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.

B6500, B6700/B7700, and successors

The B6500 (delivery in 1969) and B7500 were 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
The B6500 had variable length instructions with an 8-bit syllable instead of fixed length instructions with a 12-bit syllable.
The B6500 had a 51-bit instead of a 48-bit word, and used 3 bits as a tag
The B6500 had Symmetric Multiprocessing (SMP)
The B6500 had a Saguaro stack
The B6500 had paged arrays
The B6500 had Display Registers, D1 thru D32 to allow nested subroutines to access variables in outer blocks.
The B6500 used monolithic integrated circuits with magnetic thin-film memory.

Among other customers of the B6700 and B7700 were all five New Zealand universities in 1971.

B8500
The B8500 line derives from the D825, a military computer that was inspired by the B5000.

The B8500 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 a completed system.

History

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 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 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 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.

Primary lines of hardware
Hardware and software design, development, and manufacturing were split between two primary locations, in Orange County, California, and 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 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 the Bxx00 models were replaced by the A Series models, the differences were retained but no longer readily identifiable by model number.

ALGOL

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 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 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.

ESPOL and NEWP
Originally, 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 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 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 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 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.

DCALGOL and Message Control Systems (MCS)
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 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 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 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 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 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 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 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 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 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 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 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 the OSI standard defined applications were implemented including X.400 mail hosting and X.500 directory services.

DMALGOL and databases
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 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 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" 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 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 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.

Stack architecture
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 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:
B5000, B5500, B5700
Initiate P1 (IP1) and Initiate P2 (IP2)
B6500, B7500 and successors
MVST (move stack).
Each stack and associated Program Reference Table (PRT) represents 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 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 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 speed and performance
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 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 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 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 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.

How programs map to the stack

Here is an example of how programs map to the stack structure

 begin
    — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
    — This is lexical level 2 (level zero is reserved for the operating system and level 1 for code segments).
    — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

    — At level 2 we place global variables for our program.

    integer i, j, k;
    real f, g;
    array a [0:9];

    procedure p (real p1, p2);
       value p1;     — p1 passed by value, p2 implicitly passed by reference.
       begin
          — — — — — — — — — — — — — — — — — —
          — This block is at lexical level 3
          — — — — — — — — — — — — — — — — — —
          real r1, r2;
          r2 := p1 * 5;
          p2 := r2;  — This sets g to the value of r2
          p1 := r2;  — This sets p1 to r2, but not f
          — Since this overwrites the original value of f in p1 it might be a
          — coding mistake.  Some few of ALGOL's successors therefore insist that
          — value parameters be read only – but most do not.

          if r2 > 10 then
             begin
                — — — — — — — — — — — — — — — — — — — — — — — — — — — —
                — A variable declared here makes this lexical level 4
                — — — — — — — — — — — — — — — — — — — — — — — — — — — —
                integer n;
                — The declaration of a variable makes this a block, which will invoke some
                — stack building code. Normally you won't declare variables here, in which
                — case this would be a compound statement, not a block.

                ... <== sample stack is executing somewhere here.
             end;
       end;

    .....

    p (f, g);
 end.

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 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 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 the generation method frequently nested procedure within procedure.

Procedures
Procedures can be invoked in four ways – normal, call, process, and run.

The normal invocation invokes a procedure in the normal way any language invokes a routine, by suspending the calling routine until the invoked procedure returns.

The call mechanism invokes a procedure as a coroutine. Coroutines are partner tasks established as synchronous entities operating in their own stack at the same lexical level as the initiating process. Control is explicitly passed between the initiating process and the coroutine by means of a CONTINUE instruction.

The process mechanism invokes a procedure as an asynchronous task with a separate stack set up starting at the lexical level of the processed procedure. As an asynchronous task, there is no control over exactly when control will be passed between the tasks, unlike coroutines. The processed procedure still has access to the enclosing environment and this is a very efficient IPC (Inter Process Communication) mechanism. Since two or more tasks now have access to common variables, the tasks must be synchronized to prevent race conditions, which is handled by the EVENT data type, where processes can WAIT on one, or more, events until it is caused by another cooperating process. EVENTs also allow for mutual exclusion synchronization through the PROCURE and LIBERATE functions. If for any reason the child task dies, the calling task can continue – however, if the parent process dies, then all child processes are automatically terminated. On a machine with more than one processor, the processes may run simultaneously. This EVENT mechanism is a basic enabler for multiprocessing in addition to multitasking.

Run invocation type

The last invocation type is run. This runs a procedure as an independent task which can continue on after the originating process terminates. For this reason, the child process cannot access variables in the parent's environment, and all parameters passed to the invoked procedure must be call-by-value.

Thus, Burroughs Extended ALGOL had some of the multi-processing and synchronization features of later languages like Ada.  It made use of the support for asynchronous processes that was built into the hardware.

Inline procedures

One last possibility is that in NEWP a procedure may be declared INLINE, that is when the compiler sees a reference to it the code for the procedure is generated inline to save the overhead of a procedure call; this is best done for small pieces of code. Inline functions are similar to parameterized macros such as C #defines, except you don't get the problems with parameters that you can with macros.

Asynchronous calls

In the example program only normal calls are used, so all the information will be on a single stack. For asynchronous calls, a separate stack is initiated for each asynchronous process so that the processes share data but run asynchronously.

Display registers

A stack hardware optimization is the provision of D (or "display") registers. These are registers that point to the start of each called stack frame. These registers are updated automatically as procedures are entered and exited and are not accessible by any software other than the MCP. There are 32 D registers, which is what limits operations to 32 levels of lexical nesting.

Consider how we would access a lexical level 2 (D[2]) global variable from lexical level 5 (D[5]). Suppose the variable is 6 words away from the base of lexical level 2. It is thus represented by the address couple (2, 6). If we don't have D registers, we have to look at the control word at the base of the D[5] frame, which points to the frame containing the D[4] environment. We then look at the control word at the base of this environment to find the D[3] environment, and continue in this fashion until we have followed all the links back to the required lexical level. This is not the same path as the return path back through the procedures which have been called in order to get to this point. (The architecture keeps both the data stack and the call stack in the same structure, but uses control words to tell them apart.)

As you can see, this is quite inefficient just to access a variable. With D registers, the D[2] register points at the base of the lexical level 2 environment, and all we need to do to generate the address of the variable is to add its offset from the stack frame base to the frame base address in the D register. (There is an efficient linked list search operator LLLU, which could search the stack in the above fashion, but the D register approach is still going to be faster.) With D registers, access to entities in outer and global environments is just as efficient as local variable access.

 D Tag Data                — Address couple, Comments
 register

 | 0        | n          | (4, 1) The integer n (declared on entry to a block, not a procedure)
 |-----------------------|
 | D[4]==>3 | MSCW       | (4, 0) The Mark Stack Control Word containing the link to D[3].
 |=======================|
 | 0        | r2         | (3, 5) The real r2
 |-----------------------|
 | 0        | r1         | (3, 4) The real r1
 |-----------------------|
 | 1        | p2         | (3, 3) A SIRW reference to g at (2,6)
 |-----------------------|
 | 0        | p1         | (3, 2) The parameter p1 from value of f
 |-----------------------|
 | 3        | RCW        | (3, 1) A return control word
 |-----------------------|
 | D[3]==>3 | MSCW       | (3, 0) The Mark Stack Control Word containing the link to D[2].
 |=======================|
 | 1        | a          | (2, 7) The array a  ======>[ten word memory block]
 |-----------------------|
 | 0        | g          | (2, 6) The real g
 |-----------------------|
 | 0        | f          | (2, 5) The real f
 |-----------------------|
 | 0        | k          | (2, 4) The integer k
 |-----------------------|
 | 0        | j          | (2, 3) The integer j
 |-----------------------|
 | 0        | i          | (2, 2) The integer i
 |-----------------------|
 | 3        | RCW        | (2, 1) A return control word
 |-----------------------|
 | D[2]==>3 | MSCW       | (2, 0) The Mark Stack Control Word containing the link to the previous stack frame.
 |=======================| — Stack bottom

If we had invoked the procedure p as a coroutine, or a process instruction, the D[3] environment would have become a separate D[3]-based stack. This means that asynchronous processes still have access to the D[2] environment as implied in ALGOL program code. Taking this one step further, a totally different program could call another program's code, creating a D[3] stack frame pointing to another process' D[2] environment on top of its own process stack. At an instant the whole address space from the code's execution environment changes, making the D[2] environment on the own process stack not directly addressable and instead make the D[2] environment in another process stack directly addressable. This is how library calls are implemented. At such a cross-stack call, the calling code and called code could even originate from programs written in different source languages and be compiled by different compilers.

The D[1] and D[0] environments do not occur in the current process's stack. The D[1] environment is the code segment dictionary, which is shared by all processes running the same code. The D[0] environment represents entities exported by the operating system.

Stack frames actually don't even have to exist in a process stack. This feature was used early on for file I/O optimization, the FIB (file information block) was linked into the display registers at D[1] during I/O operations. In the early nineties, this ability was implemented as a language feature as STRUCTURE BLOCKs and – combined with library technology - as CONNECTION BLOCKs. The ability to link a data structure into the display register address scope implemented object orientation. Thus, the B6500 actually used a form of object orientation long before the term was ever used.

On other systems, the compiler might build its symbol table in a similar manner, but eventually the storage requirements would be collated and the machine code would be written to use flat memory addresses of 16-bits or 32-bits or even 64-bits. These addresses might contain anything so that a write to the wrong address could damage anything. Instead, the two-part address scheme was implemented by the hardware. At each lexical level, variables were placed at displacements up from the base of the level's stack, typically occupying one word - double precision or complex variables would occupy two. Arrays were not stored in this area, only a one word descriptor for the array was. Thus, at each lexical level the total storage requirement was not great: dozens, hundreds or a few thousand in extreme cases, certainly not a count requiring 32-bits or more. And indeed, this was reflected in the form of the VALC instruction (value call) that loaded an operand onto the stack. This op-code was two bits long and the rest of the byte's bits were concatenated with the following byte to give a fourteen-bit addressing field. The code being executed would be at some lexical level, say six: this meant that only lexical levels zero to six were valid, and so just three bits were needed to specify the lexical level desired. The address part of the VALC operation thus reserved just three bits for that purpose, with the remainder being available for referring to entities at that and lower levels. A deeply nested procedure (thus at a high lexical level) would have fewer bits available to identify entities: for level sixteen upwards five bits would be needed to specify the choice of levels 0–31 thus leaving nine bits to identify no more than the first 512 entities of any lexical level. This is much more compact than addressing entities by their literal memory address in a 32-bit addressing space. Further, only the VALC opcode loaded data: opcodes for ADD, MULT and so forth did no addressing, working entirely on the top elements of the stack.

Much more important is that this method meant that many errors possible on systems employing flat addressing could not occur because they were simply unspeakable even at the machine code level. A task had no way to corrupt memory in use by another task, because it had no way to develop its address. Offsets from a specified D-register would be checked by the hardware against the stack frame bound: rogue values would be trapped. Similarly, within a task, an array descriptor contained information on the array's bounds, and so any indexing operation was checked by the hardware: put another way, each array formed its own address space. In any case, the tagging of all memory words provided a second level of protection: a misdirected assignment of a value could only go to a data-holding location, not to one holding a pointer or an array descriptor, etc. and certainly not to a location holding machine code.

Array storage
Arrays were not stored contiguous in memory with other variables, they were each granted their own address space, which was located via the descriptor. The access mechanism was to calculate on the stack the index variable (which therefore had the full integer range potential, not just fourteen bits) and use it as the offset into the array's address space, with bound checking provided by the hardware. By default, should an array's length exceed 1,024 words, the array would be segmented, and the index be converted into a segment index and an offset into the indexed segment. There was, however, the option to prevent segmentation by specifying the array as LONG in the declaration.  In ALGOL's case, a multidimensional array would employ multiple levels of such addressing. For a reference to A[i,j], the first index would be into an array of descriptors, one descriptor for each of the rows of A, which row would then be indexed with j as for a single-dimensional array, and so on for higher dimensions. Hardware checking against the known bounds of all the array's indices would prevent erroneous indexing.

FORTRAN however regards all multidimensional arrays as being equivalent to a single-dimensional array of the same size, and for a multidimensional array simple integer arithmetic is used to calculate the offset where element A[i,j,k] would be found in that single sequence. The single-dimensional equivalent array, possibly segmented if large enough, would then be accessed in the same manner as a single-dimensional array in ALGOL. Although accessing outside this array would be prevented, a wrong value for one index combined with a suitably wrong value for another index might not result in a bounds violation of the single sequence array; in other words, the indices were not checked individually.

Because an array's storage was not bounded on each side by storage for other items, it was easy for the system to "resize" an array - though changing the number of dimensions was precluded because compilers required all references to have the same number of dimensions. In ALGOL's case, this enabled the development of "ragged" arrays, rather than the usual fixed rectangular (or higher dimension) arrays. Thus in two dimensions, a ragged array would have rows that were of different sizes. For instance, given a large array A[100,100] of mostly-zero values, a sparse array representation that was declared as SA[100,0] could have each row resized to have exactly enough elements to hold only the non-zero values of A along that row.

Because arrays larger than 1024 words were generally segmented but smaller arrays were not, on a system that was short of real memory, increasing the declared size of a collection of scratchpad arrays from 1,000 to say 1,050 could mean that the program would run with far less "thrashing" as only the smaller individual segments in use were needed in memory. Actual storage for an array segment would be allocated at run time only if an element in that segment were accessed, and all elements of a created segment would be initialised to zero. Not initialising an array to zero at the start therefore was encouraged by this, normally an unwise omission.

Array equivalencing is also supported.  The ARRAY declaration requested allocation of 48-bit data words which could be used to store any bit pattern but the general operational practice was that each allocated word was considered to be a REAL operand.  The declaration of:

   ARRAY A [0:99]

requested the allocation of 100 words of type REAL data space in memory.  The programmer could also specify that the memory might be referred to as character oriented data by the following equivalence declaration:

   EBCDIC ARRAY EA [0] = A [*];

or as hexadecimal data via the equivalence declaration:

   HEX ARRAY HA [0] = A [*];

or as ASCII data via the equivalence declaration:

   ASCII ARRAY AA [0] = A[*];

The capability to request data type specific arrays without equivalencing is also supported, e.g.

   EBCDIC ARRAY MY_EA [0:99]

requested that the system allocated a 100 character array.  Given that the architecture is word based, the actual space allocated is the requested number of characters rounded up to the next whole word boundary.

The Data Descriptor generated at compilation time indicated the data type usage for which the array was intended.  If an array equivalence declaration was made a copy descriptor indicating that particular usage type was generated but pointed back to the original, or MOM, descriptor.  Thus, indexing the correct location in memory was always guaranteed.

BOOLEAN arrays are also supported and may be used as a bit vector.  INTEGER arrays may also be requested.

The immediately preceding discussion uses the ALGOL syntax implementation to describe ARRAY declarations, but the same functionality is supported in COBOL and FORTRAN.

Stack structure advantages

One nice thing about the stack structure is that if a program does happen to fail, a stack dump is taken and it is very easy for a programmer to find out exactly what the state of a running program was. Compare that to core dumps and exchange packages of other systems.

Another thing about the stack structure is that programs are implicitly recursive. FORTRAN was not expected to support recursion and perhaps one stumbling block to people's understanding of how ALGOL was to be implemented was how to implement recursion. On the B5000, this was not a problem – in fact, they had the reverse problem, how to stop programs from being recursive. In the end they didn't bother. The Burroughs FORTRAN compiler allowed recursive calls (just as every other FORTRAN compiler does), but unlike many other computers, on a stack-based system the returns from such calls succeeded as well. This could have odd effects, as with a system for the formal manipulation of mathematical expressions whose central subroutines repeatedly invoked each other without ever returning: large jobs were ended by stack overflow!

Thus Burroughs FORTRAN had better error checking than other contemporary implementation of FORTRAN. For instance, for subroutines and functions it checked that they were invoked with the correct number of parameters, as is normal for ALGOL-style compilers. On other computers, such mismatches were common causes of crashes. Similarly with the array-bound checking: programs that had been used for years on other systems embarrassingly often would fail when run on a Burroughs system. In fact, Burroughs became known for its superior compilers and implementation of languages, including the object-oriented Simula (a superset of ALGOL), and Iverson, the designer of APL declared that the Burroughs implementation of APL was the best he'd seen. John McCarthy, the language designer of LISP disagreed, since LISP was based on modifiable code, he did not like the unmodifiable code of the B5000, but most LISP implementations would run in an interpretive environment anyway.

The storage required for the multiple processes came from the system's memory pool as needed. There was no need to do SYSGENs on Burroughs systems as with competing systems in order to preconfigure memory partitions in which to run tasks.

Tagged architecture
The most defining aspect of the B5000 is that it is a stack machine as treated above. However, two other very important features of the architecture is that it is tag-based and descriptor-based.

In the original B5000, a flag bit in each control or numeric word was set aside to identify the word as a control word or numeric word. This was partially a security mechanism to stop programs from being able to corrupt control words on the stack.

Later, when the B6500 was designed, it was realized that the 1-bit control word/numeric distinction was a powerful idea and this was extended to three bits outside of the 48 bit word into a tag. The data bits are bits 0–47 and the tag is in bits 48–50. Bit 48 was the read-only bit, thus odd tags indicated control words that could not be written by a user-level program. Code words were given tag 3. Here is a list of the tags and their function:

Internally, some of the machines had 60 bit words, with the extra bits being used for engineering purposes such as a Hamming code error-correction field, but these were never seen by programmers.

The current incarnation of these machines, the Unisys ClearPath has extended tags further into a four bit tag. The microcode level that specified four bit tags was referred to as level Gamma.

Even-tagged words are user data which can be modified by a user program as user state. Odd-tagged words are created and used directly by the hardware and represent a program's execution state. Since these words are created and consumed by specific instructions or the hardware, the exact format of these words can change between hardware implementation and user programs do not need to be recompiled, since the same code stream will produce the same results, even though system word format may have changed.

Tag 1 words represent on-stack data addresses. The normal IRW simply stores an address couple to data on the current stack. The SIRW references data on any stack by including a stack number in the address.  Amongst other things, SIRW's are used to provide addressing between discrete process stacks such as those generated in response to the CALL and PROCESS statements.

Tag 5 words are descriptors, which are more fully described in the next section. Tag 5 words represent off-stack data addresses.

Tag 7 is the program control word which describes a procedure entry point. When hardware operators hit a PCW, the procedure is entered. The ENTR operator explicitly enters a procedure (non-value-returning routine). Functions (value-returning routines) are implicitly entered by operators such as value call (VALC). Global routines are stored in the D[2] environment as SIRWs that point to a PCW stored in the code segment dictionary in the D[1] environment. The D[1] environment is not stored on the current stack because it can be referenced by all processes sharing this code. Thus code is reentrant and shared.

Tag 3 represents code words themselves, which won't occur on the stack. Tag 3 is also used for the stack control words MSCW, RCW, TOSCW.

Descriptor-based architecture

The figure to the left shows how the Burroughs Large System architecture was fundamentally a hardware architecture for object-oriented programming, something that still doesn't exist in conventional architectures.

Instruction sets

There are three distinct instruction sets for the Burroughs large systems. All three are based on short syllables that fit evenly into words.

B5000, B5500 and B5700

Programs on a B5000, B5500 and B5700 are made up of 12-bit syllables, four to a word.
The architecture has two modes, Word Mode and Character Mode, and each has a separate repertoire of syllables. A processor may be either Control State or Normal State, and certain syllables are only permissible in Control State. The architecture does not provide for addressing registers or storage directly; all references are through the 1024 word Program Reference Table, current code segment, marked locations within the stack or to the A and B registers holding the top two locations on the stack. Burroughs numbers bits in a syllable from 0 (high bit) to 11 (low bit)

B6500 and successors

Programs are made up of 8-bit syllables, which may be Name Call, Value Call, or form an operator, which may be from one to twelve syllables in length. There are less than 200 operators, all of which fit into 8-bit syllables. Many of these operators are polymorphic depending on the kind of data being acted on as given by the tag. If we ignore the powerful string scanning, transfer, and edit operators, the basic set is only about 120 operators. If we remove the operators reserved for the operating system such as MVST and HALT, the set of operators commonly used by user-level programs is less than 100. The Name Call and Value Call syllables contain address couples; the Operator syllables either use no addresses or use control words and descriptors on the stack.

Multiple processors
The B5000 line also were pioneers in having two processors connected together on a high-speed bus as master and slave. In the B6000, B7000 and B8000 lines the processors were symmetric. The B7000 line could have up to eight processors, as long as at least one was an I/O module. RDLK (ReaD with LocK) is a very low-level way of synchronizing between processors. RDLK operates in a single cycle. The higher level mechanism generally employed by user programs is the EVENT data type. The EVENT data type did have some system overhead. To avoid this overhead, a special locking technique called Dahm locks (named after a Burroughs software guru, Dave Dahm) can be used.  Dahm locks used the READLOCK ALGOL language statement which generated a RDLK operator at the code level.

Notable operators are:

HEYU — send an interrupt to another processor
RDLK — Low-level semaphore operator: Load the A register with the memory location given by the A register and place the value in the B register at that memory location in a single uninterruptible cycle. The Algol compiler produced code to invoke this operator via a special function that enabled a "swap" operation on single-word data without an explicit temporary value. x:=RDLK(x,y);
WHOI — Processor identification
IDLE — Idle until an interrupt is received

Two processors could infrequently simultaneously send each other a 'HEYU' command resulting in a lockup known as 'a deadly embrace'.

Influence of the B5000
The direct influence of the B5000 can be seen in the current Unisys ClearPath range of mainframes which are the direct descendants of the B6500, which was influenced by the B5000, and still have the MCP operating system after 40 years of consistent development. This architecture is now called emode (for emulation mode) since the B6500 architecture has been implemented on machines built from Intel Xeon processors running the x86 instruction set as the native instruction set, with code running on those processors emulating the B5000 instruction set. In those machines, there was also going to be an nmode (native mode), but this was dropped, so you may often hear the B6500 successor machines being referred to as "emode machines".

B5000 machines were programmed exclusively in high-level languages; there is no assembler.

The B5000 stack architecture inspired Chuck Moore, the designer of the programming language Forth, who encountered the B5500 while at MIT. In Forth - The Early Years, Moore described the influence, noting that Forth's DUP, DROP and SWAP came from the corresponding B5500 instructions (DUPL, DLET, EXCH).

B5000 machines with their stack-based architecture and tagged memory also heavily influenced the Soviet Elbrus series of mainframes and supercomputers. The first two generations of the series featured tagged memory and stack-based CPUs that were programmed only in high-level languages. There existed a kind of an assembly language for them, called El-76, but it was more or less a modification of ALGOL 68 and supported structured programming and first-class procedures. Later generations of the series, though, switched away from this architecture to the EPIC-like VLIW CPUs.

The Hewlett-Packard designers of the HP 3000 business system had used a B5500 and were greatly impressed by its hardware and software; they aimed to build a 16-bit minicomputer with similar software. Several other HP divisions created similar minicomputer or microprocessor stack machines.  Bob Barton's work on reverse Polish notation (RPN) also found its way into HP calculators beginning with the 9100A, and notably the HP-35 and subsequent calculators.

The NonStop systems designed by Tandem Computers in the late 1970s and early 1980s were also 16-bit stack machines, influenced by the B5000 indirectly through the HP 3000 connection, as several of the early Tandem engineers were formerly with HP.  Around 1990, these systems migrated to MIPS RISC architecture but continued to support execution of stack machine binaries by object code translation or direct emulation.  Sometime after 2000, these systems migrated to Itanium architecture and continued to run the legacy stack machine binaries.

Bob Barton was also very influential on Alan Kay. Kay was also impressed by the data-driven tagged architecture of the B5000 and this influenced his thinking in his developments in object-oriented programming and Smalltalk.

Another facet of the B5000 architecture was that it was a secure architecture that runs directly on hardware. This technique has descendants in the virtual machines of today in their attempts to provide secure environments. One notable such product is the Java JVM which provides a secure sandbox in which applications run.

The value of the hardware-architecture binding that existed before emode would be substantially preserved in the x86-based machines to the extent that MCP was the one and only control program, but the support provided by those machines is still inferior to that provided on the machines where the B6500 instruction set is the native instruction set. A little-known Intel processor architecture that actually preceded 32-bit implementations of the x86 instruction set, the Intel iAPX 432, would have provided an equivalent physical basis, as it too was essentially an object-oriented architecture.

See also
 Burroughs Medium Systems
 Burroughs Small Systems
 CANDE
 Network Definition Language (NDL)
 Work Flow Language (WFL)
 Octal floating point

Notes

References

 The Extended ALGOL Primer (Three Volumes), Donald J. Gregory.
 Computer Architecture: A Structured Approach, R. Doran, Academic Press (1979).
 Stack Computers: The New Wave, Philip J. Koopman, available at:
 B5500, B6500, B6700, B6800, B6900, B7700 manuals at: bitsavers.org

Further reading
Barton, Robert S. "A New Approach to the Functional Design of a Digital Computer" Proceedings of the Western Joint Computer Conference. ACM (1961).
Burroughs B 5000 Oral history, Charles Babbage Institute, University of Minnesota. The Burroughs 5000 computer series is discussed by individuals responsible for its development and marketing from 1957 through the 1960s in a 1985 conference sponsored by AFIPS and Burroughs Corporation.

Hauck, E.A., Dent, Ben A. "Burroughs B6500/B7500 Stack Mechanism", SJCC (1968) pp. 245–251.
McKeeman, William M. "Language Directed Computer Design", Fall Joint Computer Conference, (1967) pp. 413–417.
Organick, Elliot I. "Computer System Organization The B5700/B6700 series", Academic Press (1973).
 Waychoff, Richard, "Stories of the B5000 and People Who Were There", September 27, 1979.
 Allweiss, Jack. "The Burroughs B5900 and E-Mode A bridge to 21st Century Computing", Revised 2018.
 Martin, Ian. "'Too far ahead of its time': Britain, Burroughs and real-time banking in the 1960s", Society for the History of Technology Annual Meeting, 20 Sep-3 Oct 2010, Tacoma, USA.

External links
 Ian Joyner's Burroughs page
 The Burroughs B5900 and E-Mode: A bridge to 21st Century Computing - Jack Allweiss
 (web archive of:) Ralph Klimek on the B7800 at Monash University
 "Early Burroughs Machines", University of Virginia's Computer Museum.
 "Computer System Organization", ACM Monograph Series.
 Index of B8500 manuals
 B5500 Emulation Project Project to create a functional emulator for the Burroughs B5500 computer system.
 "Burroughs B6500 film & transcript"

Large Systems
High-level language computer architecture
Stack machines
Transistorized computers
Unisys
Computer-related introductions in 1961
1960s in computing
1970s in computing
1980s in computing
Burroughs B5000

Burroughs Large Systems


Trance describes a state of mind. A trance is when a person is conscious, and not sleeping, but is unaware of what is happening around him or her.

The term trance is associated with hypnosis, meditation, magic, flow, religion, and certain kinds of music. It is an "altered state of consciousness".

There are many efforts to define what a trance is. Some think it is a borderland between normal consciousness and spirituality

The most straightforward example is when a person is hypnotized, they are in a trance. Conscious, and responding to the hypnotist, the person seems to block out other thoughts and other information.

Another common example is the day-dream, where a person's mind drifts across private thoughts. Everyone daydreams, but young children constantly daydream, and have vivid imaginary fantasies. This is entirely normal. In the language of psychology, this kind of temporary separation from one's surroundings is called "dissociation". Research shows that a lot is going on when we daydream.

There are many examples of trance in religion. African animistic religions, such as that of the Yoruba, feature dances in celebration of the spirits. Under the influence of rhythm and song, a group dances, often for hours at a time. During this time, various members of the group may fall into trances, and some may act as if possessed by one of the spirits being worshiped. States of "spiritual ecstasy" are known in most forms of Christian worship. It is a main part of those aspects of religion known as "mysticism".

Related pages
Flow (psychology)

References

Psychology

Trance


The Ghost Train is a 1941 British mystery thriller film directed by Walter Forde based on the 1923 play of the same name written by Arnold Ridley.

Plot
Tommy Gander (Arthur Askey), a music hall comedian, pulls the communication cord on a GWR express train, bringing it to a stop so he can retrieve his hat. Returning to the train, he escapes an angry conductor by ducking into a compartment occupied by attractive blonde Jackie Winthrop (Carole Lynne), with whom Gander flirts. Another passenger, Teddy (Richard Murdoch), has his eye on Jackie as well, but her companion Richard Winthrop (Peter Murray-Hill) ejects both of them from the compartment.

When the train stops at Fal Vale Junction, Cornwall, these four get off to change trains, as do Herbert (Stuart Latham) and his fiancée Edna (Betty Jardine), spinster Miss Bourne (Kathleen Harrison), and the tippling Dr. Sterling (Morland Graham). However, the stationmaster, Saul Hodgkin (Herbert Lomas) tells them the last Truro-bound train has gone, and that they cannot remain at the station, as he is locking up for the night. The passengers insist on staying, as it is raining heavily and the nearest village is four miles away.

Hodgkin warns them the station is haunted. A branch line once crossed the river on a swing bridge close to the station. One night 43 years ago, then stationmaster Ted Holmes had a fatal heart attack while attempting to close the bridge, causing a train to plunge into the river. Ever since, a phantom train has been heard periodically on the abandoned track. It is said to kill anyone who looks upon it.

With that, he reluctantly leaves them. As the passengers make themselves as comfortable as they can, they hear footsteps outside. Richard opens the door, and Hodgkin collapses into the room. Dr. Sterling pronounces him dead. Later, a terrified young woman in black (Linden Travers) appears. She, Julia, pleads for help, saying that someone is pursuing her. A car spins off the road and crashes into a tree. The driver is unhurt, but his car is damaged. Back in the waiting room, he introduces himself as John Price (Raymond Huntley) and explains that he is searching for his sister Julia, who he says suffers from delusions. Julia protests that he is lying. Price further explains that she thought she had seen the ghost train, and became obsessed with it ever since. The passengers tell him that Hodgkin has died. When Price insists on seeing the body, they discover it has mysteriously vanished.

Price leaves to arrange transportation. Then an approaching train is heard. As it thunders past, Julia smashes a window to look at it, then screams and faints. They hear singing from the nearby railway tunnel mouth. Julia claims that Ben Isaacs (D. J. Williams), the sole survivor of the accident, is coming back. Teddy shoots at the "ghost", causing it to flee back into the tunnel, leaving behind a bloodstained cloth.

Teddy shows the others the cloth and orders the others, at gunpoint, to stay put until the police arrive, but Richard punches him, knocking him out. The passengers carry him to the bus Price has obtained. When Teddy comes to, he is furious with Richard, as now there will be no one to intercept the train on its return journey. When Gander remarks that he had returned the bridge to the open position, Dr. Sterling suddenly orders the bus driver to stop, while his confederate, Price, produces his own gun. Sterling orders the driver to turn back so they can warn the train.

Meanwhile, guns are being loaded aboard the "ghost train"; a very much alive Hodgkin flags the train off and climbs aboard. Teddy explains that the train is really being used by Nazi fifth columnists to secretly transport arms. While Price heads down the embankment with Julia and the driver to try to stop the train, Teddy knocks Sterling out and gains control of the situation. The train plunges into the river.

Cast
Arthur Askey as Tommy Gander
Richard Murdoch as Teddy Deakin
Kathleen Harrison as Miss Bourne
Peter Murray-Hill as R. G. Winthrop
Carole Lynne as Jackie Winthrop
Morland Graham as Dr. Sterling
Betty Jardine as Edna
Stuart Latham as Herbert
Herbert Lomas as Saul Hodgkin
Raymond Huntley as John Price
Linden Travers as Julia Price
D. J. Williams as Ben Isaacs
 George Merritt as Inspector
 Sidney Monckton as Train Guard
 Wallace Bosco as Ted Holmes
 William Thomas Jones as the chauffeur

Production
The first sound film version was released in 1931 with Jack Hulbert. The Askey version was announced in August 1939. The script had to be rewritten to accommodate Askey; the actions of Hulbert's part were divided between the comic star and Richard Murdoch.

Filming did not proceed immediately; in January 1941 reports said Carol Reed would direct and Edward Black would produce. Eventually the job of directing went to Walter Forde who had made the earlier sound version.

Filming began in February 1941. It was an early role for Carole Lynn who had been discovered dancing on the West End. Shooting took place at the Lime Grove Studios in Shepherd's Bush, with sets designed by the art director Alex Vetchinsky. Some location shots were also taken around Teignmouth and Dawlish Warren in Devon.

Reviews
The Monthly Film Bulletin  described it as "a classy thriller".

Sight & Sound called it "funnier and more ghostly than the original".

In the 21st century, TV Guide.com noted the film was "good for a few laughs and a couple of chilling surprises."

Soundtrack
Arthur Askey – "The Seaside Band" (Written by Kenneth Blain)  –  (UK DECCA F 9944 10" 78 rpm shellac PICTURE LABELS)

References

External links

The Ghost Train at TCMDB

1940s comedy horror films
1940s mystery thriller films
1941 horror films
British comedy horror films
British black-and-white films
British films based on plays
Films directed by Walter Forde
Films set in Cornwall
Gainsborough Pictures films
Rail transport films
Films with screenplays by Marriott Edgar
British mystery thriller films
1941 comedy films
1941 films
Films scored by Walter Goehr
1940s English-language films
1940s British films

The Ghost Train (1941 film)


Raster graphics is one of the two different kinds of computer graphics. Raster graphics are also called bitmap graphics.

With raster graphics, images are made of many tiny dots. The dots are called pixels.

The individual pixels of a raster image each has its own color.

The problem with raster graphics is that they can look blurry when zoomed in on. Therefore, there is another type of graphics called Vector graphics that work differently.

A computer monitor is a good example of a raster image because it is made of pixels. The number of pixels it has is called the resolution of the monitor. Another example is photographs, which are normally raster images.
Many printers today use computer languages like Postscript or PCL. These languages are usually based on the other type of computer graphics, called vector graphics.

But to be printed, these images need to be translated into raster graphics first.

This is done by a part called a Raster Image Processor. Most modern printers have those processors inside the printer. Some printers use a special piece of software on the computer to do that job.

References

Computer graphics

Raster graphics


Die Abreise (The Departure) is a comic opera in one act by composer Eugen d'Albert. The libretto was written by Ferdinand Sporck, a friend of the composer, after a play by August Ernst Steigentesch.

Composition history
Eugen d'Albert composed the opera in 1896. The score was published by  in 1898, and is now available from Boosey & Hawkes.

Performance history
The opera was first performed 20 October 1898 at the Alte Oper in Frankfurt, under the baton of Ludwig Rottenberg.

Roles

Synopsis
Time and place: The garden hall of a summer residence in central Germany, at the end of the 18th century.

Gilfen and Luise have been married for many years, and the passion in their relationship has dimmed considerably. Gilfen has been planning to undertake a long journey, but he has postponed his departure every time because he was afraid his wife would take advantage of the situation. And so, he never departed.

Trott, a friend of the couple, is in love with Luise, so it is easily understood why he advises his friend to finally undertake the long planned journey. Gilfen (who has guessed Trott's motives) plays along and takes leave from his wife, faking his departure. Trott immediately seizes the opportunity, but Luise rejects him.

Gilfen then returns to find (much to his surprise and delight) that his wife has been faithful to him. Now it is Trott's turn to leave. Gilfen and Luise finally have time for each other again and they decide to renew their love.

Recordings
In 1998 CPO released a recording made in 1978 at the . János Kulka conducted the Philharmonia Hungarica; the singers were Hermann Prey (Gilfen), Edda Moser (Luise) and Peter Schreier (Trott).

Notes

Further reading
 : Opera – Komponisten, Werke, Interpreten (Könemann, 2000, Dutch translation)

External links

Operas by Eugen d'Albert
1898 operas
Operas set in Germany
Operas set in the 18th century
One-act operas
German-language operas
Operas
Operas based on plays

Die Abreise


Jules Blanchard (25 May 1832 – 2 May 1916) was a French sculptor.

Blanchard was born in Puiseaux. He was the son-in-law of sculptor Denis Foyatier. He was a student of François Jouffroy.  Blanchard is perhaps best known for his renovation of the Fontaine du Palmier in the Place du Châtelet, Paris.

Selected works

 La Bocca della verità (La bouche de la vérité) (1871), statue, marble, Paris, Jardin du Luxembourg
 Andromède (Salon de 1892), statue,  Paris, Jardin du Luxembourg
 La Science (commande de 1882), statue, bronze, Paris, by the Hôtel de Ville, Paris
 Boccador, Paris, by the Hôtel de Ville
 Four caryatids, on the facade of the Hôtel de Ville
 Un jeune équilibriste (Salon de 1866), plaster
 Jeune Fille parlant au Sphinx, mairie de Puiseaux

1832 births
1916 deaths
20th-century French sculptors
20th-century French male artists
19th-century French male artists
19th-century French sculptors
French male sculptors

Jules Blanchard


"They Only Come Out at Night" is the fourth single from Lordi's third album, The Arockalypse, and is one of the band's five singles that has not been made into a music video (along with "My Heaven is Your Hell", "Beast Loose in Paradise", "Deadache", and "Rock Police").

Overview
Udo Dirkschneider guest stars in the song. Although a promo version was released by Lordi's German record label, Drakkar Entertainment, it hasn't appeared in stores. Instead, the promo single was handed out at some events in Germany in February 2006. The B-side of the Finnish version is a cover of the Accept song, "Midnight Mover", which was recorded in 2003 in a radio studio during a live broadcast. The song charted at number six in Finland.

Track lists
Finnish edition
 "They Only Come Out at Night" (featuring Udo Dirkschneider) – 3:37
 "Midnight Mover (live)" – 3:26

German promo version
 "They Only Come Out at Night"
 "Supermonstars"

References

2007 singles
Lordi songs
2006 songs
Sony BMG singles

They Only Come Out at Night (Lordi song)


Richard Stephen Dreyfuss ( ; né Dreyfus; born October 29, 1947) is an American actor. He is known for starring in popular films during the 1970s, 1980s, and 1990s, including American Graffiti (1973), Jaws (1975), Close Encounters of the Third Kind (1977), The Goodbye Girl (1977), The Competition (1980), Stand by Me (1986), Down and Out in Beverly Hills (1986), Stakeout (1987), Nuts (1987), Always (1989), What About Bob? (1991), and Mr. Holland's Opus (1995).

Dreyfuss won the Academy Award for Best Actor in 1977 for The Goodbye Girl (at the time, the youngest-ever actor—age 30–to win), and was nominated in the same category for Mr. Holland's Opus in 1995. He is the recipient of a Golden Globe and a BAFTA, and was nominated for two Screen Actors Guild Awards in 2002; for his starring role in the CBS drama series The Education of Max Bickford, and his portrayal of Alexander Haig in the Showtime film The Day Reagan Was Shot, respectively.

Early life
Dreyfuss was born on October 29, 1947, in Brooklyn, New York, the second and younger son of Norman Dreyfuss (1920–2013), an attorney, restaurateur and plastics company owner originally from a "violent gang culture in Brooklyn", and Geraldine ( Robbins; 1921–2000), a peace activist. He is the second child of three children. He had an older brother, Lorin Dreyfuss (1944-2021), who was an actor, film producer and screenplay writer, and a younger sister, Cathy. His father Norman suffered from the debilitating physical effects of a mortar explosion at the Battle of the Bulge in World War II, requiring the use of crutches, canes, and special footwear provided by the Army for the rest of his life. He left the family when his son was 21 years old, and remarried more than once; he and his son were not on speaking terms at the time of his death.

Dreyfuss was raised in the Bayside area of Queens, New York. His family is Jewish, descended from immigrants from Russia and Poland; the Dreyfuss family was from Rzeszow. He has commented that he "grew up thinking that Alfred Dreyfus and [he] are from the same family" and that his great-grand aunt was Hesya Helfman, one of the assassins of Tsar Alexander II of Russia and the only one to escape execution for the deed. His father disliked New York, and moved the family first to Europe, and later to Los Angeles, California, when Dreyfuss was nine. Dreyfuss attended Beverly Hills High School.

Career

Dreyfuss began acting in his youth, at Temple Emanuel of Beverly Hills Arts Center and the Westside Jewish Community Center, under drama teacher Bill Miller. He debuted in the TV production In Mama's House, when he was fifteen. He attended San Fernando Valley State College, now California State University, Northridge, for a year, and was a conscientious objector during the Vietnam War, working in alternate service for two years, as a clerk in a Los Angeles hospital. During this time, he acted in a few small TV roles on shows such as Peyton Place, Gidget, That Girl, Gunsmoke, Bewitched, The Ghost & Mrs. Muir, and The Big Valley. He played a larger role  in an episode in the second season of Judd, for the Defense. During the late 1960s and early 1970s, he also performed on stage on Broadway, Off-Broadway, repertory, and improvisational theater.

Dreyfuss appeared in the play The Time of Your Life, which was revived on March 17, 1972, at the Huntington Hartford Theater in Los Angeles, and directed by Edwin Sherin.

Dreyfuss's first film role was a small, uncredited appearance in The Graduate. He had one line, "Shall I get the cops? I'll get the cops." He was also briefly seen as a stagehand in Valley of the Dolls (1967), in which he had a few lines. In 1973 he starred in the CBS pilot Catch-22. He appeared in the subsequent Dillinger, and landed a role in the 1973 hit American Graffiti, acting with other future stars such as Harrison Ford and Ron Howard. Dreyfuss played his first lead role in the Canadian film The Apprenticeship of Duddy Kravitz (1974), receiving positive reviews, including praise from Pauline Kael.

Dreyfuss went on to star in box office blockbusters Jaws (1975) and Close Encounters of the Third Kind (1977), both directed by Steven Spielberg. He won the 1978 Academy Award for Best Actor at the 50th Academy Awards ceremony for his portrayal of a struggling actor in The Goodbye Girl (1977), becoming the youngest actor to do so (at the age of 30 years, 125 days old), besting Marlon Brando, who had won his first Oscar in 1955 at the age of 30 years, 360 days old. This record stood for 25 years until it was broken in 2003 by Adrien Brody, who was three weeks shy of age 30 at the time of the 75th Academy Awards ceremony. Dreyfuss is still, however, the shortest to have ever won Best Actor, standing at about 5 foot 4¼ inches tall. In five years, between 1973 and 1978, the films that Dreyfuss appeared in grossed upwards of $900 million.

Around 1978, Dreyfuss began using cocaine frequently; he claims to not remember anything from the production of the 1981 film Whose Life Is It Anyway?. His addiction came to a head in 1982, when he was arrested for possession of the drug after he blacked out while driving, and his Mercedes-Benz 450 SL struck a tree. He entered rehabilitation and eventually made a Hollywood comeback with the films Down And Out In Beverly Hills in 1986 and Stakeout the following year. Dreyfuss had an important supporting role in the Rob Reiner movie Stand by Me, a 1986 coming-of-age drama/comedy film adapted from Stephen King's novella The Body. Dreyfuss plays the elder Gordie Lachance (played by his Buddy System co-star Wil Wheaton), who narrates the film. In 1988, he reunited with director Paul Mazursky to star in the political farce Moon over Parador.

In 1989, Dreyfuss reunited with Spielberg on Always, a remake of A Guy Named Joe in which he co-starred with Holly Hunter. He had a starring role opposite Bill Murray in the 1991 comedy What About Bob?, as a psychiatrist driven to insanity by a particularly obsessive new patient. That same year, Dreyfuss produced and starred as Georges Picquart in Prisoner of Honor, an HBO movie about the historical Dreyfus Affair.

In 1994, he participated in the historic Papal Concert to Commemorate the Shoah at the Vatican in the presence of Pope John Paul II, Rav Elio Toaff, chief rabbi of Rome, and Oscar Luigi Scalfaro, President of the Italian Republic. He recited Kaddish as part of a performance of Leonard Bernstein's Third Symphony with the Royal Philharmonic Orchestra under the baton of Gilbert Levine. The event was broadcast worldwide.

Dreyfuss was nominated for an Oscar and a Golden Globe for his performance as Glenn Holland in Mr. Holland's Opus (1995). Since then, he has continued working in movies, television and the stage. In 2001–2002, he played Max Bickford in the television drama The Education of Max Bickford. In April 2004, he appeared in the revival of Sly Fox on Broadway (opposite Eric Stoltz, René Auberjonois, Bronson Pinchot and Elizabeth Berkley).

In 1997, Dreyfuss recorded a voiceover for the Apple Computer "Think Different" ad campaign, and also provided the voice of the narrator in The Call of the Wild: Dog of the Yukon.

Dreyfuss spent four years as a research adviser at St Antony's College, Oxford, from 2004 until 2008. In November 2004, he was scheduled to appear in The Producers in London, but withdrew from the production a week before opening night. The media noted that Dreyfuss was still suffering from problems relating to an operation for a herniated disc in January, and that the part of Max Bialystock in the play is a physically demanding one. Both he and his assistant for the production stated that Dreyfuss was accumulating injuries that required him to wear physical therapy supports during rehearsals. After Dreyfuss was officially let go from the production he was replaced by Nathan Lane. He ultimately made his West End debut at The Old Vic in 2009.

In 2006, he appeared as Richard Nelson, a gay architect and one of the survivors in the film Poseidon. Dreyfuss portrayed U.S Vice President Dick Cheney in Oliver Stone's 2008 George W. Bush bio-pic W.

In early 2009, he appeared in the play Complicit by Joe Sutton at London's Old Vic theatre. The production was directed by the theatre's artistic director, Kevin Spacey. Dreyfuss's performance was subject to some controversy, owing to his use of an earpiece onstage, reportedly because of his inability to learn his lines in time. According to an article published in 2017, Kevin Spacey groped one of Dreyfuss's sons while the three of them were alone in Spacey's apartment, an allegation that a lawyer representing Kevin Spacey denied. Richard Dreyfuss was focused on learning the lines of his script at the time and did not notice any harassment
. He guest-voiced as himself in the "Three Kings" episode of Family Guy in 2009, and later appeared again in the episode "Peter-assment". Dreyfuss guest starred in the sixth season of Weeds as Warren Schiff, Nancy's high school teacher to whom she had lost her virginity.

In 2010 he played Matt Boyd in Piranha 3D.

Dreyfuss was inducted as a "star" on the Hollywood Walk of Fame on October 10, 1996. It is located at 7021 Hollywood Blvd.

Dreyfuss was among 99 other stars at the 2012 Academy Awards – Night of 100 Stars. He did an interview for the Bill Zucker Show with actor/singer Bill Zucker.

In 2014 he appeared with best-selling Abraham Lincoln scholar Ronald C. White in a documentary entitled "Lincoln's Greatest Speech", highlighting Lincoln's Second Inaugural Address, appearing as host of the program and reciting Lincoln's speech on camera.

On February 18, 2015, it was announced that Dreyfuss would portray Bernie Madoff in the miniseries Madoff. The first episode was telecast on February 3, 2016, co-starring Blythe Danner.

On September 25, 2017, it was announced that The Last Laugh will be headlined by Richard Dreyfuss, Chevy Chase and Andie MacDowell, and it was released on Netflix on January 11, 2019.

Other work

The Dreyfuss Civics Initiative
Dreyfuss seeks to revive civics education to teach future generations about the power of their citizenship and the principles that hold America together. In 2006, he created The Dreyfuss Civics Initiative (TDCI). TDCI is a 501(c)3 designated organization, recognized as of 2008.

On February 16, 2006, he spoke at The National Press Club in Washington, D.C., in hopes of prompting a national discussion on impeachment charges against U.S. President George W. Bush. On November 17, 2006, Dreyfuss appeared on HBO's Real Time with Bill Maher as a panel member to discuss teaching Civics in schools. In 2007, Dreyfuss appeared in the youth voting documentary film 18 in '08.

Politics
Dreyfuss has been outspoken regarding the media's influence in shaping public opinion, policy, and legislation. In the 2000s, he expressed his sentiments in favor of right to privacy, freedom of speech, democracy, and individual accountability. In 2011 and 2014, Dreyfuss was elected to the Common Cause National Governing Board.

In May 2023, Dreyfuss spoke out against the Academy Awards' new diversity guidelines that require films to have met at least two of four benchmarks, including that the lead actors are from underrepresented groups or that at least 30% of the cast and crew come from these groups. During an interview with Margaret Hoover, host of the PBS show The Firing Line, Dreyfuss claimed that the new guidelines "make me vomit". Dreyfuss explained that he was opposed to the guidelines because movie-making is "an art form ... and no one should be telling me as an artist that I have to give into the latest, most current idea of what morality is."

Books and articles
In 1995, Dreyfuss co-authored with science-fiction writer Harry Turtledove the book The Two Georges, a novel set in the year 1995 of a timeline in which the American Revolution was peacefully avoided.  In 2002, he authored One Thought Scares Me...: We Teach Our Children What We Wish Them to Know; We Don't Teach Our Children What We Don't Wish Them to Know about the teaching of civics in American schools

Personal life

Dreyfuss married writer and producer Jeramie Rain in the early 1980s, and they had three children: Emily (born 1983), Benjamin (born 1986), and Harry (born 1990). Benjamin was born with Peters Anomaly, a rare genetic eye disorder which, despite many operations, left him blind in his left eye. Dreyfuss and Rain have continued to raise money for ophthalmology centers throughout the United States. After his 1995 divorce from Rain, Dreyfuss married Janelle Lacey in 1999. They divorced in 2005.

In 2006, Dreyfuss discussed his diagnosis of bipolar disorder in the documentary Stephen Fry: The Secret Life of the Manic Depressive, in which Fry (who also has the disorder) interviewed Dreyfuss about his experience being bipolar.

Dreyfuss and Russian-born Svetlana Erokhin married in 2006 and as of February 2020 they live in San Diego, California, although they have frequently visited New York City, London, and Sun Valley, Idaho, where Dreyfuss once lived. They also lived in Carlsbad, California. In February 2008, they bought a $1.5 million house in Encinitas, California, intending to renovate the 1970s structure with green technologies.

During his acting career, Dreyfuss had feuds with some of the people he worked with, most notably actors Robert Shaw and Bill Murray, who costarred with him in Jaws and What About Bob? respectively, and filmmaker Oliver Stone, who directed him in W.

Allegation of sexual harassment
In 2017, writer Jessica Teich accused Dreyfuss of sexual harassment during the filming of an ABC special. Dreyfuss denied the allegations. He said he had been overly flirtatious in his past, and that he regretted that behavior, but he emphasized that he "value[s] and respect[s] women" and is "not an assaulter".

Filmography

Awards and nominations

Books
 Dreyfuss, Richard. (2022) One Thought Scares Me...: We Teach Our Children What We Wish Them to Know; We Don't Teach Our Children What We Don't Wish Them to Know.  New York: Skyhorse Publishing.
 Dreyfuss, Richard (with Harry Turtledove). (1996) The Two Georges.  New York: Tor Books.

References

External links

THR: Richard Dreyfuss finds 'Happiness'
The Dreyfuss Initiative
 Richard Dreyfuss interview on BBC Radio 4 Desert Island Discs, May 14, 1999

1947 births
Living people
20th-century American male actors
21st-century American male actors
American conscientious objectors
American male film actors
American male television actors
American Ashkenazi Jews
Best Actor Academy Award winners
Best Actor BAFTA Award winners
Best Musical or Comedy Actor Golden Globe (film) winners
Beverly Hills High School alumni
Comedians from California
David di Donatello winners
Jewish agnostics
Jewish American male actors
Jewish pacifists
Male actors from Los Angeles
People from Bayside, Queens
Male actors from Brooklyn
People with bipolar disorder
People from Sun Valley, Idaho
National Arts Club Medal of Honor Recipients

Richard Dreyfuss


Yevgeny Alexandrovich Morgunov (; April 27, 1927 – June 25, 1999) was a Soviet and Russian actor, film director, and script writer, Merited Artist of Russian SFSR (1978).

Early life
He started out as a worker in a Moscow factory, but - "a little naive and obsessed with becoming an actor" - he wrote a letter to Joseph Stalin about his dream. Morgunov reportedly received a reply from Stalin that said that a place was allocated for him in the acting class at the State Institute of Cinematography. Morgunov launched his film career while still a student.

Career
Yevgeny Morgunov was one of Russia's leading comic actors. "Plump and bald," Morgunov often "represented a traditional character of Soviet satire - Byvaly, or Experienced, a slightly dull, strong-built drunk whose attempts to commit petty crimes always failed."

Although his acting career was not limited to comedies, he was best known for his work in a comic trio in a series of films by Leonid Gaidai, with Yuri Nikulin as Fool (Balbes), and Georgy Vitsin as Coward (Trus). Their best-known films together were Operation Y and Other Shurik's Adventures and Prisoner of the Caucasus, or Shurik's New Adventures. Morgunov's character named Experienced (Byvaly) was always the "tight-lipped and aggressive leader of the group". Reportedly, "the three symbolized exactly what Soviet men were not supposed to be - drunk, unemployed and inclined toward mischief." In one of the legendary scenes in Caucasian Kidnapping Experienced gives lessons on how to dance the twist - by putting out cigarette butts with his feet.

However, after his triumphant role of "Byvaly" Morgunov was not much into filming. His best works included those in films Three Fat Men (Tri tolstyaka) (1966), Ilf and Petrov Went by Tram (Ekhali v tramvaye Ilf i Petrov) (1972). There were also other, less noteworthy roles. Morgunov also tried his wings as a film director. As early as 1962, he directed the comedy When the Cossacks Weep (Kogda Kazaki plachut) under the patronage of the illustrious writer Michail Sholokhov. However, the film remained his only director's work.

In 1993, Morgunov was featured in American-Russian adventure film My Family Treasure (Russian: Сокровище моей семьи) directed by Rolfe Kanefsky and Edward Staroselsky alongside Dee Wallace.

Morgunov's popularity was not far behind that of his partner Nikulin, a famous actor and clown of the Moscow Circus.

Morgunov is buried at the Kuntsevo Cemetery.

Selected filmography
 Six P.M. (1944)
  It Happened in the Donbass (1945)
 The Young Guard (1948)
 Brave People (1950)
 Hostile Whirlwinds (1953)
 Othello (1956)
 Destiny of a Man (1959)
 Resurrection (1960)
 Dog Barbos and Unusual Cross (1961)
 Scarlet Sails (1961)
 Bootleggers (1961)
 When the Cossacks Weep (1963)
 A Tale of Lost Times (1964)
 Give me a complaints book (1965)
 Operation Y and Shurik's Other Adventures (1965)
 Three Fat Men (1966)
 Kidnapping, Caucasian Style (1967)
 Seven Old Men and a Girl (1968)
 Ilf and Petrov Rode a Tram (1972)
 Unbelievable Adventures of Italians in Russia  (1973)
 Northern Rhapsody  (1974)
 Circus in the Circus (1976)
 The Pokrovsky Gate (1982)
 Simply Awful! (1982)
 Yeralash (1984)
 Act, Manya! (1991)

References
Biography at the peoples.ru site

External links

 Biography of Yevgeny Morgunov

Russian male film actors
Soviet male film actors
Russian male comedians
Male actors from Moscow
Gerasimov Institute of Cinematography alumni
Burials at Kuntsevo Cemetery
1927 births
1999 deaths
Honored Artists of the RSFSR
20th-century comedians

Yevgeny Morgunov