Software Engineering: Definitions, Challenges & Evolution

What is Software Engineering?

Software engineering is the systematic application of engineering principles to the design, development, maintenance, testing, and evaluation of software. It bridges the gap between raw programming and large-scale, reliable software systems.

Why is it called "engineering"?

• Disciplined approach: Like civil or mechanical engineering, it follows structured processes (requirements → design → implementation → testing).
• Scalability: Manages complexity in large projects (e.g., eSewa’s payment system or WhatsApp’s end-to-end encryption).
• Reliability: Ensures software meets quality standards (e.g., Ncell’s network uptime).

The Software Crisis: Why Traditional Programming Fails

Before software engineering, projects often failed due to:

• Unclear requirements (e.g., NEPSE’s trading platform crashes during high volatility).
• Poor documentation (e.g., legacy bank systems with undocumented code).
• Late testing (e.g., Daraz’s website bugs appearing only after launch).

Key Problems:

Evolution of Software Development

1. Programming Era (1940s–1960s)

• Focus: Writing code manually (e.g., early bank transaction scripts).
• Problem: No structure → "spaghetti code" (hard to debug).

2. Software Crisis (1968–1970s)

• NATO Conference (1968): First use of the term "software engineering."
• Solution: Introduced structured methodologies (e.g., waterfall model).

3. Modern Era (1980s–Present)

• Agile, DevOps, AI-driven tools: Used by Google (TensorFlow), Pathao (real-time ride matching).
• Outcome: Faster iterations, better collaboration.

timeline
    title Evolution of Software Development
    1940s : Programming Era (Manual Coding)
    1968 : Software Crisis (NATO Conference)
    1970s : Structured Methods (Waterfall)
    1990s : Agile & Iterative Models
    2010s : DevOps & AI Integration

Core Characteristics of Software Engineering

Software vs. Programming: Key Differences

Real-World Applications

1. eSewa (Nepal)

• Idea Used: Modular design (separate payment, user, and admin modules).
• How: Ensures updates to one module (e.g., tax rules) don’t break others.

2. WhatsApp (Global)

• Idea Used: End-to-end encryption (security-focused design).
• How: Uses signal protocol to encrypt messages before sending.

3. NTC’s Network Management

• Idea Used: Fault tolerance (redundant servers).
• How: If one data center fails, traffic reroutes automatically.

Worked Example: Khalti’s Loan Interest Calculation

• Problem: Calculate monthly interest for a ₹10,000 loan at 12% annual rate.
• Software Engineering Approach:
  1. Requirement: Define formula: $\text{Monthly Interest}=\frac{P\times r}{12}$.
  2. Design: Create a LoanCalculator class with input validation.
  3. Implementation:

     class LoanCalculator:
         def calculate_monthly_interest(self, principal, annual_rate):
             return (principal * annual_rate) / 12
     

  4. Testing: Verify with edge cases (e.g., ₹0 principal).

Challenges in Software Engineering

1. Changing Requirements

   • Example: NEPSE’s platform must adapt to new trading rules.
   • Solution: Agile methodologies (iterative development).

2. Scalability

   • Example: Pathao’s app must handle 100K+ users during Dashain.
   • Solution: Cloud-based microservices (AWS, Google Cloud).

3. Security

   • Example: Daraz’s database breaches.
   • Solution: Encryption (TLS), regular audits.

4. Maintenance

   • Example: Old bank ATMs with outdated software.
   • Solution: Version control (Git), documentation.

Software Engineering Principles

1. Abstraction: Hide complexity (e.g., Google Maps API hides GPS math).
2. Modularity: Break into components (e.g., WhatsApp’s messaging vs. calls modules).
3. Reusability: Use libraries (e.g., Python’s requests for HTTP calls).
4. Verification & Validation:
   • Verification: Are we building it right? (Testing).
   • Validation: Are we building the right thing? (User feedback).

stateDiagram-v2
    [*] --> Development
    Development --> Testing : Verify
    Testing --> Deployment : Validate
    Deployment --> Maintenance : Monitor
    Maintenance --> [*]

Exam Tip

1. Define Key Terms Clearly:
   • Example: "Software engineering is the application of systematic, disciplined approaches to software development." (2 marks).
2. Compare Models:
   • Contrast waterfall vs. agile in a table (3 marks).
3. Real-World Links:
   • Relate concepts to Nepali apps (e.g., "Khalti uses modular design for its payment system").
4. Diagrams:
   • Draw a software lifecycle model (e.g., spiral model) for 4 marks.
5. Short Answers:
   • "What is the software crisis?" → Briefly explain with an example (e.g., Ariane 5).

Visual Summary: