Think, Weigh, Judge

Before reading this article, take a moment to reflect on these 3 questions:

1. How often, and how long, do you stop and think for yourself before seeking information from others?
2. What are some positives and negatives about the widespread proliferation of information today?
3. Do you find yourself thinking through problems more or less than you have in the past?

Second-Hand Thinking

One of the theologians I follow recently posted an article highlighting the abundance of commentary¹ on theological subjects, and the over-reliance that can result from it. He referred to those who might lean towards such over-reliance as “second-handers” (i.e., second-hand thinking). Here is the full quote:

Here’s the catch with regard to thinking. John Dewey was mainly right when he said, “Nobody thinks until he has a problem.” Thinking is hard mental work. And constitutionally, we’re all disposed to be lazy, to avoid hard work, which means we naturally default to letting somebody else think for us, and then we get the answer when they’re done thinking. And that sounds efficient. He did the thinking; I’ll just take his answer and save myself a lot of time. What that does is turn the mind into passive mush and turn us into second-handers, inauthentic people.²

Aside from the application to its intended audience, this quote also made me think of the gravitation towards second-handedness that can occur in nearly all areas of life, not just theology. Software development happens to be one of them. Let’s dive into that.

Stack Information Overflow

As any developer will tell you, the sheer volume of information on practically every development topic is pretty staggering. Articles, documentation, tooling, best practices, opinions, adages (e.g., “Don’t roll your own crypto”), etc. They are a constant flow and increasing all the time. As with anything produced by people, that information is a mixture of good and bad information. Some good information becomes bad information over time (and perhaps, albeit rarely, the inverse is also true).

One response to this deluge of output can be to ignore its value entirely. I remember an old colleague positing that you “could forget everything they teach you in college [in the realm of technology] because by the time you graduate, everything will have changed”. While I didn’t go to college, I am skeptical of this assertion on the grounds that the principles that have aided me in my career the most have been those that transcend frameworks, tools, even time itself. I suspect those would form the basis for the things that would be taught in a college courses. Nonetheless, the problem of data decay is inevitable and needs to be taken into account.

On the other side of that equation is the “new is always better” mindset. I think it’s fair to say that any developer you might ask would tell you that “keeping up my skills” is more than a passing career concern. The Angular of today looks nothing like the AngularJS I used starting out. In that time, the front-end community has moved through Grunt, Bower, Gulp, Webpack, Rollup, Vite, etc. (and I’m sure there are/will be others). Humorous takes³ on the JavaScript community’s short attention span are often underscored whenever I see the results of the latest State of JavaScript survey. This criticism (which can just as easily be applied to other stacks) is not that “new is bad”, but “Have I stopped to think, weigh, and judge for myself before incorporating the thoughts/ideas/solutions of others?”.

Bad Habits Produce Bad Results

It is not an uncommon practice for developers to search for a problem, find a StackOverflow article detailing a similar/identical problem, and then copy-pasting the suggested solution into the codebase.

flowchart LR
    A(Encounter Problem) -->B(Stack Overflow)
    B --> C(Copy/Paste)
    C --> D(Did it work?)
    D -->|No| B
    D --> |Yes| E(Done)
  

This presents a problem on two fronts:

1. Experience: No knowledge was gained by either the developer or the codebase. When asked by others in the future (perhaps even their future self), the developer will be able to offer little-to-no insight into the solution (and potentially even the issue).
2. Impact: There are some subjects where having only second-hand knowledge can very easily result in incredibly damaging effects, e.g., security, cryptography.

This brings to mind another famous theologian, G. K. Chesterton, and a quote oft repeated in tech circles: “Chesterton’s Fence”. It goes something like this: “Should you come upon a fence, you should not consider removing it until you understand why it was put there in the first place”. This is a great quote, and one that I think of often, but the full text is worth expanding:

In the matter of reforming things, as distinct from deforming them, there is one plain and simple principle; a principle which will probably be called a paradox. There exists in such a case a certain institution or law; let us say, for the sake of simplicity, a fence or gate erected across a road. The more modern type of reformer goes gaily up to it and says, “I don’t see the use of this; let us clear it away.” To which the more intelligent type of reformer will do well to answer: “If you don’t see the use of it, I certainly won’t let you clear it away. Go away and think. Then, when you can come back and tell me that you do see the use of it, I may allow you to destroy it.”⁴

Go Away and Think

This is simply not what a lot of us want to do when presented with such easy access to information. This has been exacerbated with the introduction and proliferation of easy-to-access LLMs/GPTs. Where previously the requirement was to search and evaluate possible solutions, there is now the ability to have an interaction (“conversation” doesn’t quite fit) with an infinitely-patient, incredibly informative (again, “knowledgeable” doesn’t quite fit), pseudo intelligence that never sleeps, never needs a break, and never thinks. The worst version of our interaction from earlier now might look something like this:

flowchart LR
    A(Encounter Problem) -->B(Paste Full Error/Output Into GPT)
    B --> C(Copy/Accept Solution)
    C --> D(Is the problem still there?)
    D -->|Yes| B
    D --> |No| E(Done)
  

Where previously there was at least some level of thinking required in order to a) evaluate the problem outlined by others to see if it’s a match and b) discern how and where to implement the suggested solution, it is now possible to entirely outsource the “thinking” process to a LLM. While this should be a concern for those established developers who might see this ability as a feature (and perhaps the logical evolution of the search -> copy -> paste model), there is an even greater concern: those younger developers for whom GPT/LLMs will have been a constant starting day 1.

It’s one thing to know how to think and then to lean on second-hand knowledge; It’s something altogether different when that second-hand knowledge appears following each keystroke. When the ability to refactor entire codebases is available with the typing of a sentence and the clicking of a button (“Accept Solution”).

Do you fully understand the problem? Do you fully understand the solution?

Framing Your Thoughts

One of my favorite things about the aforementioned “second-handers” theologian is a habit I’ve observed in his thought-process: lists. Nearly every time I’ve heard him offer insight into a particular issue, he frames (or outright shares) his commentary in the form of a list:

• “Here are 10 observations about the problem at hand.”
• “I would ask 4 questions on this subject.”
• “I can think of 7 things that might be helpful to consider on this topic.”

Taking the time to a) look at the issue long enough to create a list of observations, questions, and/or ideas and b) sitting with those observations, questions, and/or ideas seems to be pretty powerful. Putting that into practice, I have 4 observations as to why thinking has become more difficult:

1. Western culture is built around near-instant and almost-universal access to just about anything and everything one could possibly want (let alone need). A byproduct of this seems to be the compulsion to have an immediate answer, opinion, or response to everything encountered in daily life.
2. The answer is (probably) already available somewhere.
3. The world is connected in such a way as has not been seen at any point in history and the sharing of experiences/knowledge is seen as both a human right and, more critically, an obligation.
4. Previously fundamental concerns like hunger, shelter, disease, and death, have largely been relegated to the background.⁵ I don’t have to think about anything anymore.

Stay Awhile And… Think

If anything is to be gleaned from this article, it isn’t that second-hand knowledge is bad; Second-hand knowledge is an awesome gift that, when applied correctly, has moved and inspired many of the countless, awe-inspiring things that can be seen all around today. And yet, as that knowledge is made more easily and more readily available, the tendency towards mental lethargy will undoubtably increase. The solution then, if there is any such thing, would seem to be to:

• Ask more questions (e.g., “Do I fully understand the problem?”)
• Spend more time in reflection than in action
• Get more comfortable with:
  • Having an answer/opinion/response but not needing to share it
  • Not having an answer/opinion/response on every subject
• Think, weigh, judge