Abstract
Modern computing is generally taken to consist primarily of symbol manipulation. But symbols are abstract, and computers are physical. How can a physical device manipulate abstract symbols? Neither Church nor Turing considered this question. My answer is that the bit, as a hardware-implemented abstract data type, serves as a bridge between materiality and abstraction. Computing also relies on three other primitive—but more straightforward—abstractions: Sequentiality, State, and Transition. These physically-implemented abstractions define the borderline between hardware and software and between physicality and abstraction. At a deeper level, asking how a physical device can interact with abstract symbols is the wrong question. The relationship between symbols and physical devices begins with the realization that human beings already know what it means to manipulate symbols. We build and program computers to do what we understand to be symbol manipulation. To understand what that means, consider a light switch. A light switch doesn’t turn a light on or off. Those are abstractions. Light switches don’t operate with abstractions. We build light switches (and their associated circuitry), so that when flipped, the world is changed in such a way that we understand the light to be on or off. Similarly, we build computers to perform operations that we understand as manipulating symbols.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
Notes
“What’s in the brain that ink may character” opens Shakespeare’s Sonnet 108. McCullough intended that line to mean, “What is a brain that it is able to see pen scratches as characters.” Shakespeare’s concern is with the opposite journey.
What's in the brain that ink may character,
Which hath not figur'd to thee my true spirit?
What's new to speak, what new to register,
That may express my love or thy dear merit?
I take the first two lines to mean: What thoughts that may be written down (i.e., that ink may character) about my love for you have not already been expressed?
For both Shakespeare and McCullough, character functions (creatively) as a verb—transitive for Shakespeare, intransitive for McCullough—with ink (also creatively) as its subject.
This ignores scoping issues. ∃x∃y(Axy & (∀x Bxy)) contains twox items. The x in Axy and the x in Bxy look the same, but they refer to different symbols. (One can see that they refer to two symbols by replacing the two final occurrences of x with z and noticing that the meaning of the expression is not changed.) To accommodate this broader usage would add complexity but would not change the overall argument. So scope issues are ignored in this paper.
This statement is too strong. Is a bee’s perspective on a flower to which it is attracted an abstraction? When a bee responds to a flower, it cannot be responding to a precise patterns of forms and colors. That is, a slight difference in the data a bee’s sense organs receive will not, in most cases, change whether the bee is attracted to the flower. Bees, and other biological organisms, must generalize from the data their sense organs receive to abstractions of some sort—e.g., flower to explore versus flower to ignore. Yet I wouldn’t go so far as to claim that all biological organisms that perform this sort of generalization have concepts for those abstractions. I would refer to phenomena like this—and similar threshold-like reactions by biological organisms—as what one might call proto-abstractions.
In lambda calculus all functions have a single argument. If one wants a function of multiple arguments, one nests one inside the other (λP λQ …) as in the example of every.
See Wetzel (2018) for additional discussion.
Nature has identified “Computational Science” as one of its “subject areas.” See https://www.nature.com/subjects/computational-science. See also Humphreys (2004) for an extended discussion and review.
Here, token is meant in the conventional way, i.e., as a concrete instance of the symbol as a type. Below we see how Newell uses the notion of a symbol token more abstractly.
It’s also possible to fool image recognition systems with what are called adversarial images. These are images that a person would confidently identify as one thing but that the best AI image recognizers would confidently identify as another. The field is developing quickly enough that rather than give a specific reference I suggest a web search for adversarial images.
This may seem trivial since humans do it so easily. But recall the discussion of the Unicode Standard. It doesn’t display letter abstractions; it doesn’t adopt particular glyphs as letter tokens; and it doesn’t discuss the issue of how to translate back and forth between letter abstractions and letter glyph tokens. These non-trivial issues are beyond the scope of the Standard.
Cuffaro and Fletcher (2018) collects a dozen contributions to the field of physical computing—including one by Piccinini and Anderson. In this paper, I focus on Piccinini because his work is the most completely fleshed out.
Several similar definitions are provided throughout the book.
A variable whose possible values range over the complex numbers does, indeed, have two degrees of freedom, but most variables are not of this form.
Is it fair to say that a switch is a vehicle?
Recall that computational data consists of “letters” of an arbitrary finite alphabet. These letters may represent such discrete values as on/off, 0/1, etc. and need not be understood in the context of elements of text.
Here, we are talking about digits as letter or value tokens. “Of the same type” means something like having the same value.
As far as I can tell, no more detailed description of how microstates are to be grouped is provided.
Newell uses the term symbol structure as synonymous with expression.
Generalized in that it represents any physical symbol system, not just the particular example discussed earlier in the paper.
In most programming languages = represents the act of assigning a value rather than a predicate asserting equality. In this case the value associated with the x-symbol is incremented by 1.
Bits make a strange foundation. Although as abstractions they are less substantial than sand, they are far more enduring.
As programming languages grew more sophisticated they added a feature similar to abstract data type. It is known as a class. A class is similar to what philosophers might refer to as an ontological kind, i.e., a category of things that are naturally grouped together, such as dogs, schools, etc. Programmers define the classes they need for a particular program. A University scheduling program, to take a well-worn example, may include classes for students, instructions, courses, sections, lecture rooms, grades, etc. When a programmer defines a class she characterizes how it behaves—similar to how one defines an abstract data type. In the case of programming language classes, the behaviors are specified by what are known as methods. These method specifications are written in software, not in a formal language such as predicate calculus. A method is defined by the program that is executed when the method is activated.
An important feature of classes is that software may create instances of them, e.g., a particular course, or a particular student, etc. The program may then manipulate these instances according to the operations the class defines: e.g., one may enroll a student in a course. As I just did, the term instance is typically used for these cases. I will often use that term to mean a particular case of a defined category.
When a user employs an operation listed in the API of a software element, the software element behaves in some way. Since the behavior is symbolic it would be misleading to call it physical. On the other hand, since the behavior involves the execution of portions of the software entity by a physical computer, the behavior is fundamentally physical. This presents a terminological difficulty. Something physical occurs, but the result is understood symbolically. I am using the term discernable for this sort of situation. A crucial element of the behavior is that the user of the API operation is able to discern that it occurred.
Discernibility does not imply that the effect of the behavior is immediately apparent. For example, entering something into a database is not immediately discernable. It is discernable in that a query to that database reveals that the information is in it. Similarly, the effect of pushing something onto a stack is not immediately discernable. It becomes discernable when a pop operation pops that element off the stack.
If taken too rigidly, such a perspective risks seriously mischaracterizing an item. What one can do to an item and how it will respond is generally well defined. How an agent can make use of an item depends on the imagination and creativity of the agent—as is revealed by the ever-popular challenge of listing 100 things one can do with some item, which may often include using it as a doorstop or paperweight.
This cute 5-minute video illustrates the problem. https://youtu.be/yY96hTb8WgI.
When a plant uses insect sense organs as affordances, the plant realizes a functional need (pollen transportation) even though that functional need is not reified by the plant as a concept. See Dennett (2017) for an extended discussion of what he refers to as “competence without consciousness”.
According to Norman, the affordances offered by a product or device will signal how to use it if they are well designed. Most commercial products come with user manuals. Most users don’t read user manuals; they expect the produce’s affordances to provide sufficient guidance about how to use the product.
That engineers turn dreams into reality is not original with either Miyazaki or Caproni. But I have been unable to find an original use. Turning dreams into reality turns out to be a fairly common theme. For example, a 1974 ad for Sony sound systems (Sony 1974) lets readers know that the product exists because, as the ad says, “engineers dream, and at Sony they turn their dreams into reality.”.
These are also abstractions. The coffee maker doesn’t “grind beans;” it sets cutting blades into motion, which results in beans being ground. It doesn’t “heat water;” it causes electricity to flow though a device that when activated produces heat. Etc.
References
Abbott, R. (2008). If a tree casts a shadow is it telling the time? International Journal of Unconventional Computing, 4(3), 195–222.
Abbott, R. (2009). Bits don’t have error bars: Upward conceptualization and downward approximation. In I. Poel & D. Goldberg (Eds.), Philosophy and engineering: An emerging agenda (pp. 285–294). Berlin: Springer.
Abbott, R. (2018). Meaning, autonomy, symbolic causality, and free will. Review of General Psychology, 22, 85–94. https://doi.org/10.1037/gpr0000125.
Abbott, R. (2019). A software inspired constructive view of nature. Presented at the 2016 conference of the international association for computing and philosophy. To appear in selected papers from that conference. Springer.
Blum, L., Shub, M., & Smale, S. (1989). On a theory of computation and complexity over the real numbers: NP-completeness, recursive functions and universal machines. Bulletin of the American Mathematical Society, 21(1), 1–46.
Bringsjord, S. (2015). The symbol grounding problem… remains unsolved. Journal of Experimental & Theoretical Artificial Intelligence, 27(1), 63–72.
Chua, H.-C. (2018). Teaching notes, National Taiwan University. https://www3.ntu.edu.sg/home/ehchua/programming/java/datarepresentation.html.
Church, A. (1932). A set of postulates for the foundation of logic. Annals of Mathematics, 32(33), 346–366.
Cubek, R., Ertel, W., & Palm, G. (2015). A critical review on the symbol grounding problem as an issue of autonomous agents. In Joint German/Austrian conference on artificial intelligence (Künstliche Intelligenz) (pp. 256–263). Cham: Springer.
Cuffaro, M. E., & Fletcher, S. C. (Eds.). (2018). Physical perspectives on computation, computational perspectives on physics. Cambridge: Cambridge University Press.
Dennett, D. C. (2017). From bacteria to Bach and back: The evolution of minds. New York City: WW Norton & Company.
Gibson, J. J. (1977). The theory of affordances. In R. E. Shaw & J. Bransford (Eds.), Perceiving, acting, and knowing. Abingdon-on-Thames: Lawrence Erlbaum Associates.
Gibson, J. J. (1979). The ecological approach to visual perception. Boston: Houghton Mifflin.
Günther, F., Dudschig, C., & Kaup, B. (2018). Symbol grounding without direct experience: Do words inherit sensorimotor activation from purely Linguistic context? Cognitive science, 42, 336–374.
Humphreys, P. (2004). Extending ourselves: Computational science, empiricism, and scientific method. Oxford: Oxford University Press.
Janssen, T. M. V. (2017). Montague semantics. In Zalta, E. N. (Ed.), The Stanford encyclopedia of philosophy (Spring 2017 Edition).
Liskov, B., & Zilles, S. (1974). Programming with abstract data types. ACM Sigplan Notices, 9(4), 50–59.
McCullogh, W. (1960). What is a number that a man may know it, and a man, that he may know a number? Alfred Korzybski Memorial Lecture, Institute of General Semantics, Princeton Club, NY, NY. First published in General Semantics Bulletin, No. 26/27, 7-18. Reprinted in www.vordenker.de (Winter Edition 2008/2009) J. Paul (Ed.) http://www.vordenker.de/ggphilosophy/mcculloch_what-is-a-number.pdf.
McCullough, W. (1964). What’s in the brain that ink may character? International congress for logic, methodology and philosophy of science, Jerusalem, Israel, August 28, 1964, first published in Embodiments of Mind (pp. 387–397). MIT Press. Reprinted in www.vordenker.de (Winter Edition 2008/2009) J. Paul (Ed.). http://www.vordenker.de/ggphilosophy/mcculloch_whats-in-the-brain.pdf.
Miyazaki, H. (2013). The wind rises. Koganei: Studio Ghibli.
Müller, V. C. (2015). Which symbol grounding problem should we try to solve? Journal of Experimental & Theoretical Artificial Intelligence, 27(1), 73–78.
Newell, A. (1980). Physical symbol systems. Cognitive Science, 4, 135–183. (Newell includes the following footnote to the paper title. “Herb Simon would be a co-author of this paper, except that he is giving his own paper at this conference. The key ideas are entirely joint”.).
Newell, A., & Simon, H. A. (1976). Computer science as empirical inquiry: Symbols and search. Communications of the ACM, 19(3), 113–126.
Norman, D. A. (1988). The psychology of everyday things. New York: Basic Books.
Norman, D. A. (2013). The design of everyday things: Revised and (expanded ed.). New York City: Doubleday.
Pearl, J. (2000). Causality: Models, reasoning, and inference. Cambridge: Cambridge University Press.
Piccinini, G. (2015). Physical computation: A mechanistic account. Oxford: Oxford University Press.
Rosen, G. (2017). Abstract objects. In E. N. Zalta (Ed.), The Stanford encyclopedia of philosophy (Winter 2017 Edition).
Sony Corporation. (1974). Ad for a Sony sound system. Radio-Electronics, p 13. https://www.americanradiohistory.com/Archive-Radio-Electronics/70s/1974/Radio-Electronics-1974-02.pdf.
Taddeo, M., & Floridi, L. (2007). A praxical solution of the symbol grounding problem. Minds and Machines, 17(4), 369–389. This paper is reprinted in Floridi, L. (2011) The Philosophy of Information (Oxford, UK: OUP).
Turing, A. M. (1936) On computable numbers, with an application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, 2 (published 1937), 42(1), 230–265. https://doi.org/10.1112/plms/s2-42.1.230. Turing, A. M. (1938). On computable numbers, with an application to the Entscheidungsproblem: A correction. Proceedings of the London Mathematical Society, 2, 43(6), 544–6. https://doi.org/10.1112/plms/s2-43.6.544.
Turner, R. (2011). Specification. Minds and Machines, 21(2), 135–152.
Turner, R., & Angius, N. (2017). The philosophy of computer science. In E. N. Zalta (Ed.), The Stanford encyclopedia of philosophy (Spring 2017 Edition).
The Unicode Consortium. (2017). The Unicode ® Standard Version 10.0—Core specification. The Unicode Consortium. http://www.unicode.org/versions/Unicode10.0.0/UnicodeStandard-10.0.pdf.
US Copyright Office. Website, FAQ page. https://www.copyright.gov/help/faq/faq-general.html. Accessed September 2, 2017.
van Eijck, J. (2010) A program for computational semantics. Slides for informal presentation. Centre for Mathematics and Computer Science (CWI), Amsterdam, Universities of Utrecht, Amsterdam. https://homepages.cwi.nl/~jve/courses/10/pdfs/APFCS.pdf and http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.297.9166&rep=rep1&type=pdf.
van Eijck, J., & Unger, C. (2010). Computational semantics with functional programming. Cambridge: Cambridge University Press.
Wang, H. (1957). A variant to Turing’s theory of computing machines. Journal of the ACM, 4(1), 63–92.
Wetzel, L. (2009). Types and tokens: On abstract objects. Cambridge: MIT Press.
Wetzel, L. (2018). Types and tokens. In E. N. Zalta (Ed.), The Stanford encyclopedia of philosophy (Fall 2018 Edition).
Wirth, N. (1971). The programming language Pascal. Acta Informatica, 1, 35–63.
Woodward, J. (2003). Making things happen, volume 114 of Oxford studies in the philosophy of science. Oxford: Oxford University Press.
Woodward, J. (2014). A functional account of causation; or, a defense of the legitimacy of causal thinking by reference to the only standard that matters—Usefulness (as opposed to metaphysics or agreement with intuitive judgment). Philosophy of Science, 81(5), 691–713.
Author information
Authors and Affiliations
Corresponding author
Additional information
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Appendix: Unicode. This Appendix is Brought to You by the Letter ‘A’
Appendix: Unicode. This Appendix is Brought to You by the Letter ‘A’
This section examines how character types are treated in software.
For software, text, and data to be portable from one computer to another requires agreement on how letters, digits, etc. are to be encoded. (Even if each file of software, text, or data were always accompanied by a translation table that specifies how that file refers to letters and digits, the table itself must refer to the various letters in order to specify their file-specific representations.) Because portability is so important, there is now agreement, virtually worldwide, on what is known as the Unicode Standard. The Unicode standard provides a way to refer to any character in any of the world’s written languages. Here is how it describes itself (Unicode 2017).
The Unicode Standard is the universal character encoding standard for written characters and text. It defines a consistent way of encoding multilingual text that enables the exchange of text data internationally and creates the foundation for global software. …
The Unicode Standard specifies a numeric value (code point) and a name for each of its characters. …
The Unicode Standard contains 1,114,112 code points [the (hexadecimal) digits 0 to 10 FFFF16] most of which are available for encoding of characters. … The overall capacity for more than 1 million characters is more than sufficient for all known character encoding requirements, including full coverage of all minority and historic scripts of the world.
The Unicode Standard even includes emojis.Footnote 31 This might seem difficult because an emoji is a small image, and emoji images are not standardized. According to the Standard,
The mark made on screen or paper, called a glyph, is a visual representation of [a] character. The Unicode Standard does not define glyph images.
In other words, the software that displays text is free to choose an image for each character. This makes sense in that each font face prescribes its own visual images for characters.
The same holds for emojis. For example,
is the recommended Unicode glyph for the DNA emoji—although, other glyphs are possible.
What does the Unicode Standard tell us about the letter ‘A’?
The character identified by a Unicode code point is an abstract entity [emphasis added], such as “latin capital letter a” or “bengali digit five.”
Note that “latin capital letter a” is considered an abstract entity.
The Unicode Standard does not include definitions for the characters it catalogues. It does not include anything like “the letter ‘A’ is the first character of the latin alphabet.” Each Unicode character is no more or less than an assigned name (e.g., “latin capital letter a”) along with a Unicode code point, i.e., a number expressed in hexadecimal notation. The capital latin letter a, for example, has this entry.
latin capital letter a (U+0041)
When a Unicode encoded character appears in a text, all that appears is the character’s code point value. The software that displays it selects the glyph to display. In other words, when working on a document in a word processor, the content of the document within the computer is a sequence of code points. It is up to the word processing system to decide the glyphs to use to display those numbers.
A corollary is that characters themselves, i.e. characters as abstractions, cannot be displayed or exhibited. Abstractions have no visual representations.
Given this framework Wetzel’s example, ∃x(Ax & Bx), would be expressed as follows in Unicode. (The latin characters are shown above the code point hex values.)
The three occurrences of x are represented by the Unicode code-point U+0078. In other words, the symbol x itself does not appear in the expression. What appears is the identifying number of the symbol x.
In other words, ∃x(Ax & Bx) is not (only) a statement in predicate calculus; it is also a sequence of characters—which can be interpreted as a predicate calculus statement. In particular, the Unicode code point U+0078 refers to the character x, which refers to an abstract predicate calculus symbol, which occurs in three places when the sequence is taken as a predicate calculus statement.
As before, we are implementing one language by using an existing language. In this case we are implementing the language of predicate calculus by using a language that includes the Unicode Standard for encoding characters.
We can ask the same sort of question we asked earlier. How does one determine that the three occurrences of U+0078 are, in fact, the same Unicode code point? Since code-point numbers are represented as hexadecimal characters, we are again back to where we started, this time asking how one compares two hexadecimal characters? The answer is the same as before. To determine whether two hexadecimal characters are the same, one compares their bit representations. Of course the same question arises again at yet lower level: how does one tell whether two bits are the same bit value? As before, as discussed in Sect. 8, we depend on a hardware-implemented Bit ADT.
Rights and permissions
About this article
Cite this article
Abbott, R. The Bit (and Three Other Abstractions) Define the Borderline Between Hardware and Software. Minds & Machines 29, 239–285 (2019). https://doi.org/10.1007/s11023-018-9486-1
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11023-018-9486-1