Programmers love complexity

My post title looks like I’m starting another war (like my last one). Please keep an open mind, I think most of you will agree.Programmers like to solve problems. Sure there are exceptions, but if you don’t get satisfaction from solving a difficult problem, you’re not in the right job. Most programmers also get a high from solving a problem where other’s failed. It’s a form of prestige, putting your name in the ‘credits’ behind a particularly nasty coding obstacle.Similarly, programmers like to be part of a ‘brotherhood’ of people that have achieved a level of expertise. Take for example the cfgurus. I don’t know what rules are in place for membership in this mailing list, but one thing is clear: people on this list discuss a lot of nasty programming problems. There is also a lot of mystery and secrecy surrounding this group, because membership is invitation only. (if you’re wondering, no I’m not on the list).Given the above two arguments, I believe that it follows to say that programmers like and often crave complexity. I know I often find myself smiling and enjoying life when I’m searching for an elusive solution to a challenging complication. I do, however, enjoy simplicity when I can have it. But a good example of the yearning for difficulty is Linux. There are a lot of people putting a lot of hard work into making Linux an easy to use, user friendly operating system. But if you get deep into the Linux guru community, you will find that most people feel this effort is ruining their beloved OS. See, these folks have a achieved a level of greatness that is the Linux guru, because Linux is complex. They hate the point-n-click GUI, and thrive in a text based command shell, using memorized commands they’ve spent years mastering. The new face of Linux, an easy and approachable OS, will allow any old Joe to easily do what the Linux guru has spent years mastering. I know I’m oversimplifying the Linux OS and community, but the analogy holds water with a lot of Linux masters.Here’s where I’m afraid I’ll start a war. The ColdFusion community has some folks that fit the above descriptions. These programmers come from various backgrounds, but I’m going to pick on one: Java. Don’t get me wrong, I think Java is awesome (even though I have very little experience with it), and I’m not saying that it’s bad to like and seek out complexity. But one mistake I’ve seen people make is wish for complexity where none is needed. You can see this iingn the OOP community. For example, there has been a lot of talk about duck typing. There are some very smart luminaries pushing the idea of duck typing, and I happen to agree with them. But there are also a lot of intelligent people that don’t like this concept. The naysayers make some compelling arguments, but I believe the biggest reason is that duck typing removes the beloved complexity. They will say that this complexity is needed, because you lose power and/or control without it. But on the other side, some very smart people are striving to prove that duck typing will work, and indeed makes sense.In conclusion, I believe that one of the hardest things to do as a programmer is to make straightforward, usable software. There are tons of horrible user interfaces and websites out there. I believe this is because we use complex tools, we read and understand complex code, and we communicate using complex terms. Therefore, it becomes very difficult to communicate with our users, and thus to ‘communicate’ through an understandable, consistent, friendly interface. We don’t know how to speak their language, and often we hate the way our users would prefer to do things. However, we need to fight this propensity to create difficult software, as we will lose our users in the process.