References
Published online by Cambridge University Press: 19 December 2025
HTML view is not available for this content. However, as you have access to this content, a full PDF is available via the 'Save PDF' action button.
Information
- Type
- Chapter
- Information
- Cultures of ProgrammingThe Development of Programming Concepts and Methodologies, pp. 309 - 331Publisher: Cambridge University PressPrint publication year: 2026
- Creative Commons
This content is Open Access and distributed under the terms of the Creative Commons Attribution licence CC-BY-NC 4.0 https://creativecommons.org/cclicenses/
References
Aaron, S. (2016). Sonic pi–performance in education, technology and art. International Journal of Performance Arts and Digital Media, 12(2):171–178.CrossRefGoogle Scholar
Abadi, M. and Cardelli, L. (1996). A Theory of Objects. Springer Science & Business Media.CrossRefGoogle Scholar
Abadi, M., Gardner, P., Gordon, A., Mardare, R., and (eds.) (2014). Essays for the Luca Cardelli Fest. Technical Report MSR-TR-2014-104.Google Scholar
Abbate, J. (2012). Recoding Gender: Women’s Changing Participation in Computing. MIT Press.10.7551/mitpress/9014.001.0001CrossRefGoogle Scholar
Abbott, R. J. (1983). Program design by informal English descriptions. Communications of the ACM, 26(11):882–894.CrossRefGoogle Scholar
Adam, A. (2005). Hacking into hacking: Gender and the hacker phenomenon. In Adam, A. (ed.), Gender, Ethics and Information Technology, pages 128–146. Springer.CrossRefGoogle Scholar
Agaram, K. (2020). Bicycles for the mind have to be see-through. In Programming’20: 4th International Conference on the Art, Science, and Engineering of Programming, Porto, Portugal, March 23–26, 2020, pages 173–186.Google Scholar
Allen, C. D., Chapman, D. N., and Jones, C. B. (1972). A formal definition of Algol 60. Technical Report 12.105, IBM Laboratory Hursley.Google Scholar
Allman, E. (2004). A conversation with James Gosling: James Gosling talks about virtual machines, security, and of course, Java. Queue, 2(5):24–33.CrossRefGoogle Scholar
Altenkirch, T., Gaspes, V., Nordström, B., and von Sydow, B. (1994). A user’s guide to ALF. Technical Report, Chalmers University of Technology, Sweden.Google Scholar
Altenkirch, T., McBride, C., and McKinna, J. (2005). Why dependent types matter. Manuscript, 235, available online, www.e-pig.org/downloads/ydtm.pdf.Google Scholar
Amin, N. and Tate, R. (2016). Java and Scala’s type systems are unsound: The existential crisis of null pointers. ACM Sigplan Notices, 51(10):838–848.Google Scholar
ANSI/IEEE (1983). IEEE standard for software test documentation. Technical Report 829-1983, Institute of Electrical and Electronics Engineers.Google Scholar
ANSI/IEEE (1986). IEEE standard for software verification and validation plans. Technical Report 1012-1986, Institute of Electrical and Electronics Engineers.Google Scholar
ANSI/IEEE (1987). IEEE standard for software unit testing. Technical Report 1008-1987, Institute of Electrical and Electronics Engineers.Google Scholar
Ardis, M., Basili, V., Gerhart, S., Good, D., Gries, D., Kemmerer, R., Leveson, N., Musser, D., Neumann, P., and von Henke, F. (1989). ACM forum. Communications of the ACM, 32(3):287–ff.Google Scholar
Armstrong, J. (2007). A history of Erlang. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages, HOPL III, 1–26. New York. ACM Publications.Google Scholar
Ashenhurst, R. L. (1972). Curriculum recommendations for graduate professional programs in information systems. Communications of the ACM, 15(5):363–398.CrossRefGoogle Scholar
Astarte, T. K. (2017). Towards an interconnected history of semantics. In Fourth International Conference on the History and Philosophy of Computing, 1–5, Brno, Czech Republic.Google Scholar
Astarte, T. K. (2019). Formalising Meaning: A History of Programming Language Semantics. PhD thesis, Newcastle University.Google Scholar
Astarte, T. K. and Jones, C. B. (2018). Formal semantics of Algol 60: Four descriptions in their historical context. In De Mol, L. and Primiero, G., (eds.), Reflections on Programming Systems: Historical and Philosophical Aspects, pages 71–141. Springer.Google Scholar
Atchison, W. F. (1985). The development of computer science education. Advances in Computers, 24:319–377.10.1016/S0065-2458(08)60370-8CrossRefGoogle Scholar
Atkinson, B. (2016). Atkinson, Bill, interviewed by Laporte, Leo. https://twit.tv/shows/triangulation/episodes/247.Google Scholar
Augustsson, L. (1998). Cayenne: A language with dependent types. In Doaitse Swierstra, S., Oliveira, J. N. and Henriques, P. R. (eds.), International School on Advanced Functional Programming, pages 240–267. Springer.Google Scholar
Backus, J. W. (1980). Programming in America in the 1950s: Some personal impressions. In Metropolis, N., Howlett, J. and Rota, G.-C. (eds.), A History of Computing in the Twentieth Century, pages 125–135. Elsevier.10.1016/B978-0-12-491650-0.50017-4CrossRefGoogle Scholar
Backus, J. W., Bauer, F. L., Green, J., Katz, C., McCarthy, J., Naur, P., Perlis, A. J., Rutishauser, H., Samelson, K., Vauquois, B., et al. (1960). Report on the algorithmic language Algol 60. Numerische Mathematik, 2(1):106–136.CrossRefGoogle Scholar
Backus, J. W., Bauer, F. L., Green, J., Katz, C., McCarthy, J., Perlis, A. J., Rutishauser, H., Samelson, K., Vauquois, B., Wegstein, J. H., van Wijngaarden, A., and Woodger, M. (1963). Revised report on the algorithm language Algol 60. Communications of the ACM, 6(1):1–17.CrossRefGoogle Scholar
Backus, J. W., Beeber, R. J., Best, S., Goldberg, R., Herrick, H. L., Hughes, R. A., Mitchell, B., Nelson, R. A., Nutt, R., Sayre, D., Sheridan, P. B., Stern, H., and Ziller, L. (1956). Fortran: Automatic Coding System for the IBM 704 EDPM, IBM Corporation.Google Scholar
Backus, J. W., Herrick, H., and Ziller, I. (1954). Specifications for the IBM Mathematical Formula Translating System, Fortran. preliminary report, programming research group. Applied Science Division, IBM Corporation.Google Scholar
Baker, T. F. and Mills, H. D. (1973). Chief programmer teams. Datamation, 19(12):58–61.Google Scholar
Barber, R. J. (1975). The advanced research projects agency, technical report published by ARPA, number AD-A154 363. URL: https://apps.dtic.mil/sti/citations/ADA154363. 1958–1974.Google Scholar
Bardini, T. (2000). Bootstrapping: Douglas Engelbart, Coevolution, and the Origins of Personal Computing. Stanford University Press.CrossRefGoogle Scholar
Bartik, J. J. (2013). Pioneer Programmer: Jean Jennings Bartik and the Computer That Changed the World. Truman State University Press.Google Scholar
Bawden, A., Greenblatt, R., Holloway, J., Knight, T., Moon, D., and Weinreb, D. (1974). Lisp machine progress report. Technical Report AIM-444, MIT.Google Scholar
Beck, K. (2000). Extreme Programming Explained: Embrace Change. Addison-Wesley Professional.Google Scholar
Beck, K., Beedle, M., Van Bennekum, A., Cockburn, A., Cunningham, W., Fowler, M., Grenning, J., Highsmith, J., Hunt, A., Jeffries, R., et al. (2001). Manifesto for agile software development. URL: https://agilemanifesto.org/.Google Scholar
Beck, K. and Cunningham, W. (1989). A laboratory for teaching object oriented thinking. In Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications, OOPSLA ’89, pages 1–6, New York. ACM.Google Scholar
Beeler, M., Gosper, R. W., and Schroeppel, R. (1972). HAKMEM. Technical Report, AI Memo 239, MIT.Google Scholar
Benington, H. D. (1983). Production of large computer programs. Annals of the History of Computing, 5(4):350–361.CrossRefGoogle Scholar
Bissell, C. (2007). Historical perspectives: The moniac a hydromechanical analog computer of the 1950s. IEEE Control Systems Magazine, 27(1):69–74.CrossRefGoogle Scholar
Black, A. P. (2013). Object-oriented programming: Some history, and challenges for the next fifty years. Information and Computation, 231:3–20.CrossRefGoogle Scholar
Blackwell, A. F. and Collins, N. (2005). The programming language as a musical instrument. In Proceedings of the 17th Annual Workshop of the Psychology of Programming Interest Group, PPIG 2005, Brighton, UK, June 29–July 1, 2005, page 11. Psychology of Programming Interest Group.Google Scholar
Bobrow, D. G., Darley, D. L., Deutsch, L. P., Murphy, D. L., and Teitelman, W. (1967). The BBN 940 LISP system. Technical Report, Bolt Beranek and Newman, Inc.10.21236/AD0656771CrossRefGoogle Scholar
Bobrow, D. G. and Winograd, T. (1976). An overview of KRL, a knowledge representation language. Technical Report AIM-293, Stanford Aritifical Intelligence Laboratory.Google Scholar
Boehm, B. W. (1988). A spiral model of software development and enhancement. Computer, 21(5):61–72.CrossRefGoogle Scholar
Böhm, C. and Jacopini, G. (1966). Flow diagrams, Turing machines and languages with only two formation rules. Communications of the ACM, 9(5):366–371.CrossRefGoogle Scholar
Booch, G. (1990). Object-Oriented Analysis and Design with Applications. Benjamin Cummings.Google Scholar
Bornat, R. (2009). Peter Landin: A computer scientist who inspired a generation. Higher-Order and Symbolic Computation, 22(4):295–298.CrossRefGoogle Scholar
Borning, A. (1981). The programming language aspects of ThingLab, a constraint-oriented simulation laboratory. ACM Transactions on Programming Languages and Systems (TOPLAS), 3(4):353–387.10.1145/357146.357147CrossRefGoogle Scholar
Borning, A. H. (1986). Classes versus prototypes in object-oriented languages. In Proceedings of 1986 ACM Fall Joint Computer Conference, pages 36–40.Google Scholar
Bosak, R., Clippinger, R. F., Dobbs, C., Goldfinger, R., Jasper, R. B., Keating, W., Kendrick, G., and Sammet, J. E. (1962). An information algebra: Phase 1 report – language structure group of the CODASYL development committee. Communications of the ACM, 5(4):190–204.CrossRefGoogle Scholar
Boyer, C. (2004). The 360 Revolution. IBM. Online at https://archive.org/details/h42_The_ 360_Revolution_Chuck_Boyer.Google Scholar
Boyer, R. S. and Moore, J. (1983). On why it is impossible to prove that the BDX90 dispatcher implements a time-sharing system. Technical report published by NASA document number: 19840017251. URL: https://ntrs.nasa.gov/citations/19840017251.Google Scholar
Boyer, R. S. and Moore, J. S. (1988). A Computational Logic Handbook. Academic Press Professional.Google Scholar
Brand, S. (1972). Spacewar: Fanatic life and symbolic death among the computer bums. Rolling Stone, (123) December 1972, 52–57.Google Scholar
Brand, S. and Crandall, R. (1988). The media lab: Inventing the future at MIT. Computers in Physics, 2(1):91–92.CrossRefGoogle Scholar
Brooks, F. (1987). No silver bullet: Essence and accidents of software engineering. Computer, 20(4):10–19.CrossRefGoogle Scholar
Brooks Jr, F. P. (1975). The Mythical Man-Month: Essays on Software Engineering. Addison-Wesley.wCrossRefGoogle Scholar
Budd, T. A., Lipton, R. J., DeMillo, R. A., and Sayward, F. G. (1978). The design of a prototype mutation system for program testing. In Ghosh, S. P. and Liu, L. Y., (eds.), American Federation of Information Processing Societies: 1978 National Computer Conference, June 5–8, 1978, Anaheim, CA, USA, volume 47 of AFIPS Conference Proceedings, pages 623–629. AFIPS Press.Google Scholar
Burstall, R. (2000). Christopher Strachey: Understanding programming languages. Higher-Order and Symbolic Computation, 13(1–2):51–55.10.1023/A:1010052305354CrossRefGoogle Scholar
Buxton, J., Randell, B., and Committee, N. S. (1970). Software Engineering Techniques: Report on a Conference Sponsored by the NATO Science Committee. NATO Science Committee; available from Scientific Affairs Division, NATO.Google Scholar
Byous, J. (1998). Happy 3rd birthday! Sun Microsystems, archived at http://web.archive.org/web/19990223195009/http://java.sun.com/features/1998/05/birthday.html (Retrieved on 19 Jan 2024).Google Scholar
Campbell-Kelly, M. (1980). Programming the EDSAC: Early programming activity at the University of Cambridge. Annals of the History of Computing, 2(1):7–36.10.1109/MAHC.1980.10009CrossRefGoogle Scholar
Campbell-Kelly, M. (1992). The airy tape: An early chapter in the history of debugging. IEEE Annals of the History of Computing, 14:16–26.10.1109/85.194051CrossRefGoogle Scholar
Campbell-Kelly, M. (2004). From Airline Reservations to Sonic the Hedgehog: A History of the Software Industry. MIT Press.Google Scholar
Campbell-Kelly, M. (2011). From theory to practice: The invention of programming, 1947–51. In Jones, C. B. and Lloyd, J. L. (eds.), Dependable and Historic Computing, pages 23–37. Springer.10.1007/978-3-642-24541-1_4CrossRefGoogle Scholar
Campbell-Kelly, M. and Aspray, W. (1996). Computer: A History of the Information Machine. Basic Books.Google Scholar
Cardelli, L. (1984). A semantics of multiple inheritance. In Kahn, G., MacQueen, D. B. and Plotkin, G. (eds.), Proc. of the International Symposium on Semantics of Data Types, pages 51–67, Berlin, Heidelberg. Springer-Verlag.10.1007/3-540-13346-1_2CrossRefGoogle Scholar
Cardelli, L. and MacQueen, D. (1983). Polymorphism: The ML/LCF/Hope newsletter. Polymorphism, 1(1), http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%201.pdf.Google Scholar
Cardelli, L. and Wegner, P. (1985). On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17(4):471–523.10.1145/6041.6042CrossRefGoogle Scholar
Cardone, F. and Hindley, J. R. (2006). History of lambda-calculus and combinatory logic. Handbook of the History of Logic, 5:723–817.10.1016/S1874-5857(09)70018-4CrossRefGoogle Scholar
Cavanaugh, R. (2018). Type-checking unsoundness: Standardize treatment of such issues among typescript team/community? [Online: https://github.com/Microsoft/TypeScript/ issues/9825\#issuecomment-234115900. Accessed September 10, 2018].Google Scholar
Ceruzzi, P. (1988). Electronics technology and computer science, 1940–1975: A coevolution. Annals of the History of Computing, 10(4):257–275.10.1109/MAHC.1988.10036CrossRefGoogle Scholar
Chandrasekaran, S. K., Leijen, D., Pretnar, M., and Schrijvers, T. (2018). Algebraic effect handlers go mainstream (dagstuhl seminar 18172). In Dagstuhl reports, volume 8. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik. https://drops.dagstuhl.de/entities/document/10.4230/DagRep.8.4.104.Google Scholar
Chang, H. (2004). Inventing Temperature: Measurement and Scientific Progress. Oxford University Press.10.1093/0195171276.001.0001CrossRefGoogle Scholar
Chang, H. (2012). Is Water H2O? Evidence, Realism and Pluralism, volume 293. Springer Science & Business Media.10.1007/978-94-007-3932-1CrossRefGoogle Scholar
Chang, H. (2017). Who cares about the history of science? Notes and Records: The Royal Society Journal of the History of Science, 71(1):91–107.10.1098/rsnr.2016.0042CrossRefGoogle ScholarPubMed
Cheatham, T. E. (1969). Motivation for extensible languages. SIGPLAN Notices, 4(8):45–49.CrossRefGoogle Scholar
Brown, Chris and John, Bischoff (2002). Indigenous to the net: Early network music bands in the San Francisco Bay area. http://crossfade.walkerart.org/brownbischoff/IndigenoustotheNetPrint.html [Accessed December 7, 2021].Google Scholar
Church, A. (1940). A formulation of the simple theory of types. Journal of Symbolic Logic, 5(2):56–68.Google Scholar
Cihon, P. (2019). Standards for AI governance: International standards to enable global coordination in AI research & development. Technical Report, Future of Humanity Institute. University of Oxford.Google Scholar
Clarke, D. G., Potter, J. M., and Noble, J. (1998). Ownership types for flexible alias protection. In Proceedings of the 13th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, pages 48–64.10.1145/286936.286947CrossRefGoogle Scholar
Cohn, A. (1989). The notion of proof in hardware verification. Journal of Automated Reasoning, 5(2):127–139.10.1007/BF00243000CrossRefGoogle Scholar
Colburn, T. R., Fetzer, J. H., and Rankin, T. L., (eds.). (2012). Program Verification: Fundamental Issues in Computer Science, volume 14. Springer Science & Business Media.Google Scholar
Conger, R. A. (1962). Certification of algorithm 58: Matrix inversion. Communications of the ACM, 5(6):347.10.1145/367766.368188CrossRefGoogle Scholar
Cook, S. (1988). Impressions of ecoop’88, Journal of Object-Oriented Programming, 1(4):42–43. SIGS Publications Inc., New York.Google Scholar
Cook, W. and Palsberg, J. (1989). A denotational semantics of inheritance and its correctness. In Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications, OOPSLA ’89, page 433–443, New York. ACM.10.1145/74877.74922CrossRefGoogle Scholar
Cook, W. R. (2009). On understanding data abstraction, revisited. In Proceedings of the 24th ACM SIGPLAN Conference on Object-Oriented Programming Systems Languages and Applications, pages 557–572.CrossRefGoogle Scholar
Coquand, C., Takeyama, M., and Synek, D. (2006). An emacs interface for type directed support constructing proofs and programs. In European Joint Conferences on Theory and Practice of Software, ENTCS, volume 2.Google Scholar
Coquand, T. (2018). Type theory. In Zalta, E. N., (ed.), The Stanford Encyclopedia of Philosophy. Metaphysics Research Lab, Stanford University, fall 2018 edition.Google Scholar
Cox, B. J., Naroff, S., and Hsu, H. (2020). The origins of Objective-c at PPI/Stepstone and its evolution at NeXT. Proceedings of the ACM on Programming Languages, 4(HOPL).CrossRefGoogle Scholar
Crawford, K. and Paglen, T. (2019). Excavating AI: The politics of images in machine learning training sets. AI and Society, 36(4): 1105–1116.Google Scholar
Dahl, O.-J. (1969). Programming languages as tools for the formulation of concepts. In Aubert, K. E. and Ljunggren, W., (eds.), Proceedings of the 15th Scandinavian Congress Oslo 1968, pages 18–29, Berlin, Heidelberg. Springer Berlin Heidelberg.Google Scholar
Dahl, O. J., Dijkstra, E. W., and Hoare, C. A. R., (eds.). (1972). Structured Programming. Academic Press.Google Scholar
Dahl, O.-J., Myhrhaug, B., and Nygaard, K. (1968). Some features of the SIMULA 67 language. In Proceedings of the Second Conference on Applications of Simulations, pages 29–31. Winter Simulation Conference.Google Scholar
Dahl, O.-J. and Nygaard, K. (1966). SIMULA: An Algol-based simulation language. Communications of the ACM, 9(9):671–678.10.1145/365813.365819CrossRefGoogle Scholar
Dahl, O. -J. and Nygaard, K. (2002). Class and Subclass Declarations, pages 91–107. Springer.Google Scholar
Damouth, D., Urbach, J., Mitchel, J. G., and Kay, A. (1971). Parc papers for pendery and planning purposes. Technical Report, Xerox PARC.Google Scholar
Dastin, J. (2018). Amazon scraps secret AI recruiting tool that showed bias against women. In K., Martin (ed.), Ethics of Data and Analytics, pages 296–299. Auerbach Publications.Google Scholar
DeMillo, R. A., Lipton, R. J., and Perlis, A. J. (1979). Social processes and proofs of theorems and programs. Communications of the ACM, 22(5):271–280.10.1145/359104.359106CrossRefGoogle Scholar
De Mol, L. and Bullynck, M. (2018). Making the history of computing: The history of computing in the history of technology and the history of mathematics. Revue de Synthèse, 139(3–4):361–380.CrossRefGoogle Scholar
Dechesne, F. and Nederpelt, R. (2012). N.G. de Bruijn (1918–2012) and his road to automath: The earliest proof checker. The Mathematical Intelligencer, 34(4):4–11.CrossRefGoogle Scholar
DeMillo, R. A., Lipton, R. J., and Perlis, A. J. (1977). Social processes and proofs of theorems and programs. In Proceedings of the 4th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL ’77, page 206–214, New York. ACM.Google Scholar
DeMillo, R. A., Lipton, R. J., and Sayward, F. G. (1978). Hints on test data selection: Help for the practicing programmer. Computer, 11(4):34–41.10.1109/C-M.1978.218136CrossRefGoogle Scholar
Depaz, P. (2023). The Role of Aesthetics in Understanding Source Code. PhD thesis, Université Sorbonne Nouvelle, ED120 - THALIM.Google Scholar
DeRemer, F. and Kron, H. H. (1976). Programming-in-the-large versus programming-in-the-small. IEEE Transactions on Software Engineering, SE-2(2):80–86.10.1109/TSE.1976.233534CrossRefGoogle Scholar
Deutsch, L. P. and Lampson, B. W. (1967). An online editor. Communications of the ACM, 10(12):793–799.10.1145/363848.363863CrossRefGoogle Scholar
Deutsch, L. P. (1967). Preliminary guide to the LISP editor. Technical Report Project Genie Document W-21, University of California, Berkeley.Google Scholar
Di Sessa, A. A. (1985). A principled design for an integrated computational environment. Human-Computer Interaction, 1(1):1–47.10.1207/s15327051hci0101_1CrossRefGoogle Scholar
Dijkstra, E. W. (1968). Letters to the editor: Go to statement considered harmful. Communications of the ACM, 11(3):147–148.CrossRefGoogle Scholar
Dijkstra, E. W. (1972). The humble programmer. Communications of the ACM, 15(10):859–866.10.1145/355604.361591CrossRefGoogle Scholar
Dijkstra, E. W. (1977). A position paper on software reliability. ACM SIGSOFT Software Engineering Notes, 2(5):3–5.CrossRefGoogle Scholar
Dijkstra, E. W. (1978). On a political pamphlet from the middle ages. ACM SIGSOFT Software Engineering Notes, 3(2):14–16.10.1145/1005888.1005890CrossRefGoogle Scholar
Dijkstra, E. W. (1980). America’s programming plight. Technical Report EWD 750, The University of Texas at Austin.Google Scholar
Dijkstra, E. W. (1982). How do we tell truths that might hurt? In Dijkstra, E. W. (ed.), Selected Writings on Computing: A personal Perspective, pages 129–131. Springer.10.1007/978-1-4612-5695-3_22CrossRefGoogle Scholar
Dijkstra, E. W. (1988). On the cruelty of really teaching computing science. Technical Report EWD 1036, The University of Texas at Austin.Google Scholar
Dijkstra, E. W. (1993). In reply to comments. Technical Report EWD 1058, The University of Texas at Austin.Google Scholar
Dijkstra, E. W. (2002). Ewd 1308: What led to ‘Notes on structured programming’. In Broy, M. and Denert, E. (eds.), Software Pioneers, pages 340–346. Springer.10.1007/978-3-642-59412-0_19CrossRefGoogle Scholar
diSessa, A. A. and Abelson, H. (1986). Boxer: A reconstructible computational medium. Communications of the ACM, 29(9):859–868.10.1145/6592.6595CrossRefGoogle Scholar
Dyer, M. and Mills, H. D. (1981). Cleanroom software development. In Sixth Annual Software Engineering Workshop. NASA.Google Scholar
Ellis, T. O., Heafner, J. F., and Sibley, W. L. (1969). The GRAIL project: An experiment in man-machine communications. Technical Report, RAND Corporation, Santa Monica, CA.Google Scholar
Engelbart, D. C. (1962). Augmenting human intellect: A conceptual framework. Technical Report AFOSR 3223, Stanford Research Institute.Google Scholar
English, J. (1998). The story of the Java platform. Archived at http://web.archive.org/web/19990218201604/http://java.sun.com/nav/whatis/storyofjava.html (Retrieved on 19 Jan 2024).Google Scholar
Ensmenger, N. (2010). Making programming masculine. In Misa, T. J., Gender Codes: Why Women Are Leaving Computing, pages 115–141. IEEE Computer Society and John Wiley & Sons.10.1002/9780470619926.ch6CrossRefGoogle Scholar
Ensmenger, N. (2012). The Computer Boys Take Over: Computers, Programmers, and the Politics of Technical Expertise. MIT Press.Google Scholar
Ensmenger, N. (2015). ‘Beards, sandals, and other signs of rugged individualism’: Masculine culture within the computing professions. Osiris, 30(1):38–65.10.1086/682955CrossRefGoogle ScholarPubMed
Evans, T. G. and Darley, D. L. (1965). Debug–an extension to current online debugging techniques. Communications of the ACM, 8(5):321–326.10.1145/364914.364952CrossRefGoogle Scholar
Evans, T. G. and Darley, D. L. (1966). On-line debugging techniques: A survey. In Proceedings of the November 7-10, 1966, fall joint computer conference, pages 37–50. ACM.Google Scholar
Fedorkow, G. C. (2021). Recovering software for the whirlwind computer. IEEE Annals of the History of Computing, 43(1):38–59.10.1109/MAHC.2020.3048815CrossRefGoogle Scholar
Fetzer, J. H. (1988). Program verification: The very idea. Communications of the ACM, 31(9):1048–1063.10.1145/48529.48530CrossRefGoogle Scholar
Finney, J. W. (1975). Safeguard ABM system to shut down: 5 billion spent in 6 years since debate. The New York Times.Google Scholar
Fisher, D. A. (1970). Control structures for programming languages. PhD thesis, Carnegie Mellon University.Google Scholar
Fisher, K. D., Carr, C. J., and Talbot, J. M. (1975). Computer applications in the biological sciences. Technical Report AD-A012 589, Air Force Office of Scientific Research, Advanced Research Projects Agency.10.21236/ADA012589CrossRefGoogle Scholar
Floyd, C. (1987). Outline of a paradigm change in software engineering. In Bjerknes, G., (ed.), Computers and Democracy: A Scandanavian Challenge, pages 191–210. Brookfield, Gower Publishing Company.Google Scholar
Floyd, C., Mehl, W.-M., Resin, F.-M., Schmidt, G., and Wolf, G. (1989). Out of Scandinavia: Alternative approaches to software design and system development. Human-Computer Interaction, 4(4):253–350.10.1207/s15327051hci0404_1CrossRefGoogle Scholar
Floyd, R. W. (1967). Assigning meanings to program. In Proc. Symposia in Applied Mathematics, 1967, volume 19, pages 19–32.10.1090/psapm/019/0235771CrossRefGoogle Scholar
Forrester, J. W. and Everett, R. R. (1990). The whirlwind computer project. IEEE Transactions on Aerospace and Electronic Systems, 26(5):903–910.10.1109/7.102724CrossRefGoogle Scholar
Fowler, M. (1999). Refactoring: Improving the Design of Existing Code. Addison-Wesley.Google Scholar
Fowler, M. (2001). The new methodology. Wuhan University Journal of Natural Sciences, 6(1):12–24.10.1007/BF03160222CrossRefGoogle Scholar
Freiberger, P. and Swaine, M. (1984). Fire in the Valley: The Making of the Personal Computer. McGraw-Hill.Google Scholar
Gabriel, R. P. (1996). Patterns of Software: Tales from the Software Community. Oxford University Press.Google Scholar
Gabriel, R. P. (2012). The structure of a programming language revolution. In Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2012, pages 195–214, New York. ACM.10.1145/2384592.2384611CrossRefGoogle Scholar
Gabriel, R. P., Bourbaki, N., Devin, M., Dussud, P., Gray, D., and Sexton, H. (1990). Foundation for a c++ programming environment. Proceedings of C++ at Work, 90.Google Scholar
Gabriel, R. P. and Frost, M. E. (1984). A programming environment for a timeshared system. In Proceedings of the First ACM SIGSOFT/SIGPLAN Software Engineering Symposium on Practical Software Development Environments, SDE 1, page 185–192, New York. ACM.Google Scholar
Galison, P. (1997). Image and Logic: A Material Culture of Microphysics. University of Chicago Press.Google Scholar
Gamma, E., Helm, R., Johnson, R., and Vlissides, J. (1995). Design Patterns: Elements of Reusable Object-Oriented Software. Pearson.Google Scholar
Gelperin, D. and Hetzel, B. (1988). The growth of software testing. Communications of the ACM, 31(6):687–695.10.1145/62959.62965CrossRefGoogle Scholar
Genuys, F., (ed.). (1968). Programming Languages: NATO Advanced Study Institute. Academic Press.Google Scholar
Gilmore, J. T. Jr. (1958a). A functional description of the TX-0 computer. Technical Report 6M-4789-1, Massachusetts Institute of Technology.Google Scholar
Gilmore, J. T. Jr. (1958b). TX-0 direct input utility system. Technical Report 6M-5097-1, Massachusetts Institute of Technology.Google Scholar
Gold, B. and Simons, R. (2008). Proof and Other Dilemmas: Mathematics and Philosophy. MAA spectrum. Mathematical Association of America.10.5948/UPO9781614445050CrossRefGoogle Scholar
Goldberg, A. (2002). Oral history of Adele Goldberg, interviewed by Janet Abbate, 3 July, 2002. Technical Report Interview 591, IEEE History Center.Google Scholar
Goldberg, A. and Kay, A. (1976a). Smalltalk-72: Instruction Manual. Xerox Corporation Palo Alto.Google Scholar
Goldberg, A. and Kay, A. (1976b). Smalltalk-72: Instruction manual. Technical Report SSL 76-6, Xerox Corporation, Palo Alto.Google Scholar
Goldberg, A. and Robson, D. (1983). Smalltalk-80: The Language and Its Implementation. Addison-Wesley Longman Publishing.Google Scholar
Goldberg, J., Kautz, W. H., Melliar-Smith, P. M., Green, M. W., Levitt, K. N., Schwartz, R. L., and Weinstock, C. B. (1984). Development and analysis of the software implemented fault-tolerance (sift) computer. Technical Report NASA Contractor Report 172146, SRI International.Google Scholar
Goodenough, J. B. (1975a). Exception handling: Issues and a proposed notation. Communications of the ACM, 18(12):683–696.10.1145/361227.361230CrossRefGoogle Scholar
Goodenough, J. B. (1975b). Structured exception handling. In Graham, R. M., Harrison, M. A., and Reynolds, J. C., (eds.), Conference Record of the Second ACM Symposium on Principles of Programming Languages, Palo Alto, pages 204–224. ACM Press.Google Scholar
Goodenough, J. B. and Gerhart, S. L. (1975). Toward a theory of test data selection. In Proceedings of the International Conference on Reliable Software, pages 493–510, New York. ACM.10.1145/800027.808473CrossRefGoogle Scholar
Gordon, M. (2000). From LCF to HOL: A short history. In Plotkin, G., Stirling, C. P. and Tofte, M. (eds.), Proof, Language and Interaction, pages 169–186.10.7551/mitpress/5641.003.0012CrossRefGoogle Scholar
Gosling, J. and McGilton, H. (1995). The Java language environment: A whitepaper. Technical Report, Sun Microsystems Computer Company.Google Scholar
Grad, B. (2007). The creation and the demise of VisiCalc. IEEE Annals of the History of Computing, 29(3):20–31.10.1109/MAHC.2007.4338439CrossRefGoogle Scholar
Greelish, D. (2013). An interview with computing pioneer Alan Kay. Time Magazine. Greenblatt, R. (2005). Oral history of Richard Greenblatt, interviewed by Gardner Hendrie, January 12, 2005. Technical Report X3056.2005, Computer History Museum.Google Scholar
Gresham-Lancaster, S. (1998). The aesthetics and history of the Hub: The effects of changing technology on network computer music. Leonardo Music Journal, 8(1):39–44.10.2307/1513398CrossRefGoogle Scholar
Gries, D., (ed.). (1978). Programming Methodology: A Collection of Articles by Members of IFIP WG 2.3. Springer-Verlag, Berlin, Heidelberg.10.1007/978-1-4612-6315-9CrossRefGoogle Scholar
Gugerty, L. (2006). Newell and Simon’s logic theorist: Historical background and impact on cognitive modeling. Proceedings of the Human Factors and Ergonomics Society Annual Meeting, 50(9):880–884.CrossRefGoogle Scholar
Habermann, A. N. (1969). Prevention of system deadlocks. Communications of the ACM, 12(7):373–ff.10.1145/363156.363160CrossRefGoogle Scholar
Hacking, I. (1983). Representing and Intervening: Introductory Topics in the Philosophy of Natural Science. Cambridge University Press.10.1017/CBO9780511814563CrossRefGoogle Scholar
Haigh, T. (2010). Dijkstra’s crisis: The end of Algol and beginning of software engineering, 1968-72. [Online; accessed August 27, 2021].Google Scholar
Haigh, T. and Ceruzzi, P. E. (2021). A New History of Modern Computing. MIT Press.10.7551/mitpress/11436.001.0001CrossRefGoogle Scholar
Haigh, T., Priestley, P. M., Priestley, M., and Rope, C. (2016). ENIAC in Action: Making and Remaking the Modern Computer. MIT Press.10.7551/mitpress/9780262033985.001.0001CrossRefGoogle Scholar
Halpern, M. (1965). Computer programming: The debugging epoch opens. Computers and Automation, 14(11):28–31.Google Scholar
Halvorson, M. J. (2020). Code Nation: Personal Computing and the Learn to Program Movement in America. ACM Books.10.1145/3368274CrossRefGoogle Scholar
Harrison, J., Urban, J., and Wiedijk, F. (2014). History of interactive theorem proving. Computational Logic, 9:135–214.CrossRefGoogle Scholar
Henhapl, W. and Jones, C. B. (1978). A formal definition of Algol 60 as described in the 1975 modified report, pages 305–336. Springer.Google Scholar
Hetzel, B. (1988). The Complete Guide to Software Testing. QED Information Sciences, 2nd edition.Google Scholar
Hicks, M. (2010). Meritocracy and feminization in conflict: computerization in the British government. In Misa, T. J. (ed.), Gender Codes: Why Women Are Leaving Computing, pages 95–114. IEEE Computer Society and John Wiley & Sons, Inc., Hoboken, New Jersey.10.1002/9780470619926.ch5CrossRefGoogle Scholar
Hicks, M. (2017). Programmed Inequality: How Britain Discarded Women Technologists and Lost Its Edge in Computing. MIT Press.Google Scholar
Hiltzik, M. A. et al. (1999). Dealers of Lightning: Xerox PARC and the Dawn of the Computer Age. HarperCollins Publishers.Google Scholar
Hoare, C. A. (1971). Proof of a program: Find. Communications of the ACM, 14(1):39–45.10.1145/362452.362489CrossRefGoogle Scholar
Hoare, C. A. R. (1969). An axiomatic basis for computer programming. Communications of the ACM, 12(10):576–580.CrossRefGoogle Scholar
Hoare, C. A. R. (1972). Notes on data structuring. In Dahl, O. J., Dijkstra, E. W. and Hoare, C. A. R. (eds.), Structured Programming. pages 83–174. Academic Press.Google Scholar
Hoare, C. A. R. (1981). The emperor’s old clothes. Communications of the ACM, 24(2):75–83.10.1145/358549.358561CrossRefGoogle Scholar
Hoare, C. A. R. (1996). How did software get so reliable without proof? In Gaudel, M.-C. and Woodcock, J., (eds.), FME’96: Industrial Benefit and Advances in Formal Methods, pages 1–17, Springer.Google Scholar
Hodges, W. (2001). A history of british logic. http://wilfridhodges.co.uk/history01.pdf.Google Scholar
Hohpe, G. (2005). Revenge of the nerds – OOPSLA 2005. www.enterpriseintegrationpatterns.com/ramblings/37_oopsla.html.Google Scholar
Holmevik, J. (1994). Compiling simula: A historical study of technological genesis. IEEE Annals of the History of Computing, 16(4):25–37.10.1109/85.329756CrossRefGoogle Scholar
Honda, K. (1993). Types for dyadic interaction. In Best, E. (ed.), 4th International Conference on Concurrency Theory (CONCUR’ 93), Hildesheim, Germany, 23–26 August, 509–523. Springer.Google Scholar
Hooker, S. (2021). Moving beyond ‘algorithmic bias is a data problem’. Patterns, 2(4):100241.10.1016/j.patter.2021.100241CrossRefGoogle ScholarPubMed
Hoyningen-Huene, P. and Sankey, H., (eds.). (2001). Incommensurability and Related Matters. Dordrecht: Kluwer.10.1007/978-94-015-9680-0CrossRefGoogle Scholar
Huang, J. C. (1975). An approach to program testing. ACM Computing Surveys, 7(3):113–128.10.1145/356651.356652CrossRefGoogle Scholar
Hudak, P., Hughes, J., Peyton Jones, S., and Wadler, P. (2007). A history of Haskell: Being lazy with class. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages, HOPL III, page 12–1–12–55, New York. ACM.Google Scholar
Hunt, J. (1997). Smalltalk and Object Orientation: An Introduction. Springer Science & Business Media.10.1007/978-1-4471-0961-7CrossRefGoogle Scholar
IBM (1967). IBM System/360: PL/I subset reference manual. Technical Report S360-29, IBM Systems Reference Library.Google Scholar
IBM (1960). General Information Manual: IBM Commercial Translator. IBM. Online at http://bitsavers.org/pdf/ibm/7090/F28-8043_CommercialTranslatorGenInfMan_Ju60.pdf.Google Scholar
Ichbiah, J. D., Krieg-Brueckner, B., Wichmann, B. A., Barnes, J. G. P., Roubine, O., and Heliard, J. -C. (1979). Rationale for the design of the Ada programming language. SIGPLAN Notices, 14(6b):1–261.Google Scholar
Ingalls, D. (2020). The evolution of Smalltalk: From Smalltalk-72 through Squeak. Proceedings of the ACM on Programming Languages, 4(HOPL).10.1145/3386335CrossRefGoogle Scholar
Ingalls, D., Kaehler, T., Maloney, J., Wallace, S., and Kay, A. (1997). Back to the future: The story of Squeak, a practical Smalltalk written in itself. In Berman, A. M. (ed.), Proceedings of the 12th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA ’97, page 318–326, New York. ACM.CrossRefGoogle Scholar
Ingalls, D., Palacz, K., Uhler, S., Taivalsaari, A., and Mikkonen, T. (2008). The lively kernel a self-supporting system on a web page. In Hirschfeld, R. and Rose, K. (eds.), Self-Sustaining Systems: First Workshop, S3 2008 Potsdam, Germany, May 15–16, 2008 Revised Selected Papers, pages 31–50. Springer.CrossRefGoogle Scholar
Ingalls, D. H. H. (1978). The Smalltalk-76 programming system design and implementation. In Szymanski, T. G. (ed.), Proceedings of the 5th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL ’78, page 9–16, New York. ACM.Google Scholar
Jacobson, I., Booch, G., and Rumbaugh, J. (1999). The Unified Software Development Process. Addison-Wesley.Google Scholar
Jacobson, I., Ng, P.-W., McMahon, P. E., Goedicke, M., et al. (2019). The Essentials of Modern Software Engineering: Free the Practices from the Method Prisons! Morgan & Claypool.Google Scholar
Jakubovic, J., Edwards, J., and Petricek, T. (2023). Technical dimensions of programming systems. The Art, Science, and Engineering of Programming, 7(3):13–1.10.22152/programming-journal.org/2023/7/13CrossRefGoogle Scholar
Johns, A. (2010). Piracy: The Intellectual Property Wars from Gutenberg to Gates. University of Chicago Press.Google Scholar
Johnson, J., Roberts, T. L., Verplank, W., Smith, D. C., Irby, C. H., Beard, M., and Mackey, K. (1989). The Xerox star: A retrospective. Computer, 22(9):11–26.10.1109/2.35211CrossRefGoogle Scholar
Jones, A. K. and Liskov, B. (1976). An access control facility for programming languages. Technical Report AFOSR-TR 76-0886, Massachusetts Institute of Technology, Laboratory for Computer Science.CrossRefGoogle Scholar
Jones, C. B. and Astarte, T. K. (2016). An Exegesis of Four Formal Descriptions of Algol 60. Technical Report CS-TR-1498, Newcastle University School of Computer Science. (abstract). In Silberber, M. Y. (ed.), Proceedings of the November 16-18, 1971, Fall Joint Computer Conference, AFIPS ’71 (Fall), page 395–396, New York. ACM.Google Scholar
Kay, A. (1972b). A personal computer for children of all ages. In Donovan, J. J. and Shields, R. (eds.), Proceedings of the ACM annual conference-Volume 1.Google Scholar
Kay, A. (1974). Summary of Smalltalk message forms and intentions. Technical Report, Xerox Palo Alto Research Center.Google Scholar
Kay, A. (1997). The computer revolution hasn’t happened yet (keynote). The 12th annual ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages and Applications, Atlanta, USA.Google Scholar
Kay, A. (1998). prototypes vs classes was: Re: Sun’s hotspot. http://lists.squeakfoundation.org/pipermail/squeak-dev/1998-October/017019.html. E-mail sent to the squeak-dev mailing list, Accessed: July 25, 2023.Google Scholar
Kay, A. (2003). Clarification of ‘object-oriented’. http://userpage.fu-berlin.de/~ram/pub/pub_ jf47ht81Ht/doc_kay_oop_en. E-mail exchange with Stefan Ram, Accessed: July 25, 2023.Google Scholar
Kay, A. and Goldberg, A. (1977). Personal dynamic media. Computer, 10(3):31–41.10.1109/C-M.1977.217672CrossRefGoogle Scholar
Kay, A. C. (1968). FLEX, a flexible extendable language. Master’s thesis, Utah University.Google Scholar
Kay, A. C. (1996). The early history of Smalltalk. History of programming languages—II, pages 511–598.10.1145/234286.1057828CrossRefGoogle Scholar
Kell, S. (2014). In search of types. In Bruegge, B. and Krishnamurthi, S. (eds.), Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software, Onward! 2014, pages 227–241, New York. ACM.Google Scholar
Kell, S. (2017). Some were meant for C: The endurance of an unmanageable language. In Torlak, E., van der Storm, T., and Biddle, R., (eds.), Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! Vancouver, BC, October 23–27, 2017, pages 229–245. ACM.Google Scholar
Kell, S. (2018). Unix, Plan 9 and the lurking Smalltalk. In De Mol, L. and Primiero, G. (eds.), Philosophical Studies Series, vol 133. Reflections on Programming Systems: Historical and Philosophical Aspects, Philosophical Studies Series, vol 133, 189–213.10.1007/978-3-319-97226-8_6CrossRefGoogle Scholar
Kelty, C. M. (2008). Two Bits: The Cultural Significance of Free Software. Duke University Press.Google Scholar
Kennedy, A. J. (1996). Programming languages and dimensions. PhD thesis, University of Cambridge, Computer Laboratory.Google Scholar
Kiczales, G., Des Rivieres, J., and Bobrow, D. G. (1991). The Art of the Metaobject Protocol. MIT Press.10.7551/mitpress/1405.001.0001CrossRefGoogle Scholar
Kidwell, P. A. (1998). Stalking the elusive computer bug. IEEE Annals of the History of Computing, 20(4):5–9.10.1109/85.728224CrossRefGoogle Scholar
Kleiman, K. (2022). Proving Ground: The Untold Story of the Six Women Who Programmed the World’s First Modern Computer. Hurst Publishers.10.14375/NP.9781787389205CrossRefGoogle Scholar
Klein, G., Andronick, J., Fernandez, M., Kuz, I., Murray, T. C., and Heiser, G. (2018). Formally verified software in the real world. Communications of the ACM, 61(10):68–77.10.1145/3230627CrossRefGoogle Scholar
Kleiner, D. (2010). The telekommunist manifesto, volume 3. Institute of Network Cultures Amsterdam.Google Scholar
Knuth, D. (1968). The Art of Computer Programming, volume 1–4. Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA.Google Scholar
Knuth, D. E. (1973). A review of ‘structured programming’. Technical Report STAN-CS-73-371, Computer Science Department, Stanford University.Google Scholar
Kotok, A. (2005). Oral history of Alan Kotok, interviewed by Gardner Hendrie, November 15, 2004. Technical Report X3004.2005, Computer History Museum.Google Scholar
Kristensen, B. B., Madsen, O. L., and Møller-Pedersen, B. (2007). The when, why and why not of the BETA programming language. In Ryder, B. and Hailpern, B. (eds.), Proceedings of the third ACM SIGPLAN conference on History of programming languages, pages 10–1.CrossRefGoogle Scholar
Kuhn, T. (1962). The Structure of Scientific Revolutions. University of Chicago Press.Google Scholar
Kusner, M. J., Loftus, J., Russell, C., and Silva, R. (2017). Counterfactual fairness. Advances in Neural Information Processing Systems, 30.Google Scholar
Laan, T. D. L. (1997). The evolution of type theory in logic and mathematics. PhD thesis.Google Scholar
Lakatos, I. (1976). Proofs and Refutations: The Logic of Mathematical Discovery. Cambridge University Press.10.1017/CBO9781139171472CrossRefGoogle Scholar
Lampson, B. (1972). Why Alto? Technical Report, Xerox PARC. www.microsoft.com/en-us/research/wp-content/uploads/2016/11/Acrobat-1.pdf.Google Scholar
Landin, P. J. (1964). The mechanical evaluation of expressions. The Computer Journal, 6(4):308–320.CrossRefGoogle Scholar
Landin, P. J. (1965a). Correspondence between Algol 60 and Church’s lambda-notation: Part i. Communications of the ACM, 8(2):89–101.10.1145/363744.363749CrossRefGoogle Scholar
Landin, P. J. (1965b). A correspondence between Algol 60 and Church’s lambda-notations: Part ii. Communications of the ACM, 8(3):158–167.10.1145/363791.363804CrossRefGoogle Scholar
Landin, P. J. (1966a). A formal description of Algol 60. In Steel, T. B. Jr. (ed.), Formal Language Description Languages for Computer Programming, pages 266–294. North Holland Publishing Company, Amsterdam.Google Scholar
Landin, P. J. (1966b). The next 700 programming languages. Communications of the ACM, 9(3):157–166.10.1145/365230.365257CrossRefGoogle Scholar
Latour, B. (1987). Science in Action: How to Follow Scientists and Engineers through Society. Harvard university press.Google Scholar
Lauer, P. E. (1968). Formal definition of Algol 60. Technical Report 25.088, IBM Laboratory Vienna.Google Scholar
Leavenworth, B. M. (1972). Programming with(out) the goto. SIGPLAN Not., 7(11):54–58.10.1145/987361.987370CrossRefGoogle Scholar
Lehman, M. M. (1980). Programs, life cycles, and laws of software evolution. Proceedings of the IEEE, 68(9):1060–1076.10.1109/PROC.1980.11805CrossRefGoogle Scholar
Lehman, M. M. (1993). An interview conducted by William Aspray, IEEE History Center, September 23, 1993. Technical Report 178, The Institute of Electrical and Electronics Engineers, Inc.Google Scholar
Lehman, M. M. and Belady, L. A. (1985). Program Evolution: Processes of Software Change. Academic Press.Google Scholar
Lennon, B. (2019). Foo, bar, baz…: The metasyntactic variable and the programming language hierarchy. In Petricek, T., Durnova, H. and Priestley, M. (eds.), Philosophy & Technology. 34(1):13–32.10.1007/s13347-019-00387-2CrossRefGoogle Scholar
Leroy, X. (2009). Formal verification of a realistic compiler. Communications of the ACM, 52(7):107–115.10.1145/1538788.1538814CrossRefGoogle Scholar
Licklider, J. C. (1969). Underestimates and overexpectations. Computers and Automation, 18(9):48–52.Google Scholar
Licklider, J. C. R. (1960). Man-computer symbiosis. IRE Transactions on Human Factors in Electronics, HFE-1(1):4–11.CrossRefGoogle Scholar
Liskov, B. (1993). A history of Clu. In Bergin, T. J. and Gibson, R. G. (eds.), The Second ACM SIGPLAN Conference on History of Programming Languages, HOPL-II, pages 133–147, New York. ACM.10.1145/154766.155367CrossRefGoogle Scholar
Liskov, B. and Zilles, S. (1974). Programming with abstract data types. In Leavenworth, B., (ed.), Proceedings of the ACM SIGPLAN Symposium on Very High Level Languages, pages 50–59, New York. ACM.10.1145/800233.807045CrossRefGoogle Scholar
Livingston, E. (1999). Cultures of proving. Social Studies of Science, 29(6):867–888.CrossRefGoogle Scholar
Livshits, B., Sridharan, M., Smaragdakis, Y., Lhoták, O., Amaral, J. N., Chang, B. -Y. E., Guyer, S. Z., Khedker, U. P., Møller, A., and Vardoulakis, D. (2015). In defense of soundiness: A manifesto. Communications of the ACM, 58(2):44–46.10.1145/2644805CrossRefGoogle Scholar
Llewelyn, A. and Wickens, R. (1968). The testing of computer software. In Naur, P. and Randall, B. (eds.), Software Engineering, Report on a conference sponsored by the NATO SCIENCE COMMITTEE, Garmisch, Germany, pages 7–11.Google Scholar
MacKenzie, D. (2004). Mechanizing Proof: Computing, Risk, and Trust. Inside technology. MIT Press.Google Scholar
MacKenzie, D. (2005). Computing and the cultures of proving. Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences, 363(1835):2335–2350.Google Scholar
MacKenzie, D. (2014). A sociology of algorithms: High-frequency trading and the shaping of markets. https://c.mql5.com/forextsd/forum/169/algorithms25.pdf.Google Scholar
MacQueen, D., Harper, R., and Reppy, J. (2020). The history of Standard ML. In Steele, G. L. Jr. (ed.), Proceedings of the ACM on Programming Languages, 4(HOPL):1–100.Google Scholar
Madsen, O. L. and Møller-Pedersen, B. (2022). What object-oriented programming was supposed to be: Two grumpy old guys’ take on object-oriented programming. In Scholliers, C. and Singer, J., (eds.), Proceedings of the 2022 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! Auckland, New Zealand, December 8–10, 2022, pages 220–239. ACM.Google Scholar
Magnusson, L. and Nordström, B. (1993). The ALF proof editor and its proof engine. In Barendregt, H. and Nipkow, T. (eds.), International Workshop on Types for Proofs and Programs, pages 213–237. Springer.Google Scholar
Mahoney, M. S. (1988). The history of computing in the history of technology. Annals of the History of Computing, 10(2):113–125.10.1109/MAHC.1988.10011CrossRefGoogle Scholar
Mahoney, M. S. (1992). Computers and mathematics: The search for a discipline of computer science. In Echeverría, J., Ibarra, A. and Mormann, T. (eds.), The Space of Mathematics. Philosophical, Epistemological, and Historical Explorations. Berlin: Springer, pages 349–363.10.1515/9783110870299.349CrossRefGoogle Scholar
Mahoney, M. S. (1997). Computer Science: The Search for a Mathematical Theory. Taylor and Francis.Google Scholar
Mahoney, M. S. (2005). The histories of computing(s). Interdisciplinary Science Reviews, 30(2):119–135.10.1179/030801805X25927CrossRefGoogle Scholar
Markoff, J. (2005). What the dormouse said: How the sixties counterculture shaped the personal computer industry. Viking Press.Google Scholar
Martini, S. (2016). Several types of types in programming languages. In Gadducci, F. and Tavosanis, M., (eds.), History and Philosophy of Computing, pages 216–227. Springer International Publishing.10.1007/978-3-319-47286-7_15CrossRefGoogle Scholar
McBride, C. (2002). Faking it simulating dependent types in Haskell. Journal of Functional Programming, 12(4–5):375–392.10.1017/S0956796802004355CrossRefGoogle Scholar
McBride, C. and McKinna, J. (2004). The view from the left. Journal of Functional Programming, 14(1):69–111.10.1017/S0956796803004829CrossRefGoogle Scholar
McBurney, P. (2009). Guerrilla logic: A salute to Mervyn Pragnell. https://vukutu.com/blog/2009/09/guerrilla-logic-a-salute-to-mervyn-pragnell/.Google Scholar
McCabe, T. (1976). A complexity measure. IEEE Transactions on Software Engineering, SE-2(4):308–320.10.1109/TSE.1976.233837CrossRefGoogle Scholar
McCarthy, J. (1961). A basis for a mathematical theory of computation, preliminary report. In Bauer, W. F. (ed.), Papers presented at the May 9–11, 1961, Western Joint IRE-AIEE-ACM Computer Conference, pages 225–238.10.1145/1460690.1460715CrossRefGoogle Scholar
McCarthy, J. (1962). Computer programs for checking mathematical proofs. In Dekker, J. C. E. (ed.), Proceedings of Symposia in Pure Mathematics, vol 5. American Mathematical Society.Google Scholar
McCarthy, J. (1963). Towards a mathematical science of computation. In Popplewell, C. M., (ed.), Information Processing, pages 21–28. North-Holland Publishing Company.Google Scholar
McCarthy, J. (1964). A formal description of a subset of Algol. In Steel, T. B. (ed.), Formal Language Description Languages for Computer Programming, pages 1–12. North-Holland Publishing Company.Google Scholar
McCarthy, J. (1978). History of LISP. In Wexelblat, R. L. (ed.), History of Programming Languages, pages 173–185, ACM.10.1145/800025.1198360CrossRefGoogle Scholar
McCarthy, J. (1992). Reminiscences on the history of time-sharing. IEEE Annals of the History of Computing, 14(1):19–24.Google Scholar
McCarthy, J., Abrahams, P. W., Edwards, D. J., Hart, T. P., and Levin, M. I. (1962). LISP 1.5 Programmer’s Manual. MIT Press.10.21236/AD0406138CrossRefGoogle Scholar
McCracken, D. (1973). Revolution in programming: An overview. Datamation, pages 50–52.Google Scholar
McGonagle, J. D. (1972). Notes on the computer program test methods symposium. SIGPLAN Notices, 7(5):8–12.10.1145/987053.987056CrossRefGoogle Scholar
McKinsey (1968). Unlocking the computer’s profit potential. Technical Report, McKinsey & Company, Inc.Google Scholar
Meerts, J. and Graham, D. (2010). The History of Software Testing. www.testingref_erences.com/testinghistory.php.Google Scholar
Meyer, E. A. (2002). ‘Considered Harmful’: essays considered harmful. https://meyerweb.com/eric/comment/chech.html.Google Scholar
Mills, H., Dyer, M., and Linger, R. (1987). Cleanroom software engineering. IEEE Software, 4(5):19–25.10.1109/MS.1987.231413CrossRefGoogle Scholar
Milner, R. (1972). Logic for computable functions: Description of a machine implementation. Technical Report, Stanford, CA, USA.Google Scholar
Milner, R. (1978). A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17(3):348–375.CrossRefGoogle Scholar
Milner, R. (1979). LCF: A way of doing proofs with a machine. In Bečvář, J., (ed.), Mathematical Foundations of Computer Science 1979, pages 146–159. Springer.CrossRefGoogle Scholar
Milner, R. (2003). An interview with Robin Milner, interviewed by Martin Berger, September 3, 2003. https://users.sussex.ac.uk/~mfb21/interviews/milner/.Google Scholar
Milner, R. and Weyhrauch, R. (1972). Proving compiler correctness in a mechanized logic. Machine Intelligence, 7(3):51–70.Google Scholar
Mitchell, J. C. (2003). Concepts in Programming Languages. Cambridge University Press.Google Scholar
Montfort, N., Baudoin, P., Bell, J., Bogost, I., and Douglass, J. (2014). 10 PRINT CHR (205.5+ RND (1));: GOTO 10. MIT Press.Google Scholar
Moore, J. S. (2019). Milestones from the pure LISP theorem prover to ACL2. Formal Aspects of Computing, 31(6):699–732.10.1007/s00165-019-00490-3CrossRefGoogle Scholar
Morris, J. H. (1973a). Protection in programming languages. Communications of the ACM, 16(1):15–21.10.1145/361932.361937CrossRefGoogle Scholar
Morris, Jr., J. H. (1973b). Types are not sets. In Ullman, J. D. (ed.), Proceedings of the 1st Annual ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL ’73, pages 120–124, New York. ACM.Google Scholar
Morris, J. H. Jr (1969). Lambda-calculus models of programming language. PhD thesis, Massachusetts Institute of Technology.Google Scholar
Mosses, P. D. (1974). The mathematical semantics of Algol 60. Technical Report Technical Monograph PRG-12, Oxford University Computing Laboratory, Programming Research Group.Google Scholar
Mugridge, R. (2003). Test driven development and the scientific method. In Cockburn, A. (ed.), Proceedings of the Agile Development Conference, 2003. ADC 2003, pages 47–52. IEEE.Google Scholar
Murhpy, E. M. (2013). In the Matter of Knight Capital Americas LLC Respondent. Technical Report SEC Release No. 70694, File No. 3-15570, Securities and Exchange Commission.Google Scholar
Musa, J. D. (1975). A theory of software reliability and its application. IEEE Transactions on Software Engineering, 1:312–327.Google Scholar
Myers, G. J., Badgett, T., and Sandler, C. (1979). The Art of Software Testing. John Wiley & Sons, pages 22041–3467.Google Scholar
Nake, F. (1971). There should be no computer art. In Metzger, G. (ed.), Bulletin of the Computer Arts Society, PAGE 18 :1–2.Google Scholar
Nance, R. E. (1993). A history of discrete event simulation programming languages. In The Second ACM SIGPLAN Conference on History of Programming Languages, HOPL-II, page 149–175, New York. ACM.10.1145/154766.155368CrossRefGoogle Scholar
National Bureau of Standards. (1984). Guideline for lifecycle validation, verification, and testing of computer software. Technical Report, U.S. Dept. of Commerce, National Bureau of Standards.Google Scholar
National Museum of American History (2024). Log book with computer bug. https://americanhistory.si.edu/collections/nmah_334663.Google Scholar
Naur, P. (1966). Proof of algorithms by general snapshots. BIT Numerical Mathematics, 6(4):310–316.10.1007/BF01966091CrossRefGoogle Scholar
Naur, P. (1978). The European Side of the Last Phase of the Development of Algol 60, page 92–139, New York. ACM.Google Scholar
Naur, P. (1993). The place of strictly defined notation in human insight. In Colburn, T. R., Fetzer, J. H. and Rankin, T. L. (eds.), Program Verification, pages 261–274. Springer.CrossRefGoogle Scholar
Naur, P., Randell, B., Bauer, F., and Committee, N. S. (1969). Software engineering: report on a conference sponsored by the NATO Science Committee, Garmisch, Germany, 7th to 11th October 1968. Scientific Affairs Division, NATO.Google Scholar
Neff, G. and Nagy, P. (2016). Talking to bots: Symbiotic agency and the case of Tay. International Journal of Communication, 10:4915–4931.Google Scholar
Newell, A. and Simon, H. (1956). The logic theory machine: A complex information processing system. IRE Transactions on Information Theory, 2(3):61–79.10.1109/TIT.1956.1056797CrossRefGoogle Scholar
Noble, S. U. (2018). Algorithms of Oppression. New York University Press.10.18574/nyu/9781479833641.001.0001CrossRefGoogle Scholar
Nofre, D., Priestley, M., and Alberts, G. (2014). When technology became language: The origins of the linguistic conception of computer programming, 1950–1960. Technology and Culture, 55(1):40–75.10.1353/tech.2014.0031CrossRefGoogle ScholarPubMed
Noll, A. M. (2016). The Howard Wise gallery show computer-generated pictures (1965): A 50th-anniversary memoir. Leonardo, 49(3):232–239.10.1162/LEON_a_01158CrossRefGoogle Scholar
Nooney, L. (2023). The Apple II Age: How the Computer Became Personal. University of Chicago Press.10.7208/chicago/9780226816531.001.0001CrossRefGoogle Scholar
Nordström, B., Petersson, K., and Smith, J. M. (1990). Programming in Martin-Löf’s Type Theory, Volume 200. Oxford University Press, Oxford.Google Scholar
Norell, U. (2007). Towards a practical programming language based on dependent type theory. PhD thesis.Google Scholar
November, J. (2004). Linc: Biology’s revolutionary little computer. Endeavour, 28(3):125–131.10.1016/j.endeavour.2004.07.006CrossRefGoogle ScholarPubMed
Nygaard, K. and Dahl, O. -J. (1978). The development of the SIMULA languages. SIGPLAN Notices, 13(8):245–272.10.1145/960118.808391CrossRefGoogle Scholar
O’Neil, C. (2016). Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. Broadway Books.Google Scholar
Ornstein, S. (2002). Computing in the Middle Ages: A View from the Trenches. AuthorHouse.Google Scholar
Parnas, D. L. (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12):1053–1058.10.1145/361598.361623CrossRefGoogle Scholar
Parnas, D. L. (1985). Software aspects of strategic defense systems. Communications of the ACM, 28(12):1326–1335.10.1145/214956.214961CrossRefGoogle Scholar
Passani, L. (1996). Java naysayer or realist? (letter). Dr. Dobb’s Journal, (251):10–11.Google Scholar
Paulson, L. C. (1993). Designing a theorem prover. In Abramsky, S., Gabbay, D. M. and Spurr, J. (eds.), Handbook of Logic in Computer Science (vol. 2) Background: Computational Structures, pages 415–475.Google Scholar
Pelaez Valdez, M. E. (1988). A gift from Pandora’s box: The software crisis. PhD thesis, University of Edinburgh.Google Scholar
Perlis, A. J. (1978). The American Side of the Development of Algol, page 75–91, New York. ACM.Google Scholar
Perlis, A. J. and Samelson, K. (1958). Preliminary report: International algebraic language. Communications of the ACM, 1(12):8–22.10.1145/377924.594925CrossRefGoogle Scholar
Petricek, T. (2015). Against a universal definition of ’type’. In Murphy, G. C. and Steele, G. L. Jr. (eds.), 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward!), Onward! 2015, pages 254–266, New York. ACM.10.1145/2814228.2814249CrossRefGoogle Scholar
Petricek, T. (2017). Miscomputation in software: Learning to live with errors. The Art, Science, and Engineering of Programming, 1(2):14.10.22152/programming-journal.org/2017/1/14CrossRefGoogle Scholar
Petricek, T. (2018). What we talk about when we talk about monads. The Art, Science, and Engineering of Programming, 2(3):12.10.22152/programming-journal.org/2018/2/12CrossRefGoogle Scholar
Petricek, T. (2020). The lost ways of programming: Commodore 64 basic. Presented at HaPoC 2020.Google Scholar
Petricek, T. (2023). The rise and fall of extensible programming languages. Abstract presented at 7th International Conference on the History and Philosophy of Computing.Google Scholar
Petricek, T., Orchard, D., and Mycroft, A. (2014). Coeffects: A calculus of context-dependent computation. In Chakravarty, M. (ed.), Proceedings of the 19th ACM SIGPLAN International Conference on Functional Programming, ICFP ’14, pages 123–135, New York. ACM.CrossRefGoogle Scholar
Pirsig, R. M. (1999). Zen and the Art of Motorcycle Maintenance:An Inquiry into Values. Random House.Google Scholar
Pitts, A. M. (2011). Lecture notes on types for Part II of the computer science tripos. www.cl.cam.ac.uk/teaching/1112/Types/typ-notes.pdf.Google Scholar
Pleasant, James, , C. (1989). The very idea (technical correspondence). Communications of the ACM, 32(3):374–381.Google Scholar
Plotkin, G. and Pretnar, M. (2009). Handlers of algebraic effects. In Castagna, G. (ed.), European Symposium on Programming, pages 80–94. Springer.Google Scholar
Postley, J. A. (1960). Letters to the editor. Communications of the ACM, 3(1):0.06–.10.1145/366947.366948CrossRefGoogle Scholar
Priestley, M. (2011). A Science of Operations: Machines, Logic and the Invention of Programming. Springer.CrossRefGoogle Scholar
Priestley, M. (2017). AI and the origins of the functional programming language style. Minds and Machines, 27(3):449–472.10.1007/s11023-017-9432-7CrossRefGoogle Scholar
Primiero, G. (2019). On the Foundations of Computing. Oxford University Press.10.1093/oso/9780198835646.001.0001CrossRefGoogle Scholar
PROGRAMme (2022). What is a computer program? In De Mol, E. (ed.), title and publisher to be added at proof stage.Google Scholar
Project MAC (1967). Project MAC progress report III – July 1965 to July 1966. Technical Report DTIC AD-648346, MIT.Google Scholar
Pym, D., Spring, J. M., and O’Hearn, P. (2019). Why separation logic works. Philosophy & Technology, 32(3):483–516.10.1007/s13347-018-0312-8CrossRefGoogle Scholar
Radin, G. (1978). The early history and characteristics of PL/I. SIGPLAN Notices, 13(8):227–241.10.1145/960118.808389CrossRefGoogle Scholar
Randell, B. (1975). System structure for software fault tolerance. IEEE Transactions on Software Engineering, SE-1(2):220–232.10.1109/TSE.1975.6312842CrossRefGoogle Scholar
Rankin, J. L. (2018). A People’s History of Computing in the United States. Harvard University Press.10.4159/9780674988538CrossRefGoogle Scholar
Redmond, K. C. and Smith, T. M. (2000). From Whirlwind to MITRE: The R&D Story of the SAGE Air Defense Computer. MIT Press.Google Scholar
Reenskaug, T. M. H. (1981). User-oriented descriptions of smalltalk systems. Byte, 6, 8.Google Scholar
Rentsch, T. (1982). Object oriented programming. SIGPLAN Notices, 17(9):51–57.10.1145/947955.947961CrossRefGoogle Scholar
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., Millner, A., Rosenbaum, E., Silver, J., Silverman, B., et al. (2009). Scratch: Programming for all. Communications of the ACM, 52(11):60–67.CrossRefGoogle Scholar
Reynolds, J. C. (1974). Towards a theory of type structure. In Robinet, B., (ed.), Programming Symposium, pages 408–425, Springer.10.1007/3-540-06859-7_148CrossRefGoogle Scholar
Rheingold, H. (2000). Tools for Thought: The History and Future of Mind-Expanding Technology. MIT Press.Google Scholar
Richards, G., Nardelli, F. Z., and Vitek, J. (2015). Concrete Types for TypeScript. In Boyland, J. T., (ed.), 29th European Conference on Object-Oriented Programming (ECOOP 2015), volume 37, pages 76–100, Dagstuhl, Germany. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik.Google Scholar
Rochester, N. (1960). Foreword. In Rochester, N. (ed.), Papers Presented at the December 13-15, 1960, Eastern Joint IRE-AIEE-ACM Computer Conference, IRE-AIEE-ACM ’60 (Eastern), page 1–9, New York, ACM.Google Scholar
Rosenwasser, D. (2018). Announcing TypeScript 3.0. https://blogs.msdn.microsoft.com/typescript/2018/07/30/announcing-typescript-3-0/.Google Scholar
Ross, D. T. (1961). A generalized technique for symbol manipulation and numerical calculation. Communications of the ACM, 4(3):147–150.10.1145/366199.366256CrossRefGoogle Scholar
Royce, W. W. (1970). Managing the development of large software systems. In Proceedings IEEE WESCON, pages 1–9.Google Scholar
Rushby, J. M. and Von Henke, F. (1993). Formal verification of algorithms for critical systems. IEEE Transactions on Software Engineering, 19(1):13–23.10.1109/32.210304CrossRefGoogle Scholar
Russell, B. (1903). Appendix B: The doctrine of types. In Russell, B. (ed.), Principles of Mathematics, pages 523–528. Cambridge University Press.Google Scholar
Russell, B. (1908). Mathematical logic as based on the theory of types. American Journal of Mathematics, 30(3):222–262.10.2307/2369948CrossRefGoogle Scholar
Russell, S. (2017). Interview with Stephen (Steve) ‘Slug’ Russell, conducted by Christopher Weaver, January 8, 2017. Technical Report, Video Game Pioneers Oral History Collection, Archives Center, National Museum of American History, Smithsonian Institution, Washington, DC.Google Scholar
Russell, S. R. (1963). Improvements in LISP debugging. Technical Report AIM-10, Stanford Artificial Intelligence Project.Google Scholar
Ryder, B. G., Soffa, M. L., and Burnett, M. (2005). The impact of software engineering research on modern progamming languages. ACM Transactions on Software Engineering and Methodology, 14(4):431–477.CrossRefGoogle Scholar
Sack, W. (2022). Miniatures, demos and artworks: Three kinds of computer program, their uses and abuses. In De Mol, L. and Petricek, T. (eds.), Fifth Symposium on the History and Philosophy of Programming, HaPoP 2022, pages 21–24. HAPOC.Google Scholar
Sammet, J. E. (1961). Detailed description of cobol. In Goodman, R., (ed.), Annual Review in Automatic Programming, volume 2 of International Tracts in Computer Science and Technology and Their Application, pages 197–230. Elsevier.10.1016/B978-1-4831-9779-1.50013-6CrossRefGoogle Scholar
Sammet, J. E. (1969). Programming Languages: History and Fundamentals. Prentice-Hall, Inc.Google Scholar
Sammet, J. E. (1978). The early history of COBOL. SIGPLAN Notices, 13(8):121–161.10.1145/960118.808378CrossRefGoogle Scholar
Samson, P. (2017). Interview with Peter Samson, conducted by Christopher Weaver, January 9, 2017. Technical Report, Video Game Pioneers Oral History Collection, Archives Center, National Museum of American History, Smithsonian Institution, Washington, DC.Google Scholar
Schank, R. and Riesbeck, C. (1981). Inside Computer Understanding: Five Programs Plus Miniatures. Lawrence Erlbaum Associates.Google Scholar
Schuman, S. A. and Jorrand, P. (1970). Definition mechanisms in extensible programming languages. In Brown, D. (ed.), Proceedings of the November 17-19, 1970, Fall Joint Computer Conference, AFIPS ’70 (Fall), pages 9–20, New York. ACM.Google Scholar
Schwaber, K. (1997). Scrum development process. In Sutherland, J., Casanave, C., Miller, J., Patel, P. and Hollowell, G. (eds.), Business Object Design and Implementation, pages 117–134. Springer.10.1007/978-1-4471-0947-1_11CrossRefGoogle Scholar
Scott, D. S. (1993). A type-theoretical alternative to ISWIM, CUCH, OWHY. Theoretical Computer Science, 121(1):411–440.10.1016/0304-3975(93)90095-BCrossRefGoogle Scholar
Seemann, M. (2021). Code That Fits in Your Head: Heuristics for Software Engineeing. Addison-Wesley Professional.Google Scholar
Shapin, S. and Schaffer, S. (2011). Leviathan and the Air-Pump: Hobbes, Boyle, and the Experimental Life. Princeton University Press.Google Scholar
Simondon, G. (2016). On the Mode of Existence of Technical Objects. Univocal Publishing.Google Scholar
Skelton, M., Pais, M., and Malan, R. (2019). Team Topologies: Organizing Business and Technology Teams for Fast Flow. IT Revolution Press.Google Scholar
Slayton, R. (2013). Arguments That Count: Physics, Computing, and Missile Defense, 1949-2012. Arguments that Count. MIT Press.10.7551/mitpress/9234.001.0001CrossRefGoogle Scholar
Smith, B. C. (1985). Limits of correctness in computers. Technical Report CSLI-85-36, The Center for the Study of Language and Information, Stanford, CA.Google Scholar
Smith, D. A., Raab, A., Reed, D., and Kay, A. (2002). Croquet: The user manual (draft revision 0.1). Technical Report, Viewpoints Research Institute, Glendale.Google Scholar
Smith, D. C. (1977). Pygmalion: A Computer Program to Model and Stimulate Creative Thought. Birkhauser.CrossRefGoogle Scholar
Smith, R. B. and Ungar, D. (1995). Programming as an experience: The inspiration for Self. In Tokoro, M. and Pareschi, R. (eds.), European Conference on Object-Oriented Programming, pages 303–330. Springer.10.1007/3-540-49538-X_15CrossRefGoogle Scholar
Solomon, C., Harvey, B., Kahn, K., Lieberman, H., Miller, M. L., Minsky, M., Papert, A., and Silverman, B. (2020). History of Logo. Proceedings of the ACM on Programming Languages, 4(HOPL):79:1–79:66.10.1145/3386329CrossRefGoogle Scholar
Star, S. L. and Griesemer, J. R. (1989). Institutional ecology, ‘translations’ and boundary objects: Amateurs and professionals in Berkeley’s Museum of Vertebrate Zoology, 1907–39. Social Studies of Science, 19(3):387–420.10.1177/030631289019003001CrossRefGoogle Scholar
Steele, G. L. and Gabriel, R. P. (1996a). The evolution of LISP (draft). www.dreamsongs.com/Files/HOPL2-Uncut.pdf.Google Scholar
Steele, G. L. and Gabriel, R. P. (1996b). The evolution of Lisp. In History of Programming Languages—II, pages 233–330. ACMCrossRefGoogle Scholar
Steenson, M. W. (2022). Architectural Intelligence: How Designers and Architects Created the Digital Landscape. MIT Press.Google Scholar
Stockham, T. G. and Dennis, J. B. (1960). FLIT – Flexowriter Interrogation Tape: A symbolic utility program for the TX-0. Technical Report M-5001-23, MIT.Google Scholar
Stroustrup, B. (1988). What is object-oriented programming? IEEE software, 5(3):10–20.CrossRefGoogle Scholar
Stroustrup, B. (1996). A history of C++ 1979–1991. In History of Programming Languages—II, pages 699–769. ACM.10.1145/234286.1057836CrossRefGoogle Scholar
Stroustrup, B. (2007). Evolving a language in and for the real world: C++ 1991–2006. In Ryder, B. and Hailpern, B. (eds.), Proceedings of the third ACM SIGPLAN conference on History of programming languages, pages 4–1.10.1145/1238844.1238848CrossRefGoogle Scholar
Sutherland, I. E. (1963). Sketchpad: A Man-Machine Graphical Communication System. PhD thesis, MIT.10.1145/1461551.1461591CrossRefGoogle Scholar
Sutherland, W. R. (1966). On-line Graphical Specification of Computer Procedures. PhD thesis, MIT, Lincoln Labs Report TR-405.Google Scholar
Syme, D. (2020). The early history of F#. In Steele, G. L. Jr. (ed.), Proceedings of the ACM on Programming Languages, 4(HOPL):1–58.Google Scholar
Syme, D., Petricek, T., and Lomov, D. (2011). The F# asynchronous programming model. In Rocha, R. and Launchbury, J. (eds.), International Symposium on Practical Aspects of Declarative Languages, pages 175–189. Springer.10.1007/978-3-642-18378-2_15CrossRefGoogle Scholar
Takeuchi, H. and Nonaka, I. (1986). The new new product development game. Harvard Business Review, 64(1):137–146.Google Scholar
Talpin, J. and Jouvelot, P. (1994). The type and effect discipline. Information and Computation, 111(2):245–296.10.1006/inco.1994.1046CrossRefGoogle Scholar
Tan, C. (2020). The poetics of computer code: Tracing digital inscription in Ada Lovelace’s England. Digital Studies/Le champ numérique, 10(1).10.16995/dscn.355CrossRefGoogle Scholar
Tedre, M. (2014). The Science of Computing: Shaping a Discipline. CRC Press.10.1201/b17764CrossRefGoogle Scholar
Teitelman, W. (1965). EDIT and BREAK functions for LISP. Technical Report AIM-84, MIT.Google Scholar
Teitelman, W. (1974). INTERLISP reference manual. Technical Report, Xerox Palo Alto Research Center.Google Scholar
Teitelman, W. (1984). The Cedar programming environment: A midterm report and examination. Technical Report, Xerox Palo Alto Research Center.Google Scholar
Thacker, C. P., MacCreight, E., Lampson, B. W., F, S. R., and Boggs, D. R. (1982). Alto: A Personal Computer, chapter 33. McGraw-Hill.Google Scholar
Thagard, P. and Croft, D. (1999). Scientific Discovery and Technological Innovation: Ulcers, Dinosaur Extinction, and the Programming Language Java, pages 125–137. Springer.Google Scholar
The Free Software Foundation (2022). What is free software? www.gnu.org/philosophy/free- sw.en.html, Retrieved July 3, 2022.Google Scholar
Thomas, D. A. (1995). Travels with Smalltalk. web.archive.org/web/20130612055149/www.mojowire.com/TravelsWithSmalltalk/DaveThomas-TravelsWithSmalltalk.htm.Google Scholar
Tofte, M. and Talpin, J.-P. (1997). Region-based memory management. Information and Computation, 132(2):109–176.10.1006/inco.1996.2613CrossRefGoogle Scholar
Tomayko, J. E. (1988). Computers in spaceflight. Technical Report, NASA contractor report CR-182505, National Aeronautics and Space Administration, Scientific and Technical Information Division, Washington, DC, USA.Google Scholar
Tozzi, C. (2017). For Fun and Profit: A History of the Free and Open Source Software Revolution. MIT Press.Google Scholar
Tung, C. C. (1974). The ‘personal computer’: A fully programmable pocket calculator. Hewlett-Packard Journal, 25(9):2–20.Google Scholar
Turing, A. (1949). Checking a large routine. In Report of a Conference on High Speed Automatic Calculating Machines, pages 67–69, Cambridge. University Mathematical Laboratory.Google Scholar
Ungar, D. and Smith, R. B. (2007). Self. In Proceedings of the third ACM SIGPLAN Conference on History of Programming Languages, pages 9–1.Google Scholar
Univac (1957). Introducing a new language for automatic programming univac flow-matic. Computer History Museum, catalog no. 102646140.Google Scholar
Urquhart, A. (1988). Russell’s zig-zag path to the ramified theory of types. Russell: The Journal of Bertrand Russell Archives, Johns Hopkins University Press, 8(1–2), summer/winter 1988, 82–91.Google Scholar
van Wijngaarden, A., Mailloux, B. J., Peck, J. E. L., and Koster, C. H. A. (1969). Report on the Algorithmic Language Algol 68, pages 80–218. Springer.Google Scholar
Vekris, P., Cosman, B., and Jhala, R. (2016). Refinement types for TypeScript. In Berger, E. (ed.), Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’16, pages 310–325, New York. ACM.10.1145/2908080.2908110CrossRefGoogle Scholar
Victor, B. (2013). The future of programming. DBX Conference. https://worrydream.com/dbx/.Google Scholar
von Neumann, J. and Goldstine, H. (1947). Planning and coding of problems for an electronic computing instrument, Part II, vol. 1. Technical Report, Institute for Advanced Study, Princeton.Google Scholar
Wadler, P. (2015). Propositions as types. Communications of the ACM, 58(12):75–84.CrossRefGoogle Scholar
Wadler, P. and Findler, R. B. (2009). Well-typed programs can’t be blamed. In Castagna, G. (ed.), European Symposium on Programming, pages 1–16. Springer.Google Scholar
Waldrop, M. M. (2001). The Dream Machine: J.C.R. Licklider and the Revolution That Made Computing Personal. Viking Penguin.Google Scholar
Ward, A., Rohrhuber, J., Olofsson, F., McLean, A., Griffiths, D., Collins, N., and Alexander, A. (2004). Live algorithm programming and a temporary organisation for its promotion. In Goriunova, O. and Shulgin, A. (eds.), Proceedings of the README Software Art Conference, volume 289, page 290.Google Scholar
Ware, W. H. (1966). Future Computer Technology and Its Impact. RAND Corporation. Weinreb, D. and Moon, D. (1980). Flavors: Message passing in the LISP machine. Technical Report AIM-602, MIT.Google Scholar
Whitaker, W. A. (1993). Ada—the project: The DoD high order language working group. SIGPLAN Notices, 28(3):299–331.10.1145/155360.155376CrossRefGoogle Scholar
Wilkes, M. V., Wheeler, D. J., and Gill, S. (1951). The Preparation of Programs for an Electronic Digital Computer: With Special Reference to the EDSAC and the Use of a Library of Subroutines. Addison-Wesley Press.Google Scholar
Wirfs-Brock, A. (2013). Smalltalk at Tektronix. STIC’13. https://wirfs-brock.com/allen/files/tek/Tek-Smalltalk-history-slides.pdf.Google Scholar
Wirfs-Brock, A. (2020). The rise and fall of commercial Smalltalk. https://wirfs-brock.com/allen/posts/914.Google Scholar
Wirfs-Brock, R. and Wilkerson, B. (1989). Object-oriented design: A responsibility-driven approach. In Bosworth, G. (ed.), Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications, OOPSLA ’89, page 71–75, New York. ACM.10.1145/74877.74885CrossRefGoogle Scholar
Wirfs-Brock, R., Wilkerson, B., and Wiener, L. (1990). Designing Object-Oriented Software. Prentice-Hall, Inc.Google Scholar
Wirth, N. (1971). The programming language Pascal. Acta Informatica, 1(1):35–63.10.1007/BF00264291CrossRefGoogle Scholar
Wirth, N. (1996). Recollections about the Development of Pascal, page 97–120, New York. ACM.Google Scholar
Wlaschin, S. (2018). Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#. Pragmatic Bookshelf.Google Scholar
Wright, A. K. and Felleisen, M. (1994). A syntactic approach to type soundness. Information and Computation, 115(1):38–94.10.1006/inco.1994.1093CrossRefGoogle Scholar
Xi, H. and Pfenning, F. (1999). Dependent types in practical programming. In Appel, A and Aiken, A. (eds.), Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages, pages 214–227.10.1145/292540.292560CrossRefGoogle Scholar
Yau, S. S. and Cheung, R. C. (1975). Design of self-checking software. In Shooman, M. L. and Yeh, R. T. (eds.), Proceedings of the International Conference on Reliable Software, pages 450–455, New York. ACM.10.1145/800027.808468CrossRefGoogle Scholar
Yushchenko, Y. (2022). Pointers in programs on the computer MESM. For the European Virtual Computer Museum of the History of Information Technologies in Ukraine. www.icfcst.kiev.ua/MUSEUM/TXT/YuriYushchenko.pdf.Google Scholar
Zachary, G. P. (2018). Endless Frontier: Vannevar Bush, Engineer of the American Century. Simon and Schuster.Google Scholar
Zilles, S. N. (1973). Procedural encapsulation: A linguistic protection technique. In Graham, R. M. and Schroeder, M. D. (eds.), Proceeding of ACM SIGPLAN - SIGOPS Interface Meeting on Programming Languages - Operating Systems, page 142–146, New York. ACM.10.1145/800021.808305CrossRefGoogle Scholar
Zmölnig, J. and Eckel, G. (2007). Live coding: An overview. In Jensen, K. K. (ed.), Proceedings of the 2007 International Computer Music Conference, ICMC 2007, Copenhagen, Denmark, August 27–31, 2007. Michigan Publishing.Google Scholar
Accessibility standard: Unknown
Why this information is here
This section outlines the accessibility features of this content - including support for screen readers, full keyboard navigation and high-contrast display options. This may not be relevant for you.Accessibility Information
Accessibility compliance for the PDF of this book is currently unknown
and may be updated in the future.
You have
Access
Open access