Microsoft Access

A Computer Program is a precise, ordered sequence of instructions written in a specific computer language that directs the computer hardware to perform a defined task or solve a computational problem. The creative and logical process of designing, writing, testing, and debugging these instructions is called Programming (or coding). The individual who writes and implements these instructions is called a Programmer.

Because computer processors (CPUs) consist of millions of microscopic electronic switches (transistors) that operate strictly through two physical voltage states (ON = 1, OFF = 0), human programmers require formal communication systems—known as Programming Languages—to bridge human thought and electronic hardware.

Machine Language is the fundamental, native language of a computer system. It is written exclusively using binary digits: 0 and 1 (binary code). For example, an instruction to add two numbers might appear as a cryptic binary string like 01001100 00010001.

• Key Advantages: Fastest possible execution speed, zero translation overhead (directly executed by CPU registers), and extremely efficient hardware utilization.
• Severe Limitations: Highly machine-dependent (a program written for one CPU architecture will not run on another), nearly impossible for humans to memorize long binary strings, excruciatingly difficult to debug, and prone to typing errors.

To overcome the immense difficulty of binary code, computer scientists created Assembly Language. Instead of numeric 0s and 1s, Assembly language substitutes short, memorable English abbreviations called Mnemonics (e.g., ADD for addition, SUB for subtraction, MOV for moving data between registers, JMP for jump, and HLT for halt).

Because the CPU still only understands binary signals, Assembly language requires a dedicated system software translator called an Assembler to convert mnemonic code into machine language. Although vastly easier than binary, Assembly language remains low-level and machine-dependent, requiring deep knowledge of specific CPU hardware registers.

High-Level Languages (HLL) revolutionized computing by using everyday English words (such as PRINT, INPUT, IF, THEN, GOTO) and familiar mathematical operators (+, -, *, /). High-level languages are machine-independent (portable)—a program written in a high-level language can run on virtually any computer hardware equipped with the appropriate language translator.

• Historical Milestones: FORTRAN (Formula Translation, 1957 by John Backus) was the world's first high-level language, designed for scientific calculations; COBOL (Common Business-Oriented Language, 1959 by Grace Hopper) was created for business applications; BASIC (Beginners All-purpose Symbolic Instruction Code, 1964 by Kemeny & Kurtz) was built for teaching novices. Modern 3GLs include C, C++, Java, and Python.

Fourth Generation Languages (4GL) are non-procedural languages designed to maximize programming speed and human productivity. In a procedural language (like C or BASIC), the programmer must specify how to accomplish a task step-by-step. In a 4GL, the programmer simply specifies what result is desired, and the system figures out how to retrieve it. The most prominent example of a 4GL is SQL (Structured Query Language), used worldwide to query relational databases.

Fifth Generation Languages (5GL) incorporate artificial intelligence and constraint-based programming, where problems are solved using natural language queries and logical constraints rather than coded algorithms (e.g., Prolog, Mercury).

Computer hardware can never directly execute instructions written in English or Assembly mnemonics. Therefore, special system software called Language Processors (Translators) are indispensable in computing.

• Source Code (Source Program): The original program written by the programmer in a high-level language (like QBASIC or C) or assembly language. It is easily readable by humans but incomprehensible to the CPU.
• Object Code (Object Program / Machine Code): The translated binary version (0s and 1s) generated by the language processor that the CPU can directly execute.

An Assembler is a language processor that translates a program written in Assembly Language into machine language. Each assembly mnemonic corresponds closely to a single machine code instruction. Once assembled, the resulting object code can be run directly on that specific computer processor.

An Interpreter is a language processor that translates high-level source code into machine code one line at a time. As soon as it translates a single line, the CPU executes it immediately before the interpreter reads the next line.

• Debugging Advantage: If a syntax error occurs on line 5, the interpreter halts execution immediately and points out the exact error. This makes interpreters ideal for students and beginners learning to code.
• Execution Characteristic: An interpreter does not generate a standalone executable file (like a .exe file). If you run the program 100 times, the interpreter must re-translate each line 100 times, making execution relatively slower. QBASIC and Python use interpreter engines.

A Compiler is a language processor that reads and translates the entire high-level source code file all at once before any execution takes place. It performs thorough lexical analysis, syntax checking, and semantic validation across all lines.

• Output Generation: If no errors exist, the compiler generates a permanent, standalone Object File (.OBJ) or Executable File (.EXE).
• Error Reporting: If errors are found, the compiler produces a comprehensive diagnostic error report listing all errors and warning lines together at the end of the scan.
• Speed Advantage: Once compiled, the program runs at maximum hardware speed without needing the compiler present. Languages like C and C++ rely on compilers.

QBASIC stands for Quick Beginners All-purpose Symbolic Instruction Code. It is an integrated development environment (IDE) and interpreter developed by Microsoft based on the classic BASIC language created in 1964 by John G. Kemeny and Thomas E. Kurtz at Dartmouth College. QBASIC provides a friendly, structured environment featuring a text editor for writing code, instant syntax checking upon pressing Enter, an output display screen, and convenient shortcut keys (such as F5 to Run a program and Shift + F5 to restart execution).

The Character Set of QBASIC comprises alphabetic letters (A–Z, a–z), decimal digits (0–9), and special arithmetic/punctuation symbols (+ - * / = < > ( ) , ; : $ % # ").

A Constant is a fixed data value that remains unchanged throughout program execution. QBASIC supports two categories of constants:

• Numeric Constants: Positive or negative real numbers, integers, or decimals (e.g., 100, -45.5, 0, 3.14159). They are used in mathematical calculations and never enclosed in quotes.
• String Constants: Any sequence of letters, digits, spaces, or symbols enclosed within double quotation marks (e.g., "TargetExams", "Kolkata - 700001", "Class 7"). Quotation marks define the string boundaries and are not printed on the screen.

In computer programming, a Variable is a named location in the computer's memory (RAM) allocated to store a data value. Unlike constants, the contents stored inside a variable can change or be modified multiple times as program execution proceeds.

Think of a variable as a labeled box: the label on the box is the Variable Name, and the item kept inside the box is the Variable Value. For instance, executing LET MARKS = 85 places the integer 85 into the memory container named MARKS. If we later execute LET MARKS = 92, the previous value 85 is overwritten by 92.

QBASIC strictly categorizes variables based on the type of data they are designed to store:

• Numeric Variables: Designed exclusively to hold numbers upon which mathematical operations can be performed (e.g., AGE, SALARY, TOTAL, X). Attempting to assign text to a numeric variable triggers a Type Mismatch error.
• String Variables: Designed to store alphanumeric text strings. In QBASIC, a string variable name must always terminate with a dollar sign ($) (e.g., NAME$, CITY$, SUBJECT$, GRADE$). For example: LET NAME$ = "Sourav Ganguly".

To ensure valid syntax, variable names in QBASIC must strictly adhere to these fundamental rules:

1. A variable name must begin with an alphabetic letter (A–Z). It cannot begin with a number or symbol (e.g., NUM1 is valid; 1NUM is invalid).
2. A variable name can consist of letters, digits, and an optional type-declaration suffix character (like $ for strings).
3. No blank spaces or special punctuation characters (such as -, @, #, .) are allowed within the name (e.g., ROLL_NO or ROLLNO is valid; ROLL NO is invalid).
4. A variable name cannot be a Reserved Keyword (such as PRINT, INPUT, CLS, LET, END) because QBASIC reserves these words for commands.
5. Variable names can be up to 40 characters in length and are case-insensitive (Marks and MARKS refer to the exact same variable).

CLS (Clear Screen): Clears all previous text, graphics, and prompts from the output screen. It is standard industry practice to make CLS the very first executable line of every QBASIC program so the user sees a pristine, uncluttered display screen.

REM (Remark): Used to insert explanatory notes, documentation, author credits, and comments inside source code. The interpreter ignores everything written after REM on that line during execution. An apostrophe (') can be used as a convenient shorthand for REM. Example:
CLS
REM Program to Calculate Area of Rectangle
' Author: Class 7 Student

The LET statement assigns a constant value, another variable's contents, or the evaluated result of a mathematical expression to a designated variable.

Syntax: LET <variable_name> = <value or expression>
Examples:

• LET R = 7 (Stores 7 in numeric variable R)
• LET PI = 3.14159 (Stores decimal value in PI)
• LET AREA = PI * R * R (Computes $\pi r^2$ and stores the product in AREA)
• LET GREETING$ = "Welcome to Computer Science!"

The INPUT statement allows a running program to pause, prompt the user via the keyboard, and store the user's keystroke response into one or more specified variables.

Syntax: INPUT "Optional Prompt Message"; <variable>
Examples:

• INPUT "Enter your name: "; STUDENT$ $\rightarrow$ Displays the prompt string followed by a question mark, pauses execution, and stores user input into STUDENT$.
• INPUT "Enter length and breadth: "; L, B $\rightarrow$ Allows inputting multiple numeric values separated by a comma.

The PRINT statement displays text strings, variable contents, and calculated values on the output monitor. QBASIC provides two crucial punctuation separators that control on-screen layout:

• Comma (,) – Tabular Print Zones: QBASIC divides the screen horizontally into standard print zones of 14 characters each. When items in a PRINT statement are separated by commas, each item begins at the next 14-column zone tab. Example: PRINT "Roll", "Name", "Marks" displays headers in neat, tabular columns.
• Semicolon (;) – Compact Inline Display: Separating items with a semicolon suppresses wide spacing, printing the next item immediately after the preceding item with only a single space between numbers. Example: PRINT "Total Score = "; SCORE prints Total Score = 95 compactly on one line.
• A blank PRINT statement outputs an empty line, useful for creating visual paragraph spacing.

An Operator is a special symbol that directs the computer to perform specific arithmetic, comparison, or logical calculations upon values (operands).

Evaluation Hierarchy (Precedence): Parentheses () $\rightarrow$ Exponentiation ^ $\rightarrow$ Multiplication & Division * / $\rightarrow$ Integer Division \ $\rightarrow$ Modulus MOD $\rightarrow$ Addition & Subtraction + - $\rightarrow$ Relational Operators $\rightarrow$ Logical Operators (NOT $\rightarrow$ AND $\rightarrow$ OR).

By default, computer programs follow a Sequential Flow—statements execute line-by-line in exact chronological order from top to bottom. However, solving real-world challenges requires two additional fundamental control structures:

1. Selection (Conditional Branching): Executing specific blocks of code only when certain conditions evaluate to TRUE (e.g., granting a discount only if total bill exceeds ₹1000).
2. Iteration (Looping): Repeating a sequence of instructions multiple times until a terminating condition is met (e.g., printing numbers 1 to 100).

The IF...THEN...ELSE statement tests a relational or logical condition. If the condition is true, the statements under THEN are executed; if false, the statements under ELSE are executed.

Block Syntax:

IF <condition> THEN
    [statements to execute if true]
ELSE
    [statements to execute if false]
END IF

The FOR...NEXT loop is an entry-controlled counter loop used to repeat a block of code a specified number of times.

Syntax:

FOR counter = start_value TO end_value [STEP increment]
    [loop body statements]
NEXT counter

• Counter Variable: A numeric variable that automatically tracks the current iteration.
• STEP Clause: Optional. Specifies the step value by which the counter increases (or decreases) on each cycle. If omitted, default step is +1. Using STEP 2 skips odd numbers; using STEP -1 creates a countdown loop.

A properly structured QBASIC program follows the universal IPO (Input $\rightarrow$ Process $\rightarrow$ Output) paradigm:

1. Header & Setup: CLS and REM documentation.
2. Input Stage: INPUT statements to acquire dynamic user data.
3. Processing Stage: LET statements and mathematical/logical operations.
4. Output Stage: PRINT statements presenting human-readable results.
5. Termination: END to gracefully halt the interpreter.

The END statement marks the physical and logical completion of a QBASIC program. It halts program execution and returns control to the QBASIC editor window.

Good Coding Habits for Class 7 Exams: Always indent statements inside IF blocks and FOR loops for readability; choose meaningful variable names (like RADIUS rather than just R); provide friendly prompt messages in INPUT; and write brief explanatory REM comments explaining what the program accomplishes.