I've asked myself many times, "What does Myers-Briggs mean for programmers?"
I have come up with roughly the following:
- E -- pair programming, whiteboard discussion, code review
- I -- works alone, independently, minimum of direction and communication
- N -- Intuitives: Are interested in the abstract programming ideas. A software architecture angle.
- S -- Sensates: Are interested in the specifics of a running program, keeping it running. An administrators angle.
- F -- Feeling: Focused on how the code would feel to other programmers. Making it easy to read. Also focused on how the user will feel (user experience).
- T -- Thinking: Focused on logical implications from priors. Plays chess internally, against a codebase, or system ideas.
Perhaps "F" types code and debugs by feel,
, and note the use of the word feel,
) with attention to style. Or perhaps if T plays chess against challenges, F plays the GameOfGo?
F focuses on elegance and beauty, T focuses on speed and performance.
- P -- Perceiving External: observes, reviews, checks, sees
- J -- Judging External: works, follows procedure, plans
The contrast between Chess and GameOfGo
could apply to the J--P dimensions as well: J plays chess, where as P plays GameOfGo
For example: an ISTJ works independently, thinking methodically through problems that arise, doesn't really need to understand how a system works, just focuses on the immediate bug, "just get it done," and favors traditional standard ways of programming
For example: an ENFP wants to discuss architecture, languages, create systems, collaborate, understand how things work before debugging them
For example: an INTP studies architecture, understands lots of architectures deeply, sees in detail how they work, is an "extremely smart person" about software
might be an ENTP or an ENFP.
Language-Environments like SmallTalk
may be characteristic of the N-P type: high ideas, perceptual debugging (as in: most everything can be queries, looked at, examined, all the time)
Languages like Python and Ruby emphasize making the code easy to read and optimizing for "happiness" (F).
If you want to get something done, you probably want a J type. If you want to see a system, you probably want a P type.
My sense is that the corporate programmer, highly rewarded by our society, is the STJ -- Sensing (seeing what's in front of them, not concerned by high ideas,) Thinking (see quickly what leads to what,) and Judging (disciplined, on track, organized, keeping the work going.)
My sense is that C++ & STL reward the J more than the P: Since you can't look into the environment (see: StlSucks
) at debug time, or easily figure out how a large system works, perceptive are stunted-- you just can't see the whole system like the P's want to. But if you are a methodical J, and don't focus on big pictures, then you'll do just fine.
My sense is that a system like Smalltalk rewards the P: Since you can look at just about anything deeply in the whole system, at any time, and it makes for an exploratory environment. A "J" may find it to be "too much," like having too many options all over; Whereas the "P" may find: "Ah, finally, I can just see
what's going on."
A very few workplaces have high N
: That is, they focus on architecture, idea, cleanliness, and so on. Google is almost certainly an "N" type workplace. But the vast majority of the software world is oriented in the businessman's "S": "What works? What is expedient? How does everyone else do it? What makes clear and obvious sense?"
I have no idea how F plays out in software; And I say this as an F type myself! It seems to me that "T" type reasoning is the most clearly valuable way, in both design & debugging of software systems. Yet perhaps "F" reflects our comfort
working with a system: Does the API have beauty?
Does it feel
easy to use? Does the environment have an elegance to it? S-F (sensate feeling) might describe the programmer's I've met who have created very elegant designs
, a certain artistic bent in software development. They might not really know deep programming ideas, but they make beautiful things. (Now I think of Bill Kendrick, I think his name is; a Game developer.) Whereas an S-T is more of a mechanic who makes purring engines to classical form. An N-F makes wacky hypertext systems, an N-T makes architecture that performs mighty feats, if it works.
Google is an ENTJ. Extroverted, as noted by the high degree of internal collaboration, external collaboration with the OpenSource
world, etc.,. Intuitive, for big ideas. Thinking, rather than feeling, though to be fair, it seems more feeling oriented than most (ENxJ?). Judging -- focusing on steps and motions and work,
rather than perceiving.
Microsoft is (right now) an ISTJ. Introverted, doesn't really want to get involved with others, except as required by work. Very focused on pragmatics and "does it work" (sensate.) Thinking, rather than feeling (that's for certain,) and judging -- focusing on steps and motions and work.
Can't be bothered to perceive anything..! (Strong "J," strong executive streak.)
Yahoo might be an INFJ. CraigsList
might be an ESFP.
Apple might be xNFP: focusing on industrial design and user experience (F) with lots of innovation (NP).
Most corporations would be J, most research organizations would be P.
One thing that is interesting is that it seems that no software company is an ESTJ; I note it, because America (as in, "The United States of America,") is, basically, ESTJ. But I could see an argument that, in the late 80's and early 90's, Microsoft was an ESTJ.
As India booms into software, we may see something curious; India is INTP (introvert, intuitive, thinking, perceiving.) It might be interesting (enlightening, even :) ) to find: "What kinds of software systems follow out of Indian research facilities?" That said, perhaps the computer boom is only full of STJ entrepreneurs, which would make sense. We just need to find the Hindus and Buddhists who find a world of thought in computers.
- India is Perceiving? I dispute that. India is where a ton of CMMI level 5 organizations are, and a lot of the software contract houses write code to the letter of the contract (communication barrier forces this), often missing extremely obvious GUI/design considerations that a Perceiving type company would assume.