Programming Basics: Languages, Algorithms, and C Fundamentals

TAKEAWAYS:

• Programming languages are classified by level (high/low) and purpose (general/specialized), with C as a mid-level language bridging hardware and abstraction.
• Algorithms must be finite, unambiguous, input/output-defined, and effective to solve problems efficiently.
• Flowcharts and pseudocode are essential tools for designing algorithms before coding.
• C’s syntax (keywords, case sensitivity, and structure) enforces discipline in writing maintainable programs.
• Real-world applications (e.g., eSewa’s transaction validation or Khalti’s payment routing) rely on structured algorithms and efficient language choices.
• Debugging and testing are critical steps in translating algorithms into working programs.

1. Programming Languages: High-Level vs. Low-Level

Programming languages are tools that allow humans to communicate with computers. They are categorized based on their abstraction level and purpose.

Classification by Level

Highlighting how low-level languages interact directly with registers and memory. (Image: JonRoma (talk) (Uploads), Public domain, via Wikimedia Commons)

Why C?

C is a mid-level language because:

• It provides low-level access (pointers, memory management) for performance-critical tasks.
• It offers high-level abstractions (loops, functions, data types) for readability.
• Used in systems programming (operating systems, embedded systems) and application development (e.g., databases, compilers).

Example:

#include <stdio.h>
int main() {
    printf("Hello, World!"); // High-level abstraction
    return 0; // Low-level control (exit status)
}

Trace:

2. Types of Computer Software

Software is classified based on its function and purpose:

Classification Table

In the Real World:

• eSewa uses system software (Linux servers) and application software (backend APIs in C/Java) to process payments.
• Khalti relies on programming software (Python/C++ for fraud detection algorithms) and utility software (firewalls for security).
• NTC’s billing system uses structured algorithms (written in C/Java) to calculate electricity bills based on consumption tiers.

3. Algorithms: The Heart of Programming

An algorithm is a step-by-step procedure to solve a problem. It must satisfy:

1. Finiteness: Must terminate after finite steps.
2. Definiteness: Each step must be unambiguous.
3. Input: Takes zero or more inputs.
4. Output: Produces at least one result.
5. Effectiveness: Steps must be executable by a machine.

Example: Algorithm to Find the Sum of Two Numbers

Pseudocode:

START
   Read num1, num2
   sum = num1 + num2
   Display sum
STOP

Flowchart:

Trace Table:

In the Real World:

• Pathao’s fare calculation uses an algorithm to compute distance + time + base fare.
• Daraz’s order processing follows an algorithm to check stock → validate payment → dispatch.
• NEPSE’s stock price updates rely on algorithms to aggregate and display real-time data.

4. Flowcharts: Visualizing Algorithms

Flowcharts use standard symbols to represent steps:

• Oval: Start/Stop
• Rectangle: Process
• Diamond: Decision (Yes/No)
• Parallelogram: Input/Output
• Arrow: Flow direction

Example: Flowchart for Checking Even/Odd

flowchart TD
    A["START"] --> B["Read number"]
    B --> C["Is number % 2 == 0?"]
    C -->|"Yes"| D["Even"]
    C -->|"No"| E["Odd"]
    D --> F["STOP"]
    E --> F

Trace:

5. Introduction to C Language

C is a procedural, structured language developed by Dennis Ritchie (1972). Key features:

• Case-sensitive: int ≠ INT.
• Compiled: Source code → Object code → Executable.
• Portable: Write once, compile for any platform.
• Memory-efficient: Direct hardware access.

Structure of a C Program

#include <stdio.h> // Preprocessor directive (includes library)
int main() {       // Main function (entry point)
    // Code block
    return 0;      // Exit status
}

Trace of Compilation Process:

flowchart LR
    A["Source Code (.c)"] --> B["Preprocessor"]
    B --> C["Compiler"]
    C --> D["Assembler"]
    D --> E["Linker"]
    E --> F["Executable (.exe)"]

In the Real World:

• Ncell’s billing system uses C for low-latency processing of SMS/voice traffic.
• Bank ATMs run on C/C++ for real-time transaction validation.
• Google’s early systems (e.g., MapReduce) were prototyped in C for performance.

6. Writing Your First C Program: "Hello, World!"

Code:

#include <stdio.h>
int main() {
    printf("Hello, World!\n");
    return 0;
}

Step-by-Step Execution:

Common Errors and Fixes:

Exam Tip

1. For definitions:

   • Always state properties (e.g., "An algorithm must be finite, unambiguous...").
   • Compare high-level vs. low-level languages in a table (as above).

2. For algorithms:

   • Write pseudocode first, then draw the flowchart.
   • Show a trace table with inputs/outputs/steps.
   • Example: If asked to find the sum of two numbers, include:
     • Pseudocode
     • Flowchart
     • Trace table (with sample inputs)

3. For C programs:

   • Start with #include and main().
   • Use meaningful variable names (e.g., sum instead of s).
   • Include comments explaining key steps.

4. Real-world connections:

   • Link algorithms to eSewa’s payment flow or Khalti’s routing logic.
   • For C, mention systems programming (e.g., "C is used in Linux kernels because...").

5. Avoid:

   • Writing raw code without explanation.
   • Forgetting to initialize variables before use.
   • Using magic numbers (e.g., if (x == 5) without context).

Practice Question: Design an algorithm to check if a number is prime, then:

1. Draw the flowchart.
2. Write the pseudocode.
3. Trace it for input 7 and 10.
4. Write the equivalent C program.