Abstract
In this paper, we address the question of what current computers are from the point of view of human-computer interaction. In the early days of computing, the Turing machine (TM) has been the cornerstone of the understanding of computers. The TM defines what can be computed and how computation can be carried out. However, in the last decades, computers have evolved and increasingly become interactive systems, reacting in real-time to external events in an ongoing loop. We argue that the TM does not provide a mechanistic explanation for interactive computing. The reason is that the fundamental phenomena relevant to interactive computing are out of the scope of classical computability theory. Part of the explanatory power of the TM relies on what we propose to call an execution model. An execution model belongs to a level of abstraction where it is possible to describe both the functional architecture and the execution in mechanistic terms. An updated execution model is warranted to provide the minimal mechanistic description for interactive computation as a counterpart of what the TM could explain regarding Church-Turing computation. It would support an explanation of the ubiquitous computing devices we know - those interacting with humans, e.g., through digital interfaces. We show that such a model is not available within interactive models of computation and that relevant abstractions and concerns are available in computer engineering but need to be identified and gathered. To fill this void, we propose to reflect on the level of abstraction required to support the mechanistic description of an interactive execution and propose some preliminary requirements.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
Notes
Steve Russell, a student of McCarthy, showed in 1958 that the eval function of Lisp could serve as a concrete abstract machine and be directly implemented: “But in late 1958, Steve Russell, one of McCarthy’s grad students, looked at this definition of eval and realized that if he translated it into machine language, the result would be a Lisp interpreter. This was a big surprise at the time. Here is what McCarthy said about it later: Steve Russell said, look, why don’t I program this eval, and I said to him, ho, ho, you’re confusing theory with practice, this eval is intended for reading, not for computing. But he went ahead and did it. That is, he compiled the eval in my paper into [IBM] 704 machine code, fixing bugs, and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today.”(Graham, 2004) p. 185.
A Universal Turing Machine is a special Turing Machine that can simulate any other Turing Machine, hence its name.
In addition to that definition, a further distinction is introduced in the reactive programming community: reactive systems are sometimes distinguished from interactive systems (Harel & Pnueli, 1985; Mandel & Pouzet, 2005) A distinction is made around the real-time dimension of these systems. An interactive system reacts to events in the environment without time constraints, whereas reactive systems react within a time limit set by the environment. For example, the kernel of a general-purpose operating system (OS) is interactive (its response time to events depends on its load and hardware capabilities). In contrast, the autopilot of an aircraft is a reactive system (its response time to events is specified and must be respected). When we talk about interaction from the perspective of HCI, we refer to “interactive system” following that distinction.
Marr’s work on visual perception, e.g., presented in his book, Vision: A Computational Approach has been influential in analyzing complex information processing systems. See McClamrock’s paper (McClamrock, 1990) for a synthesis of Marr’s framework and criticisms.
References
Accot, J., Chatty, S., Maury, S., & Palanque, P. (1997). Formal transducers: Models of devices and building bricks for the design of highly interactive systems. Design, specification and verification of interactive systems’ 97 (pp. 143–159). Springer. https://doi.org/10.1007/978-3-7091-6878-3_10.
Agha, G., & Hewitt, C. (1988). Concurrent programming using actors: Exploiting large-scale parallelism. In A. H. Bond & L. Gasser (Eds.), Readings in distributed artificial intelligence (pp. 398–407). Morgan Kaufmann. https://doi.org/10.1007/3-540-16042-6_2
Alur, R., & Dill, D. L. (1994). A theory of timed automata. Theoretical Computer Science, 126(2), 183–235. https://doi.org/10.1016/0304-3975(94)90010-8
Alur, R., & Henzinger, T. A. (1993). Real-time logics: Complexity and expressiveness. Information and Computation, 104(1), 35–77. https://doi.org/10.1006/inco.1993.1025
Andersen, H. R., Mørk, S., & Sørensen, M. U. (1997). A universal reactive machine. Lecture Notes in Computer ScienceIn W. J. In & A. Mazurkiewicz (Eds.), CONCUR ’97: Concurrency theory. CONCUR 1997 (Vol. 1243, pp. 89–103). Springer. https://doi.org/10.1007/3-540-63141-0_7
Arbach, Y., Karcher, D., Peters, K., & Nestmann, U. (2015). Dynamic causality in event structures. In V. M. S. Graf (ed.), Formal techniques for distributed objects, components, and systems, volume 9039 of lecture notes in computer science, pp. 83–97. https://doi.org/10.1007/978-3-319-19195-9_6
Attie, P. C., & Lynch, N. A. (2003). Dynamic input/output automata: A formal model for dynamic systems. Technical Report MIT-CSAIL-TR-2003-006, MIT Computer Science and Artificial Intelligene Laboratory.
Baeten, J. C., Luttik, B., & Tilburg, P. V. (2013). Reactive turing machines. In S. M. T. J. In & O. Owe (Eds.), FCT 2011: Fundamentals of computation theory. Lecture notes in computer science (pp. 348–359). Springer. https://doi.org/10.1016/j.ic.2013.08.010
Bainomugisha, E., Carreton, A. L., Cutsem, T. V., Mostinckx, S., & Meuter, W. D. (2013). A survey on reactive programming. ACM Computing Surveys, 45(4), 1–34. https://doi.org/10.1145/2501654.2501666
Baldan, P., Corradini, A., & Montanari, U. (2001). Contextual petri nets, asymmetric event structures, and processes. Information and Computation, 171(1), 1–49. https://doi.org/10.1006/inco.2001.3060
Basman, A., Tchernavskij, P., Bates, S., & Beaudouin-Lafon, M. (2018). An anatomy of interaction: Co-occurrences and entanglements. In Conference companion of the 2nd international conference on art, science, and engineering of programming (pp. 188–196). Association for Computing Machinery. https://doi.org/10.1145/3191697.3214328
Beaudouin-Lafon, M. (2006). Human-computer interaction. In D. Goldin, S. A. Smolka, & P. Wegner (Eds.), Interactive computation: The new paradigm (pp. 227–254). Berlin Heidelberg: Springer. https://doi.org/10.1007/3-540-34874-3_10
Bechtel, W. (1994). Levels of description and explanation in cognitive science. Minds and Machines, 4, 1–25. https://doi.org/10.1007/BF00974201
Berry, G., & Gonthier, G. (1992). The esterel synchronous programming language: Design, semantics, implementation. Science of Computer Programming, 19(2), 87–152. https://doi.org/10.1016/0167-6423(92)90005-V
Berry, G., & Serrano, M. (2020). Hiphop.js: (a)synchronous reactive web programming. In Proceedings of the ACM SIGPLAN conference on programming language design and implementation (pp. 533–545). PLDI 2020, Association for Computing Machinery, New York, NY, USA. https://doi.org/10.1145/3385412.3385984
Bonér, J., Farley, D., Kuhn, R., & Thompson, M. (2014). The reactive manifesto. Org: Reactivemanifesto.
Boone, W., & Piccinini, G. (2016). Mechanistic abstraction. Philosophy of Science, 83, 686–697. https://doi.org/10.1086/687855
Boussinot, F. (1991). Reactive c: An extension of c to program reactive systems. Software: Practice and Experience, 21, 401–428. https://doi.org/10.1002/spe.4380210406
Bozşahin, C. (2018). Computers aren’t syntax all the way down or content all the way up. Minds and Machines, 28, 543–567. https://doi.org/10.1007/s11023-018-9469-2
Campos, J. C., & Harrison, M. D. (1997). Formally verifying interactive systems: A review. In T. J. In & M. D. Harrison (Eds.), Design, specification and verification of interactive systems’ 97. Eurographics (pp. 109–124). Springer. https://doi.org/10.1007/978-3-7091-6878-3_8
Canny, A., Navarre, D., Campos, J. C., & Palanque, P. (2019). Model-based testing of post-wimp interactions using object oriented petri-nets. In Formal methods. FM 2019 international workshops (pp. 486–502). Springer. https://doi.org/10.1007/978-3-030-54994-7_35
Casiez, G., & Roussel, N. (2011). No more bricolage! methods and tools to characterize, replicate and compare pointing transfer functions. In Proceedings of the 24th annual ACM symposium on user interface software and technology (pp. 603–614). Association for Computing Machinery. https://doi.org/10.1145/2047196.2047276
Caspi, P., Pilaud, D., Halbwachs, N., & Plaice, J. A. (1987). Lustre: A declarative language for real-time programming. In Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on principles of programming languages (pp. 178–188). POPL ’87, Association for Computing Machinery, New York, NY, USA. https://doi.org/10.1145/41625.41641
Chatty, S. (1994). Extending a graphical toolkit for two-handed interaction. In Proceedings of the 7th annual ACM symposium on user interface software and technology (pp. 195–204). Association for Computing Machinery. https://doi.org/10.1145/192426.192500
Church, A. (1940). A formulation of the simple theory of types. Journal of Symbolic Logic, 5(2), 56–68. https://doi.org/10.2307/2266170
Cockshott, P., & Michaelson, G. (2007). Are there new models of computation? reply to Wegner and Eberbach. Computer Journal, 50(2), 232–247. https://doi.org/10.1093/comjnl/bxl062
Craver, C. F. (2001). Role functions, mechanisms, and hierarchy. Philosophy of Science, 68(1), 53–74. https://doi.org/10.1086/392866
Czaplicki, E., & Chong, S. (2013). Asynchronous functional reactive programming for guis. In Proceedings of the ACM SIGPLAN conference on programming language design and implementation (PLDI) (Vol. 48, pp. 411–422). Association for Computing Machinery, New York, NY, USA. https://doi.org/10.1145/2462156.2462161
Dearden, A. M., & Harrison, M. D. (1997). Abstract models for HCI. International Journal of Human Computer Studies, 46(1), 151–177. https://doi.org/10.1006/ijhc.1996.0087
Dodig-Crnkovic, G. (2011). Significance of models of computation, from turing model to natural computation. Minds and Machines, 21, 301–322. https://doi.org/10.1007/s11023-011-9235-1
Dragicevic, P., & Fekete, J. D. (2004). Support for input adaptability in the icon toolkit. In Proceedings of the 6th international conference on multimodal interfaces (pp. 212–219). ICMI ’04, Association for Computing Machinery. https://doi.org/10.1145/1027933.1027969
Eberbach, E., Goldin, D., & Wegner, P. (2004). Turing’s ideas and models of computation. In C. Teuscher (Ed.), Alan turing: Life and legacy of a great thinker (pp. 159–194). Springer. https://doi.org/10.1007/978-3-662-05642-4_7
Elliott, C., & Hudak, P. (1997). Functional reactive animation. In Proceedings of the second ACM SIGPLAN international conference on functional programming, volume 32 of ICFP ’97 (pp. 263–273). Association for Computing Machinery. https://doi.org/10.1145/258949.258973
Fresco, N. (2010). Explaining computation without semantics: Keeping it simple. Minds and Machines, 20, 165–181. https://doi.org/10.1007/s11023-010-9199-6
Glabbeek, R. V., & Plotkin, G. (2004). Event structures for resolvable conflict. 29th international symposium on mathematical foundations of computer, volume 3153 of lecture notes in computer science (including subseries lecture notes in artificial intelligence and lecture notes in bioinformatics) (pp. 550–561). Springer. https://doi.org/10.1007/978-3-540-28629-5_42
Glennan, S. (2002). Rethinking mechanistic explanation. Philosophy of Science, 69(S3), 342–353. https://doi.org/10.1086/341857
Goldin, D., & Wegner, P. (2008). The interactive nature of computing: Refuting the strong church-turing thesis. Minds and Machines, 18, 17–38. https://doi.org/10.1007/s11023-007-9083-1
Goldin, D., Wegner, P., & Smolka, S. A. (2006). Interactive computation: The new paradigm. Springer. https://doi.org/10.1007/3-540-34874-3
Goldin, D. Q. (2000). Persistent turing machines as a model of interactive computation. In T. B. K. D. Schewe (Ed.), Foundations of information and knowledge systems. FoIKS 2000, volume 1762 of lecture notes in computer science (pp. 116–135). Springer. https://doi.org/10.1007/3-540-46564-2_8
Graham, P. (2004). Hackers and painters: Essays on the art of programming. O’Reilly & Associates Inc.
Harel, D., & Pnueli, A. (1985). On the development of reactive systems. In K. Apt, ed., Logics and Models of Concurrent Systems, volume 13 of NATO ASI Series (pp. 477–498). Springer. https://doi.org/10.1007/978-3-642-82453-1_17
Hewitt, C., & Baker, H. (1978). Actors and continuous functionals (Report No MIT/LCS/TR-194). MIT Laboratory for Computer Science. https://apps.dtic.mil/sti/pdfs/ADA052266.pdf
Hill, R. D. (1986). Supporting concurrency, communication, and synchronization in human-computer interaction–The sassafras uims. ACM Transactions on Graphics, 5, 179–210. https://doi.org/10.1145/24054.24055
Hornbaek, K., & Oulasvirta, A. (2017). What is interaction? In Proceedings of the 2017 CHI Conference on Human Factors in Computing Systems (pp. 5040–5052). Association for Computing Machinery. https://doi.org/10.1145/3025453.3025765
Huot, S., Dumas, C., Dragicevic, P., Fekete, J. D., & Hégron, G. (2004). The magglite post-wimp toolkit: draw it, connect it and run it. In Proceedings of the 17th annual ACM symposium on User interface software and technology (pp. 257–266). UIST ’04, Association for Computing Machinery. https://doi.org/10.1145/1029632.1029677
Jacob, R. J. K. (1996). Human-computer interaction: Input devices. ACM Computing Surveys, 28(1), 177–179. https://doi.org/10.1145/234313.234387
Jacob, R. J. K., Deligiannidis, L., & Morrison, S. (1999). A software model and specification language for non-wimp user interfaces. ACM Transactions on Computer-Human Interaction, 6, 1–46. https://doi.org/10.1145/310641.310642
Klein, C. (2020). Polychrony and the process view of computation. In Proceedings of the 2018 biennial meeting of the philosophy of science association. Part II (Vol. 87, pp. 1140–1149). https://doi.org/10.1086/710613
Ko, A. J., & Myers, B. A. (2004). Designing the whyline: A debugging interface for asking questions about program behavior. In Proceedings of the SIGCHI conference on human factors in computing systems (pp. 151–158). CHI ’04, Association for Computing Machinery. https://doi.org/10.1145/985692.985712
Lamport, L. (1978). Time, clocks, and the ordering of events in a distributed system. Communications of the ACM, 21, 558–565. https://doi.org/10.1145/359545.359563
Lassègue, J., & Longo, G. (2012). What is turing’s comparison between mechanism and writing worth? In D.A.L.B. Cooper S.B., ed., How the World Computes. CiE 2012., volume 7318 of Lecture Notes in Computer Science. Springer. https://doi.org/10.1007/978-3-642-30870-3_46
Lee, E. A. (2018). Plato and the nerd. MIT Press. https://doi.org/10.7551/mitpress/11180.001.0001
Lee, E. A. (2020). The coevolution. MIT Press. https://doi.org/10.7551/mitpress/12307.001.0001
Lee, E. A., & Neuendorffer, S. (2006). Concurrent models of computation for embedded software. System-on-chip: Next generation electronics. https://doi.org/10.1049/PBCS018E_ch7
Lee, E. A., & Sangiovanni-Vincentelli, A. (1998). A framework for comparing models of computation. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems. https://doi.org/10.1109/43.736561
Lee, E. A., & Varaiya, P. (2003). Structure and interpretation of signals and systems (1st ed.). Addison-Wesley.
Leeuwen, J. V., & Wiedermann, J. (2001). Beyond the turing limit: Evolving interactive systems. In R.P. Pacholski L., ed., SOFSEM 2001: Theory and Practice of Informatics, volume 2234 of Lecture Notes in Computer Science (pp. 90–109). Springer. https://doi.org/10.1007/3-540-45627-9_8
Leeuwen, J. V., & Wiedermann, J. (2006). A theory of interactive computation. In Interactive Computation: The New Paradigm (pp. 119–142). Springer. https://doi.org/10.1007/3-540-34874-3_6
Leveson, N. (2020). Are you sure your software will not kill anyone? Communications of the ACM, 63(2), 25–28. https://doi.org/10.1145/3376127
Longo, G. (1999). The difference between clocks and turing machines (Vol. 27, pp. 211–232). Springer. https://doi.org/10.1007/978-94-015-9620-6_14
Luttik, B., & Yang, F. (2016). On the executability of interactive computation. In B.L.J.N. Beckmann A., ed., Pursuit of the Universal. CiE 2016, volume 9709 of Lecture Notes in Computer Science (pp. 312–322). Springer. https://doi.org/10.1007/978-3-319-40189-8_32
Lynch, N., Segala, R., & Vaandrager, F. (1996). Hybrid i/o automata. Information and Computation, 185(1), 105–157. https://doi.org/10.1007/BFb0020971
Machamer, P., Darden, L., & Craver, C. F. (2000). Thinking about mechanisms. Philosophy of Science, 67(1), 1–25. https://doi.org/10.1086/392759
MacLennan, B. (2003). Transcending turing computability. Minds and Machines, 13, 3–22. https://doi.org/10.1023/A:1021397712328
Mandel, L., & Pouzet, M. (2005). ReactiveML, a reactive extension to ML. In Proceedings of the 7th ACM SIGPLAN International Conference on Principles and Practice of Declarative Programming (pp. 82–93). PPDP ’05, Association for Computing Machinery. https://doi.org/10.1145/1069774.1069782
Marr, D. (2010). Vision: A computational investigation into the human representation and processing of visual information. MIT Press. https://doi.org/10.7551/mitpress/9780262514620.001.0001
McClamrock, R. (1990). Marr’s three levels: A re-evaluation. Minds and Machines, 1, 185–196. https://doi.org/10.1007/BF00361036
Miłkowski, M. (2014). Computational mechanisms and models of computation. Philosophia Scientiae, 18(3), 215–228. https://doi.org/10.4000/philosophiascientiae.1019
Miłkowski, M. (2016). A mechanistic account of computational explanation in cognitive science and computational neuroscience. In V.C. Müller, ed., Computing and Philosophy: Selected Papers from IACAP 2014 (Vol. 375, pp. 191–205). Springer. https://doi.org/10.1007/978-3-319-23291-1_13
Milner, R. (1975). Processes: A mathematical model of computing agents. In H. E. Rose & J. C. Shepherdson (Eds.), Logic colloquium ’73 (Vol. 80, pp. 157–173). Elsevier. https://doi.org/10.1016/S0049-237X(08)71948-7
Milner, R. (1982). Four combinators for concurrency. In Proceedings of the annual acm symposium on principles of distributed computing (pp. 104–110). PODC ’82, Association for Computing Machinery. https://doi.org/10.1145/800220.806687
Milner, R. (1983). Calculi for synchrony and asynchrony. Theoretical Computer Science. https://doi.org/10.1016/0304-3975(83)90114-7
Milner, R. (1993). Elements of interaction: Turing award lecture. Communications of the ACM, 36(1), 78–89. https://doi.org/10.1145/151233.151240
Milner, R. (1999). Communicating and mobile systems: The -calculus. Cambridge University Press.
Milner, R. (2006). Turing, computing and communication (pp. 1–8). Springer. https://doi.org/10.1007/3-540-34874-3_1
Mol, L. D. (2018). Turing machines. Stanford Encyclopedia. https://plato.stanford.edu/entries/turing-machine/#TuriMachModeComp.
Myers, B. (1994). Challenges of HCI design and implementation. Interactions, 1(1), 73–83. https://doi.org/10.1145/174800.174808
Myers, B., Hudson, S. E., & Pausch, R. (2000). Past, present, and future of user interface software tools. ACM Transactions on Computer-Human Interaction, 7, 3–28. https://doi.org/10.1145/344949.344959
Myers, B., Park, S. Y., Nakano, Y., Mueller, G., & Ko, A. (2008). How designers design and program interactive behaviors. In Proceedings—2008 IEEE symposium on visual languages and human-centric computing, VL/HCC 2008 (pp. 177–184). IEEE. https://doi.org/10.1109/VLHCC.2008.4639081
Myers, B. A. (1991). Separating application code from toolkits: Eliminating the spaghetti of call-backs. In Proceedings of the 4th annual ACM symposium on user interface software and technology, UIST 1991 (pp. 211–220). UIST ’91, Association for Computing Machinery. https://doi.org/10.1145/120782.120805
Myers, B. A. (2013). Improving program comprehension by answering questions (keynote). In Proceedings of the 21st IEEE/ACM conference on program comprehension (ICPC) (pp. 1–2). ICPC. https://doi.org/10.1109/ICPC.2013.6613827
Myers, B. A., Giuse, D., Mickish, A., Zanden, B. V., Kosbie, D., McDaniel, R., Landay, J., Goldberg, M., & Pathasarathy, R. (1994). The garnet user interface development environment. In Conference companion on human factors in computing systems (pp. 25–26). CHI ’94, Association for Computing Machinery. https://doi.org/10.1145/259963.260472
Myers, B. A., Giuse, D. A., Dannenberg, R. B., Zanden, B. V., Kosbie, D. S., Pervin, E., Mickish, A., & Marchal, P. (1995). Garnet comprehensive support for graphical, highly interactive user interfaces. In R. Baecker, J. Grudin, W. Buxton, & S. Greenberg, eds., Readings in Human–Computer Interaction (pp. 357–371). Morgan Kaufmann. https://doi.org/10.1016/B978-0-08-051574-8.50037-6
Myers, B. A., & Rosson, M. B. (1992). Survey on user interface programming. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (pp. 195–202). CHI ’92, Association for Computing Machinery. https://doi.org/10.1145/142750.142789
Navarre, D., Palanque, P., Dragicevic, P., & Bastide, R. (2006). An approach integrating two complementary model-based environments for the construction of multimodal interactive applications. Interacting with Computers, 18, 910–941. https://doi.org/10.1016/j.intcom.2006.03.002
Navarre, D., Palanque, P., Ladry, J. F., & Barboni, E. (2009). Icos: A model-based user interface description technique dedicated to interactive systems addressing usability, reliability and scalability. ACM Transactions on Computer-Human Interaction, 16, 1–56. https://doi.org/10.1145/1614390.1614393
Nielsen, M., Plotkin, G., & Winskel, G. (1981). Petri nets, event structures and domains, part I. Theoretical Computer Science, 13(1), 85–108. https://doi.org/10.1016/0304-3975(81)90112-2
Nisan, N., & Schocken, S. (2021). The elements of computing systems (2nd ed.). Building a Modern Computer from First Principles, MIT Press.
Petri, C. (1980). Introduction to general net theory. In W. Brauer, ed., Net Theory and Applications, volume 84 of Lecture Notes in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-10001-6_21
Piccinini, G. (2007). Computing mechanisms. Philosophy of Science. https://doi.org/10.1086/522851
Piccinini, G. (2008). Computers. Pacific Philosophical Quarterly, 89(1), 32–73. https://doi.org/10.1111/j.1468-0114.2008.00309.x
Piccinini, G. (2008). Some neural networks compute, others don’t. Neural Networks, 21, 311–321. https://doi.org/10.1016/j.neunet.2007.12.010
Post, E. (1948). Degrees of recursive unsolvability: Preliminary report. Bulletin of the American Mathematical Society, 54, 641–642.
Prasse, M., & Rittgen, P. (1998). Why church’s thesis still holds. Some notes on peter Wegner’s tracts on interaction and computability. The Computer Journal, 41(6), 357–362. https://doi.org/10.1093/comjnl/41.6.357
Pylyshyn, Z. (1986). Computation and cognition. Toward a foundation for cognitive science. MIT Press.
Rapaport, W. J. (2018). What is a computer? A survey. Minds and Machines, 28(3), 385–426. https://doi.org/10.1007/s11023-018-9465-6
Reisig, W. (1988). Temporal logic and causality in concurrent systems. In F. Vogt, ed., CONCURRENCY 1988, volume 335 of Lecture Notes in Computer Science (pp. 121–139). Springer. https://doi.org/10.1007/3-540-50403-6_37
Salvaneschi, G., Margara, A., & Tamburrelli, G. (2015). Reactive programming: A walkthrough. In IEEE/ACM 37th IEEE International Conference on Software Engineering (Vol. 2, pp. 953–954). IEEE. https://doi.org/10.1109/ICSE.2015.303
Schmidt, K., & Bansler, J. (2016). Computational artifacts: interactive and collaborative computing as an integral feature of work practice. In B.L.M.P.B.S. De Angeli A., ed., COOP 2016: Proceedings of the 12th International Conference on the Design of Cooperative Systems, 23-27 May 2016, Trento, Italy (pp. 21–38). Springer.
Segala, R., Gawlick, R., Søgaard-Andersen, J., & Lynch, N. (1994). Liveness in timed and untimed systems. In S.E. Abiteboul S., ed., Automata, Languages and Programming. ICALP 1994, volume 820 of Lecture Notes in Computer Science. Springer https://doi.org/10.1007/3-540-58201-0_66
Shagrir, O. (2006). Gödel on turing on computability. In A. Olszewski, J. Wolenski, and R. Janusz, eds., Church’s Thesis After 70 Years (pp. 393–419). De Gruyter. https://doi.org/10.1515/9783110325461.393
Shagrir, O. (2012). Computation, implementation, cognition. Minds and Machines, 22, 137–148. https://doi.org/10.1007/s11023-012-9280-4
Smith, B. C. (2002). The foundations of computing. In M. Scheutz (Ed.), Computationlism: New directions. MIT Press.
Smith, W. R. (1995). Using a prototype-based language for user interface: The newton project’s experience. In Proceedings of the Tenth Annual Conference on Object-Oriented Programming Systems, Languages, and Applications (pp. 61–72). OOPSLA ’95, Association for Computing Machinery. https://doi.org/10.1145/217838.217844
Soare, R. I. (2009). Turing oracle machines, online computing, and three displacements in computability theory. Annals of Pure and Applied Logic, 160(3), 368–399. https://doi.org/10.1016/j.apal.2009.01.008
Soare, R. I. (2013). Interactive computing and relativized computability (chapter 9, pp. 214–271). MIT Press. https://doi.org/10.7551/mitpress/8009.003.0010
Suchman, L. A. (1987). Plans and situated actions: The problem of human-machine communication. Cambridge University Press.
Turing, A. (1937). On computable numbers, with an application to the entscheidungsproblem. Proceedings of the London Mathematical Society, s2–42(1), 230–265. https://doi.org/10.1112/plms/s2-42.1.230
Turing, A. (1939). Systems of logic based on ordinals. Proceedings of the London Mathematical Society, s2–45(1), 161–228. https://doi.org/10.1112/plms/s2-45.1.161
Turing, A. (1950). Computing machinery and intelligence. Minds, 59, 433–60.
Victor, B. (2012). Learnable programming–designing a programming system for understanding programs. http://worrydream.com/LearnableProgramming. Accessed 20 August 2021.
Vonder, S. V. D., Koster, J. D., Myter, F., & Meuter, W. D. (2017). Tackling the awkward squad for reactive programming: The actor-reactor model. In Proceedings of the 4th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems (pp. 27–33). REBLS 2017, Association for Computing Machinery. https://doi.org/10.1145/3141858.3141863
Wegner, P. (1995). Interaction as a basis for empirical computer science. ACM Computing Surveys (CSUR), 27(1), 45–48. https://doi.org/10.1145/214037.214092
Wegner, P. (1997). Why interaction is more powerful than algorithms. Communications of the ACM, 40(5), 80–91. https://doi.org/10.1145/253769.253801
Williams, G. (1984). Software frameworks. BYTE Magazine, 9(13), 124–127.
Wilson, D., Rosenstein, L., & Shafer, D. (1990). C++ Programming with MacApp. Macintosh inside out, Addison-Wesley Publishing Company. https://vintageapple.org/macprogramming/pdf/C++_Programming_with_MacApp_1987.pdf.
Acknowledgements
We are very grateful to our anonymous reviewers for their objections and comments.
Funding
This work was partly supported by the French “Programme d’Investissements d’avenir” ANR-17-EURE-0005 conducted by ANR and by Agence de l’Innovation de Défense (AID).
Author information
Authors and Affiliations
Corresponding author
Ethics declarations
Conflict of interest
No competing interest.
Additional information
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Rights and permissions
Springer Nature or its licensor (e.g. a society or other partner) holds exclusive rights to this article under a publishing agreement with the author(s) or other rightsholder(s); author self-archiving of the accepted manuscript version of this article is solely governed by the terms of such publishing agreement and applicable law.
About this article
Cite this article
Martin, A., Magnaudet, M. & Conversy, S. Computers as Interactive Machines: Can We Build an Explanatory Abstraction?. Minds & Machines 33, 83–112 (2023). https://doi.org/10.1007/s11023-023-09624-2
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11023-023-09624-2