UNIT 3: SOFTWARE PROJECT MANAGEMENT FOR RURAL TECHNOLOGY

(Short Notes for RGPV CS-604 - Based on "B PROJECT MANAGEMENT" Past Papers)

1. SOFTWARE ECONOMICS

Definition: Study of cost, value, and economic trade-offs in software development, deployment, and maintenance.

Evolution Over Time:

Strategies for Enhancement:

• Reuse: Utilize components, frameworks, open-source.

• COTS (Commercial Off-The-Shelf): Buy vs. build.

• Automation: Reduce manual effort in testing, deployment.

• Early ROI Focus: Deliver minimal viable product (MVP) quickly.

• Rural Context: Leverage low-cost, robust tech; shared community infrastructure.

Important Trends:

• Shift from cost-per-line-of-code to value-per-user-story.

• DevOps reduces cycle time and operational costs.

• Cloud economics (pay-as-you-go) suits sporadic rural usage.

• Open-source adoption lowers licensing costs.

Cost Estimating & Budgeting Improvement:

• Models: Use COCOMO (Constructive Cost Model) or Function Point Analysis.

• Improvement: Historical data calibration, expert judgment, parametric tools.

• Budgeting: Contingency reserves (10-20%), phased funding.

Assessing Economic Impact:

• Metrics: NPV (Net Present Value), ROI, Payback Period, TCO (Total Cost of Ownership).

• Rural Impact: Include social return on investment (SROI), reduced migration, improved livelihoods.

[!TIP] Exam often asks for COCOMO formula:

$$E = a \times (KLOC)^b \times EAF$$

Where $E$ = effort (person-months), $KLOC$ = size, $EAF$ = effort adjustment factor.

2. MODERN SOFTWARE MANAGEMENT PRINCIPLES

Core Principles:

1. Agility & Iteration: Respond to change over following a plan.

2. Value-Driven Delivery: Prioritize features by business/user value.

3. Empowered Teams: Self-organizing, cross-functional teams.

4. Continuous Improvement: Retrospectives, metric feedback.

5. Risk-Driven Approach: Proactive risk identification/mitigation.

Conventional vs. Modern:

Guiding Principles for Rural/Community Settings:

• Community Co-Design: Involve end-users from inception.

• Sustainability Focus: Low maintenance, offline-first, local skill development.

• Context-Aware: Design for low bandwidth, power constraints, local languages.

• Ethical Deployment: Privacy, data sovereignty, avoid digital divide.

3. SOFTWARE LIFECYCLE & PHASES

Overview (Rational Unified Process - RUP Example):

1. Inception → 2. Elaboration → 3. Construction → 4. Transition

Detailed Phase Expectations:

Software Maintenance:

• Definition: Modifications after delivery to correct faults, improve performance, or adapt to environment.

• Types:

  1. Corrective: Fix defects.

  2. Adaptive: Adjust to environment (OS, hardware, regulations).

  3. Perfective: Enhance performance/usability.

  4. Preventive: Prevent future issues (code refactoring).

Why Systems Lose Effectiveness Over Time:

• Technical Debt: Quick fixes accumulate.

• Environment Change: New OS, devices, security threats.

• User Needs Evolve: New requirements emerge.

• Hardware Obsolescence: Older systems incompatible with new tech.

• Rural Context: Infrastructure changes (network coverage, electricity reliability).

[!TIP] Exam link: "Real-world systems must adapt or lose effectiveness" → Answer: Due to environmental drift and requirements volatility. Without maintenance/updates, software becomes incompatible, insecure, and misaligned with user needs.

4. PROCESS FRAMEWORK ELEMENTS

Workflow Stages (Typical):

1. Requirements: Elicitation, analysis, specification.

2. Design: Architectural & detailed design.

3. Implementation: Coding, unit testing.

4. Testing: Integration, system, acceptance.

5. Deployment: Installation, training.

6. Maintenance: Ongoing support.

Process Checkpoints (Milestones/Reviews):

• Inception Review: Vision & scope approved?

• Elaboration Review: Architecture stable? Risks mitigated?

• Construction Review: Feature complete? Quality acceptable?

• Transition Review: Ready for release? Users trained?

Task Set:

• Definition: Collection of tasks (work units) required for a project.

• Selection: Based on project size, criticality, team experience, domain complexity.

• Example: Small rural app → lightweight tasks (user stories, simple design); Large system → formal specs, design reviews.

Process Discriminators (Factors Distinguishing Processes):

• Project Size & Complexity

• Team Distribution (local vs. remote)

• Requirements Stability

• Regulatory Compliance (e.g., data privacy laws)

• Technology Novelty

• Rural Context: Connectivity, local expertise availability.

5. ARTIFACTS IN SOFTWARE DEVELOPMENT

Management Artifacts: Plans, schedules, budgets, risk logs, status reports. Focus: Tracking & control. Engineering Artifacts: Source code, design models, test cases, architecture docs. Focus: Technical content.

Pragmatics Artifacts: Context-specific deliverables (e.g., community needs assessment, local language glossary, offline usage guide for rural projects). Bridge between technical and social context.

Role in Communication & Control:

• Communication: Shared understanding among stakeholders (users, developers, managers).

• Control: Baseline for measuring progress, managing changes.

• Rural Projects: Artifacts like participatory design sketches or field test logs are crucial for community trust.

6. SOFTWARE ARCHITECTURE & DESIGN

Model-Based Software Architecture:

• Concept: Use formal models (e.g., UML, ArchiMate) to represent system structure, components, interactions.

• Application: Early validation, stakeholder communication, impact analysis of changes.

• Rural Tech: Model offline sync mechanisms, data compression strategies.

Design Strategies:

Modular Design:

• Purpose: Manage complexity, enable parallel development, isolate changes, facilitate reuse.

• Cohesion: Strength of relationship within a module. High cohesion = module does one thing well (✅).

• Coupling: Degree of interdependence between modules. Low coupling = modules independent (✅).

• Goal: Maximize cohesion, minimize coupling.

[!TIP] Cohesion Types (High → Low): Functional > Sequential > Communicational > Procedural > Temporal > Logical > Coincidental.

Coupling Types (Low → High): Data > Stamp > Control > External > Common > Content.

7. TECHNICAL PRACTICES & STANDARDS

Importance:

• Quality: Reduces defects, improves reliability.

• Maintainability: Clear code = easier future updates (critical for rural long-term support).

• Team Collaboration: Consistent style = smoother knowledge sharing.

• Rural Context: Standards for offline data handling, low-power coding, localization (date/number formats).

Key Practices:

• Code Reviews: Catch errors early, share knowledge.

• Version Control (Git): Track changes, enable collaboration.

• Coding Standards: Naming conventions, formatting, documentation.

• Unit Testing: Ensure individual components work.

• Continuous Integration: Automate build/test on every commit.

8. PROJECT ORGANIZATION & TEAM STRUCTURE

Structure & Roles:

• Project Manager: Overall planning, control, stakeholder communication.

• Team Leads/Scrum Master: Facilitate team processes, remove blockers.

• Developers: Build software.

• QA/Testers: Ensure quality.

• Domain Experts: Provide rural context (agriculture, local governance).

• Community Liaison: Interface with end-users (critical for rural projects).

Software Management Team Organization:

• Functional: Specialists grouped by discipline (dev, test, docs).

• Project-Based: Cross-functional teams dedicated to one project.

• Matrix: Hybrid; individuals report to functional manager & project manager.

• Rural Projects: Often matrix with community representatives as advisors.

Multidisciplinary Team for Planning:

• Combines technical (developers, architects), domain (agronomists, local admin), social (anthropologists, community workers).

• Ensures technical feasibility + social acceptability + economic viability.

Stakeholder Organization for Effective SE:

• Identify: Users, funders, community leaders, government, NGOs.

• Engage: Regular updates, demos, feedback sessions.

• Rural Focus: Include village councils, self-help groups, local schools.

9. PROCESS AUTOMATION

Definition & Purpose: Use tools to automate repetitive SDLC tasks (build, test, deploy) to reduce errors, save time, improve consistency.

Four Stages of Automation:

1. Mechanization: Basic scripting (e.g., shell scripts for compile).

2. Integration: Automated builds, tests (CI tools like Jenkins).

3. Orchestration: Coordinated pipelines (CI/CD), infrastructure as code.

4. Intelligence: AI-driven test generation, predictive analytics.

How It Works (Examples):

• CI/CD Pipeline: Code commit → auto-build → auto-test → auto-deploy to staging.

• Tools: Jenkins, GitLab CI, Docker, Ansible.

• Rural Tech Example: Automated build that packages app with offline data bundles for areas with poor connectivity.

Role in Enhancing Software Economics:

• Reduces manual labor costs.

• Shortens time-to-market → faster ROI.

• Improves quality → less rework.

• Enables frequent releases → better user satisfaction.

10. PLANNING & CONTROL

Iterative Process Planning Approach:

• Plan at multiple levels: project (high-level), iteration (mid-level), daily (tasks).

• Example:

  1. Project Plan: Release 1.0 in 6 months with 5 features.

  2. Iteration Plan (2 weeks): Build feature A & B.

  3. Task Plan (daily): Developer X works on login module.

• Adjust plans based on iteration reviews.

Project Planning Activities:

• Scope: What will be delivered? (WBS - Work Breakdown Structure)

• Schedule: Timeline, milestones (Gantt chart).

• Resources: People, hardware, software, budget.

• Risk Plan: Identify, assess, mitigate.

Project Control Process (4 Steps):

1. Measure: Collect data (progress, defects, effort).

2. Compare: Against plan/baseline (variance analysis).

3. Decide: Is corrective action needed? (Change request, re-plan)

4. Act: Implement changes, update plan.

Project Control & Process Instrumentation:

• Instrumentation: Embed measurement points in process (e.g., time tracking, automated test coverage).

• Tools: JIRA, Trello, burn-down charts.

Success Factors:

• Realistic baseline plans.

• Regular monitoring.

• Empowered project manager.

• Stakeholder involvement.

Common Problems:

• Scope creep: Uncontrolled requirement changes.

• Inaccurate estimates: Over-optimism, unknown unknowns.

• Poor communication: Especially in distributed/rural teams.

• Resource constraints: Skilled staff shortage.

11. MEASUREMENT & INDICATORS

Process Measurement Tools:

• GQM (Goal-Question-Metric): Define goals → derive questions → identify metrics.

• Balanced Scorecard: Financial, customer, process, learning perspectives.

• Earned Value Management (EVM): Integrates scope, schedule, cost.

Key Management Indicators (KPIs):

• Schedule: Schedule variance (SV), schedule performance index (SPI).

• Cost: Cost variance (CV), cost performance index (CPI).

• Quality: Defect density, test coverage, escape rate.

• Productivity: Function points/person-month, velocity (agile).

• Rural Projects: Community adoption rate, offline usage time, local support tickets.

Use in Decision-Making:

• CPI < 1.0 → Cost overrun → need budget review.

• High defect escape → Testing process weak → improve test cases.

• Low velocity → Team blocked or requirements unclear → investigate.

12. RISK MANAGEMENT

Risk Identification Techniques:

• Brainstorming: Team workshops.

• Checklists: Based on past projects (e.g., "rural connectivity risk").

• SWOT Analysis: Strengths, Weaknesses, Opportunities, Threats.

• Expert Judgment: Consult experienced managers.

• Assumption Analysis: Challenge project assumptions.

Monitoring & Managing Risks:

1. Assess: Probability × Impact → prioritize (risk matrix).

2. Plan: Mitigation (reduce prob/impact), contingency (fallback plan), acceptance.

3. Monitor: Track triggers, review periodically.

4. Control: Execute plans when risk materializes.

Warning Signs (Project at Risk):

• Missed milestones repeatedly.

• Team morale low, high turnover.

• Requirements churn, scope creep.

• Stakeholder complaints, lack of engagement.

• Test failure rate increasing.

• Rural-Specific: Low community attendance in demos, local champion disengagement.

Actions by Project Manager:

• Re-plan: Adjust scope/schedule/budget.

• Escalate: Inform sponsors/stakeholders.

• Mitigate: Add resources, simplify design, train team.

• Communicate: Transparent updates to all parties.

• Rural Focus: Re-engage community leaders, simplify UI, provide offline training.

13. CONFIGURATION & QUALITY MANAGEMENT

Software Configuration Management (SCM):

• Process:

  1. Identification: What items to control (code, docs, env).

  2. Version Control: Track changes (Git, SVN).

  3. Change Management: Request → review → approve/reject → implement.

  4. Configuration Auditing: Verify consistency.

  5. Status Reporting: What versions exist where?

• Necessity:

  • Maintain baseline for releases.

  • Enable rollback if new version fails.

  • Track who changed what (accountability).

  • Support parallel development (branches).

Role of QA in Maintenance:

• Ensure fixes don't break existing functionality (regression testing).

• Verify adaptations (e.g., new OS compatibility) meet requirements.

• Rural Deployments: QA must test offline scenarios, low-bandwidth conditions, local language interfaces.

14. PROJECT EVALUATION & ALIGNMENT

Assessing Projects:

Integrating Goals with Strategy:

• Top-Down: Organizational strategy → project objectives.

• Bottom-Up: Project proposals should demonstrate contribution to strategic pillars (e.g., "this farm advisory app supports our goal to increase crop yields by 20%").

• Rural Context: Strategy must include capacity building (train local youth as support staff) and community ownership (cooperatives manage the system).

Final Boxed Summary for Exam:

\boxed{

\begin{array}{c}

\textbf{Key Exam Topics} \

\hline

\text{1. Software Economics: COCOMO, trends, rural impact.} \

\text{2. Lifecycle Phases: Inception→Transition goals.} \

\text{3. Artifacts: Management vs. Engineering vs. Pragmatics.} \

\text{4. Design: Top-down vs. Bottom-up, cohesion/coupling.} \

\text{5. Process Automation: 4 stages, CI/CD example.} \

\text{6. Control: 4 steps (Measure→Compare→Decide→Act).} \

\text{7. Risk: Identification, warning signs, rural risks.} \

\text{8. SCM: Version control, change management necessity.}

\end{array}

}