Computer Networking

A computer is an electronic machine capable of performing rapid calculations and data processing. However, unlike human beings, a computer possesses no innate intelligence or common sense; it cannot act independently. To execute any task, it requires a clear, step-by-step sequence of instructions provided by a human user. This human-to-machine communication is made possible through Computer Languages (also known as Programming Languages).

• Instruction (নির্দেশ): A command given to the computer's central processor to perform a specific fundamental operation (such as adding two numbers or moving a value from memory into a register).
• Program (প্রোগ্রাম): A logically organized, sequential collection of instructions written in a programming language designed to solve a specific problem or achieve a designated outcome.
• Programmer (প্রোগ্রামার): The individual who designs, writes, tests, and maintains computer programs.
• Programming (প্রোগ্রামিং): The complete intellectual and technical process of formulating an algorithm, coding it into a programming language, testing, and debugging it.
• Syntax (সিনট্যাক্স): The strict grammatical rules, punctuation, and structural conventions that govern how statements must be written in a specific programming language.
• Semantics (অর্থতত্ত্ব / সিম্যান্টিকস): The actual meaning, logic, and operational outcome of a syntactically correct statement when executed by the computer processor.

Computer languages have evolved dramatically over decades, moving progressively from raw electronic hardware switches toward natural human language and artificial intelligence. This evolutionary pathway is classified into five distinct generations:

Machine Language is the lowest and most elementary programming language. It is the only language that a computer's Central Processing Unit (CPU) can understand and execute directly without needing any translator.

• Binary Representation: Instructions and data are written entirely in binary code, consisting strictly of strings of 0s and 1s (e.g., 10110000 01100001). In digital electronics, '0' represents low electrical voltage (OFF) and '1' represents high electrical voltage (ON).
• Direct Execution: Because it matches the CPU's native instruction set, execution speed is the fastest possible with zero translation overhead.
• Hardware Dependency (যন্ত্র-নির্ভর): Machine language is strictly hardware-dependent. An instruction set written for an Intel x86 processor will not execute on an ARM or Motorola chip.
• Severe Disadvantages: Writing code in strings of 0s and 1s is excruciatingly tedious, virtually unreadable to humans, highly prone to typographical errors, and extremely difficult to debug or modify. Programmers had to memorize hundreds of numeric binary hardware opcodes and exact physical memory addresses.

To eliminate the harrowing nightmare of writing raw binary strings, computer scientists in the early 1950s created Assembly Language. It introduced human-readable symbolic codes called Mnemonics (উচ্চারণযোগ্য সংকেত) to replace numeric binary opcodes.

• Mnemonic Codes: Instead of writing binary patterns like 00000100 for addition, programmers write concise English-like shorthand codes such as ADD (addition), SUB (subtraction), MOV (move data), MUL (multiply), and JMP (jump to address).
• Symbolic Memory Addressing: Instead of specifying physical binary memory addresses (e.g., 1100101001110000), programmers can assign descriptive symbolic labels to memory locations, such as NUM1, TOTAL, or RESULT.
• Requires a Translator: Because the CPU still only understands binary pulses, an assembly program cannot run directly. It requires a specialized translator program called an Assembler to convert mnemonic statements into machine code.
• Hardware Dependency: Like machine language, assembly language is still considered a Low-Level Language (LLL) because each mnemonic directly corresponds to a specific CPU architecture instruction. It is not portable to different processor families.

Emerging in the late 1950s and 1960s, High-Level Languages (HLL) revolutionized computer science by decoupling programming from underlying machine hardware architectures.

• English-Like Statements & Mathematical Notation: Programs are written using familiar English vocabulary words (e.g., print, if, else, while, input) combined with standard mathematical operators (+, -, *, /).
• Machine Independence & Portability: A high-level program written on one computer can be executed on completely different computer hardware platforms with minimal or no modification.
• Translator Requirement: High-level source code must be translated into binary machine code before execution, utilizing either a Compiler or an Interpreter.
• Prominent Examples:
  • FORTRAN (Formula Translation - 1957): Developed by John Backus at IBM, the first commercial high-level language, engineered for scientific, mathematical, and engineering calculations.
  • COBOL (Common Business-Oriented Language - 1959): Spearheaded by Grace Hopper, tailored for corporate accounting, payroll, and banking databases.
  • BASIC (Beginner's All-purpose Symbolic Instruction Code - 1964): Created by John Kemeny and Thomas Kurtz at Dartmouth College to teach programming to beginners.
  • C (1972): Developed by Dennis Ritchie at Bell Labs; a powerful, efficient structured language used to build operating systems (including UNIX and Windows).
  • C++ (1983): Developed by Bjarne Stroustrup, extending C with Object-Oriented features.
  • Java (1995): Created by James Gosling at Sun Microsystems with the philosophy "Write Once, Run Anywhere" (WORA).
  • Python (1991): Created by Guido van Rossum; celebrated for its clean, readable syntax and extensive versatility across data science, web development, and AI.

While 3GLs are procedural (the programmer must specify step-by-step HOW the computer must achieve the result), Fourth Generation Languages (4GL) are primarily declarative or non-procedural.

• Focus on 'WHAT' Rather than 'HOW': In a 4GL, the user simply describes what output data is needed, and the underlying database management engine determines the optimal mathematical steps to retrieve it.
• Human Orientation & Productivity: Designed to allow non-specialist business managers, database administrators, and researchers to query vast datasets without writing hundreds of lines of procedural loops.
• Key Example: Structured Query Language (SQL): To find all students who scored above 90 marks from a table of 100,000 records, one writes a simple declarative query:

  SELECT name, marks FROM students WHERE marks > 90;

• Other examples include database report generators, Oracle Forms, SAS, and ABAP.

Fifth Generation Languages (5GL) represent the cutting edge of programming, designed around Artificial Intelligence (AI), neural computing, natural language processing (NLP), and automated constraint satisfaction.

• Constraint and Rule-Based Solving: Rather than coding an algorithm, the programmer feeds the system a collection of facts, rules, and constraints. When a user asks a query, the inference engine applies formal mathematical logic to deduce the answer.
• Natural Language Interfaces: Users can interact with computers using human conversational sentences rather than rigid programming syntax.
• Key Examples: Prolog (Programming in Logic), Mercury, and expert systems engines.

Computer hardware possesses a fundamental physical limitation: the Central Processing Unit (CPU) is built from millions of microscopic transistors that act as binary electronic switches. Consequently, the CPU can only execute binary machine code (sequences of 0s and 1s). It has zero comprehension of English words like print, if, or assembly mnemonics like ADD.

Therefore, any program written in assembly or high-level language must be converted into machine language before the computer can run it. Specialized system software programs that perform this conversion are called Language Translators (or Language Processors).

An Assembler is a language translator designed specifically for Second Generation Languages (2GL). Its sole responsibility is to translate assembly language mnemonics into machine language binary code.

• It maps each assembly mnemonic (e.g., ADD AX, BX) into its exact binary machine opcode (e.g., 00000001 11011000).
• It replaces symbolic labels and variable names with concrete memory addresses.
• It outputs an object code file ready for execution on that specific CPU architecture.

A Compiler is a sophisticated system program that translates an entire high-level language source program into machine language (object code) all at once in a single comprehensive batch operation.

• Batch Translation: The compiler reads the entire source code file from beginning to end, analyzes its syntax, checks variable types, and translates the whole program into machine code in one pass.
• Permanent Executable Generation: It generates a permanent object file (.obj) which is linked to produce a standalone executable file (.exe). Once compiled, the user can run the .exe file repeatedly without needing the compiler or the original source code.
• Comprehensive Error Reporting: The compiler does not halt at the first mistake. Instead, it scans the entire program and displays a complete list of all detected syntax errors along with their corresponding line numbers at the end of compilation.
• Execution Speed: Execution is blazingly fast because the CPU executes pre-built machine code directly without any translation overhead during runtime.
• Examples of Compiled Languages: C, C++, Rust, Go, FORTRAN. (Note: Java utilizes a hybrid approach: the Java compiler javac compiles source code into intermediate Bytecode, which is subsequently interpreted or JIT-compiled by the Java Virtual Machine).

An Interpreter is an alternative language processor that translates and executes high-level source code line-by-line (statement-by-statement) in real-time during program execution.

• Line-by-Line Execution: The interpreter takes the first line of source code, translates it into machine code, and immediately instructs the CPU to execute it. Only after the first line finishes does it move to the second line.
• Immediate Error Halt: If the interpreter encounters a syntax error or runtime violation on line 25, it halts program execution immediately and reports the exact line number with an error message. Lines 1 through 24 have already been executed, while lines 26 onward remain unread.
• No Standalone Object File: The interpreter does not generate a permanent .exe or .obj file on disk. Every single time the program is run, the original source code must be interpreted line-by-line from scratch.
• Execution Speed & Debugging: Execution is significantly slower than compiled code because translation happens dynamically during runtime. However, debugging is remarkably interactive and beginner-friendly because errors are caught instantly at the exact statement where they occur.
• Examples of Interpreted Languages: Python, JavaScript, Ruby, PHP, standard BASIC.

Before an architect constructs a skyscraper, they prepare detailed blueprints; before an author writes a book, they create a chapter outline. Similarly, in computer science, a programmer never starts writing code directly in a programming language. Instead, they first formulate a precise, logical plan called an Algorithm.

Definition: An Algorithm is a well-defined, finite sequence of unambiguous, step-by-step instructions designed to solve a specific computational problem or perform a designated calculation.

The word Algorithm originates from the name of the 9th-century Persian mathematician Muhammad ibn Musa al-Khwarizmi, who established the foundations of algebra and systematic arithmetic procedures.

Renowned computer scientist Professor Donald Knuth established that every valid, professional algorithm must strictly satisfy five core criteria:

1. Finiteness (সসীমতা): An algorithm must always terminate after a finite, countable number of steps. An algorithm that loops infinitely without ever stopping is flawed and invalid.
2. Definiteness (সুনির্দিষ্টতা): Every individual step must be precisely, clearly, and unambiguously defined. There must be zero ambiguity about what operation is to be performed.
3. Input (ইনপুট): An algorithm must accept zero or more well-defined inputs from an external source (e.g., numbers, strings).
4. Output (আউটপুট): An algorithm must produce at least one or more well-defined outputs (the final result or solution to the problem) that bear a direct relation to the inputs.
5. Effectiveness (কার্যকারিতা / বাস্তবায়নযোগ্যতা): Every operation specified in an algorithm must be sufficiently basic that it can be carried out exactly and in a finite amount of time, even using basic paper and pencil.

Step 1: START
Step 2: INPUT three numbers A, B, and C
Step 3: CALCULATE Sum = A + B + C
Step 4: CALCULATE Average = Sum / 3
Step 5: DISPLAY Sum and Average
Step 6: STOP

Step 1: START
Step 2: INPUT an integer N
Step 3: CALCULATE Remainder = N % 2  (or N MOD 2)
Step 4: IF Remainder == 0 THEN
            PRINT "The number is Even"
        ELSE
            PRINT "The number is Odd"
        ENDIF
Step 5: STOP

Step 1: START
Step 2: INPUT two distinct numbers A and B
Step 3: IF A > B THEN
            PRINT "A is greater than B"
        ELSE IF B > A THEN
            PRINT "B is greater than A"
        ELSE
            PRINT "Both numbers are Equal"
        ENDIF
Step 4: STOP

Step 1: START
Step 2: INPUT three distinct numbers A, B, and C
Step 3: IF (A > B) AND (A > C) THEN
            PRINT "A is the largest number"
        ELSE IF (B > A) AND (B > C) THEN
            PRINT "B is the largest number"
        ELSE
            PRINT "C is the largest number"
        ENDIF
Step 4: STOP

Step 1: START
Step 2: INPUT Principal (P), Rate (R), and Time (T)
Step 3: CALCULATE SI = (P * R * T) / 100
Step 4: CALCULATE Total_Amount = P + SI
Step 5: DISPLAY "Simple Interest =", SI
Step 6: DISPLAY "Total Amount =", Total_Amount
Step 7: STOP

A Flowchart is a graphical or diagrammatic representation of an algorithm. In a flowchart, different geometrical shapes are used to represent different types of computational operations, connected together by directional arrows (flow lines) that clearly trace the flow of control and execution from start to finish.

• Visual Clarity: Complex logical decision structures that might be hard to visualize in textual code become immediately obvious and intuitive in a graphical diagram.
• Universal Communication: Programmers, systems analysts, and non-technical clients can all review and understand the program logic without needing knowledge of specific programming language syntax.
• Error Prevention: Flowcharts expose infinite loops, missing branches, or dead ends before programmers invest time in actual coding.

In the 1960s, the American National Standards Institute (ANSI) and the International Organization for Standardization (ISO) standardized the geometric symbols used across the world in flowchart design:

• Standard Direction: The general flow of execution should proceed strictly from top to bottom or left to right.
• Entry & Exit Points:
  • The START terminal symbol has only one exit line and zero incoming lines.
  • The STOP terminal symbol has only incoming lines and zero exit lines.
  • A Process (rectangle) symbol has one incoming line and one outgoing line.
  • A Decision (diamond) symbol has one incoming line and at least two outgoing lines (labeled 'Yes'/'No' or 'True'/'False').
• No Overlapping Lines: Flow lines must never cross or intersect one another. If flow lines threaten to intersect, use an on-page circle connector.
• Language-Neutral Text: The text written inside symbols must be concise, crisp, and independent of specific programming syntax.

Below are the formal architectural traces of the core syllabus flowcharts:

     [ ( START ) ]  (Terminal: Oval)
           │
           ▼
     [/ INPUT N /]  (Input: Parallelogram)
           │
           ▼
     [ Rem = N % 2 ]  (Process: Rectangle)
           │
           ▼
        ╱     ╲
       ╱  Rem  ╲   (Decision: Diamond)
       ╲  == 0?╱
        ╲     ╱
        ╱     ╲
   YES ╱       ╲ NO
      ▼         ▼
[/ PRINT "Even" /]   [/ PRINT "Odd" /]  (Output: Parallelogram)
      │         │
      └────┬────┘
           │
           ▼
     [ ( STOP ) ]  (Terminal: Oval)

As software systems grew in complexity, computer scientists developed distinct philosophical paradigms for organizing code:

• Procedural Programming (POP): Focuses on writing procedures or functions that perform operations on data. The primary emphasis is on the action (verb). Data moves freely from function to function throughout the program, making it less secure in large-scale applications. Examples include C, Pascal, BASIC, and FORTRAN.
• Object-Oriented Programming (OOP): Focuses on modeling real-world entities as Objects. An object binds data (attributes) and methods (functions) together into a secure, cohesive unit. OOP is built upon four foundational pillars:
  1. Encapsulation (এনক্যাপসুলেশন): Wrapping data and code together into a single unit (class) to prevent unauthorized external access.
  2. Inheritance (ইনহেরিট্যান্স): The mechanism by which a new class can inherit features from an existing class, promoting code reuse.
  3. Polymorphism (পলিমরফিজম): The ability of a single function or operator to exhibit different behaviors based on input context.
  4. Abstraction (অ্যাবস্ট্রাকশন): Displaying only essential features to the user while concealing complex internal background implementation details.
  Prominent examples include Java, C++, Python, and C#.

Every computer program in existence, regardless of complexity, is constructed using combinations of only three fundamental control structures:

1. Sequence (অনুক্রম): Instructions are executed one after another in a linear, sequential order exactly as written in the source code.
2. Selection / Branching (নির্বাচন / শর্ত): Program execution branches into different pathways based on the evaluation of a boolean condition (e.g., if-else, switch-case).
3. Iteration / Looping (পুনরাবৃত্তি / লুপ): A designated block of instructions is executed repeatedly as long as a specified condition remains true (e.g., for loop, while loop).

An error in a computer program is universally referred to as a Bug, and the systematic process of discovering and correcting these errors is known as Debugging. Program errors fall into three fundamental categories:

A Syntax Error occurs when the programmer violates the formal grammatical rules, punctuation, or spelling rules of the programming language.

• Examples: Misspelling a reserved keyword (e.g., writing prnt("Hello") instead of print("Hello")), missing semicolons in C/C++, unmatched closing parentheses (a + b, or using illegal variable names.
• Detection: Syntax errors are detected automatically by the Compiler or Interpreter during the translation phase before the program can run. The program will not execute until all syntax errors are resolved.

A Runtime Error occurs while the program is actively executing. The program is syntactically flawless and compiles successfully, but during execution, it encounters an illegal or impossible condition that forces the operating system to abruptly crash the program.

• Examples:
  • Division by Zero: Attempting to divide a number by zero (e.g., x = 25 / 0), which is mathematically undefined.
  • File Not Found: Instructing the program to open and read a data file from disk that does not exist.
  • Out of Memory / Stack Overflow: Running out of RAM due to an uncontrolled recursive function.
• Detection: Caught during active program execution; causes abnormal program termination.

A Logical Error (also known as a Semantic Bug) is the most deceptive and dangerous type of programming error. The program contains no syntax errors and runs without crashing; however, due to a flaw in the programmer's algorithmic logic, it produces wrong, unexpected, or unintended output.

• Examples:
  • Writing Average = A + B + C / 3 instead of Average = (A + B + C) / 3 (operator precedence causes only C to be divided by 3).
  • Using the wrong relational operator, such as writing if (A < B) when looking for the maximum number.
  • Writing a loop with an incorrect boundary condition that runs 11 times instead of 10 (an off-by-one error).
• Detection: Translators cannot detect logical errors because computers cannot read human intentions! They can only be caught through diligent testing with test data, dry running, and manual variable tracing.