The first thing to accept is that software development is unpredictable. Regardless of what new, confusing software is being implemented and how many functional points are estimated, experience shows that the creation of target time (and not the achievement of desired quality results) is a success story.
Risks may be caused by loosely-defined requirements, time-consuming software and / or resources for software development, dependency on individual skills, and rapidly changing requirements due to changing needs.
Here are some ideas about how to make the predictability a bit more predictable.
Spend more time defining goals
The objectives of the project are important. The project does not have to be initiated without well-considered goals. Spend time analyzing what you want the project to achieve. The goals of the project should be given to the programmer for each programming task. Name the goals for each programmer to see it.
Here's an example of setting a goal. They were asked to analyze the needs of a busy driver. His manual file system was in use and was never in order. It needed a system that maintains the current details and ensures that the records can always be found. That was simple enough. During the interview, however, the phone ranged continuously with information requests. The ultimate goal was "Eliminating phone calls". This has led to a very successful solution, but it was completely different from the one originally planned.
After defining the objectives of the project, complete the exhaustive analysis of how the objectives are met. This would render unrealistic goals – such as "The Best and the Most Beautiful and Cheapest".
Do not spend too much time collecting requirements
Sturdy analysis stifles the creativity of the programmer and the user. This is no guarantee of software disaster. If documentation of the requirements covers several volumes, it usually guarantees a software disaster.
Users often do not know what they want but will be recognized when they see it. The original requirement is not necessarily what was at all. Instead, spend time creating a solid project framework that will allow you to reach the main goals.
Project breaks into multiple tasks.
Whenever possible, a big project should be split into smaller tasks. Each task is more predictable, less needs to be done, and less that goes wrong.
Initial programming task requires the creation of a minimal functionality framework. Creates dummy procedures to show style and intent – it's important for users to see the "look" of the project at the start of the development cycle. It's equally important for users to take part from the very beginning. Whatever you want, users must start the "property" of the project.
Due to the validity of the project objectives, the basic functions need to be subject to few changes. Dummy procedures can be completed when project concepts and design are approved. Later assignments can add "bells and whistles".
The project must be "infinitely modifiable"
The project should be designed to make significant changes to the requirements. With a definite framework and infinitely modifiable design, users' minds will be minimized. Like the consequences of new or better ideas as the project evolves.
There is a need to think carefully about how to create an "infinitely modifiable" system. This must be done before any programming starts. "Top down", modular design standards help.
The consequences of a rigid system are unpleasant. When the change occurs, it will be very unhappy if the goal needs to be extended. It is equally unpleasant to send programmers to "death" to finish the project timely.
Do Not Use New or Complex Technology
With the help of simple, tested and reliable software you can embark on your head. There is always some benefit to using the latest version of the software – but it can also cost you a lot. If the new technology is essential to the project, proper software testing of the software is needed to provide the right technical knowledge and that all software bugs are closed (have you ever been?).
Preparing for immature software with limited software on the software is a disaster recipe. Renting only the best and most skilled
The success of the software project is primarily dependent on the capabilities of developers. They identify just like any other factor, the reliability of the project, and have a tremendous impact on productivity.
Some tips: The successful candidate must have an enthusiastic sense of humor (see De Bono and Lateral Thinking) and idiomatic English respectability. Excellent communication is all important.
Do not undertake a big project where the best and brightest has left the company recently. The company suffers from "skim milk" syndrome – and needs the cream of the crop for successful development.
It is always helpful to collect a large directory of reusable code. Procedures need to be standardized: error handling, database access, routine editing, grid management, etc. The reusable code reduces the debug time as each procedure can be called multiple. It also reduces the amount of encoding required.
Source by sbobet