Philosophy and programming have a similar mindset
I spent nine years of my life doing philosophy at a university institution. After master’s a bachelor’s, two masters, and a doctorate I decided to move away from academia and landed a job as a software engineer.
I was surprised to discover that, even if my technical knowledge was minimal when I started to work as a software engineer, doing philosophy prepared me really well for this profession.
But doing philosophy helped me to perfect skills that are the bread and butter of good programmers. And I like to still do philosophy because I think this makes me a better programmer.
In this article, I present three reasons why doing philosophy can help you become a better programmer.
Before I get into the main three points, let me make a caveat. I speak about doing philosophy, not simple reading philosophy books. There is a difference between simply absorbing information — and actively engaging with it. You do not need to be in academia for doing philosophy. What you need is actively engage in philosophical thinking.
Philosophers disagree with each other. As the philosopher, Peter Van Inwagen puts it “Disagreement in philosophy is pervasive and irresoluble.
There is almost no thesis in philosophy about which philosophers agree” (Inwagen, 2017, pp. 129–130). A PhilPapers survey conducted among professional philosophers in 2020 shows that there are only 3 out of 40 main philosophical questions on which more than 70% of philosophers agree on the answer.
Now when doing philosophy you can think of this as somehow disappointing. You may wish to discover the truth about a certain topic and you end up acknowledging that consensus among philosophers is so hard to build. But being in a field where disagreement is so widespread among experts teaches you to disagree productively with other people.
When engaging in a philosophical argument with someone who disagrees with us, it’s important to be able to fairly reconstruct the view that they have, before criticizing it, to understand the strength of their argument, and also acknowledge the weakness in your own view. This is also a great exercise to learn to be open to changing your mind about a topic after engaging in a philosophical discussion.
Being able to productively disagree is also a very useful skill in software engineering. There are multiple solutions to a software problem, and engineers may disagree on the solution to adopt.
Software engineering is largely a collaborative enterprise, handling disagreement is very important. Being able to disagree productively teaches you to avoid past each other, and ensure that disagreement can be a source of learning.
Being able to keep an open mind and recognize the value of an approach you don’t initially like can help to find compromises and accept that as a solution if the team so prefers.
Philosophical problems can be very broad and complex (see, for instance, this list of unsolved philosophical issues). When a problem is particularly entrenched, philosophers learn to break it down into its constituent parts before addressing it. They usually do this by asking questions, clearly analyzing the components of the problem, and unveiling any hidden assumption and any implication.
When writing, philosophers do strive for clarity of argument. If needed, they create fine-grained distinctions to qualify their answer to the problem, and it’s often because of these distinctions that there is progress in the understanding of a philosophical problem.
Learning to unpack complex problems is also key for programmers. Experienced programmers know that they need to ensure they understand the problem they are trying to solve really well before starting to code.
And when coding, programmers know they need to eliminate complexity as much as they can write code that is well readable and easy to understand. As John Ousterhout says, “The greatest limitation in writing software is our ability to understand the systems we are creating” (Ousterhout, 2018, p. 1).
By doing philosophy, you spend a considerable amount of time reviewing philosophical arguments, like programmers spend a considerable amount of time reviewing code.
To ensure an argument is valid, philosophers check whether the conclusion follows from its premises and whether the argument’s premises are all true. One of the possible strategies to check whether an argument is valid is to look for a counterexample: if a counterexample can be found, the argument becomes invalid.
In general, when doing philosophy, you try to anticipate objects to your argument, and you provide an answer to it. And this is a skill that comes in handy for programmers.
When coding, proficient programmers learn to think about edge cases to be able to accommodate them in their code. They need to anticipate where the code could break so that they can improve the quality of their code and design the program to handle issues gracefully.
Software engineers do not address philosophical questions nor they usually engage with philosophical writings during their work. But the mindset developed when doing philosophy can be beneficial for programmers.
Philosophers looking to become software engineers can be reassured: these three key skills that they worked very hard to get when doing philosophy will be easily transferable. And software engineers may be curious to incorporate a bit of philosophy into their weekly routine and first-hand experiment whether they will write better software as a result.
Bourget, D. & Chalmers, DJ (2021). Philosophers on Philosophy: The PhilPapers 2020 Survey
Ousterhout, J. (2018). A Philosophy of Software Design. Palo Alto: Yaknyam Press
Van Inwagen, P. (2017). Freedom to Break the Laws. In Thinking about Free Will (pp. 129–148). Cambridge: Cambridge University Press.