An image of Heer de Beer

Heer de Beer.org

Exploring the Computational Medium

Bibliography

Huub de Beer

Abrahams, P. W. (1966). A final solution to the dangling else of ALGOL 60 and related languages. Commun. ACM, 9(9), 679–682. http://doi.org/10.1145/365813.365821
ACM. (2006). A. M. Turing Award. Retrieved from http://awards.acm.org/turing/
Alt, F. L. (1964). The standardization of programming languages. In Proceedings of the 1964 19th ACM national conference (pp. 22.1–22.6). New York, NY, USA: ACM Press. http://doi.org/10.1145/800257.808893
Arden, B. W., Galler, B. A., & Graham, R. M. (1961). The internal organization of the MAD translator. Commun. ACM, 4(1), 28–31. http://doi.org/10.1145/366062.366079
Aretz, F. E. J. K., Hagen, P. J. W. ten, & Oudshoorn, H. L. (1973). An ALGOL 60 compiler in ALGOL 60, text of the MC-compiler for the EL-X8. Amsterdam: Mathematisch Centrum.
Bachelor, G. A., Dempster, J. R. H., Knuth, D. E., & Speroni, J. (1961). SMALGOL-61. Commun. ACM, 4(11), 499–502. http://doi.org/10.1145/366813.366843
Backus, J. (1978). The history of FORTRAN i, II, and III. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 165–180). New York, NY, USA: ACM Press. http://doi.org/10.1145/800025.808380
Backus, J. (1980). Programming in america in the 1950s – some personal impressions. In N. Metropolis, J. Howlett, & G.-C. Rota (Eds.), A history of computing in the twentieth century (pp. 125–135). Academic Press.
Backus, John W. (1959). The syntax and semantics of the proposed international algebraic language of the zurich ACM-GAMM conference. In IFIP congress (pp. 125–131).
Backus, J. W., Bauer, F. L., Green, J., Katz, C., McCarthy, J., Perlis, A. J., … Woodger, M. (1960b). Report on the algorithmic language ALGOL 60. Commun. ACM, 3(5), 299–314. http://doi.org/10.1145/367236.367262
Backus, J. W., Bauer, F. L., Green, J., Katz, C., McCarthy, J., Perlis, A. J., … Woodger, M. (1960a). Report on the algorithmic language ALGOL 60. Numerische Mathematik, 2(1), 106–136.
Backus, J. W., Bauer, F. L., Green, J., Katz, C., McCarthy, J., Perlis, A. J., … Woodger, M. (1963). Revised report on the algorithm language ALGOL 60. Commun. ACM, 6(1), 1–17. http://doi.org/10.1145/366193.366201
Backus, J. W., Beeber, R. J., Best, S., Goldberg, R., Haibt, L. M., Herrick, H. L., … Nutt, R. (1957). The FORTRAN automatic coding system. In Proceedings of the western joint computer conference (pp. 187–198). Los Angeles, CA. Retrieved from http://web.mit.edu/6.035/www/papers/BackusEtAl-FortranAutomaticCodingSystem-1957.pdf
Backus, J. W., Beeber, R. J., Best, S., Goldberg, R., Herrick, H. L., Hughes, R. A., … Ziller, I. (1956). The FORTRAN automatic coding system for the IBM 704 EDPM: Programmer’s reference manual. Applied Science Division; Programming Research Department, International Business Machines Corporation. Retrieved from http://community.computerhistory.org/scc/projects/FORTRAN/704_FortranProgRefMan_Oct56.pdf
Barnett, M. P., & Futrelle, R. P. (1962). Syntactic analysis by digital computer. Commun. ACM, 5(10), 515–526. http://doi.org/10.1145/368959.368992
Bauer, F. L. (1964). Reply to comments by p.a. Samet and p.j. taylor. Commun. ACM, 7(7), 447. http://doi.org/10.1145/364520.364566
Bauer, F. L. (1976). Historical remarks on compiler construction. In G. Goos & J. Hartman (Eds.), Compiler construction. An advance course (Second, pp. 603–626). Springer Verlag.
Bauer, Friedrich L. (1980). Between zuse and rutishauser – the early development of digital computing in central europe. In N. Metropolis, J. Howlett, & G.-C. Rota (Eds.), A history of computing in the twentieth century (pp. 505–524). Academic Press.
Bauer, F. L. (1990). The cellar pronciple of state transition and storage allocation. Annals of the History of Computing, 12(1), 41–49.
Bauer, Friedrich L. (2002). From the stack principle to ALGOL. In M. Broy & E. Denert (Eds.), Software pioneers: Contributions to software engineering (pp. 26–42). Berlin: Springer.
Bauer, Friedrich L., & Samelson, K. (1959a). Sequentielle formelübersetzung. Elektronische Rechenanlagen, 1(1), 176–182.
Bauer, F. L., & Samelson, K. (1959). The cellar principle for formula translation. In Alan J. Perlis (Ed.), IFIP congress (pp. 154–155).
Bauer, Friedrich L., & Samelson, K. (1959b). The problem of a common language, especially for scientific numeral work. In IFIP congress (pp. 120–124).
Bauer, F. L., & Samelson, K. (1961). Comments on ALGOL 60 maintenance and revisions. ALGOL Bull., (12), 7–8. http://doi.org/10.1145/1060920.1060930
Bauer, F. L., & Samelson, K. (1962). The ALCOR project. In Gordon & Breach (Eds.), Symbolic languages in data processing, proceedings of the symposium, organized and edited by the international computation centre rome, march 26-31, 1962 (pp. 207–217). New York.
Bauer, F. L., & Wössner, H. (1972). The “plankalkül” of konrad zuse: A forerunner of today’s programming languages. Commun. ACM, 15(7), 678–685. http://doi.org/10.1145/361454.361515
Baumann, R. (1968). Algol-manual der alcor-gruppe: Einfuehrung in die algorithmische formelsprache ALGOL (Third). Muenchen: Oldenbourg.
Beer, H. de. (2004). Was SIMULA overbodig? Het ontstaan van het objectgeoriënteerdee programmeren als bijproduct van de opkomst van computersimulatie.
Bemer, R. W. (1958). The status of automatic programming for scientific problems. In F. C. Bock (Ed.), Computer applications: Annual symposium, 4th, 1957, chicago (pp. 107–117). Illinois Institute of Technology, Armour Research Foundation.
Bemer, R. W. (1959). A proposal for a generalized card code for 256 characters. Commun. ACM, 2(9), 19–23. http://doi.org/10.1145/368424.368435
Bemer, R. W. (1967). The programmer’s ALGOL: A complete reference. In C. P. Lecht (Ed.), (pp. vii–xiii). London: McGraw-Hill.
Bemer, R. W. (1969). A politico-social history of algol. In M. I. Halpern & C. J. Shaw (Eds.), Annual review in automatic programming (Vol. 5, pp. 151–237). London: Pergamon.
Bergin, T. (Ed.). (1997). HOPL II — closing panel: The history of programming (panel): Does our present past have a future? SIGPLAN Not., 32(9), 15–37. http://doi.org/10.1145/270507.270509
Breuer, H. (1966). Dictionary for computer languages (Vol. 6). London: Academic Press.
Bromberg, H. (Ed.). (1963). Survey of programming languages and processors. Commun. ACM, 6(3), 93–98.
Brooker, R. A., & Morris, D. (1960). An Assembly Program for a Phrase Structure Language. The Computer Journal, 3(3), 168–174. http://doi.org/10.1093/comjnl/3.3.168
Brooker, R. A., & Morris, D. (1961). Some Proposals for the Realization of a Certain Assembly Program. The Computer Journal, 3(4), 220–231. http://doi.org/10.1093/comjnl/3.4.220
Bumgarner, L. L., & Feliciano, M. (1963). ALCOR group representation of ALGOL symbols. Commun. ACM, 6(10), 597–599.
Campbell-Kelly, M. (1996). Computer: A history of the information machine. BasicBooks.
Cantor, D. G. (1962). On the ambiguity problem of backus systems. J. ACM, 9(4), 477–479. http://doi.org/10.1145/321138.321145
Centre, I. C. (Ed.). (1962). Symbolic languages in data processing. Proceedings of the symposium organized and edited by the international computation centre rome, march 26-31, 1962. London: Gordon; Breach Science Publishers.
Ceruzzi, P. E. (1998). Ahistory of modern computing. The MITPress.
Chipps, J., Koschmann, M., Orgel, S., Perlis, A., & Smith, J. (1956). A mathematical language compiler. In ACM ’56: Proceedings of the 1956 11th ACM national meeting (pp. 114–117). New York, NY, USA: ACM Press.
Chomsky, N. (1956). Three models for the description of language. Information Theory, IEEE Transactions on, 2(3), 113–124. Retrieved from http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1056813
Chomsky, Noam. (1959). On certain formal properties of grammars. Information and Control, 2(2), 137–167.
Conway, M. E. (1958). Proposal for an UNCOL. Commun. ACM, 1(10), 5–8. http://doi.org/10.1145/368924.368928
Conway, M. E. (1961). Letters to the editor: ALGOL 60 comment. Commun. ACM, 4(10), 465. http://doi.org/10.1145/366786.366810
Corrigenda: ALCOR group representation of ALGOL symbols. (1964). Commun. ACM, 7(3), 189.
Dahl, O. J. (1966). A plea for multi-programming. ALGOL Bull., (24), 26–27. http://doi.org/10.1145/1061073.1061081
Dahl, Ole-Johan. (2002). The roots of object-oriented programming:simula 67. In M. Broy & E. Denert (Eds.), Software pioneers: Contributions to software engineering (pp. 78–90). Berlin: Springer.
Dahlstrand, I. (1961). Suggestion on ALGOL 60 maintenance. ALGOL Bull., (12), 2–2. http://doi.org/10.1145/1060920.1060924
Dijkstra, E. W. (1960). Recursive programming. Numerische Mathematik, (2), 312–318.
Dijkstra, E. W. (1961). Letter to the editor: Defense of ALGOL 60. Commun. ACM, 4(11), 502–503. http://doi.org/10.1145/366813.366844
Dijkstra, E. W. (1963a). An ALGOL 60 translator for the X1. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 329–345).
Dijkstra, E. W. (1963b). Making a translator for ALGOL 60. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 347–356).
Dijkstra, Edsger W. (1968). Letters to the editor: Go to statement considered harmful. Commun. ACM, 11(3), 147–148. http://doi.org/10.1145/362929.362947
Dijkstra, Edsger W. (1970, April). Notes on Structured Programming. Retrieved from http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF
Dijkstra, Edsger W. (1972). The humble programmer. Retrieved from http://www.cs.utexas.edu/users/EWD/ewd03xx/EWD340.PDF
Dijkstra, Edsger W. (2002). From “goto considered harmful” to structured programming. In M. Broy & E. Denert (Eds.), Software pioneers: Contributions to software engineering (pp. 340–346). Berlin: Springer.
Dijkstra, Duncan, Garwick, Hoare, Randell, Seegmüller, … Garwick. (1970). Minority report. ALGOL Bull., (31), 7. http://doi.org/10.1145/1061500.1061502
Dreyfus, P. (1962). General panel discussion. Are extensions to ALGOL 60 necessary and if so what ones? In Symbolic languages in data processing (pp. 811–832). London: Gordon; Breach Science Publishers.
Duncan, Fraser G. (1963). ECMA subset of ALGOL 60. Commun. ACM, 6(10), 595–597.
Duncan, F. G., & Wijngaarden, A. van. (1964). Cleaning up ALGOL60. ALGOL Bull., (16), 24–32. http://doi.org/10.1145/1060960.1060966
Eickel, J., Paul, M., Bauer, F. L., & Samelson, K. (1963). A syntax controlled generator of formal language processors. Commun. ACM, 6(8), 451–455. http://doi.org/10.1145/366707.367583
Flamm, K. (1988). Creating the computer. The Brookings Institution.
Floyd, R. W. (1960). An algorithm defining ALGOL assignment statements. Commun. ACM, 3(3), 170–171. http://doi.org/10.1145/367149.367170
Floyd, R. W. (1961). An algorithm for coding efficient arithmetic operations. Commun. ACM, 4(1), 42–51. http://doi.org/10.1145/366062.366082
Floyd, R. W. (1962). On ambiguity in phrase structure languages. Commun. ACM, 5(10), 526. http://doi.org/10.1145/368959.368993
Floyd, R. W. (1963). Syntactic analysis and operator precedence. J. ACM, 10(3), 316–333. http://doi.org/10.1145/321172.321179
Floyd, R. W. (1964). The syntax of programming languages – a survey. IEEE Trans. Elec. Comp., 13, 346–353.
Galler, B. A. (1966). The for statement in ALGOL. ALGOL Bull., (22), 6–7. http://doi.org/10.1145/1061047.1061051
Galler, B. A., & Perlis, A. J. (1967). A proposal for definitions in ALGOL. Commun. ACM, 10(4), 204–219. http://doi.org/10.1145/363242.363252
Garwick, Jan V. (1964). Remark on further generalization of ALGOL. Commun. ACM, 7(7), 422–423. http://doi.org/10.1145/364520.364555
Garwick, J. V. (1965). Remarks on p naur’s new language proposals. ALGOL Bull., (19), 17–18. http://doi.org/10.1145/1060998.1061005
George O. Collins, Jr. (1961). Experience in automatic storage allocation. Commun. ACM, 4(10), 436–440. http://doi.org/10.1145/366786.366802
Gill, S. (1959). Current theory and practice of automatic programming. The Computer Journal, 2(3), 110–114. Retrieved from http://comjnl.oxfordjournals.org
Ginsburg, S., & Rice, H. G. (1962). Two families of languages related to ALGOL. J. ACM, 9(3), 350–371. http://doi.org/10.1145/321127.321132
Goodman, R. (1963). Annual review in automatic programming 3 (Vol. 11). London: Pergamon.
Goodman, R. (1964). Annual review in automatic programming 4 (Vol. 12). London: Pergamon.
Gorn, Saul. (1961a). Some basic terminology connected with mechanical languages and their processors: A tentative base terminology presented to ASA x3.4 as a proposal for subsequent inclusion in a glossary. Commun. ACM, 4(8), 336–339. http://doi.org/10.1145/366678.366682
Gorn, Saul. (1961b). Specification languages for mechanical languages and their processors a baker’s dozen: A set of examples presented to ASA x3.4 subcommittee. Commun. ACM, 4(12), 532–542. http://doi.org/10.1145/366853.366856
Gorn, Saul. (1963). Detection of generative ambiguities in context-free mechanical languages. J. ACM, 10(2), 196–208. http://doi.org/10.1145/321160.321168
Gorn, S. (Ed.). (1964a). Report on input-output procedures for ALGOL 60. Commun. ACM, 7(10), 628–630.
Gorn, S. (1964b). Report on SUBSET ALGOL 60 (IFIP). Commun. ACM, 7(10), 626–628.
Grau, A. A. (1961). Recursive processes and ALGOL translation. Commun. ACM, 4(1), 10–15. http://doi.org/10.1145/366062.366074
Grau, A. A. (1962). A translator-oriented symbolic programming language. J. ACM, 9(4), 480–487. http://doi.org/10.1145/321138.321146
Grau, A. A., Hill, U., & Langmaack, H. (1967). Translation of ALGOL60. (F. L. Bauer, A. S. Householder, F. W. J., F. W. J. Olver, H. Rutishauser, K. Samelson, & E. Stiefel, Eds.) (Vol. 1b). Berlin: Springer-Verlag.
Green, J. (1959a). Possible modification to the international algebraic language. Commun. ACM, 2(2), 6–8. http://doi.org/10.1145/368280.368285
Green, J. (1959b). Remarks on ALGOL and symbol manipulation. Commun. ACM, 2(9), 25–27. http://doi.org/10.1145/368424.368438
Griffiths, T. V., & Petrick, S. R. (1965). On the relative efficiencies of context-free grammar. Commun. ACM, 8(5), 289–300. http://doi.org/10.1145/364914.364943
Hawkins, E. N., & Huxtable, D. H. R. (1963). A multi-pass translation scheme for ALGOL 60. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 163–205).
Higman, B. (1963a). Towards an ALGOL translator. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 121–162).
Higman, B. (1963b). What EVERYBODY should know about ALGOL. The Computer Journal, 6(1), 50–56. Retrieved from http://comjnl.oxfordjournals.org
Hill, I. D. (1966). Remarks on “contribution to the development of ALGOL.” ALGOL Bull., (24), 28–32. http://doi.org/10.1145/1061073.1061082
Hill, I. D. (1967). For statements and the copy rule. ALGOL Bull., (25), 11–12. http://doi.org/10.1145/1061155.1061160
Hoare, C. A. R. (1964). Case expressions. ALGOL Bull., (18), 20–22. http://doi.org/10.1145/1060978.1060988
Hoare, C. A. R. (1965a). Cleaning up the for statement. ALGOL Bull., (21), 32–35. http://doi.org/10.1145/1061032.1061039
Hoare, C. A. R. (1965b). Record handling. ALGOL Bull., (21), 39–69. http://doi.org/10.1145/1061032.1061041
Hoare, C. A. R. (1967). File processing. ALGOL Bull., (25), 12–19. http://doi.org/10.1145/1061155.1061161
Hoare, Charles Antony Richard. (1981). The emperor’s old clothes. Commun. ACM, 24(2), 75–83. http://doi.org/10.1145/358549.358561
Hoare, C. A. R. (2002). Assertions: A personal perspective. In M. Broy & E. Denert (Eds.), Software pioneers: Contributions to software engineering (pp. 356–366). Berlin: Springer.
Hockney, R. W. (1961). A proposed extension to algol 60. ALGOL Bull., (Sup 12), 1–12. http://doi.org/10.1145/1064054.1064055
Holt, H. G. (1959). Code to translation systems. In Alan J. Perlis (Ed.), IFIP congress (p. 153).
Huskey, H. D. (1959). A variation of the ALGOL language. In Alan J. Perlis (Ed.), IFIP congress (p. 153).
Huskey, H. D. (1961). Compiling Techniques for Algebraic Expressions. The Computer Journal, 4(1), 10–19. http://doi.org/10.1093/comjnl/4.1.10
Huskey, Harry D., Halstead, M. H., & McArthur, R. (1960). NELIAC&a dialect of ALGOL. Commun. ACM, 3(8), 463–468. http://doi.org/10.1145/367368.367373
IBM, P. R. G. (1954). Preliminary report – specifications for the IBM mathematical FORmula TRANslating system FORTRAN. New York: IBM. Retrieved from http://community.computerhistory.org/scc/projects/FORTRAN/BackusEtAl-Preliminary Report-1954.pdf
Ingerman, P. (1962). A translation technique for languages whose syntax is expressible in extended backus nrmal form. In Symbolic languages in data processing (pp. 23–64). London: Gordon; Breach Science Publishers.
Ingerman, P. Z. (1961). Thunks: A way of compiling procedure statements with some comments on procedure declarations. Commun. ACM, 4(1), 55–58. http://doi.org/10.1145/366062.366084
Ingerman, Peter Zilahy. (1967). “Pänini-backus form” suggested. Commun. ACM, 10(3), 137. http://doi.org/10.1145/363162.363165
Irons, Edgar T. (1961). A syntax directed compiler for ALGOL 60. Commun. ACM, 4(1), 51–55. http://doi.org/10.1145/366062.366083
Irons, Edgar T. (1963a). An error-correcting parse algorithm. Comminications of the ACM, 6(11), 669–673.
Irons, Edgar T. (1963b). The structure and use of the syntax directed compiler. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 207–227).
Irons, E. T., & Acton, F. S. (1959). A proposed interpretation in ALGOL. Commun. ACM, 2(12), 14–15. http://doi.org/10.1145/368518.368546
Irons, E. T., & Feurzeig, W. (1960). Comments on the implementation of recursive procedures and blocks in algol-60. ALGOL Bull., (Sup 13.2), 1–15. http://doi.org/10.1145/1064060.1064061
Jensen, J., Mondrup, P., & Naur, P. (1961). A storage allocation scheme for ALGOL 60. Commun. ACM, 4(10), 441–445. http://doi.org/10.1145/366786.366803
Jensen, J., & Naur, P. (1961). An implementation of algol 60 procedures. (Pre-print from nordisk tidskrift for informations-behandling, volume 1, no 1 -1961). ALGOL Bull., (Sup 11), 38–47. http://doi.org/10.1145/1064051.1064052
Kanner, H. (1959). An algebraic translator. Commun. ACM, 2(10), 19–22. http://doi.org/10.1145/368453.368461
Kay, A. C. (1993). The early history of smalltalk. In HOPL-II: The second ACM SIGPLAN conference on history of programming languages (pp. 69–95). New York, NY, USA: ACM Press. http://doi.org/10.1145/154766.155364
Kleene, S. C. (1981). Origins of recursive function theory. Annals of the History of Computing, 3(1), 52–67.
Knuth, D. E. (1964). A proposal for input-output conventions in ALGOL 60. Commun. ACM, 7(5), 273–283. http://doi.org/10.1145/364099.364222
Knuth, Donald E. (1964). Backus normal form vs. Backus naur form. Commun. ACM, 7(12), 735–736. http://doi.org/10.1145/355588.365140
Knuth, D. E. (1965). A list of the remaining trouble spots in ALGOL60. ALGOL Bull., (19), 29–38. http://doi.org/10.1145/1060998.1061007
Knuth, Donald E. (1965). On the translation of languages from left to right. Information and Control, 8(6), 607–639.
Knuth, Donald E. (1967). The remaining trouble spots in ALGOL 60. Commun. ACM, 10(10), 611–618. http://doi.org/10.1145/363717.363743
Knuth, Donald E. (1972). A history of writing compilers. In Pollack & W. Bary (Eds.), Compiler techniques (pp. 38–56). Princeton.
Knuth, Donald E., & Gorn, S. (1962). Backus’ language. Commun. ACM, 5(4), 185. http://doi.org/10.1145/366920.366925
Knuth, Donald E., & Pardo, L. T. (1975). Early development of programming languages. In J. Belzer, A. G. Holzman, & A. Kent (Eds.), Encyclopedia of computer science and technology (Vol. 7, pp. 419–493). Marcel Dekker INC.
Koopman, P. (1989). Stack computers: The new wave. Ellis Horwood. Retrieved from http://www.ece.cmu.edu/~koopman/stack_computers/
Koster, C. H. A. (1996). The making of ALGOL68. In Proceedings of andrei ershov second international memorial conference “perspectives on systems informatics” (PSI’96). Retrieved from http://www.cs.ru.nl/~kees/home/papers/psi96.pdf
Kral, J. (1966). A note on hoare proposal AB21.3.6. ALGOL Bull., (24), 17–25. http://doi.org/10.1145/1061073.1061080
Kruseman Aretz, F. E. J. (2003). The dijkstra-zonneveld ALGOL 60 compiler for the electrologica X1. Amsterdam: CWI. Retrieved from http://ftp.cwi.nl/CWIreports/SEN/SEN-N0301.pdf
Laarschot, P. J. J. van de, & Nederkoorn, J. (1965). Some comments on a proposal by n. Wirth; n. Wirth: Reply to the foregoing comments. ALGOL Bull., (19), 12–14. http://doi.org/10.1145/1060998.1061002
Langmaack, H. (2002). Klaus samelsons frühe beiträge zur informatikentwicklung. Informatik-Spektrum, 25(2), 132–137.
Laski, J. G. (1968). Sets and other types. ALGOL Bull., (27), 41–48. http://doi.org/10.1145/1061098.1061107
Ledley, R. S., & Wilson, J. B. (1962). Automatic-programming-language translation through syntactical analysis. Commun. ACM, 5(3), 145–155. http://doi.org/10.1145/366862.366872
Leroy, H. (1966). A proposal for macro-facilities in ALGOL. ALGOL Bull., (22), 15–26. http://doi.org/10.1145/1061047.1061058
Lévénez, Éric. (2005). Languages. Retrieved from http://www.levenez.com/lang/
Lindsey, C. H. (1988). A browse through some early bulletins. ALGOL Bull., (52), 27–38. http://doi.org/10.1145/1061804.1061810
Lindsey, C. H. (1993). A history of ALGOL 68. In HOPL-II: The second ACM SIGPLAN conference on history of programming languages (pp. 97–132). New York, NY, USA: ACM Press. http://doi.org/10.1145/154766.155365
Lindsey, C. H., & Meulen, S. G. van der. (1971). Informal introduction to ALGOL 68. Amsterdam: North-Holland Publishing Company.
Lucas, P. (1961). The structure of formula-translators. ALGOL Bull., (Sup 16), 1–27. http://doi.org/10.1145/1064069.1064070
Mahoney, M. S. (1997). Computer science. The search for a mathematical theory. In J. Krige & D. Pestre (Eds.), Science in the 20th century. Amsterdam: Harwood Academic Publishers. Retrieved from http://www.princeton.edu/~mike/articles/20thcSci/20thcent.html
Mahoney, M. S. (2002). Software as science - science as software. In U. Hashagen, Keil-Slawik, & A. Norberg (Eds.), History of computing: Software issues. Berlin: Springer Verlag. Retrieved from http://www.princeton.edu/~mike/softsci.htm
Mahoney, M. S. (2004). What was the question? The origins of the theory of computation. In A. Akera & W. Aspray (Eds.), Using history to teach computer science and related disciplines (pp. 225–232). Washington D.C.: Computer Research Association. Retrieved from http://www.princeton.edu/~mike/cra/cra.html
McCracken, D. D. (1962). A new home for ALGOL. Datamation, (5), 44–46.
McMahon, J. T. (1962). ALGOL vs. FORTAN. A defense of the former. Datamation, (4), 88–89.
Medema, P. (1965). Another trouble spot in ALGOL60. ALGOL Bull., (20), 47–48. http://doi.org/10.1145/1061018.1061028
Merner, J. N. (1966). Own concept and ALGOL x. ALGOL Bull., (22), 7–9. http://doi.org/10.1145/1061047.1061052
Mitchell, G. E. (1957). General information manual: Programmer’s primer for FORTRAN automatic coding system for the IBM 704. New York: IBM. Retrieved from http://www.bitsavers.org/pdf/ibm/704/F28-6019_704_FORTRAN_primer.pdf
Morgan, R. D. (1977). The algollers. ALGOL Bull., (41), 8–9. http://doi.org/10.1145/1061688.1061692
Naur, Peter. (1959). Complete issue. ALGOL Bull., (1), 1–6. http://doi.org/10.1145/1060871.1060872
Naur, Peter. (1960a). ALGOL 60 maintenance. ALGOL Bull., (10), 1–10. http://doi.org/10.1145/1060892.1060893
Naur, Peter. (1960b). ALGOL 60 maintenance. ALGOL Bull., (11), 1–4. http://doi.org/10.1145/1060905.1060906
Naur, Peter. (1960c). ALGOL translator characteristics and the progress in translator construction. ALGOL Bull., (10), 14–16. http://doi.org/10.1145/1060892.1060900
Naur, Peter. (1960d). Questionnaire on ALGOL translator characteristics, etc. ALGOL Bull., (9), 4–4. http://doi.org/10.1145/1061146.1061153
Naur, Peter. (1961a). Suggestions from the moscow working conference on ALGOL. ALGOL Bull., (12), 4–6. http://doi.org/10.1145/1060920.1060929
Naur, Peter. (1961b). Summary of the discussion in the u.s. ALGOL 60 maintenance group during august 1960 to june 1961. ALGOL Bull., (13), 1–11. http://doi.org/10.1145/1060935.1060936
Naur, Peter. (1962a). The ALGOL meeting in rome. ALGOL Bull., (15), 1–2. http://doi.org/10.1145/1060952.1060953
Naur, P. (1962). The basic philosophy concepts, and features of ALGOL. In Symbolic languages in data processing (pp. 385–390). London: Gordon; Breach Science Publishers.
Naur, Peter. (1962b). The discontinuation of the ALGOL bulletin. ALGOL Bull., (15), 2–3. http://doi.org/10.1145/1060952.1060954
Naur, Peter. (1962c). The IFIP working group on ALGOL. ALGOL Bull., (15), 52–52. http://doi.org/10.1145/1060952.1060956
Naur, Peter. (1962d). The progress of ALGOL in europe. In R. S. Hollitch & B. Mittman (Eds.), Computer applications: Annual symposium, 6th, 1961 (pp. 115–125). London: MacMillan.
Naur, Peter. (1962e). The questionnaire. ALGOL Bull., (14), 1–14. http://doi.org/10.1145/1060945.1060946
Naur, Peter. (1962f). The replies to the AB14 questionnaire. ALGOL Bull., (15), 3–51. http://doi.org/10.1145/1060952.1060955
Naur, Peter. (1963). Documentation problems: ALGOL 60. Commun. ACM, 6(3), 77–79. http://doi.org/10.1145/366274.366286
Naur, Peter. (1964). Editor’s notes. ALGOL Bull., (16), 1–2. http://doi.org/10.1145/1060960.1060961
Naur, P. (1964a). Proposals for a new language. ALGOL Bull., (18), 26–43. http://doi.org/10.1145/1060978.1060990
Naur, P. (1964b). The design of the GIER ALGOL compiler. In R. Goodman (Ed.), Annual review in automatic programming 4 (pp. 49–85).
Naur, Peter. (1966a). Program translation viewed as a general data processing problem. Commun. ACM, 9(3), 176–179. http://doi.org/10.1145/365230.365260
Naur, Peter. (1966b). The form of specifications. ALGOL Bull., (22), 14–14. http://doi.org/10.1145/1061047.1061057
Naur, Peter. (1968). Successes and failures of the ALGOL effort. ALGOL Bull., (28), 58–62. http://doi.org/10.1145/1061112.1061118
Naur, Peter. (1970). Announcements. ALGOL Bull., (31), 7–9. http://doi.org/10.1145/1061500.1061502
Naur, Peter. (1978a). The european side of the last phase of the development of ALGOL 60. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 15–44). New York, NY, USA: ACM Press. http://doi.org/10.1145/800025.808370
Naur, Peter. (1978b). Transcripts of presentations. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 147–161). New York, NY, USA: ACM Press.
Naur, Peter. (1992a). Aad van wijngaarden’s contributions to ALGOL 60. In Peter Naur (Ed.), Computing. A human activity (pp. 98–106). Newy York, NY, USA: ACM Press.
Naur, Peter. (1992b). Computing: A human activity. New York, NY, USA: ACM Press.
Naur, Peter. (1992c). The design of the GIER ALGOL compiler. In Peter Naur (Ed.), Computing. A human activity (pp. 117–149). Newy York, NY, USA: ACM Press.
Owen, K. (1983). The art and science of programming. ALGOL Bull., (50), 6–9. http://doi.org/10.1145/1061790.1061793
Paul, M. (1962). A general processor for certain formal languages. In Symbolic languages in data processing (pp. 65–74). London: Gordon; Breach Science Publishers.
Perlis, Alan J. (1959). Symposium on automatic programming. In IFIP congress (pp. 152–156).
Perlis, Alan J. (1967). The synthesis of algorithmic systems. J. ACM, 14(1), 1–9. http://doi.org/10.1145/321371.321372
Perlis, Alan J. (1978a). The american side of the development of algol. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 3–14). New York, NY, USA: ACM Press. http://doi.org/10.1145/800025.808369
Perlis, Alan J. (1978b). Transcripts of presentations. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 139–147). New York, NY, USA: ACM Press.
Perlis, A. J., & Samelson, K. (1958). Preliminary report: International algebraic language. Commun. ACM, 1(12), 8–22. http://doi.org/10.1145/377924.594925
Peschke, J. von. (1965). Proposals for ALGOL x. ALGOL Bull., (21), 23–23. http://doi.org/10.1145/1061032.1061037
Poel, W. L. van der. (1986). Some notes on the history of ALGOL. In A quarter century of IFIP (pp. 373–392). Amsterdam: Elsevier.
Pressroom, A. (2006). Software pioneer peter naur wins ACM’s turing award. Dane’s creative genius revolutionized computer language design. Retrieved from http://campus.acm.org/public/pressroom/press_releases/3_2006/turing_3_01_2006.cfm
Question, T. of, & Session, A. (1978). Transcript of question and answer session. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 161–167). New York, NY, USA: ACM Press.
Rabin, M. O., & Scott, D. (1959). Finite automata and their decision problems. IBM Journal, 114–125.
Radin, G. (1978). The early history and characteristics of PL/i. In HOPL-1: The first ACM SIGPLAN conference on history of programming languages (pp. 227–241). New York, NY, USA: ACM Press. http://doi.org/10.1145/800025.808389
Randell, B. (1964). Whetsone ALGOL revisited or confessions of a compiler writer. Retrieved from http://www.cs.ncl.ac.uk/research/pubs/articles/papers/427.pdf
Randell, B. (1979). Software engineering in 1968 (No. 138). School of Computing Science: University of Newcastle upon Tyne.
Randell, B., & Russell, L. J. (1964a). ALGOL 60 implementation. The translation and use of ALGOL 60 programs on a computer (Vol. 5). London: Academic Press.
Randell, B., & Russell, L. J. (1964b). Single-scan techniques for the translation of arithmetic expressions into ALGOL 60. J. ACM, 11(2), 159–167. http://doi.org/10.1145/321217.321221
Rice, J. R., & Dijkstra, E. W. (1968). Letters to the editor: The go to statement reconsidered. Commun. ACM, 11(8), 538. http://doi.org/10.1145/363567.363570
Ritchie, D. M. (1996). The development of the c programming language, 671–698. http://doi.org/10.1145/234286.1057834
Rose, G. F. (1964). An extension of ALGOL-like languages. Commun. ACM, 7(2), 52–61. http://doi.org/10.1145/363921.363925
Rosen, S. (1964). A compiler-building system developed by brooker and morris: Including a comprehensive discussion of the major features of the system. Commun. ACM, 7(7), 403–414. http://doi.org/10.1145/364520.364521
Rosen, S. (Ed.). (1967a). Programming systems and languages. London: McGraw-Hill.
Rosen, S. (1967b). Programming systems and languages. A historical survey. In S. Rosen (Ed.), Programming systems and languages (pp. 3–22). London: McGraw-Hill.
Rosen, S. (1967c). The ALGOL programming language. In S. Rosen (Ed.), Programming systems and languages (pp. 48–78). London: McGraw-Hill.
Rosen, S. (1969). Electronic computers: A historical survey. Computing Surveys, 1(1), 7–36.
Rosen, S. (1972). Programming systems and languages 1965-1975. Commun. ACM, 15(7), 591–600. http://doi.org/10.1145/361454.361482
Rutishauser, H. (1952). Automatische rechenplanfertigung bei programmgesteuerten rechenmaschinen. Z. Angew. Math. Mech., 32(3), 312–313.
Rutishauser, H. (1963). The use of recursive procedures in ALGOL 60. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 43–51).
Rutishauser, Heinz. (1967). Description of ALGOL 60. (F. L. Bauer, A. S. Householder, F. W. J., F. W. J. Olver, H. Rutishauser, K. Samelson, & E. Stiefel, Eds.) (Vol. 1). Berlin: Springer-Verlag.
Samelson, K., & Bauer, F. (1962). The ALCOR project. In Gordon & Breach (Eds.), Symbolic languages in data processing: Proc. Of the symp. Organized and edited by the int. Computation center, rome, 26-31 march 1962 (pp. 207–217). New York.
Samelson, K., & Bauer, F. L. (1960). Sequential formula translation. Commun. ACM, 3(2), 76–83. http://doi.org/10.1145/366959.366968
Samet, P. A., & Taylor, P. J. (1964). Comments on the ALCOR group represenatation of of ALGOL symbols. Commun. ACM, 7(7), 424. http://doi.org/10.1145/364520.364563
Sammet, J. E. (1969). Programming languages: History and fundamentals. Englewood Cliffs, N. J.: Prentice-Hall.
Sanders, N., & Fitzpatrick, C. (1963). ALGOL and FORTAN revisited. Datamation, (1), 30–32.
Sattley, K. (1961). Allocation of storage for arrays in ALGOL 60. Commun. ACM, 4(1), 60–65. http://doi.org/10.1145/366062.366088
Schützenberger, M. P. (1963). On context-free languages and push-down automata. Information and Control, 6(3), 246–264.
Schwarz, H. R. (1981). The early years of computing in switzerland. Annals of the History of Computing, 3(2), 121–132.
Seegmuller, G. (1965). Some proposals for ALGOL x. ALGOL Bull., (21), 7–22. http://doi.org/10.1145/1061032.1061036
Simauti, T. (1967). Comments on - contribution to the development of ALGOL (wirth and hoare). ALGOL Bull., (26), 23–27. http://doi.org/10.1145/1061086.1061093
Smith, J. W. (1960). Syntactic and semantic augments to ALGOL. Commun. ACM, 3(4), 211–213. http://doi.org/10.1145/367177.367210
Steel, T. B. (Ed.). (1966). Formal language description languages for computer programming. Proceedings of the IFIP working conference on formal language description languages, september 1964. Amsterdam: North-Holland Publishing Company.
Strong, J., Wegstein, J., Tritter, A., Olsztyn, J., Mock, O., & Steel, T. (1958). The problem of programming communication with changing machines: A proposed solution. Commun. ACM, 1(8), 12–18. http://doi.org/10.1145/368892.368915
Taylor, W., Turner, L., & Waychoff, R. (1961). A syntactical chart of ALGOL 60. Commun. ACM, 4(9), 393. http://doi.org/10.1145/366696.366766
Thomson, C. M. (1981). ALGOL 68 as a living language. ALGOL Bull., (47), 21–24. http://doi.org/10.1145/1061760.1061768
Trout, R. G. (1967). A compiler—compiler system. In Proceedings of the 1967 22nd national conference (pp. 317–322). New York, NY, USA: ACM Press.
Turnep, L. D., Dahm, D., Taylor, W., & Waychoff, R. E. (1961). Letters to the editor: ALGOL 60 reply. Commun. ACM, 4(9), 365. http://doi.org/10.1145/366696.366700
Utman, R. E. (1963). Suggestions on ALGOL 60 (ROME) issues. Commun. ACM, 6(1), 20–23. http://doi.org/10.1145/366193.366209
Warshall, S. (1961). A syntax directed generator. In Proceedings of the 1961 eastern joint computer conference, washington, d.c., december 11 – 14, 1961 (pp. 295–305). Washington.
Wegner, P. (1976). Programming languages - the first 25 years. IEEE Trans. Computers, 25(12), 1207–1225.
Wegstein, J. H. (1959). From formulas to computer oriented language. Commun. ACM, 2(3), 6–8. http://doi.org/10.1145/368300.368318
Wegstein, J. H. (1960). Algorithms: anouncement. Commun. ACM, 3(2), 74. http://doi.org/10.1145/366959.366964
Wegstein, J. H. (1961a). ALGOL 60. A status report. Datamation, (9), 24–26.
Wegstein, J. H. (1961b). ALGOL: A critical profile. The RAND symposium, part two. Datamation, (10), 41–45.
Weinberg, G. M. (1961). Letters to the editor: ALGOL: Pleasure through pain. Commun. ACM, 4(6), 252. http://doi.org/10.1145/366573.366575
Wichmann, B. A. (1973). ALGOL 60 compilation and assessment (Vol. 10). London: Academic Press.
Wijngaarden, A. V. (1965). Orthogonal design and description of a formal language. Amsterdam: Mathematisch Centrum. Retrieved from http://www.fh-jena.de/~kleine/history/languages/VanWijngaarden-MR76.pdf
Wijngaarden, A. van. (1963). Generalized ALGOL. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 17–26).
Wijngaarden, A. van. (1966). Recursive definition of syntax and semantics. In Formal language description languages for computer programming. Proceedings of the IFIP working conference on formal language description languages. (pp. 13–24). Amsterdam: North-Holland Publishing Company.
Wijngaarden, A. V., Mailloux, B. J., Peck, J., & Koster, C. H. A. (1968a). Draft report on the algorithmic language ALGOL 68. (A. V. Wijngaarden, Ed.). Amsterdam: Mathematisch Centrum.
Wijngaarden, A. V., Mailloux, B. J., Peck, J., & Koster, C. H. A. (1968b). Draft report on the algorithmic language ALGOL 68. ALGOL Bull., (Sup 26), 1–84. http://doi.org/10.1145/1064072.1064073
Wijngaarden, A. V., Mailloux, B. J., Peck, J., & Koster, C. H. A. (1969). Report on the algorithmic language ALGOL 68. (A. V. Wijngaarden, Ed.). Amsterdam: Mathematisch Centrum.
Williams, F. A. (1959). Handling identifiers as internal symbols in language processors. Commun. ACM, 2(6), 21–24. http://doi.org/10.1145/368336.368352
Wirth, Niklaus. (1963). A generalization of ALGOL. Commun. ACM, 6(9), 547–554. http://doi.org/10.1145/367593.367619
Wirth, N. (1966). Additional notes on - contribution to the development of ALGOL. ALGOL Bull., (24), 13–17. http://doi.org/10.1145/1061073.1061079
Wirth, N. (1968). Closing word at zurich colloquium. ALGOL Bull., (29), 16–19. http://doi.org/10.1145/1061166.1061171
Wirth, Niklaus. (1985). From programming language design to computer construction. Commun. ACM, 28(2), 160–164. http://doi.org/10.1145/2786.2789
Wirth, N. (1993). Recollections about the development of pascal. In HOPL-II: The second ACM SIGPLAN conference on history of programming languages (pp. 333–342). New York, NY, USA: ACM Press. http://doi.org/10.1145/154766.155378
Wirth, N. (1996). Recollections about the development of pascal, 97–120. http://doi.org/10.1145/234286.1057812
Wirth, Niklaus. (2002). Pascal and its successors. In M. Broy & E. Denert (Eds.), Software pioneers: Contributions to software engineering (pp. 108–119). Berlin: Springer.
Wirth, Niklaus, & Hoare, C. A. R. (1966). A contribution to the development of ALGOL. Commun. ACM, 9(6), 413–432. http://doi.org/10.1145/365696.365702
Wirth, Niklaus, & Jensen, K. (1974). PASCAL. User manual and report. (G. Goos & J. Hartmanis, Eds.). Belin: Springer-Verlag.
Wirth, Niklaus, & Weber, H. (1966a). EULER: A generalization of ALGOL and it formal definition: Part 1. Commun. ACM, 9(1), 13–25. http://doi.org/10.1145/365153.365162
Wirth, Niklaus, & Weber, H. (1966b). EULER: A generalization of ALGOL, and its formal definition: Part II. Commun. ACM, 9(2), 89–99. http://doi.org/10.1145/365170.365202
Wood, D. (1967). A note on programming languages. ALGOL Bull., (25), 7–10. http://doi.org/10.1145/1061155.1061159
Wood, Derick. (1969). A few more trouble spots in ALGOL 60. Commun. ACM, 12(5), 247–248. http://doi.org/10.1145/362946.362957
Woodger, M. (1963a). Supplement to the ALGOL 60 report. Commun. ACM, 6(1), 18–20. http://doi.org/10.1145/366193.366207
Woodger, M. (1963b). The description of computing processes: Some observations on automatic programming and ALGOL 60. In R. Goodman (Ed.), Annual review in automatic programming 3 (pp. 1–15).
Woodger, M. (1966). ALGOL x, note on the proposed successor to ALGOL 60. ALGOL Bull., (22), 28–33. http://doi.org/10.1145/1061047.1061060
Zemanek, H. (1966). Semiotics and programming languages. Commun. ACM, 9(3), 139–143. http://doi.org/10.1145/365230.365249
Zemanek, Heinz (Ed.). (1986). A quarter century of IFIP. The IFIP silver summary. Proceedings of the 25th anniversary celebration of IFIP, march 985. Amsterdam: Elsevier.
Zuse, K. (1980). Some remarks on the history of computing in germany. In N. Metropolis, J. Howlett, & G.-C. Rota (Eds.), A history of computing in the twentieth century (pp. 611–627). Academic Press.