I've noticed (is it just me?), that the really, really good programmers seem to be good at writing. Like their code flows, so does their written language.
To me, I suppose that makes sense: programming is writing programming languages. One writes code. Different code is written in different languages.
In your opinion, subjectively, does this hold, in general, true?
The really good programmers that I know by reputation are good writers, and I'm sure that is because they developed their reputation by writing well. The best programmers that I have personally worked with have had no unusual talent for writing.
Not at all.
Think about it: you only read articles/blog posts from good programmers which are also good at writing. But you never read articles/blog post from good programmers which are not good at writing - because they don't even write articles.
I'd say there's a correlation, but there are bound to be exceptions. Bear in mind that a good programmer doesn't just write good code - they write good comments, good documentation, good emails to their colleagues etc. Communication is hugely important in most programmers' jobs.
There's also the matter of "clear thinking leads to clear code" - if you can express what your code does accurately and concisely, you probably have a good handle on it, which means it's less likely to be buggy.
Note that this is about communication, not real "flair" when it comes to writing. You don't have to be a persuasive writer to write clean code, for example - but you should be able to explain yourself clearly.
Some of the best code I've seen has been written by people who are also good communicators. Being a good communicator can take a lot of shapes, including:
I think that if you include readability and expressiveness as adjectives that are applied to code from "good" coders, then I think that this makes sense. Communication is important in both writing code and life in general.
Defining the quality of code is related to this question, so I'll take a short stab at it as well. I value code that is both functional and expressive. If you had to pick one or the other I'd definitely pick functional code, but expressive code can be simpler, more elegant easier to understand, and more pleasant to maintain. As some other people have pointed out here, simple code is also more likely to be free of bugs, because there seems to be a correlation of bugginess with the number of moving parts in code.
Opposed to the idea of code as functional beauty, there's a lot of value in the model of writing lots and lots of functional code in a manner that's more pragmatic than elegant, and making things elegant when appropriate. A lot of amazing coders that I know follow that model. Some of them are awful communicators. :)
The bottom line is that there's some correlation, but I think that people who are on the skillful end of any distribution are likely to be better communicators.
maybe is because good programmers may have a better understanding on the subjects and when they pass a lot of their time blogging,writing, reading and coding it becomes a more natural thing.
What matters with broad generalizations such as "good programmers are good writers" isn't whether they are "true" but rather how you use them.
Should you hire someone who seems like a fine programmer and a good writer? Yes - they can contribute both skills in a team. Should you assume the best writer will be the greatest programmer one on the team? No. Should you test your teams' writing skills and fire the bad writers? No. Should you offer writing skills training to your team? Yes, if it seems useful.
Also, you may have heard about really good programmers who write well because they have communicated about themselves in blog and articles. The ones who don't write well might not have communicated about themselves as much. (Edit: those who put typos in the posts don't remembered as easily either)
Some say that good programmers are often good musicians, http://www.codinghorror.com/blog/archives/001214.html
I think you're making a pretty big mistake in your thinking. Just because two things are called "writing" doesn't mean they are actually the same, or use the same mental facilities. Just because two things are metaphorically related doesn't mean they are the same.
I think there are two reasons why you might think that good programmers are good writers
1) Smart people are probably going to be better writers then dumb people, and good programmers are obviously going to be pretty smart. But, but there are smart people who are not going to be good writers. They could have dyslexia, for example, or some other kind of aphasia. Those are extreme cases, but I think that if you adjust for intelligence good programmers are probably not better writers on average then other people.
2) People who are better at writing are better at explaining why their code is awesome. There could be great programmers out there who aren't very good at expressing themselves. No one will ever know how great they are because they can't explain it well, at least not without being very boring. On the other hand, someone who write well can explain their code in a way that's interesting. People will listen to them talking about their code, realize how awesome they are, and tell their friends. Those programmers who are great at writing or speaking will end up with reputations as great programmers.
Good communication is essential in performing any non-trivial task.
Unless you are writing code on your own (and I'm assuming that the majority of software written, isn't by just one person), then writing good software relies on good communication.
Look at some of the more useful parts of any software processes (agile, scrum, rup etc.) and they revolve around maximising good communication and disseminating information in an efficient way.
Even a continuous build process could be thought of as communicating problems to everyone sooner rather than later.
Test your hypothesis. Is the literary quality of SO better than your average public threaded discussion list?
How many good communicators you know are not good programmers?
I personally know many bad programmers who are excellent communicators.
I don't think these are related in the least.
Being a good communicator is always a plus in any industry, as its always good to be able to articulate your thoughts..but one and the other (good communicator, programmer) do not relate.
Linus is very proud of not being a good communicator, I agree with him, but IMHO he is a very good programmer..
he is not an exception either, just a popular easy example to throw here.
no, i notice my sentences are overly verbose as the c++ programming language that i write in. People also comment on my lack of Pronoun and i should try to be fluent in the english language (which is my native language). I tend to write with only nouns and everyone always comment on my bad grammar. (BTW ATM i am not trying to make my language worse, this is how i normally write. It isnt to bad? :))
You might be interested to read the "Learn how to write..." section in Joel Spolsky's "advice to college students". Basically, there may not be a correlation between good coders and good writers, but there's certainly a correlation between influential coders and good writers.
Good coders are not good writers usually, but good engineers are.
Good writing is a skill, not a gift (we are not talking about writing fiction here). It is a skill that can and should be trained. I sure that everyone of us can find many examples from his own life when good writing and speaking really made difference.
Also you may found interesting answers to the question "Should programmers be able to write clearly?".
I think this works naturaly just like SO does, when a badly written blog post comes along, none "up-votes" (sends it to a friend), instead they "down-vote" (ignore it, and avoid the blog), so the good stuff tends to bubble to the top, and the bad stuff never get out of the gate.
I don't think there is a correlation. Most of the programmers I have worked with are not good writers. What they write is not very creative and is straight to the point. They are also not good at UI design (even though most wouldn't admit it). I always assumed this was because programmers tend to be very logical and methodical (and less creative).
Just my thoughts..
No direct relation. They are two completely different tasks with completely different requirements.
Writing good code requires that you be clear, concise, and correct.
Writing good prose requires that you be at least minimally entertaining (so your readers don't get bored and leave). It also often requires some degree of persuasiveness. Neither of these is entirely compatible with just stating the facts clearly and briefly, then being done with it.
The effect you've observed is simply selection bias. The good programmers you read are also good writers because, if they weren't good writers, you wouldn't be reading them.
I just want to say that good written/spoken communication skills make good programmers great.
SkillSet skillSet = new SkillSet();
skillSet.Add(Skill.Coding, SkillLevel.High);
Programmer goodProgrammer = new Programmer(skillSet);
skillSet.Add(Skill.WrittenCommunication, SkillLevel.High);
skillSet.Add(Skill.SpokenCommunication, SkillLevel.High);
Programmer greatProgrammer = new Programmer(skillSet);
I would argue that good writing is a skill that affects a programmer's job performance. After all, what good is your code if nobody can figure out how to use it? Being a good writer will make you a better programmer, but it won't make you a good programmer.
If anything, I would say clear thinkers are clear programmers, and clear thinkers are clear writers
Edward Dijkstra says
Besides a mathematical inclination, an exceptionally good mastery of one's native tongue is the most vital asset of a competent programmer.
I don't think so.
To be a good programming writer requires a number of steps. First, this person must be good at programming. This of course means that they can put code on the screen, and then show that it is right, and it is efficient. Not everyone can do all of these things.
Following that, it must be that the programmer can communicate effectively in code. This is essentially the art of writing code for others to read. I think that this is a skill that must be learned over time, with much feedback from others, and also requires that the programmer do a lot of reading code himself, which not every coder likes to do.
Next the programmer must have something to say, in code form. At some level, I think all passionate programmers have this feature. This is basically the pet project everyone is working on in their spare time. I'm not sure, but in my opinion, this is The Art Knuth was talking about.
Finally, The programmer must be able to communicate effectively in prose. This about as hard to learn as communicating in code, except that you can't ever really fall back on the excuse that prose is really for machines to understand, because prose, unlike code, doesn't have that audience. With code, you might be able to verify that it works, even if it ultimately fails at showing other programmers why you would want to do it that way. There is no unit testing for prose.