Selection of an Appropriate

Project Approach
Faculty: Dr. Muhammad Naveed
Introduction
• The development of software in-house usually means that
• The developers and the users belong to the same organization
• The application will slot into a portfolio of existing computer-based systems
• The methodologies and technologies are largely dictated by organizational
standards and policies, including the existing enterprise architecture.
• The decision making process has been called technical planning, or
project analysis or methods engineering and methods tailoring.
• This may count as the 3rd step of Step-wise project planning approach
as analyze project characteristics.
 ‘Step Wise’ - an overview
0.Select
1. Identify project 2. Identify project
project objectives infrastructure

3. Analyse
project
characteristics
Review
4. Identify products
and activities

5. Estimate effort
Lower for activity For each
level activity
detail 6. Identify activity
risks
10. Lower level
7. Allocate
planning
resources

8. Review/ publicize
9. Execute plan plan
3
Build or Buy?
• Software development
• Developers
• Clients or Users
• In-house development
• Developers and users are in the same organization
• Outsourced development
• Developers and users are in different organizations
• Different organization could be different continents
• Recruitment of technical staff
• Once the project has been completed, will no longer be required
• Contracting the project out to an external IT development company would be a
better option
Build or Buy? cont..
• Whether in-house or outsourced, software development is still involved.
• Advantages of outsourced development
• Large number of customers, reduced cost per customer
• The software already exist, so
• It can be examined and even trailed before acquisition
• No delay as software already developed
• Most of the bugs already removed as reported by several customers
• More reliable software
• Disadvantages of outsourced development
• Same application as everyone else, there is no competitive advantage
• Although flexibility there but is limited, so have to change the office procedures
• You will not own the software code
• You may be charged extra inflated cost since you have been captive customer
Choosing Methodologies and Technologies
• The term methodology describes a collection of methods.
• Methods
• A general way of carrying out a specific task that could be applicable to any project
needing to do that task
• Methods often involve the creation of models like ERD, Unified Software Development
Process (USDP), Structured Systems Analysis and Design methods (SSADM) and
Human-Centered Design
• Technologies
• Involve the application of scientific, mathematical or logical principles to resolve a
particular kind of problem
• Include appropriate application building and automated testing environments
• Project analysis should select the most appropriate methodologies and
technologies for a project
Identify project as either objective-driven or
product-driven
Objective-Driven Projects:
Pros:
1.Clarity of Purpose: Objectives provide a clear direction for the project team,
ensuring everyone is aligned on what needs to be achieved.
2.Flexibility: Teams can adapt their approach and methods as long as they are
moving towards the defined objectives, allowing for creative problem-solving
and innovation.
3.Measurable Results: Objectives are typically quantifiable, making it easier to
track progress and evaluate the success of the project.
4.Stakeholder Alignment: Clear objectives help stakeholders understand the
project's purpose and expectations, leading to better support and collaboration.
Identify project as either objective-driven or
product-driven
Objective-Driven Projects:
Cons:
1.Narrow Focus: Objectives may limit exploration of alternative solutions or
opportunities that could add value but are not directly tied to the defined
goals.
2.Rigidity: In some cases, strict adherence to objectives may stifle creativity
and prevent teams from responding effectively to changing circumstances.
3.Risk of Tunnel Vision: Team members may become overly focused on
achieving the objectives, potentially overlooking broader strategic
considerations or unintended consequences.
Identify project as either objective-driven or
product-driven
Product-Driven Projects:
Pros:
1.Customer Focus: Product-driven projects prioritize meeting customer needs and
delivering value through the product, leading to increased customer satisfaction
and loyalty.
2.Iterative Improvement: Continuous product development and iteration allow for
ongoing improvements based on user feedback and market trends.
3.Innovation: Emphasis on the product encourages teams to explore new ideas,
features, and technologies that can differentiate the product in the market.
4.Long-Term Vision: Product-driven projects often align with long-term strategic
goals, fostering sustainability and growth.
Identify project as either objective-driven or
product-driven
Product-Driven Projects:
1.Ambiguity: Without clear objectives, teams may struggle to prioritize tasks,
make decisions, or measure success effectively.
2.Scope Creep: Continuous product development can lead to scope creep, where
the project expands beyond its initial boundaries, increasing complexity and risk.
3.Resource Allocation: Balancing ongoing product improvements with new
initiatives or projects can be challenging, requiring careful resource allocation
and prioritization.
4.Stakeholder Expectations: Managing stakeholder expectations can be more
complex in product-driven projects, as priorities and features may evolve over
time based on feedback and market dynamics.
Identify high level project risks

Product Uncertainty
• Definition: Product uncertainty refers to uncertainties related to the
software product being developed, including requirements,
functionalities, and user expectations.
• Example: Developing a mobile app where the target audience's
preferences and usage patterns are not well understood, leading to
uncertainty about feature prioritization and design decisions.
Identify high level project risks
Process Uncertainty
• Definition: Process uncertainty involves uncertainties related to the
development process, methodologies, tools, and team dynamics.
• Example: Adopting a new agile development methodology for a
project without prior experience, resulting in uncertainty about the
team's ability to effectively implement and adapt to the new approach.
Identify high level project risks
Resource Uncertainty
• Definition: Resource uncertainty encompasses uncertainties related to
resource availability, skills, capacity, and dependencies.
• Example: Depending on a critical external vendor for a key
component of the software, leading to uncertainty about delivery
timelines and potential risks if the vendor fails to meet expectations.
Mitigating risks
Mitigating Product Uncertainty
• Strategies: Conduct user research, gather feedback through prototypes,
prioritize features based on data and user needs.
• Example: Running usability tests and gathering feedback from beta
testers to validate design choices and prioritize features effectively.
Mitigating risks
Mitigating Process Uncertainty
• Strategies: Provide training and support for new methodologies,
establish clear communication channels, conduct regular
retrospectives for process improvement.
• Example: Investing in agile coaching and training for the team to
ensure a smooth transition to agile practices and continuous
improvement throughout the project.
Mitigating risks
Mitigating Resource Uncertainty
• Strategies: Diversify resources, build contingency plans, establish
clear roles and responsibilities, monitor and manage dependencies
proactively.
• Example: Identifying backup vendors or alternative solutions for
critical dependencies, maintaining a skilled and adaptable team to
mitigate resource risks.
Software Process and Process Model
Software Process Overview
• Definition: A software process is a set of activities, methods, and tools
used to develop and maintain software products.
• Key Components: Planning, requirements analysis, design,
implementation, testing, deployment, maintenance.
• Importance: Ensures systematic and organized development, enhances
quality, facilitates collaboration.
Software Process and Process Model
Characteristics of Software Processes
• Iterative and Incremental: Development occurs in cycles, with
feedback and improvements incorporated iteratively.
• Tailorable: Processes can be customized based on project needs, team
capabilities, and project complexity.
• Risk-Driven: Emphasizes identifying and managing risks throughout
the development lifecycle.
• Measurable: Metrics and measurements are used to assess progress,
quality, and performance.
Software Process and Process Model
Common Software Process Models
• Waterfall Model: Sequential phases (requirements, design, implementation,
testing, deployment) with linear progression.
• Agile Model: Iterative and collaborative approach, emphasizing flexibility,
adaptability, and continuous improvement.
• Spiral Model: Iterative with risk analysis and prototyping, suitable for large,
complex projects with evolving requirements.
• V-Model: Corresponds testing phases to development phases, ensuring
comprehensive testing at each stage.
• Incremental Model: Divides project into smaller increments, delivering
functionality incrementally.
Software Process and Process Model
Waterfall Model
• Overview: Sequential phases with linear progression from
requirements to deployment.
• Pros: Simple and easy to understand, well-suited for small, well-
defined projects with stable requirements.
• Cons: Limited flexibility, late feedback incorporation, potential for
high risk in complex or evolving projects.
Software Process and Process Model
Agile Model
• Overview: Iterative, collaborative approach focusing on delivering
working software in short iterations (sprints).
• Pros: Flexibility, adaptability to changing requirements, early and
continuous customer feedback, promotes teamwork.
• Cons: Requires experienced team and customer involvement,
challenges with documentation and scalability in large projects.
Agile Model Example:
Mobile Banking Application Development

• Project Kickoff and Initial Planning

1. Establish Product Backlog:
1. User Stories: Define high-level requirements as user stories. For example:
1. As a user, I want to log in securely.
2. As a user, I want to view my account balance.
3. As a user, I want to transfer money to another account.
2. Prioritize User Stories: Work with stakeholders to prioritize the user stories
based on business value and urgency.
2. Sprint Planning:
1. Sprint Duration: Decide on a sprint duration, typically 2-4 weeks.
2. Select User Stories for Sprint: Choose the top-priority user stories to be
completed in the first sprint.
Agile Model Example:
Mobile Banking Application Development
Sprint 1: Basic Functionality
1. Planning Meeting:
1. Break down selected user stories into tasks.
2. Assign tasks to team members.
2. Development:
1. Tasks: Implement login functionality, set up the user interface, create a basic backend structure.
2. Daily Standups: Short daily meetings to discuss progress, impediments, and plans.
3. Testing:
1. Conduct unit tests and integration tests for the implemented features.
4. Review and Demo:
1. Present the completed features to stakeholders.
2. Gather feedback and note any changes or new requirements.
5. Retrospective:
1. Reflect on what went well, what didn’t, and how to improve in the next sprint.
Agile Model Example:
Mobile Banking Application Development
Sprint 2: Account Management
1.Sprint Planning:
1. Review feedback from Sprint 1.
2. Select the next set of user stories, e.g., view account balance and transaction history.
2.Development:
1. Tasks: Implement account summary page, integrate with backend to fetch account details, design
transaction history interface.
2. Daily Standups: Continue with daily updates.
3.Testing:
1. Perform unit tests, integration tests, and user acceptance testing (UAT) for new features.
2. Regression testing to ensure new changes do not affect existing functionality.
4.Review and Demo:
1. Demonstrate the new features.
2. Collect feedback and adjust the product backlog as necessary.
5.Retrospective:
1. Discuss improvements and plan actions for future sprints.
Agile Model Example:
Mobile Banking Application Development
Sprint 3: Money Transfer Feature
1.Sprint Planning:
1. Based on priority and feedback, choose the money transfer feature and any refinements from previous
sprints.
2.Development:
1. Tasks: Implement transfer money functionality, secure the transaction process, create transfer
confirmation and error handling.
2. Daily Standups: Ensure continuous communication and progress tracking.
3.Testing:
1. Comprehensive testing including security testing for the transfer feature.
2. UAT to ensure the feature meets user expectations.
4.Review and Demo:
1. Showcase the money transfer feature.
2. Get feedback and note any enhancements or issues.
5.Retrospective:
1. Evaluate the sprint’s successes and challenges.
2. Plan improvements for the next sprint.
Agile Model Example:
Mobile Banking Application Development
Ongoing Process
• This iterative process continues with each sprint focusing on delivering
incremental value through new features, refinements, and enhancements. The
Agile approach ensures:
• Flexibility: Easily adapt to changing requirements and feedback.
• Customer Collaboration: Regular interaction with stakeholders ensures the
product meets user needs.
• Incremental Delivery: Each sprint delivers a potentially shippable product
increment.
• Continuous Improvement: Retrospectives ensure ongoing process
improvement.
Agile Model Example:
Mobile Banking Application Development
Benefits of Using the Agile Model
• Customer Satisfaction: Regular updates and iterations keep
stakeholders engaged and satisfied.
• Adaptability: Quickly respond to changes in requirements and market
conditions.
• Quality Improvement: Continuous testing and integration improve
the overall quality of the product.
• Team Collaboration: Daily standups and retrospectives enhance team
communication and collaboration.
Software Process and Process Model
Spiral Model
• Overview: Iterative with risk analysis and prototyping, suitable for
projects with evolving requirements and high risks.
• Pros: Risk-driven development, early identification and mitigation of
risks, flexibility in accommodating changes.
• Cons: Complex management, time-consuming, resource-intensive, not
suitable for small projects with stable requirements.
Spiral Model Example:
E-commerce Website Development
1. Identification of Objectives, Alternatives, and Constraints
• Objective: Develop a feature-rich, user-friendly e-commerce
platform.
• Alternatives: Custom development vs. using a platform like Shopify
or Magento.
• Constraints: Budget, time, technology stack, security requirements,
scalability.
Spiral Model Example:
E-commerce Website Development
2. Risk Analysis and Prototyping
• Risks Identified:
• Unclear requirements from stakeholders.
• Potential security vulnerabilities.
• Integration with payment gateways.
• Prototyping:
• Create a basic prototype focusing on the user interface and core
functionalities like product listing, cart, and checkout process.
• Evaluation of Prototype:
• Gather feedback from stakeholders and potential users to refine requirements.
Spiral Model Example:
E-commerce Website Development
3. Planning the Next Iteration
• Plan: Based on feedback, plan the next iteration to include more
detailed design and additional features such as user authentication,
product search, and admin panel.
Spiral Model Example:
E-commerce Website Development
4. Engineering and Production
• Detailed Design and Implementation:
• Develop detailed design documents.
• Code the new features, ensuring integration with the existing prototype.
• Testing:
• Perform unit tests, integration tests, and user acceptance testing (UAT).
• Review and Validate:
• Review the developed features with stakeholders.
• Validate against requirements and make necessary adjustments.
Spiral Model Example:
E-commerce Website Development
Second Iteration
1. Identification of Objectives, Alternatives, and Constraints
• Objective: Enhance the e-commerce platform with advanced features
and improve performance.
• Alternatives: Optimize current implementation vs. adding third-party
solutions for features like search optimization.
• Constraints: More specific budget and timeline, user feedback.
Spiral Model Example:
E-commerce Website Development
2. Risk Analysis and Prototyping
• Risks Identified:
• Performance bottlenecks due to increased traffic.
• Complex integration with third-party services.
• Prototyping:
• Prototype the advanced search functionality and performance enhancements.
• Evaluation of Prototype:
• Collect feedback on the new features and assess performance improvements.
Spiral Model Example:
E-commerce Website Development
3. Planning the Next Iteration
• Plan: Incorporate feedback and plan for full-scale integration of
advanced features, along with robust performance testing and security
audits.
Spiral Model Example:
E-commerce Website Development
4. Engineering and Production
• Implementation:
• Complete the integration of advanced search and other features.
• Optimize the backend for better performance.
• Testing:
• Perform comprehensive testing, including load testing and security testing.
• Review and Validate:
• Review with stakeholders, conduct another round of UAT, and validate the
system.
Spiral Model Example:
E-commerce Website Development
• Further Iterations
• This process continues, with each spiral involving more detailed
planning, risk analysis, and development of increasingly complex and
feature-rich iterations of the system. Over time, the project progresses
from a basic prototype to a fully functional and optimized e-commerce
platform, addressing risks and refining the system at each stage.
Spiral Model Example:
E-commerce Website Development
• Benefits of Using the Spiral Model
• Risk Management: Continuous risk analysis and mitigation.
• Flexibility: Adaptable to changes in requirements and feedback.
• Incremental Development: Allows for progressive refinement and
validation.
• User Involvement: Frequent stakeholder reviews ensure alignment
with user needs and expectations.
Extreme Programming
• Extreme Programming (XP) is a software development methodology
that is part of the Agile movement.

• It emphasizes customer satisfaction, continuous delivery of valuable

software, and the ability to adapt to changing requirements.

• XP incorporates a set of best practices intended to improve software

quality and responsiveness to changing customer requirements.
Extreme Programming
Core Principles
1.Communication: Continuous and clear communication among team
members and stakeholders is essential. This is facilitated through practices
like pair programming and daily standups.
2.Simplicity: The simplest solution that works is chosen. This means avoiding
overengineering and focusing on delivering the most essential features first.
3.Feedback: Rapid and continuous feedback is sought from customers, team
members, and the software itself (through testing).
4.Courage: Team members should have the courage to make necessary
changes, discard failing practices, and improve the codebase by refactoring.
5.Respect: Mutual respect among team members is crucial for a collaborative
and effective working environment.
Extreme Programming
Key Practices
1. Test-Driven Development (TDD): Write tests before writing the corresponding code to ensure
that the software meets its requirements. This practice leads to better-designed, more reliable, and
maintainable code.
2. Pair Programming: Two developers work together at one workstation. One writes the code (the
driver), while the other reviews each line of code as it is written (the observer or navigator). This
practice improves code quality and knowledge sharing.
3. Continuous Integration (CI): Code changes are integrated into the main codebase frequently,
usually multiple times a day. Automated tests are run to catch integration issues early.
4. Refactoring: Continuously improve the design of existing code without changing its functionality.
This practice helps keep the codebase clean and maintainable.
5. Small Releases: Develop software in small, frequent releases. This allows for quicker feedback
and the ability to adapt to changes in requirements.
6. Collective Code Ownership: All code is owned collectively by the team, and any team member
can make changes. This practice enhances collaboration and code quality.
Extreme Programming
Key Practices (cont..)
6. Coding Standards: Adhere to a consistent style and standard for writing code. This
makes the code more readable and maintainable.
7. Sustainable Pace: Maintain a pace that can be sustained indefinitely. Avoid
overtime and burnout by working at a manageable pace.
8. Metaphor: Use a common metaphor to describe the system and guide development,
ensuring a shared understanding among team members.
9. On-Site Customer: Have a real customer (or a customer representative) on-site to
provide continuous feedback and clarification on requirements.
10. Planning Game: Plan iterations collaboratively with the customer, prioritizing user
stories based on business value and technical estimates.
11. Simple Design: Design the system as simply as possible at any given moment.
Extra functionality and features should not be added until absolutely necessary.
Scrum
• Scrum is a framework for managing and completing complex projects,
particularly in the field of software development.
• It is a subset of Agile methodologies and focuses on iterative progress,
team collaboration, and delivering functional increments of the
product within short, time-boxed periods called sprints.
Key Components of Scrum
1.Roles:
1. Product Owner: Responsible for defining the features of the product and
prioritizing them in the product backlog. The product owner ensures that the
team is working on the most valuable tasks.
2. Scrum Master: Facilitates the Scrum process and helps remove impediments
that hinder the team's progress. The Scrum Master also ensures that Scrum
practices are followed.
3. Development Team: A cross-functional group of professionals who work
together to deliver the product increments. The team is self-organizing and
decides how best to accomplish the work.
Key Components of Scrum
• Artifacts:
• Product Backlog: A prioritized list of features, enhancements, and fixes that
need to be developed for the product. It is continuously updated by the
product owner.
• Sprint Backlog: A subset of the product backlog items selected for
development in the current sprint, along with a plan for delivering the
product increment.
• Increment: The sum of all the product backlog items completed during a
sprint and all previous sprints. The increment must be in a usable condition
and meet the Scrum team's definition of "Done".
Key Components of Scrum
Events:
1. Sprint: A time-boxed period (usually 2-4 weeks) during which a usable and
potentially releasable product increment is created. Sprints are of consistent
length throughout a project.
2. Sprint Planning: A meeting at the beginning of each sprint where the team
selects product backlog items to work on and creates a plan to deliver them.
3. Daily Scrum: A short, time-boxed (15 minutes) daily meeting for the
development team to synchronize activities and create a plan for the next 24
hours.
4. Sprint Review: A meeting held at the end of the sprint to inspect the increment
and adapt the product backlog if needed. The development team demonstrates the
work done during the sprint.
5. Sprint Retrospective: A meeting for the Scrum team to reflect on the sprint that
has just ended and identify ways to improve processes and collaboration for the
next sprint.
Principles of Scrum
• Empirical Process Control: Scrum relies on transparency, inspection,
and adaptation to optimize predictability and control risk.
• Collaboration: Effective collaboration between the product owner,
Scrum Master, and development team is crucial for success.
• Value-Based Prioritization: The product owner prioritizes work
based on the value it delivers to the customer or business.
• Time-Boxing: All events in Scrum are time-boxed to encourage focus
and efficiency.
• Iterative Development: Development happens in iterations (sprints),
allowing for regular feedback and continuous improvement.