SIMULA(ID:170/sim052)SIMUlation LAnguagefor SIMUlation LAnguage. Kristen Nygaard & Ole-Johan Dahl, designed 1962, implemented 1964. Extension to ALGOL 60 for the Univac 1107, for discrete simulation. Added two new structures to Algol - SIMULA processes (which became objects) and SIMULA activities (which became methods). Control of these passed to the Executive system at runtime. Coroutines. "UNIVAC developed the 1107, its secondgeneration scientific computer, between 1960 and 1962. There was much talk about ALGOL being its primary language [...] Case Institute of Technology in Cleveland provided an ALGOL compiler for the EXEC II environment, as part of the arrangement by which it acquired an 1107. The Case Tech compiler was completed in 1964, and computer science students there were trained in ALGOL, rather than FORTRAN [...] In 1962 Bob Bemer became aware of the SIMULA language which had been proposed by Kristen Nygaard and Ole-Johan Dahl of the Norwegian Computing Center. SIMULA was designed for the analysis of systems which can be modeled as a series of events, such as a service counter serving a line of customers. In 1963 UNIVAC agreed to provide an 1107 to the Norwegian Computing Center at a discounted price in exchange for the development of SIMULA as an extension to the Case Tech ALGOL. The 1107 was delivered in August 1963, and the first version of SIMULA was completed in December 1964. " People: Hardware:
Structures: Related languages
References: in Popplewell, Cicely M. (Ed.) Information Processing 62, Proceedings of the 2nd IFIP Congress, Munich, Aug. 1962. North Holland Publ. Co., 1963. view details in Proceedings of the Third International Conference Operation Research view details in Proceedings of the Third International Conference Operation Research view details in Proceedings of the Third International Conference Operation Research view details in Proceedings of the Third International Conference Operation Research view details in Proceedings of the Third International Conference Operation Research view details in Hollingdale, S.M. (ed.) "Digital Simulation in Operations Research", English Universities Press, London, 1965 view details in Hollingdale, S.M. (ed.) "Digital Simulation in Operations Research", English Universities Press, London, 1965 view details in [ACM] CACM 9(09) September 1966 view details in [ACM] CACM 9(10) October 1966 view details SIMULA SIMULA, developed at the Norwegian Computer Center at Oslo under contract with Univac, satisfies the need for studying complex systems stemming from modern technological development. It facilitates the numerous methods for planning, predicting, and decision making in all forms of research and practice. SIMULA, a simulator based on ALGOL as a subset (they even share a common compiler), provides a language to describe a wide class of phenomena. It provides a programming language for generating (through a compiler) simulation programs which are used to analyze a series of instantaneous events in a complex system (known as a discrete event system) associated with the phenomena. With proper formulation, this definition encompasses most physical/logical systems dependent on time. Control is achieved by the Executive system. The language is built around a few basic concepts selected to provide the research worker with a standardized approach to a wide class of problems. These concepts are integrated into the language in a way that makes it readable; hence, the language also serves as a useful tool for communication. A SIMULA program describes a sequence of events rather than a set of permanent relationships. For example, the permanent relationship viewpoint of a store counter for serving a line of customers is that the customers are passive entities acted upon by the store clerk (a series of service completions). The drawback to this viewpoint is that interactions between passive entities cannot be studied (for example, impatient customer steps ahead in line in reaction to slow customers ahead of him). By subordinating the formation of permanent relationships, SIMULA permits the modeling of a great variety of decision rules and interactions between system entities. The range of variation in decision rules and interactions between system components is so great that it is necessary to let the language contain a general algorithmic language. This is an important reason why ALGOL, which has a compatible block structure, was chosen. In contrast with analytical methods, which offer more complete and reliable information than the statistical inference from a simulated sample of system runs, simulation enables the study of problems of greater complexity, and both transient and stationary states of systems may be analyzed whereas the analytical approach often is limited to stationary states. SIMULA's statistical gathering statements have some semiautomatic output reporting routines, and the programmer has all the features of ALGOL available for gathering particular types of statistical simulation data and generating other types of reports. in [ACM] CACM 9(10) October 1966 view details in Buxton, J. ed.: Simulation Programming Languages. Proceedings from the IFIP Working Conference in Oslo, May 1967, North Holland, 1968. view details in ACM Computing Reviews 9(02) February 1968 view details [321 programming languages with indication of the computer manufacturers, on whose machinery the appropriate languages are used to know. Register of the 74 computer companies; Sequence of the programming languages after the number of manufacturing firms, on whose plants the language is implemented; Sequence of the manufacturing firms after the number of used programming languages.] in ACM Computing Reviews 9(02) February 1968 view details Simula. Simula, an extension of Algol developed at the Norwegian Computing Center by O.-J. Dahl and K. Nygaard, is process-oriented: A process (user) continues until it is prevented from execution. An operative process is considered "active"; a queued or suspended process is considered "passive." Simula contains recursiveness, list-processing capability, and allows complete user access to Algol. An advanced version, also called Simula, is a general-purpose scientific language containing simulation capability. in Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972 view details in [ACM] CACM 15(07) (July 1972) view details in Computers & Automation 21(6B), 30 Aug 1972 view details in Computers & Automation 21(6B), 30 Aug 1972 view details in Computers & Automation 21(6B), 30 Aug 1972 view details The exact number of all the programming languages still in use, and those which are no longer used, is unknown. Zemanek calls the abundance of programming languages and their many dialects a "language Babel". When a new programming language is developed, only its name is known at first and it takes a while before publications about it appear. For some languages, the only relevant literature stays inside the individual companies; some are reported on in papers and magazines; and only a few, such as ALGOL, BASIC, COBOL, FORTRAN, and PL/1, become known to a wider public through various text- and handbooks. The situation surrounding the application of these languages in many computer centers is a similar one. There are differing opinions on the concept "programming languages". What is called a programming language by some may be termed a program, a processor, or a generator by others. Since there are no sharp borderlines in the field of programming languages, works were considered here which deal with machine languages, assemblers, autocoders, syntax and compilers, processors and generators, as well as with general higher programming languages. The bibliography contains some 2,700 titles of books, magazines and essays for around 300 programming languages. However, as shown by the "Overview of Existing Programming Languages", there are more than 300 such languages. The "Overview" lists a total of 676 programming languages, but this is certainly incomplete. One author ' has already announced the "next 700 programming languages"; it is to be hoped the many users may be spared such a great variety for reasons of compatibility. The graphic representations (illustrations 1 & 2) show the development and proportion of the most widely-used programming languages, as measured by the number of publications listed here and by the number of computer manufacturers and software firms who have implemented the language in question. The illustrations show FORTRAN to be in the lead at the present time. PL/1 is advancing rapidly, although PL/1 compilers are not yet seen very often outside of IBM. Some experts believe PL/1 will replace even the widely-used languages such as FORTRAN, COBOL, and ALGOL.4) If this does occur, it will surely take some time - as shown by the chronological diagram (illustration 2) . It would be desirable from the user's point of view to reduce this language confusion down to the most advantageous languages. Those languages still maintained should incorporate the special facets and advantages of the otherwise superfluous languages. Obviously such demands are not in the interests of computer production firms, especially when one considers that a FORTRAN program can be executed on nearly all third-generation computers. The titles in this bibliography are organized alphabetically according to programming language, and within a language chronologically and again alphabetically within a given year. Preceding the first programming language in the alphabet, literature is listed on several languages, as are general papers on programming languages and on the theory of formal languages (AAA). As far as possible, the most of titles are based on autopsy. However, the bibliographical description of sone titles will not satisfy bibliography-documentation demands, since they are based on inaccurate information in various sources. Translation titles whose original titles could not be found through bibliographical research were not included. ' In view of the fact that nany libraries do not have the quoted papers, all magazine essays should have been listed with the volume, the year, issue number and the complete number of pages (e.g. pp. 721-783), so that interlibrary loans could take place with fast reader service. Unfortunately, these data were not always found. It is hoped that this bibliography will help the electronic data processing expert, and those who wish to select the appropriate programming language from the many available, to find a way through the language Babel. We wish to offer special thanks to Mr. Klaus G. Saur and the staff of Verlag Dokumentation for their publishing work. Graz / Austria, May, 1973 in Computers & Automation 21(6B), 30 Aug 1972 view details Extract: SIMULA The process concept, as typified by GPSS and by the original SIMULA (Dahl and Nygaard, 1966), is a method of discretely simulating concurrency in the real world, and is nonprocedural because the details of the sequencing and scheduling of processes is hidden from the programmer. This style of programming, using primitives such as ACTIVATE, HOLD, WAIT and TERMINATE (in SIMULA) has been called quasiparallel programming (Knuth, 1968). in Proceedings of the ACM SIGPLAN symposium on Very high level languages, March 28-29, 1974, Santa Monica, California, United States view details in SIGPLAN Notices 14(04) April 1979 including The first ACM SIGPLAN conference on History of programming languages (HOPL) Los Angeles, CA, June 1-3, 1978 view details in SIGPLAN Notices 14(04) April 1979 including The first ACM SIGPLAN conference on History of programming languages (HOPL) Los Angeles, CA, June 1-3, 1978 view details in SIGPLAN Notices 14(04) April 1979 including The first ACM SIGPLAN conference on History of programming languages (HOPL) Los Angeles, CA, June 1-3, 1978 view details DOI in TOPLAS 2(4) October 1980 view details in TOPLAS 2(4) October 1980 view details After introductory remarks, Jean Sammet, the Conference and Program Committee Chairman, introduces the keynote speaker and "the third programmer of the first large scale digital computer, Mark I," Capt. Grace Hopper of the US Navy. Capt. Hopper describes the very early history -- combining personal recollections and technical observations. It is an excellent historical talk, precisely establishing the milieu existing in the 1940s and early 50s, when the concept of using a computer to create programs was just emerging. The FORTRAN presentation by John Backus emphasizes the importance of object efficiency for FORTRAN acceptance. He states that language design was never considered a problem; the real problem was to consistently produce object programs as efficient as hand-coded ones. The presentation captures the clear and unwavering focus of Backus's original team on that goal: a focus and dedication which characterized the direction of one of the most significant software projects in the history of computers. The controversies in the committee designing ALGOL 60 are re-enacted in miniature on these tapes. Alan Perlis describes the American contributions, concluding that ALGOL has Influenced all languages since that time. "It's the mother's milk of us all." Peter Naur describes the European contributions and the origins of recursion in the language. A lively floor discussion involving John McCarthy, John Backus, and Fritz Bauer ensues. The Algol 60 committee got involved in "academic log rolling" according to McCarthy who also points out that the committee decision not to consider implementation led to a language which was not implementable as a whole. It was assumed that "everyone was a gentleman and none would propose something he didn't know how to implement. However there was no guarantee the combination was implementable." The excerpt on the LISP lecture by John McCarthy emphasizes the features of the language and is an excellent description of its intellectual sources. Jean Sammet in presenting COBOL also clearly defines the influences on the language and how and why the choices were made in a series of committee meetings. These choices were very much colored by the decision to take "a short range composite approach good for at least a year or two." The tapes show how differently some of these important languages developed. According to Douglas Ross, APT evolved out of application requirements; by contrast, the major features of JOVIAL were developed in a few minutes, relates Jules Schwartz, its sole designer. Geoffrey Gordon tells how GPSS also grew from feedback from application users. SIMULA, developed by Kristen Nygaard and Ole-Johan Dahl, didn't even start as a programming language. Charles Baker discusses the development of JOSS, and Thomas Kurtz, BASIC -- intended to make learning to program analogous to learning to drive a car: by doing it. PL/I was the largest language represented at the conference. According to presenter, George Radin, much of the complexity and size is due to the necessity of defining the result of all operations on mixed types and to implicit typing. The excerpts of the presentations on SNOBOL by Ralph Griswold and APL by Kenneth Iverson establish the specific motivations for those languages: in both cases conserving human resources was considered very important. The conference banquet tapes contain anecdotes by the conference speakers and by master of ceremonies Bernard Galler. These entertaining historical asides and footnotes sometimes give more insight into the how and why things happened than the more scholarly analyses. For example, George Radin's story about the PL/I committee's ordering pizza -- the pizza had everything anyone wanted -- says a great deal about how the committee functioned when designing the language. These tapes constitute an important historical record. Unfortunately, the quality of the tapes is less than desired. They were not professionally produced and the picture quality is often quite poor. Still-photos by Robert McClure and Richard Wexelblat are used where the videotape is inadequate. However, the excerpts have been well selected by J.A.N. Lee, Jean Sammet, and Henry Tropp. In his summary Fred Brooks says that "the best thing about this conference is the character set." He also points out that the presentations on the languages designed by a committee emphasized the process, whereas the presentations on single-author languages emphasized technical issues. These tapes capture the factors that have made the history: the personalities, the process, and the technology. They are interesting now and will be invaluable to future historians of the pioneering period of language development. in ACM Computing Reviews March 1982 view details in ACM Computing Reviews March 1982 view details in The Computer Journal 25(1) 1984 view details It is a difficult book to review adequately. One must ask if it conveys the same message to that vast majority of information processing specialists who were not in the business at the time of the events recounted as it does to those of us who played an active role in some of the developments as they happened. Judicious inquiry of younger readers of the book suggests that rather more of the informal flavor comes through than one might suspect at first. In that sense the book "tells it like it was," although some of the text makes it quite clear that programming language designers have the same kind of selective and prismatic memories that other people have. The plan of the book is straightforward. Thirteen specific languages were selected by the conference organizers, and the book contains, for each language: a formal paper; a transcript of the presentation; a transcript of remarks by a designated discussant; a transcript of a subsequent question and answer session; the full text of all questions submitted; a biography of the authors. In addition there is the full text of the Keynote Address presented by Captain Grace Murray Hopper, itself required reading, and a series of appendices, including summaries of each language. As stated in the introductory material on the organization of the conference, the criteria for selection of the languages to be included were: "that the languages 1) were created and in use by 1967; 2) remain in use in 1977; and 3) have had considerable influence on the field of computing." The 1967 cutoff was to insure at least ten years perspective. The result of applying these criteria was: ALGOL 60 APL APT BASIC COBOL FORTRAN GPSS JOSS JOVIAL LISP PL/I SIMULA SNOBOL This general review cannot pursue the specific language chapters; that is a task for individual reviews elsewhere in CR. Some overall comments are in order, however. The formal papers are not simply personal recollections of the authors. An organized procedure was established to guide each author in preparing an account according to established historical practice, thus maximizing the archival value of the papers. It appears to have worked, for the authors systematically -- and in some cases, apparently, painfully -- searched for old records, letters, and memoranda. The vignettes that surface therefrom are fascinating. No one should be surprised that the accounts of the camel (designed by committee) languages, ALGOL 60 and COBOL, have a somewhat different flavor from the others. There is a gold mine for students of decision making processes in this book. The conference organizers are to be commended for providing two accounts of ALGOL 60, one from the American and one from the European point of view. The contrasting perceptions and the almost recursive discussion are both intriguing and delightful. This reviewer's one regret is that it was impossible to capture and document the conversations that occurred over the coffee cups and in the corridors. In summary, this is a superb book, a must for all computer professionals. It is also one of the very few records of a conference of any sort where the reader gets a feeling for what it was like to actually be there. This reviewer was there and reading this book almost four years after the conference brought back delightful memories with preternatural clarity. in ACM Computing Reviews March 1982 view details The particular interests of the authors show in the variety of organization and emphasis found in the papers. John Backus describes the background of the FORTRAN project, some of the design decisions, the documentation and implementation. Alan Perlis emphasizes the many people involved in the ALGOL design, from before 1958, through the Zurich and Paris meetings, culminating in ALGOL 60. Peter Naur concentrates on the design decisions made between the Zurich and Paris meetings. The disagreements which surface in appendices to his paper make for fascinating reading. Kristen Nygaard describes the many changes which the design of SIMULA went through from 1961 through 1971, from SIMULA I to SIMULA 67. The book is not a dry history -- many statements seem particularly surprising in hindsight. John Backus says of FORTRAN, "As far as we were aware, we simply made up the language as we went along. We did not regard language design as a difficult problem, merely a simple prelude to the real work of designing a compiler which could produce efficient programs." Jean Sammet stresses with regard to COBOL, "We were going to recommend a short range composite approach good for at least the next year or two." The history of the technical decisions is particularly well researched and presented. Many ideas were taken directly from other languages, such as the separation of the data description and executable statements in COBOL, deriving from FLOW-MATIC. Some seemed to occur almost casually, such as Thomas Kurtz commenting on the design of BASIC, "Around 1960 or 1961, after a visit to the PDP-1 time-shared computer at MIT, I can clearly recall John McCarthy saying, 'Why don't you guys do time sharing?' Shortly afterward I said to Kemeny, 'I think we ought to do time sharing.' Kemeny responded, 'OK.' And that was that!" Other decisions stemmed from deadlocks, as Alan Perlis described, when a European member of the ALGOL committee declared "No! I will never use a period for a decimal point." The proposal from Joseph Wegstein for three levels of language calmed the situation. The ALGOL paper and appendices by Peter Naur present different views of the same experience. Even a project consisting of only two people can produce its share of excitement. Kristen Nygaard describes the shock of a switchboard operator at overhearing a violent argument between two men in a hallway. She was reassured that it was just Dahl and Nygaard discussing SIMULA. One thing which emerges from many of the papers is the deep involvement which a language design can elicit from its designers. John Backus and Jean Sammet both describe many late, long hours. But this book is not just a series of papers by knowledgeable authors. It is itself a history of the History of Programming Languages Conference held in Los Angeles in 1978. Jean Sammet, the General Chairman, describes how the conference was put together. There are many valuable ideas here for potential conference organizers. The Conference Historian, Henry Tropp, provides a historical perspective and suggests archiving of design papers. The keynote address is by Grace Hopper. Its transcript captures the qualities of innovation and humor which make her talks such an experience. The author talks are based on the papers, so there is much redundancy of material. The main value to be gained by the duplication is the opportunity to discover the human side of the authors, which comes out in the more informal relation to the audience. Jean Sammet brings down the house with her lament that students are not given more than a passing exposure to COBOL before they receive their degrees in computer science. The question and answer sessions were often as interesting as the talks. The book gives John Backus's answer to the question why the letters I through N were chosen to designate integers. The readability of these sections attest to the effort which Richard Wexelblat put into the editing of this volume. The History of Languages represents a tremendous amount of effort from a great many people, and is a book which programmers as well as language designers will find both instructive and enjoyable. in ACM Computing Reviews March 1982 view details in ACM Computing Reviews March 1982 view details in The 16th Winter Simulation Conference 28-30 November 1984 Sheraton Dallas Hotel, Dallas, TX view details The Computer Question The event that would eventually propel the SIMULA project off the paper occurred in 1962 and would eventually also represent the solution to NCC's computer problems. In April 1961 NCC received an informal proposal from the Danish Computing Center in Copenhagen regarding possible future cooperation.[14] At the time, the Computing Centre's director Nils Ivar Beck, had ideas for a large network of Scandinavian computing centers called the Scandinavian Electronic System. According to the Danish proposition, NCC could, within a few years, become part of this network and would in the short run benefit from such cooperation in several ways. From the point of view of NTNF and NCC's board, the Danish proposition seemed to offer the ideal solution to NCC's most immediate problems, and after a few preliminary meetings during 1961, informal relations between the two computing centers were thus established. From Nygaard's point of view it was tacitly understood that when he and NCC's director, Bjørn Ørjansen were given the task of drawing up a report on NCC's immediate computer needs, they should conclude by recommending a GIER from the Danish Computing Center.[15] GIER was a recognized medium-sized computer, but in Nygaard and Ørjansen's opinion not the ideal solution for NCC's immediate needs, nor for the benefit of Norwegian informatics in the long run. What they wanted was a real mainframe like English Electric's KDF-9. However, this computer was, at the time, far beyond NCC's financial reach, and consequently they settled for GIER. Based on the conclusions in the Nygaard and Ørjansen report, NTNF decided in February 1962 that NCC should order a GIER from Denmark, and granted 2 mill. NOK. ($280,112) for this purpose.[16] This was roughly the situation when another important actor, the Univac Division of the Sperry Rand Corporation, entered the stage towards the end of May 1962. In connection with the marketing of their brand-new computers UNIVAC III and UNIVAC 1107, the company arranged an executive tour to the United States for prospective European customers. Kristen Nygaard was invited to participate on behalf of NCC.[17] Now, at this point let us briefly recapitulate the status on the SIMULA project. As mentioned earlier, the SIMULA concept had, by May 1962, reached a state of semi-maturity, and Dahl and Nygaard felt that they now had a presentable language concept at hand. The preliminary groundwork was done, and it was time to seek out financial resources. As reported by Dahl and Nygaard in 1981,[18] there was no initial enthusiasm for SIMULA in NCC's environment, i.e., apart from the valuable moral support given by the board of NCC. The main objection according to them was that there would be no use for a programming language like SIMULA, and if by any chance there was, such a language certainly existed already. Furthermore it was asserted that their ideas were not good enough, and that they in general lacked the competence needed to embark upon such an extensive project, which for these reasons would never be completed. Finally it was maintained that this kind of work should not be performed in small countries like Norway. From these statements it should be evident that gathering financial support from the Research Council, would indeed be a difficult and protracted mission. Fortunately though, other options existed, and in an attempt to reverse Univac's sales mission Kristen Nygaard decided to introduce SIMULA to the Americans. As soon as the party arrived in New York, he contacted the Univac Europe representative James W. Nickitas and presented him with SIMULA and another NCC software project on linear programming.[19] Nickitas found Nygaard's ideas interesting, and agreed to set up a meeting with a few influential representatives from Univac's software division. Present at this meeting was also Robert Bemer, previously a key person at IBM, now Univac's director of systems programming. Bemer recalls that: It was just after I started with UNIVAC that I met a Kristen Nygaard of the Norwegian Computing Center, Oslo. He told me about his project SIMULA. My yearly budget for Systems Programming was about $8 million at that time, for in the neighborhood of 325 people. Dr. Rader had advised me that 5% of that money was my discretion, to do what ever I thought would benefit UNIVAC most! It happened that I was organizing and chairing a session at the IFIP Conference in Munich that August, to which Nygaard's project was a close fit. I invited him to give a paper at that session. It caught my interest, and I wanted SIMULA for the 1107 software repertoire (ALGOL was also in the repertoire, which I could never have made happen at IBM, but at UNIVAC I was RUNNING [sic] the show!). [20] Bemer had been a sworn ALGOL 60 fan all along and as he listened to Nygaard explaining his ideas for an ALGOL-based simulation language, he became more and more convinced that SIMULA's sophisticated simulation facilities would significantly benefit ALGOL 60 in it's struggle with FORTRAN.[21] By the end of the meeting Bemer announced that he was to chair a session at the IFIP 62 World Congress in Munich, and that he very much wanted a presentation of SIMULA for this occasion. Nygaard immediately accepted this offer as he realized the significance of such an opportunity.[22] The presentation of SIMULA at the IFIP conference first of all implied an important step toward consolidation of the language concepts. Furthermore, it offered a suitable setting for the introduction of SIMULA, and simultaneously provided Dahl and Nygaard with an important entry to the distinguished community of computer professionals. Even though Kristen Nygaard had managed to draw professional attention to SIMULA, the vital question of financial support was still unsettled. At this point, however, Univac started to move. In connection with the marketing of the UNIVAC 1107, the company needed a demonstration site in Europe as soon as possible. In this regard, Kristen Nygaard must have made quite an impression on the Univac people and really succeeded in convincing them of NCC's professional qualities, because upon his return to Norway, Nickitas approached him with an informal proposal for Univac to establish this demonstration site at NCC. The deal was that the demonstration site should serve promotional purposes for Univac, and NCC would get a 50% discount on an eventual purchase. In return for this generous offer however, Univac wanted NCC to provide them with SIMULA and an implementation of the linear programming system developed by Sverre Spurkland.[23] in Annals of the History of Computing 16(1) Spring 1994 view details MAD was developed at the University of Michigan in 195960 for the IBM 704. It was very widely used on the IBM 7090 and 7094, the Philco 2000, and UNIVAC 1100 computers during the 1960s for the purpose of teaching programming to college students. Michigan published a reference manual, but most students learned MAD from the MAD PRIMER, written by Elliott Organick of the University of Houston and distributed by Ulrichs Book Store of Ann Arbor, Michigan. Organick also wrote a more widely used FORTRAN PRIMER. The MAD compiler for the UNIVAC 1100 computers called RALPH was developed at the University of Maryland. The name RALPH is an acronym of sorts: Reentrant Algorithmic Language Processor with H just for the H of it. (The explanation of the acronym is supplied by George Baltz, formerly at the University of Maryland.) The RALPH processor could compile either FORTRAN or MAD, depending on the option selected. MAD is perhaps most famous for the line printer picture of Alfred E. Neumann which was printed when an attempted compilation had too many errors. Underneath the picture it printed the caption: See this man about your program--He might want to publish it. He never worries--but from the looks of your program, you should. MAD faded from the scene in the 1970s. A very simple MAD program follows: INTEGER A START A = 1 WHENEVER A .G. 0 PRINT COMMENT $ A GTR 0$ OTHERWISE PRINT COMMENT $A LEQ 0$ END OF CONDITIONAL PRINT COMMENT $ END $ END OF PROGRAM The WHENEVER OTHERWISE END OF CONDITIONAL is equivalent to an if-else statement External link: Online copy at UNISIS History in Annals of the History of Computing 16(1) Spring 1994 view details in Annals of the History of Computing 16(1) Spring 1994 view details in Annals of the History of Computing 16(1) Spring 1994 view details |