Complete 2025 Guide: Computer Programming Syllabus (BE I/I)

Computer Programming Micro Syllabus

Representative Image for the Computer Programming Micro Syllabus
Course: Computer Programming
Placement: First Year, First Part
Total Theory Hours: 45 Hours
Total Board Marks: 60 Marks

Syllabus Table of Contents

Quickly navigate to any chapter in the Computer Programming Syllabus using the links below.

S.N. Chapter Name View Details
1 Introduction to Programming
2 Overview of C
3 Operators and Expressions
4 Input-output in C
5 Control Structures
6 Array and Pointer
7 User-defined Functions
8 Structure
9 File Management
10 Recent Trends in Programming
11 Lab Activities
12 Final Exam

Computer Programming Micro Syllabus Course Content Details

1. Introduction to Programming
3 hrs 4 Marks

  1. Computer Program and Programming Language
    1. Definition
  2. Types of Programming Languages
    1. Machine Level, Assembly Level & High-Level Language
  3. Generations of programming language
    1. First (machine level) to fifth ‘AI & more’
  4. Problem-solving using a Computer
    1. Analysis
    2. Design-algorithm and flowchart
    3. Programming
    4. Compilation Linking and Execution
    5. Debugging & Testing
      1. Types of Testing
    6. Documentations

2. Overview of C
3 hrs 4 Marks

  1. Introduction & History of C Programming
    1. ALGOL (1960s) ► B ► BCPL ► K&R C ► ANSI C ► C99
  2. C Headers and Library Functions
    1. Header files: stdlib.h, stdio.h, string.h, math.h and library functions defined under these header files.
  3. Preprocessor Directives
    1. Definition and examples (#include, #define)
  4. Basic Structure of a C Program
    1. 6 sections [Documentation, link, definition, global declaration, main, sub-program section]
  5. C Tokens
    1. Character Set [letters, digits, special characters, whitespace characters]
    2. Keywords [32 reserved words]
    3. Identifiers [definition, Naming rules & guidelines]
  6. Type Casting
    1. Implicit, Explicit
  7. Data Types, Variables and Constants
    1. Data types [fundamental, derived & user-defined]
    2. Variables [declaration, types, scope]
  8. Compilers and IDE for C

3. Operators and Expressions
4 hrs 4 Marks

  1. Operators
    1. Arithmetic
    2. Logical
    3. Relational
    4. Assignment
    5. Increment & Decrement [pre & post]
    6. Bitwise
    7. Special [sizeof, comma]
  2. Expressions
    1. Arithmetic expressions
      1. Shorthand Assignment Operator
    2. Evaluation of expressions
    3. Precedence of arithmetic operators [high, low]
    4. Associativity [left to right, right to left]

4. Input-output in C
3 hrs 3 Marks

  1. Unformatted I/O
    1. getchar()
    2. getch()
    3. getche()
    4. gets()
    5. putchar()
    6. puts()
  2. Formatted I/O
    1. printf()
    2. scanf()
  3. Control String
    1. Flags
    2. Field width
    3. Precision and
    4. Specifier

5. Control Structures
8 hrs 12 Marks

  1. Sequential
  2. Branching
    1. simple if
    2. if-else
    3. nested if-else
    4. else-if ladder
    5. switch
    6. goto
  3. Looping
    1. Types
      1. while, do & for
    2. Categories
      1. entry-controlled & exit controlled
      2. counter-controlled & sentinel controlled
    3. Nesting
    4. Loop interruption
      1. break, continue

6. Array and Pointer
7 hrs 11 Marks

  1. Array
    1. One Dimensional Array
    2. Two-Dimensional Array
    3. Multi-Dimensional Array
    4. String
    5. String handling functions
      1. strlen(), strcpy(), strcat(), strrev(), strcmp(), strlwr(), strupr()
    6. Array of strings
  2. Pointer
    1. Definition, Declaration & Types [null, void, etc.]
    2. Pointer Arithmetic
    3. Relationship between Pointer and Array

7. User-defined Functions
6 hrs 8 Marks

  1. Introduction & Advantages
  2. Elements of User-defined Function
    1. Declaration/Prototype, Definition, Function Parameters, function call
  3. Storage Class
    1. auto, register, extern, and static
  4. Scope Rules
  5. Category of Functions
    1. Functions with no arguments and no return values
    2. Functions with arguments and no return values
    3. Functions with arguments and return values
    4. Functions with no arguments and return values
  6. Recursive functions
  7. Function Call by Values and Reference
  8. Passing Array and String to Function

8. Structure
5 hrs 6 Marks

  1. Defining, Declaring, Accessing & Initializing Structure Elements
  2. Array of Structure
  3. Array within structure
  4. Structure within structure/ nested structure
  5. Structure & pointer [This operator (->) concept]
  6. Passing and Returning Structures to/from Function

9. File Management
4 hrs 5 Marks

  1. Binary and Text File in C
  2. File Opening Modes
    1. w, r, a, wb, rb, ab, w+, a+, r+ & more
  3. Defining, Opening & Closing File
  4. Input-output operations on files
    1. Character I/O [fputc(), fgetc()]
    2. String I/O [fgets(), fputs()]
    3. Formatted I/O [fscanf(), fprintf()]
    4. Record I/O [fwrite(), fread()]
  5. Overview of Random File Access
    1. fseek, ftell, and rewind
  6. Error handling

10. Recent Trends in Programming
2 hrs 3 Marks

  1. Introduction to OOP
  2. Definitions of Class, Method and Object in OOP
  3. Difference between POP and OOP
  4. Overview of other High-Level Programming Languages
    1. C++, Python, JavaScript, Java, C#, R, Kotlin, Ruby & more

Lab Activities
50 Marks (Internal)

  1. Lab 1: Introduction and Demonstrations of projects written in C
  2. Lab 2: Formatted and Unformatted Input/output in C
  3. Lab 3: Branching in Control Structure in C
  4. Lab 4: Looping in Control Structure in C
  5. Lab 5: Array in C
  6. Lab 6: String in C
  7. Lab 7: Pointers in C
  8. Lab 8: User-Defined functions in C
  9. Lab 9: Structure in C
  10. Lab 10: File handling in C
  11. Group project on C: Maximum 4 students in a group at the end of the course. (20 marks out of 50 marks)

Final Exam
60 Marks (Final Exam)

  • Question Type Distribution
    • 40% theory & 60% Example code.
  • Question Complexity Distribution
    • 40% questions complexity should be easy.
    • 40% questions complexity should be moderately hard.
    • 20% questions complexity should be hard.
Scroll to Top