C Programming - Introduction to Programming Notes
First Year Internals Preparation
1. Definition of a Computer
A computer is an electronic device that accepts data (input), processes it according to specified instructions,
stores information, and produces output.
Key Characteristics:
Processes data at high speed
Stores large amounts of data
Performs tasks with accuracy and precision
Can execute repetitive tasks without fatigue
Operates based on programmed instructions
Versatile - can perform multiple tasks
2. Components of Computer System
A. Hardware (Physical Components)
Input Devices
Keyboard, Mouse, Scanner, Microphone, Webcam, Joystick
Output Devices
Monitor, Printer, Speakers, Projector, Plotter
Central Processing Unit (CPU) - "Brain of Computer"
ALU (Arithmetic Logic Unit): Performs arithmetic (+, -, ×, ÷) and logical operations (AND, OR, NOT)
CU (Control Unit): Controls and coordinates all operations, manages data flow
Registers: Small, fast storage locations inside CPU for temporary data
Memory
Primary Memory:
RAM (Random Access Memory): Volatile, temporary storage, fast access
ROM (Read Only Memory): Non-volatile, permanent, stores BIOS
Secondary Memory:
Hard Disk, SSD, USB drives, CD/DVD, Memory Cards
Non-volatile, large capacity, slower than RAM
B. Software (Programs/Instructions)
System Software
Operating Systems (Windows, Linux, macOS)
Device Drivers
Utility Programs (Antivirus, Disk Cleanup)
Compilers, Interpreters, Assemblers
Application Software
Programs for specific tasks
Examples: MS Word, Excel, Browsers, Games, Photoshop
C. Data
Raw facts and figures
Becomes meaningful information after processing
D. People (Users/Personnel)
Programmers, System Analysts, Operators, End Users
3. Programming Languages
Definition: A programming language is a set of instructions, rules, and syntax used to communicate with
computers and create programs.
Classification:
A. Low-Level Languages
1. Machine Language (1GL - First Generation)
Binary code consisting of 0s and 1s
Directly understood by computer hardware
Advantages: Very fast execution, no translation needed
Disadvantages: Difficult to write and debug, machine-dependent
Example: 10110000 01100001
2. Assembly Language (2GL - Second Generation)
Uses mnemonics (symbolic codes)
Examples of mnemonics: ADD, SUB, MOV, MUL, DIV
Requires Assembler to convert to machine code
Advantages: Easier than machine language, more control over hardware
Disadvantages: Machine-dependent, still complex
Example: MOV AX, 5
B. High-Level Languages (3GL - Third Generation)
Human-readable syntax, English-like statements
Platform-independent (portable)
Requires Compiler or Interpreter
Examples: C, C++, Java, Python, FORTRAN, COBOL, BASIC
Advantages:
Easy to learn and write
Portable across different machines
Easier debugging and maintenance
More productive
Disadvantages:
Slower execution than low-level languages
Less control over hardware
Example in C:
printf("Hello World");
C. Fourth Generation Languages (4GL)
Very high-level, non-procedural
Examples: SQL, MATLAB, R
Used for database queries and specialized applications
D. Fifth Generation Languages (5GL)
Based on artificial intelligence
Examples: Prolog, Mercury, LISP
Compiler vs Interpreter
Compiler Interpreter
Translates entire program at once Translates line by line
Creates executable file No executable file
Faster execution Slower execution
Errors shown after compilation Errors shown line by line
Example: C, C++ Example: Python, JavaScript
4. Design and Implementation of Efficient Programs
What is an Efficient Program?
A program that:
Uses minimum memory
Executes in minimum time
Is easy to understand and maintain
Produces correct output for all inputs
Handles errors gracefully
Steps in Program Development:
1. Problem Definition: Clearly understand the problem
2. Problem Analysis: Identify inputs, outputs, and processing requirements
3. Algorithm Development: Step-by-step solution
4. Coding: Write program in chosen language
5. Testing: Check for errors and correct output
6. Documentation: Write comments and user manuals
7. Maintenance: Updates and bug fixes
Characteristics of Good Programs:
Correctness: Produces accurate results
Efficiency: Optimal use of time and space
Readability: Easy to understand (proper indentation, comments)
Maintainability: Easy to modify and update
Portability: Runs on different platforms
Reliability: Works consistently without crashes
Robustness: Handles unexpected inputs gracefully
5. Program Design Tools
A. Algorithm
Definition: An algorithm is a step-by-step procedure or set of well-defined instructions to solve a problem.
Characteristics of Good Algorithm:
Finiteness: Must terminate after finite steps
Definiteness: Each step must be clear and unambiguous
Input: Zero or more inputs
Output: At least one output
Effectiveness: Each step must be feasible and executable
Example: Algorithm to find sum of two numbers
Step 1: Start
Step 2: Read first number A
Step 3: Read second number B
Step 4: Calculate Sum = A + B
Step 5: Display Sum
Step 6: Stop
Example: Algorithm to find largest of three numbers
Step 1: Start
Step 2: Read three numbers A, B, C
Step 3: If A > B and A > C, then
Display "A is largest"
Step 4: Else if B > C, then
Display "B is largest"
Step 5: Else
Display "C is largest"
Step 6: Stop
B. Flowchart
Definition: A flowchart is a graphical/pictorial representation of an algorithm using standard symbols.
Standard Flowchart Symbols:
Oval/Ellipse: Start/Stop (Terminal)
Parallelogram: Input/Output
Rectangle: Process/Computation
Diamond: Decision/Condition
Arrow: Flow of control
Circle: Connector (for page continuation)
Advantages:
Easy to understand
Visual representation
Better communication
Easy to analyze logic
Disadvantages:
Time-consuming for large programs
Difficult to modify
No standard rules for complex problems
Example: Flowchart to add two numbers
[Start] → [Read A, B] → [Sum = A + B] → [Display Sum] → [Stop]
Example: Flowchart to check even/odd
[Start] → [Read N] → <Is N%2==0?>
↓ Yes ↓ No
[Print "Even"] [Print "Odd"]
↓ ↓
[Stop] ←────────────┘
C. Pseudocode
Definition: Pseudocode is an informal, high-level description of an algorithm using a mix of natural language
and programming constructs.
Characteristics:
Not a formal programming language
No specific syntax rules
Easy to convert to actual code
Language-independent
Common Keywords:
BEGIN, END
INPUT, OUTPUT, PRINT, READ
IF, THEN, ELSE, ENDIF
WHILE, ENDWHILE
FOR, ENDFOR
SET, CALCULATE
Example: Pseudocode to find sum of two numbers
BEGIN
READ A, B
SET Sum = A + B
PRINT Sum
END
Example: Pseudocode to check positive/negative
BEGIN
READ number
IF number > 0 THEN
PRINT "Positive"
ELSE IF number < 0 THEN
PRINT "Negative"
ELSE
PRINT "Zero"
ENDIF
END
Example: Pseudocode for factorial
BEGIN
READ N
SET fact = 1
FOR i = 1 TO N
SET fact = fact * i
ENDFOR
PRINT fact
END
Comparison of Design Tools
Algorithm Flowchart Pseudocode
Text-based Graphical Text-based
Step-by-step Symbolic Structured English
Detailed Visual Semi-formal
Good for simple problems Good for visualization Good for complex logic
6. Types of Errors
A. Syntax Errors (Compile-Time Errors)
Definition: Errors due to violation of grammar/syntax rules of the programming language.
Examples:
Missing semicolon: printf("Hello") (should be ; at end)
Wrong keyword: Printf instead of printf
Unmatched brackets: if (a > b {
Missing header file: Not including #include <stdio.h>
Incorrect variable declaration
Detection: Found by compiler during compilation
Correction: Easy to fix, compiler shows line number and error message
B. Logical Errors (Semantic Errors)
Definition: Errors in the logic/algorithm of the program. The program compiles and runs but produces incorrect
output.
Examples:
Using + instead of - : sum = a + b when you meant diff = a - b
Wrong formula: Using area = 2 * r instead of area = 3.14 * r * r
Incorrect condition: if (a > b) instead of if (a >= b)
Infinite loops due to wrong loop condition
Wrong variable used in calculation
Detection: Found during testing by checking outputs
Correction: Most difficult to find and fix, requires careful analysis
C. Runtime Errors (Execution Errors)
Definition: Errors that occur during program execution, causing abnormal termination.
Examples:
Division by zero: result = a / 0;
Array index out of bounds: Accessing arr[10] when array size is 5
File not found: Opening a non-existent file
Insufficient memory: Allocating too much memory
Stack overflow: Too many recursive calls
Type mismatch: Reading integer when string is input
Detection: Occurs during execution
Correction: Use error handling techniques (validation, exception handling)
D. Linker Errors
Definition: Errors that occur during linking phase when object files are combined.
Examples:
Missing function definition
Undefined reference to external variables
Multiple definitions of same function
Missing library files
Detection: Found by linker after compilation
Important Exam Tips
Common Algorithm Questions:
1. Find sum, product, average of numbers
2. Find largest/smallest of numbers
3. Check even/odd
4. Check prime number
5. Find factorial
6. Generate Fibonacci series
7. Reverse a number
8. Check palindrome
9. Swap two numbers
10. Calculate simple/compound interest
Common Flowchart Questions:
1. Check whether number is positive/negative/zero
2. Find grade based on marks
3. Calculate area of circle
4. Check leap year
5. Find roots of quadratic equation
Key Points to Remember:
1. Computer = Electronic device for processing data
2. Four main components = Hardware, Software, Data, People
3. CPU parts = ALU, CU, Registers
4. Language levels = Machine → Assembly → High-level
5. Three design tools = Algorithm, Flowchart, Pseudocode
6. Algorithm must have: Finiteness, Definiteness, Input, Output, Effectiveness
7. Four error types = Syntax, Logical, Runtime, Linker
8. Syntax errors = Found by compiler (easiest)
9. Logical errors = Wrong output (hardest)
10. Runtime errors = During execution (division by zero)
Quick Revision Checklist
Definition and characteristics of computer
Four components of computer system
CPU components and their functions
Primary vs Secondary memory
Types of programming languages with examples
Compiler vs Interpreter differences
Characteristics of efficient programs
Algorithm definition and characteristics
Write simple algorithms (sum, largest number)
Flowchart symbols and their uses
Draw flowcharts for basic problems
Pseudocode format and keywords
All four types of errors with examples
How to detect each error type
Sample Questions for Practice
Short Answer (2-3 marks):
1. Define computer and list its characteristics
2. What is CPU? Explain its components
3. Differentiate between RAM and ROM
4. What is a programming language?
5. Differentiate between compiler and interpreter
6. What is an algorithm? List its characteristics
7. Draw flowchart symbols
8. What is pseudocode?
9. Define syntax error with example
10. What is runtime error?
Long Answer (5-10 marks):
1. Explain components of computer system in detail
2. Explain types of programming languages with examples
3. What are the characteristics of a good program?
4. Explain program design tools with examples
5. Write algorithm and draw flowchart to find largest of three numbers
6. Explain types of errors in programming with examples
7. Compare algorithm, flowchart, and pseudocode
8. Write algorithm and pseudocode to check whether a number is prime
All the Best for Your Internals! 🎯
Quick Study Tips:
Focus on definitions and examples
Practice drawing flowcharts
Write 2-3 algorithms on your own
Remember the four error types clearly
Revise CPU components (ALU, CU, Registers)
Know compiler vs interpreter difference
Time Management:
Read question carefully
Start with questions you know well
Draw neat flowcharts with proper symbols
Write algorithms in clear steps
Review your answers before submitting