1. It's a great way to learn a new codebase.
2. It's a good way to get some political capital so that you can get autonomy more easily.
You just don't usually start out with the plum assignments when you start a new job. If you do, you won't be given the autonomy to make them satisfying. So in my opinion, it's better to start off with jobs that you know will be drudgery to prove your worth than it will be to get a neat-sounding task where you'll be kept on a short leash.
For some people, the answer will always be "no". For others, it's complicated, and potentially impossible to answer without trying out the company for a while.
Suppose the code is well organized and understandable. The bugs are not the product of bad design, they're just the inevitable side effect of any real software project. The programmers who created these bugs are largely still with the organization, they are highly competent, and are more than willing to help a new dev get up to speed - and the documentation (and code quality) is so good that it usually isn't necessary. Lastly, the team and management is eager to give autonomy and flexibility to a talented, proven dev, so it's not a problem to build up that "political capital" you mentioned. Well in this case, what you said is reasonable and more than acceptable to many good devs, even if it isn't right for everyone.
Then there's the nightmare scenario - the team is not highly competent, and the reason you were hired is that the good programmers keep quitting and there's nobody to help you. The code base is a mess, and documentation doesn't exist or is useless. Even getting a build to work is difficult and painful. The reason the management is giving you bug fixes is that they don't really know what to do with a new hire, so they assign some bug fixes, that'll keep you busy for a while. Lastly, they're aren't interested in listening to new suggestions, so political capital won't get you anywhere. O course, in this case, I suppose it doesn't really matter what your assignments are.
By the way, there is another way to get political capital. In my first real programming job, I had an almost ludicrous amount of autonomy. Like, "find something that might be useful and write software for it" levels of autonomy. This was the dot com boom, and there was enough money to hire people for this kind of thing. Of course, they didn't give me high impact assignments, but they did give me broad flexibility in meeting (and even determining) my assignments. This can be an alternate way to build up the political capital you mentioned. Instead of having a limited role on a high impact project, you have a broad role on a low impact project. That can work well for some people - however, these jobs are very rare. Usually, you have to trade the stability of a paycheck for that kind of freedom, especially early in your career.
My current job had almost zero documentation anywhere, and nobody knew the entire system (or even the over-arching design, which I discovered was none). Which is starting to royally screw them over. And I started with a fairly highly integrated project. I learned it in spite of what I was doing in their system and lack of education for me (ie, zero), not because of it - they wanted things finished, I didn't want to finish them incorrectly.
Having someone take care of some of this stuff first to familiarize himself with the project and get used to the processes before jumping straight into a big task seems like a good idea to me.
Indeed!
Many developers view fixing bugs as a punishment. Perhaps that is part of the reason why so much software is riddled with bugs.
I really enjoy using various tools like static analysis programs and memory checkers to ferret out the offending bits of code, figuring out why they're broken, and fixing them.
It gives me a certain sense of satisfaction to finally conquer a bug. Particularly when it's a really tricky bug I've been bashing my head against for days.
Then again, when I've been after a given bug for days it can get really frustrating, and I don't enjoy the frustration.
And it's not like my dream job is doing nothing but fixing bugs. I also enjoy architecting new systems, learning new concepts, and applying them during the quest to complete a project.
I suppose a healthy mix of tasks, from architecture, to writing new code, to fixing bugs is ideal.
But what I really hate is writing documentation. I know it's necessary. And my (non-throwaway) code has quite a lot of comments in it because I know it's necessary and good practice. But it can get quite tedious.
I'd much rather bugfix than write documentation.
I actually treat bug fixing as a little treat. When I want a break from coding -- I'll go and find a few bugs to fix.
I started working on the bugs by choice, it was an easier way to familiarise myself with the source code and gave me some problems that the other developers hadn't been able to fix, or hadn't gotten to yet.
This is a little bit of an aside, but how many people out there take this approach with a new hire? If you're a manager/team lead, do you start new developers out fixing bugs? If you're a developer, how do you feel when bug fixes are your first assignments?
Personally, I think that fixing someone else's bugs is one of the hardest tasks in programming. Depending on how the interview went, it can also be a very depressing and alarming task (autonomy? creativity, opportunity to influence the project? we've found that our recruitment success increased by 10% every time we used one of those words. now here's your task list, go fix some bugs).
I want to be sure that I emphasize that people have the right to pick their own management style, and I'm not questioning it. It also sounds like Richard was very reasonable about this - giving programmers adequate time to navigate the system (though "adequate" is a relative term... if "a few days" is enough for new devs to have their a-ha moments and fix several bugs, you probably have very high quality code and documentation).
But let's add this as reason #458 why young programmers prefer to start their own companies: their first "assignment" is creating a product, not fixing someone else's crap code.