The fact that you consider training a waste is depressing. Good senior developers recognize that training is critically important unless they want to do everything personally – and it's extremely rare that you don't learn something, too. If it's a waste of time, you're doing it wrong - a truly senior developer would learn from that and fix something.
As the employer-employee loyalty culture has been systematically destroyed, I am far more likely to see the training of more junior developers as training my own replacement than as improving the capabilities of my team.
If you want me to train someone in anything, you really ought to make me feel secure in my position, such as by offering me some form of job security. For the sake of discussion, let's just call that "tenure". If I am an "at will" employee, the only form of job security at my disposal is to be indispensable, and training others undermines that.
So if your company has a clear career path, with employees from entry-level tenderfoot to ultra-senior guru, and every step in between, you might feel good about training. If, on the other hand, your office is full of young bros, and the dusties are encouraged to move out to pasture when it's time, your time is coming.
If a company truly has a commitment to training, a necessary prerequisite is a commitment to long-term employee retention.
There is very little inherent to pair programming in itself that can be considered good or bad in isolation from the people using it. Good teams follow good practices. This is not because the practices are good, but because the team finds them to be temporarily useful to meet their specific needs.
If your manager went to a conference, learned about agile stuff, and returned to institute pair programming, you will likely find that to be of dubious value. If your team decides internally that the new hire should do pair programming with each of the existing team members until the greenness fades, that will probably have a better outcome.
I'm all for training. I'm against 8-hour a day, 5-day a week pair programming. Even if training is so important, developers are not signing up to be a professional trainer.
(2) The only relation anything "Agile" has to do with manufacturing is that the Agile approach to software is close parallels to Lean methodologies in manufacturing (which have circled around to create Lean software methodologies.) But Lean, while it is an approach to improving productivity, is pretty much the opposite of doing so at the expense of the creativity of the line workers, as they rest on the combination of defining and measuring value and harnessing the deep knowledge of the workforce to propose, implement, and test methods of improving value produced.
I've actually been on a team that did this. "For the next two-week iteration, we're going to change the process in this way, and we'll see how that works."
Process doesn't have to be a static thing handed down from on high. Hack it. Make it work for you. (One of the agile approaches to software is "pay attention to pain". That is, when it's hard to change the software in some way, that's telling you that it should be refactored so that it quits being hard to change it in that way. Well, the same thing works for process. If the process is painful, pay attention. It's telling you that you need to change the process.)
Yes, that's exactly what Lean in software means (and you'll note that it has a very close relation to Agile principles -- Lean is pretty much Agile with more focus on measurable output and several decades more of development behind it -- both for the good and the bad [there's a lot of depth in the literature of practices and how and when they work to draw from for your circumstances, but there's also breadth and depth in the buzzword snake-oil].)
Practices like continuous integration and unit testing traditionally fell into that category. I would say these days that writing unit tests is so common that it doesn't feel like it came from anywhere. Just that it always existed.
The ossification of Agile into a set of cargo cult practices divorced from the particular teams and their needs flips Agile into exactly what it was a reaction against.
In my experience the main thing to keep in mind to improving any system is to:
1. See what state you are in 2. Figure out what new state you would like to be in 3. Guess at something that will help you move into that state and then follow that guess. 4. See if that move helped you get closer to that state 5. goto 1
People label those steps with lots of names depending on what industry they work in but in the end that is the easiest way to get better.
I disagree. That's not how you build a team. Also, senior developers who can't pair program, aren't senior developers. That means you can't communicate, or at least you don't want to, even if it's talking about code you don't want to. That's not how you become a lead/architect.
Ah yes, the cliched "if you don't do X you can't call yourself Y" shtick. I know many senior developers that don't pair program. Why? It's inefficient and they get significantly less done. Not to mention, you have no room to experiment with different approaches because you've got some person sitting next to you and human emotion kicks in and they feel like they're being watched and judged at every move.
You know when pair programming is endorsed by the senior developers? Root-causing bugs.
I can communicate very well, and am helpful as I can be when people need it. But slow-as-molasses pair programming with an 8nexperienced junior sounds like hell to me.
One can be an effective leader, communicates well, designs and architects large system, mentors junior developers, inspires them to learn, coordinates development effort, sets up development processes and standards, and develops awesome software without doing pair programming.
Pair programming is not the only and true way to develop software. It's just some passé imposed by Agile advocates.
The daily meetings usually turn into daily status meetings, no matter how much the Agile advocates claim otherwise. The rough estimate become a hard deadline, with daily remainder of why it's slipping. Pair programming - free training for junior developers, a waste of time for senior developers.