I’m a huge fan of cross-domain knowledge. Coming from an academic background in philosophy, I feel my greatest strategy for creating and building a career is leaning in hard to knowledge and skills that are learned in one domain or context, then applying it to a unique area. You get a large confidence boost when you make connections by spotting patterns and connections that map analogical cases to each other.

The first time I truly appreciated this was in my days working for the university gambling lab. We were collecting data on slot machine players by recruiting participants into our study to measure the effects properties of the machine user-interface had in gambler’s cognitive awareness. In other words, did how the graphics and sounds play on the screen help the gambler understand their relative wins and losses over time. In one study, the simulation we were using for participants to play on during the trial had been modified, but on some of the laptops the wrong version of the software was copied over, and we didn’t realize the mistake until the end of the day. Of the three laptops, two had the right software, and one did not. At the end of each session, we uploaded the user data to a secure repository and deleted the local files, which meant that once we were back in the lab, there was no way of knowing which participant file batch came from the defective software.

We thankfully caught the issue early and limited the damage, but afterwards we had an issue with figuring out which files to exclude from analysis. On the face of it, there was no way of knowing from the participant’s biometric data which simulation they used. So instead we had to dig into the debug files that were spit out by the machine to verify that the simulation ran successfully.

All the files were generated in an XML format, however I had neither experience in basic coding nor reading XML files. I had to figure out a way of showing whether the version of the software was correct. To me, the XML files were largely gibberish.

But, I was able to spot a pattern in the files that reminded me of my formal logic courses from undergrad. While I did poorly in the courses at the time, I did retain some of the strategies taught for understanding the structuring of the syntax of formal logic arguments, specifically how nested arguments worked and how assumptions were communicated. I started to see the same structure in the XML code, how sub- and sub-sub arguments were written to call different files into the program, and where those files were being drawn from.

And there it was. At the bottom of one of the debug files, was a list of the files being called on by the simulation. In the broken simulation, the file path to a certain sound that was meant to be played was empty, meaning that when the simulation was supposed to play and auditory cue, there was no file name to look for, and so the simulation moved on.

I compared this with the files we knew came from the working simulators and saw that this was the main difference, giving us the key for finding the bad data points and justifiably excluding them from the overall data set. By finding this, I saved an entire day’s worth of data files (a cost savings that includes the some-30 participant files, their remuneration, three research assistant wages, per diem costs, travel, and consumable materials on site).

I grant that computer programming is entirely built on the foundations of formal logic and mathematics, so it’s not that I was gaining a unique insight into the problem by bringing knowledge from one separate domain into another. However, this was one of the first times I encountered a problem where I lacked the traditional knowledge and skill to address it, so I came at the problem from another angle. It was a case where I gained confidence in myself to be resourceful and tap into previous learning to address new/novel problems.

As I noted above, being trained in academic philosophy has pushed me in this direction of career development. On a superficial level, relying on cross-domain knowledge is a career survival strategy because philosophy doesn’t always teach you skills that are easily applicable to the working world. I have sadly, never once, had to use my understanding of Plato’s arguments in my workplace. But on a deeper level, I think training in philosophy naturally pushes you into this kind of problem-solving. Most of my experiences in philosophy involves approaching a thought experiment or line of thinking, considering what it’s trying to tell us, then testing those arguments against counter-factuals and alternative arguments or explanations. To do this well, you have to reduce a problem down into its constitutive parts to tease out relevant intuitions, then test them out, often by porting those intuitions from one context into another to see if they still hold as both valid and sound.

It’s not all that dissimilar to the processes used by engineers or designers to gather data and accurately define the problem they are intending to design for. Whereas the engineer will apply the tools they’ve been taught fairly linearly to create a design for the problem, my strategy is to adopt cross-domain knowledge to make connections where they might previously had not been apparent. The results can often be solved quicker or more efficiently if I had the relevant domain knowledge (e.g. an understanding of coding), however when I lack the specific experience to address the problem, as a generalist thinker I have to rely on analogical thinking and a wider exposure to ideas to suss out those connections. What I lack in a direct approach, I make up for in novelty and creative/divergent thinking, which has the benefit of sometimes opening up new opportunities to explore.

Stay Awesome,

Ryan