I first noticed something like this, though I draw the lines differently, in the 1980s.

What's interesting is that there has been a shift over the years to where "programming" has come ot have a strong ideological bias to only one type.

The types I noticed then I call Cowboys and Architects. These are just terms I'm using for convenience, not meant as pejoratives.

Cowboys are now more common:
Some programmers write a bunch of sloppy code without bothering to ever design anything. Their methedology for making a product seems to be akin to bashing to the code into the shape it needs to be eventually. This group of people tend to advocate policies that assume everyone else is writing crappy code as well- unit tests, agile, etc. For instance, agile rejects design and assumes you can't know what the right shape for the code is going to be more than a week in advance and that all code is maleable without repercussions.

Architects are now rare:
Other programmers will sit for a week and think without writing any code. When they do, they sit down and over the course of an hour (or however long it takes to type it) will write out the code for the complete system or module. It will be bug-free with the exception of typos. Once the typos are fixed (Generally by getting the compiler to accept the code) the programmer can move on to implementing the next bit of functionality. Sometimes there are errors in the code working with other code, generally integration errors, but not errors in the thinking of the programmer. These programmers only accept that Agile makes sense because the business side of things can't make up its mind, so they architect core systems that are flexible to support multiple business needs, but don't need to be rewritten or bashed around, because they did it right the first time.

I'm of the latter type, and I have tested this objectively, by producing a 10,000 line iOS App like this, which has been in use for several years by tens of thousands of people with no crashes or other defects (a few minor conceptual bugs- mismatch between the features and the expectations of the business, which were fixed)... and not a single unit test. It compiled, it worked, and almost all the development time was spent on the UI. It has had major releases (eg: going from being iPad only to a universal app, etc.)

It has built in reporting for exceptions, and all of the reported exceptions are the result of things other than my code (eg: there are several situations where iOS will crash an app if it needs to or due to problems with pre-release versions of iOS, and those are what generate the exceptions.) No customer reported bugs either. (though they do have requests for things working slightly differently and new features, no programming errors reported by customers.)

The industry is so dominated by a culture of "all code is crap" that I think many people think that all programmers are cowboys and even Steve here is delineating types of Cowboys, and nobody believes architects exist.

Can you imagine someone saying "unit tests are a waste of time, they just double the amount of work with no benefit.". It produces a litany of excuses for why this isn't true. ("You need them if other people work on your code!", "maybe for a team of one", "you're assuming you'll never forget a design decision", etc.) I know this message will get responses along those lines-- its because Cowboyism has become an ideology. Yegge is right - programmers are ideological.

I'm not a savant and I'm not rare. Architects like me were about %50 of the programmers out there when I started out. I think the mainstreaming of "hacking" has produced a lot of people who are taught to be cowboys and a culture that encourages cowboyism.