<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gordon Gibson on Medium]]></title>
        <description><![CDATA[Stories by Gordon Gibson on Medium]]></description>
        <link>https://medium.com/@gordongibson_37627?source=rss-c5b37e50f21a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*I7zZvyP3FTAtjaSY.</url>
            <title>Stories by Gordon Gibson on Medium</title>
            <link>https://medium.com/@gordongibson_37627?source=rss-c5b37e50f21a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 14:15:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gordongibson_37627/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Excerpts from “A Philosophy of Software Design”]]></title>
            <link>https://medium.com/@gordongibson_37627/excerpts-from-a-philosophy-of-software-design-761f03629838?source=rss-c5b37e50f21a------2</link>
            <guid isPermaLink="false">https://medium.com/p/761f03629838</guid>
            <category><![CDATA[book-excerpts]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[philosophy-of-software]]></category>
            <dc:creator><![CDATA[Gordon Gibson]]></dc:creator>
            <pubDate>Sun, 29 Aug 2021 16:28:57 GMT</pubDate>
            <atom:updated>2021-08-29T16:31:38.868Z</atom:updated>
            <content:encoded><![CDATA[<p>Having recently read and enjoyed John Ousterhout’s 2018 book <a href="https://www.goodreads.com/en/book/show/39996759-a-philosophy-of-software-design"><em>A Philosophy of Software Design</em></a><em> </em>, I wanted to select a set of excerpts to capture some the ideas that I enjoyed and found useful. All of the quotes below are direct excerpts from the book, and if you find them interesting I highly recommend a full read of the book, whose brevity and examples are very instructive.</p><h4>Chapter 2<br>The Nature of Complexity</h4><blockquote>This book is about how to design software systems to minimize their complexity.</blockquote><blockquote>For the purposes of this book, I define “complexity” in a practical way. Complexity is anything related to the structure of a software system that makes it hard to understand and modify the system.</blockquote><blockquote>Complexity manifests itself in three general ways, which are described in the paragraphs below. Each of these manifestations makes it harder to carry out development tasks.</blockquote><blockquote>Change amplification: The first symptom of complexity is that a seemingly simple change requires code modifications in many different places. One of the goals of good design is to reduce the amount of code that is affected by each design decision, so design changes don’t require very many code modifications.</blockquote><blockquote>Cognitive load: The second symptom of complexity is cognitive load, which refers to how much a developer needs to know in order to complete a task. A higher cognitive load means that developers have to spend more time learning the required information, and there is a greater risk of bugs because they have missed something important.</blockquote><blockquote>Sometimes an approach that requires more lines of code is actually simpler, because it reduces cognitive load.</blockquote><blockquote>Unknown unknowns: The third symptom of complexity is that it is not obvious which pieces of code must be modified to complete a task, or what information a developer must have to carry out the task successfully.</blockquote><blockquote>An unknown unknown means that there is something you need to know, but there is no way for you to find out what it is, or even whether there is an issue. You won’t find out about it until bugs appear after you make a change.</blockquote><blockquote>Complexity is caused by two things: dependencies and obscurity.</blockquote><blockquote>A dependency exists when a given piece of code cannot be understood and modified in isolation; the code relates in some way to other code, and the other code must be considered and/or modified if the given code is changed.</blockquote><blockquote>Dependencies are a fundamental part of software and can’t be completely eliminated. However, one of the goals of software design is to reduce the number of dependencies and to make the dependencies that remain as simple and obvious as possible.</blockquote><blockquote>The second cause of complexity is obscurity. Obscurity occurs when important information is not obvious. A simple example is a variable name that is so generic that it doesn’t carry much useful information (e.g., time).</blockquote><blockquote>In many cases, obscurity comes about because of inadequate documentation. However, obscurity is also a design issue. If a system has a clean and obvious design, then it will need less documentation. The need for extensive documentation is often a red flag that the design isn’t quite right. The best way to reduce obscurity is by simplifying the system design.</blockquote><blockquote>Complexity isn’t caused by a single catastrophic error; it accumulates in lots of small chunks.</blockquote><blockquote>Complexity comes about because hundreds or thousands of small dependencies and obscurities build up over time.</blockquote><blockquote>The incremental nature of complexity makes it hard to control. It’s easy to convince yourself that a little bit of complexity introduced by your current change is no big deal. However, if every developer takes this approach for every change, complexity accumulates rapidly.</blockquote><blockquote>In order to slow the growth of complexity, you must adopt a “zero tolerance” philosophy.</blockquote><h4>Chapter 3<br>Working Code Isn’t Enough (Strategic vs. Tactical Programming)</h4><blockquote>The first step towards becoming a good software designer is to realize that working code isn’t enough. It’s not acceptable to introduce unnecessary complexities in order to finish your current task faster. The most important thing is the long-term structure of the system. Most of the code in any system is written by extending the existing code base, so your most important job as a developer is to facilitate those future extensions. Thus, you should not think of “working code” as your primary goal, though of course your code must work. Your primary goal must be to produce a great design, which also happens to work. This is strategic programming.</blockquote><h4>Chapter 4<br>Modules Should Be Deep</h4><blockquote>The best modules are those whose interfaces are much simpler than their implementations. Such modules have two advantages. First, a simple interface minimizes the complexity that a module imposes on the rest of the system. Second, if a module is modified in a way that does not change its interface, then no other module will be affected by the modification. If a module’s interface is much simpler than its implementation, there will be many aspects of the module that can be changed without affecting other modules.</blockquote><blockquote>The most important issue in designing classes and other modules is to make them deep, so that they have simple interfaces for the common use cases, yet still provide significant functionality. This maximizes the amount of complexity that is concealed.</blockquote><h4>Chapter 5<br>Information Hiding (and Leakage)</h4><blockquote>Information hiding and deep modules are closely related. If a module hides a lot of information, that tends to increase the amount of functionality provided by the module while also reducing its interface. This makes the module deeper. Conversely, if a module doesn’t hide much information, then either it doesn’t have much functionality, or it has a complex interface; either way, the module is shallow.</blockquote><h4>Chapter 6<br>General-Purpose Modules are Deeper</h4><blockquote>In my experience, the sweet spot is to implement new modules in a somewhat general-purpose fashion. The phrase “somewhat general-purpose” means that the module’s functionality should reflect your current needs, but its interface should not. Instead, the interface should be general enough to support multiple uses. The interface should be easy to use for today’s needs without being tied specifically to them. The word “somewhat” is important: don’t get carried away and build something so general-purpose that it is difficult to use for your current needs.</blockquote><h4>Chapter 10<br>Define Errors Out Of Existence</h4><blockquote>The best way to eliminate exception handling complexity is to define your APIs so that there are no exceptions to handle: define error out of existence.</blockquote><blockquote>Rather than throwing an error when <em>unset</em> is asked to delete an unknown variable, it should have simply returned without doing anything. I should have changed the definition of <em>unset</em> slightly: rather than deleting a variable, <em>unset</em> should ensure that a variable no longer exists. With the first definition, <em>unset</em> can’t do its job if the variable doesn’t exist, so generating an exception makes sense. With the second definition, it is perfectly natural for <em>unset</em> to be invoked with the name of a variable that doesn’t exist. In this case, its work is already done, so it can simply return. There is no longer an error case to report.</blockquote><blockquote>The second technique for reducing the number of places where exceptions must be handled is exception masking. With this approach, an exceptional condition is detected and handled at a low level in the system, so that higher levels of software need not be aware of the condition.</blockquote><blockquote>The third technique for reducing complexity related to exceptions is exception aggregation. The idea behind exception aggregation is to handle many exceptions with a single piece of code; rather than writing distinct handlers for many individual exceptions, handle them all in one place with a single handler.</blockquote><h4>Chapter 11<br>Design it Twice</h4><blockquote>Designing software is hard, so it’s unlikely that your first thoughts about how to structure a module or system will produce the best design. You’ll end up with a much better result if you consider multiple options for each major design decision: design it twice.</blockquote><blockquote>Try to pick approaches that are radically different from each other; you’ll learn more that way. Even if you are certain that there is only one reasonable approach, consider a second design anyway, no matter how bad you think it will be. It will be instructive to think about the weaknesses of that design and contrast them with the features of other designs.</blockquote><h4>Chapter 12<br>Why Write Comments? The Four Excuses</h4><blockquote>If users must read the code of a method in order to use it, then there is no abstraction: all of the complexity of the method is exposed. Without comments, the only abstraction of a method is its declaration, which specifies its name and the names and types of its arguments and results. The declaration is missing too much essential information to provide a useful abstraction by itself.</blockquote><h4>Chapter 13<br>Comments Should Describe Things that Aren’t Obvious from the Code</h4><blockquote>The guiding principle for comments is that comments should describe things that aren’t obvious from the code.</blockquote><blockquote>Developers should be able to understand the abstractions provided by a module without reading any code other than its externally visible declarations. The only way to do this is by supplementing the declarations with comments.</blockquote><blockquote>After you have written a comment, ask yourself the following question: could someone who has never seen the code write the comment just by looking at the code next to the comment? If the answer is yes, as in the examples above, then the comment doesn’t make the code any easier to understand. Comments like these are why some people think that comments are worthless.</blockquote><blockquote>A first step towards writing good comments is to use different words in the comment from those in the name of the entity being described.</blockquote><blockquote>Comments augment the code by providing information at a different level of detail. Some comments provide information at a lower, more detailed, level than the code; these comments add precision by clarifying the exact meaning of the code. Other comments provide information at a higher, more abstract, level than the code; these comments offer intuition, such as the reasoning behind the code, or a simpler and more abstract way of thinking about the code.</blockquote><blockquote>Higher-level comments are more difficult to write than lower-level comments because you must think about the code in a different way. Ask yourself: What is this code trying to do? What is the simplest thing you can say that explains everything in the code? What is the most important thing about this code?</blockquote><blockquote>The main goal of implementation comments is to help the readers understand what the code is doing (not how it does it). Once readers know what the code is trying to do, it’s usually easy to understand how the code works.</blockquote><h4>Chapter 14<br>Choosing Names</h4><blockquote>When choosing a name, the goal is to create an image in the mind of the reader about the nature of the thing being named. A good name conveys a lot of information about what the underlying entity is, and, just as important, what it is not. When considering a particular name, ask yourself: “If someone sees this name in isolation, without seeing its declaration, its documentation, or any code that uses the name, how closely will they be able to guess what the name refers to? Is there some name that will paint a clearer picture?”</blockquote><blockquote>Overall, I would argue that readability must be determined by readers, not writers. If you write code with short variable names and the people who read it find it easy to understand, then that’s fine. If you start getting complaints that your code is cryptic, then you should consider using longer names.</blockquote><h4>Chapter 15<br>Write The Comments First<br>(Use Comments As Part Of The Design Process)</h4><blockquote>Delaying documentation often means that it never gets written at all. Once you start delaying, it’s easy to delay a bit more; after all, the code will be even more stable in a few more weeks. By the time the code has arguably stabilized, there is a lot of it, which means the task of writing documentation has become huge and even less attractive. There’s never a convenient time to stop for a few days and fill in all of the missing comments, and it’s easy to rationalize that the best thing for the project is to move on and fix bugs or write the next new feature.</blockquote><blockquote>The second, and most important, benefit of writing the comments at the beginning is that it improves the system design. Comments provide the only way to fully capture abstractions, and good abstractions are fundamental to good system design.If you write comments describing the abstractions at the beginning, you can review and tune them before writing implementation code.</blockquote><blockquote>The third and final benefit of writing comments early is that it makes comment-writing more fun.</blockquote><blockquote>If you are programming strategically, where your main goal is a great design rather than just writing code that works, then writing comments should be fun, since that’s how you identify the best designs.</blockquote><h4>Chapter 16<br>Modifying Existing Code</h4><blockquote>Ideally, when you have finished with each change, the system will have the structure it would have had if you had designed it from the start with that change in mind. To achieve this goal, you must resist the temptation to make a quick fix.</blockquote><blockquote>If you’re not making the design better, your are probably making it worse.</blockquote><blockquote>The best way to ensure that comments get updated is to position them close to the code they describe, so developers will see them when the change the code. The farther a comment is from its associated code, the less likely it is that it will be updated properly.</blockquote><blockquote>A common mistake when modifying code is to put detailed information about the change in the commit message for the source code repository, but then not to document it in the code. Although commit messages can be browsed in the future by scanning the repository’s log, a developer who needs the information is unlikely to think of scanning the repository log. Even if they do scan the log, it will be tedious to find the right log message.</blockquote><blockquote>If information is already documented someplace outside your program, don’t repeat the documentation inside the program; just reference the external documentation.</blockquote><h4>Chapter 18<br>Code Should be Obvious</h4><blockquote>If code is obvious, it means that someone can read the code quickly, without much thought, and their first guesses about the behaviour or meaning of the code will be correct.</blockquote><blockquote>If someone reading your code says it’s not obvious, then it’s not obvious, no matter how clear it may seem to you. By trying to understand what made the code non obvious, you will learn how to write better code in the future.</blockquote><h4>Chapter 19<br>Software Trends</h4><blockquote>Tests, particularly unit tests, play an important role in software design because the facilitate refactoring. Without a test suite, it’s dangerous to make major structural changes to a system.</blockquote><blockquote>Although I am a strong advocate of unit testing, I am not a fan of test-driven development. The problem with test-driven development is that it focuses attention on getting specific feature working, rather than finding the best design. This is tactical programming pure and simple, with all of its disadvantages. Test-driven development is too incremental: at any point in time, it’s tempting to just hack in the next feature to make the next test pass. There’s no obvious time to do design, so it’s easy to end up with a mess.</blockquote><h4>Chapter 20<br>Designing for Performance</h4><blockquote>It’s tempting to rush off and start making performance tweaks, based on your intuitions about what is slow. Don’t do this! Programmer’s intuitions about performance are unreliable. This is true even for experienced developers. If you start making changes based on intuition, you’ll waste time on things that don’t actually improve performance, and you’ll probably make the system more complicated in the process.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=761f03629838" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Excerpts from Gödel, Escher, Bach]]></title>
            <link>https://medium.com/@gordongibson_37627/excerpts-from-g%C3%B6del-escher-bach-b14ae3d82162?source=rss-c5b37e50f21a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b14ae3d82162</guid>
            <category><![CDATA[geb]]></category>
            <category><![CDATA[douglas-hofstadter]]></category>
            <dc:creator><![CDATA[Gordon Gibson]]></dc:creator>
            <pubDate>Mon, 28 Sep 2020 03:52:55 GMT</pubDate>
            <atom:updated>2021-08-29T14:58:34.098Z</atom:updated>
            <content:encoded><![CDATA[<h3>Excerpts from “Gödel, Escher, Bach”</h3><p>Having recently read and enjoyed Douglas Hofstadter’s 1979 book <a href="https://en.wikipedia.org/wiki/G%C3%B6del,_Escher,_Bach"><em>Gödel, Escher, Bach: an Eternal Golden Braid</em></a>, I wanted to select a set of excerpts to capture some the ideas that I found to be the most exciting and thought-provoking. All of the quotes below are direct excerpts from the book (I placed a few modifications for clarity within “[]”), and if you find them interesting I highly recommend a full read of the book, whose richness and illuminating analogies go well beyond the content here.</p><h3>Introduction</h3><h4>Motivation</h4><blockquote>In a word, <strong>GEB</strong> is a very personal attempt to say how it is that animate beings can come out of inanimate matter. What is a self, and how can a self come out of stuff that is as selfless as a stone or a puddle? What is an “I” and why are such things found (at least so far) only in association with, as poet Russell Edson once wonderfully phrased it, “teetering bulbs of dread and dream” — that is, only in association with certain kinds of gooey lumps encased in hard protective shells mounted atop mobile pedestals that roam the world on pairs of slightly fuzzy, jointed stilts?</blockquote><blockquote><strong>GEB </strong>was inspired by my long-held conviction that the “strange loop” notion holds the key to unravelling the mystery that we conscious beings call “being” or “consciousness”.</blockquote><h4>Strange Loops in Bach, Escher, Gödel</h4><blockquote>The “Strange Loop” phenomenon occurs whenever, by moving upwards (or downwards) through the levels of some hierarchical system, we unexpectedly find ourselves right back where we started.</blockquote><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FxUHQ2ybTejU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DxUHQ2ybTejU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FxUHQ2ybTejU%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/fa9ee8a16d2199610c29c31b2a0359ad/href">https://medium.com/media/fa9ee8a16d2199610c29c31b2a0359ad/href</a></iframe><blockquote>Implicit in the concept of Strange Loops is the concept of infinity, since what else is a loop but a way of representing an endless process in a finite way? And infinity plays a large role in many of [M.C.] Escher’s drawings. Copies of one single theme often fit into each other, forming visual analogues to the canons of Bach.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rEaQf1lmiXs7oWg0IhfbEQ.png" /></figure><blockquote>In its absolutely barest form, Godel’s discovery involves the translation of an ancient paradox in philosophy into mathematical terms. That paradox is the so-called Epimenides paradox, or liar paradox. Epimenides was a Cretan who made one immortal statement: “All Cretans are liars.” A sharper version of the statement is simply “I am lying”; or, “This statement is false”.</blockquote><p><strong>Godel’s First Incompleteness Theorem:</strong> Any adequate axiomatizable theory is incomplete. In particular the sentence “This sentence is not provable” is true but not provable in the theory.</p><blockquote>Completeness: Every true statement which can be expressed in the notation of the system is a theorem. When all statements which are true (in some imaginable world), and which can be expressed as well-formed strings of the system, are theorems.</blockquote><h3>Levels of Mind</h3><h4>Articles of Reductionistic Faith</h4><blockquote>One way to think about the relation between higher and lower levels in the brain is this. One could assemble a neural net which, on a local (neuron-to-neuron) level, performed in a manner indistinguishable from a neural net in a brain, but which had no higher-level meaning at all. The fact that the lower level is composed of interacting neurons does not necessarily force any higher level of meaning to appear — no more than the fact that alphabet soup contains letters forces meaningful sentences to be found, swimming about in the bowl. High-level meaning is an optional feature of a neural network — one which may emerge as a consequence of evolutionary environmental pressures.</blockquote><blockquote>Figure 107 is a diagram illustrating the fact that emergence of a higher level of meaning is optional. The upwards-pointing arrow indicates that a substrate can occur without a higher level of meaning, but not vice versa: the higher level must be derived from properties of a lower one.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wHaVs1h0nDBz5_uXYvviLA.png" /></figure><blockquote>The diagram includes an indication of a computer simulation of a neural network. This is in principle feasible, no matter how complicated the network, provided that the behavior of individual neurons can be described in terms of computations which a computer can carry out. This is a subtle postulate which few people even think of questioning. Nevertheless it is a piece of “reductionistic faith”; it could be considered a “microscopic version” of the Church-Turing Thesis. Below we state it explicitly:</blockquote><blockquote>CHURCH-TURING THESIS, MICROSCOPIC VERSION:<br>The behavior of the components of a living being can be simulated on a computer. That is, the behavior of any component (typically assumed to be a cell) can be calculated by a FlooP program (i.e., general recursive function) to any desired degree of accuracy, given a sufficiently precise description of the component’s internal state and local environment.</blockquote><blockquote>This version of the Church-Turing Thesis says that brain processes do not possess any more mystique — even though they possess more levels of organization-than, say, stomach processes. It would be unthinkable in this day and age to suggest that people digest their food, not by ordinary chemical processes, but by a sort of mysterious and magic “assimilation”. This version of the CT-Thesis simply extends this kind of commonsense reasoning to brain processes. In short, it amounts to faith that the brain operates in a way which is, in principle, understandable. It is a piece of reductionist faith.</blockquote><blockquote>A corollary to the Microscopic CT-Thesis is this rather terse new macroscopic version:</blockquote><blockquote>CHURCH-TURING THESIS, REDUCTIONIST’S VERSION:<br>All brain processes are derived from a computable substrate.</blockquote><blockquote>This statement is about the strongest theoretical underpinning one could give in support of the eventual possibility of realizing Artificial Intelligence.</blockquote><blockquote>Of course, Artificial Intelligence research is not aimed at simulating neural networks, for it is based on another kind of faith: that probably there are significant features of intelligence which can be floated on top of entirely different sorts of substrates than those of organic brains.</blockquote><h4>Parallel Progress in Al and Brain Simulation?</h4><blockquote>The idea that, if Al is to be achieved, the actual hardware of the brain might one day have to be simulated or duplicated, is, for the present at least, quite an abhorrent thought to many Al workers. Still one wonders, “How finely will we need to copy the brain to achieve Al?” The real answer is probably that it all depends on how many of the features of human consciousness you want to simulate.</blockquote><blockquote>Is an ability to play checkers well a sufficient indicator of intelligence? If so, then Al already exists, since checker-playing programs are of world class. Or is intelligence an ability to integrate functions symbolically, as in a freshman calculus class? If so, then AI already exists, since symbolic integration routines outdo the best people in most cases. Or is intelligence the ability to play chess well? If so, then AI is well on its way, since chess-playing programs can defeat most good amateurs; and the level of artificial chess will probably continue to improve slowly.</blockquote><blockquote>Historically, people have been naive about what qualities, if mechanized, would undeniably constitute intelligence. Sometimes it seems as though each new step towards Al, rather than producing something which everyone agrees is real intelligence, merely reveals what real intelligence is not. If intelligence involves learning, creativity, emotional responses, a sense of beauty, a sense of self, then there is a long road ahead, and it may be that these will only be realized when we have totally duplicated a living brain.</blockquote><h4>Irrational and Rational Can Coexist on Different Levels</h4><blockquote>A brain, too, is a collection of faultlessly functioning elements — neurons. Whenever a neuron’s threshold is surpassed by the sum of the incoming signals, BANG! — it fires. It never happens that a neuron forgets its arithmetical knowledge — carelessly adding its inputs and getting a wrong answer. Even when a neuron dies, it continues to function correctly, in the sense that its components continue to obey the laws of mathematics and physics. Yet as we all know, neurons are perfectly capable of supporting high-level behavior that is wrong, on its own level, in the most amazing ways. Figure 109 is meant to illustrate such a clash of levels: an incorrect belief held in the software of a mind, supported by the hardware of a faultlessly functioning brain.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LYqII2G0VKLUkciqzfQ44Q.png" /></figure><blockquote>The point — a point which has been made several times earlier in various contexts — is simply that meaning can exist on two or more different levels of a symbol-handling system, and along with meaning, rightness and wrongness can exist on all those levels. The presence of meaning on a given level is determined by whether or not reality is mirrored in an isomorphic (or looser) fashion on that level. So the fact that neurons always perform correct additions (in fact, much more complex calculations) has no bearing whatsoever on the correctness of the top-level conclusions supported by their machinery.</blockquote><blockquote>To make the same point in a different way, let us say you are having a hard time making up your mind whether to order a cheeseburger or a pineappleburger. Does this imply that your neurons are also balking, having difficulty deciding whether or not to fire? Of course not. Your hamburger-confusion is a high-level state which fully depends on the efficient firing of thousands of neurons in very organized ways. This is a little ironic, yet it is perfectly obvious when you think about it. Nevertheless, it is probably fair to say that nearly all confusions about minds and computers have their origin in just such elementary level-confusions.</blockquote><blockquote>There is no reason to believe that a computer’s faultlessly functioning hardware could not support high-level symbolic behavior which would represent such complex states as confusion, forgetting, or appreciation of beauty. It would require that there exist massive subsystems interacting with each other according to a complex “logic”. The overt behavior could appear either rational or irrational; but underneath it would be the performance of reliable, logical hardware.</blockquote><blockquote>This sentence is False. — Epimenides sentence</blockquote><h4>The Neural Substrate of the Epimenides Paradox</h4><blockquote>Presumably when you hear the Epimenides sentence, your brain sets up some “coding” of the sentence — an internal configuration of interacting symbols. Then it tries to classify the sentence as “true” or “false”. This classifying act must involve an attempt to force several symbols to interact in a particular way. (Presumably this happens when any sentence is processed.) Now if it happens that the act of classification would physically disrupt the coding of the sentence — something which would ordinarily never happen — then one is in trouble, for it is tantamount to trying to force a record player to play its self-breaking record. We have described the conflict in physical terms, but not in neural terms. If this analysis is right so far, then presumably the rest of the discussion could be carried on when we know something about the constitution of the “symbols” in the brain out of neurons and their firings, as well as about the way that sentences become converted into “codings”.</blockquote><blockquote>This sketch of the neural substrate of the Epimenides paradox suggests (to me, at least) that the resolution of the English version of the Epimenides paradox might be similar to that for the Tarski version. The resolution involves abandoning the notion that a brain could ever provide a fully accurate representation for the notion of truth. The novelty of this resolution lies in its suggestion that a total modeling of truth is impossible for quite physical reasons: namely, such a modeling would require physically incompatible events to occur in a brain.</blockquote><h3>Strange Loops and Consciousness</h3><h4>Can Machines Possess Originality?</h4><blockquote>[Arthur] Samuel’s point, if I may caricature it, is this:</blockquote><blockquote>No computer ever “wants” to do anything, because it was programmed by someone else. Only if it could program itself from zero on up — an absurdity — would it have its own sense of desire.</blockquote><blockquote>In his argument, Samuel […] implies that behind any mechanization of desire, there has to be either an infinite regress or worse, a closed loop. If this is why computers have no will of their own, what about people? The same criterion would imply that:</blockquote><blockquote>Unless a person designed himself and chose his own wants (as well as choosing to choose his own wants, etc.), he cannot be said to have a will of his own.</blockquote><blockquote>It makes you pause to think where your sense of having a will comes from. Unless you are a soulist, you’ll probably say that it comes from your brain — a piece of hardware which you did not design or choose. And yet that doesn’t diminish your sense that you want certain things, and not others. You aren’t a “self-programmed object” (whatever that would be), but you still do have a sense of desires, and it springs from the physical substrate of your mentality. Likewise, machines may someday have wills despite the fact that no magic program spontaneously appears in memory from out of nowhere (a “self-programmed program”). They will have wills for much the same reason as you do — by reason of organization and structure on many levels of hardware and software. Moral: The Samuel argument doesn’t say anything about the differences between people and machines, after all.</blockquote><h4>Below Every Tangled Hierarchy Lies An Inviolate Level</h4><blockquote>A central issue of this book would be: “Do words and thoughts follow formal rules?” One major thrust of the book has been to point out the many-leveledness of the mind/brain, and I have tried to show why the ultimate answer to the question is, “Yes — provided that you go down to the lowest level — the hardware — to find the rules.” When we humans think, we certainly do change our own mental rules, and we change the rules that change the rules, and on and on — but these are, so to speak, “software rules”. However, the rules at bottom do not change. Neurons run in the same simple way the whole time. You can’t “think” your neurons into running some nonneural way, although you can make your mind change style or subject of thought. Like Achilles in the Prelude, Ant Fugue, you have access to your thoughts but not to your neurons. Software rules on various levels can change; hardware rules cannot — in fact, to their rigidity is due the software’s flexibility! Not a paradox at all, but a fundamental, simple fact about the mechanisms of intelligence.</blockquote><blockquote>This distinction between self-modifiable software and inviolate hardware is what I wish to pursue in this final Chapter, developing it into a set of variations on a theme. Some of the variations may seem to be quite far-fetched, but I hope that by the time I close the loop by returning to brains, minds, and the sensation of consciousness, you will have found an invariant core in all the variations.</blockquote><blockquote>My main aim in this Chapter is to communicate some of the images which help me to visualize how consciousness rises out of the jungle of neurons; to communicate a set of intangible intuitions, in the hope that these intuitions are valuable and may perhaps help others a little to come to clearer formulations of their own images of what makes minds run. I could not hope for more than that my own mind’s blurry images of minds and images should catalyze the formation of sharper images of minds and images in other minds.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/646/1*mGGw7US7aBxJXiXHlBcSeA.png" /><figcaption>Drawing Hands, by M. C. Escher (lithograph, 1948)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_JWmDCGbxVf7KJ0mQCqxtg.png" /></figure><h4>Brain and Mind: A Neural Tangle Supporting a Symbol Tangle</h4><blockquote>We can relate [“Drawing Hands”] to the brain, as well as to Al programs. In our thoughts, symbols activate other symbols, and all interact heterarchically. Furthermore, the symbols may cause each other to change internally, in the fashion of programs acting on other programs. The illusion is created, because of the Tangled Hierarchy of symbols, that there is no inviolate level. One thinks there is no such level because that level is shielded from our view.</blockquote><blockquote>If it were possible to schematize this whole image, there would be a gigantic forest of symbols linked to each other by tangly lines like vines in a tropical jungle — this would be the top level, the Tangled Hierarchy where thoughts really flow back and forth. This is the elusive level of mind: the analogue to LH and RH. Far below in the schematic picture, analogous to the invisible “prime mover” Escher, there would be a representation of the myriad neurons — the “inviolate substrate” which lets the tangle above it come into being. Interestingly, this other level is itself a tangle in a literal sense — billions of cells and hundreds of billions of axons, joining them all together.</blockquote><blockquote>This is an interesting case where a software tangle, that of the symbols, is supported by a hardware tangle, that of the neurons. But only the symbol tangle is a Tangled Hierarchy. The neural tangle is just a “simple” tangle. This distinction is pretty much the same as that between Strange Loops and feedback, which I mentioned in Chapter XVI. A Tangled Hierarchy occurs when what you presume are clean hierarchical levels take you by surprise and fold back in a hierarchy-violating way. The surprise element is important; it is the reason I call Strange Loops “strange”. A simple tangle, like feedback, doesn’t involve violations of presumed level distinctions. An example is when you’re in the shower and you wash your left arm with your right, and then vice versa. There is no strangeness to the image. Escher didn’t choose to draw hands drawing hands for nothing!</blockquote><h4>Understanding the Mind</h4><blockquote>“Can we ever hope to understand our minds! brains?”</blockquote><blockquote>Or does some marvelous diabolical Gödelian proposition preclude our ever unraveling our minds? Provided you do not adopt a totally unreasonable definition of “understanding”, I see no Gödelian obstacle in the way of the eventual understanding of our minds. For instance, it seems to me quite reasonable to desire to understand the working principles of brains in general, much the same way as we understand the working principles of car engines in general. It is quite different from trying to understand any single brain in every last detail — let alone trying to do this for one’s own brain! I don’t see how Gödel’s Theorem, even if construed in the sloppiest way, has anything to say about the feasibility of this prospect. I see no reason that Gödel’s Theorem imposes any limitations on our ability to formulate and verify the general mechanisms by which thought processes take place in the medium of nerve cells. I see no barrier imposed by Gödel’s Theorem to the implementation on computers (or their successors) of types of symbol manipulation that achieve roughly the same results as brains do. It is entirely another question to try and duplicate in a program some particular human’s mind — but to produce an intelligent program at all is a more limited goal. Godel’s Theorem doesn’t ban our reproducing our own level of intelligence via programs any more than it bans our reproducing our own level of intelligence via transmission of hereditary information in DNA, followed by education.</blockquote><blockquote>Does Gödel’s Theorem, then, have absolutely nothing to offer us in thinking about our own minds? I think it does, although not in the mystical and imitative way which some people think it ought to. I think that the process of coming to understand Gödel’s proof, with its construction involving arbitrary codes, complex isomorphisms, high and low levels of interpretation, and the capacity for self-mirroring, may inject some rich undercurrents and flavors into one’s set of images about symbols and symbol processing, which may deepen one’s intuition for the relationship between mental structures on different levels.</blockquote><blockquote>Before suggesting a philosophically intriguing “application” of Godel’s proof. I would like to bring up the idea of “accidental inexplicability” of intelligence. Here is what that involves. It could be that our brains, unlike car engines, are stubborn and intractable systems which we cannot neatly decompose in any way. At present, we have no idea whether our brains will yield to repeated attempts to cleave them into clean layers, each of which can be explained in terms of lower layers — or whether our brains will foil all our attempts at decomposition.</blockquote><blockquote>But even if we do fail to understand ourselves, there need not be any Godelian “twist” behind it; it could be simply an accident of fate that our brains are too weak to understand themselves. Think of the lowly giraffe, for instance, whose brain is obviously far below the level required for self-understanding — yet it is remarkably similar to our own brain. In fact, the brains of giraffes, elephants, baboons — even the brains of tortoises or unknown beings who are far smarter than we are — probably all operate on basically the same set of principles. Giraffes may lie far below the threshold of intelligence necessary to understand how those principles fit together to produce the qualities of mind; humans may lie closer to that threshold perhaps just barely below it, perhaps even above it. The point is that there may be no fundamental (i.e., Gödelian) reason why those qualities are incomprehensible; they may be completely clear to more intelligent beings.</blockquote><blockquote>What insights might Gödel’s proof offer us about explanations of our minds/brains? Gödel’s proof offers the notion that a high-level view of a system may contain explanatory power which simply is absent on the lower levels.</blockquote><h4>Consciousness as an Intrinsically High-Level Phenomenon</h4><blockquote>Gödel’s proof suggests — though by no means does it prove! — that there could be some high-level way of viewing the mind/brain, involving concepts which do not appear on lower levels, and that this level might have explanatory power that does not exist — not even in principle — on lower levels. It would mean that some facts could be explained on the high level quite easily, but not on lower levels at all. No matter how long and cumbersome a low-level statement were made, it would not explain the phenomena in question. It is the analogue to the fact that, if you make derivation after derivation in TNT [an axiomatic system], no matter how long and cumbersome you make them, you will never come up with one for G [a valid theorem that states it’s own falsehood]— despite the fact that on a higher level, you can see that G is true.</blockquote><blockquote>What might such high-level concepts be? It has been proposed for eons, by various holistically or “soulistically” inclined scientists and humanists, that consciousness is a phenomenon that escapes explanation in terms of brain-components; so here is a candidate, at least. There is also the ever-puzzling notion of free will. So perhaps these qualities could be “emergent” in the sense of requiring explanations which cannot be furnished by the physiology alone. But it is important to realize that if we are being guided by Gödel’s proof in making such bold hypotheses, we must carry the analogy through thoroughly. In particular, it is vital to recall that G’s nontheoremhood does have an explanation — it is not a total mystery! The explanation hinges on understanding not just one level at a time, but the way in which one level mirrors its metalevel, and the consequences of this mirroring. If our analogy is to hold, then, “emergent” phenomena would become explicable in terms of a relationship between different levels in mental systems.</blockquote><blockquote>My belief is that the explanations of “emergent” phenomena in our brains — for instance, ideas, hopes, images, analogies, and finally consciousness and free will — are based on a kind of Strange Loop, an interaction between levels in which the top level reaches back down towards the bottom level and influences it, while at the same time being itself determined by the bottom level. In other words, a self-reinforcing “resonance” between different levels — quite like the Henkin sentence which, by merely asserting its own provability, actually becomes provable. The self comes into being at the moment it has the power to reflect itself.</blockquote><blockquote>This should not be taken as an antireductionist position. It just implies that a reductionistic explanation of a mind, in order to be comprehensible, must bring in “soft” concepts such as levels, mappings, and meanings. In principle, I have no doubt that a totally reductionistic but incomprehensible explanation of the brain exists; the problem is how to translate it into a language we ourselves can fathom. Surely we don’t want a description in terms of positions and momenta of particles; we want a description which relates neural activity to “signals” (intermediate-level phenomena) — and which relates signals, in turn, to “symbols” and “subsystems”, including the presumed-to-exist “self-symbol”. This act of translation from low-level physical hardware to high-level psychological software is analogous to the translation of number-theoretical statements into metamathematical statements. Recall that the level-crossing which takes place at this exact translation point is what creates Godel’s incompleteness and the self-proving character of Henkin’s sentence. I postulate that a similar level-crossing is what creates our nearly unanalyzable feelings of self.</blockquote><blockquote>There is a famous breach between two languages of discourse: the subjective language and the objective language. For instance, the “subjective” sensation of redness, and the “objective” wavelength of red light. To many people, these seem to be forever irreconcilable. I don’t think so. No more than the two views of Escher’s Drawing Hands are irreconcilable from “in the system”, where the hands draw each other, and from outside, where Escher draws it all. The subjective feeling of redness comes from the vortex of self-perception in the brain; the objective wavelength is how you see things when you step back, outside of the system. Though no one of us will ever be able to step back far enough to see the “big picture”, we shouldn’t forget that it exists. We should remember that physical law is what makes it all happen — way, way down in neural nooks and crannies which are too remote for us to reach with our high-level introspective probes.</blockquote><h4>The Self-Symbol and Free Will</h4><blockquote>Now let us go on to imagine a robot which has a repertoire of symbols. This robot is placed in a T-maze. However, instead of going for the reward, it is preprogrammed to go left whenever the next digit of the square root: of 2 is even, and to go right whenever it is odd. Now this robot is capable of modeling the situation in its symbols, so it can watch itself making choices. Each time the T is approached, if you were to address to the robot the question, “Do you know which way you’re going to turn this time?” it would have to answer, “No”. Then in order to progress, it would activate its “decider” subroutine, which calculates the next digit of the square root of 2, and the decision is taken. However, the internal mechanism of the decider is unknown to the robot — it is represented in the robot’s symbols merely as a black box which puts out “left”’s and “right”’s by some mysterious and seemingly random rule. Unless the robot’s symbols are capable of picking up the hidden heartbeat of the square root of 2, beating in the L’s and R’s, it will stay baffled by the “choices” which it is making. Now does this robot make choices? Put yourself in that position. If you were trapped inside a marble rolling down a hill and were powerless to affect its path, yet could observe it with all your human intellect, would you feel that the marble’s path involved choices? Of course not. Unless your mind is affecting the outcome, it makes no difference that the symbols are present.</blockquote><blockquote>So now we make a modification in our robot: we allow its symbols — including its self-symbol — to affect the decision that is taken. Now here is an example of a program running fully under physical law, which seems to get much more deeply at the essence of choice than the previous examples did. When the robot’s own chunked concept of itself enters the scene, we begin to identify with the robot, for it sounds like the kind of thing we do. It is no longer like the calculation of the square root of 2, where no symbols seem to be monitoring the decisions taken. To be sure, if we were to look at the robot’s program on a very local level, it would look quite like the square-root program. Step after step is executed, and in the end “left” or “right” is the output. But on a high level we can see the fact that symbols are being used to model the situation and to affect the decision. That radically affects our way of thinking about the program. At this stage, meaning has entered this picture — the same kind of meaning as we manipulate with our own minds.</blockquote><blockquote>Now if some outside agent suggests ‘L’ as the next choice to the robot, the suggestion will be picked up and channeled into the swirling mass of interacting symbols. There, it will be sucked inexorably into interaction with the self-symbol, like a rowboat being pulled into a whirlpool. That is the vortex of the system, where all levels cross. Here, the ‘L’ encounters a Tangled Hierarchy of symbols and is passed up and down the levels. The self-symbol is incapable of monitoring all its internal processes, and so when the actual decision emerges — ‘L’ or ‘R’ or something outside the system — the system will not be able to say where it came from. Unlike a standard chess program, which does not monitor itself and consequently has no ideas about where its moves come from, this program does monitor itself and does have ideas about its ideas — but it cannot monitor its own processes in complete detail, and therefore has a sort of intuitive sense of its workings, without full understanding. From this balance between self-knowledge and self-ignorance comes the feeling of free will.</blockquote><blockquote>Think, for instance, of a writer who is trying to convey certain ideas which to him are contained in mental images. He isn’t quite sure how those images fit together in his mind, and he experiments around, expressing things first one way and then another, and finally settles on some version. But does he know where it all came from? Only in a vague sense. Much of the source, like an iceberg, is deep underwater, unseen — and he knows that. Or think of a music composition program, something we discussed earlier, asking when we would feel comfortable in calling it the composer rather than the tool of a human composer. Probably we would feel comfortable when self-knowledge in terms of symbols exists inside the program, and when the program has this delicate balance between self-knowledge and self-ignorance. It is irrelevant whether the system is running deterministically; what makes us call it a “choice maker” is whether we can identify with a high-level description of the process which takes place when the program runs. On a low (machine language) level, the program looks like any other program; on a high (chunked) level, qualities such as “will”, “intuition”, “creativity”, and “consciousness” can emerge.</blockquote><blockquote>The important idea is that this “vortex” of self is responsible for the tangledness, for the Gödelian-ness, of the mental processes. People have said to me on occasion, “This stuff with self-reference and so on is very amusing and enjoyable, but do you really think there is anything serious to it?” I certainly do. I think it will eventually turn out to be at the core of AI, and the focus of all attempts to understand how human minds work. And that is why Godel is so deeply woven into the fabric of my book.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b14ae3d82162" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>