- Author:
- Per Brinch Hansen
From the Preface
CONCURRENT PROGRAMMING
This book describes a method for writing concurrent computer programs of high quality. It is written for professional programmers and students who are faced with the complicated task of building reliable computer operating systems or real-time control programs.
The motivations for mastering concurrent programming are both economic and intellectual. Concurrent programming makes it possible to use a computer where many things need attention at the same time--be they people at terminals or temperatures in an industrial plant. It is without doubt the most difficult form of programming.
This book presents a systematic way of developing concurrent programs in a structured language called Concurrent Pascal--the first of its kind. The use of this language is illustrated by three non-trivial concurrent programs: a single-user operating system, a job-stream system, and a real-time scheduler. All of these have been used successfully on a PDP 11/45 computer. The book includes the complete text of these three programs and explains how they are structured, programmed, tested, and described.
In an earlier book, Operating System Principles [Prentice-Hall, 1973], I tried to establish a background for studying existing operating systems in terms of basic concepts. This new text tells the other side of the story: how concurrent programs can be constructed systematically from scratch. It also illustrates details of important design problems--the management of input/output, data files, and programs--which were deliberately omitted from the first book. So it is useful both as a practical supplement to operating system courses and also as a handbook on structured concurrent programming for engineers.
COMPILATION AND TESTING
A concurrent program consists of sequential processes that are carried out simultaneously. The processes cooperate on common tasks by exchanging data through shared variables. The problem is that unrestricted access to the shared variables can make the result of a concurrent program dependant on the relative speeds of its processes. This is obvious if you think of a car and a train passing through the same railroad crossing : it is the relative timing of these "processes" that determines whether they will collide.
Unfortunately, the execution speed of a program will vary somewhat from one run to the next. It will be influenced by other (unrelated) programs running simultaneously and by operators :responding to requests. So you can never be quite sure what an incorrect, concurrent program is going to do. If you execute it many times with the same data you will get a different result each time. This makes it hopeless to judge what went wrong. Program testing is simply useless as a means of locating time-dependent errors.
Some of these errors can no doubt be located by proofreading. I have seen a programmer do this by looking at an assembly language program for a week. But, to proofread a large program, you must understand it in complete detail. So the search for an error may involve all of the people who wrote the program, and even then you cannot be sure it will be found.
Well, if we cannot make concurrent programs work by proofreading or testing, then I can see only one other effective method at the moment: to write all concurrent programs in a programming language that is so structured that you can specify exactly what processes can do to shared variables and depend on a compiler to check that the programs satisfy these assumptions. Concurrent Pascal is the first language that makes this possible.
In the long run it is not advisable to write large concurrent programs in machine-oriented languages that permit unrestricted use of store locations and their addresses. There is just no way we will be able to make such programs reliable (even with the help of complicated hardware mechanisms).
CONCURRENT PASCAL
From 1963-65 I was one of ten programmers who wrote a Cobol compiler in assembly language. This program of 40,000 instructions took 15 man-years to build. Although it worked well, the compiler was very difficult to maintain since none of us understood it completely.
Five years later, compiler writing was completely changed by the sequential programming language Pascal, invented by Niklaus Wirth. Pascal is an abstract language that hides irrelevant machine detail from the programmer. At the same time it is efficient enough for system programming. It is easily understood by programmers familiar with Fortran, Algol 60, Cobol, or PL/I.
In 1974 A1 Hartmann used Sequential Pascal to write a compiler for my new programming language, called Concurrent Pascal. This compiler is comparable to a machine program of 35,000 instructions. But, written in Pascal, the program text is only 8,300 lines long and can be completely understood by a single person. The programming and testing of this compiler took only 7 months.
The aim of Concurrent Pascal is to do for operating systems what Sequential Pascal has done for compilers: to reduce the programming effort by an order of magnitude.
Concurrent Pascal extends Sequential Pascal with concurrent processes and monitors. The compiler prevents some time-dependent programming errors by checking that the private variables of one process are inaccessible to another. Processes can only communicate by means of monitors.
A monitor defines all the possible operations on a shared data structure. It can, for example, define the send and receive operations on a message buffer. The compiler will check that processes only perform these two operations on a buffer.
A monitor can delay processes to make their interactions independent of their speeds. A process that tries to receive a message from an empty buffer will, for example, be delayed until another process sends a message to it.
If a programmer can design a process or monitor correctly, the rest of a program will not be able to make that component behave erratically (since no other part of the program has direct access to the variables used by a component). The controlled access to private and shared variables greatly reduces the risk of time-dependent program behavior caused by erroneous processes.
MODEL OPERATING SYSTEMS
This book stresses the practice of concurrent; programming. It contains a complete description of three model operating systems written in Concurrent Pascal.
Chapter 5 describes a single-user operating system, called Solo. It supports the development of Sequential and Concurrent Pascal programs on the PDP 11/45 computer. Input/output are handled by concurrent processes. Pascal programs can call one another recursively and pass arbitrary parameters among themselves. This makes it possible to use Pascal as a job control language. Solo is the first major example of a hierarchical concurrent program made of processes and monitors.
Chapter 6 presents a job-stream system that compiles and executes short Pascal programs which are input from a card reader and are output on a line printer. Input, execution, and output take place simultaneously, using buffers stored on disk.
Chapter 7 discusses a real-time scheduler for process control applications in which a fixed number of concurrent tasks are carried out periodically with frequencies chosen by an operator.
These chapters not only describe how to build different kinds of operating systems but also illustrate the main steps of the program development process.
The Solo system shows how a concurrent program of more than a thousand lines can be structured and programmed as a sequence of components of less than one page each. The real-time scheduler is used to demonstrate how a hierarchical, concurrent program can be tested systematically. The job-stream system illustrates how a program structure can be derived from performance considerations.
LANGUAGE DEFINITION AND IMPLEMENTATION
I have tried to make this book as readable as possible to share an architectonic view of concurrent programming effectively. Formalism is often a stumbling block in the first encounter with a new field, and the practice of structured concurrent programming is not commonplace yet. So I have assumed in chapters 3 and 4 that you are so familiar with one or more programming languages that it is sufficient to show the flavor of Sequential and Concurrent Pascal by examples before describing the model operating systems.
But when you wish to use a new programming language in your own work, a precise definition of it becomes essential. So the Concurrent Pascal report is included in chapter 8.
The whole purpose of this work is to show how much a concurrent programming effort can be reduced by using an abstract language that suppresses as much machine detail as one can afford to without losing control of program efficiency. For this reason the introduction to Concurrent Pascal ignores the question of how the language is implemented.
Chapter 9 is an overview of the language implementation for those who feel uncomfortable unless they have a dynamic feeling for what their programs make the machine do. I suspect that most of us belong to that group. Once you understand what a machine does, however, it is easier to forget the details again and start relying completely on the abstract concepts that are built into the language.
TEACHING AND ENGINEERING
Very few operating systems are so well-structured and well-documented that they are worth studying in detail. And few (if any) computing centers make it possible for students to write their own concurrent programs in an abstract language. Since students can neither study nor build realistic operating systems it is almost impossible to make them feel comfortable about the subject.
This book tries to remedy that situation. It defines an abstract language for concurrent programming that has been implemented on the PDP 11/45 computer. The compiler can be moved to other computers since it is written in Sequential Pascal and generates code for a simple machine that can be simulated efficiently by microprogram or machine language.
The book also offers complete examples of model operating systems that can be studied by students.
If you are a professional programmer you can seldom choose your own programming language for large projects. But you can benefit from new language constructs--such as processes and monitors--by taking them as models of a systematic programming style that can be imitated as closely as possible in other languages (including assembly languages).
The system kernel that is described in chapter 9 illustrates this. It is an assembly language program written entirely by means of classes (a concept similar to monitors). Since this concept is not in the assembly language it is described by comments only.
The book can also be used as a handbook on the design of small operating systems and significant portions of larger ones.
If you are a software engineer you may feel that the operating systems described here are much smaller than those you are asked to build. This raises the question of whether the concepts used here can help you build huge systems. My recommendation is to use abstract programming concepts (such as processes and monitors) wherever you can. 'This will probably solve most programming problems in a simple manner and leave you with only a few really machine-dependent components (such as a processor scheduler and a storage allocator). As a means of organizing :your thoughts, Concurrent Pascal can only be helpful.
But I should also admit that I do not see a future for large operating systems. They never worked well and they probably never will. They are just too complicated for the human mind. They were the product of an early stage in which none of us had a good feeling for what software quality means. The new technology that supports wide-spread use of cheap, personal computers will soon make them obsolete.
Although operating systems have provided the most spectacular examples of the difficulty of making concurrent programs reliable, there are other applications that present problems of their own. As an industrial programmer I was involved in the design of process control programs for a chemical plant, a power plant, and a meteorological institute. These realtime applications had one thing in common: they were all unique in their software requirements.
When the cost of developing a large program cannot be shared by many users the pressure to reduce the cost is much greater than it is for generalpurpose software, such as compilers and operating systems. The only practical way of reducing cost then is to give the process control engineers an abstract language for concurrent programming. To illustrate this I rewrote an existing real-time scheduler from machine language into Concurrent Pascal (chapter 7).
The recent reduction of hardware costs for microprocessors will soon put even greater pressure on software designers to reduce their costs as well. So there is every reason for a realistic programmer to keep an eye on recent developments in programming methodology.
PROJECT BACKGROUND
In 1971, Edsger Dijkstra suggested that concurrent programs might be easier to understand if all synchronizing operations on a shared data structure were collected into a single program unit (which we now call a monitor).
In May 1972 I wrote a chapter on Resource Protection for Operating System Principles. I introduced a language notation for monitors and pointed out that resource protection in operating systems and type checking in compilers are solutions to the same problem: to verify automatically that programs only perform meaningful operations on data structures. My conclusion was that "I expect to see many protection rules in future operating systems being enforced in the cheapest possible manner by type checking at compile time. However, this will require exclusive use of efficient, well-structured languages for programming." This is still the idea behind Concurrent Pascal.
I developed Concurrent Pascal at the California Institute of Technology from 1972-75. The compiler was written by A1 Hartmann. Robert Deverill and Tom Zepko wrote the interpreter for the PDP 11/45. I built the model operating systems, and Wolfgang Franzen made improvements to one of them (Solo).
Chapters
- BELL, J. R., "Threaded code," Comm. ACM 16, 6, pp. 370-72, June 1973. Google Scholar
Digital Library
- BRINCH HANSEN, P., and HOUSE, R., "The Cobol compiler for the Siemens 3003," BIT 6, 1, pp. 1-23, 1966.Google ScholarCross Ref
- BRINCH HANSEN, P., "The RC 4000 real-time control system at Pulawy," BIT 7, 4, pp. 279-88, 1967.Google Scholar
- BRINCH HANSEN, P., "The nucleus of a multiprogramming system," Comm. ACM 13, 4, pp. 238-50, April 1970. Google ScholarDigital Library
- BRINCH HANSEN, P., "Testing a multiprogramming system," Software--Practice & Experience 3, 2, pp. 145-50, April-June 1973a.Google Scholar
- BRINCH HANSEN, P., "The Solo operating system," Software--Practice & Experience 6, 2, pp. 141-205, April-June 1976.Google Scholar
- CAMPBELL, R. H., and HABERMANN, A. N., The specification of process synchronization by path expressions. Computing Laboratory, University of Newcastle upon Tyne, Newcastle upon Tyne, England, Jan. 1974.Google Scholar
- DIJKSTRA, E. W., "Cooperating sequential processes," In Programming languages, F. Genuys (ed.), Academic Press, New York, NY, 1968.Google Scholar
- HARTMANN, A. C., A Concurrent Pascal compiler for minicomputers. Lecture Notes in Computer Science, Springer-Verlag, New York, NY, 1977.Google Scholar
- HOARE, C. A. R., "An axiomatic basis for computer programming," Comm. ACM 12, 10, pp. 576-80, 83, Oct. 1969.Google ScholarDigital Library
- HOARE, C. A. R., "Proof of a program: Find," Comm. ACM 14, 1, pp. 39--45, Jan. 1971.Google ScholarDigital Library
- HOARE, C. A. R., "Towards a theory of parallel programming," In Operating systems techniques, C. A. R. Hoare (ed.), Academic Press, New York, NY, 1972a.Google Scholar
- HOARE, C. A. R., "Proof of correctness of data representations," Acta Informatica 1, pp. 271-81, 1972b.Google ScholarDigital Library
- HOWARD, J. H., "Proving monitors," Comm. ACM 19, 5, pp. 273-79, May 1976.Google ScholarDigital Library
- IGARASHI, S., LONDON, R. L., and LUCKHAM, D. C., "Automatic program verification I: Logical basis and its implementation," Acta Informatica 4, 2, pp. 145-82, 1975.Google ScholarDigital Library
- LAMPSON, B. W., "An operating system for a single-user machine," Lecture notes in computer science 16, Springer-Verlag, New York, NY, pp. 208-17, 1974.Google Scholar
- NAUR, P., "The design of the Gier Algol compiler," BIT 3, 2-3, pp. 124-43 & 145-66, 1963.Google Scholar
- NORI, K. V., et al., The Pascal P compiler: implementation notes. Institut fiir Informatik, EidgenSssische Technische Hochschule, Zurich, Switzerland, Dec. 1974.Google Scholar
- OWICKI, S., and GRIES, D., "Verifying properties of parallel programs: an axiomatic approach," Comm. ACM 19, 5, pp. 279-85, May 1976.Google ScholarDigital Library
- STOY, J. E., and STRACHEY, C., "OS6--an experimental operating system for a small computer," Computer Journal 15, 2, p. 117, Feb. 1972.Google Scholar
- WIRTH, N., "The design of a Pascal compiler," Software--Practice & Experience 1, pp. 309-33, 1971.Google ScholarCross Ref
- WIRTH, N., Modula: a programming language for modular multiprogramming. Software--Practice and Experience 7, 2, March-April 1977.Google ScholarCross Ref
- WULF. W. A., Alphard: toward a language to support structured programming. Computer Science Department, Carnegie-Mellon University, Pittsburgh, PA, Apr. 1974.Google Scholar
- ALEXANDER, C., Notes on the synthesis of form. Harvard University Press, Cambridge, MA, 1964.Google Scholar
- BRONOWSKI, J., The ascent of man. Little, Brown and Company, Boston, MA, 1973.Google Scholar
- BROOKS, F. P., The mythical man-month. Essays on software engineering. Addison-Wesley, Reading, MA, 1975.Google Scholar
- ELSASSER, W. M., The chief abstractions of biology. American Elsevier, New York, NY, 1975.Google Scholar
- HARDY, G. H., A mathematician's apology. Cambridge University Press, New York, NY, 1967.Google Scholar
- LANGER, S. K., An introduction to symbolic logic. Dover Publications, New York, NY, 1967.Google Scholar
- MCNEILL, W. H., The shape of European history. Oxford University Press, New York, NY, 1974.Google Scholar
- SIMON, H. A., The sciences of the artificial. M.I.T. Press, Cambridge, MA, 1969.Google Scholar
- STRUNK, W., and WHITE, E. B., The elements of style. Macmillan, New York, NY, 1959.Google Scholar
- DAHL, O. J., DIJKSTRA, E. W., and HOARE, C. A. R., Structured programming. Academic Press, New York, NY, 1972. Google ScholarDigital Library
- HOARE, C. A. R., Hints on programming language design. Computer Science Department, Stanford University, Stanford, CA, Dec. 1973. Google ScholarDigital Library
- JENSEN, K., and WIRTH, N., "Pascal--user manual and report," Lecture notes in computer science 18, Springer-Verlag, New York, NY, 1974. Google ScholarDigital Library
- WIRTH, N., Systematic programming: an introduction. Prentice-Hall Inc., Englewood Cliffs, NJ, 1973. Google ScholarDigital Library
- WIRTH, N., Algorithms + data structures = programs. Prentice-Hall Inc., Englewood Cliffs, NJ, 1976a.Google Scholar
- WIRTH, N., Programming languages: what to demand and how to assess them. Institut far Informatik, Eidgenossische Technische Hochschule, Zurich, Switzerland, 1976b.Google Scholar
- BRINCH HANSEN, P., "Structured multiprogramming," Comm. ACM 15, 7, pp. 574-78, July 1972. Google ScholarDigital Library
- BRINCH HANSEN, P., Operating system principles. Prentice-Hall Inc., Englewood Cliffs, NJ, July 1973b. Google ScholarDigital Library
- BRINCH HANSEN, P., "The programming language Concurrent Pascal," IEEE Transactions on Software Engineering 1, 2, pp. 199-207, June 19'75.Google Scholar
- DAHL, O. J., DIJKSTRA, E. W., and HOARE, C. A. R., Structured programming. Academic Press, New York, NY, 1972. Google ScholarDigital Library
- DIJKSTRA, E. W., "Hierarchical ordering of sequential processes," Acta Informatica 1, 2, pp. 115-38, 1971.Google ScholarDigital Library
- HOARE, C. A. R., "Monitors: an operating system structuring concept," Comm. ACM 17, 10, pp. 549-57, Oct. 1974. Google ScholarDigital Library
Cited By
- Lusk E, Butler R and Pieper S (2018). Evolution of a minimal parallel programming model, International Journal of High Performance Computing Applications, 32:1, (4-13), Online publication date: 1-Jan-2018.
Schoeberl M, Korsholm S, Kalibera T and Ravn A (2011). A Hardware Abstraction Layer in Java, ACM Transactions on Embedded Computing Systems (TECS), 10:4, (1-40), Online publication date: 1-Nov-2011.- Orchard D The four Rs of programming language design Proceedings of the 10th SIGPLAN symposium on New ideas, new paradigms, and reflections on programming and software, (157-162)
- Black A, Hutchinson N, Jul E and Levy H The development of the Emerald programming language Proceedings of the third ACM SIGPLAN conference on History of programming languages, (11-1-11-51)
- Denning P and Tichy W Monitor, synchronization Encyclopedia of Computer Science, (1191-1192)
- Wand M (1999). Continuation-Based Multiprocessing Revisited, Higher-Order and Symbolic Computation, 12:3, (283-283), Online publication date: 1-Oct-1999.
- Hansen P Monitors and Concurrent Pascal History of programming languages---II, (121-172)
- Kleiman S and Eykholt J (1995). Interrupts as threads, ACM SIGOPS Operating Systems Review, 29:2, (21-26), Online publication date: 1-Apr-1995.
- Kim K, Bacellar L, Kim Y, Subbaraman C, Yoon H, Kim J and Rim K A timeliness-guaranteed kernel model-DREAM kernel-and implementation techniques Proceedings of the 2nd International Workshop on Real-Time Computing Systems and Applications
- Hansen P Monitors and concurrent Pascal The second ACM SIGPLAN conference on History of programming languages, (1-35)
- Hansen P (2019). Monitors and concurrent Pascal, ACM SIGPLAN Notices, 28:3, (1-35), Online publication date: 1-Mar-1993.
- Chang J Computer aided software engineering (CASE) based on transformation with object-oriented logic (TOOL) Proceedings of the 1992 ACM annual conference on Communications, (331-335)
- Higginbotham C and Morelli R A system for teaching concurrent programming Proceedings of the twenty-second SIGCSE technical symposium on Computer science education, (309-316)
- Higginbotham C and Morelli R (1991). A system for teaching concurrent programming, ACM SIGCSE Bulletin, 23:1, (309-316), Online publication date: 1-Mar-1991.
- Andersen B (1990). Ellie language definition report, ACM SIGPLAN Notices, 25:11, (45-64), Online publication date: 1-Nov-1990.
- Scott T and McBride R (1990). A programmer's guide to the Edison language, ACM SIGSMALL/PC Notes, 16:1, (14-23), Online publication date: 1-Feb-1990.
- Kim K and Welch H (2019). Distributed Execution of Recovery Blocks, IEEE Transactions on Computers, 38:5, (626-636), Online publication date: 1-May-1989.
- Bräunl T A specification language for parallel architectures and algorithms Proceedings of the 5th international workshop on Software specification and design, (49-51)
- Bräunl T (1989). A specification language for parallel architectures and algorithms, ACM SIGSOFT Software Engineering Notes, 14:3, (49-51), Online publication date: 1-May-1989.
- Bain W A global object name space for the Intel hypercube Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1, (570-574)
- Hsieh C and Unger E Resource scheduling Proceedings of the 1988 ACM sixteenth annual conference on Computer science, (429-437)
- Steier R (1987). Authors, Communications of the ACM, 30:9, (749-ff.), Online publication date: 1-Sep-1987.
- Ashenhurst R (1987). ACM forum, Communications of the ACM, 30:9, (752-753), Online publication date: 1-Sep-1987.
- Shub C (1987). The decline and fall of Operating Systems I, ACM SIGCSE Bulletin, 19:1, (217-220), Online publication date: 1-Feb-1987.
- Figueroa M (1987). The control of a toy robot ARM: a real time programming experience, ACM SIGCSE Bulletin, 19:1, (382-385), Online publication date: 1-Feb-1987.
- Shub C The decline and fall of Operating Systems I Proceedings of the eighteenth SIGCSE technical symposium on Computer science education, (217-220)
- Figueroa M The control of a toy robot ARM: a real time programming experience Proceedings of the eighteenth SIGCSE technical symposium on Computer science education, (382-385)
- Hsieh C and Unger E Manifolds Proceedings of the 15th annual conference on Computer Science, (196-204)
- Leu J, Agrawal D and Mauney J Modeling of parallel software for efficient computation communication overlap Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow, (569-575)
- Black A, Hutchinson N, Jul E and Levy H Object structure in the Emerald system Conference proceedings on Object-oriented programming systems, languages and applications, (78-86)
- Black A, Hutchinson N, Jul E and Levy H (2019). Object structure in the Emerald system, ACM SIGPLAN Notices, 21:11, (78-86), Online publication date: 1-Nov-1986.
- Gupta R and Soffa M (1985). The efficiency of storage management schemes for Ada programs, ACM SIGAda Ada Letters, V:2, (164-172), Online publication date: 1-Sep-1985.
- Gupta R and Soffa M The efficiency of storage management schemes for Ada programs Proceedings of the 1985 annual ACM SIGAda international conference on Ada, (164-172)
- Lees B (1985). Introductory concurrent programming with Modula-2, ACM SIGCSE Bulletin, 17:3, (34-41), Online publication date: 1-Sep-1985.
- Gupta R and Soffa M (1985). The efficiency of storage management schemes for Ada programs, ACM SIGPLAN Notices, 20:11, (30-38), Online publication date: 1-Nov-1985.
- Buhr R, Woodside C, Karam G, Van Der Loo K and Lewis D Experiments with Prolog design descriptions and tools in CAEDE Proceedings of the 8th international conference on Software engineering, (62-67)
- Zave P (1984). An overview of the PAISLey project-1984, ACM SIGSOFT Software Engineering Notes, 9:4, (12-19), Online publication date: 1-Jul-1984.
- Clemmesen M (1984). Interval arithmetic implementations, ACM SIGNUM Newsletter, 19:4, (2-8), Online publication date: 1-Oct-1984.
- Wittie L and Frank A A portable modula-2 operating system Proceedings of the July 9-12, 1984, national computer conference and exposition, (283-292)
- Leavens G (1984). Prettyprinting styles for various languages, ACM SIGPLAN Notices, 19:2, (75-79), Online publication date: 1-Feb-1984.
- Boyd S (1984). Free and bound generics, ACM SIGPLAN Notices, 19:3, (12-20), Online publication date: 1-Mar-1984.
- Zahniser R (1983). Levels of abstraction in the system life cycle, ACM SIGSOFT Software Engineering Notes, 8:1, (6-12), Online publication date: 1-Jan-1983.
- Hayashi T An operating systems programming laboratory course Proceedings of the fourteenth SIGCSE technical symposium on Computer science education, (31-35)
- Fornaro R, Garrard K and Uzzle E A structured approach to teaching operating systems principles using a high level concurrent programming language Proceedings of the fourteenth SIGCSE technical symposium on Computer science education, (41-49)
- Hayashi T (1983). An operating systems programming laboratory course, ACM SIGCSE Bulletin, 15:1, (31-35), Online publication date: 1-Feb-1983.
- Fornaro R, Garrard K and Uzzle E (1983). A structured approach to teaching operating systems principles using a high level concurrent programming language, ACM SIGCSE Bulletin, 15:1, (41-49), Online publication date: 1-Feb-1983.
- Kruijer H (1982). Processor management in a concurrent Pascal kernel, ACM SIGOPS Operating Systems Review, 16:2, (7-17), Online publication date: 1-Apr-1982.
- Dasgupta S and Olafsson M (2019). Towards a family of languages for the design and implementation of machine architectures, ACM SIGARCH Computer Architecture News, 10:3, (158-167), Online publication date: 1-Apr-1982.
- Santhanam V and Potochnik J Data abstraction for Pascal programmers Proceedings of the June 7-10, 1982, national computer conference, (595-603)
- Wakshull M (1982). The use of APL in a concurrent data flow environment, ACM SIGAPL APL Quote Quad, 13:1, (367-372), Online publication date: 1-Sep-1982.
- Wakshull M The use of APL in a concurrent data flow environment Proceedings of the international conference on APL, (367-372)
- Dixon D (1982). A Pascal compiler testing facility, ACM SIGPLAN Notices, 17:1, (23-26), Online publication date: 1-Jan-1982.
- Pokrass D and Wu B (1982). An operating systems project using structured methodology, ACM SIGCSE Bulletin, 14:3, (7-10), Online publication date: 1-Sep-1982.
- Dasgupta S and Olafsson M Towards a family of languages for the design and implementation of machine architectures Proceedings of the 9th annual symposium on Computer Architecture, (158-167)
- Hamer P and Frewin G M.H. Halstead's Software Science - a critical examination Proceedings of the 6th international conference on Software engineering, (197-206)
- Chiba K, Konishi K and Kurematsu A A model for description of communication protocol Proceedings of the 6th international conference on Software engineering, (424-425)
- Madsen J (1981). A computer system supporting data abstraction, ACM SIGOPS Operating Systems Review, 15:1, (45-72), Online publication date: 1-Jan-1981.
- Madsen J (1981). A computer system supporting data abstraction, ACM SIGOPS Operating Systems Review, 15:2, (38-78), Online publication date: 1-Apr-1981.
- Van Oost E (1981). Multi-processor system description and simulation using structured multi-programming languages, ACM SIGARCH Computer Architecture News, 9:2, (16-32), Online publication date: 1-Apr-1981.
- Bacon J (1981). An approach to distributed software systems, ACM SIGOPS Operating Systems Review, 15:4, (62-74), Online publication date: 1-Oct-1981.
- LaGarde J, Olivier G and Padiou G (1981). An operating system course project, ACM SIGCSE Bulletin, 13:2, (34-48), Online publication date: 1-Jun-1981.
- Brown D A State-Machine Synthesizer—SMS Proceedings of the 18th Design Automation Conference, (301-305)
- Azuma M, Takahashi M, Kamiya S and Minomura K Interactive software development tool Proceedings of the 5th international conference on Software engineering, (153-162)
- Zave P and Yeh R Executable requirements for embedded systems Proceedings of the 5th international conference on Software engineering, (295-304)
- Kunii T and Harada M SID Proceedings of the May 19-22, 1980, national computer conference, (33-40)
- Groves L and Rogers W The design of a virtual machine for Ada Proceedings of the ACM-SIGPLAN symposium on The ADA programming language, (223-234)
- Wand M Continuation-based multiprocessing Proceedings of the 1980 ACM conference on LISP and functional programming, (19-28)
- Wupit A Writing device drivers Proceedings of the 3rd ACM SIGSMALL symposium and the first SIGPC symposium on Small systems, (78-83)
- Schrage J Educator's view of structured concepts Proceedings of the ACM 1980 annual conference, (327-341)
- Hibbard P Multiprocessor software design Proceedings of the ACM 1980 annual conference, (527-536)
- Groves L and Rogers W The design of a virtual machine for Ada Proceedings of the ACM-SIGPLAN symposium on Ada programming language, (223-234)
- Wittle L and Van Tilborg A (1980). Micros, A Distributed Operating System for Micronet, A Reconfigurable Network Computer, IEEE Transactions on Computers, 29:12, (1133-1144), Online publication date: 1-Dec-1980.
- Groves L and Rogers W (2019). The design of a virtual machine for Ada, ACM SIGPLAN Notices, 15:11, (223-234), Online publication date: 1-Nov-1980.
- Unger B and Parker J (1979). An operating system implementation and simulation language (OASIS), ACM SIGMETRICS Performance Evaluation Review, 8:3, (151-161), Online publication date: 1-Sep-1979.
- Mattheyses R and Conry S (1979). Models for specification and anaysis of parallel computing systems, ACM SIGMETRICS Performance Evaluation Review, 8:3, (215-224), Online publication date: 1-Sep-1979.
- Unger B and Parker J (1979). An operating system implementation and simulation language (OASIS), ACM SIGSIM Simulation Digest, 11:1, (151-161), Online publication date: 1-Sep-1979.
- Mattheyses R and Conry S (1979). Models for specification and anaysis of parallel computing systems, ACM SIGSIM Simulation Digest, 11:1, (215-224), Online publication date: 1-Sep-1979.
- Crews P and Leventhal L (1979). Interactive microprogram validation, ACM SIGMICRO Newsletter, 10:4, (61-67), Online publication date: 1-Dec-1979.
- Appelbe B and Kroening M Concurrent programming on microcomputers Proceedings of the Second symposium on Small systems, (20-27)
- Appelbe B and Kroening M (1979). Concurrent programming on microcomputers, ACM SIGSMALL Newsletter, 5:2, (20-27), Online publication date: 1-Apr-1979.
- Grand A Issues in the design of concurrent programming languages Proceedings of the 1979 annual conference, (95-101)
- Unger B and Parker J An operating system implementation and simulation language (OASIS) Proceedings of the 1979 ACM SIGMETRICS conference on Simulation, measurement and modeling of computer systems, (151-161)
- Mattheyses R and Conry S Models for specification and anaysis of parallel computing systems Proceedings of the 1979 ACM SIGMETRICS conference on Simulation, measurement and modeling of computer systems, (215-224)
- Quick G (1979). Intelligent memory, ACM SIGARCH Computer Architecture News, 7:8, (23-28), Online publication date: 15-Jun-1979.
- Hunt J (1979). Messages in typed languages, ACM SIGPLAN Notices, 14:1, (27-45), Online publication date: 1-Jan-1979.
- Fosdick H (1979). High-level languages for operating systems development, ACM SIGPLAN Notices, 14:7, (31-37), Online publication date: 1-Jul-1979.
- Boehm B Software engineering-as it is Proceedings of the 4th international conference on Software engineering, (11-21)
- Cristian F A recovery mechanism for modular software Proceedings of the 4th international conference on Software engineering, (42-50.A)
- Campbell R and Kolstad R Path expressions in pascal Proceedings of the 4th international conference on Software engineering, (212-219)
- Crews P and Leventhal L Interactive microprogram validation Proceedings of the 12th annual workshop on Microprogramming, (61-67)
- Hansen P (1978). Distributed processes, Communications of the ACM, 21:11, (934-941), Online publication date: 1-Nov-1978.
- Hansen P (1978). Multiprocessor architectures for concurrent programs, ACM SIGARCH Computer Architecture News, 7:4, (4-23), Online publication date: 1-Dec-1978.
- Mohan C (1978). Survey of recent operating systems research, designs and implementations, ACM SIGOPS Operating Systems Review, 12:1, (53-89), Online publication date: 1-Jan-1978.
- Heimbigner D (1978). Writing device drivers in Concurrent Pascal, ACM SIGOPS Operating Systems Review, 12:4, (16-33), Online publication date: 1-Oct-1978.
- Shaw M, Feldman G, Fitzgerald R, Hilfinger P, Kimura I, London R, Rosenberg J and Wulf W Validating The Utility Of Abstraction Techniques Proceedings of the 1978 annual conference, (106-110)
- Hansen P Multiprocessor Architectures For Concurrent Programs Proceedings of the 1978 annual conference, (317-323)
Index Terms
- The architecture of concurrent programs
Recommendations
The translation of 'go to' programs to 'while' programs
Classics in software engineeringSome of the papers presented in this book already have been widely circulated; others were published in well-known journals, like IBM Systems Journal but largely were ignored when they first appeared; and then there are the obscure papers like this one ...
Safe optimisations for shared-memory concurrent programs
PLDI '11Current proposals for concurrent shared-memory languages, including C++ and C, provide sequential consistency only for programs without data races (the DRF guarantee). While the implications of such a contract for hardware optimisations are relatively ...
The heart of object-oriented concurrent programming
OOPSLA/ECOOP '88: Proceedings of the 1988 ACM SIGPLAN workshop on Object-based concurrent programmingConcurrency has been with us almost from the beginning of computing. Managing and programming for concurrency is a difficult problem and various solutions have been suggested over the years. Debates on message passing vs. remote procedure call, ...