Software Project

Management
UNIT – I
Dr.A.Pathanjali Sastri
Professor, Dean Adademics & QA
The old way and the New
The Principles of Conventional
Software Engineering
1. Make quality #1
Quality must be quantified and mechanism put into place to motivate its achievement.
2. High-quality software is possible
Techniques that have been demonstrated to increase quality include involving the customer,
prototyping, simplifying design, conducting inspections, and hiring the best people.
3. Give products to customers early
No matter how hard you try to learn users’ needs during the requirements phase, the most
effective way to determine real needs is to give users a product and let them play with it.
4. Determine the problem before writing the requirements
When faced with what they believe is a problem, most engineers rush to offer a solution. Before
you try to solve a problem, be sure to explore all the alternatives and don’t be blinded by the
obvious solution.
5. Evaluate design alternatives
After the requirements are agreed upon, you must examine a variety of architectures and
algorithms.
The Principles of Conventional
Software Engineering
6. Use an appropriate process model.
Each project must select a process that makes the most sense for that project on the basis of
corporate culture, willingness to take risks, application area, volatility of requirements, and the
extent to which requirements are well understood.
7. Use different languages for different phases.
Use recommended languages/notations for the primitive artifacts of the process.
8. Minimize intellectual distance.
To minimize intellectual distance, the software’s structure should be as close as possible to the real-
world structure.
9. Put techniques before tools.
A disciplined software engineer with good tools will outproduce disciplined software experts with
no tools.
10. Get it right before you make it faster.
It is far easier to make a working program run than it is to make a fast program work. Don’t worry
about optimization during initial coding.
The Principles of Conventional
Software Engineering
11. Inspect code.
Inspecting the detailed design and code is a much better way to find errors than testing.
12. Good management is more important than good technology.
• The best technology will not compensate for poor management, and a good manager can produce great results
even with meager resources.
• Good management motivates people to do their best, but there are no universal “right” styles of management.
13. People are the key to success.
• Highly skilled people with appropriate experience, talent, and training are key.
• The right people with insufficient tools, languages, and process will succeed.
• The wrong people with appropriate tools, languages, and process will probably fail.
14. Follow with care.
• Just because everybody is doing something does not make it right for you, but you must carefully assess its
applicability to your environment.
• Object orientation, measurement, reuse, process improvement, CASE, prototyping-all these might increase
quality, decrease cost, and increase user satisfaction.
15. Take responsibility.
• The fact is that in any engineering discipline, the best methods can be used to produce awful designs, and the
most antiquated methods to produce elegant design.
The Principles of Conventional
Software Engineering
16. Understand the customer’s priorities.
It is possible the customer would tolerate 90% of the functionality delivered late if they could have
10% of it on time.
17. The more they see, the more they need.
The more functionality (or performance) you provide a user, the more functionality (or
performance) the user wants.
18. Plan to throw one away .
• One of the most important critical success factors is whether or not a product is entirely new.
• Such brand-new applications, architectures, interfaces, or algorithms rarely work the first time.
19. Design for change.
The architectures, components, and specification techniques you use must accommodate change.
20. Design without documentation is not design.
All that is left is the documentation.
The Principles of Conventional
Software Engineering
21. Use tools, but be realistic.
Software tools make their users more efficient.
22. Avoid tricks.
• Many programmers love to create programs with tricks- constructs that perform a function correctly,
but in an obscure way.
• Show the world how smart you are by avoiding tricky code.
23.Encapsulate.
Information-hiding is a simple, proven concept that results in software that is easier to test and much
easier to maintain.
24.Use coupling and cohesion.
Coupling and cohesion are the best ways to measure software’s inherent maintainability and
adaptability.
25.Use the McCabe complexity measure.
Although there are many metrics available to report the inherent complexity of software, none is as
intuitive and easy to use as Tom McCabe’s.
The Principles of Conventional
Software Engineering
26. Don’t test your own software.
Software developers should never be the primary testers of their own software.
27. Analyze causes for errors.
a) It is far more cost-effective to reduce the effect of an error by preventing it than it is to find and fix
it.
b) One way to do this is to analyze the causes of errors as they are detected.
28.Realize that software’s entropy increases.
Any software system that undergoes continuous change will grow in complexity and become more
and more disorganized.
29.People and time are not interchangeable.
Measuring a project solely by person-months makes little sense.
30.Expert excellence.
Your employees will do much better if you have high expectations for them.
The Principles of Modern Software
Management
• There are some modern principles for the development of software.
• By following these modern principles we can develop an efficacious
software meeting all the needs of customer.
• To develop a proper software one should follow the following 10
Principles of software development:
The Principles of Modern Software
Management
The Principles of Modern Software
Management
• Architecture first approach:
• The architecture-first approach emphasizes the significance of devising a
robust architecture early in the development cycle.
• Developers can mitigate ambiguities, enhance decision-making, and optimize
the overall productivity of the project
• Iterative life cycle process:
• By continuously iterating through the development cycle, software projects
become more adaptable to evolving requirements and changes in the
development landscape.
• Major risks must be addressed early to increase predictability and avoid
expensive downstream scrap and rework.
The Principles of Modern Software
Management
• Component Based Approach:
• The component-based approach capitalizes on the reuse of pre-defined
functions and code components.
• This approach not only accelerates development but also ensures consistency,
reduces errors, and promotes maintainability.
• Change Management system:
• A robust change management system facilitates controlled and systematic
handling of changes.
• Such a system ensures that the software remains adaptable to dynamic
requirements and minimizes disruptions caused by changes.
The Principles of Modern Software
Management
• Round Trip Engineering:
• Round-trip engineering is the environment support necessary to automate and
synchronize engineering information in different formats (such as requirements
specifications, design models, source code, executable code, test cases).
• Round trip engineering integrates code generation and reverse engineering in a
dynamic environment.
• Automatic updates of artifacts enhance collaboration, reduce errors, and contribute
to the overall efficiency of the development process.
• Model Based Evolution:
• In model-based evolution, software development relies on graphical and textual
representations to adapt to changing requirements.
• Models provide a conceptual framework for understanding the software’s
architecture and behavior.
The Principles of Modern Software
Management
• Objective Quality Control:
• The objective quality control principle emphasizes defining and adhering to
quality metrics, checklists, and improvement measures.
• By consistently monitoring and improving quality, software projects can
minimize defects, enhance user satisfaction, and ensure that the final product
meets established standards.
• Evolving levels of details:
• This principle promotes incremental refinement of use cases, architecture, and
design details.
• By breaking down the development process into manageable stages, teams can
adapt to changes and enhance the software’s flexibility and responsiveness to
user needs.
The Principles of Modern Software
Management
• Establish a configurable process:
• One single process is not suitable for all the development so we must use a
configurable process which can deal with various applications.
• A way of tailoring the process to the needs of each particular project
• Demonstration Based approach:
• The demonstration-based approach involves showcasing working software
(Prototype) to stakeholders.
• Demonstrations offer a clear representation of the problem domain,
approaches used, and proposed solutions.
• This approach fosters engagement, encourages feedback, and enhances
productivity and quality.
The Principles of Modern Software
Management
The Principles of Modern Software
Management
• The following table maps top 10 risks of the conventional process to
the key attributes and principles of a modern process
Transitioning to an Iterative Process
• Modern Software Development has moved far away from
Conventional waterfall model.
• Consider the process exponent parameters of the COCOMO II model
for economic impact of process improvement.
• The parameters that govern the value of the process exponent are:
• Application precedentedness,
• Process flexibility
• Architecture risk resolution
• Team cohesion and
• Software process maturity.
Transitioning to an Iterative Process
• Application precedentedness:
• In life cycle, early iterations generally establish or develop precedents from which
product, process, and plans can be explained and elaborated in evolving levels detail.
• Process flexibility:
• Both a rigid process and a unsystematically changing process are destined for failure of
projects.
• A configurable process that allows a common framework to be adapted across a range
of projects is necessary to achieve a software return on investment.
• Architecture risk resolution:
• An architecture-first and component-based development approach forces the
infrastructure, common mechanisms, and control mechanisms to be elaborated early in
the life cycle and drives all component make/buy decisions into the architecture process.
Transitioning to an Iterative Process
• Team cohesion:
• Successful teams and cohesive teams share common objectives and priorities.
• Software process maturity:
• The Software Engineering Institute's Capability Maturity Model (CMM) is a
well-accepted benchmark for software process assessment.
• A highly mature process is allowed through an integrated environment that
generally provides appropriate and correct level of automation to instrument
process for control of objective quality.