Programming Languages & Tools: Syntax, Paradigms, IDEs & Compilers

Core Concepts

1. Programming Languages: Definition & Classification

Programming languages are formal languages designed to communicate instructions to computers. They enable developers to write software by defining syntax (rules for writing code) and semantics (meaning of code).

Classification of Programming Languages

Key Attributes of Good Programming Languages

2. Programming Paradigms

A. Procedural Programming

• Definition: Code is written as a sequence of procedures (functions) that operate on data.
• Example Languages: C, Pascal, Fortran.
• Example in Nepali Context:

  // Calculating compound interest for a bank loan (Nepal SBI)
  float calculateInterest(float principal, float rate, int years) {
      return principal * pow(1 + rate/100, years) - principal;
  }
  

B. Object-Oriented Programming (OOP)

• Core Principles:

  mindmap
    root((OOP Principles))
      Encapsulation["Data + Methods in a Class"]
      Inheritance["Reuse via Parent-Child Classes"]
      Polymorphism["Same Method, Different Behavior"]
      Abstraction["Hide Complexity (Interfaces/Abstract Classes)"]

• Example in Nepal: Pathao’s Ride-Hailing System:

  class Ride {
      private String driverName;
      private double distance;
      public double calculateFare() { return distance * 10; } // Polymorphism for discounts
  }
  

C. Functional Programming

• Definition: Treats computation as evaluation of mathematical functions (immutable data, pure functions).
• Example Languages: Haskell, Lisp, Scala.
• Example:

  -- Calculate factorial (used in combinatorial algorithms)
  factorial 0 = 1
  factorial n = n * factorial (n - 1)
  

3. Software Development Tools

A. Integrated Development Environments (IDEs)

B. Compilers & Interpreters

• Compiler: Translates entire code to machine code (e.g., gcc for C).
• Interpreter: Executes code line-by-line (e.g., Python’s interpreter).
• Example: Khalti’s Payment Gateway:

sequenceDiagram
    participant User
    participant KhaltiApp as Khalti App (Python)
    participant KhaltiServer as Khalti Server (HTTP)
    participant Bank as Bank System (SQL)
    User->>KhaltiApp: Initiate Payment (Python Script)
    KhaltiApp->>KhaltiServer: Send Request (HTTP API Call)
    KhaltiServer->>Bank: Verify Funds (SQL Query)
    Bank-->>KhaltiServer: Response (Approved/Rejected)
    KhaltiServer-->>KhaltiApp: Process Response
    KhaltiApp-->>User: Display Result
    note right of KhaltiApp: Compiled/Interpreted
    note right of KhaltiServer: Compiled (e.g., Java)
    note right of Bank: SQL (Interpreted)

C. Debuggers & Profilers

• Debuggers: Identify runtime errors (e.g., gdb for C, PyCharm for Python).
• Profilers: Optimize performance (e.g., cProfile for Python).
• Example: NTC’s Traffic Simulation:

  import cProfile
  def simulate_traffic(routes):
      # Simulate Kathmandu’s traffic routes
      pass
  cProfile.run('simulate_traffic(routes)')
  

4. Version Control Systems (VCS)

Git & GitHub/GitLab

• Commands:

  git init          # Start a new repo
  git add file.py   # Stage changes
  git commit -m "Fix bug"  # Save changes
  git push origin main  # Upload to GitHub
  

• Example in Nepal: Open-Source Projects:
  • NepalGovTech: Collaborative coding for government apps (e.g., eSewa).
  • Daraz Nepal: Uses GitHub for multi-team coordination.

In the Real World

1. eSewa (Nepal):

   • Language: Backend in Java (OOP for user accounts, transactions), frontend in JavaScript (procedural for UI logic).
   • Tools: Eclipse (IDE), Maven (build tool), GitHub (version control).
   • Example: When you pay a bill, eSewa’s Java classes handle authentication (OOP) while JavaScript renders the payment page (procedural).

2. Pathao (Ride-Hailing):

   • Language: Python (functional for route calculations, OOP for user/driver models).
   • Tools: PyCharm (IDE), Docker (containerization for scaling).
   • Example: The calculate_fare() function uses recursion (functional paradigm) to compute dynamic pricing based on distance and demand.

3. NTC’s Traffic Management:

   • Language: C++ (procedural for real-time traffic light control).
   • Tools: Visual Studio (IDE), Wireshark (network debugging).
   • Example: Traffic lights at Thapathali use compiled C++ code to synchronize signals, with debuggers to fix delays during peak hours.

Worked Example: Compiling a Nepali Loan Calculator

Scenario: A bank in Nepal wants to compile a C program to calculate loan interest (procedural paradigm).

1. Code:

   #include <stdio.h>
   float calculateEMI(float principal, float rate, int years) {
       float emi = (principal * rate * years) / (12 * years);
       return emi;
   }
   int main() {
       printf("EMI: %.2f", calculateEMI(1000000, 8.5, 5));
       return 0;
   }
   

2. Compilation Steps:

   gcc loan.c -o loan.exe  # Compile with GCC
   ./loan.exe             # Run executable
   

3. Output:

   EMI: 18872.50
   

Comparison Table: Paradigms in Nepali Apps

Exam Tip

1. Definitions: Always define terms precisely (e.g., "A compiler translates high-level code to machine code before execution").
2. Diagrams: Draw sequence diagrams for tool workflows (e.g., IDE → Compiler → Executable) and mindmaps for paradigms.
3. Examples: Relate to Nepali apps:
   • eSewa → OOP for user management.
   • Pathao → Functional programming for route optimization.
4. Code Snippets: Include 1-2 lines of code in answers (e.g., git commit or a Python function).
5. Tools vs. Paradigms:
   • Tools (IDEs, compilers) are how you build software.
   • Paradigms (OOP, functional) are how you structure the code.
6. Common Pitfalls:
   • Don’t confuse interpreters (execute line-by-line) with compilers (translate all at once).
   • Avoid vague answers like "Git is for version control" → specify git commit, git push, etc.