HeerdeBeer

Bibliography

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. K., Hagen, P. ten, & Oudshoorn, H. (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, J. 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. (1960a). 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. (1960b). 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., Beeber, R., Best, S., Goldberg, R., Herrick, H., Hughes, R., … 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, F. 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, F. 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, F. 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 A. J. Perlis (Ed.), IFIP congress (pp. 154–155).

Bauer, F. 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, N. (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, O.-J. (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, E. 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, E. W. (1970, April). Notes on Structured Programming. Retrieved from http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF

Dijkstra, E. W. (1972). The humble programmer. Retrieved from http://www.cs.utexas.edu/users/EWD/ewd03xx/EWD340.PDF

Dijkstra, E. 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, F. 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, J. 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, J. (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, S. (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, S. (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, S. (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. (1964a). Report on sUBSET aLGOL 60 (iFIP). Commun. ACM, 7(10), 626–628.

Gorn, S. (Ed.). (1964b). Report on input-output procedures for aLGOL 60. Commun. ACM, 7(10), 628–630.

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., 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. (2002). Assertions: A personal perspective. In M. Broy & E. Denert (Eds.), Software pioneers : Contributions to software engineering (pp. 356–366). Berlin: Springer.

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, C. A. R. (1981). The emperor’s old clothes. Commun. ACM, 24(2), 75–83. http://doi.org/10.1145/358549.358561

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. (1959). Code to translation systems. In A. J. Perlis (Ed.), IFIP congress (p. 153).

Huskey, H. D. (1959). A variation of the aLGOL language. In A. 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, H. 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, P. Z. (1967). “Pänini-backus form” suggested. Commun. ACM, 10(3), 137. http://doi.org/10.1145/363162.363165

Irons, E. T. (1961). A syntax directed compiler for aLGOL 60. Commun. ACM, 4(1), 51–55. http://doi.org/10.1145/366062.366083

Irons, E. T. (1963a). An error-correcting parse algorithm. Comminications of the ACM, 6(11), 669–673.

Irons, E. 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., & 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

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

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, D. 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, D. E. (1965). On the translation of languages from left to right. Information and Control, 8(6), 607–639.

Knuth, D. E. (1967). The remaining trouble spots in aLGOL 60. Commun. ACM, 10(10), 611–618. http://doi.org/10.1145/363717.363743

Knuth, D. E. (1972). A history of writing compilers. In Pollack & W. Bary (Eds.), Compiler techniques (pp. 38–56). Princeton.

Knuth, D. E., & Gorn, S. (1962). Backus’ language. Commun. ACM, 5(4), 185. http://doi.org/10.1145/366920.366925

Knuth, D. 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. (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. (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. (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, P. (1959). Complete issue. ALGOL Bull., (1), 1–6. http://doi.org/10.1145/1060871.1060872

Naur, P. (1960a). ALGOL 60 maintenance. ALGOL Bull., (10), 1–10. http://doi.org/10.1145/1060892.1060893

Naur, P. (1960b). ALGOL 60 maintenance. ALGOL Bull., (11), 1–4. http://doi.org/10.1145/1060905.1060906

Naur, P. (1960c). ALGOL translator characteristics and the progress in translator construction. ALGOL Bull., (10), 14–16. http://doi.org/10.1145/1060892.1060900

Naur, P. (1960d). Questionnaire on aLGOL translator characteristics, etc. ALGOL Bull., (9), 4–4. http://doi.org/10.1145/1061146.1061153

Naur, P. (1961a). Suggestions from the moscow working conference on aLGOL. ALGOL Bull., (12), 4–6. http://doi.org/10.1145/1060920.1060929

Naur, P. (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, P. (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, P. (1962b). The discontinuation of the aLGOL bulletin. ALGOL Bull., (15), 2–3. http://doi.org/10.1145/1060952.1060954

Naur, P. (1962c). The iFIP working group on aLGOL. ALGOL Bull., (15), 52–52. http://doi.org/10.1145/1060952.1060956

Naur, P. (1962d). The progress of aLGOL in europe. In R. Hollitch & B. Mittman (Eds.), Computer applications : Annual symposium, 6th, 1961 (pp. 115–125). London: MacMillan.

Naur, P. (1962e). The questionnaire. ALGOL Bull., (14), 1–14. http://doi.org/10.1145/1060945.1060946

Naur, P. (1962f). The replies to the aB14 questionnaire. ALGOL Bull., (15), 3–51. http://doi.org/10.1145/1060952.1060955

Naur, P. (1963). Documentation problems: ALGOL 60. Commun. ACM, 6(3), 77–79. http://doi.org/10.1145/366274.366286

Naur, P. (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, P. (1966a). Program translation viewed as a general data processing problem. Commun. ACM, 9(3), 176–179. http://doi.org/10.1145/365230.365260

Naur, P. (1966b). The form of specifications. ALGOL Bull., (22), 14–14. http://doi.org/10.1145/1061047.1061057

Naur, P. (1968). Successes and failures of the aLGOL effort. ALGOL Bull., (28), 58–62. http://doi.org/10.1145/1061112.1061118

Naur, P. (1970). Announcements. ALGOL Bull., (31), 7–9. http://doi.org/10.1145/1061500.1061502

Naur, P. (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, P. (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, P. (1992a). Aad van wijngaarden’s contributions to aLGOL 60. In P. Naur (Ed.), Computing. a human activity (pp. 98–106). Newy York, NY, USA: ACM Press.

Naur, P. (1992b). Computing: A human activity. New York, NY, USA: ACM Press.

Naur, P. (1992c). The design of the gIER aLGOL compiler. In P. 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, A. J. (1959). Symposium on automatic programming. In IFIP congress (pp. 152–156).

Perlis, A. J. (1967). The synthesis of algorithmic systems. J. ACM, 14(1), 1–9. http://doi.org/10.1145/321371.321372

Perlis, A. 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, A. 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. (1967a). Programming systems and languages. a historical survey. In S. Rosen (Ed.), Programming systems and languages (pp. 3–22). London: McGraw-Hill.

Rosen, S. (1967b). 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

Rosen, S. (Ed.). (1967c). Programming systems and languages. London: McGraw-Hill.

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, H. (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. (1973). ALGOL 60 compilation and assessment (Vol. 10). London: Academic Press.

Wijngaarden, A. V. (1965, October). 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. V., Mailloux, B. J., Peck, J., & Koster, C. H. A. (1968a). 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. (1968b). 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. (1969). Report on the algorithmic language aLGOL 68. (A. V. Wijngaarden, Ed.). Amsterdam: Mathematisch Centrum.

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.

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, N. (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, N. (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, N. (2002). Pascal and its successors. In M. Broy & E. Denert (Eds.), Software pioneers : Contributions to software engineering (pp. 108–119). Berlin: Springer.

Wirth, N., & 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, N., & Jensen, K. (1974). PASCAL. user manual and report. (G. Goos & J. Hartmanis, Eds.). Belin: Springer-Verlag.

Wirth, N., & 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, N., & 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, D. (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, H. (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.