한 달에이 아기가 필요 해요
어떤 상황에서 프로그래머를 팀에 추가하면 실제로 이미 늦은 프로젝트의 개발 속도가 빨라 집니까?
정확한 상황은 프로젝트 (예 : 개발 팀, 관리 스타일, 프로세스 성숙도, 주제의 어려움 등)에 매우 분명합니다. 이 문제를 조금 더 잘 설명하기 위해 지나치게 단순화하지 않고 다른 것에 대해 이야기 할 수 있도록 귀하의 질문을 다시 말씀 드리겠습니다.
어떤 상황에서 늦게 실행중인 소프트웨어 개발 프로젝트에 팀 구성원을 추가 할 수있는 경우 기존 팀이 완료 될 때까지 작업 할 수있는 경우와 동일한 품질 수준으로 실제 선적 날짜가 줄어 듭니까?
이것이 발생하기 위해서는 필요 하지만 충분하지 않다고 생각되는 많은 것들이 있습니다 (특별한 순서로).
- 프로젝트에 추가 될 제안 된 개인은 다음을 갖추어야합니다.
- 프로젝트의 문제 영역에 대한 합리적인 이해
- 프로젝트의 언어와 그들이 주어진 작업에 사용할 특정 기술에 능숙해야합니다.
- 그들의 실력은 각각 가장 약하거나 강한 기존 회원보다 훨씬 적거나 크지 않아야합니다. 약한 회원은 기존 직원에게 3 차 문제를 겪게되지만 너무 강한 신입 사원은 팀이 업무를 수행하고 수행하는 방식이 잘못되어 팀을 혼란시킬 것입니다.
- 의사 소통 능력이 뛰어남
- 동기를 부여하십시오 (예 : 자극없이 독립적으로 일할 수 있음)
- 기존 팀 구성원에게는 다음이 있어야합니다.
- 탁월한 의사 소통 능력
- 뛰어난 시간 관리 기술
- 프로젝트 리드 / 관리에는 다음이 있어야합니다.
- 우수한 우선 순위 지정 및 자원 할당 기능
- 기존 팀원의 높은 존중
- 탁월한 의사 소통 능력
- 프로젝트에는 다음이 있어야합니다.
- 훌륭하고 완성되고 문서화 된 소프트웨어 디자인 사양
- 이미 구현 된 것들에 대한 좋은 문서
- 명확한 책임을 제거 할 수있는 모듈 식 설계
- 필요한 결함 수준에 대한 품질 보증을위한 충분한 자동화 프로세스 (단위 테스트, 회귀 테스트, 자동화 된 빌드 배포 등)
- 팀이 현재 사용 중이고 사용중인 버그 / 기능 추적 시스템 (예 : trac, SourceForge, FogBugz 등)
가장 먼저 논의해야 할 사항 중 하나는 배송 날짜 를 늦출 수 있는지, 기능을 삭감 할 수 있는지 여부 및이 두 가지의 조합으로 기존 직원과의 릴리스를 만족시킬 수 있는지 여부입니다. 많은 경우 몇 가지 특징이 투자와 동등한 가치를 제공하지 않는 팀의 자원을 실제로 끌어 들이고 있습니다. 따라서 프로젝트의 우선 순위에 우선적으로 다른 사항을 검토하십시오.
위 단락의 결과가 충분하지 않으면 위 목록을 방문하십시오. 일정 전표를 일찍 잡은 경우 적절한 시간에 적절한 팀 구성원을 추가하면 릴리스가 저장 될 수 있습니다. 불행히도 예상 배송 날짜에 가까워 질수록 사람들을 추가하는 데 더 많은 문제가 발생할 수 있습니다. 어느 시점에서, (현재 개발 지점 배송 이외의) 많은 양의 변경이 릴리스를 저장할 수없는 "반환 지점"을 넘을 것입니다.
나는 계속해서 갈 수 있었지만 주요 포인트를 쳤다고 생각합니다. 프로젝트 외부 및 경력 측면에서 회사의 미래 성공 등 반드시해야 할 일 중 하나는 왜 늦었는지, 조기에 경고를 할 수 있었던 경우, 필요한 조치를 파악하는 것입니다. 앞으로 그것을 막기 위해. 늦은 프로젝트는 대개 다음 중 하나 때문에 발생합니다.
- 시작하기 전에 늦었습니다 (시간보다 더 많은 것들).
- 하루에 1 시간 씩 미끄러졌다.
희망이 도움이됩니다!
리소스 기반 프로젝트가있는 경우에만 도움이됩니다.
예를 들어 다음을 고려하십시오.
4 x 6 미터 크기의 큰 포스터를 페인트해야합니다. 큰 포스터라면 아마 2 ~ 3 명 정도를 앞에두고 평행하게 페인트를 칠할 수 있습니다. 그러나 20 명을 배치하면 작동하지 않습니다. 또한 엉터리 포스터를 원하지 않는 한 숙련 된 인력이 필요합니다.
그러나 프로젝트가 인쇄 된 편지 ( You MIGHT won! 와 같은)로 봉투를 채우는 경우 더 많은 사람을 추가할수록 더 빨리 진행됩니다. 많은 작업을 처리하는 데 약간의 오버 헤드가 있으므로 한 사람이 홍보하는 시점까지 혜택을 얻을 수 없습니다. 봉투에 있지만 2 ~ 3 명 이상의 혜택을 누릴 수 있습니다.
따라서 프로젝트를 작은 덩어리로 쉽게 나눌 수 있고 팀 구성원이 빠른 속도로 (예를 들어 ... 순간적으로) 속도를 낼 수 있다면 더 많은 사람들을 추가하면 더 빠르게 진행할 수 있습니다.
안타깝게도 우리 세상에는 그런 프로젝트가 그리 많지 않기 때문에 신화적인 Man-Month 책에 대한 docgnome의 팁이 정말 좋은 조언입니다.
다음 조건이 적용되는 경우 :
- 새로운 프로그래머는 이미 프로젝트를 이해하고 있으며 램프 업 시간이 필요하지 않습니다.
- 새로운 프로그래머는 이미 개발 환경에 능숙합니다.
- 개발자를 팀에 추가하는 데 관리 시간이 필요하지 않습니다.
- 팀원 간에는 거의 의사 소통이 필요하지 않습니다.
이 모든 것을 한 번에 처음 볼 때 알려 드리겠습니다.
According to the Mythical Man-Month, the main reason adding people to a late project makes it later is the O(n^2) communication overhead.
I've experienced one primary exception to this: if there's only one person on a project, it's almost always doomed. Adding a second one speeds it up almost every time. That's because communication isn't overhead in that case - it's a helpful opportunity to clarify your thoughts and make fewer stupid mistakes.
Also, as you obviously knew when you posted your question, the advice from the Mythical Man-Month only applies to late projects. If your project isn't already late, it is quite possible that adding people won't make it later. Assuming you do it properly, of course.
If the existing programmers are totally incompetent, then adding competent programmers may help.
I can imagine a situation where you had a very modular system, and the existing programmer(s) hadn't even started on a very isolated module. In that case, assigning just that portion of the project to a new programmer might help.
Basically the Mythical Man Month references are correct, except in contrived cases like the one I made up. Mr. Brooks did solid research to demonstrate that after a certain point, the networking and communication costs of adding new programmers to a project will outweigh any benefits you gain from their productivity.
- If the new people focus on testing
- If you can isolate independent features that don't create new dependencies
- If you can orthogonalise some aspects of the project (especially non-coding tasks such as visual design/layout, database tuning/indexing, or server setup/network configuration) so that one person can work on that while the others carry on with application code
- If the people know each other, and the technology, and the business requirements, and the design, well enough to be able to do things with a knowledge of when they'll step on each other's toes and how to avoid doing so (this, of course, is pretty hard to arrange if it isn't already the case)
Only when you have at that late stage some independent (almost 0% interaction with other parts of the project) tasks not tackled yet by anybody and you can bring on the team somebody that is a specialist in that domain. The addition of a team member has to minimize the disruption for the rest of the team.
Rather than adding programmers, one can think about adding administrative help. Anything that will remove distractions, improve focus, or improve motivation can be helpful. This includes both system and administration, as well as more prosaic things like getting lunches.
Obviously every project is different but most development jobs can be assured to have a certain amount of collaboration among developers. Where this is the case my experience has been that fresh resources can actually unintentionally slow down the people they are relying on to bring them up to speed and in some cases this can be your key people (incidentally it's usually 'key' people that would take the time to educate a newb). When they are up to speed, there are no guarantees that their work will fit into established 'rules' or 'work culture' with the rest of the team. So again, it can do more harm than good. So that aside, these are the circumstances where it might be beneficial:
1) The new resource has a tight task which requires a minimum of interaction with other developers and a skill set that's already been demonstrated. (ie. porting existing code to a new platform, externally refactoring a dead module that's currently locked down in the existing code base).
2) The project is managed in such a way that other more senior team members time can be shared to assist bringing the newb up to speed and mentoring them along the way to ensure their work is compatible with what's already been done.
3) The other team members are very patient.
I suppose the adding people toward the end of the work could speed things up if:
The work can be done in parallel.
The amount saved by added resources is more than the amount of time lost by having the people experienced with the project explain things to those that are inexperienced.
EDIT: I forgot to mention, this kind of thing doesn't happen all too often. Usually it is fairly straight forward stuff, like admin screens that do simple CRUD to a table. These days these types of tools can be mostly autogenerated anyway.
Be careful of managers that bank on this kind of work to hand off though. It sounds great, but it in reality there usually isn't enough of it trim any significant time off of the project.
- Self-contained modules that have yet to be started
- Lacking development tools they can integrate (like an automated build manager)
Primarily I'm thinking of things that let them stay out of the currently developing people's way. I do agree with Mythical Man-Month, but I also think there are exceptions to everything.
I think adding people to a team may speed up a project more than adding them to the project itself.
I often run into the problem of having too many concurrent projects. Any one of those projects could be completed faster if I could focus on that project alone. By adding team members, I could transition off other projects.
Of course, this assumes that you've hired capable, self-motivated developers, who are able to inherit large projects and learn independently. :-)
If the extra resource complement your existing team it can be ideal. For example, if you are about to set up your production hardware and verify that the database is actually tuned as opposed to just returning good results (that your team knows as domain experts) borrowing time from a good dba who works on the the project next to yours can speed the team up without much training cost
Simply put. It comes down to comparing the time left and productivity you will get from someone excluding the amount of time it takes the additional resources to come up to speed and be productive and subtracting the time invested in teaching them by existing resources. The key factors (in order of significance):
- How good the resource is at picking it up. The best developers can walk onto a new site and be productive fixing bugs almost instantly with little assistance. This skill is rare but can be learnt.
- The segregability of tasks. They need to be able to work on objects and functions without tripping over the existing developers and slowing them down.
- The complexity of the project and documentation available. If it's a vanilla best practice ASP.Net application and common well-documented business scenarios then a good developer can just get stuck in straight away. This factor more than any will determine how much time the existing resources will have to invest in teaching and therefore the initial negative impact of the new resources.
- The amount of time left. This is often mis-estimated too. Frequently the logic will be we only have x weeks left and it will take x+1 weeks to get someone up to speed. In reality the project IS going to slip and does in fact have 2x weeks of dev left to go and getting more resources on sooner rather than later will help.
Where a team is already used to pair programming, then adding another developer who is already skilled at pairing may not slow the project down, particularly if development is proceeding with a TDD style.
The new developer will slowly become more productive as they understand the code base more, and any misunderstandings will be caught very early either by their pair, or by the test suite that is run before every check-in (and there should ideally be a check in at least every ten minutes).
However, the effects of the extra communication overheads need to be taken into account. It is important not to dilute the existing knowledge of the project too much.
Adding developers makes sense when the productivity contributed by the additional developers exceeds the productivity lost to training and managing those developers.
참고URL : https://stackoverflow.com/questions/76526/i-need-this-baby-in-a-month-send-me-nine-women