Thanks to visit codestin.com
Credit goes to github.com

Skip to content

This repository I will write all of basic knowledge about programming. Here I will write about the topics that are common in every programming language.

Notifications You must be signed in to change notification settings

shahidul50/Programming-Basic-Knowledge

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

4 Commits
 
 

Repository files navigation

Programming Basic Knowledge

āφāĻŽāϰāĻž āϝāĻžāϰāĻž Programming āĻļ⧇āĻ–āĻžāϰ āϚāĻŋāĻ¨ā§āϤāĻž āĻ•āϰāĻ›āĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āĻŽāύ⧇ āĻ…āύ⧇āĻ• āϧāϰāϪ⧇āϰ āĻĒā§āϰāĻļā§āύ āϘ⧁āϰāĻĒāĻžāĻ• āĻ–āĻžā§ŸāĨ¤ āφāĻŽāĻŋāĻ“ āϝāĻ–āύ Programming āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĻ›āĻŋāϞāĻžāĻŽ āϤāĻ–āύ āφāĻŽāĻžāϰāĻ“ āϏāĻ•āϞ⧇āϰ āĻŽāϤ āĻāχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻŽāĻžāĻĨāĻžā§Ÿ āφāϏāϤāĨ¤ āϏ⧇āχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡āχ āφāϜāϕ⧇āϰ āĻāχ Article āϟāĻŋ āϞāĻŋāĻ–āĻŦāĨ¤ āĻāχ Article āϟāĻŋ āĻĒ⧜āϞ⧇ āĻāĻ•āϜāύ Beginner āĻšāĻŋāϏ⧇āĻŦ⧇ āφāĻŽāĻžāϰāĻž Programming āύāĻŋā§Ÿā§‡ āĻ…āύ⧇āĻ• āĻ•āĻŋāϛ⧁ āϜāĻžāύāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤ āĻāχ āϏāĻ•āϞ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āφāĻŽāĻžāĻĻ⧇āϰ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻŽā§āĻ–āĻ¸ā§āϤ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āύāĻžāĨ¤ āĻāϗ⧁āϞ⧋ āĻĒ⧜āϞ⧇ Programming āύāĻŋā§Ÿā§‡ āĻāĻ•āϟāĻž āĻ­āĻžāϞ Overview āĻĒāĻžāĻŦ āϝ⧇āϟāĻž āφāĻŽāĻžāĻĻ⧇āϰ āĻ­āĻŦāĻŋāĻˇā§āϝāϤ⧇ āĻ…āύ⧇āĻ• āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āĻŦ⧇āĨ¤ āϤāĻžāχ āϚāϞ⧁āύ āφāϰ āĻĻ⧇āϰāĻŋ āύāĻž āĻ•āϰ⧇ āĻļ⧁āϰ⧁ āĻ•āϰāĻŋāĨ¤ Programming āĻļ⧇āĻ–āĻžāϰ āφāϗ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āϝ⧇āϏāĻ•āϞ āĻŦāĻŋāώ⧟ āϜāĻžāύāĻž āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āϤāĻž āύāĻŋā§Ÿā§‡ āĻāĻ–āĻžāύ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšāĻŦ⧇:

Table of Contents

  • Computer āĻ•āĻŋ?

  • Computer āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇?

  • Program āĻ•āĻŋ?

  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Program āĻāϰ āϧāĻžāϰāĻŖāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻāϞ⧋?

  • Programming āĻ•āĻŋ?

  • Programming Language āĻŦāϞāϤ⧇ āĻ•āĻŋ āĻŦ⧁āĻāĻžā§Ÿ?

  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Programming āĻļ⧇āĻ–āĻž āφāϰ Programming Language āĻļ⧇āĻ–āĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϕ⧀?

  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Programming āĻļ⧇āĻ–āĻžāϰ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻž āĻ•āĻŋ āĻ•āĻŋ?

  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ Programming āĻāϰ āĻĒā§āϰāĻ•āĻžāϰāϭ⧇āĻĻ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇?

  • Machine āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Assembly āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Mid Level āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • High Level āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Machine Code āĻāĻŦāĻ‚ Byte Code āĻ•āĻŋ?

  • Assembler āĻ•āĻŋ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Compiler āĻ•āĻŋ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Interpreter āĻ•āĻŋ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Compiler āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Interpreter āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • JIT(Just-In-Time) Compiler āĻ•āĻŋ? āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āϕ⧋āĻĨāĻžā§Ÿ āĻšā§Ÿ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • JIT(Just-In-Time) Compiler āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Token āĻ•āĻŋ?

  • Keyword āĻ•āĻŋ? Keyword āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Identifier āĻ•āĻŋ? Identifier āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? Identifier āϤ⧈āϰāĻŋāϰ āύāĻŋ⧟āĻŽāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Literal āĻ•āĻŋ? Identifier āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϧāϰāύ āϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Statement āĻ•āĻŋ?

  • Expression āĻ•āĻŋ?

  • Syntax āĻ•āĻŋ?

  • Algorithm āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϟāĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āϕ⧇āύ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ?

  • Pseudo Code āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

  • Bug āĻ•āĻŋ ? Debug āĻ•āĻŋ?

  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Programming āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻāĻ•āϟāĻŋ Problem āĻāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻž āϝāĻžā§Ÿ?

  • āĻāĻ•āϜāύ Beginner āĻšāĻŋāϏ⧇āĻŦ⧇ "āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻāϰ āφāĻĻā§āϝ⧋āĻĒā§āϰāĻžāĻ¨ā§āϤ" āĻŦāχāϟāĻŋ āφāĻŽāϰāĻž āϕ⧇āύ āĻĒ⧜āĻŦ?

  • Computer āĻ•āĻŋ?

    Computer āĻšāϞ āĻāĻ•āϟāĻŋ Electronics Device āϝāĻž Data āĻ—ā§āϰāĻšāĻŖ, āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāĻŖ āĻāĻŦāĻ‚ āφāωāϟāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āϤāĻĨā§āϝ āϏāϰāĻŦāϰāĻžāĻš āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Program āĻŦāĻž Instructions(āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻžāϰ) āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ āĻ“ āύāĻŋāĻ°ā§āϭ⧁āϞāĻ­āĻžāĻŦ⧇ āĻ—āĻŖāύāĻž, āϤāĻĨā§āϝ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻāĻŦāĻ‚ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāĻŖ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽāĨ¤

    Computer āĻĒā§āϰāϧāĻžāύāϤ āϚāĻžāϰāϟāĻŋ āĻ…āĻ‚āĻļ⧇ āĻŦāĻŋāĻ­āĻ•ā§āϤ:

    1. Input Unit ⇒ Data āĻŦāĻž Information(āϤāĻĨā§āϝ) Computer āĻ āĻĒā§āϰāĻŦ⧇āĻļ āĻ•āϰāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āϝ⧇āĻŽāύ: Keyboard, Mouse āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    2. Processing Unit(CPU) ⇒ āĻāϟāĻŋ āĻŽāĻ¸ā§āϤāĻŋāĻˇā§āϕ⧇āϰ āĻŽāϤ⧋ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻāĻŦāĻ‚ Data āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāĻŖ āĻ•āϰ⧇āĨ¤
    3. Memory(RAM, Storage) ⇒ Data āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ Access āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤
    4. Output Unit ⇒ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāϜāĻžāϤ āϤāĻĨā§āϝāϕ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰ āĻ•āĻžāϛ⧇ Display(āĻĒā§āϰāĻĻāĻ°ā§āĻļāύ āĻ•āϰ⧇)āĨ¤ āϝ⧇āĻŽāύ: Monitor, Printer āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Computer āϕ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĻ⧁āχ āĻ­āĻžāϗ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āϝāĻžāϝāĻŧ:

    1. Hardware ⇒ āϝāĻž āĻļāĻžāϰ⧀āϰāĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻĻ⧃āĻļā§āϝāĻŽāĻžāύ āĻāĻŦāĻ‚ āĻ¸ā§āĻĒāĻ°ā§āĻļāϝ⧋āĻ—ā§āϝāĨ¤
    2. Software ⇒ āϝāĻž āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻŦāĻž āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āφāĻ•āĻžāϰ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

    Computer āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ•āĻžāĻœā§‡ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ, āϝ⧇āĻŽāύ: āϞ⧇āĻ–āĻžāϞ⧇āĻ–āĻŋ, Design, Programming, Database Management, āϝ⧋āĻ—āĻžāϝ⧋āĻ— āĻāĻŦāĻ‚ āĻŦāĻŋāύ⧋āĻĻāύ āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤


  • Computer āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇?

    Computer āĻāĻ•āϟāĻŋ āϏ⧁āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϧāĻžāĻĒ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Input, Processing, Storage, āĻāĻŦāĻ‚ Output - āĻāχ āϚāĻžāϰāϟāĻŋ āĻĒā§āϰāϧāĻžāύ āϧāĻžāĻĒ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āĻžāĻ°ā§āϝ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰ⧇āĨ¤ āύāĻŋāĻšā§‡ āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻĒā§āϰāĻŖāĻžāϞ⧀ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšāϞ⧋:

    1. Input Stage

    Computer āĻ•āĻžāϜ āĻļ⧁āϰ⧁ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻĒā§āϰāĻĨāĻŽā§‡ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰ āĻ•āĻžāĻ› āĻĨ⧇āϕ⧇ Data āĻŦāĻž Instruction(āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž) āĻ—ā§āϰāĻšāĻŖ āĻ•āϰ⧇āĨ¤ āĻāχ āϧāĻžāĻĒāϟāĻŋ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰāϤ⧇ Input Device āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻ•āĻŋāϛ⧁ āϏāĻžāϧāĻžāϰāĻŖ Input Device āĻšāϞ⧋:

    • Keyboard ⇒ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ Keyboard āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Computer āĻāϰ āϤāĻĨā§āϝ āĻĒā§āϰāĻŦāĻžāĻšāĻŋāϤ āĻ•āϰ⧇āύāĨ¤ āϝ⧇āĻŽāύ, āϞ⧇āĻ–āĻž, Command, āϏāĻ‚āĻ–ā§āϝāĻž āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    • Mouse ⇒ Mouse āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž Computer āĻāϰ Screen āĻ Objects(āϝ⧇āĻŽāύ Icon) āύāĻŋāĻ°ā§āĻŦāĻžāϚāύ āĻ•āϰāĻŋ, Drag āĻ•āϰāĻŋ, āĻŦāĻž Click āĻ•āϰ⧇ āϕ⧋āύ⧋ Action Complete āĻ•āϰāĻŋāĨ¤
    • Microphone ⇒ Voice Input āĻĻ⧇āϝāĻŧāĻžāϰ āϜāĻ¨ā§āϝ Microphone āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
    • Scanner/Camera ⇒ Image, Document āĻŦāĻž āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ Visual Input Device āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϤāĻĨā§āϝ Computer āĻ āĻĒā§āϰāĻŦāĻžāĻšāĻŋāϤ āĻšāϝāĻŧāĨ¤

    āϝ⧇āĻ­āĻžāĻŦ⧇ Input āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āσ

    • āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ Data āϏāϰāĻŦāϰāĻžāĻš āĻ•āϰ⧇ Keyboard, Mouse, Microphone, Camera āχāĻ¤ā§āϝāĻžāĻĻāĻŋ Input Device āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡āĨ¤
    • Input Device āϏāϰāĻŦāϰāĻžāĻšāĻ•ā§ƒāϤ Data āϕ⧇ Digital Format āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇āĨ¤
    • āĻāχ Data āϤāĻžāϰāĻĒāϰ Processing Unit āĻ āĻĒāĻžāĻ āĻžāύ⧋ āĻšāϝāĻŧāĨ¤

    āωāĻĻāĻžāĻšāϰāĻŖ:

    • Keyboard āĻ "A" Typed āĻ•āϰāϞ⧇ ASCII Code āφāĻ•āĻžāϰ⧇ āĻāϟāĻŋ Processing Unit āĻ āϝāĻžāϝāĻŧāĨ¤
    • Mouse Click āĻ•āϰāϞ⧇ āϤāĻžāϰ Position āĻāϰ āϤāĻĨā§āϝ Processor āĻāϰ āĻ•āĻžāϛ⧇ āϝāĻžāϝāĻŧāĨ¤

    2. Processing Stage

    Input Data, Processing Unit(CPU) āĻ āĻĒāĻžāĻ āĻžāύ⧋ āĻšāϝāĻŧāĨ¤ CPU-āχ Computer āĻāϰ āĻĒā§āϰāϧāĻžāύ āĻ•āĻžāϜāϗ⧁āϞ⧋ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰ⧇āĨ¤

    CPU-āĻāϰ āĻ•āĻžāϜ

    CPU āĻŦāĻž Central Processing Unit āϤāĻŋāύāϟāĻŋ āĻ…āĻ‚āĻļ āύāĻŋāϝāĻŧ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇:

    1. Control Unit(CU)
      • āϏāĻŽāĻ¸ā§āϤ Device āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽ āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰ⧇āĨ¤
      • Input āĻĨ⧇āϕ⧇ Data āύāĻŋāϝāĻŧ⧇ āϕ⧋āĻĨāĻžāϝāĻŧ āĻĒāĻžāĻ āĻžāϤ⧇ āĻšāĻŦ⧇ āϤāĻž āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇āĨ¤
      • āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰ⧇āĨ¤
    2. Arithmetic Logic Unit(ALU)
      • āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āĻ—āĻŖāύāĻž (āϝ⧇āĻŽāύ āϝ⧋āĻ—, āĻŦāĻŋāϝāĻŧā§‹āĻ—) āĻāĻŦāĻ‚ Logical Operation(āϝ⧇āĻŽāύ āϤ⧁āϞāύāĻž āĻ•āϰāĻž, āĻļāĻ°ā§āϤ āϝāĻžāϚāĻžāχ āĻ•āϰāĻž) āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰ⧇āĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: āϝāĻĻāĻŋ "2 + 2" āĻšāϝāĻŧ, ALU āĻāχ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āĻŖāϝāĻŧ āĻ•āϰāĻŦ⧇āĨ¤
    3. Register āĻ“ Cache Memory
      • āĻ…āĻ¸ā§āĻĨāĻžāϝāĻŧā§€āĻ­āĻžāĻŦ⧇ Data āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤
      • CPU āϝāĻ–āύ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāϪ⧇āϰ āϜāĻ¨ā§āϝ Data āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϤāĻ–āύ āĻāϟāĻŋ Register āĻ āĻĨāĻžāϕ⧇āĨ¤

    āωāĻĻāĻžāĻšāϰāĻŖ

    • āϝāĻĻāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āϕ⧋āύ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āϝ⧋āĻ— āĻ•āϰāϤ⧇ āĻŦāϞ⧇ (āϝ⧇āĻŽāύ 5 + 3), CPU āϏ⧇āχ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋ ALU-āϤ⧇ āĻĒāĻžāĻ āĻŋāϝāĻŧ⧇ āĻĢāϞāĻžāĻĢāϞ āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇āĨ¤
    • Email Check āĻ•āϰāĻžāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇, CPU āϏāĻžāϰāĻž Internet āĻĨ⧇āϕ⧇ Data Process āĻ•āϰ⧇ āĻāĻŦāĻ‚ Output āφāĻ•āĻžāϰ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤
    1. Memory and Storage Stage

      Processing āϚāϞāĻžāĻ•āĻžāϞ⧀āύ āĻāĻŦāĻ‚ āĻĒāϰ⧇ Data āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Memory āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ āĻĻ⧁āχ āϧāϰāύ⧇āϰ āĻšāϤ⧇ āĻĒāĻžāϰ⧇:

      1. Primary Memory(RAM)
        • āĻ…āĻ¸ā§āĻĨāĻžāϝāĻŧā§€ Memory āϝāĻž āĻĻā§āϰ⧁āϤ Data Access āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤
        • Processing āϚāϞāĻžāĻ•āĻžāϞ⧇ Data āĻāĻ–āĻžāύ⧇ āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ āĻĨāĻžāϕ⧇āĨ¤
      2. Secondary Storage
        • āĻĻā§€āĻ°ā§āϘāĻŽā§‡āϝāĻŧāĻžāĻĻā§€ āϏāĻ‚āϰāĻ•ā§āώāϪ⧇āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤
        • āωāĻĻāĻžāĻšāϰāĻŖ: Hard Drive(HDD), Solid State Drive(SSD), USB Drive āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

      āωāĻĻāĻžāĻšāϰāĻŖ

      • āĻāĻ•āϟāĻŋ Video Play āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ Video Data RAM-āĻ Load āĻšāϝāĻŧ āĻāĻŦāĻ‚ Processing āĻļ⧇āώ⧇ āĻĢāϞāĻžāĻĢāϞ āĻĻ⧇āĻ–āĻžāύ⧋ āĻšāϝāĻŧāĨ¤
      • āϝāĻ–āύ āϕ⧋āύ⧋ Document Save āĻ•āϰāĻž āĻšāϝāĻŧ, āϤāĻ–āύ āĻāϟāĻŋ Hard Drive āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ āĻšāϝāĻŧāĨ¤
    2. Output Stage

      Processing āĻļ⧇āώ āĻšāϞ⧇ āĻĢāϞāĻžāĻĢāϞ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰ āĻ•āĻžāϛ⧇ āĻĒ⧌āρāϛ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ Output Device āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϘāĻŸā§‡āĨ¤ āϝ⧇āĻŽāύ:

      • Monitor ⇒ Data āĻŦāĻž āϤāĻĨā§āϝ Screen āĻ āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤
      • Printer ⇒ Document Print āĻ•āϰ⧇āĨ¤
      • Speaker ⇒ Audio āφāĻ•āĻžāϰ⧇ āϤāĻĨā§āϝ āϏāϰāĻŦāϰāĻžāĻš āĻ•āϰ⧇āĨ¤

      āωāĻĻāĻžāĻšāϰāĻŖ:

      • āĻ•ā§āϝāĻžāϞāϕ⧁āϞ⧇āϟāϰ⧇ 5 + 3 āϞāĻŋāϖ⧇ "Enter" āϚāĻžāĻĒāϞ⧇ Output āĻ 8 Monitor āĻ Display(āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŋāϤ) āĻšāϝāĻŧāĨ¤
      • āĻāĻ•āϟāĻŋ Image(āĻ›āĻŦāĻŋ) āϏāĻŽā§āĻĒāĻžāĻĻāύāĻž āĻ•āϰāĻžāϰ āĻĒāϰ āϏ⧇āχ Image āϟāĻŋ Monitor āĻ āĻĻ⧇āĻ–āĻžāύ⧋ āĻšāϝāĻŧāĨ¤
    3. Feedback Stage

      Output āĻĻ⧇āĻ–āĻžāϰ āĻĒāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āφāĻŦāĻžāϰ āύāϤ⧁āύ āϕ⧋āύ⧋ Input āĻĻāĻŋāϞ⧇ āϏ⧇āϟāĻŋ āφāĻŦāĻžāϰ Input Stage āĻ āϚāϞ⧇ āϝāĻžāϝāĻŧ āĻāĻŦāĻ‚ āĻĒ⧁āϰ⧋ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻĒ⧁āύāϰāĻžāϝāĻŧ āĻļ⧁āϰ⧁ āĻšāϝāĻŧāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ: āφāĻŽāϰāĻž āĻāĻ•āϟāĻŋ Game āϖ⧇āϞāϞ⧇, āϏ⧇āĻ–āĻžāύ⧇ āĻĒā§āϰāϤāĻŋāϟāĻŋ Click āĻŦāĻž Movement Feedback āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    4. Software

      Computer āĻāϰ Hardware āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āϤāĻĨā§āϝ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ Software āϤāĻžāϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻĻ⧇āϝāĻŧ āĻāĻŦāĻ‚ āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤ Software āĻšāϞ Computer āĻāϰ Program āĻŦāĻž Application āϝāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āϏāĻšāĻžāϝāĻŧāĻ• āĻšāϝāĻŧāĨ¤ Software āĻĻ⧁āϟāĻŋ āĻ­āĻžāϗ⧇ āĻŦāĻŋāĻ­āĻ•ā§āϤ:

      • System Software ⇒ āĻāϟāĻŋ Hardware āĻāĻŦāĻ‚ Application Software āĻāϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ• āĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰ⧇, āϝ⧇āĻŽāύ Operating System(Windows, Linux, MacOS).
      • Application Software ⇒ āĻāϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ, āϝ⧇āĻŽāύ Microsoft Office, Graphics Design Software āĻŦāĻž Internet Browse āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Computer āĻāĻ•āϟāĻŋ āϜāϟāĻŋāϞ āϝāĻ¨ā§āĻ¤ā§āϰ āϝāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āωāĻĒāĻžāĻĻāĻžāύ āĻĻā§āĻŦāĻžāϰāĻž āĻ•āĻžāϜ āĻ•āϰ⧇: Input Device, Processing Unit, Storage, Output Device āĻāĻŦāĻ‚ Software. āĻāχ āωāĻĒāĻžāĻĻāĻžāύāϗ⧁āϞāĻŋ āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āϏāĻžāĻĨ⧇ āϏāĻŽāĻ¨ā§āĻŦāϝāĻŧ āĻ•āϰ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āϝāĻžāϤ⧇ Computer āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


  • Program āĻ•āĻŋ?

    Program āĻšāϞ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļ⧇āώ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Computer āĻāϰ āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž Code āĻāϰ āĻāĻ•āϟāĻŋ Set āĻŦāĻž āϏāĻ‚āĻ—ā§āϰāĻšāĨ¤ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āϤ⧈āϰāĻŋ āĻ•āϰāĻž Command āĻŦāĻž āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻžāϗ⧁āϞāĻŋāϰ āϏāĻŽāĻˇā§āϟāĻŋāĨ¤ Program āϟāĻŋ Computer āĻŦāĻž āĻ…āĻ¨ā§āϝ āϕ⧋āύ⧋ āϝāĻ¨ā§āĻ¤ā§āϰ⧇ Run āĻ•āϰāĻž āĻšā§Ÿ āĻāĻŦāĻ‚ āĻāϟāĻŋ āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰ⧇āĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    • āĻāĻ•āϟāĻŋ āĻ—āĻŖāύāĻž Program āϝāĻž āĻĻ⧁āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϝ⧋āĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻŦ⧇āĨ¤
    • āĻāĻ•āϟāĻŋ Word Processor Program(āϝ⧇āĻŽāύ Microsoft Word), āϝāĻž āφāĻŽāϰāĻž Document āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŋāĨ¤

    āĻāĻ–āĻžāύ⧇ Program āĻšāϞ āϏ⧇āχ Code āĻŦāĻž Software āϝāĻž Computer āϕ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϕ⧋āύ⧋ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻā§‡ā§ŸāĨ¤ Computer āĻāĻ•āϟāĻŋ Program āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŋāϤ āϝāĻ¨ā§āĻ¤ā§āϰāĨ¤ Program āĻ›āĻžā§œāĻž Computer āĻĻāĻŋā§Ÿā§‡ āϕ⧋āύ āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžā§Ÿ āύāĻžāĨ¤ Program āĻŦāĻŋāĻšā§€āύ Computer āĻāĻ•āϟāĻŋ āĻ•āĻ°ā§āĻŽāĻšā§€āύ āύāĻŋāĻ°ā§āĻœā§€āĻŦ āϜ⧜ āĻŦāĻ¸ā§āϤ⧁ āĻ›āĻžā§œāĻž āφāϰ āĻ•āĻŋāϛ⧁āχ āύ⧟āĨ¤ Computer āĻĻāĻŋā§Ÿā§‡ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻšāϞ⧇ āϏ⧇āχ āĻ•āĻžāĻœā§‡āϰ āωāĻĒāϝ⧋āĻ—ā§€ Program āĻāϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§ŸāĨ¤

    āĻāĻ›āĻžā§œāĻž Computer āĻāĻ•āϟāĻŋ Electronics āϝāĻ¨ā§āĻ¤ā§āϰāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ Electronics āϝāĻ¨ā§āĻ¤ā§āϰ⧇āϰ āĻŽāϤ Computer āϕ⧇āĻŦāϞ āĻŦāĻŋāĻĻā§āϝ⧁āϤ⧇āϰ āωāĻĒāĻ¸ā§āĻĨāĻŋāϤāĻŋ āφāϰ āĻ…āύ⧁āĻĒāĻ¸ā§āĻĨāĻŋāϤāĻŋ āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻŦāĻŋāĻĻā§āϝ⧁āϤ⧇āϰ āωāĻĒāĻ¸ā§āĻĨāĻŋāϤāĻŋāϕ⧇ Binary Number 1 āφāϰ āĻ…āύ⧁āĻĒāĻ¸ā§āĻĨāĻŋāϤāĻŋāϕ⧇ Binary Number 0 āĻĻā§āĻŦāĻžāϰāĻž āĻŦ⧁āĻāĻžāύ⧋ āĻšā§ŸāĨ¤ āĻāĻ•āϗ⧁āĻšā§āĻ› Binary Number 0 āĻ“ 1 āĻĻā§āĻŦāĻžāϰāĻž āĻāĻ• āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻ—āĻ āĻŋāϤ āĻšā§Ÿ, āϝāĻž āĻĻā§āĻŦāĻžāϰāĻž Computer āϕ⧋āύ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ Computer āĻāϰ āĻŦā§‹āϧāĻ—āĻŽā§āϝ āĻāϰ⧁āĻĒ āĻ…āϏāĻ‚āĻ–ā§āϝ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĒāϰāĻĒāϰ āϏāĻžāϜāĻŋā§Ÿā§‡ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ Program āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϧāϰāϪ⧇āϰ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰ⧇ āϤāĻĨāĻž āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϧāϰāϪ⧇āϰ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ Binary 0 āĻ“ 1 āĻĻā§āĻŦāĻžāϰāĻž āϝ⧇ āϏāĻ•āϞ Program āϞ⧇āĻ–āĻž āĻšā§Ÿ āϤāĻž Computer āϏāϰāĻžāϏāϰāĻŋ āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāϜāĻ¨ā§āϝ āĻ āĻ­āĻžāώāĻžāϕ⧇ Computer āĻāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻ­āĻžāώāĻž āĻŦāϞāĻž āĻšā§ŸāĨ¤ āĻāϟāĻžāϕ⧇ Machine āĻ­āĻžāώāĻž āĻŦāĻž āϝāĻžāĻ¨ā§āĻ¤ā§āϰāĻŋāĻ• āĻ­āĻžāώāĻžāĻ“ āĻŦāϞāĻž āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤ āĻŦāĻŋāĻœā§āĻžāĻžāύ⧀āĻĻ⧇āϰ āĻ…āĻ•ā§āϞāĻžāĻ¨ā§āϤ āĻĒāϰāĻŋāĻļā§āϰāĻŽā§‡āϰ āĻĢāϞ⧇ Machine āĻ­āĻžāώāĻž āĻŦāĻž āϝāĻžāĻ¨ā§āĻ¤ā§āϰāĻŋāĻ• āĻ­āĻžāώāĻž āĻ›āĻžā§œāĻžāĻ“ āφāϰāĻ“ āĻ…āύ⧇āĻ• āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻ­āĻžāώāĻžāϰ āϏ⧃āĻˇā§āϟāĻŋ āĻšā§Ÿā§‡āϛ⧇āĨ¤ āĻāχ āϏāĻ•āϞ āĻ­āĻžāώāĻžā§Ÿ 0 āĻ“ 1 āĻāϰ āĻĒāϰāĻŦāĻ°ā§āϤāĻŋāϤ⧇ āϏāĻžāϧāĻžāϰāĻŖ āĻ­āĻžāώāĻž(āχāĻ‚āϰ⧇āϜāĻŋ āĻ­āĻžāώāĻžāϰ) āĻļāĻŦā§āĻĻāĻžāĻŦāϞ⧀ āĻĒā§āĻ°ā§Ÿā§‹āĻ— āĻ•āϰ⧇ Computer āĻ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĒā§āϰāϧāĻžāύ āĻ•āϰāĻž āϝāĻžā§Ÿ āϤāĻĨāĻž Program āϰāϚāύāĻž āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤ Computer āĻāϰ āĻŦā§‹āϧāĻ—āĻŽā§āϝ āĻāϰ⧁āĻĒ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāĻŽāĻžāϞāĻžāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āϤ⧈āϰāĻŋ āĻšā§Ÿ āĻāĻ• āĻāĻ•āϟāĻŋ Program. Program āĻāĻŦāĻ‚ Program āĻāϰ āϏāĻŽāĻˇā§āϟāĻŋāϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ Software.


  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Program āĻāϰ āϧāĻžāϰāĻŖāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻāϞ⧋?

    Program āĻŦāĻž Programming āĻāϰ āϧāĻžāϰāĻŖāĻž āĻāĻ•āϟāĻŋ āĻĻā§€āĻ°ā§āϘ āχāϤāĻŋāĻšāĻžāϏ⧇āϰ āĻĢāϞ, āϝāĻž āĻ—āĻŖāύāĻž āĻāĻŦāĻ‚ Algorithmic āϚāĻŋāĻ¨ā§āϤāĻž āĻĨ⧇āϕ⧇ āϧ⧀āϰ⧇ āϧ⧀āϰ⧇ āφāϧ⧁āύāĻŋāĻ• Computer Science āĻ“ Software Development āĻ āĻĒāϰāĻŋāĻŖāϤ āĻšā§Ÿā§‡āϛ⧇āĨ¤ āĻāϰ āĻĒ⧇āĻ›āύ⧇ āĻ…āύ⧇āĻ• āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ• āϚāĻŋāĻ¨ā§āϤāĻž āĻ“ āφāĻŦāĻŋāĻˇā§āĻ•āĻžāϰ āĻ°ā§Ÿā§‡āϛ⧇, āĻāĻŦāĻ‚ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϝ⧁āϗ⧇ āĻ—āĻŖāύāĻž āĻāĻŦāĻ‚ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āύāϤ⧁āύ āĻĒāĻĻā§āϧāϤāĻŋāϰ āĻŽāĻ§ā§āϝ⧇ āĻŦāĻŋāĻ•āĻļāĻŋāϤ āĻšā§Ÿā§‡āϛ⧇āĨ¤

    āύāĻŋāĻšā§‡ Program āĻāĻŦāĻ‚ Programming āĻāϰ āχāϤāĻŋāĻšāĻžāϏ āφāϰāĻ“ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšāϞ:

    1. āĻĒā§āϰāĻĨāĻŽ āĻ—āĻŖāύāĻž āϝāĻ¨ā§āĻ¤ā§āϰ⧇āϰ āϧāĻžāϰāĻŖāĻž:

      āĻĒā§āϰāĻžāĻšā§€āύ āĻ•āĻžāϞ āĻĨ⧇āϕ⧇āχ āĻŽāĻžāύ⧁āώ āĻ—āĻŖāύāĻž āĻāĻŦāĻ‚ āĻĒāϰāĻŋāĻŽāĻžāĻĒ⧇āϰ āϜāĻ¨ā§āϝ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϝāĻ¨ā§āĻ¤ā§āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤāĨ¤ āĻāϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĒ⧁āϰ⧋āύ⧋ āĻāĻŦāĻ‚ āĻĒāϰāĻŋāϚāĻŋāϤ āϝāĻ¨ā§āĻ¤ā§āϰāϗ⧁āϞāĻŋāϰ āĻŽāĻ§ā§āϝ⧇ āφāĻŦāĻžāĻ•āĻžāϏ (Abacus) āĻ…āĻ¨ā§āϝāϤāĻŽ, āϝāĻž āĻ–ā§āϰāĻŋāĻ¸ā§āϟāĻĒā§‚āĻ°ā§āĻŦ ⧍ā§Ļā§Ļā§Ļ āϏāĻžāϞ⧇āĻ“ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϤ⧋āĨ¤ āϝāĻĻāĻŋāĻ“ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Mechanical Device, āϤāĻŦ⧇ āĻāϟāĻŋ āϕ⧋āύāĻ“ Programming Language āĻ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āϞāĻŋāϖ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āĻŽāϤ⧋ āĻ•āĻŋāϛ⧁ āĻ›āĻŋāϞ āύāĻžāĨ¤ āϤāĻŦ⧇ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ—āĻŖāύāĻž āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āύāĻŋ⧟āĻŽ āĻāĻŦāĻ‚ āϧāĻžāĻĒ āĻ›āĻŋāϞ, āϝ⧇āϗ⧁āϞāĻŋ āĻĒāϰ⧇ Programming āĻāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāĻœā§‡ āĻāϏ⧇āϛ⧇āĨ¤

    2. Charles Babbage(āϚāĻžāĻ°ā§āϞāϏ āĻŦā§āϝāĻžāĻŦ⧇āϜ) āĻāĻŦāĻ‚ āĻĒā§āϰāĻĨāĻŽ Mechanical Computer:

      Charles Babbage ā§§ā§Žā§Šā§Ļ-āĻāϰ āĻĻāĻļāϕ⧇ āĻĒā§āϰāĻĨāĻŽ Difference Engine Design āĻ•āϰ⧇āύ, āϝāĻž āĻāĻ•āϟāĻŋ Mechanical Computer āĻ›āĻŋāϞ āĻāĻŦāĻ‚ āĻ—āĻŖāύāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϤāĨ¤ Babbage āĻāϰ āĻāχ āĻĒā§āϰāĻ•āĻ˛ā§āĻĒ āĻ›āĻŋāϞ āĻāĻ•āϟāĻŋ āĻŦ⧜ āĻĒāĻĻāĻ•ā§āώ⧇āĻĒ āĻ—āĻŖāύāĻž āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāϕ⧇ Automatic(āĻ¸ā§āĻŦ⧟āĻ‚āĻ•ā§āϰāĻŋ⧟) āĻ•āϰāĻžāϰ āĻĻāĻŋāϕ⧇āĨ¤ Babbage āĻāϰ āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ Analytical Engine Design āĻ•āϰ⧇āύ, āϝāĻž āĻāĻ•āϟāĻŋ āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋ āωāĻĻā§āĻ­āĻžāĻŦāύ⧀ Design āĻ›āĻŋāϞāĨ¤ āĻāϟāĻŋ āĻ›āĻŋāϞ āĻāĻ•āϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āωāĻĻā§āĻĻ⧇āĻļā§āϝ⧇āϰ Computer āϝāĻž Binary Code āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĻ›āĻŋāϞ āĻāĻŦāĻ‚ Programable āĻ›āĻŋāϞāĨ¤ āĻāχ Analytical Engine -āĻāϰ āϜāĻ¨ā§āϝ Babbage āĻāϰ āĻĒā§āϰāĻĨāĻŽ Programming āϧāĻžāϰāĻŖāĻžāϟāĻŋ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšā§Ÿā§‡āĻ›āĻŋāϞ, āϝ⧇āĻ–āĻžāύ⧇ Machine āϟāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻšāϤ⧇ āĻĒāĻžāϰāϤ āϝāĻĻāĻŋ āϤāĻžāϕ⧇ āϏāĻ āĻŋāĻ• Instruction āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϤāĨ¤

    3. Ada Lovelace(āĻ…ā§āϝāĻžāĻĄāĻž āϞāĻžāĻ­āϞ⧇āϏ):

      Ada Lovelace, Charles Babbage āĻāϰ āϏāĻšāϝ⧋āĻ—ā§€, āĻ›āĻŋāϞ⧇āύ āĻĒā§āϰāĻĨāĻŽ āĻŦā§āϝāĻ•ā§āϤāĻŋ āϝāĻŋāύāĻŋ Computer Programming āĻāϰ āϧāĻžāϰāĻŖāĻžāϕ⧇ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻŦ⧁āĻāϤ⧇ āĻāĻŦāĻ‚ āĻĒā§āϰāĻŽāĻžāĻŖ āĻ•āϰāϤ⧇ āĻĒ⧇āϰ⧇āĻ›āĻŋāϞ⧇āύāĨ¤ āϤāĻŋāύāĻŋ Analytical Engine āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻŋ Program āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϤ⧈āϰāĻŋ āĻ•āϰ⧇āύ, āϝāĻž ā§§ā§Žā§Ēā§Š āϏāĻžāϞ⧇ āĻāĻ•āϟāĻŋ āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āϏāĻŋāϰāĻŋāϜ āĻ—āĻŖāύāĻž āĻ•āϰāĻŦ⧇āĨ¤ Ada Lovelace āϤāĻžāϰ Program āĻ āĻĒā§āϰāĻĨāĻŽā§‡ Babbage āĻāϰ Machine āĻ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Logical Instructions āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āύ āĻāĻŦāĻ‚ Machine āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏ⧇āχ Instruction āϕ⧇ āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āĻžāύ⧋āϰ āĻāĻ•āϟāĻŋ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰ⧇āύāĨ¤ āĻāχ āĻ•āĻžāϜāϟāĻŋāϕ⧇ āχāϤāĻŋāĻšāĻžāϏ⧇āϰ āĻĒā§āϰāĻĨāĻŽ "Computer Program" āĻšāĻŋāϏ⧇āĻŦ⧇ āϧāϰāĻž āĻšā§ŸāĨ¤ āϤāĻžāϰ āĻ•āĻžāϜ āφāϜāϕ⧇āϰ āĻĻāĻŋāύ⧇ Programing āĻāϰ Algorithm āĻŦāĻž Coding Language āĻāϰ āĻŽā§‚āϞ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰ⧇āĨ¤

    4. Turing Machine āĻāĻŦāĻ‚ āϤāĻ¤ā§āĻ¤ā§āĻŦāĻ—āϤ āĻ­āĻŋāĻ¤ā§āϤāĻŋ:

      āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ āĻŦāĻŋāĻļā§āĻŦāϝ⧁āĻĻā§āϧ⧇āϰ āϏāĻŽā§Ÿ, āĻāϞāĻžāύ āϟāĻŋāωāϰāĻŋāĻ‚ (Alan Turing) ā§§ā§¯ā§Šā§Ŧ āϏāĻžāϞ⧇ āĻāĻ•āϟāĻŋ āϤāĻžāĻ¤ā§āĻ¤ā§āĻŦāĻŋāĻ• Model āĻĒā§āϰāĻ¸ā§āϤāĻžāĻŦ āĻ•āϰ⧇āύ, āϝāĻžāϰ āύāĻžāĻŽ Turing Machine. Turing Machine āĻāĻ•āϟāĻŋ āĻŽā§ŒāϞāĻŋāĻ• āĻ—āĻŖāύāĻž āϝāĻ¨ā§āĻ¤ā§āϰ⧇āϰ Model āϝāĻž Algorithm āĻŦāĻž Program āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āϤāĻžāϰ āϤāĻžāĻ¤ā§āĻ¤ā§āĻŦāĻŋāĻ• āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻĻā§‡ā§ŸāĨ¤ āĻāϟāĻŋ āĻĒā§āϰāĻŽāĻžāĻŖ āĻ•āϰ⧇āĻ›āĻŋāϞ āϝ⧇, āϕ⧋āύ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Program āĻŦāĻž Algorithm āϝāĻĻāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻĨāĻžāϕ⧇, āϤāĻŦ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϝāĻ¨ā§āĻ¤ā§āϰ āĻŦāĻž Machine (āϝ⧇āĻŽāύ Computer) āϏ⧇āχ Program āϟāĻŋ āϚāĻžāϞāĻžāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤ āĻāϟāĻŋ āĻ—āĻŖāύāĻž āϤāĻ¤ā§āĻ¤ā§āĻŦ āĻāĻŦāĻ‚ Computer Science āϕ⧇ āĻāĻ•āϟāĻŋ āϤāĻžāĻ¤ā§āĻ¤ā§āĻŦāĻŋāĻ• āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇, āĻāĻŦāĻ‚ Program āĻāϰ āϧāĻžāϰāĻŖāĻžāϕ⧇ āĻ—āĻ­ā§€āϰāĻ­āĻžāĻŦ⧇ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰ⧇āĨ¤

    5. Machine Code āĻāĻŦāĻ‚ Assembly Language:

      ⧧⧝ā§Ēā§Ļ-āĻāϰ āĻĻāĻļāĻ• āĻĨ⧇āϕ⧇ Computer Electrically āϤ⧈āϰāĻŋ āĻšāϤ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĻ›āĻŋāϞ, āĻāĻŦāĻ‚ āĻāχ āϏāĻŽā§Ÿ āĻĨ⧇āϕ⧇āχ Computer āĻ Machine Code āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϤāĨ¤ Machine Code āĻ›āĻŋāϞ āĻāĻ•āϟāĻŋ Computer āĻŦāĻž āϝāĻ¨ā§āĻ¤ā§āϰ⧇āϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ, Binary Language(0 āĻāĻŦāĻ‚ 1) āϝāĻž Execute āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Computer āĻāϰ Program āĻ›āĻŋāϞāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ Machine Code āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāĻž āĻ›āĻŋāϞ āϖ⧁āĻŦāχ āĻ•āĻ āĻŋāύ, āϤāĻžāχ āφāϏ⧇āĻŽā§āĻŦāϞāĻŋ āĻ­āĻžāώāĻž (Assembly Language) āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϞ, āϝāĻž Machine Code āĻāϰ āĻāĻ•āϟāĻŋ āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž āĻ›āĻŋāϞ āĻāĻŦāĻ‚ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰāĻž āφāϰāĻ“ āϏāĻšāĻœā§‡ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāϤ⧇āύāĨ¤ āφāϏ⧇āĻŽā§āĻŦāϞāĻŋ āĻ­āĻžāώāĻžā§Ÿ, Computer āĻāϰ Memory āĻ“ Register āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāϪ⧇āϰ āϜāĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ Code āĻ›āĻŋāϞ, āϝāĻž Code āϞ⧇āĻ–āĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāϕ⧇ āĻ…āύ⧇āĻ• āϏāĻšāϜ āĻ•āϰ⧇āĻ›āĻŋāϞāĨ¤ āĻāϟāĻŋ āĻ›āĻŋāϞ āĻŽā§‚āϞāϤ Programming āĻāϰ āĻĒā§āϰāĻĨāĻŽ āϧāĻžāĻĒ, āϝ⧇āĻ–āĻžāύ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰāĻž āϏāϰāĻžāϏāϰāĻŋ Code āϞāĻŋāϖ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāϤ⧇āύāĨ¤

    6. āĻĒā§āϰāĻĨāĻŽ āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ Programming āĻ­āĻžāώāĻž:

      ⧧⧝ā§Ģā§Ļ-āĻāϰ āĻĻāĻļāϕ⧇ āĻĒā§āϰāĻĨāĻŽ āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ­āĻžāώāĻž āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšā§Ÿ, āϝ⧇āĻŽāύ FORTRAN, āϝāĻž āĻŽā§‚āϞāϤ āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ• āĻ“ āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āĻ—āĻŖāύāĻž āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϤāĨ¤ āĻāϰāĻĒāϰ COBOL āĻāĻŦāĻ‚ LISP āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϤ⧈āϰāĻŋ āĻšā§Ÿ, āϝāĻž āφāϰāĻ“ āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻāĻŦāĻ‚ āϜāύāĻĒā§āϰāĻŋ⧟ āĻšā§Ÿā§‡ āĻ“āϠ⧇āĨ¤ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ Man-Machine Interface āϤ⧈āϰāĻŋ āĻ•āϰ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ Code āϞ⧇āĻ–āĻžāϰ āϏāĻŽā§Ÿ āĻ…āύ⧇āĻ•āϟāĻž āĻĒā§āϰāĻ•ā§ƒāϤ āĻ­āĻžāώāĻžāϰ āĻŽāϤ⧋ āĻ­āĻžāĻŦāϤ⧇ āĻĒāĻžāϰāϤāĨ¤ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ Code āϞ⧇āĻ–āĻž āĻ…āύ⧇āĻ• āϏāĻšāϜ āĻāĻŦāĻ‚ āĻ—āϤāĻŋāĻŽā§Ÿ āĻšā§Ÿā§‡ āĻ“āϠ⧇āĨ¤

    7. Computer āĻāĻŦāĻ‚ Programming āĻāϰ āφāϧ⧁āύāĻŋāĻ• āϝ⧁āĻ—:

      ⧧⧝⧭ā§Ļ-ā§Žā§Ļ āĻĻāĻļāĻ• āĻĨ⧇āϕ⧇ Computer Technology(āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋ) āĻŦā§āϝāĻžāĻĒāĻ•āĻ­āĻžāĻŦ⧇ āĻŦ⧃āĻĻā§āϧāĻŋ āĻĒ⧇āϤ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĨ¤ Programming Language āϗ⧁āϞ⧋āϰ āϏāĻ‚āĻ–ā§āϝāĻž āĻāĻŦāĻ‚ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ āφāϰāĻ“ āϏāĻŽā§ƒāĻĻā§āϧ āĻšāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤ āύāϤ⧁āύ āύāϤ⧁āύ Language āϝ⧇āĻŽāύ āϏāĻŋ (C), āĻĒāĻžāχāĻĨāύ (Python), āϜāĻžāĻ­āĻž (Java), āϜāĻžāĻ­āĻžāĻ¸ā§āĻ•ā§āϰāĻŋāĻĒā§āϟ (JavaScript) āχāĻ¤ā§āϝāĻžāĻĻāĻŋ Computer Science āĻ“ Software Development āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰāϕ⧇ āĻŦā§āϝāĻžāĻĒāĻ•āĻ­āĻžāĻŦ⧇ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰ⧇āĨ¤ āĻāχ Language āϗ⧁āϞāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āĻĻ⧇āϰ āϜāĻ¨ā§āϝ āφāϰāĻ“ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀, āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀-āĻŦāĻžāĻ¨ā§āϧāĻŦ āĻāĻŦāĻ‚ āĻĻāĻ•ā§āώ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻžāϰ āϏ⧁āϝ⧋āĻ— āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇āĨ¤ āĻāĻ›āĻžā§œāĻžāĻ“ Object Oriented Programming(OOP), Functional Programming, Logical Programming āĻāĻŦāĻ‚ Declarative Programming āĻāϰ āĻŽāϤ Paradigm āϗ⧁āϞ⧋āϰ āωāĻĻā§āĻ­āĻŦ āϘāĻŸā§‡, āϝāĻž Programming āĻāϰ Structure(āĻ—āĻ āύ) āĻāĻŦāĻ‚ Language(āĻ­āĻžāώāĻž) āϤ⧈āϰāĻŋ āĻ•āϰāĻžāϰ āĻĒāĻĻā§āϧāϤāĻŋāϕ⧇ āφāϰāĻ“ āĻ—āϤāĻŋāĻļā§€āϞ āĻ“ āύāĻŽāĻ¨ā§€ā§Ÿ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤

    8. āφāϜāϕ⧇āϰ āĻĻāĻŋāύ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽā§‡āϰ āϧāĻžāϰāĻŖāĻž:

      āφāϜāϕ⧇āϰ āĻĻāĻŋāύ⧇ Program āĻšāϞ āĻāĻ•āĻžāϧāĻŋāĻ• Code āĻāϰ āĻāĻ•āϟāĻŋ āϏāĻ‚āĻ•āϞāύ āϝāĻž Computer āϕ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Instruction(āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž) āĻĻā§‡ā§ŸāĨ¤ āĻāϟāĻŋ āϏāϰāĻžāϏāϰāĻŋ Software, Application, Website, Game, Database āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āϤ⧈āϰāĻŋāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ Programming āĻšāϞ āϏ⧇āχ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž, āϝāĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāĻ•āϟāĻŋ Program āϤ⧈āϰāĻŋ āĻšā§Ÿ āĻāĻŦāĻ‚ āϏ⧇āϟāĻž āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžā§Ÿāύ āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻ…āĻ¨ā§āϝāĻĻāĻŋāϕ⧇, Machine Learning, Artificial Intelligence(AI) āĻāĻŦāĻ‚ Big Data āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋāϰ āωāĻĻā§āĻ­āĻŦ⧇āϰ āϏāĻžāĻĨ⧇ Programming āĻāϰ āϧāĻžāϰāĻŖāĻžāĻ“ āφāϰāĻ“ āϜāϟāĻŋāϞ āĻ“ Intelligence āĻšā§Ÿā§‡ āωāĻ āϛ⧇āĨ¤

    āϏ⧁āϤāĻžāϰāĻžāĻ‚, Program āĻāϰ āϧāĻžāϰāĻŖāĻž āĻŽā§‚āϞāϤ āĻ—āĻŖāύāĻž āĻāĻŦāĻ‚ Algorithm āĻĨ⧇āϕ⧇ āĻ‰ā§ŽāĻĒāĻ¨ā§āύ āĻšā§Ÿā§‡āϛ⧇, āϝāĻž āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ• āφāĻŦāĻŋāĻˇā§āĻ•āĻžāϰ āĻ“ Computer āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋāϰ āĻ…āĻ—ā§āϰāĻ—āϤāĻŋāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāϧ⧁āύāĻŋāĻ• Programming Language āĻāĻŦāĻ‚ Software āĻ āĻĒāϰāĻŋāĻŖāϤ āĻšā§Ÿā§‡āϛ⧇āĨ¤ Charles Babbage, Ada Lovelace, Alan Turing āĻāĻŦāĻ‚ āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ Machine Code āĻĨ⧇āϕ⧇ āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāϤāĻŋāϟāĻŋ āϝ⧁āĻ— Program āĻāĻŦāĻ‚ Programming āĻāϰ āϧāĻžāϰāĻŖāĻžāϕ⧇ āφāϰāĻ“ āĻĒāϰāĻŋāĻļā§€āϞāĻŋāϤ āĻ•āϰ⧇āϛ⧇, āϝāĻž āφāϜāϕ⧇āϰ āĻĻāĻŋāύ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āĻĻ⧈āύāĻ¨ā§āĻĻāĻŋāύ āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻ…āĻ¨ā§āϝāϤāĻŽ āĻ…āĻŦāĻŋāĻšā§āϛ⧇āĻĻā§āϝ āĻ…āĻ‚āĻļāĨ¤


  • Programming āĻ•āĻŋ?

    Programming āĻšāϞ āϏ⧇āχ Process āĻŦāĻž āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āϝāĻž āĻĻāĻŋā§Ÿā§‡ āφāĻŽāϰāĻž āĻāĻ•āϟāĻŋ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻŋāĨ¤ āĻāϟāĻŋ āĻšāϞ Code āϞ⧇āĻ–āĻž, Logic āϤ⧈āϰāĻŋ āĻ•āϰāĻž, āĻāĻŦāĻ‚ Computer āĻāϰ āĻ­āĻžāώāĻžā§Ÿ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāĨ¤ Programming āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž Program āϤ⧈āϰāĻŋ āĻ•āϰāĻŋ, āϝāĻž āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ Computer āĻŦāĻž āĻ…āĻ¨ā§āϝ Device āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Execute(āĻ•āĻžāĻ°ā§āϝāĻ•āϰ) āĻ•āϰāĻž āĻšā§ŸāĨ¤

    • Program āĻšāĻšā§āϛ⧇ Code āĻāϰ āĻāĻ•āϟāĻŋ Single Unit āϝāĻž āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    • āφāϰ Programing āĻšāĻšā§āϛ⧇ āϏ⧇āχ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāĨ¤

    āϝ⧇āĻŽāύ, āφāĻŽāϰāĻž āĻāĻ•āϟāĻŋ āĻ—āĻŖāύāĻž Program āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āϚāĻžāχ āĻāĻ–āύ āφāĻŽāϰāĻž āĻāχ Program āϟāĻŋ āϤ⧈āϰāĻŋ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Code āϞāĻŋāĻ–āĻŦ, Code āϞ⧇āĻ–āĻžāϰ āĻāχ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāϟāĻžāϕ⧇ āĻŦāϞāĻž āĻšāĻšā§āϛ⧇ Programming.


  • Programming Language āĻŦāϞāϤ⧇ āĻ•āĻŋ āĻŦ⧁āĻāĻžā§Ÿ?

    Programming Language āĻšāϞ⧋ Computer Program āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻ­āĻžāώāĻžāĨ¤ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āύāĻŋ⧟āĻŽāĻžāĻŦāϞāĻŋ āĻŦāĻž Syntax āĻāĻŦāĻ‚ āĻļāĻŦā§āĻĻāĻžāĻŦāϞ⧀(Vocabulary) āĻ…āύ⧁āϏāĻžāϰ⧇ Computer āĻŦāĻž āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ Digital Device āĻāϰ āϏāĻžāĻĨ⧇ āϝ⧋āĻ—āĻžāϝ⧋āĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻ­āĻžāώāĻžāĨ¤ āĻāϟāĻŋāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āĻŦāĻž Developers Computer āϕ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ Instruction(āύāĻŋāĻ°ā§āĻĻ⧇āĻļ) āĻĻā§‡ā§ŸāĨ¤ Programming Language āĻĻāĻŋā§Ÿā§‡ Program āϞ⧇āĻ–āĻž āĻšā§Ÿ, āϝāĻž Computer āϕ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽ āĻ•āϰ⧇āĨ¤ Programming Language āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āφāĻŽāϰāĻž Computer āϕ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāϪ⧇āϰ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻŦāϞāĻŋ, āϝ⧇āĻŽāύ -

    • Calculation(āĻ—āĻŖāύāĻž),
    • Data Processing,
    • User Interface(UI) āϤ⧈āϰāĻŋ,
    • Game Development āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    āĻāĻ•āϟāĻŋ Programming Language āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Computer āϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āϜāĻ¨ā§āϝ āϏāĻžāϧāĻžāϰāĻŖāϤ Syntax āĻāĻŦāĻ‚ Semantics āĻāϰ āύāĻŋāϝāĻŧāĻŽāĻžāĻŦāϞ⧀ āĻ…āύ⧁āϏāϰāĻŖ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

    Programming Language āĻāϰ āĻ•āĻŋāϛ⧁ āωāĻĻāĻžāĻšāϰāĻŖ:

    1. C ⇒ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āĻĒ⧁āϰāύ⧋ āĻāĻŦāĻ‚ āϜāύāĻĒā§āϰāĻŋ⧟ Programming Language āϝāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ System Programming āĻāĻŦāĻ‚ Software Development āĻ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
    2. Python ⇒ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ High Level āĻ­āĻžāώāĻž āϝāĻž āϏāĻšāĻœā§‡ āĻļāĻŋāĻ–āĻž āϝāĻžā§Ÿ āĻāĻŦāĻ‚ Web Development, Data Science āĻāĻŦāĻ‚ āϝ⧇āϕ⧋āύ⧋ āϧāϰāϪ⧇āϰ Software Development āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
    3. Java ⇒ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Object Oriented Programming Language(OOP), āϝāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ Application Development āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ Enterprise Level Application āϤ⧈āϰāĻŋ āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
    4. JavaScript ⇒ āĻāϟāĻŋ Webpage āĻāϰ Interactivity āĻŦāĻžā§œāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āϤāĻŦ⧇ āĻŦāĻ°ā§āϤāĻŽāĻžāύ⧇ āĻāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ…āύ⧇āĻ• āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤
    5. Ruby ⇒ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ High Level Programming Language, āϝāĻž Web Development āĻ āϜāύāĻĒā§āϰāĻŋ⧟āĨ¤

    Programming Language āĻāϰ āϧāϰāύ:

    • Low-level Languages ⇒ āϝ⧇āĻŽāύ Machine Language āĻāĻŦāĻ‚ Assembly Language āϝāĻž āϏāϰāĻžāϏāϰāĻŋ Computer Hardware āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    • High-level Languages ⇒ āϝ⧇āĻŽāύ C, Java, Python, JavaScript, PHP, āϝāĻž āĻŽāĻžāύ⧁āώ⧇āϰ āϜāĻ¨ā§āϝ āĻŦ⧁āĻāϤ⧇ āϏāĻšāϜ, āĻāĻŦāĻ‚ Computer āϕ⧇ āϏāĻšāĻœā§‡āχ āĻŦ⧁āĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤

    Programming Language āĻ Program āϞ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡, āφāĻŽāϰāĻž Computer āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ Software āĻāĻŦāĻ‚ Application āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤


  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Programming āĻļ⧇āĻ–āĻž āφāϰ Programming Language āĻļ⧇āĻ–āĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϕ⧀?

    Programming āĻļ⧇āĻ–āĻž āĻāĻŦāĻ‚ Programming Language āĻļ⧇āĻ–āĻž āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻ•āĻŋāϛ⧁ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ āφāϏ⧁āύ āϏ⧇āϗ⧁āϞ⧋ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤāĻ­āĻžāĻŦ⧇ āĻŦ⧁āĻā§‡ āύ⧇āĻ“ā§ŸāĻž āϝāĻžāĻ•:

    Programming āĻļ⧇āĻ–āĻž:

    • Programming āĻļ⧇āĻ–āĻžāϰ āĻŽā§‚āϞ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ⧋ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϧāĻžāϰāĻŖāĻž āĻ“ āĻĒāĻĻā§āϧāϤāĻŋ āĻļ⧇āĻ–āĻžāĨ¤
    • āĻāϟāĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āϝ⧁āĻ•ā§āϤāĻŋ āĻāĻŦāĻ‚ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻ•ā§ŒāĻļāϞ āωāĻ¨ā§āύāϤ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤ āĻāĻ–āĻžāύ⧇ āφāĻŽāϰāĻž āϕ⧋āύ āĻ­āĻžāώāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻ›āĻŋ, āϤāĻž āϤ⧇āĻŽāύ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āύ⧟āĨ¤
    • Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰāĻŦ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻŽāĻ¸ā§āϝāĻž āĻĨ⧇āϕ⧇ Algorithm āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āĻšā§Ÿ āĻāĻŦāĻ‚ āϏ⧇āϟāĻŋ āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžā§Ÿāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Code āϞāĻŋāĻ–āϤ⧇ āĻšā§ŸāĨ¤
    • āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ, āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϝ⧇āĻŽāύ āĻĻ⧁āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž āϝ⧋āĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻŋ Algorithm āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āĻļ⧇āĻ–āĻžāĨ¤ Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻāϟāĻŋ āĻŦ⧁āĻāϤ⧇ āĻšāĻŦ⧇ āϝ⧇ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻāĻ•āϟāĻŋ āĻ•āĻžāϜ āϏāĻžāϜāĻžāύ⧋ āϝāĻžā§Ÿ, āĻ­āĻžāώāĻž āύāĻž āϚāĻŋāĻ¨ā§āϤāĻž āĻ•āϰ⧇āχāĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž āϤāĻž āĻĒāϰ⧇ āϝ⧇āϕ⧋āύ⧋ āĻ­āĻžāώāĻžā§Ÿ Code āĻ•āϰāĻž āϝāĻžāĻŦ⧇āĨ¤

    Programming Language āĻļ⧇āĻ–āĻž:

    • Programming Language āĻļ⧇āĻ–āĻž āĻŽāĻžāύ⧇ āĻšāϞ⧋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻāĻ•āϟāĻŋ Codding āĻ­āĻžāώāĻž āĻļ⧇āĻ–āĻž, āϝ⧇āĻŽāύ Python, Java, C++ āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    • āĻāĻ–āĻžāύ⧇ āĻŽā§‚āϞāϤ āφāĻŽāϰāĻž āĻļāĻŋāϖ⧇ āĻĨāĻžāĻ•āĻŋ āĻāĻ•āϟāĻŋ āĻ­āĻžāώāĻžāϰ Syntax(āϝ⧇āĻŽāύ āϕ⧀āĻ­āĻžāĻŦ⧇ Code āϞāĻŋāĻ–āϤ⧇ āĻšā§Ÿ), Data Structure āĻāĻŦāĻ‚ Function/Class āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻšā§ŸāĨ¤
    • āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ, āϝāĻĻāĻŋ āφāĻŽāϰāĻž Python āĻļāĻŋāĻ–āĻŋ, āϤāĻŦ⧇ āφāĻŽāϰāĻž Python āĻāϰ Syntax(āϝ⧇āĻŽāύ āϕ⧀āĻ­āĻžāĻŦ⧇ Code āĻ Indention āĻĻāĻŋāϤ⧇ āĻšāĻŦ⧇), āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Datatype(āϝ⧇āĻŽāύ list, tuple), Function āϤ⧈āϰāĻŋ āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āĻļāĻŋāĻ–āĻŦāĨ¤

    āĻāĻ­āĻžāĻŦ⧇ āĻŦāϞāĻž āϝāĻžā§Ÿ, Programming āĻļ⧇āĻ–āĻž āĻ…āύ⧇āĻ•āϟāĻž āĻāĻ•āϟāĻŋ āϧāĻžāϰāĻŖāĻžāĻ—āϤ āĻĻāĻ•ā§āώāϤāĻž āĻ…āĻ°ā§āϜāύ āĻ•āϰāĻž, āϝ⧇āĻ–āĻžāύ⧇ Programming Language āĻļ⧇āĻ–āĻž āĻšāϞ⧋ āϏ⧇āχ āĻĻāĻ•ā§āώāϤāĻžāϕ⧇ āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžā§ŸāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϟ⧁āϞāϏ āĻŦāĻž āĻ­āĻžāώāĻž āĻļ⧇āĻ–āĻžāĨ¤


  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Programming āĻļ⧇āĻ–āĻžāϰ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻž āĻ•āĻŋ āĻ•āĻŋ?

    Programming āĻļ⧇āĻ–āĻžāϰ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻž āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻāĻŦāĻ‚ āĻāϟāĻŋ āĻœā§€āĻŦāύ⧇āϰ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āχāϤāĻŋāĻŦāĻžāϚāĻ• āĻĒā§āϰāĻ­āĻžāĻŦ āĻĢ⧇āϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āύāĻŋāĻšā§‡ āĻ•āĻŋāϛ⧁ āĻĒā§āϰāϧāĻžāύ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻž āϤ⧁āϞ⧇ āϧāϰāĻž āĻšāϞ⧋:

    1. āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻĻāĻ•ā§āώāϤāĻž āĻŦ⧃āĻĻā§āϧāĻŋ ⇒ Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϏāĻŽāĻ¸ā§āϝāĻž āϚāĻŋāĻ¨ā§āϤāĻž āĻ•āϰ⧇ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āĻļāĻŋāĻ–āĻŦāĨ¤ āĻāϟāĻŋ āφāĻŽāĻžāĻĻ⧇āϰ Thinking Process āωāĻ¨ā§āύāϤ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āφāĻŽāϰāĻž āφāϰāĻ“ āĻ•āĻžāĻ°ā§āϝāĻ•āϰāĻ­āĻžāĻŦ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤
    2. Logical āϚāĻŋāĻ¨ā§āϤāĻž āĻ“ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•ā§āώāĻŽāϤāĻž ⇒ Programming āĻļ⧇āĻ–āĻžāϰ āĻĢāϞ⧇ āφāĻŽāĻžāĻĻ⧇āϰ Logical āϚāĻŋāĻ¨ā§āϤāĻž āĻ“ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•ā§āώāĻŽāϤāĻž āωāĻ¨ā§āύāϤ āĻšā§ŸāĨ¤ Code āϞ⧇āĻ–āĻž āĻāĻŦāĻ‚ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āϗ⧇āϞ⧇ āĻĒā§āϰāϤāĻŋāύāĻŋ⧟āϤ āφāĻŽāĻžāĻĻ⧇āϰ Logical āĻ­āĻžāĻŦ⧇ āϚāĻŋāĻ¨ā§āϤāĻž āĻ•āϰāϤ⧇ āĻšā§ŸāĨ¤
    3. āĻĻāĻ•ā§āώāϤāĻž āĻŦ⧃āĻĻā§āϧāĻŋ āĻāĻŦāĻ‚ Career āϏāĻŽā§āĻ­āĻžāĻŦāύāĻž ⇒ āĻŦāĻ°ā§āϤāĻŽāĻžāύ⧇ āĻ…āύ⧇āĻ• āϚāĻžāĻ•āϰāĻŋ, āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ Technology, Engineering āĻāĻŦāĻ‚ Data Science āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āĻ•ā§āώ⧇āĻ¤ā§āϰāϗ⧁āϞ⧋āϤ⧇ Programming āĻĻāĻ•ā§āώāϤāĻžāϰ āϚāĻžāĻšāĻŋāĻĻāĻž āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ Programming āϜāĻžāύāϞ⧇ āφāĻŽāϰāĻž āĻ­āĻžāϞ⧋ āϚāĻžāĻ•āϰāĻŋ āĻĒ⧇āϤ⧇ āĻĒāĻžāϰāĻŋ āĻāĻŦāĻ‚ Career āĻŦāĻŋāĻ•āĻžāĻļ⧇āϰ āϏ⧁āϝ⧋āĻ— āĻĒāĻžāĻŦāĨ¤
    4. āĻ¸ā§āĻŦāĻžāϧ⧀āύ āĻ•āĻžāĻœā§‡āϰ āϏ⧁āϝ⧋āĻ— ⇒ Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž Freelance āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ, āύāĻŋāĻœā§‡ āĻāĻ•āϟāĻŋ āĻŦā§āϝāĻŦāϏāĻž āĻļ⧁āϰ⧁ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ āĻŦāĻž Startup āĻĒā§āϰāϤāĻŋāĻˇā§āĻ āĻž āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤ āĻ…āύ⧇āĻ• Freelancing Platform āĻ Programming āĻĻāĻ•ā§āώāϤāĻžāϰ āϚāĻžāĻšāĻŋāĻĻāĻž āĻ°ā§Ÿā§‡āϛ⧇āĨ¤
    5. āύāϤ⧁āύ āĻ•āĻŋāϛ⧁ āϏ⧃āĻˇā§āϟāĻŋ āĻāĻŦāĻ‚ āωāĻĻā§āĻ­āĻžāĻŦāύ ⇒ Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āύāϤ⧁āύ Software, Application, Game āĻŦāĻž Technology(āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋ) āωāĻĻā§āĻ­āĻžāĻŦāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āĻāϟāĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āϏ⧃āϜāύāĻļā§€āϞāϤāĻž āĻŦāĻžā§œāĻžā§Ÿ āĻāĻŦāĻ‚ āφāĻŽāĻžāĻĻ⧇āϰāϕ⧇ āύāϤ⧁āύ āĻ•āĻŋāϛ⧁ āϤ⧈āϰāĻŋ āĻ•āϰāĻžāϰ āφāĻ—ā§āϰāĻš āĻĻā§‡ā§ŸāĨ¤
    6. āϏāĻŽā§Ÿ āĻāĻŦāĻ‚ āĻ•āĻžāĻœā§‡āϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāύāĻļā§€āϞāϤāĻž āĻŦāĻžā§œāĻžāύ⧋ ⇒ Programming āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āφāĻŽāϰāĻž āĻ…āύ⧇āĻ• āϧāϰāύ⧇āϰ āĻ•āĻžāϜ Automatic āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋ, āϝāĻžāϰ āĻĢāϞ⧇ āϏāĻŽā§Ÿ āĻŦāĻžāρāϚāĻžāύ⧋ āĻāĻŦāĻ‚ āĻ•āĻžāĻœā§‡āϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāύāĻļā§€āϞāϤāĻž āĻŦ⧃āĻĻā§āϧāĻŋ āĻĒāĻžā§ŸāĨ¤ āϝ⧇āĻŽāύ āĻĻ⧈āύāĻ¨ā§āĻĻāĻŋāύ āĻ•āĻžāϜāϗ⧁āϞ⧋ Automated āĻ•āϰ⧇ āĻĻ⧇āĻ“ā§ŸāĻž, Data Analysis āϏāĻšāϜ āĻ•āϰāĻž āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    7. Critical Thinking ⇒ Programming āĻļ⧇āĻ–āĻžāϰ āĻĢāϞ⧇ āφāĻŽāϰāĻž āĻĻā§āϰ⧁āϤ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύāĻŋāϤ⧇ āĻļāĻŋāĻ–āĻŦ āĻāĻŦāĻ‚ āφāĻŽāϰāĻž āĻāĻ•āĻžāϧāĻŋāĻ• āĻĻ⧃āĻˇā§āϟāĻŋāϕ⧋āĻŖ āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻŋ āϏāĻŽāĻ¸ā§āϝāĻžāϕ⧇ āĻĻ⧇āĻ–āϤ⧇ āϏāĻ•ā§āώāĻŽ āĻšāĻŦ, āϝāĻž āφāĻŽāĻžāĻĻ⧇āϰ āϚāĻŋāĻ¨ā§āϤāĻžāϰ āĻ—āĻ­ā§€āϰāϤāĻž āĻāĻŦāĻ‚ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•ā§āώāĻŽāϤāĻž āĻŦāĻžā§œāĻžā§ŸāĨ¤
    8. āĻĻāϞāĻŦāĻĻā§āϧ āĻ•āĻžāĻœā§‡āϰ āĻ•ā§āώāĻŽāϤāĻž ⇒ Programming āĻļāĻŋāĻ–āϞ⧇ āφāĻŽāϰāĻž āĻĻāϞāĻŦāĻĻā§āϧāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϏ⧁āϝ⧋āĻ— āĻĒāĻžāĻŦ, āĻ•āĻžāϰāĻŖ Software Development āĻŦāĻž Programming āĻĒā§āϰāĻ•āĻ˛ā§āĻĒ⧇ āĻāĻ•āĻžāϧāĻŋāĻ• āĻŦā§āϝāĻ•ā§āϤāĻŋ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āϏāĻšāϝ⧋āĻ—āĻŋāϤāĻžāĻŽā§‚āϞāĻ• āĻ•āĻžāĻœā§‡āϰ āĻ•ā§āώāĻŽāϤāĻž āĻŦāĻžā§œāĻžā§ŸāĨ¤
    9. āĻ…āĻ°ā§āĻĨāύ⧈āϤāĻŋāĻ• āĻĻāĻŋāĻ• āĻĨ⧇āϕ⧇ āϏ⧁āĻŦāĻŋāϧāĻž ⇒ Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āĻŦāĻžā§œāϤāĻŋ āĻ†ā§Ÿā§‡āϰ āĻ‰ā§ŽāϏ āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤ āϝ⧇āĻŽāύ, Freelancing, Online Course āϤ⧈āϰāĻŋ, āĻŦāĻž Software Development āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ…āĻ°ā§āĻĨ āωāĻĒāĻžāĻ°ā§āϜāύ āĻ•āϰāĻžāĨ¤
    10. āĻ…āĻŦāϏāϰ āϏāĻŽā§Ÿā§‡āϰ āϏ⧁āϚāĻŋāĻ¨ā§āϤāĻŋāϤ āĻŦā§āϝāĻŦāĻšāĻžāϰ ⇒ Programming āĻļ⧇āĻ–āĻž āφāĻŽāĻžāĻĻ⧇āϰ āĻ…āĻŦāϏāϰ āϏāĻŽā§Ÿā§‡ āĻŽāĻ¸ā§āϤāĻŋāĻˇā§āĻ•āϕ⧇ āϏāϚāϞ āϰāĻžāϖ⧇ āĻāĻŦāĻ‚ āφāĻĒāύāĻžāϰ āϚāĻŋāĻ¨ā§āϤāĻž-āĻ­āĻžāĻŦāύāĻž āϤ⧀āĻ•ā§āĻˇā§āĻŖ āĻ•āϰ⧇, āϝāĻž āĻāĻ•āĻĻāĻŋāϕ⧇ āϝ⧇āĻŽāύ āĻŽāĻžāύāϏāĻŋāĻ• āĻ¸ā§āĻŦāĻžāĻ¸ā§āĻĨā§āϝ⧇āϰ āϜāĻ¨ā§āϝ āĻ­āĻžāϞ⧋, āϤ⧇āĻŽāύāĻŋ āĻ…āĻ¨ā§āϝāĻĻāĻŋāϕ⧇ āφāĻŽāĻžāĻĻ⧇āϰāϕ⧇ āĻŦā§āϝāĻ•ā§āϤāĻŋāĻ—āϤ āĻœā§€āĻŦāύ⧇ āφāϰ⧋ āĻĻāĻžā§ŸāĻŋāĻ¤ā§āĻŦāĻļā§€āϞ āĻ“ āĻ—āĻ āύāĻŽā§‚āϞāĻ• āĻšāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤

    āĻāĻ­āĻžāĻŦ⧇, Programming āĻļ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ āĻŦā§āϝāĻ•ā§āϤāĻŋāĻ—āϤ āĻāĻŦāĻ‚ āĻĒ⧇āĻļāĻžāĻ—āϤ āĻĻāĻ•ā§āώāϤāĻž āĻ…āĻ°ā§āϜāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋ, āϝāĻž āφāĻŽāĻžāĻĻ⧇āϰ āĻœā§€āĻŦāύ⧇ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āφāύāϤ⧇ āϏāĻšāĻžā§ŸāĻ• āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ Programming āĻāϰ āĻĒā§āϰāĻ•āĻžāϰāϭ⧇āĻĻ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇?

    Programming āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻĒā§āϰāĻ•āĻžāϰ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āĻāĻŦāĻ‚ āφāĻŽāϰāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ⧇āϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ Programming āĻāϰ āĻĒā§āϰāĻ•āĻžāϰāϭ⧇āĻĻ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āĻŽā§‚āϞāϤ āύāĻŋāĻŽā§āύāϞāĻŋāĻ–āĻŋāϤ āĻĒā§āϰāϧāĻžāύ āĻļā§āϰ⧇āĻŖā§€āϗ⧁āϞāĻŋāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ Programming āĻĒā§āϰāĻ•āĻžāϰāϭ⧇āĻĻ āĻ•āϰāĻž āĻšāϝāĻŧ:

    1. Programming Paradigm āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇:

    Programming Paradigms(āĻĒāĻĻā§āϧāϤāĻŋ) āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ• āϧāĻžāϰāĻŖāĻž āϝāĻž āĻŦāϞ⧇ āĻĻā§‡ā§Ÿ Program āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇āĨ¤ āĻāϟāĻŋ Programming āĻāϰ Style āĻāĻŦāĻ‚ Problem Solving āĻāϰ āĻĻ⧃āĻˇā§āϟāĻŋāĻ­āĻ™ā§āĻ—āĻŋ āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇āĨ¤ āĻ­āĻŋāĻ¨ā§āύ āĻ­āĻŋāĻ¨ā§āύ Paradigm, Programming Problem Solving āĻāϰ āĻ­āĻŋāĻ¨ā§āύ āϧāϰāϪ⧇āϰ āĻĻ⧃āĻˇā§āϟāĻŋāĻ­āĻ™ā§āĻ—āĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Programming āĻ­āĻžāώāĻžāϰ āĻŽā§‚āϞ āĻ•āĻžāĻ āĻžāĻŽā§‹ āĻāĻŦāĻ‚ āĻŽā§ŒāϞāĻŋāĻ• āϧāĻžāϰāĻŖāĻžāϕ⧇ āĻĒā§āϰāϤāĻŋāύāĻŋāϧāĻŋāĻ¤ā§āĻŦ āĻ•āϰ⧇āĨ¤ āĻāĻ•āϟāĻŋ Programming Language āĻāĻ•āĻžāϧāĻŋāĻ• Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ, Python āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Multi-Paradigm Language āϝāĻž Object-Oriented, Procedural, āĻāĻŦāĻ‚ Functional āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ Style āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤

    āĻĒā§āϰāĻžāĻĨāĻŽāĻŋāĻ•āĻ­āĻžāĻŦ⧇ Programming Paradigms āϕ⧇ āφāĻŽāϰāĻž āĻĻ⧁āχāĻ­āĻžāϗ⧇ āĻŦāĻŋāĻ­āĻ•ā§āϤ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āϝāĻĨāĻžāσ

    1. Imperative Programming.
    2. Declarative Programming.

    Imperative Programming.(āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻšāĻŦ⧇ āϤāĻž āĻŦāϞ⧇)

    Imperative Programming Language āĻšāϞ āĻāĻ•āϟāĻŋ Programming Paradigm āϝ⧇āĻ–āĻžāύ⧇ Program āϟāĻŋ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜāϟāĻŋ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇, āϤāĻž Step-by-step Instruction(āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž) āĻĻāĻŋā§Ÿā§‡ āĻŦāĻ°ā§āĻŖāĻŋāϤ āĻšā§ŸāĨ¤ āĻāĻ–āĻžāύ⧇ Programmer āϕ⧇ āĻĒā§āϰāϤāĻŋāϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āϏāĻ āĻŋāĻ• Statement āĻŦāĻž Command āĻĻāĻŋāϤ⧇ āĻšā§Ÿ, āϝāĻž System āϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻā§‡ā§Ÿ āϕ⧀āĻ­āĻžāĻŦ⧇ Data āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻŦāĻž Process āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤

    āĻāϟāĻŋ "What to do" āύ⧟, āĻŦāϰāĻ‚ "How to do" āĻāϰ āωāĻĒāϰ āĻŦ⧇āĻļāĻŋ āĻĢā§‹āĻ•āĻžāϏ āĻ•āϰ⧇āĨ¤ Imperative Programming Language āĻ, Programmer āϕ⧇ Statement āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāϤ⧇ āĻšā§Ÿ āϝāĻž System āϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻā§‡ā§Ÿ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜāϟāĻŋ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇, āĻāĻŦāĻ‚ Program āϟāĻŋ āϏāĻŽā§Ÿā§‡āϰ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰ⧇āĨ¤ Imperative Programming Language āĻāϰ āĻ•āĻŋāϛ⧁ āωāĻĻāĻžāĻšāĻžāϰāĻŖ āĻšāϞāσ Assembly Language, C, C++, Java, Python (āϝāĻĻāĻŋāĻ“ āĻāϟāĻŋ Mixed Paradigm Language), JavaScript (āϝāĻĻāĻŋāĻ“ āĻāϟāĻŋ Mixed Paradigm Language) āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Imperative Programming Language āϕ⧇ āφāĻŽāϰāĻž āĻĻ⧁āχāĻ­āĻžāϗ⧇ āĻ­āĻžāĻ— āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āϝāĻĨāĻžāσ

    1. Procedural Programming.
    2. Object Oriented Programming.

    Procedural Programming:

    Procedural Programming āĻšāĻšā§āϛ⧇ Programming āĻāϰ āĻāĻ•āϟāĻŋ āĻĒāĻĻā§āϧāϤāĻŋ āϝ⧇āĻ–āĻžāύ⧇ Program āϗ⧁āϞāĻŋ āϧāĻžāĻĒ⧇ āϧāĻžāĻĒ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āϞ⧇āĻ–āĻž āĻšāϝāĻŧāĨ¤ āĻ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āφāĻŽāĻžāĻĻ⧇āϰāϕ⧇ āĻŦāϞ⧇ āĻĻāĻŋāϤ⧇ āĻšā§Ÿ āϝ⧇ āĻāĻ•āϟāĻž āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ Step āφāĻŽāĻžāĻĻ⧇āϰāϕ⧇ āϞāĻŋāϖ⧇ āĻĻāĻŋā§Ÿā§‡ āĻšā§ŸāĨ¤ āϝ⧇āĻŽāύāσ C, Pascal, COBOL, Fortran, BASIC, Rust, PHP āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Object Oriented Programming(OOP):

    Object-Oriented Programming āĻšāϞ⧋ Programming āĻāϰ āφāϰ⧇āĻ•āϟāĻŋ āĻĒāĻĻā§āϧāϤāĻŋ āϝ⧇āĻ–āĻžāύ⧇ Programmers āĻāϰāĻž Object āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ Program āϤ⧈āϰ⧀ āĻ•āϰ⧇āύāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ Object āϤāĻžāϰ Data āĻāĻŦāĻ‚ Method āϧāĻžāϰāĻŖ āĻ•āϰ⧇āĨ¤ OOP-āĻāϰ āϚāĻžāϰāϟāĻŋ āĻŽā§‚āϞ āύ⧀āϤāĻŋ āĻšāϞ: Encapsulation, Inheritance, Polymorphism, āĻāĻŦāĻ‚ Abstraction.

    āύāĻŋāĻšā§‡ OOP-āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• āĻ•āĻŋāϛ⧁ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ Programming Language āĻāϰ āϤāĻžāϞāĻŋāĻ•āĻž āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ⧋āĨ¤

    • Pure Object-Oriented Languages (āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ OOP): āϝ⧇āϏāĻŦ āĻ­āĻžāώāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ Object-Oriented Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤

      • Smalltalk: āĻāϟāĻŋ āĻĒā§āϰāĻĨāĻŽ āĻŦāĻŋāĻļ⧁āĻĻā§āϧ OOP āĻ­āĻžāώāĻž āĻāĻŦāĻ‚ OOP āϧāĻžāϰāĻŖāĻžāϰ āĻĒāĻĨāĻĒā§āϰāĻĻāĻ°ā§āĻļāĻ•āĨ¤
      • Ruby: āϏāĻšāϜ āĻāĻŦāĻ‚ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ OOP āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ•āĨ¤
      • Eiffel: āĻāĻ•āϟāĻŋ āĻ—āĻŦ⧇āώāĻŖāĻž āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• OOP āĻ­āĻžāώāĻžāĨ¤
    • Hybrid Object-Oriented Languages(OOP + āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ Paradigm): āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— āφāϧ⧁āύāĻŋāĻ• Programming Language Object-Oriented Paradigm āĻāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ Procedural āĻāĻŦāĻ‚ Functional āĻĒāĻĻā§āϧāϤāĻŋāĻ“ āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤

      • C++ ⇒ Object-Oriented āĻāĻŦāĻ‚ Procedural Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Java ⇒ āĻĒā§‚āĻ°ā§āĻŖāĻžāĻ™ā§āĻ— OOP āĻ­āĻžāώāĻž āĻāĻŦāĻ‚ āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤāĨ¤
      • C# ⇒ Microsoft-āĻāϰ āϤ⧈āϰāĻŋ, āϝāĻž OOP āĻāĻŦāĻ‚ Functional Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Python ⇒ OOP āϧāĻžāϰāĻŖāĻž āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āĻĒā§āϰāϝāĻŧā§‹āĻ— āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϟāĻŋ Multi-Paradigm.
      • PHP ⇒ Web Development āĻāϰ āϜāĻ¨ā§āϝ āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻāĻ•āϟāĻŋ OOP āĻ­āĻžāώāĻžāĨ¤
      • JavaScript ⇒ Browser āĻāĻŦāĻ‚ Web Development āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ, ES6 āĻĨ⧇āϕ⧇ Class āĻāĻŦāĻ‚ Object āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤ āĻāĻ›āĻžā§œāĻžāĻ“ Functional Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • TypeScript ⇒ JavaScript-āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇, āϝāĻž Static Typing āĻāĻŦāĻ‚ OOP āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Kotlin ⇒ Android Development āĻāϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧋āĻ—ā§€, āĻāϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ OOP āĻāĻŦāĻ‚ Functional Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Perl ⇒ System Administration āĻāĻŦāĻ‚ Web Development āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤
      • Go (Golang) ⇒ āĻāĻ•āϟāĻŋ Hybrid Language, āϝ⧇āĻ–āĻžāύ⧇ OOP āϧāĻžāϰāĻŖāĻžāϗ⧁āϞ⧋ āϏ⧀āĻŽāĻŋāϤāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤
      • Scala ⇒ Functional āĻāĻŦāĻ‚ Object-Oriented Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Rust ⇒ OOP āϧāĻžāϰāĻŖāĻž āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇, āϤāĻŦ⧇ āĻāϟāĻŋ Performance āĻāĻŦāĻ‚ Memory-Safe LanguageāĨ¤
      • R ⇒ Data Analysis āĻāĻŦāĻ‚ Visualization āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ OOP āϧāĻžāϰāĻŖāĻž āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤

      āĻāĻ›āĻžā§œāĻžāĻ“ āφāϰāĻ“ āĻ…āύ⧇āĻ• OOP Programming Language āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ āωāĻĒāϰ⧇āϰ Language āϗ⧁āϞ⧋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ•āĻžāĻœā§‡ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ, āĻāĻŦāĻ‚ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āϏāĻ āĻŋāĻ• Language āĻŦ⧇āϛ⧇ āύāĻŋāϞ⧇ āφāĻŽāϰāĻž Object-Oriented Programming āĻĨ⧇āϕ⧇ āϏ⧇āϰāĻž āϏ⧁āĻŦāĻŋāϧāĻž āύāĻŋāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤

    Declarative Programming.(āϕ⧀ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āϤāĻž āĻŦāϞ⧇)

    Declarative Programming āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Programming Paradigm āϝ⧇āĻ–āĻžāύ⧇ āφāĻŽāϰāĻž āĻļ⧁āϧ⧁ "āϕ⧀ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇" āϤāĻž āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰāĻŦ, āĻ•āĻŋāĻ¨ā§āϤ⧁ "āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇" āϤāĻž āύāĻŋāϝāĻŧ⧇ āĻŽāĻžāĻĨāĻž āϘāĻžāĻŽāĻžāϤ⧇ āĻšāĻŦ⧇ āύāĻžāĨ¤ āĻāϟāĻŋ High-Level Programming Language āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻžāϰ āĻāĻ•āϟāĻŋ āĻĒāĻĻā§āϧāϤāĻŋ, āϝ⧇āĻ–āĻžāύ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āĻ•āĻžāĻ™ā§āĻ•ā§āώāĻŋāϤ āĻĢāϞāĻžāĻĢāϞ⧇āϰ āωāĻĒāϰ Focus āĻ•āϰāĻž āĻšāϝāĻŧ, āĻāĻŦāĻ‚ āĻ•āĻžāĻœā§‡āϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻŦāĻž āϧāĻžāĻĒāϗ⧁āϞ⧋āϰ āĻĻāĻŋāϕ⧇ āĻ•āĻŽ āĻŽāύ⧋āϝ⧋āĻ— āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ Declarative Programming Language āĻāϰ āĻ•āĻŋāϛ⧁ āωāĻĻāĻžāĻšāĻžāϰāĻŖ āĻšāϞāσ SQL, HTML, Prolog, Mercury āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Declarative Programming Language āϕ⧇ āφāĻŽāϰāĻž āϤāĻŋāύāĻ­āĻžāϗ⧇ āĻ­āĻžāĻ— āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āϝāĻĨāĻžāσ

    1. Functional Programming.
    2. Logical Programming.
    3. Reactive Programming

    Functional Programming:

    Functional Programming āĻšāϞ⧋ Programming āĻāϰ āĻāĻ•āϟāĻŋ Paradigm āϝ⧇āĻ–āĻžāύ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ⧇ Function āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāϕ⧇ āĻĒā§āϰāĻžāϧāĻžāĻ¨ā§āϝ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ āϝāĻž Code āĻāϰ āĻĒ⧁āύāϰāĻžāϝāĻŧ āĻŦā§āϝāĻŦāĻšāĻžāϰāϝ⧋āĻ—ā§āϝāϤāĻž āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āĻŦāĻžāĻĄāĻŧāĻžāϝāĻŧāĨ¤ āĻāχ āĻĒāĻĻā§āϧāϤāĻŋāϤ⧇ Function āϗ⧁āϞ⧋āϕ⧇ First-Class Function āĻŦāĻž Higher Order Function āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦāĻŋāĻŦ⧇āϚāύāĻž āĻ•āϰāĻž āĻšāϝāĻŧ, āĻ…āĻ°ā§āĻĨāĻžā§Ž Function āϕ⧇ Variable āĻšāĻŋāϏ⧇āĻŦ⧇ Pass āĻ•āϰāĻž, Return āĻ•āϰāĻž, āĻŦāĻž āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦāĨ¤ āĻāϟāĻŋ "Declarative Programming" āĻĒāĻĻā§āϧāϤāĻŋāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āϝ⧇āĻ–āĻžāύ⧇ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻšāĻŦ⧇ āϤāĻžāϰ āĻšā§‡āϝāĻŧ⧇ "āϕ⧀ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇" āĻŦ⧇āĻļāĻŋ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖāĨ¤

    āύāĻŋāĻšā§‡ āĻ•āϝāĻŧ⧇āĻ•āϟāĻŋ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ Functional Programming āĻ­āĻžāώāĻžāϰ āϤāĻžāϞāĻŋāĻ•āĻž āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϞ⧋:

    • Purely Functional Languages (āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ Functional): āĻāϗ⧁āϞ⧋āϤ⧇ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ Functional Programming āĻĒāĻĻā§āϧāϤāĻŋ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤
      • Haskell: āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļ⧁āĻĻā§āϧ āĻĢāĻžāĻ‚āĻļāύāĻžāϞ āĻ­āĻžāώāĻž āϝāĻž Lazy Evaluation āĻāĻŦāĻ‚ Immutable Data āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āϜāĻ¨ā§āϝ āĻĒāϰāĻŋāϚāĻŋāϤāĨ¤
      • Erlang: Concurrent āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻāĻŦāĻ‚ Distributed Systems āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧋āĻ—ā§€āĨ¤
    • Hybrid Object-Oriented Languages(Functional+ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ Paradigm): āĻāϗ⧁āϞ⧋ āĻĢāĻžāĻ‚āĻļāύāĻžāϞ āĻĒāĻĻā§āϧāϤāĻŋāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āĻĒāĻĻā§āϧāϤāĻŋ (āϝ⧇āĻŽāύ: Object-Oriented, Procedural) āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • JavaScript: ES6 āĻĨ⧇āϕ⧇ JavaScript-āĻ Functional Programming āĻāϰ Features(āϝ⧇āĻŽāύ: Higher-Order Functions, Map, Reduce) āϝ⧁āĻ•ā§āϤ āĻšāϝāĻŧ⧇āϛ⧇āĨ¤
      • Python: Functional Programming āĻāϰ Features(āϝ⧇āĻŽāύ: Lambda Functions, Map, Filter, Reduce) āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Rust: Performance āĻāĻŦāĻ‚ Memory-Safe Language āϝāĻž Functional Programming Features āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Kotlin: Functional āĻāĻŦāĻ‚ Object-Oriented Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Android Development-āĻ āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤāĨ¤
      • F# (F Sharp): Microsoft āĻāϰ āĻāĻ•āϟāĻŋ āĻ­āĻžāώāĻž āϝāĻž Functional āĻāĻŦāĻ‚ Object-Oriented Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
      • Scala: Functional āĻāĻŦāĻ‚ Object-Oriented Paradigm āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ JVM-āĻ āϰāĻžāύ āĻ•āϰ⧇āĨ¤
      • Clojure: JVM-āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• āĻāĻ•āϟāĻŋ Functional Language āϝāĻž Lisp-āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇āĨ¤

    āĻāĻ›āĻžā§œāĻžāĻ“ āφāϰāĻ“ āĻ…āύ⧇āĻ• Functional Programming Language āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ āωāĻĒāϰ⧇āϰ Language āϗ⧁āϞ⧋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ•āĻžāĻœā§‡ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ, āĻāĻŦāĻ‚ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āϏāĻ āĻŋāĻ• Language āĻŦ⧇āϛ⧇ āύāĻŋāϞ⧇ āφāĻŽāϰāĻž Functional Programming āĻĨ⧇āϕ⧇ āϏ⧇āϰāĻž āϏ⧁āĻŦāĻŋāϧāĻž āύāĻŋāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤

    Logical Programming:

    Logical Programming āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Programming Paradigm āϝāĻž Logic āĻŦāĻž āϝ⧁āĻ•ā§āϤāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰ⧇āĨ¤ āĻāϤ⧇ Data āĻāĻŦāĻ‚ Information āύāĻŋāϝāĻŧ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āύāĻŋāϝāĻŧāĻŽāĻžāĻŦāϞ⧀(rules) āϏāĻ‚āĻœā§āĻžāĻžāϝāĻŧāĻŋāϤ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āϏ⧇āϗ⧁āϞ⧋ āĻĨ⧇āϕ⧇ āύāϤ⧁āύ āϤāĻĨā§āϝ āĻŦāĻž āĻĢāϞāĻžāĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āϝāĻžāĻ¨ā§āĻ¤ā§āϰāĻŋāĻ• āϝ⧁āĻ•ā§āϤāĻŋ āĻĒā§āϰāϝāĻŧā§‹āĻ— āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ Logical Programming āĻŽā§‚āϞāϤ Declarative Programming āĻĒāĻĻā§āϧāϤāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ āφāϰ āφāĻŽāϰāĻž āϜāĻžāύāĻŋ āĻāχ āĻĒāĻĻā§āϧāϤāĻŋāϤ⧇ āĻļ⧁āϧ⧁ āĻ•āĻŋ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āĻŦāĻž Logical Programming āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āϕ⧀ āϏāĻ¤ā§āϝāĻŋ(what is true) āϏ⧇āϟāĻž āφāĻŽāϰāĻž āĻŦāϞ⧇ āĻĻāĻŋā§Ÿā§‡ āĻĨāĻžāĻ•āĻŋ āĻāĻŦāĻ‚ System āϤāĻž āĻĨ⧇āϕ⧇ āύāĻŋāĻœā§‡ āύāĻŋāĻœā§‡āχ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύāĻŋāϝāĻŧ⧇ "āϕ⧀āĻ­āĻžāĻŦ⧇ āϏāĻŽāĻžāϧāĻžāύ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇" āϤāĻž āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ Logical Programming-āĻāϰ Language āϗ⧁āϞ⧋ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ Design āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇ āϝāĻžāϤ⧇ Logic, Rules āĻāĻŦāĻ‚ facts āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• Programming āϏāĻšāϜ āĻšāϝāĻŧāĨ¤ āύāĻŋāĻšā§‡ Logical Programming-āĻāϰ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āĻāĻŦāĻ‚ āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋āϰ āϤāĻžāϞāĻŋāĻ•āĻž āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϞ⧋:

    • Prolog ⇒ āĻāϟāĻŋ āĻšāĻšā§āϛ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ Logical Programming LanguageāĨ¤ "Facts" āĻāĻŦāĻ‚ "Rules" āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰ⧇āĨ¤ Backtracking āĻāĻŦāĻ‚ Logical Inference āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āĻāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ Artificial Intelligence (AI), Natural Language Processing (NLP), Expert Systems āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϤ⧇āĨ¤
    • Datalog ⇒ āĻāϟāĻŋ Prolog-āĻāϰ āĻāĻ•āϟāĻŋ āϏāĻšāϜ āϏāĻ‚āĻ¸ā§āĻ•āϰāĻŖāĨ¤ āĻāϟāĻž āĻšāĻšā§āϛ⧇ Declarative Query Language āϝāĻž Database Logic āύāĻŋāϝāĻŧ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Immutable Data āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ āĻāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ Database Query, Deductive Databases, Knowledge Representation āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϤ⧇āĨ¤
    • Mercury ⇒ āĻāϟāĻŋ Prolog-āĻāϰ āĻāĻ•āϟāĻŋ āωāĻ¨ā§āύāϤ āϏāĻ‚āĻ¸ā§āĻ•āϰāĻŖāĨ¤ āĻāϟāĻž āĻāĻ•āϟāĻž High-Level āĻāĻŦāĻ‚ High-Performance Logical Programming LanguageāĨ¤ āĻāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ Large-Scale AI Systems, Data Analysis āĻāĻŦāĻ‚ Optimization āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϤ⧇āĨ¤
    • Golog ⇒ āĻāϟāĻžāĻ“ Prolog āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āϤ⧈āϰāĻŋāĨ¤ Dynamic Systems āĻŽāĻĄā§‡āϞ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āĻāĻ›āĻžā§œāĻž Automated Planning, Robotics āĻāĻŦāĻ‚ Intelligent Agents āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϤ⧇āĻ“ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤
    • Flora-2 ⇒ āĻāϟāĻž Logical āĻāĻŦāĻ‚ Object-Oriented Programming Paradigm āĻāϰ āϏāĻŽāĻ¨ā§āĻŦāϝāĻŧāĨ¤ āĻāϟāĻž Semantic Web Applications, AI āĻāĻŦāĻ‚ Data Management āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϤ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤
    • Alice ⇒ āĻāϟāĻž Functional āĻāĻŦāĻ‚ Logical Programming Paradigm āĻāϰ āϏāĻŽāĻ¨ā§āĻŦāϝāĻŧāĨ¤ āĻāϟāĻž AI āĻāĻŦāĻ‚ Logical Problem Solving āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰāϗ⧁āϞ⧋āϤ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤
    • ASP (Answer Set Programming) ⇒ āĻāϟāĻž Complex Problems āĻāϰ āϜāĻ¨ā§āϝ Logical Rules āĻāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋāϤ⧇ Answer Sets āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤ āĻāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇ Problem Solving, AI āĻāĻŦāĻ‚ Robotics āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϤ⧇āĨ¤

    āĻāĻ›āĻžā§œāĻž āφāϰāĻ“ āĻ…āύ⧇āĻ• Logical Programming Language āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ āĻāχ Language āϗ⧁āϞ⧋ āĻŦāĻŋāĻļ⧇āώāϤ AI, Expert Systems, Knowledge Representation, āĻāĻŦāĻ‚ Semantic Web āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻ­ā§‚āĻŽāĻŋāĻ•āĻž āĻĒāĻžāϞāύ āĻ•āϰ⧇āĨ¤ Prolog, Mercury, āĻāĻŦāĻ‚ Datalog āĻāϰ āĻŽāϤ⧋ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋ āĻļāĻŋāĻ•ā§āώāĻžāĻ°ā§āĻĨā§€āĻĻ⧇āϰ āϜāĻ¨ā§āϝ Logical Programming āĻļ⧇āĻ–āĻžāϰ āĻāĻ•āϟāĻŋ āϚāĻŽā§ŽāĻ•āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽāĨ¤

    Reactive Programming:

    Reactive Programming āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Programming Paradigm āϝāĻž Data Streams āĻāĻŦāĻ‚ Change Propagation āĻāϰ āϧāĻžāϰāĻŖāĻžāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āϤ⧈āϰāĻŋāĨ¤ āĻāϟāĻŋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĒāĻĻā§āϧāϤāĻŋ āϝ⧇āĻ–āĻžāύ⧇ Program, Real Time Event āĻāĻŦāĻ‚ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ⧇āϰ āĻĒā§āϰāϤāĻŋ āĻĒā§āϰāϤāĻŋāĻ•ā§āϰāĻŋāϝāĻŧāĻž āϜāĻžāύāĻžāϝāĻŧāĨ¤ Reactive Programming āĻŽā§‚āϞāϤ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ āĻāĻŽāύ System āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āϝ⧇āĻ–āĻžāύ⧇ Data āĻŦāĻž Event āĻāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ Automatically Program āĻāϰ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ…āĻ‚āĻļ⧇ āĻĒā§āϰāĻ­āĻžāĻŦ āĻĢ⧇āϞ⧇āĨ¤

    Reactive Programming-āĻāϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ­āĻžāώāĻžāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Library āĻāĻŦāĻ‚ Framework āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āύāĻŋāĻšā§‡ Reactive Programming āϏāĻŽāĻ°ā§āĻĨāύāĻ•āĻžāϰ⧀ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āĻ­āĻžāώāĻž āĻāĻŦāĻ‚ Library āĻāϰ āϤāĻžāϞāĻŋāĻ•āĻž āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϞ⧋:

    • Java

      • Reactive Libraries:
        • RxJava: Java āĻāϰ āϜāĻ¨ā§āϝ Reactive ExtensionsāĨ¤
        • Project Reactor: Spring Framework āĻāϰ āϜāĻ¨ā§āϝ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϜāύāĻĒā§āϰāĻŋāϝāĻŧāĨ¤

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Web, API Development, Microservices.

    • JavaScript

      • Reactive Libraries:
        • RxJS: Reactive Extensions for JavaScript.
        • Bacon.js: Data Streams āĻāĻŦāĻ‚ Event Handling āĻāϰ āϜāĻ¨ā§āϝāĨ¤
        • Most.js: High-performance Reactive Programming Library.

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Web Apps, UI State Management āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • Python

      • Reactive Libraries:
        • RxPY: Python āĻāϰ āϜāĻ¨ā§āϝ Reactive Extensions.
        • Trio: Asynchronous Programming āĻāϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧋āĻ—ā§€āĨ¤

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Asynchronous Systems, Data Streams āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • C# (.NET Framework)

      • Reactive Libraries:
        • Reactive Extensions (Rx.NET): .NET āĻāϰ āϜāĻ¨ā§āϝ Reactive Framework.
        • UniRx: Unity-āϤ⧇ Reactive Programming āĻāϰ āϜāĻ¨ā§āϝāĨ¤

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Windows Apps, Game Development āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • Kotlin

      • Reactive Libraries:
        • Kotlin Flow: Kotlin-āĻāϰ āϜāĻ¨ā§āϝ āφāϧ⧁āύāĻŋāĻ• Reactive APIāĨ¤
        • RxKotlin: RxJava āĻāϰ Kotlin Implementation.

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Mobile Apps, Backend Services āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • Dart (Flutter)

      • Reactive Libraries:
        • Streams API: Dart āĻ­āĻžāώāĻžāϝāĻŧ Build-in.
        • RxDart: Flutter āĻāϰ āϜāĻ¨ā§āϝ Reactive Programming Library.

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Flutter-based Mobile Apps āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • Swift (iOS Development)

      • Reactive Libraries:
        • RxSwift: iOS Application āĻāϰ āϜāĻ¨ā§āϝāĨ¤
        • Combine: Apple āĻāϰ āύāĻŋāϜāĻ¸ā§āĻŦ Reactive Framework

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ iOS Apps, Apple Ecosystem āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • Ruby

      • Reactive Libraries:
        • ReactiveRuby: Reactive Programming āĻāϰ āϜāĻ¨ā§āϝ Ruby Framework.

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ Web Apps, Asynchronous Systems āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    • Rust

      • Reactive Libraries:
        • RxRust: Rust āĻāϰ āϜāĻ¨ā§āϝ Reactive Extensions

      āĻāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ High-Performance Systems āϤ⧈āϰāĻŋāϤ⧇āĨ¤

    Reactive Programming āϏāĻŽāĻ°ā§āĻĨāύāĻ•āĻžāϰ⧀ Framework āϗ⧁āϞ⧋ āĻšāϞāσ

    1. Angular (JavaScript Framework):
      • RxJS āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤
      • Reactive Forms āĻāĻŦāĻ‚ State Management āĻāϰ āϜāĻ¨ā§āϝ āĻ•āĻžāĻ°ā§āϝāĻ•āϰāĨ¤
    2. Spring WebFlux (Java Framework):
      • Non-Blocking āĻāĻŦāĻ‚ Reactive Programming āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤
    3. React (JavaScript Library):
      • React Native āϏāĻš State āĻāĻŦāĻ‚ Event Management āĻāϰ āϜāĻ¨ā§āϝāĨ¤
    4. Flutter (Dart Framework):
      • Reactive Streams āĻāĻŦāĻ‚ RxDart āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ UI āφāĻĒāĻĄā§‡āϟ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰ⧇āĨ¤

    Reactive Programming āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ­āĻžāώāĻž āĻāĻŦāĻ‚ Library āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇ āϝāĻž āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ Real Time Data Processing, Event-Driven Architecture āĻāĻŦāĻ‚ User Interface Update āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ RxJS, RxJava, Akka Streams, āĻāĻŦāĻ‚ RxDart āĻāϰ āĻŽāϤ⧋ Library āĻāχ āĻĒāĻĻā§āϧāϤāĻŋāϰ āĻ…āĻ¨ā§āϝāϤāĻŽ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āϏāϰāĻžā§āϜāĻžāĻŽāĨ¤

    2. Compilation Method āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇:

    • Compiled Languages
      • Code āϏāϰāĻžāϏāϰāĻŋ machine Code āĻ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻšāϝāĻŧāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: C, C++
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: High-Performance ApplicationsāĨ¤
    • Interpreted Languages
      • Code Line-By-Line āĻ…āύ⧁āĻŦāĻžāĻĻ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻšāϝāĻŧāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Python, JavaScript.
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Script āĻāĻŦāĻ‚ Dynamic ApplicationsāĨ¤
    • Hybrid Languages
      • āĻ•āĻŋāϛ⧁ āĻ…āĻ‚āĻļ Compile āĻāĻŦāĻ‚ āĻ•āĻŋāϛ⧁ āĻ…āĻ‚āĻļ Interpret āĻšāϝāĻŧāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Java (Bytecode + JVM)

    3. Generation(āĻĒā§āϰāϜāĻ¨ā§āĻŽ) āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇:

    • āĻĒā§āϰāĻĨāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž(⧧⧝ā§Ēā§Ģ) ⇒ Machine āĻŦāĻž āϝāĻžāĻ¨ā§āĻ¤ā§āϰāĻŋāĻ• āĻ­āĻžāώāĻžāĨ¤
    • āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž(⧧⧝ā§Ģā§Ļ) ⇒ Assembly āĻ­āĻžāώāĻžāĨ¤ āϝ⧇āĻŽāύ Assembly, MASM.
    • āϤ⧃āĻ¤ā§€ā§Ÿ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž(⧧⧝ā§Ŧā§Ļ) ⇒ āωāĻšā§āϚāϤāϰ āĻ­āĻžāώāĻžāĨ¤ āϝ⧇āĻŽāύ C, C++, Java, Python, Fortran.
    • āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž(⧧⧝⧭ā§Ļ) ⇒ 4GL āĻŦāĻž āĻ…āϤāĻŋ āωāĻšā§āϚāϤāϰ āĻ­āĻžāώāĻžāĨ¤ āϝ⧇āĻŽāύ SQL, MATLAB, ABAP, Delphi.
    • āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž(ā§§ā§¯ā§Žā§Ļ) ⇒ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ• āĻŦāĻž āĻ¨ā§āϝāĻžāĻšā§‡āϰāĻžāϞ āĻ­āĻžāώāĻžāĨ¤ āϝ⧇āĻŽāύ Prolog, Mercury, Lisp, Erlang.

    4. Language Structure āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇:

    • Low-Level Programming
      • āϏāϰāĻžāϏāϰāĻŋ āĻŽā§‡āĻļāĻŋāύ⧇āϰ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Assembly Language
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Hardware InteractionāĨ¤
    • Middle-Level Programming
      • Low-Level āĻāĻŦāĻ‚ High-Level āĻāϰ āϏāĻ‚āĻŽāĻŋāĻļā§āϰāĻŖāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: C
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: System āĻāĻŦāĻ‚ Application SoftwareāĨ¤
    • High-Level Programming
      • āĻŽāĻžāύ⧁āώ⧇āϰ āĻĒāĻĄāĻŧāĻž āĻāĻŦāĻ‚ āϞ⧇āĻ–āĻžāϰ āϜāĻ¨ā§āϝ āϏāĻšāϜāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Python, Java, C++
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: General Applications.

    5. āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇āϰ āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇:

    • System Programming
      • System Software āϝ⧇āĻŽāύ Operating System, Driver āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: C, C++
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Kernel Development, Embedded Systems.
    • Web Programming
      • Website āĻāĻŦāĻ‚ Web App āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: HTML, CSS, JavaScript, PHP.
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Web Frontend āĻ“ Backend Development.
    • Mobile Application Programming
      • Mobile App Development āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Kotlin (Android), Swift (iOS).
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Mobile Applications.
    • Game Programming
      • āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Game āϤ⧈āϰāĻŋāϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: C++, C#, Unity
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: 2D/3D Games, Virtual Reality.
    • Scientific and Data Analysis Programming
      • Math āĻāĻŦāĻ‚ Data Analysis āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§ŸāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Python, R, MATLAB
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Data Science, Statistics, Numerical Analysis.
    • Artificial Intelligence and Machine Learning Programming
      • Machine Learning Model āĻāĻŦāĻ‚ AI āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§ŸāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Python, Lisp, Prolog
      • āĻŦā§āϝāĻŦāĻšāĻžāϰ: Chatbots, Recommendation Systems.

    6. Programming Models āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇:

    • Concurrent Programming
      • āĻāĻ•āĻžāϧāĻŋāĻ• āĻ•āĻžāϜ āĻāĻ•āĻ¤ā§āϰ⧇ āϏāĻŽā§āĻĒāĻ¨ā§āύāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: Java (Multithreading), Go.
    • Distributed Programming
      • Network āĻ āĻŦāĻŋāĻ­āĻ•ā§āϤ System Management.
      • āωāĻĻāĻžāĻšāϰāĻŖ: Python, Java.
    • Parallel Programming
      • āĻāĻ•āĻžāϧāĻŋāĻ• Processor āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ•āĻžāϜāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: CUDA, OpenMP.
    • Reactive Programming
      • Data āĻāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ⧇āϰ āĻĒā§āϰāϤāĻŋāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: RxJava.

    āϏ⧁āϤāĻžāϰāĻžāĻ‚ āĻĒāϰāĻŋāĻļ⧇āώ⧇ āĻŦāϞāĻž āϝāĻžā§Ÿ, āφāĻŽāĻžāĻĻ⧇āϰ āĻ•āĻžāĻœā§‡āϰ āϧāϰāĻŖ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ Programming Language āĻāĻŦāĻ‚ āĻĒāĻĻā§āϧāϤāĻŋ āύāĻŋāĻ°ā§āĻŦāĻžāϚāύ āĻ•āϰāϞ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āφāϰāĻ“ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻšāĻŦ⧇āĨ¤ Python, JavaScript, C, C++ āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āĻ­āĻžāώāĻž āĻļ⧇āĻ–āĻž āĻļ⧁āϰ⧁ āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻ…āύ⧇āĻ• āĻ­āĻŋāĻ¨ā§āύ āĻĒā§āϰāĻ•āĻžāϰ⧇āϰ āĻĒāĻĻā§āϧāϤāĻŋ āĻāĻŦāĻ‚ āĻ•ā§āώ⧇āĻ¤ā§āϰ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āĻĻāĻ•ā§āώāϤāĻž āĻ…āĻ°ā§āϜāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤


  • Machine āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Computer Machine āĻāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻ­āĻžāώāĻžāϕ⧇ Machine āĻ­āĻžāώāĻž āĻŦāĻž āύāĻŋāĻŽā§āύāĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž āĻŦāϞ⧇āĨ¤ Machine āĻ­āĻžāώāĻž āĻšāϞ⧋ Computer āĻŦāĻž Microprocessor āĻāϰ āϜāĻ¨ā§āϝ āϏāĻŦāĻšā§‡ā§Ÿā§‡ āĻŽā§ŒāϞāĻŋāĻ• āĻāĻŦāĻ‚ āϏāϰāĻžāϏāϰāĻŋ āĻŦā§‹āĻāĻžāϰ āωāĻĒāϝ⧋āĻ—ā§€ āĻ­āĻžāώāĻžāĨ¤ āĻāϟāĻŋ Binary Code āĻ (0 āĻāĻŦāĻ‚ 1 āĻāϰ āϏāĻŽāĻ¨ā§āĻŦā§Ÿā§‡) āϞ⧇āĻ–āĻž āĻšā§Ÿ, āϝāĻž Computer Hardware āĻĻā§āĻŦāĻžāϰāĻž āϏāϰāĻžāϏāϰāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤ Machine āĻ­āĻžāώāĻžā§Ÿ Computer āϝ⧇āϏāĻŦ Instruction(āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž) āĻ—ā§āϰāĻšāĻŖ āĻ•āϰ⧇, āϏ⧇āϗ⧁āϞ⧋ Program āĻāϰ Command āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦāĻŋāĻŦ⧇āϚāĻŋāϤ āĻšā§ŸāĨ¤

    Machine āĻ­āĻžāώāĻžāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. Binary Code āĻ āϞ⧇āĻ–āĻž ⇒ Machine āĻ­āĻžāώāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ 0 āĻāĻŦāĻ‚ 1 (Binary āϏāĻ‚āĻ–ā§āϝāĻž) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϞ⧇āĻ–āĻž āĻšā§Ÿ, āϝāĻž Computer Hardware(āϝ⧇āĻŽāύ Processor) āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    2. Computer āĻĻā§āĻŦāĻžāϰāĻž āϏāϰāĻžāϏāϰāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ ⇒ Machine āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž āϕ⧋āύ⧋ Program Computer āϏāϰāĻžāϏāϰāĻŋ āύāĻŋāĻ°ā§āĻŦāĻžāĻš (execute) āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϕ⧋āύ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ­āĻžāώāĻžāϰ āĻ…āύ⧁āĻŦāĻžāĻĻ (translation) āĻ›āĻžā§œāĻžāχāĨ¤
    3. Processor āύāĻŋāĻ°ā§āĻ­āϰ ⇒ āĻŽā§‡āĻļāĻŋāύ āĻ­āĻžāώāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Processor āĻāϰ āϜāĻ¨ā§āϝ āφāϞāĻžāĻĻāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻžāϰāĻŖ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Processor āĻāϰ āϜāĻ¨ā§āϝ Instruction āϏ⧇āϟ āĻ­āĻŋāĻ¨ā§āύ āĻšā§ŸāĨ¤
    4. āωāĻšā§āϚ āĻ—āϤāĻŋāϰ āĻ•āĻžāϜ ⇒ Machine āĻ­āĻžāώāĻž āϏāϰāĻžāϏāϰāĻŋ Hardware āĻĻā§āĻŦāĻžāϰāĻž āĻĒāϰāĻŋāϚāĻžāϞāĻŋāϤ āĻšāĻ“ā§ŸāĻžā§Ÿ āĻāϟāĻŋ āĻĻā§āϰ⧁āϤ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

    Machine āĻ­āĻžāώāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻžāϏāĻŽā§‚āĻš:

    1. āωāĻšā§āϚ āĻ—āϤāĻŋāϰ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ ⇒ Machine āĻ­āĻžāώāĻž āϏāϰāĻžāϏāϰāĻŋ Computer Hardware āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āϤāĻžāχ āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āϖ⧁āĻŦ āĻĻā§āϰ⧁āϤāĨ¤
    2. Computer āĻĻā§āĻŦāĻžāϰāĻž āĻĒā§‚āĻ°ā§āĻŖāĻžāĻ™ā§āĻ—āĻ­āĻžāĻŦ⧇ āĻŦā§‹āĻāĻž ⇒ āϕ⧋āύ⧋ āϰ⧂āĻĒ⧇ āĻ…āύ⧁āĻŦāĻžāĻĻ⧇āϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§Ÿ āύāĻž, āϝāĻž Program āĻāϰ āĻĻā§āϰ⧁āϤ āϏāĻŽā§āĻĒāĻžāĻĻāύāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧇āĨ¤
    3. āύāĻŋāĻ°ā§āϭ⧁āϞāϤāĻž ⇒ Machine āĻ­āĻžāώāĻžā§Ÿ āϕ⧋āύ⧋ āĻ­āĻžāώāĻžāĻ—āϤ āĻ¤ā§āϰ⧁āϟāĻŋ āĻŦāĻž āϭ⧁āϞ āĻšāĻ“ā§ŸāĻžāϰ āϏāĻŽā§āĻ­āĻžāĻŦāύāĻž āϖ⧁āĻŦ āĻ•āĻŽ, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Code āĻāĻŦāĻ‚ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻžā§Ÿ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

    Machine āĻ­āĻžāώāĻžāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϏāĻŽā§‚āĻš:

    1. āĻŽāĻžāύ⧁āώ⧇āϰ āĻĒ⧜āĻž āĻ•āĻ āĻŋāύ ⇒ Machine āĻ­āĻžāώāĻžāϰ Code(Binary Code) āĻŽāĻžāύ⧁āώ⧇āϰ āϜāĻ¨ā§āϝ āĻŦā§‹āĻāĻž āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻ•āĻ āĻŋāύ, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ āĻļ⧁āϧ⧁ 0 āĻāĻŦāĻ‚ 1 āĻāϰ āϏāĻ‚āĻŽāĻŋāĻļā§āϰāĻŖāĨ¤
    2. āϝāĻĨāĻžāϝāĻĨ Coding āĻĻāĻ•ā§āώāϤāĻž āĻĒā§āĻ°ā§Ÿā§‹āϜāύ ⇒ Machine āĻ­āĻžāώāĻžā§Ÿ Programming āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ—āĻ­ā§€āϰ āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋāĻ—āϤ āĻœā§āĻžāĻžāύ āĻ“ āĻĻāĻ•ā§āώāϤāĻž āĻĒā§āϰāϝāĻŧā§‹āϜāύāĨ¤
    3. Portable āύ⧟ ⇒ Machine āĻ­āĻžāώāĻž āĻāĻ• Processor āĻāϰ āϜāĻ¨ā§āϝ āϞāĻŋāĻ–āĻŋāϤ āĻšāϞ⧇ āĻ…āĻ¨ā§āϝ Processor āĻ āϏ⧇āϟāĻž āϚāϞāĻŦ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ Instruction āϏ⧇āϟ āφāϞāĻžāĻĻāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. āĻĻā§€āĻ°ā§āϘ Programming āϏāĻŽā§Ÿ ⇒ Machine āĻ­āĻžāώāĻžā§Ÿ Code āϞ⧇āĻ–āĻž āĻāĻŦāĻ‚ āϏāĻ‚āĻļā§‹āϧāύ āĻ•āϰāϤ⧇ āĻŦ⧇āĻļāĻŋ āϏāĻŽā§Ÿ āĻāĻŦāĻ‚ āĻĒāϰāĻŋāĻļā§āϰāĻŽ āϞāĻžāϗ⧇āĨ¤

  • Assembly āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Assembly āĻ­āĻžāώāĻž āĻšāϞ āĻāĻ•āϟāĻŋ Computer Programming āĻ­āĻžāώāĻž āϝāĻž āϏāϰāĻžāϏāϰāĻŋ Computer āĻāϰ Hardware, āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ Processor āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Design āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āĻāϟāĻŋ Machine āĻ­āĻžāώāĻžāϰ āϏāĻžāĻĨ⧇ āϤ⧁āϞāύāĻžāĻŽā§‚āϞāĻ•āĻ­āĻžāĻŦ⧇ āĻāĻ• āϧāĻžāĻĒ āωāĻĒāϰ⧇ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ Programming āĻ­āĻžāώāĻžāϰ āĻāĻ•āϟāĻŋ āύ⧀āϚ⧁ āĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāϰāĻŋāϚāĻŋāϤāĨ¤

    Assembly āĻ­āĻžāώāĻžāϰ Code āϗ⧁āϞāĻŋ Machine āĻ­āĻžāώāĻžāϝāĻŧ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļ⧇āώ Program, āϝāĻž Assembler(āĻ…ā§āϝāĻžāϏ⧇āĻŽā§āĻŦāϞāĻžāϰ) āύāĻžāĻŽā§‡ āĻĒāϰāĻŋāϚāĻŋāϤ āĻāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

    Assembly āĻ­āĻžāώāĻžāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. Machine āĻ­āĻžāώāĻžāϰ āĻĒā§āϰāϤāĻŋāύāĻŋāϧāĻŋāĻ¤ā§āĻŦ ⇒ Assembly āĻ­āĻžāώāĻž āĻŽā§‚āϞāϤ Machine āĻ­āĻžāώāĻžāϰ āĻĒā§āϰāϤ⧀āϕ⧀ āϰ⧂āĻĒ, āϝ⧇āĻ–āĻžāύ⧇ Binary Code āĻāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤ⧇ Memory Location, Register āĻŦāĻž Instruction āĻļāĻŦā§āĻĻ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤
    2. Machine Code āĻāϰ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋ ⇒ Assembly āĻ­āĻžāώāĻž Machine Code āĻāϰ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋ āĻĨāĻžāϕ⧇, āϤāĻžāχ āĻāϟāĻŋ Computer āϕ⧇ āϖ⧁āĻŦ āϏ⧋āϜāĻž āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ Instruction āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    3. Processor āύāĻŋāĻ°ā§āĻ­āϰ ⇒ Assembly āĻ­āĻžāώāĻžāĻ“ Processor āύāĻŋāĻ°ā§āĻ­āϰ, āĻ…āĻ°ā§āĻĨāĻžā§Ž, āĻāĻ• Processor āĻāϰ āϜāĻ¨ā§āϝ āϞ⧇āĻ–āĻž Code āĻ…āĻ¨ā§āϝ Processor āĻāϰ āϜāĻ¨ā§āϝ āĻ•āĻžāϜ āύāĻžāĻ“ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϝ⧇āĻŽāύ, x86 āĻŦāĻž ARM-āĻāϰ āϜāĻ¨ā§āϝ āφāϞāĻžāĻĻāĻž Assembly āĻ­āĻžāώāĻž āĻĒā§āĻ°ā§Ÿā§‹āϜāύāĨ¤
    4. āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Register āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻ•ā§āώāĻŽāϤāĻž ⇒ Assembly āĻ­āĻžāώāĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āϏāϰāĻžāϏāϰāĻŋ Processor āĻāϰ Register āϗ⧁āϞāĻŋāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤
    5. Computer Hardware āĻāϰ āϏāĻžāĻĨ⧇ āϏāϰāĻžāϏāϰāĻŋ Interaction ⇒ Assembly āĻ­āĻžāώāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ Computer Hardware āϝ⧇āĻŽāύ Memory, Input āĻāĻŦāĻ‚ Output Device, āĻāĻŦāĻ‚ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āωāĻĒāĻžāĻĻāĻžāύ⧇āϰ āϏāĻžāĻĨ⧇ āϏāϰāĻžāϏāϰāĻŋ āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤
    6. āĻŦāĻ°ā§āĻŖāύāĻž-āĻŽā§āĻ–ā§€ (Mnemonics) ⇒ Assembly āĻ­āĻžāώāĻžāϝāĻŧ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Mnemonics, āϝ⧇āĻŽāύ MOV, ADD, SUB, āϝāĻž Machine āĻ­āĻžāώāĻžāϰ Binary Code āĻāϰ āϜāĻ¨ā§āϝ āĻĒā§āϰāϤ⧀āĻ• āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    7. Computer āĻĻā§āĻŦāĻžāϰāĻž āύāĻŋāĻ°ā§āĻŦāĻžāĻšāϝ⧋āĻ—ā§āϝ āύ⧟ āϏāϰāĻžāϏāϰāĻŋ ⇒ Assembly āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž Code āϏāϰāĻžāϏāϰāĻŋ Computer āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϚāĻžāϞāĻžāύ⧋ āϏāĻŽā§āĻ­āĻŦ āύāϝāĻŧ, āĻāϕ⧇ āĻĒā§āϰāĻĨāĻŽā§‡ Assembler āĻĻāĻŋāϝāĻŧ⧇ Machine āĻ­āĻžāώāĻžāϝāĻŧ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāϤ⧇ āĻšā§ŸāĨ¤

    Assembly āĻ­āĻžāώāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻžāϏāĻŽā§‚āĻš:

    1. āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ ⇒ Assembly āĻ­āĻžāώāĻž Machine āĻ­āĻžāώāĻžāϰ āϖ⧁āĻŦ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋ āĻšāĻ“āϝāĻŧāĻžāϝāĻŧ āĻāϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĨ¤ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϖ⧁āĻŦ āĻ•āĻŽ āϏāĻŽā§Ÿā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ Code āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤
    2. Computer Hardware āĻāϰ āωāĻĒāϰ āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ ⇒ Assembly āĻ­āĻžāώāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ Programmer, Hardware āĻāϰ āωāĻĒāϰ āĻĒā§‚āĻ°ā§āĻŖ āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ Memory āĻĒāϰāĻŋāϚāĻžāϞāύāĻž, Register āĻŦā§āϝāĻŦāĻšāĻžāϰ āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    3. āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Optimization ⇒ Assembly āĻ­āĻžāώāĻžāϝāĻŧ Code Optimize āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ, āĻ•āĻžāϰāĻŖ Programmer Memory āĻāĻŦāĻ‚ Processor āĻāϰ Resource āϗ⧁āϞāĻŋāϰ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    • āωāĻšā§āϚ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž ⇒ Assembly āĻ­āĻžāώāĻžā§Ÿ Code Compile āĻšāĻ“ā§ŸāĻžāϰ āĻĒāϰ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻšā§Ÿ, āϝāĻž āϏāϰāĻžāϏāϰāĻŋ Hardware āĻ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻāϰ āĻĢāϞ⧇ āĻāϟāĻŋ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    • āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Hardware Configuration ⇒ āϝāĻĻāĻŋ āφāĻŽāϰāĻž āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Hardware āĻāϰ āϜāĻ¨ā§āϝ Code āϞāĻŋāĻ–āϤ⧇ āϚāĻžāχ, āϤāĻŦ⧇ Assembly āĻ­āĻžāώāĻž āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤
    • Compact āϕ⧋āĻĄ ⇒ Assembly āĻ­āĻžāώāĻžā§Ÿ āϞāĻŋāĻ–āĻŋāϤ Code āϏāĻžāϧāĻžāϰāĻŖāϤ āϖ⧁āĻŦ āϛ⧋āϟ āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻšā§Ÿ, āĻ•āĻžāϰāĻŖ āĻāϤ⧇ āĻĒā§āĻ°ā§Ÿā§‹āϜāĻ¨ā§€ā§Ÿ Memory Space āĻ•āĻŽ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
    • āĻ•āĻŽ āĻ¸ā§āĻĨāĻžāύ āĻĻāĻ–āϞ ⇒ Assembly āĻ­āĻžāώāĻžāϝāĻŧ Program āϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻ•āĻŽ Memory āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ āϖ⧁āĻŦ āϏāĻ‚āĻ•ā§āώāĻŋāĻĒā§āϤ āĻāĻŦāĻ‚ āϏāϰāĻžāϏāϰāĻŋ Machine āĻ­āĻžāώāĻžāϝāĻŧ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    • āĻŦāĻŋāĻļ⧇āώ āωāĻĻā§āĻĻ⧇āĻļā§āϝ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ ⇒ Software Optimization āĻāϰ āϜāĻ¨ā§āϝ āĻŦāĻž āϕ⧋āύ⧋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Hardware āϚāĻžāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ Assembly āĻ­āĻžāώāĻž āϖ⧁āĻŦāχ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĨ¤

    Assembly āĻ­āĻžāώāĻžāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϏāĻŽā§‚āĻš:

    1. āĻŦ⧇āĻļāĻŋ āϜāϟāĻŋāϞāϤāĻž ⇒ Assembly āĻ­āĻžāώāĻž āĻļāĻŋāĻ–āϤ⧇ āĻāĻŦāĻ‚ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻ…āύ⧇āĻ• āĻ•āĻ āĻŋāύ, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ Machine āĻ­āĻžāώāĻžāϰ āϖ⧁āĻŦ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āĻāϤ⧇ āĻ•āĻŽāĻĒāĻ•ā§āώ⧇ āĻĒā§āϰāĻžāĻĨāĻŽāĻŋāĻ• āĻĒāĻ°ā§āϝāĻžāϝāĻŧ⧇ Computer Architecture āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āĻ—āĻ­ā§€āϰ āϧāĻžāϰāĻŖāĻž āĻĨāĻžāĻ•āϤ⧇ āĻšā§ŸāĨ¤
    2. Code āϞ⧇āĻ–āĻž āϏāĻŽā§ŸāϏāĻžāĻĒ⧇āĻ•ā§āώ ⇒ Assembly āĻ­āĻžāώāĻžā§Ÿ Code āϞ⧇āĻ–āĻž āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ High Level āĻ­āĻžāώāĻžāϰ āϤ⧁āϞāύāĻžāϝāĻŧ āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋ āϏāĻŽā§ŸāϏāĻžāĻĒ⧇āĻ•ā§āώ āĻāĻŦāĻ‚ āĻļā§āϰāĻŽāϏāĻžāĻ§ā§āϝāĨ¤ āĻ•āĻžāϰāĻŖ āĻāĻ–āĻžāύ⧇ āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋ Manual āĻ•āĻžāĻœā§‡āϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ āĻāĻŦāĻ‚ Code āĻāϰ āĻĒāĻžāĻ āϝ⧋āĻ—ā§āϝāϤāĻž āĻ•āĻŽāĨ¤
    3. Portable āύ⧟ ⇒ Assembly āĻ­āĻžāώāĻžāϰ Code āĻāĻ• Processor āĻāϰ āϜāĻ¨ā§āϝ āϞ⧇āĻ–āĻž āĻšāϞ⧇ āĻ…āĻ¨ā§āϝ Processor āĻ āϏ⧇āϟāĻŋ āϚāϞāĻŦ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ āĻĒā§āϰāϤāĻŋāϟāĻŋ Processor āĻāϰ Instructions āϏ⧇āϟ āĻ­āĻŋāĻ¨ā§āύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. āĻāĻ–āύāĻ•āĻžāϰ āϏāĻŽā§Ÿā§‡āϰ āωāĻ¨ā§āύāϤ āĻĒā§āĻ°ā§Ÿā§‹āϜāĻ¨ā§€ā§ŸāϤāĻž ⇒ āĻŦāĻ°ā§āϤāĻŽāĻžāύ āϏāĻŽā§Ÿā§‡āϰ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— Programming āĻ­āĻžāώāĻž High Level āĻāĻŦāĻ‚ Assembly āĻ­āĻžāώāĻžāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻ…āύ⧇āĻ•āϟāĻžāχ āĻ•āĻŽā§‡ āϗ⧇āϛ⧇āĨ¤ āϤāĻžāχ, Assembly āĻ­āĻžāώāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻŦāĻŋāĻļ⧇āώ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇āχ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧ, āϝ⧇āĻŽāύ Operating System āĻāϰ Development, Embedded System āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Assembly āĻ­āĻžāώāĻž Computer āĻāϰ Hardware āĻāϰ āϏāĻžāĻĨ⧇ āϏāϰāĻžāϏāϰāĻŋ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āϖ⧁āĻŦ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϜāϟāĻŋāϞ āĻāĻŦāĻ‚ āϏāĻŽā§ŸāϏāĻžāĻĒ⧇āĻ•ā§āώ, āϤāĻžāχ āϏāĻžāϧāĻžāϰāĻŖ Programming āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ High Level āĻ­āĻžāώāĻž (āϝ⧇āĻŽāύ C, Python, Java) āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤


  • Mid Level āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Mid-level āĻ­āĻžāώāĻž āĻŦāϞāϤ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāĻŽāύ āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻžāϕ⧇ āĻŦā§‹āĻāĻžāύ⧋ āĻšāϝāĻŧ āϝāĻž āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž (High-level language) āĻāĻŦāĻ‚ āύāĻŋāĻŽā§āύ āĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž (Low-level language) āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ āĻ•āϰ⧇āĨ¤ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋ āĻŽā§‚āϞāϤ Hardware āĻ“ Software āĻāϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ• āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇, āĻāĻŦāĻ‚ āϤāĻžāĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϟāĻŋ āϏ⧇āϤ⧁ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āϏāϰāĻžāϏāϰāĻŋ Hardware āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϰ Syntax āĻŦāĻž Concept High Level āĻ­āĻžāώāĻžāϰ āĻŽāϤ⧋ āϏāĻšāϜāĻ“ āĻšā§ŸāĨ¤ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āωāĻ¨ā§āύāϤ āĻĢāĻŋāϚāĻžāϰ āϝ⧇āĻŽāύ Portability, Programming āϏ⧁āĻŦāĻŋāϧāĻž, āĻāĻŦāĻ‚ āϏāϰāĻžāϏāϰāĻŋ Memory Access āĻĒāĻžāĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤

    Mid Level āĻ­āĻžāώāĻžāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. Hardware āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŖ ⇒ Mid Level āĻ­āĻžāώāĻžāϗ⧁āϞ⧋ āϏāĻžāϧāĻžāϰāĻŖāϤ Assembly āĻ­āĻžāώāĻž āĻāĻŦāĻ‚ C āĻāϰ āĻŽāϤ⧋ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āĻŽāϤ⧋, āϝāĻž Hardware āĻāϰ āĻ•āĻžāϛ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽ āĻšā§ŸāĨ¤ āĻāϤ⧇ āφāĻŽāϰāĻž Pointer āĻŦāĻž Memory Access āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Computer Hardware āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤
    2. Memory Manipulation ⇒ āĻāϟāĻŋ Programmer āϕ⧇ āϏāϰāĻžāϏāϰāĻŋ Memory Address āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰāϤ⧇ āĻĻ⧇āϝāĻŧ, āϝ⧇āĻŽāύ Pointer āĻŦā§āϝāĻŦāĻšāĻžāϰ, āϝāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ High Level āĻ­āĻžāώāĻžāϝāĻŧ āĻĒāĻžāĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧ āύāĻžāĨ¤
    3. Hardware āĻāϰ āĻ•āĻžāϛ⧇ Access ⇒ Mid Level āĻ­āĻžāώāĻžāϝāĻŧ Program āϗ⧁āϞāĻŋ āϏāϰāĻžāϏāϰāĻŋ Hardware āĻāĻŦāĻ‚ Operating System āĻāϰ āϏāĻžāĻĨ⧇ āϝ⧋āĻ—āĻžāϝ⧋āĻ— āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽāĨ¤ āϝ⧇āĻŽāύ CPU, RAM, āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϰ āϏāĻ™ā§āϗ⧇ āϘāύāĻŋāĻˇā§āĻ āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžā§Ÿ, āĻĢāϞ⧇ Operating System āĻāĻŦāĻ‚ Computer Management āϏāĻšāϜ āĻšā§ŸāĨ¤
    4. Portability ⇒ āϝāĻĻāĻŋāĻ“ āĻāϟāĻŋ Hardware āύāĻŋāĻ°ā§āĻ­āϰ, āϤāĻŦ⧇ āĻ­āĻžāϞ⧋āĻ­āĻžāĻŦ⧇ Design āĻ•āϰāĻž Mid Level āĻ­āĻžāώāĻžāϰ Program āϗ⧁āϞāĻŋ āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āωāĻĒāϰ Portable āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ C āĻ­āĻžāώāĻžāϰ Program āϗ⧁āϞāĻŋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Platform āĻ Run āĻ•āϰāĻžāĨ¤
    5. Performance ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĻā§āϰ⧁āϤ āϰāĻžāύ āĻ•āϰ⧇ āĻ•āĻžāϰāĻŖ āϏ⧇āϗ⧁āϞ⧋ Computer System āĻāϰ āύāĻŋāĻ•āϟāĻ¸ā§āĻĨ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āĻŦ⧇āĻļāĻŋ Optimized āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤
    6. Assembly āĻ­āĻžāώāĻžāϰ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋ ⇒ Mid Level āĻ­āĻžāώāĻž āĻĒā§āϰāĻžāϝāĻŧāĻļāχ Assembly āĻ­āĻžāώāĻžāϰ āĻŽāϤ⧋, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϰ āĻ•āĻŋāϛ⧁ āϏ⧁āĻŦāĻŋāϧāĻž āϝ⧇āĻŽāύ Automatic Memory Management āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āĻĨāĻžāϕ⧇āĨ¤

    Mid Level āĻ­āĻžāώāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž:

    1. Performance ⇒ Computer System āĻāϰ āϏāĻžāĻĨ⧇ āĻŦ⧇āĻļāĻŋ āϏāĻ‚āϝ⧁āĻ•ā§āϤ āĻšāĻ“ā§ŸāĻžā§Ÿ, āĻāϰ Code āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĻā§āϰ⧁āϤ āĻ“ āĻĻāĻ•ā§āώāĻ­āĻžāĻŦ⧇ Run āĻ•āϰ⧇āĨ¤
    2. āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŖ ⇒ Memory, Hardware āĻāĻŦāĻ‚ System Resource āĻāϰ āωāĻĒāϰ āĻĒā§‚āĻ°ā§āĻŖ āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŖ āĻĒāĻžāĻ“ā§ŸāĻž āϝāĻžā§ŸāĨ¤
    3. Portability ⇒ āĻ•āĻŋāϛ⧁ Mid Level āĻ­āĻžāώāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Platform āĻ āϚāϞāϤ⧇ āĻĒāĻžāϰ⧇ (āϝ⧇āĻŽāύ C). āϤāĻŦ⧇, Code āĻāϰ āϏāĻžāĻŽāĻžāĻ¨ā§āϝ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻŦāĻž āϏāĻžāĻŽāĻžā§āϜāĻ¸ā§āϝ⧇āϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. āĻŦ⧜ System Development ⇒ Operating System, Driver, Academic Software, Embedded System āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧁āĻ•ā§āϤāĨ¤

    Mid Level āĻ­āĻžāώāĻžāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž:

    1. Complexity ⇒ āĻāϟāĻŋ āĻ•āĻŋāϛ⧁āϟāĻž āϜāϟāĻŋāϞ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ āϝāĻ–āύ Programmer āϕ⧇ Memory āĻāĻŦāĻ‚ Hardware āύāĻŋāϝāĻŧāĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤ āϝāĻž āύāϤ⧁āύ āĻŦāĻž āĻ…āĻ˛ā§āĻĒ āĻ…āĻ­āĻŋāĻœā§āĻž Programmers āĻāϰ āϜāĻ¨ā§āϝ āĻ•āĻ āĻŋāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    2. Memory Management ⇒ āϝāĻĻāĻŋāĻ“ āĻāϟāĻŋ āĻ…āύ⧇āĻ• āϏ⧁āĻŦāĻŋāϧāĻž āĻĻ⧇āϝāĻŧ, āϤāĻŦ⧇ āĻ•āĻŋāϛ⧁ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ Manual Memory Management Programmers āĻāϰ āϜāĻ¨ā§āϝ āϏāĻŽāĻ¸ā§āϝāĻž āϏ⧃āĻˇā§āϟāĻŋ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ Memory Lick.
    3. āϏāĻŽāϝāĻŧāϏāĻžāĻĒ⧇āĻ•ā§āώ ⇒ Code āϞ⧇āĻ–āĻžāϰ āϏāĻŽā§Ÿā§‡ āĻ•āĻŋāϛ⧁ āϏāĻŽāϝāĻŧ āĻāϟāĻŋ Compile āĻšāϤ⧇ āϏāĻŽāϝāĻŧ āύāĻŋāϤ⧇ āĻĒāĻžāϰ⧇ āĻāĻŦāĻ‚ Programming āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻŦ⧇āĻļāĻŋ āĻŽāύ⧋āϝ⧋āĻ— āĻāĻŦāĻ‚ āϭ⧁āϞ⧇āϰ āϜāĻ¨ā§āϝ āϏāĻŽāϝāĻŧ āύāĻˇā§āϟ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. Debugging Challenge ⇒ Mid Level āĻ­āĻžāώāĻžāϝāĻŧ Code Debug āĻ•āϰāĻž āϤ⧁āϞāύāĻžāĻŽā§‚āϞāĻ•āĻ­āĻžāĻŦ⧇ āĻ•āĻ āĻŋāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ Hardware āĻāϰ āĻ•āĻžāĻ›āĻžāĻ•āĻžāĻ›āĻŋ āĻāĻŦāĻ‚ āĻ•āĻŋāϛ⧁ āĻ…āĻ‚āĻļ āφāϰ⧋ Complex.

    āϏ⧁āϤāĻžāϰāĻžāĻ‚, Mid Level āĻ­āĻžāώāĻž āĻāĻ•āϟāĻŋ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ Tool āϝāĻž Programmers āϏāϰāĻžāϏāϰāĻŋ Hardware āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĻ⧇āϝāĻŧ, āϤāĻŦ⧇ āĻāϟāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āϜāĻ¨ā§āϝ āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ āĻĻāĻ•ā§āώāϤāĻž āĻāĻŦāĻ‚ āĻŽāύ⧋āϝ⧋āĻ— āĻĒā§āϰāϝāĻŧā§‹āϜāύāĨ¤


  • High Level āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    High-level āĻ­āĻžāώāĻž (āωāĻšā§āϚāĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž) āĻšāϞ āϏ⧇āχ āϧāϰāύ⧇āϰ Programming āĻ­āĻžāώāĻž āϝāĻž āĻŽāĻžāύ⧁āώ⧇āϰ āϜāĻ¨ā§āϝ āϏāĻšāĻœā§‡ āĻŦā§‹āϧāĻ—āĻŽā§āϝ āĻāĻŦāĻ‚ Computer āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇ āϤāĻž āĻĒā§āϰāĻĻāĻ°ā§āĻļāύ āĻ•āϰāĻžāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤ⧇ Programmer āĻāϰ āĻ•āĻžāϜāϕ⧇ āϏāĻšāϜ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ Compiler āĻŦāĻž Interpreter āϏāϰāĻžāϏāϰāĻŋ Computer Hardware āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āϤāĻžāχ Program āϞ⧇āĻ–āĻžāϰ āϏāĻŽāϝāĻŧ Programmer āĻ…āύ⧇āĻ•āϟāĻžāχ Complexity āĻĨ⧇āϕ⧇ āĻŽā§āĻ•ā§āϤāĻŋ āĻĒ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

    High-level āĻ­āĻžāώāĻžāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. āĻŽāĻžāύāĻŦ āĻĒāĻžāĻ āϝ⧋āĻ—ā§āϝāϤāĻž ⇒ High-level āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āχāĻ‚āϰ⧇āϜāĻŋ āĻ­āĻžāώāĻžāϰ āĻŽāϤ⧋ Semantic āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϝāĻž Programmers āĻāϰ Code āϞ⧇āĻ–āĻž āϏāĻšāϜ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤
    2. Authentication āĻĨ⧇āϕ⧇ āĻ¸ā§āĻŦāĻžāϧ⧀āύāϤāĻž ⇒ Computer Hardware āĻāϰ āύāĻŋāĻ°ā§āĻ­āϰāϤāĻž āĻĨ⧇āϕ⧇ āĻĨ⧇āϕ⧇ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāĻ­āĻžāĻŦ⧇ āĻĨ⧇āϕ⧇ āĻŽā§āĻ•ā§āϤ āĻĨāĻžāϕ⧇āĨ¤ Program āϟāĻŋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ Computing System āĻ Run āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    3. Automated Memory Management ⇒ āĻ…āϧāĻŋāĻ•āĻžāĻ‚āĻļ High-level āĻ­āĻžāώāĻžāϝāĻŧ Memory āĻŦā§āϝāĻŦāĻ¸ā§āĻĨāĻžāĻĒāύāĻž Automatically āĻšāϝāĻŧ (āϝ⧇āĻŽāύ Garbage Collection). āĻāϤ⧇ Manually Memory Allocation āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āύāĻžāĨ¤
    4. Portable ⇒ āĻāĻ• Computer āĻ āϞ⧇āĻ–āĻž Program āĻ…āĻ¨ā§āϝ Computer āĻ Compile āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ, āϝāĻĻāĻŋ āϏ⧇āχ Computer āĻ“ āĻāĻ•āχ āϧāϰāύ⧇āϰ Compiler āĻŦāĻž Interpreter āϚāĻžāϞāĻžāϝāĻŧāĨ¤
    5. āĻŦ⧈āϚāĻŋāĻ¤ā§āĻ°ā§āϝāĻŽāϝāĻŧ Data Type āĻāĻŦāĻ‚ Function ⇒ āĻ…āϧāĻŋāĻ•āĻžāĻ‚āĻļ High-level āĻ­āĻžāώāĻž āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ Data Type (āϝ⧇āĻŽāύ, integers, floats, strings) āĻāĻŦāĻ‚ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ Function āĻŦāĻž Library āϏāϰāĻŦāϰāĻžāĻš āĻ•āϰ⧇āĨ¤
    6. Abstraction ⇒ Complex Computational āĻ•āĻžāϜāϕ⧇ āϏāϰāϞāĻ­āĻžāĻŦ⧇ āωāĻĒāĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āφāϰāĻ“ āĻ­āĻžāϞ⧋ Abstraction āϏāϰāĻŦāϰāĻžāĻš āĻ•āϰ⧇āĨ¤ āϝ⧇āĻŽāύ, Loop, Conditional Statement āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    High-level āĻ­āĻžāώāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž:

    1. āϏāĻšāϜ āĻļāĻŋāĻ–āϤ⧇ āĻ“ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Programmers āĻāϰ āϜāĻ¨ā§āϝ āφāϰāĻ“ āϏāĻšāϜ, āĻ•āĻžāϰāĻŖ Code āϏāĻšāĻœā§‡ āĻĒāĻĄāĻŧāĻž āĻ“ āĻŦā§‹āĻāĻž āϝāĻžāϝāĻŧāĨ¤
    2. āĻ•āĻŽ āϏāĻŽāϝāĻŧ⧇ Program āϤ⧈āϰāĻŋ ⇒ Code āϞ⧇āĻ–āĻžāϰ āϏāĻŽāϝāĻŧ āĻ•āĻŽ āϏāĻŽāϝāĻŧ āϞāĻžāϗ⧇, āĻ•āĻžāϰāĻŖ Complexity āĻ…āύ⧇āĻ•āϟāĻžāχ Abstract āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
    3. āĻŦāĻšā§ Platform āĻ āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžāϝāĻŧ ⇒ Portability āĻāϰ āĻ•āĻžāϰāϪ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Hardware āĻ āĻŦāĻž Operating System āĻ āĻāĻ•āχ Code Run āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. āϏāĻ‚āĻļā§‹āϧāύ āĻāĻŦāĻ‚ Debugging āϏāĻšāϜ ⇒ Error āĻŦāĻž Bug āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰāĻž āϏāĻšāϜ āĻšāϝāĻŧ, āĻ•āĻžāϰāĻŖ Code āĻāϰ āĻ—āĻ āύ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āĻĨāĻžāϕ⧇āĨ¤
    5. Developer Productivity āĻŦ⧃āĻĻā§āϧāĻŋ ⇒ Programmers āĻāϰ āϏ⧃āϜāύāĻļā§€āϞāϤāĻž āĻ“ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āϏāĻŽāϝāĻŧ āĻŦ⧃āĻĻā§āϧāĻŋ āĻĒāĻžāϝāĻŧ, āĻ•āĻžāϰāĻŖ āϤāĻžāĻĻ⧇āϰ Complex System āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻŦāĻž Manual āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āύāĻžāĨ¤

    High-level āĻ­āĻžāώāĻžāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž:

    1. Computer Resource āĻŦ⧇āĻļāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ ⇒ High-level āĻ­āĻžāώāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ Computer āĻāϰ Resource(āϝ⧇āĻŽāύ CPU, Memory) āĻŦ⧇āĻļāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ āĻāϗ⧁āϞāĻŋ Hardware Details āĻ āĻ•āĻžāϜ āύāĻž āĻ•āϰ⧇ Abstract āĻ•āϰ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    2. Code Running Time Slow ⇒ High-level āĻ­āĻžāώāĻžāϝāĻŧ Program Run āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ āϞ⧇āϗ⧇ āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ Compiler āĻŦāĻž Interpreter āĻĻā§āĻŦāĻžāϰāĻž Execute āĻšāϝāĻŧ āĻāĻŦāĻ‚ Mid Level Code āĻāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰāĻļā§€āϞ āĻĨāĻžāϕ⧇āĨ¤
    3. Compiler āĻŦāĻž Interpreter āĻāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰāϤāĻž ⇒ High-level āĻ­āĻžāώāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻšāϞ⧇ Programmer āϕ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Compiler āĻŦāĻž Interpreter āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϚāĻžāϞāĻžāϤ⧇ āĻšāϝāĻŧ, āϝāĻž āĻ•āĻ–āύāĻ“ āĻ•āĻ–āύāĻ“ āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āĻ•āĻŽāĻŋāϝāĻŧ⧇ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. Hardware āĻāϰ āϏāĻžāĻĨ⧇ āϏāϰāĻžāϏāϰāĻŋ Interaction āĻ•āĻ āĻŋāύ ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Hardware āĻāϰ āϏāĻžāĻĨ⧇ āϏāϰāĻžāϏāϰāĻŋ āĻ•āĻžāϜ āĻ•āϰāĻž āϖ⧁āĻŦāχ āĻ•āĻ āĻŋāύ āĻŦāĻž āϏāĻŽā§āĻ­āĻŦ āύāϝāĻŧāĨ¤

    āϏ⧁āϤāϰāĻžāĻ‚, High-level āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϏāĻšāϜ āĻŦā§āϝāĻŦāĻšāĻžāϰāϝ⧋āĻ—ā§āϝ, āĻĻā§āϰ⧁āϤ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ, āϤāĻŦ⧇ āĻāϗ⧁āϞāĻŋāϰ āĻ•āĻŋāϛ⧁ Computational āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āĻ“ Hardware āĻāϰ āϏāĻžāĻĨ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āĻ•āĻŋāϛ⧁ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž āϰāϝāĻŧ⧇āϛ⧇āĨ¤ āϤāĻžāχ High-level āĻ­āĻžāώāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāϰ āϏāĻŽā§Ÿ, āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āϏāĻšā§‡āϤāύ āĻĨāĻžāĻ•āĻž āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖāĨ¤


  • āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž (4th Generation Language, 4GL) āĻāĻŽāύ āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻž āϝāĻž āωāĻšā§āϚ-āĻ¸ā§āϤāϰ⧇āϰ āĻāĻŦāĻ‚ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āĻŦāĻ¨ā§āϧ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ, āĻāĻŦāĻ‚ āĻāϰ āĻŽā§‚āϞ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āϏāĻšāϜāĻ­āĻžāĻŦ⧇ Software Development āĻ āϏāĻšāĻžāϝāĻŧāϤāĻž āĻ•āϰāĻžāĨ¤ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ Abstraction āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻŦāĻŋāĻļ⧇āώāĻ­āĻžāĻŦ⧇ Database āĻĒāϰāĻŋāϚāĻžāϞāύāĻž, Report Generation, āĻŦāĻž Application Development āĻāϰ āϜāĻ¨ā§āϝ Design āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

    āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. āωāĻšā§āϚ āĻ¸ā§āϤāϰ⧇āϰ Abstraction ⇒ āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ Computer Hardware āĻŦāĻž Memory Management āύāĻŋāϝāĻŧ⧇ āĻ­āĻžāĻŦāĻžāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ āύāĻžāĨ¤ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ āĻ•āĻŽ Code āϞ⧇āĻ–āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰāϤ⧇ āϏāĻšāĻžāϝāĻŧāϤāĻž āĻ•āϰ⧇āĨ¤
    2. āϏāĻšāϜ āĻŦā§āϝāĻŦāĻšāĻžāϰ ⇒ āĻāϟāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ Complex Code āϞāĻŋāϖ⧇ āϏāĻŽāϝāĻŧ āύāĻˇā§āϟ āĻ•āϰāϤ⧇ āĻĻ⧇āϝāĻŧ āύāĻž, āĻŦāϰāĻ‚ āϏāĻšāϜ āĻāĻŦāĻ‚ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ• āĻ­āĻžāώāĻžāϝāĻŧ Development āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰāϤ⧇ āϏāĻšāĻžāϝāĻŧāĻ•āĨ¤
    3. Database āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• Application ⇒ 4GL Database āĻāϰ āϏāĻžāĻĨ⧇ āĻ­āĻžāϞ⧋āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ Data Management, āĻ•ā§ā§Ÿā§‡āϰāĻŋ(Query) āϞ⧇āĻ–āĻžāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻāϟāĻŋ āϖ⧁āĻŦāχ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĨ¤
    4. āĻŦāĻŋāύāĻžāĻŽā§‚āĻ˛ā§āϝ⧇ Graphics User Interface(GUI) ⇒ āĻ…āύ⧇āĻ• 4GL Software Package āĻāϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻšāϜ Graphical Interface āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ, āϝāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āĻĻ⧇āϰ āϜāĻ¨ā§āϝ Programming āϏāĻšāϜ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤
    5. Fast Development ⇒ 4GL āĻ­āĻžāώāĻžā§Ÿ āĻ•āĻŽ Code āϞāĻŋāϖ⧇ āĻĻā§āϰ⧁āϤ Application Develop āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦāĨ¤
    6. āĻŦāĻŋāĻļ⧇āώ āωāĻĻā§āĻĻ⧇āĻļā§āϝāĻĒā§āϰāĻŖāĻžāϞ⧀ ⇒ 4GL āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϝ⧇āĻŽāύ Database, Reporting, Graphics āχāĻ¤ā§āϝāĻžāĻĻāĻŋāϰ āϜāĻ¨ā§āϝ āϤ⧈āϰāĻŋ āĻšā§ŸāĨ¤

    āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž:

    1. āĻĻā§āϰ⧁āϤ Programming ⇒ 4GL āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Programming āĻ…āύ⧇āĻ• āĻĻā§āϰ⧁āϤ āĻšā§ŸāĨ¤ āĻ…āύ⧇āĻ• āϏāĻŽā§Ÿ āĻ•āĻŽ Code āϞāĻŋāϖ⧇āχ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤
    2. āϏāĻšāϜ āϏāĻŽāĻžāϧāĻžāύ ⇒ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āϏāĻšāϜ āĻāĻŦāĻ‚ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀-āĻŦāĻžāĻ¨ā§āϧāĻŦ āĻšā§Ÿ, āϝāĻžāϰ āĻĢāϞ⧇ Software Development āĻāϰ āϜāϟāĻŋāϞāϤāĻž āĻ•āĻŽā§‡ āϝāĻžā§ŸāĨ¤
    3. Database Manipulation ⇒ āĻĄā§‡āϟāĻžāĻŦ⧇āϏ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āĻāϟāĻŋ āĻŦāĻŋāĻļ⧇āώāĻ­āĻžāĻŦ⧇ āωāĻĒāϝ⧋āĻ—ā§€āĨ¤ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰāĻž āϏāĻšāĻœā§‡āχ Query, Report āĻāĻŦāĻ‚ Data āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. āĻ•āĻŽ Code āϞ⧇āĻ–āĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž ⇒ 4GL āĻ­āĻžāώāĻžāϝāĻŧ Code āĻ•āĻŽ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ, āĻĢāϞ⧇ Program āϞ⧇āĻ–āĻž āϏāĻšāϜ āĻāĻŦāĻ‚ āϛ⧋āϟ āĻšāϝāĻŧāĨ¤
    5. Computer Skills āĻ•āĻŽ āĻĨāĻžāĻ•āĻž āϏāĻ¤ā§āĻ¤ā§āĻŦ⧇āĻ“ āωāĻ¨ā§āύāϝāĻŧāύ ⇒ āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžā§Ÿ Code āϞ⧇āĻ–āĻžāϰ āϜāĻ¨ā§āϝ āĻ—āĻ­ā§€āϰ Programming āĻœā§āĻžāĻžāύ⧇āϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ āύāĻž, āϏ⧁āϤāϰāĻžāĻ‚ āύāϤ⧁āύ Developers āĻāϰ āϜāĻ¨ā§āϝ āĻāϟāĻŋ āϏ⧁āĻŦāĻŋāϧāĻžāϜāύāĻ•āĨ¤

    āϚāϤ⧁āĻ°ā§āĻĨ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž:

    1. āĻ•āĻŽ Flexibility ⇒ 4GL āĻ•āĻŋāϛ⧁ āĻŦāĻŋāĻļ⧇āώ āωāĻĻā§āĻĻ⧇āĻļā§āϝ⧇ āϤ⧈āϰāĻŋ āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻžāϰāϪ⧇, āϏāĻžāϧāĻžāϰāĻŖ āĻŦāĻž āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻĒā§‚āϰāϪ⧇āϰ āϜāĻ¨ā§āϝ āĻāϟāĻŋ āĻ•āĻŽāĻĢāϞāĻĻāĻžāϝāĻŧāĻ• āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    2. Performance āĻāϰ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž ⇒ 4GL āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Code āĻ Optimization āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻ•āϰāĻž āĻ•āĻ āĻŋāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻĢāϞ⧇ āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ Performance āĻ•āĻŽ āĻšāϝāĻŧāĨ¤
    3. āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž ⇒ āĻ…āύ⧇āĻ• āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ 4GL āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϧāϰāύ⧇āϰ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧋āĻ—ā§€, āϝ⧇āĻŽāύ Database Manipulation āĻŦāĻž Report āϤ⧈āϰāĻŋāϰ āĻ•āĻžāϜāĨ¤
    4. Code āĻāϰ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž ⇒ Code āĻāϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Structure āĻ“ āĻļāĻ°ā§āϤāĻžāĻŦāϞ⧀ āĻĨāĻžāĻ•āĻžāϝāĻŧ āϕ⧋āύ⧋ āϜāϟāĻŋāϞ āĻāĻŦāĻ‚ āĻŦāĻŋāĻļ⧇āώāϤ Custom Features āĻāϰ āϜāĻ¨ā§āϝ āĻ•āĻŽ Flexibility āĻĨāĻžāϕ⧇āĨ¤

    āϏ⧁āϤāĻžāϰāĻžāĻ‚, 4GL āĻ­āĻžāώāĻž āĻŽā§‚āϞāϤ āĻāĻŽāύ Software Development āĻ­āĻžāώāĻž āϝāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϕ⧇ āϏāĻšāϜ āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ Programming āĻ…āĻ­āĻŋāĻœā§āĻžāϤāĻž āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻŦāĻŋāĻļ⧇āώāĻ­āĻžāĻŦ⧇ Database Manipulation, Report Generation, āĻāĻŦāĻ‚ āĻŦāĻŋāĻļā§āϞ⧇āώāϪ⧇āϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧁āĻ•ā§āϤ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ•āĻŋāϛ⧁ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻāϰ Performance āĻāĻŦāĻ‚ Flexibility āϏ⧀āĻŽāĻŋāϤ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


  • āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž (5th Generation Language - 5GL) āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻžāϰ āĻĒāϰāĻŦāĻ°ā§āϤ⧀ āĻ¸ā§āϤāϰ, āϝāĻž āĻŽā§‚āϞāϤ āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻž (Artificial Intelligence - AI) āĻāĻŦāĻ‚ Automated Programming āĻāϰ āϜāĻ¨ā§āϝ Design āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Automatically āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āĻāĻŦāĻ‚ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰ Input āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻ—ā§āϰāĻšāϪ⧇ āϏāĻ•ā§āώāĻŽāĨ¤ āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āĻŽāĻžāύ⧁āώ⧇āϰ āĻ­āĻžāώāĻž āĻ“ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻ…āύ⧁āϏāϰāĻŖ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ 'Declarative Language' āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāϰāĻŋāϚāĻŋāϤ, āϝ⧇āĻ–āĻžāύ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āĻ•āĻŋ āĻ•āϰāϤ⧇ āϚāĻžāύ āϤāĻž āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻ⧇āύ, āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āϤāĻž āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āϤāĻž āύāϝāĻŧāĨ¤

    āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. Declarative āĻĒā§āϰāĻ•ā§ƒāϤāĻŋ ⇒ āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϝāĻŧ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āϕ⧇āĻŦāϞāĻŽāĻžāĻ¤ā§āϰ āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϞāĻ•ā§āĻˇā§āϝ āĻŦāĻž āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻŦāĻ°ā§āĻŖāύāĻž āĻ•āϰ⧇, System āύāĻŋāĻœā§‡ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻžāϰ āωāĻĒāĻžāϝāĻŧ āĻŦ⧇āϰ āĻ•āϰ⧇āĨ¤
    2. āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ ⇒ āĻāϟāĻŋ āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻž āĻāĻŦāĻ‚ Machine Learning āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽāĨ¤ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϝ⧇āĻŽāύ Programming āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Automatically āĻœā§āĻžāĻžāύ āĻ…āĻ°ā§āϜāύ āĻ“ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    3. Automated Programming ⇒ āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ Automated Program āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āĻŽ Code āϞ⧇āĻ–āĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ Programming āϏāĻšāϜ āĻšāϝāĻŧāĨ¤
    4. Natural āĻ­āĻžāώāĻžāϰ āϏāĻžāĻĨ⧇ āϏāĻ™ā§āĻ—āϤāĻŋ: āĻ…āύ⧇āĻ• āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž Natural āĻ­āĻžāώāĻžāϰ (āϝ⧇āĻŽāύ āχāĻ‚āϰ⧇āϜāĻŋ) āϏāĻžāĻĨ⧇ āϏāĻ™ā§āĻ—āϤāĻŋāĻĒā§‚āĻ°ā§āĻŖāĨ¤ āĻāϰ āĻĢāϞ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āĻ­āĻžāώāĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Command āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύāĨ¤
    5. āĻŦāĻ°ā§āϧāĻŋāϤ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ āĻ•ā§āώāĻŽāϤāĻž ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϜāϟāĻŋāϞ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽ, āϝ⧇āĻŽāύ Logical āϏāĻŽāĻ¸ā§āϝāĻžāϗ⧁āϞāĻŋ, Algorithm āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻāĻŦāĻ‚ āφāϰāĻ“ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āϜāϟāĻŋāϞ āϏāĻŽāĻžāϧāĻžāύāĨ¤

    āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž:

    1. āϏāĻšāϜ āĻŦā§āϝāĻŦāĻšāĻžāϰ ⇒ āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ Programmers āĻāϰāĻž āĻ•āĻŽ Coding āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύ āĻāĻŦāĻ‚ Program āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻ…āύ⧇āĻ• āϏāĻšāϜ āĻšāϝāĻŧāĨ¤
    2. āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āϏ⧁āĻŦāĻŋāϧāĻž ⇒ āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻžāϰ āĻļāĻ•ā§āϤāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϝāĻžāϰ āĻĢāϞ⧇ āĻāϟāĻŋ System āϕ⧇ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻžāύāĻ­āĻžāĻŦ⧇ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽ āĻ•āϰ⧇āĨ¤
    3. Automatic āϏāĻŽāĻžāϧāĻžāύ ⇒ āĻāϟāĻŋ Programming āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ Automate āϏāĻŽāĻžāϧāĻžāύ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇, āϝāĻž āĻŽāĻžāύāĻŦāĻļāĻ•ā§āϤāĻŋāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰāĻļā§€āϞāϤāĻž āĻ•āĻŽāĻžāϝāĻŧāĨ¤
    4. Declarative Programming ⇒ Programmer āϕ⧇ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āϞāĻ•ā§āĻˇā§āϝ āĻŦāĻž āϏāĻŽāĻ¸ā§āϝāĻž āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ, āϤāĻž āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ­āĻžāώāĻž āĻŦāĻž System āύāĻŋāĻœā§‡ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻŦ⧇āϰ āĻ•āϰ⧇āĨ¤
    5. āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ Debugging ⇒ Logical āĻ­āĻžāώāĻžā§Ÿ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ āϏāĻšāϜāϤāϰ āĻšā§Ÿ, āĻāĻŦāĻ‚ Debugging āĻ•āϰāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻĨāĻžāϕ⧇āĨ¤

    āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž:

    1. āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋāĻ—āϤ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ Computer System āĻāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāĻ—āϤ āĻĒāĻ°ā§āϝāĻžā§Ÿā§‡ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ āϝāĻĻāĻŋ System āĻāϰ āϝāĻĨ⧇āĻˇā§āϟ āϜāĻžā§ŸāĻ—āĻž āύāĻž āĻĨāĻžāϕ⧇āĨ¤
    2. Comparative Processing ⇒ āϏāĻžāϧāĻžāϰāĻŖāϤ 5GL-āĻ Coding āĻ•āϰāϞ⧇ System āĻāϰ Performance āĻ•āĻŽ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻžāϰāĻŖ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻ…āϤāĻŋ āϏāĻšāϜ āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž āĻšā§ŸāĨ¤
    3. āωāĻ¨ā§āύāϤ Hardware āĻĒā§āϰāϝāĻŧā§‹āϜāύ ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āĻ…āύ⧇āĻ•āϟāĻŋ āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻžāϰ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ Computer āĻāĻŦāĻ‚ Hardware āĻāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύāĨ¤
    4. āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻž āϏāĻŽāĻžāϧāĻžāύ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž ⇒ āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻ•āĻŋāϛ⧁ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĨ¤ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻŦā§āϝāĻžāĻĒāĻ• āϜāϟāĻŋāϞāϤāĻžā§Ÿ āĻāĻĻ⧇āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāĨ¤
    5. āĻļāĻŋāĻ–āϤ⧇ āĻ•āĻ āĻŋāύ ⇒ Declarative Programming āĻāĻŦāĻ‚ Logical Programming āĻāϰ āϧāĻžāϰāĻŖāĻž āĻ…āύ⧇āϕ⧇āϰ āϜāĻ¨ā§āϝ āύāϤ⧁āύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āĻāĻŦāĻ‚ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āĻ•āĻŋāϛ⧁ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻļāĻŋāĻ–āϤ⧇ āĻ•āĻŋāϛ⧁āϟāĻž āĻ•āĻ āĻŋāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    6. āϏāĻŽā§āĻĒā§āϰāϏāĻžāϰāϪ⧇āϰ āϏāĻŽāĻ¸ā§āϝāĻž ⇒ āĻāχ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āĻ…āύ⧇āĻ• āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇āχ āĻ…āĻĒāĻ°ā§āϝāĻžāĻĒā§āϤ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āĻŦ⧃āĻšāĻ¤ā§āϤāϰ āĻŦāĻž āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻŋāϤ Software System āϤ⧈āϰāĻŋāϰ āϜāĻ¨ā§āϝāĨ¤

    āĻĒāĻžā§āϚāĻŽ āĻĒā§āϰāϜāĻ¨ā§āĻŽā§‡āϰ āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋ āĻ•ā§ƒāĻ¤ā§āϰāĻŋāĻŽ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻ¤ā§āϤāĻž, Automate āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻ—ā§āϰāĻšāĻŖ, āĻāĻŦāĻ‚ Logical āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āωāĻĒāϝ⧁āĻ•ā§āϤāĨ¤ āϤāĻŦ⧇, āĻāϗ⧁āϞāĻŋāϰ āĻ•āĻŋāϛ⧁ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž āĻ°ā§Ÿā§‡āϛ⧇, āĻŦāĻŋāĻļ⧇āώāϤ Computer System āĻ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāĻ—āϤ āϜāϟāĻŋāϞāϤāĻž āĻāĻŦāĻ‚ Performance āĻāϰ āĻĻāĻŋāĻ• āĻĨ⧇āϕ⧇āĨ¤


  • Machine Code āĻāĻŦāĻ‚ Byte Code āĻ•āĻŋ?

    Machine Code:

    Machine Code āĻšāϞ⧋ āϏ⧇āχ Code āϝāĻž Computer āĻŦāĻž Device āĻāϰ CPU (Central Processing Unit) āϏāϰāĻžāϏāϰāĻŋ āĻŦ⧁āĻāϤ⧇ āĻāĻŦāĻ‚ Execute āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāϟāĻŋ āĻāĻ• āϧāϰāύ⧇āϰ Binary Code āϝāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ 0 āĻāĻŦāĻ‚ 1 āĻĻāĻŋā§Ÿā§‡ āĻ—āĻ āĻŋāϤāĨ¤ Machine Code āĻšāϞ Programming āĻ­āĻžāώāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āύāĻŋāĻšā§‡āϰ āĻ¸ā§āϤāϰ, āĻāĻŦāĻ‚ āĻāχ Code āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāĻ•āϟāĻŋ Computer āϤāĻžāϰ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽ āĻšā§ŸāĨ¤

    Byte Code:

    Byte Code āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Intermediate(āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀) Computer Code āϝāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ Interpreted āĻŦāĻž Portable Programming āĻ­āĻžāώāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āĻāϟāĻŋ āĻāĻ• āϧāϰāύ⧇āϰ Machine Instruction āϝāĻž āϏāϰāĻžāϏāϰāĻŋ āϕ⧋āύāĻ“ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Hardware āĻŦāĻž Processor āĻāϰ āϜāĻ¨ā§āϝ āϞ⧇āĻ–āĻž āĻšā§ŸāύāĻŋ, āĻŦāϰāĻ‚ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Virtual Machine(VM) āĻĻā§āĻŦāĻžāϰāĻž Execute āĻ•āϰāĻž āĻšā§ŸāĨ¤


  • Assembler āĻ•āĻŋ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Assembler āĻāĻ•āϟāĻŋ Program āĻŦāĻž Software, āϝāĻž Assembly āĻ­āĻžāώāĻžāϝāĻŧ āϞ⧇āĻ–āĻž Code āϕ⧇ Machine āĻ­āĻžāώāĻžāϝāĻŧ (Machine Language) āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇āĨ¤ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡, āĻāĻ•āϜāύ Programmer, Assembly Language āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ Program āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰ⧇āύ, āϝ⧇āϟāĻŋ āĻĒāϰ⧇ Assembler āĻĻā§āĻŦāĻžāϰāĻž Machine Code āĻ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāĻŋāϤ āĻšā§ŸāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāσ

    Assembly Code:

    MOV AX, 5      ; AX āϰ⧇āϜāĻŋāĻ¸ā§āϟāĻžāϰ⧇ ā§Ģ āϰāĻžāϖ⧇
    ADD AX, 3      ; AX āĻāϰ āϏāĻžāĻĨ⧇ ā§Š āϝ⧋āĻ— āĻ•āϰ⧇

    Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ:

    B8 05 00       ; MOV AX, 5
    05 03 00       ; ADD AX, 3
    

    Assembler Program āωāĻĒāϰ⧇āϰ Assembly Code āϕ⧇ āĻāχ Machine Code āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇, āϝāĻž Processor āϏāϰāĻžāϏāϰāĻŋ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

    Assembler āϝ⧇āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇:

    1. Input Code ⇒ Programmer Assembly āĻ­āĻžāώāĻžāϝāĻŧ Code āϞāĻŋāϖ⧇āύāĨ¤ āĻāχ Code āϕ⧇ Source Code āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤
    2. Symbol Resolution(āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ ) ⇒ Assembly āĻ­āĻžāώāĻžāϝāĻŧ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻĒā§āϰāϤ⧀āĻ• (āϝ⧇āĻŽāύ Level, Variable) āĻāĻŦāĻ‚ Opcode āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰ⧇āĨ¤
    3. Conversion ⇒ āĻĒā§āϰāϤāĻŋāϟāĻŋ Assembly āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž (Instruction) āϏāĻ‚āĻļā§āϞāĻŋāĻˇā§āϟ Machine Code āĻ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Processor āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§‹āϧāĻ—āĻŽā§āϝ Binary āĻŦāĻž Hexadecimal Format āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻšāϝāĻŧāĨ¤
    4. Output(Object Code) ⇒ Assembler āĻāĻ•āϟāĻŋ Object Code āĻŦāĻž Machine Code File āϤ⧈āϰāĻŋ āĻ•āϰ⧇, āϝāĻž āϏāϰāĻžāϏāϰāĻŋ Processor āĻ āϚāĻžāϞāĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤

    Assembler-āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ:

    1. Low Level āĻ­āĻžāώāĻžāϰ āĻ…āύ⧁āĻŦāĻžāĻĻāĻ•: āĻāϟāĻŋ Assembly āĻ­āĻžāώāĻžāϕ⧇ āϏāϰāĻžāϏāϰāĻŋ Machine Code āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰ⧇āĨ¤
    2. āϧāϰāύ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€:
      • Single-pass Assembler: āĻĒ⧁āϰ⧋ Code āĻāĻ•āĻŦāĻžāϰ⧇ āĻĒāĻĄāĻŧ⧇ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰ⧇āĨ¤
      • Two-pass Assembler: āĻĒā§āϰāĻĨāĻŽ āĻĒāĻžāϏ⧇ Level āĻŦāĻž Symbol(āĻĒā§āϰāϤ⧀āĻ•) āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻĒāĻžāϏ⧇ Machine Code āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤
    3. Program āĻāϰ Instruction āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇ āĻāĻŦāĻ‚ Code āĻ āϕ⧋āύ⧋ āϭ⧁āϞ āĻĨāĻžāĻ•āϞ⧇ āϤāĻž āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰ⧇āĨ¤
    4. Program āύāĻŋāĻ°ā§āĻŦāĻžāĻšā§‡āϰ āϜāĻ¨ā§āϝ āĻĒā§āĻ°ā§Ÿā§‹āϜāĻ¨ā§€ā§Ÿ Memory āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰāĻžāĨ¤
    5. Instruction āĻāĻŦāĻ‚ Data Memory āϤ⧇ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻžāĨ¤

  • Compiler āĻ•āĻŋ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Compiler āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Software Program, āϝāĻž āωāĻšā§āϚ-āĻ¸ā§āϤāϰ⧇āϰ Programming āĻ­āĻžāώāĻžāϝāĻŧ āϞ⧇āĻ–āĻž Code (āϝ⧇āĻŽāύ C, C++, Java)āϕ⧇ Machine āĻ­āĻžāώāĻžāϝāĻŧ āĻŦāĻž Binary Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇āĨ¤ Machine āĻ­āĻžāώāĻž āϏāϰāĻžāϏāϰāĻŋ Processor āĻĻā§āĻŦāĻžāϰāĻž āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ āĻāĻ•āϟāĻŋ Compiler Code āϕ⧇ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰāĻžāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ Programming āĻ­āĻžāώāĻžāϰ Syntax Check āĻ•āϰāĻž, Optimization āĻ•āϰāĻž āĻāĻŦāĻ‚ āĻāĻ•āϟāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ Program āϤ⧈āϰāĻŋāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    Source Code (C Language):

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

    Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ:

    B8 04 00 00 00 BB 01 00 00 00 B9 00 00 00 00 BA 0D 00 00 00 ...
    

    Compiler āϝ⧇āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇:

    Compiler āĻĒā§āϰāϧāĻžāύāϤ āĻ•āϝāĻŧ⧇āĻ•āϟāĻŋ āϧāĻžāĻĒ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇:

    1. Lexical Analysis:

      • Source Code āϕ⧇ Token āĻ āϭ⧇āϙ⧇ āĻĢ⧇āϞāĻž āĻšāϝāĻŧāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: int a = 5; --> int, a, =, 5, ;āĨ¤
    2. Syntax Analysis:

      • Source Code āĻāϰ Structure(āĻ•āĻžāĻ āĻžāĻŽā§‹) āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇, Program āϟāĻŋ āϏāĻ āĻŋāĻ• āύāĻŋāϝāĻŧāĻŽ āĻŽā§‡āύ⧇ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ⧇āϛ⧇ āĻ•āĻŋāύāĻžāĨ¤
      • āϝāĻĻāĻŋ āϕ⧋āύ⧋ Syntax āĻ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻĨāĻžāϕ⧇, āĻāĻ–āĻžāύ⧇ āϤāĻž āϧāϰāĻž āĻĒāĻĄāĻŧ⧇āĨ¤ āϝ⧇āĻŽāύ āĻāĻ•āϟāĻŋ āĻŦāĻ¨ā§āϧāύ⧀ āϭ⧁āϞāĻ­āĻžāĻŦ⧇ āĻ–ā§‹āϞāĻž āĻŦāĻž āĻŦāĻ¨ā§āϧ āĻ•āϰāĻžāĨ¤
    3. Semantic Analysis:

      • Code āĻāϰ āĻ…āĻ°ā§āĻĨāĻĒā§‚āĻ°ā§āĻŖāϤāĻž āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āϝ⧇āĻŽāύ, Variable āĻāϰ Datatype āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ⧇āϛ⧇ āĻ•āĻŋāύāĻžāĨ¤
      • āϕ⧋āύ⧋ Variable āφāϗ⧇ āĻ˜ā§‹āώāĻŖāĻž āύāĻž āĻ•āϰ⧇āχ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇ āĻ•āĻŋāύāĻž āϏ⧇āϟāĻž āĻāχ āϧāĻžāĻĒ⧇ āĻĻ⧇āĻ–āĻž āĻšā§ŸāĨ¤
    4. Intermediate Code Generation:

      • Source Code āϕ⧇ āĻāĻ•āϟāĻŋ āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀ Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰāĻž āĻšāϝāĻŧ, āϝāĻž Machine āύāĻŋāϰāĻĒ⧇āĻ•ā§āώāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: a = b + c; --> ADD b, c -> a
    5. Code Optimization:

      • Code āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āωāĻ¨ā§āύāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ…āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ Code āϏāϰāĻŋāϝāĻŧ⧇ āĻĢ⧇āϞāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ Execution Time āĻ•āĻŽāĻžāύ⧋āϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
    6. Code Generation:

      • āĻšā§‚āĻĄāĻŧāĻžāĻ¨ā§āϤ Machine Code āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧ āϝāĻž Processor āĻāϰ āϜāĻ¨ā§āϝ āĻ•āĻžāĻ°ā§āϝāĻ•āϰāĨ¤
      • āωāĻĻāĻžāĻšāϰāĻŖ: x86, ARM Machine Code.
    7. Error Handling:

      • Code āĻāϰ āϝ⧇āϕ⧋āύ⧋ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰāĻž āĻāĻŦāĻ‚ āĻŦāĻžāĻ°ā§āϤāĻž āĻĒā§āϰāĻĻāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    8. Linking & Loading:

      • Code āϕ⧇ āĻ…āĻ¨ā§āϝ Library āĻŦāĻž Module āϗ⧁āϞ⧋āϰ āϏāĻžāĻĨ⧇ āϏāĻ‚āϝ⧁āĻ•ā§āϤ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Executable File āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

    Compiler āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϏāĻŽā§‚āĻš āĻšāϞ:

    1. āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖāĻžāĻ™ā§āĻ— āĻ­āĻžāώāĻžāϰ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ ⇒ Compiler āĻāĻ•āϟāĻŋ High Level āĻ­āĻžāώāĻž āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻŋ Low Level āĻāϰ āĻ­āĻžāώāĻžā§Ÿ Code āϕ⧇ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāϰ⧂āĻĒ⧇ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇āĨ¤ Compiler āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Program āϕ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻ…āύ⧁āĻŦāĻžāĻĻāĻ•ā§ƒāϤ Program āĻāĻ•āϏāĻžāĻĨ⧇ Memory āϤ⧇ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤
    2. Fast Execution ⇒ āĻāĻ•āĻŦāĻžāϰ Code Compile āĻšāϞ⧇, Runtime āĻ āĻĻā§āϰ⧁āϤ Program āϟāĻŋ Execute āĻ•āϰāĻž āϝāĻžā§Ÿ, āĻ•āĻžāϰāĻŖ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ Code āϕ⧇ āϏāϰāĻžāϏāϰāĻŋ āϚāĻžāϞāĻžāύ⧋ āϝāĻžā§ŸāĨ¤
    3. Error Checking ⇒ Compiler Code āĻāϰ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāύāĻžāĻ•ā§āϤ āĻ•āϰāϤ⧇ āϏāĻ•ā§āώāĻŽ, āϝ⧇āĻŽāύ Syntax Error, Datatype āϭ⧁āϞ, āĻ…āύ⧁āĻĒāĻ¸ā§āĻĨāĻŋāϤ Library File āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤ Compiler āϏāĻ•āϞ āϭ⧁āϞ⧇āϰ āϤāĻžāϞāĻŋāĻ•āĻž āĻāĻ•āϏāĻžāĻĨ⧇ āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤
    4. Debugging ⇒ Compiler āĻāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ Debugging āĻ āĻŦ⧇āĻļāĻŋ āϏāĻŽā§Ÿ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§ŸāĨ¤
    5. Portability ⇒ āĻāĻ•āĻŦāĻžāϰ Code Compile āĻšā§Ÿā§‡ āϗ⧇āϞ⧇, āĻāϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻāĻ•āϟāĻŋ Platform āĻāϰ āϜāĻ¨ā§āϝ āϤ⧈āϰāĻŋ āĻšā§Ÿ āĻāĻŦāĻ‚ āϏ⧇āϟāĻŋ āĻ…āĻ¨ā§āϝ Platform āĻ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤ āϤāĻŦ⧇, āĻŽāĻžāĻā§‡ āĻŽāĻžāĻā§‡ Code āϟāĻŋ āĻĒ⧁āύāϰāĻžā§Ÿ Compile āĻ•āϰāϤ⧇ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ Platform āĻāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰ āĻ•āϰ⧇āĨ¤
    6. āĻĻā§€āĻ°ā§āϘ āϏāĻŽā§Ÿ āĻ¨ā§‡ā§Ÿ ⇒ Compiler Code āϟāĻŋ āĻāĻ•āĻŦāĻžāϰ⧇ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āϰ⧂āĻĒ⧇ Compile āĻ•āϰ⧇, āϤāĻžāχ Program Compile āĻšāĻ“ā§ŸāĻžāϰ āϏāĻŽā§Ÿ āϤ⧁āϞāύāĻžāĻŽā§‚āϞāĻ•āĻ­āĻžāĻŦ⧇ āĻŦ⧇āĻļāĻŋ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϤāĻŦ⧇ āĻāĻ•āĻŦāĻžāϰ Compile āĻšā§Ÿā§‡ āϗ⧇āϞ⧇ āϤāĻž āĻĻā§āϰ⧁āϤ āϚāĻžāϞāĻžāύ⧋ āϝāĻžā§ŸāĨ¤
    7. Optimization ⇒ Compiler Code āϟāĻŋ Optimize āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āϝāĻžāϤ⧇ Computing Resource āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āĻŽ āĻšā§Ÿ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āĻŦ⧃āĻĻā§āϧāĻŋ āĻĒāĻžā§ŸāĨ¤
    8. āĻāĻ•āĻžāϧāĻŋāĻ• āĻ­āĻžāώāĻž āϏāĻŽāĻ°ā§āĻĨāύ ⇒ āĻ…āύ⧇āĻ• Compiler āĻāĻ•āĻžāϧāĻŋāĻ• Programming āĻ­āĻžāώāĻžāϕ⧇ āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ, GCC (GNU Compiler Collection) āĻāĻ•āĻžāϧāĻŋāĻ• āĻ­āĻžāώāĻžā§Ÿ Code Compile āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ C, C++, Fortran, Ada āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Compiler Programming āĻ­āĻžāώāĻžāϰ Code āϕ⧇ Computer āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āωāĻĒāϝ⧋āĻ—ā§€ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Programming āĻ­āĻžāώāĻžāϰ Syntax, Semantic āĻāĻŦāĻ‚ Optimization Check āĻ•āϰ⧇ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ Code āϤ⧈āϰāĻŋ āĻ•āϰ⧇, āϝāĻž Computer āĻ āĻĻā§āϰ⧁āϤ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻšāϤ⧇ āϏāĻ•ā§āώāĻŽāĨ¤


  • Interpreter āĻ•āĻŋ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Interpreter āĻšāϞ⧋ āĻāĻ•āϟāĻŋ Software, āϝāĻž Source Code āϕ⧇ Line-By-Line āĻĒāĻĄāĻŧ⧇ āĻāĻŦāĻ‚ āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ Execute āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻžāϰ Source Code āϕ⧇ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Step-By-Step āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻĻā§‡ā§Ÿ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Program āĻāĻ•āĻŦāĻžāϰ⧇ Compile āĻ•āϰāĻžāϰ āĻŦāĻĻāϞ⧇ āĻĒā§āϰāϤāĻŋ Line āĻ āĻĒāĻ°ā§āϝāĻžāϞ⧋āϚāύāĻž āĻ“ Execute āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āωāĻšā§āϚ-āĻ¸ā§āϤāϰ⧇āϰ Programming āĻ­āĻžāώāĻžāϰ (āϝ⧇āĻŽāύ Python, JavaScript) Code āϕ⧇ āϏāϰāĻžāϏāϰāĻŋ Machine āĻ­āĻžāώāĻžāϝāĻŧ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āύāĻž āĻ•āϰ⧇, Execute āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āϧāĻžāĻĒ⧇ āϧāĻžāĻĒ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āϚāĻžāϞāĻžāϝāĻŧāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāσ

    Source code (Python):

    x = 5
    y = 10
    print(x + y)
    • āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύ: x = 5 --> Variable xāĻ 5 āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤
    • āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύ: y = 10 --> Variable yāĻ 10 āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤
    • āϤ⧃āϤ⧀āϝāĻŧ āϞāĻžāχāύ: print(x + y) --> āĻĻ⧁āχ Variable āĻāϰ āϝ⧋āĻ—āĻĢāϞ (15) Print āĻ•āϰ⧇āĨ¤

    Result:

    15
    

    Interpreter āϝ⧇āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇:

    Interpreter āĻ•āĻžāϜ āĻ•āϰ⧇ āύāĻŋāĻŽā§āύ⧋āĻ•ā§āϤ āϧāĻžāĻĒāϗ⧁āϞ⧋ āĻ…āύ⧁āϏāϰāĻŖ āĻ•āϰ⧇:

    1. Source Code Input:

      • Programmer āϝ⧇ Code āϞāĻŋāϖ⧇āϛ⧇āύ, āϤāĻž Interpreter āĻĻā§āĻŦāĻžāϰāĻž āϏāϰāĻžāϏāϰāĻŋ āĻĒāĻĄāĻŧāĻž āĻšāϝāĻŧāĨ¤
    2. Lexical Analysis:

      • Code āϟāĻŋ Lexical Token āĻ āϭ⧇āϙ⧇ āĻĢ⧇āϞāĻž āĻšāϝāĻŧ, āϝ⧇āĻŽāύ Keyword, Variable, Operator āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    3. Parsing:

      • Token āϗ⧁āϞ⧋āϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ Program āĻāϰ āĻ—āĻ āύ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ Syntax Tree āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
    4. Error Checking:

      • Code āĻāϰ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāĻ•āĻŦāĻžāϰ āϕ⧋āύ⧋ Error āĻĒāĻžāĻ“āϝāĻŧāĻž āϗ⧇āϞ⧇ Interpreter Execution āĻŦāĻ¨ā§āϧ āĻ•āϰ⧇āĨ¤
    5. Execution:

      • Interpreter Line-By-Line Code āĻĒāĻĄāĻŧ⧇ āĻāĻŦāĻ‚ āĻĒā§āϰāϤāĻŋāϟāĻŋ Statement āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ Execute(āĻ•āĻžāĻ°ā§āϝāĻ•āϰ) āĻ•āϰ⧇āĨ¤

    Interpreter-āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻšāϞ:

    1. Line-By-Line Execution ⇒ Code āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻŋ Line āĻŦāĻž Statement āĻāϕ⧇ āĻāϕ⧇ Execute(āĻ•āĻžāĻ°ā§āϝāĻ•āϰ) āĻ•āϰāĻž āĻšā§Ÿ, āĻ…āĻ°ā§āĻĨāĻžā§Ž āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Program āĻāĻ•āĻŦāĻžāϰ⧇ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰāĻž āĻšā§Ÿ āύāĻžāĨ¤ āĻ…āύ⧁āĻŦāĻžāĻĻāĻ•ā§ƒāϤ Program āĻāϰ āĻĒā§āϰāϤāĻŋ Line āφāϞāĻžāĻĻāĻžāĻ­āĻžāĻŦ⧇ Memory āϤ⧇ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤
    2. Dynamic Execution ⇒ Interpreter Execute āĻ•āϰāĻžāϰ āϏāĻŽā§Ÿā§‡ Code āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻ•āĻŋāϛ⧁ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āĻāĻŦāĻ‚ āύāϤ⧁āύ Input āύāĻŋā§Ÿā§‡ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž āĻ•āĻŋāϛ⧁ āĻ­āĻžāώāĻžāϝāĻŧ, Runtime āĻ Dynamic Typing āĻ“ Variable āĻ˜ā§‹āώāĻŖāĻž āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤
    3. āĻ¤ā§ŽāĻ•ā§āώāĻŖāĻžā§Ž āĻĢāϞāĻžāĻĢāϞ ⇒ Code āϞāĻŋāϖ⧇ āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ Execute āĻ•āϰāĻžāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻĻ⧇āϝāĻŧāĨ¤
    4. Debugging āϏāĻšāϜ ⇒ āϝ⧇āĻšā§‡āϤ⧁ Line-By-Line Code Execute āĻšā§Ÿ, āϤāĻžāϤ⧇ āϕ⧋āύ⧋ āϭ⧁āϞ āĻšāϞ⧇ āϤāĻž āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰāĻž āϏāĻšāϜāĨ¤ Debugging āĻ āĻ…āĻĒ⧇āĻ•ā§āώāĻžāĻ•ā§ƒāϤ āĻ•āĻŽ āϏāĻŽā§Ÿā§‡āϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§ŸāĨ¤
    5. Error āϏāύāĻžāĻ•ā§āϤāĻ•āϰāϪ⧇ āϏāĻšāĻžāϝāĻŧāĻ• ⇒ Code āĻ āϕ⧋āύ⧋ āϭ⧁āϞ āĻĨāĻžāĻ•āϞ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Line āĻ Error āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž āĻāĻ•āϟāĻŋ āϭ⧁āϞ āϧāϰāĻž āĻĒ⧜āϞ⧇ Program āύāĻŋāĻ°ā§āĻŦāĻžāĻš āĻĨ⧇āĻŽā§‡ āϝāĻžā§ŸāĨ¤
    6. Portability ⇒ Interpreter āĻāĻ•āĻžāϧāĻŋāĻ• Platform āĻ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ Linux, Windows, āĻŦāĻž MacOS, āϝ⧇āĻ–āĻžāύ⧇ Code āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇, āϤāĻŦ⧇ āĻāϟāĻŋ System āĻāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰāĻļā§€āϞ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    7. āϕ⧋āύāĻ“ Executable File āϤ⧈āϰāĻŋ āĻšāϝāĻŧ āύāĻž ⇒ Interpreter āϏāĻžāϧāĻžāϰāĻŖāϤ Machine Code āĻ Convert āĻ•āϰ⧇ āύāĻž, āĻŦāϰāĻ‚ āϏāϰāĻžāϏāϰāĻŋ Source Code āϚāĻžāϞāĻžāϝāĻŧāĨ¤
    8. āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ­āĻžāώāĻž Support ⇒ Interpreter āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Programming āĻ­āĻžāώāĻžā§Ÿ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžā§Ÿ, āϝ⧇āĻŽāύ Python, JavaScript, PHP āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Interpreter āĻšāϞ āĻāĻ•āϟāĻŋ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ Software āϝāĻž Code āĻāϰ Execution āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāϕ⧇ āϏāϰāϞ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰāĻ­āĻžāĻŦ⧇ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰ⧇āĨ¤ Interpreter āϏāĻžāϧāĻžāϰāĻŖāϤ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āĻŦāĻž Developer āϕ⧇ āϏāĻšāĻœā§‡ Debug āĻ•āϰāϤ⧇ āϏāĻšāĻžā§ŸāϤāĻž āĻ•āϰ⧇, āϤāĻŦ⧇ āĻŦ⧜ Program āĻŦāĻž Code āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ Compiler āĻāϰ āϤ⧁āϞāύāĻžā§Ÿ āϧ⧀āϰ āĻ—āϤāĻŋāϰ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


  • Compiler āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Compiler āĻšāϞ āĻāĻ•āϟāĻŋ Software Tool āϝāĻž āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻžāϝāĻŧ āϞ⧇āĻ–āĻž Source Code āϕ⧇ Machine Code āĻŦāĻž Byte Code āĻ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āωāĻšā§āϚāĻ¸ā§āϤāϰ⧇āϰ āĻ­āĻžāώāĻž (āϝ⧇āĻŽāύ C, C++, Java) āĻĨ⧇āϕ⧇ Computer Programmer āĻāϰ āĻ­āĻžāώāĻž (āϝ⧇āĻŽāύ Assembly āĻŦāĻž Machine code) āϤ⧇ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇āĨ¤ Compiler āĻāϰ āĻ•āĻŋāϛ⧁ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž āύāĻŋāĻšā§‡ āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ⧋:

    Compiler-āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. āĻĻā§āϰ⧁āϤ Execution:
      • āĻāĻ•āĻŦāĻžāϰ Program Compile āĻ•āϰāĻž āĻšāϞ⧇ āĻāϟāĻŋ Machine āĻ­āĻžāώāĻžāϝāĻŧ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻšāϝāĻŧ, āϝāĻž āϏāϰāĻžāϏāϰāĻŋ Processor āĻĻā§āĻŦāĻžāϰāĻž āϚāĻžāϞāĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤ āĻāϟāĻŋ āĻāĻ•āĻŦāĻžāϰ Compile āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒāϰ āĻŦāĻžāϰāĻŦāĻžāϰ Run āĻāϰ āϜāĻ¨ā§āϝ āĻĒā§āϰāĻ¸ā§āϤ⧁āϤ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
    2. Standalone(āĻ¸ā§āĻŦāĻžāϧ⧀āύ ) Executable File:
      • Compiler āĻāĻ•āϟāĻŋ Executable File āϤ⧈āϰāĻŋ āĻ•āϰ⧇, āϝāĻž āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āϕ⧋āύāĻ“ Compiler āĻāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻ›āĻžāĻĄāĻŧāĻžāχ āϏāϰāĻžāϏāϰāĻŋ āϚāĻžāϞāĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤
    3. Error Detection(āĻļāύāĻžāĻ•ā§āϤāĻ•āϰāĻŖ):
      • Compiler, Source Code āĻāϰ Code āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇ āĻāĻŦāĻ‚ āϏāĻŽāĻ¸ā§āϤ Error (Syntax Error, Type Error āχāĻ¤ā§āϝāĻžāĻĻāĻŋ) āφāϗ⧇āχ āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰ⧇, āĻĢāϞ⧇ Programmer Code āϞāĻŋāϖ⧇ āĻļ⧇āώ āĻ•āϰāĻžāϰ āĻĒāϰ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻšāĻœā§‡āχ āϖ⧁āρāĻœā§‡ āĻĒāĻžā§ŸāĨ¤
    4. Static Type Checking:
      • Compiler Source Code āĻ Datatype āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āϏāĻŽāĻ¸ā§āϝāĻž āφāϗ⧇āχ āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰ⧇, āĻĢāϞ⧇ Program āϟāĻŋ Run āĻ•āϰāĻžāϰ āϏāĻŽā§Ÿ Type āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻ•āĻŽ āĻĨāĻžāϕ⧇āĨ¤
    5. Optimized Code:
      • Compiler, Code Optimize āĻ•āϰ⧇ āϤ⧈āϰāĻŋ āĻ•āϰ⧇, āϝāĻž Memory āĻāĻŦāĻ‚ Processing āϏāĻŽāϝāĻŧ āϏāĻžāĻļā§āϰāϝāĻŧā§€ āĻ•āϰ⧇āĨ¤
    6. Portability:
      • āĻāĻ•āĻŦāĻžāϰ Source Code Compile āĻšāϝāĻŧ⧇ āϗ⧇āϞ⧇, āϏ⧇āϟāĻž āĻ…āĻ¨ā§āϝ Machine āĻŦāĻž Platform āĻ āϚāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āϕ⧋āύ⧋ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§Ÿ āύāĻž (āϝāĻĻāĻŋ Byte Code āĻ Compile āĻ•āϰāĻž āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇, āϝ⧇āĻŽāύ Java āϤ⧇)āĨ¤
    7. āĻŦā§āϝāĻžāĻĒāĻ• āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻ­āĻžāώāĻž āϏāĻŽāĻ°ā§āĻĨāύ:
      • Compiler-āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ C, C++, Java āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āĻ­āĻžāώāĻžāϰ Program āϏāĻšāĻœā§‡āχ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āϝāĻž Software Industry āĻāϰ āĻŽā§āϞ āϚāĻžāϞāĻŋāĻ•āĻž āĻļāĻ•ā§āϤāĻŋāĨ¤

    Compiler-āĻāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. Compilation Time:
      • āĻāĻ•āϟāĻŋ āĻŦ⧃āĻšā§Ž Program Compile āĻ•āϰāϤ⧇ āϏāĻŽā§Ÿ āϞ⧇āϗ⧇ āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇, āĻāĻŦāĻ‚ āϏ⧁āϤāϰāĻžāĻ‚ Development āĻāϰ āϏāĻŽā§Ÿ āĻŦ⧃āĻĻā§āϧāĻŋ āĻĒāĻžā§ŸāĨ¤ āĻŦāĻŋāĻļ⧇āώāϤ āĻŦ⧜ āĻŦ⧜ Project āĻ āĻāϟāĻž āϏāĻŽāĻ¸ā§āϝāĻž āϏ⧃āĻˇā§āϟāĻŋ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    2. Slow Development Process:
      • Code āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāϞ⧇ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Program āĻĒ⧁āύāϰāĻžāϝāĻŧ Compile āĻ•āϰāϤ⧇ āĻšāϝāĻŧ, āϝāĻž āϏāĻŽāϝāĻŧāϏāĻžāĻĒ⧇āĻ•ā§āώāĨ¤
    3. Complex Error Debugging:
      • Compiler āĻāĻ•āĻŦāĻžāϰ⧇ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Code Compile āĻ•āϰ⧇ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤ āϝāĻĻāĻŋ āĻāĻ•āĻžāϧāĻŋāĻ• Error āĻĨāĻžāϕ⧇, āϤāĻ–āύ Error āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻž āϜāϟāĻŋāϞ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤
    4. Limited for Dynamic Programming:
      • Runtime Dynamic Feature, āϝ⧇āĻŽāύ Interpreted Language āĻ Dynamic Variable āϤ⧈āϰāĻŋ āĻ•āϰāĻž, Compiler āĻĻāĻŋāϝāĻŧ⧇ āϏāĻŽā§āĻ­āĻŦ āύāϝāĻŧāĨ¤
    5. Unable to Detect Runtime Errors:
      • Compiler āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ Syntax āĻāĻŦāĻ‚ Type āϏāĻ‚āĻ•ā§āϰāĻžāĻ¨ā§āϤ Error āϖ⧁āρāĻœā§‡ āĻĒāĻžā§Ÿ, āϤāĻŦ⧇ Logical āĻŦāĻž Runtime Error āϗ⧁āϞāĻŋ (āϝ⧇āĻŽāύ āĻļā§‚āĻ¨ā§āϝ āĻĻā§āĻŦāĻžāϰāĻž āĻ­āĻžāĻ— āĻ•āϰāĻž, Out of Bound Access) Program āϚāĻžāϞāĻžāύ⧋āϰ āĻĒāϰ⧇āχ āϜāĻžāύāĻž āϝāĻžā§ŸāĨ¤ āϤāĻŦ⧇ Runtime Error āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰāĻž āĻāϰ āĻ•āĻžāϜ āύāϝāĻŧāĨ¤
    6. Debugging āĻ•āĻ āĻŋāύ:
      • Compiler āĻĻā§āĻŦāĻžāϰāĻž āĻ‰ā§ŽāĻĒāĻ¨ā§āύ Machine Code āĻŦāĻž Byte Code āϏāĻžāϧāĻžāϰāĻŖāϤ Programmers āĻāϰ āϜāĻ¨ā§āϝ āĻ…āĻ¸ā§āĻĒāĻˇā§āϟ āĻĨāĻžāϕ⧇, āĻĢāϞ⧇ Error āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰāĻž āĻāĻŦāĻ‚ Debug āĻ•āϰāĻž āĻ•āĻ āĻŋāύ āĻšā§Ÿā§‡ āϝāĻžā§ŸāĨ¤
    7. Memory Management:
      • āĻ•āĻŋāϛ⧁ Compiler āϝ⧇āĻŽāύ Garbage Collection āĻŦāĻž Memory Management Advance Tools āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āύāĻž, āĻĢāϞ⧇ Memory Lick āĻŦāĻž āĻ…āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ Memory āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āϏāĻŽāĻ¸ā§āϝāĻž āϤ⧈āϰāĻŋ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • Interpreter āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Interpreter āĻšāϞ āĻāĻŽāύ āĻāĻ•āϟāĻŋ Program āϝāĻž Source Code āϕ⧇ Line-By-Line Execute āĻ•āϰ⧇, āĻ…āĻ°ā§āĻĨāĻžā§Ž āĻāĻ• āĻāĻ• āĻ•āϰ⧇ Command āϚāĻžāϞāĻžā§ŸāĨ¤ āĻāϟāĻŋ Programming āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž Code āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻŋ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžā§Ÿāύ āĻ•āϰ⧇ āĻāϕ⧇ āĻāϕ⧇āĨ¤ Interpreter āĻāϰ āĻ•āĻŋāϛ⧁ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž āύāĻŋāĻšā§‡ āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ⧋:

    Interpreter-āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. Easy Development and Debugging:
      • Interpreter Code Line-By-Line āĻĒāĻĄāĻŧ⧇ āĻāĻŦāĻ‚ āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ Execute āĻ•āϰ⧇āĨ¤ āĻāϤ⧇ Debugging āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āĻĻā§āϰ⧁āϤ āĻšā§Ÿ āĻāĻŦāĻ‚ Code āĻ āϭ⧁āϞ āĻĨāĻžāĻ•āϞ⧇ āϤāĻž āĻĻā§āϰ⧁āϤ āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤ āϝāĻĻāĻŋ Error āĻĨāĻžāϕ⧇, āĻāϟāĻŋ āϤāĻžā§ŽāĻ•ā§āώāĻŖāĻŋāĻ•āĻ­āĻžāĻŦ⧇ āϏ⧇āχ Line āĻ āϞāĻžāχāύ⧇ Error āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤
    2. Instant Feedback:
      • Code āϞāĻŋāϖ⧇ āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ āĻĢāϞāĻžāĻĢāϞ āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ, āϝāĻž Development Process āĻĻā§āϰ⧁āϤāϤāϰ āĻ•āϰ⧇āĨ¤
    3. Support for Dynamic Features:
      • Runtime āĻ Variable Declare(āĻ˜ā§‹āώāĻŖāĻž) āĻāĻŦāĻ‚ Dynamic Code Execution āϏāĻŽā§āĻ­āĻŦāĨ¤ āϝ⧇āĻŽāύ, Python āĻāĻŦāĻ‚ JavaScript-āĻāϰ āĻŽāϤ⧋ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋āϤ⧇āĨ¤
    4. Portability:
      • Source Code āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Platform āĻ āϚāĻžāϞāĻžāύ⧋ āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻĻāĻŋ āϏ⧇āĻ–āĻžāύ⧇ Interpreter āωāĻĒāĻ¸ā§āĻĨāĻŋāϤ āĻĨāĻžāϕ⧇āĨ¤
    5. Interactive Mode:
      • āĻļ⧇āĻ–āĻžāϰ āĻāĻŦāĻ‚ āĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āϜāĻ¨ā§āϝ Interpreter āϏāĻŽāĻ°ā§āĻĨāĻŋāϤ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋ āϖ⧁āĻŦ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Interactive Mode āĻ Line āϧāϰ⧇ Code āϚāĻžāϞāĻžāύ⧋āϰ āϏ⧁āϝ⧋āĻ— āĻĻ⧇āϝāĻŧāĨ¤
    6. No Build Required:
      • Interpreter Program āϚāĻžāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ Executable File āϤ⧈āϰāĻŋāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ āύāĻž, āϏāϰāĻžāϏāϰāĻŋ Source Code āĻĨ⧇āϕ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

    Interpreter-āĻāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. Slow Execution ⇒ Line āϧāϰ⧇ Code Execute āĻ•āϰāĻžāϰ āĻ•āĻžāϰāϪ⧇ Interpreter, Compiler āĻāϰ āϤ⧁āϞāύāĻžāϝāĻŧ āϧ⧀āϰāĨ¤ āĻŦ⧃āĻšā§Ž āĻŦāĻž āϜāϟāĻŋāϞ Code āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āĻ•āĻŽā§‡ āϝāĻžā§ŸāĨ¤
    2. Impact(āĻĒā§āϰāĻ­āĻžāĻŦ) of Runtime Errors ⇒ Code Execution āϚāϞāĻžāĻ•āĻžāϞ⧇ Error āĻĒāĻžāĻ“āϝāĻŧāĻž āϗ⧇āϞ⧇ Program āϚāĻžāϞāĻžāύ⧋ āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ āĻŦāĻ¨ā§āϧ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤
    3. Lack of Efficiency for Repeated Execution ⇒ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ Code āϚāĻžāϞāĻžāύ⧋āϰ āϏāĻŽāϝāĻŧ Interpreter āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ Code āĻĒ⧁āύāϰāĻžāϝāĻŧ āĻĒāĻĄāĻŧ⧇ āĻāĻŦāĻ‚ Execute āĻ•āϰ⧇, āϝāĻž Compiler āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• Code āĻāϰ āϤ⧁āϞāύāĻžāϝāĻŧ āĻ•āĻŽ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ
    4. No Standalone Executable ⇒ Interpreter āϕ⧋āύ⧋ Executable File āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āύāĻžāĨ¤ āĻāϟāĻŋ Runtime āĻ Source Code āĻĒāĻĄāĻŧ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āĻĢāϞ⧇ Executable File āĻļ⧇āϝāĻŧāĻžāϰ āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ āύāϝāĻŧāĨ¤
    5. Lack of Optimization ⇒ Code Optimization āϤ⧁āϞāύāĻžāĻŽā§‚āϞāĻ•āĻ­āĻžāĻŦ⧇ āĻ•āĻŽ, āĻ•āĻžāϰāĻŖ Interpreter Runtime āĻ āϏāϰāĻžāϏāϰāĻŋ Code Execute āĻ•āϰ⧇āĨ¤
    6. Deployment Complexity ⇒ Source Code Share āĻ•āϰāĻžāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ, āĻāĻŦāĻ‚ Interpreter āωāĻĒāĻ¸ā§āĻĨāĻŋāϤ āύāĻž āĻĨāĻžāĻ•āϞ⧇ Program āϚāĻžāϞāĻžāύ⧋ āϏāĻŽā§āĻ­āĻŦ āύāϝāĻŧāĨ¤

  • JIT(Just-In-Time) Compiler āĻ•āĻŋ? āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āϕ⧋āĻĨāĻžā§Ÿ āĻšā§Ÿ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āϟāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    JIT (Just-In-Time) Compiler āĻšāϞ āĻāĻ•āϟāĻŋ āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋ, āϝāĻž Program āϚāϞāĻžāĻ•āĻžāϞ⧀āύ āϏāĻŽāϝāĻŧ⧇ Source Code āĻŦāĻž āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀(Intermediate) Code āϕ⧇ āϏāϰāĻžāϏāϰāĻŋ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Compiler āĻāĻŦāĻ‚ Interpreter-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϟāĻŋ āϏāĻ‚āĻŽāĻŋāĻļā§āϰāĻŖ, āϝāĻž Runtime Optimization āĻāĻŦāĻ‚ Execution Speed āωāĻ¨ā§āύāϤ āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ Application āϗ⧁āϞāĻŋāϰ Performance āωāĻ¨ā§āύāϤ āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    Java āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽā§‡āϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ JIT-āĻāϰ āĻ•āĻžāϜ:

    1. Source Code:

      public class Example {
          public static void main(String[] args) {
              for (int i = 0; i < 10; i++) {
                  System.out.println("Hello, JIT!");
              }
          }
      }
    2. Compilation to Bytecode:

      • javac Compiler Source Code āϕ⧇ Bytecode-āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇āĨ¤
    3. JIT Execution:

      • JVM Bytecode āύāĻŋāϝāĻŧ⧇ JIT Compiler āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻĻā§āϰ⧁āϤ Loop Execute āĻ•āϰ⧇āĨ¤

    JIT āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ:

    • Java Virtual Machine (JVM):
      • Java Program āĻāϰ Byte Code, JIT āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻšāϝāĻŧāĨ¤
    • .NET Framework:
      • Microsoft .NET āĻāϰ Common Language Runtime (CLR) JIT āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤
    • JavaScript Engines:
      • āϝ⧇āĻŽāύ V8 (Chrome) āĻāĻŦāĻ‚ SpiderMonkey (Firefox), JIT āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĻā§āϰ⧁āϤ JavaScript Code Execute āĻ•āϰ⧇āĨ¤
    • Python (PyPy):
      • Python-āĻāϰ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻ•āĻ˛ā§āĻĒ Implementation, āϝ⧇āĻ–āĻžāύ⧇ JIT āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

    JIT āϝ⧇āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇:

    JIT Compiler āϏāĻžāϧāĻžāϰāĻŖāϤ āύāĻŋāĻšā§‡āϰ āϧāĻžāĻĒ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇:

    1. Bytecode Generation:
      • āĻĒā§āϰāĻĨāĻŽā§‡ Source Code āϕ⧇ āĻāĻ•āϟāĻŋ āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀ Format āĻ (āϝ⧇āĻŽāύ Java-āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ Bytecode) āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāĻž āĻšāϝāĻŧ, āϝāĻž Platform āύāĻŋāϰāĻĒ⧇āĻ•ā§āώāĨ¤
    2. Execution Request:
      • āϝāĻ–āύ Program āϚāĻžāϞ⧁ āĻšāϝāĻŧ, āϤāĻ–āύ JIT Compiler Bytecode āĻŦāĻž Intermediate(āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀) Code āϕ⧇ āĻĒāĻ°ā§āϝāĻžāϝāĻŧāĻ•ā§āϰāĻŽā§‡ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĨ¤
    3. Frequently Used Code Identification:
      • JIT Compiler Runtime āĻ āϏ⧇āχ Code āĻ…āĻ‚āĻļāϗ⧁āϞ⧋ āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰ⧇, āϝāĻž āĻŦāĻžāϰāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ (āϝ⧇āĻŽāύ Loop āĻŦāĻž Function)āĨ¤
    4. Translation to Machine Code:
      • āĻļāύāĻžāĻ•ā§āϤāĻ•ā§ƒāϤ Code āϕ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻāϟāĻŋ Cache-āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ āϏ⧇āχ āĻ…āĻ‚āĻļāϟāĻŋ āĻĒ⧁āύāϰāĻžāϝāĻŧ Execute āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āφāϰ āĻ…āύ⧁āĻŦāĻžāĻĻ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ āύāĻžāĨ¤
    5. Runtime Optimization:
      • JIT Compiler, Code āϕ⧇ Optimize āĻ•āϰ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇, āϝāĻžāϤ⧇ Execution āφāϰāĻ“ āĻĻā§āϰ⧁āϤ āĻšāϝāĻŧāĨ¤
    6. Execution:
      • Machine Code āϏāϰāĻžāϏāϰāĻŋ Processor āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

    JIT-āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻšāϞ:

    1. Runtime Compilation:
      • Program āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ Code Compile āĻ•āϰ⧇ āĻāĻŦāĻ‚ āϏāĻ™ā§āϗ⧇ āϏāĻ™ā§āϗ⧇āχ āϚāĻžāϞāĻžāϝāĻŧāĨ¤
    2. Dynamic Optimization:
      • Program Execution āĻāϰ āϏāĻŽāϝāĻŧ Code āĻāϰ Performance(āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž) āĻŦāĻžāĻĄāĻŧāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ Optimization āĻ•āϰ⧇āĨ¤
    3. Platform Independence:
      • Intermediate(āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀) Code (Bytecode) āϤ⧈āϰāĻŋ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĢāϞ⧇ JIT āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Platform āĻ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. Cache Mechanism:
      • JIT machine Code āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇, āϝāĻžāϤ⧇ āĻĒāϰāĻŦāĻ°ā§āϤ⧀ Execution āĻāϰ āϏāĻŽāϝāĻŧ āφāϰāĻ“ āĻĻā§āϰ⧁āϤ āϏāĻžāĻĄāĻŧāĻž āĻĻ⧇āϝāĻŧāĨ¤
    5. Frequent Execution Analysis:
      • JIT āĻŦāĻžāϰāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšā§ƒāϤ Code āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āϏ⧇āχ āĻ…āĻ‚āĻļāϗ⧁āϞ⧋āϕ⧇ āĻŦāĻŋāĻļ⧇āώāĻ­āĻžāĻŦ⧇ Optimize āĻ•āϰ⧇āĨ¤
    6. Hybrid Approach:
      • āĻāϟāĻŋ Compiler āĻāĻŦāĻ‚ Interpreter-āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻāĻ•āĻ¤ā§āϰāĻŋāϤ āĻ•āϰ⧇āĨ¤
    7. Dynamic Typing Support:
      • āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āϜāĻ¨ā§āϝ, āϝ⧇āĻŽāύ Java āĻŦāĻž C#, āϝ⧇āĻ–āĻžāύ⧇ Typing Runtime āĻ āύāĻŋāĻ°ā§āϧāĻžāϰāĻŋāϤ āĻšā§Ÿ, JIT Compiler āĻĻā§āϰ⧁āϤ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻ¨ā§‡ā§Ÿ āϝ⧇ āϕ⧀āĻ­āĻžāĻŦ⧇ Code āϟāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰāĻ­āĻžāĻŦ⧇ Execute āĻšāĻŦ⧇āĨ¤

    āĻ…āϤāĻāĻŦ, JIT Compiler āĻāĻ•āϟāĻŋ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ Tool, āϝāĻž Code āĻāϰ Performance āĻ“ āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āĻŦāĻžā§œāĻžāϤ⧇ āϏāĻšāĻžā§ŸāϤāĻž āĻ•āϰ⧇āĨ¤ JIT Compiler āĻŽā§‚āϞāϤ āĻŦāĻĄāĻŧ Application āĻāĻŦāĻ‚ Web Browser āĻāϰ āϜāĻ¨ā§āϝ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀, āϝ⧇āĻ–āĻžāύ⧇ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻĻāĻ•ā§āώ Code Execution āĻĒā§āϰāϝāĻŧā§‹āϜāύāĨ¤


  • JIT(Just-In-Time) Compiler āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    JIT (Just-In-Time) Compiler āĻšāϞ āĻāĻ•āϟāĻŋ Technique āϝāĻž Program āĻāϰ Code āϕ⧇ Runtime (āϝāϤāϟ⧁āϕ⧁ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§Ÿ) Compile āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Interpreted āĻ­āĻžāώāĻžāϗ⧁āϞāĻŋāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§Ÿ, āϝ⧇āĻŽāύ Java, C#, āĻāĻŦāĻ‚ JavaScript. JIT Compiler āĻāĻ•āϟāĻŋ Program āĻāϰ Code āϕ⧇ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻŦāĻž āφāĻ‚āĻļāĻŋāĻ•āĻ­āĻžāĻŦ⧇ Runtime āĻ machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇, āϝāĻžāϤ⧇ Program āϟāĻŋ āĻĻā§āϰ⧁āϤāϤāĻŽ āĻ—āϤāĻŋāϤ⧇ āϚāϞ⧇āĨ¤ JIT Compiler āĻāϰ āĻ•āĻŋāϛ⧁ āϏ⧁āĻŦāĻŋāϧāĻž āĻ“ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž āύāĻŋāĻšā§‡ āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ⧋:

    JIT-āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. Fast Execution ⇒ JIT Compiler āĻāϰ āĻĒā§āϰāϧāĻžāύ āϏ⧁āĻŦāĻŋāϧāĻž āĻšāϞ āĻāϟāĻŋ Program āĻāϰ Code Runtime āĻ Compile āĻ•āϰ⧇, āĻĢāϞ⧇ Code Execution āĻāϰ āĻ—āϤāĻŋ āωāĻ¨ā§āύāϤ āĻšā§ŸāĨ¤ āĻāĻ•āĻŦāĻžāϰ Code Compile āĻšā§Ÿā§‡ āϗ⧇āϞ⧇, āϤāĻž āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ āĻĻā§āϰ⧁āϤ Execute āĻšā§ŸāĨ¤
    2. Runtime Optimization ⇒ JIT Compiler Runtime āĻ Code Optimize āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ Loop Optimization, Inline Function Call, āĻāĻŦāĻ‚ Static Data Manipulation. āĻāχ āĻ•āĻžāϰāϪ⧇ Code āφāϰāĻ“ āĻĻā§āϰ⧁āϤ āϚāϞ⧇āĨ¤
    3. Platform Independent ⇒ āĻāĻ•āĻŦāĻžāϰ Code Compile āĻšā§Ÿā§‡ āϗ⧇āϞ⧇, āϏ⧇āχ Code āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Platform āĻāϰ āϜāĻ¨ā§āϝ Optimized āĻšā§Ÿā§‡ āϝāĻžā§ŸāĨ¤ āĻāϰ āĻĢāϞ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Hardware āĻ“ Operating System āĻ Program āϚāĻžāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ JIT āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. Efficient Memory Usage ⇒ JIT Compiler Memory Management āĻ āĻĻāĻ•ā§āώ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāϟāĻŋ Runtime āĻ āϝ⧇āϕ⧋āύ⧋ āϧāϰāύ⧇āϰ Data Structure āϕ⧇ Memory āĻĨ⧇āϕ⧇ āϏāϰāĻŋā§Ÿā§‡ āĻŦāĻž āĻĒ⧁āύāσāĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻž Program āĻāϰ Memory Management āϕ⧇ āφāϰāĻ“ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ Code āĻāϰ āĻ…āĻ‚āĻļāϕ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻ•āϰ⧇āĨ¤
    5. Dynamic Code Updates ⇒ Code āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻŦāĻž Update āĻ•āϰāϞ⧇ JIT āϤāĻžā§ŽāĻ•ā§āώāĻŖāĻŋāĻ•āĻ­āĻžāĻŦ⧇ āϤāĻžāϰ āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āĻŦāϜāĻžāϝāĻŧ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

    JIT-āĻāϰ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. Startup Delay ⇒ Program āĻĒā§āϰāĻĨāĻŽāĻŦāĻžāϰ āϚāĻžāϞ⧁ āĻšāĻ“āϝāĻŧāĻžāϰ āϏāĻŽāϝāĻŧ JIT Compiler āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀ Code āϕ⧇ Machine Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāϤ⧇ āϏāĻŽāϝāĻŧ āύ⧇āϝāĻŧāĨ¤
    2. High Resource Usage ⇒ Code ****Compile āĻāĻŦāĻ‚ Optimization āĻāϰ āϏāĻŽāϝāĻŧ CPU āĻ“ Memory āĻŦ⧇āĻļāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤ āĻ•āĻžāϰāĻŖ Compile āĻ•āϰāĻž Code Memory āϤ⧇ āϰāĻžāĻ–āĻž āĻšā§Ÿ, āĻāĻŦāĻ‚ āϏ⧇āχ Code āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ āφāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāϟāĻŋ Memory Management āϕ⧇ āϜāϟāĻŋāϞ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤
    3. Compilation Overhead ⇒ Code āϕ⧇ Runtime āĻ Compile āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ Computational āĻļāĻ•ā§āϤāĻŋāϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§ŸāĨ¤ āĻāχ āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ Computational Load Program āϟāĻŋāϰ āϏāĻžāĻŽāĻ—ā§āϰāĻŋāĻ• Performance āϕ⧇ āĻĒā§āϰāĻ­āĻžāĻŦāĻŋāϤ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    4. Unpredictable Behavior ⇒ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻŋāϛ⧁ āĻĒāϰāĻŋāĻ¸ā§āĻĨāĻŋāϤāĻŋāϤ⧇ JIT Optimization āĻ•āĻžāĻ™ā§āĻ•ā§āώāĻŋāϤ āĻĢāϞāĻžāĻĢāϞ āύāĻžāĻ“ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • Token āĻ•āĻŋ?

    Programming āĻŦāĻž Computer Science āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ "Token" āĻŦāϞāϤ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ Code āĻāϰ āĻāĻ•āϟāĻŋ āĻŽā§ŒāϞāĻŋāĻ• āĻ…āĻ‚āĻļ āĻŦāĻž Unit āϕ⧇ āĻŦ⧁āĻāĻžāύ⧋ āĻšā§Ÿ, āϝāĻž āĻ­āĻžāώāĻžāϰ (Programming Language) Syntax āĻ…āύ⧁āϝāĻžā§Ÿā§€ āĻ…āĻ°ā§āĻĨāĻĒā§‚āĻ°ā§āĻŖāĨ¤ āĻāϕ⧇ āĻ…āĻ¨ā§āϝāĻ­āĻžāĻŦ⧇ āĻŦāϞāϤ⧇ āϗ⧇āϞ⧇, āĻāĻ•āϟāĻŋ Token āĻšāϞ⧋ Programming āĻ­āĻžāώāĻžāϰ āϏāĻŦāĻšā§‡ā§Ÿā§‡ āϛ⧋āϟ āωāĻĒāĻžāĻĻāĻžāύ āϝāĻž āĻŦāĻŋāĻļ⧇āώāĻ­āĻžāĻŦ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻŦāĻž āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻ•āϰ⧇āĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ:

    • Keyword ⇒ āϝ⧇āĻŽāύ if, while, return āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    • Identifier ⇒ āϝ⧇āĻŽāύ Variable āĻŦāĻž Function āĻāϰ āύāĻžāĻŽāĨ¤
    • Literal ⇒ āϝ⧇āĻŽāύ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻŽāĻžāύ āĻŦāĻž String (āϝ⧇āĻŽāύ 42, "hello" āχāĻ¤ā§āϝāĻžāĻĻāĻŋ)āĨ¤
    • Operator ⇒ āϝ⧇āĻŽāύ +, , , /, = āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    • Semicolon, Comma āχāĻ¤ā§āϝāĻžāĻĻāĻŋ Punctuation āϚāĻŋāĻšā§āύāĻ“ āĻāĻ•āϟāĻŋ Token āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

    āωāĻĻāĻžāĻšāϰāĻŖ: āϧāϰāĻž āϝāĻžāĻ• āύāĻŋāĻšā§‡āϰ Code āϟāĻŋ

    int x = 10;

    āĻāχ Code āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Token āĻ°ā§Ÿā§‡āϛ⧇:

    • int → āĻšāϞ Keyword.
    • x → āĻšāϞ Identifier.
    • = → āĻšāϞ Operator.
    • 10 → āĻšāϞ Literal.
    • ; → āĻšāϞ Semicolon.

    Token āĻāϰ Process:

    Code āϟāĻŋ āϝāĻ–āύ Compile āĻŦāĻž Interpreted āĻ•āϰāĻž āĻšā§Ÿ, āϤāĻ–āύ āĻĒā§āϰāĻĨāĻŽā§‡ āĻāϟāĻŋ Token āϗ⧁āϞāĻŋāϤ⧇ āϭ⧇āϙ⧇ āĻĢ⧇āϞāĻž āĻšā§Ÿ, āϤāĻžāϰāĻĒāϰ āĻāϏāĻŦ Token āϕ⧇ Syntax āĻāĻŦāĻ‚ Semantics āĻāϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞāĻŋā§Ÿā§‡ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻāχ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāϕ⧇ Lexical Analysis āĻŦāϞāĻž āĻšā§ŸāĨ¤

    āĻŽā§‹āϟāĻ•āĻĨāĻž, Token āĻšāϞ⧋ Code āĻāϰ āĻ­āĻžāώāĻžāĻ—āϤ āωāĻĒāĻžāĻĻāĻžāύ, āϝāĻž āĻĒāϰāĻŦāĻ°ā§āϤ⧀ āϧāĻžāĻĒ⧇ Program āϟāĻŋāϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽā§‡ āϰ⧂āĻĒ āĻ¨ā§‡ā§ŸāĨ¤


  • Keyword āĻ•āĻŋ? Keyword āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Keyword āĻŦāϞāϤ⧇ āĻāĻŽāύ āĻļāĻŦā§āĻĻāϕ⧇ āĻŦā§‹āĻāĻžāύ⧋ āĻšā§Ÿ āϝāĻž āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻžāϰ āϜāĻ¨ā§āϝ āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ āĻāĻŦāĻ‚ āϏ⧇āχ āĻ­āĻžāώāĻžāϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Syntax āĻāϰ āĻ…āĻ‚āĻļ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ Keyword āϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻ­āĻžāώāĻžāϰ Syntax āĻāĻŦāĻ‚ āφāϚāϰāĻŖ āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Variable, Function āĻŦāĻž āĻ…āĻ¨ā§āϝ āϕ⧋āύ āύāĻžāĻŽā§‡āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžāĻŦ⧇ āύāĻžāĨ¤ C, C++, Java, Python āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āĻ­āĻžāώāĻžāϰ Keyword āĻāϰ āĻ•āĻŋāϛ⧁ āωāĻĻāĻžāĻšāϰāĻŖ ****āύāĻŋāĻšā§‡ āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ:

    C/C++:

    • int (Datatype)
    • if (Condition(āĻļāĻ°ā§āϤ) āϝāĻžāϚāĻžāχ)
    • while (Loop)
    • for (Loop)
    • return (Function āĻĨ⧇āϕ⧇ āĻŽāĻžāύ Return)
    • void (Function āĻāϰ āϕ⧋āύ Return Value āύ⧇āχ)

    Java:

    • class (Class Define āĻ•āϰāĻž)
    • public (Access Specifier)
    • private (Access Specifier)
    • extends (World Class āĻĨ⧇āϕ⧇ Inherit āĻ•āϰāĻž)
    • new (Object āϤ⧈āϰāĻŋ)
    • static (Static Member āĻŦāĻž Method)

    Python:

    • def (Function Define āĻ•āϰāĻž)
    • if (Condition(āĻļāĻ°ā§āϤ) āϝāĻžāϚāĻžāχ)
    • elif (āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ āĻļāĻ°ā§āϤ)
    • else (āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ)
    • return (Function āĻĨ⧇āϕ⧇ āĻŽāĻžāύ Return)
    • import (Library āĻŦāĻž Module Import āĻ•āϰāĻž)

    Keyword āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ āĻšāϞ:

    1. āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ āĻļāĻŦā§āĻĻ: Keyword āϗ⧁āϞāĻŋ āĻĒā§‚āĻ°ā§āĻŦāύāĻŋāĻ°ā§āϧāĻžāϰāĻŋāϤ āĻāĻŦāĻ‚ āĻāϕ⧇ āϕ⧋āύāĻ“ Variable āĻŦāĻž Function āĻāϰ āύāĻžāĻŽ āĻšāĻŋāϏāĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžāĻŦ⧇ āύāĻžāĨ¤
    2. āĻŦāĻŋāĻļ⧇āώ āωāĻĻā§āĻĻ⧇āĻļā§āϝ: āĻĒā§āϰāϤāĻŋāϟāĻŋ Keyword āĻāϰ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ­ā§‚āĻŽāĻŋāĻ•āĻž āĻāĻŦāĻ‚ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻĨāĻžāϕ⧇ āϝ⧇āĻŽāύ Loop āϚāĻžāϞāĻžāύ⧋, āĻļāĻ°ā§āϤ āϝāĻžāϚāĻžāχ āĻ•āϰāĻž, Function Define āĻ•āϰāĻž āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤
    3. āĻ­āĻžāώāĻžāĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ•: Keyword āϗ⧁āϞāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Programming āĻ­āĻžāώāĻžāϰ āĻ…āĻ‚āĻļ āĻāĻŦāĻ‚ āĻāĻ• āĻ­āĻžāώāĻžāϰ Keyword āĻ…āĻ¨ā§āϝ āĻ­āĻžāώāĻžā§Ÿ āφāϞāĻžāĻĻāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

    Keyword āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ:

    Keyword āϗ⧁āϞāĻŋ Program āĻ Logic āĻŦāĻž Flow āύāĻŋāĻ°ā§āϧāĻžāϰāϪ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āϝ⧇āĻŽāύ:

    • āĻļāĻ°ā§āϤāĻŽā§‚āϞāĻ• āĻŦāĻŋāĻŦ⧃āϤāĻŋ (if, else, switch) ⇒ Code āĻāϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ…āĻ‚āĻļ⧇āϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽ āύāĻŋāĻ°ā§āĻŦāĻžāϚāύ āĻ•āϰ⧇āĨ¤
    • Loop (for, while, do-while): Code āĻāϰ āĻ…āĻ‚āĻļ āĻāĻ•āĻžāϧāĻŋāĻ• āĻŦāĻžāϰ āϚāĻžāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤
    • Function āĻŦāĻž Method (return, def, void): āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Function āĻŦāĻž Method Define āĻ•āϰāĻžāĨ¤
    • Datatype (int, float, char, string): Variable āĻāϰ Datatype āĻ˜ā§‹āώāĻŖāĻž āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤

    Keyword āĻāĻ•āϟāĻŋ Programming āĻ­āĻžāώāĻžāϰ āĻ…āĻ‚āĻļ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§Ÿ, āϝāĻž āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ āĻĨāĻžāϕ⧇āĨ¤ āĻāϗ⧁āϞāĻŋ āĻ­āĻžāώāĻžāϰ āĻŽā§ŒāϞāĻŋāĻ• āĻ•āĻžāĻ āĻžāĻŽā§‹ āĻ—ā§œā§‡ āϤ⧋āϞ⧇ āĻāĻŦāĻ‚ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀āϰ āĻĻā§āĻŦāĻžāϰāĻž āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāĻž āϝāĻžā§Ÿ āύāĻžāĨ¤


  • Identifier āĻ•āĻŋ? Identifier āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? Identifier āϤ⧈āϰāĻŋāϰ āύāĻŋ⧟āĻŽāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Identifier āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āύāĻžāĻŽ āϝāĻž Program āĻ āĻāĻ•āϟāĻŋ Variable, Function, Class, Object, Constant āĻŦāĻž āĻ…āĻ¨ā§āϝ āϕ⧋āύ āωāĻĒāĻžāĻĻāĻžāύāϕ⧇ āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āĻāϟāĻŋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ Token āϝāĻž Program āĻāϰ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āωāĻĒāĻžāĻĻāĻžāύāϕ⧇ āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ āĻāĻŦāĻ‚ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Code āĻāϰ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ…āĻ‚āĻļ⧇ Reference āĻŦāĻž Access āĻ•āϰāĻž āĻšā§ŸāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    C/C++:

    int age;              // āĻāĻ–āĻžāύ⧇ 'age' āĻāĻ•āϟāĻŋ Identifier. 
    float salary;         // āĻāĻ–āĻžāύ⧇ 'salary' āĻāĻ•āϟāĻŋ Identifier.

    Java:

    int age;              // āĻāĻ–āĻžāύ⧇ 'age' āĻāĻ•āϟāĻŋ Identifier.
    String name;          // āĻāĻ–āĻžāύ⧇ 'name' āĻāĻ•āϟāĻŋ Identifier.

    Python:

    name = "John"         # āĻāĻ–āĻžāύ⧇ 'name' āĻāĻ•āϟāĻŋ Identifier.
    def greet():           # āĻāĻ–āĻžāύ⧇ 'greet' āĻāĻ•āϟāĻŋ Identifier.
        print("Hello")

    Identifier āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻšāϞ:

    1. Letter, Number āĻāĻŦāĻ‚ Underscore ⇒ āĻāĻ•āϟāĻŋ Identifier āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻ…āĻ•ā§āώāϰ (A-Z, a-z), āϏāĻ‚āĻ–ā§āϝāĻž (0-9), āĻāĻŦāĻ‚ Underscore(_) āĻĻāĻŋā§Ÿā§‡ āĻ—āĻ āĻŋāϤ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϤāĻŦ⧇, āĻāĻ•āϟāĻŋ Identifier āĻ•āĻ–āύ⧋āχ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĻā§āĻŦāĻžāϰāĻž āĻļ⧁āϰ⧁ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤
    2. Case Sensitive ⇒ āĻ…āϧāĻŋāĻ•āĻžāĻ‚āĻļ Programming āĻ­āĻžāώāĻžā§Ÿ Identifier Case Sensitive āĻšā§ŸāĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž, myVariable āĻāĻŦāĻ‚ myvariable āĻĻ⧁āϟāĻŋ āφāϞāĻžāĻĻāĻž Identifier āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ—āĻŖā§āϝ āĻšāĻŦ⧇āĨ¤
    3. Keyword āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž: Identifier āĻ•āĻ–āύ⧋āχ āĻ­āĻžāώāĻžāϰ āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ Keyword āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž (āϝ⧇āĻŽāύ if, for, while āχāĻ¤ā§āϝāĻžāĻĻāĻŋ)āĨ¤
    4. āĻĒā§‚āĻ°ā§āĻŦ⧇ Define: Program āĻ āϝ⧇āĻ–āĻžāύ⧇ Identifier āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāĻŦ⧇, āϏ⧇āĻ–āĻžāύ⧇ āϏ⧇āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŦ⧇ Define(āĻ˜ā§‹āώāĻŖāĻž) āĻ•āϰāĻž āĻĨāĻžāĻ•āϤ⧇ āĻšāĻŦ⧇āĨ¤

    Identifier āϤ⧈āϰāĻŋāϰ āĻ•āĻŋāϛ⧁ āύāĻŋ⧟āĻŽ:

    • āĻļ⧁āϰ⧁ āĻšāϤ⧇ āĻšāĻŦ⧇ Letter āĻŦāĻž Underscore āĻĻāĻŋā§Ÿā§‡:
      • āϏāĻ āĻŋāĻ•: age, _age, variable_name
      • āϭ⧁āϞ: 1age (āĻ•āĻžāϰāĻŖ Number āĻĻāĻŋā§Ÿā§‡ āĻļ⧁āϰ⧁ āĻ•āϰāĻž āϝāĻžāĻŦ⧇ āύāĻž)
    • āϕ⧇āĻŦāϞ Letter, Number āĻāĻŦāĻ‚ Underscore āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžāĻŦ⧇:
      • āϏāĻ āĻŋāĻ•: my_var123, tempValue
      • āϭ⧁āϞ: my-var (āĻ•āĻžāϰāĻŖ - āϚāĻŋāĻšā§āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝāĻžāĻŦ⧇ āύāĻž)
    • Identifier Keyword āĻšāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āύāĻž:
      • āϭ⧁āϞ: if, while, for (āĻ•āĻžāϰāĻŖ āĻāϗ⧁āϞāĻŋ Keyword)
    • Case Sensitive:
      • Variable, variable āĻāĻŦāĻ‚ VARIABLE āϏāĻŦāχ āφāϞāĻžāĻĻāĻž Identifier āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦāĻŋāĻŦ⧇āϚāĻŋāϤ āĻšāĻŦ⧇āĨ¤

    Identifier āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ:

    Identifier āϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Programming āωāĻĒāĻžāĻĻāĻžāύāϕ⧇ āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ, āϝ⧇āĻŽāύ:

    • Variable ⇒ āĻāĻ•āϟāĻŋ āĻŽāĻžāύ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ Identifier.
    • Function ⇒ Code āĻāϰ āĻāĻ•āϟāĻŋ āĻ…āĻ‚āĻļ āϝāĻž āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰ⧇āĨ¤
    • Class ⇒ āĻāĻ•āϟāĻŋ Data Structure āĻŦāĻž Object āĻāϰ Template.
    • Constant ⇒ āĻāĻ•āϟāĻŋ Value āϝāĻž āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύāϝ⧋āĻ—ā§āϝ āύ⧟āĨ¤

  • Literal āĻ•āĻŋ? Identifier āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āϧāϰāύ āϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Literal āĻšāϞ⧋ Code āĻ āϏāϰāĻžāϏāϰāĻŋ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŽāĻžāύ, āϝ⧇āĻŽāύ Number, String, Boolean Value āĻŦāĻž āĻ…āĻ¨ā§āϝ āĻ•āĻŋāϛ⧁āĨ¤ āĻāϟāĻŋ Program āĻ Data āωāĻĒāĻžāĻĻāĻžāύāϗ⧁āϞ⧋āϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āϏāĻžāϧāĻžāϰāĻŖāϤ Constant(āĻ…āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύāĻļā§€āϞ) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āωāĻĻāĻžāĻšāĻžāϰāĻŖāσ

    25   // āĻāĻ–āĻžāύ⧇ 25 āĻāĻ•āϟāĻŋ Integer Literal
    19.99    // āĻāĻ–āĻžāύ⧇ 19.99 āĻāĻ•āϟāĻŋ Float Literal
    "Alice"   // āĻāĻ–āĻžāύ⧇ "Alice" āĻāĻ•āϟāĻŋ String Literal
    true   // āĻāĻ–āĻžāύ⧇ true āĻāĻ•āϟāĻŋ Boolean Literal

    Literal āϗ⧁āϞāĻŋāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻšāϞ:

    1. Pre-define Value ⇒ Literal āϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āϕ⧇āĻŦāϞ Value āϕ⧇ āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰ⧇, āϝ⧇āĻŽāύ āĻāĻ•āϟāĻŋ Number, String āĻŦāĻž Boolean Value.
    2. Constant ⇒ Literal Value Code āĻ āϏāϰāĻžāϏāϰāĻŋ āωāĻ˛ā§āϞ⧇āĻ– āĻ•āϰāĻž āĻšā§Ÿ āĻāĻŦāĻ‚ āĻāϟāĻŋ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύāϝ⧋āĻ—ā§āϝ āύ⧟ (āĻ…āĻ°ā§āĻĨāĻžā§Ž, āĻāϟāĻŋ āϕ⧋āύāĻ“ Variable āĻāϰ āĻŽāĻžāύ āύ⧟, āĻŦāϰāĻ‚ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŽāĻžāύ)āĨ¤
    3. Different Datatype Literal ⇒ āĻĒā§āϰāϤāĻŋāϟāĻŋ Datatype āĻāϰ āϜāĻ¨ā§āϝ āφāϞāĻžāĻĻāĻž Literal āĻ—āĻ āύ āĻĨāĻžāϕ⧇ āϝ⧇āĻŽāύ Integer, Float, String, Boolean āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Literals āĻāϰ āϧāϰāύāϗ⧁āϞ⧋ āĻšāϞ:

    Literals āϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Datatype āĻ…āύ⧁āϏāĻžāϰ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāύ⧇āϰ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ:

    • Integer Literal
    • Float Literal
    • String Literal
    • Character Literal
    • Boolean Literal

  • Statement āĻ•āĻŋ?

    Statement āĻŦāϞāϤ⧇ āĻāĻ•āϟāĻŋ āĻāĻ•āĻ• āĻ•āĻžāϜ āĻŦāĻž āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻŦ⧁āĻāĻžāύ⧋ āĻšāϝāĻŧ āϝāĻž Program āϕ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āĻŦāϞ⧇āĨ¤ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āĻāĻ•āĻ• Executable Unit āϝāĻž Program āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ Programming āĻ­āĻžāώāĻžā§Ÿ āĻāĻ•āϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻŦāĻŋāĻŦ⧃āϤāĻŋ, āϝāĻž Computer āϕ⧇ āϕ⧋āύ⧋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻŦāϞ⧇āĨ¤

    āϝ⧇āĻŽāύ, āφāĻŽāϰāĻž āϝāĻ–āύ āĻāĻ•āϟāĻŋ Program āĻ āϕ⧋āύ⧋ Value Assign āĻ•āϰāĻŋ, āϕ⧋āύ⧋ Condition āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰāĻŋ, āĻ…āĻĨāĻŦāĻž āϕ⧋āύ⧋ Loop āϚāĻžāϞāĻžā§Ÿ, āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻ•āĻžāϜāχ āĻāĻ•āϟāĻŋ Statement āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ—āĻŖā§āϝ āĻšāϝāĻŧāĨ¤

    Statement āĻāϰ āĻ•āĻŋāϛ⧁ āωāĻĻāĻžāĻšāϰāĻŖ:

    1. Assignment Statement (Value Assign āĻ•āϰāĻž):

      • āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Statement āϝāĻž āĻāĻ•āϟāĻŋ Variable āĻāϰ Value āĻĻ⧇āϝāĻŧāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        int x = 10;  // x Variable āĻ 5 āĻŽāĻžāύ Assign āĻ•āϰāĻž āĻšāĻšā§āϛ⧇āĨ¤
    2. Conditional Statement (āĻļāĻ°ā§āϤāĻžāϧ⧀āύ Statement):

      • āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Statement āϝāĻž āĻāĻ•āϟāĻŋ Condition(āĻļāĻ°ā§āϤ) āϝāĻžāϚāĻžāχ āĻ•āϰ⧇ āĻāĻŦāĻ‚ Condition āϏāĻ āĻŋāĻ• āĻšāϞ⧇ āĻ•āĻŋāϛ⧁ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        if (x > 10) {
            printf("x is greater than 10\n");
            }            // Condition āϝāĻĻāĻŋ āϏāĻ¤ā§āϝ āĻšāϝāĻŧ, āϤāĻžāĻšāϞ⧇ āĻāχ Code āϟāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āĻšāĻŦ⧇āĨ¤
    3. Looping Statement (Loop Statement):

      • āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Statement āϝāĻž āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻĒāϰāĻŋāĻŽāĻžāϪ⧇ Code āĻĒ⧁āύāϰāĻžāĻŦ⧃āĻ¤ā§āϤāĻŋ āĻ•āϰ⧇āĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        for (int i = 0; i < 5; i++) {
            printf("%d\n", i);
        }         // 0, 1, 2, 3, 4 āĻāχ āϏāĻ‚āĻ–ā§āϝāĻž āϗ⧁āϞāĻŋ Print āĻ•āϰāĻŦ⧇āĨ¤
    4. Function Call Statement (Function Call Statement):

      • āĻāĻ•āϟāĻŋ Function Call āĻ•āϰāĻž āĻāĻ•āϟāĻŋ Statement āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ—āĻŖā§āϝ āĻšāϝāĻŧāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        printf("Hello, world!\n");  // print Function Call āĻšāĻšā§āϛ⧇āĨ¤
    5. Return Statement:

      • āĻāϟāĻŋ āĻāĻ•āϟāĻŋ Function āĻĨ⧇āϕ⧇ Value āĻĢ⧇āϰāϤ āĻĒāĻžāĻ āĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        int add(int a, int b) {
            return a + b;    // āĻŽāĻžāύ āĻĢ⧇āϰāϤ āĻĻā§‡ā§ŸāĨ¤
        }  

  • Expression āĻ•āĻŋ?

    Expression āĻāĻ•āϟāĻŋ Code āĻāϰ āĻ…āĻ‚āĻļ āϝāĻž āĻŽāĻžāύ āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āĻŦāĻž āϕ⧋āύ⧋ āĻ•āĻžāĻ°ā§āϝ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• Variable, Operator āĻāĻŦāĻ‚ Function āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϕ⧋āύ⧋ āĻŽāĻžāύ āĻŦāĻž āĻĢāϞāĻžāĻĢāϞ āĻ‰ā§ŽāĻĒāĻ¨ā§āύ āĻ•āϰ⧇āĨ¤ Expression āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāĻ•āϟāĻŋ Statement āĻāϰ āĻ…āĻ‚āĻļ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āĻāĻŦāĻ‚ āĻāϰ āĻĢāϞāĻžāĻĢāϞ āĻāĻ•āϟāĻŋ āĻŽāĻžāύ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ Expression āϗ⧁āϞāĻŋ Computer āϕ⧇ āĻ•āĻŋāϛ⧁ āĻ—āĻŖāύāĻž āĻŦāĻž āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽ āĻ•āϰāϤ⧇ āĻŦāϞ⧇, āĻāĻŦāĻ‚ āϏ⧇āχ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽā§‡āϰ āĻļ⧇āώ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŽāĻžāύ āĻŦāĻž āĻĢāϞāĻžāĻĢāϞ āĻĒāĻžāĻ“ā§ŸāĻž āϝāĻžā§ŸāĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž Expression āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ Final āĻāĻ•āϟāĻž Result āĻĨāĻžāĻ•āĻŦ⧇āχāĨ¤ āϝ⧇āĻŽāύ:

    1. Arithmetic Expression(āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• Expression):

      • āĻāϟāĻŋ āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• Operation āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰ⧇, āϝ⧇āĻŽāύ āϝ⧋āĻ—, āĻŦāĻŋāϝāĻŧā§‹āĻ—, āϗ⧁āĻŖ, āĻ­āĻžāĻ— āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤ āĻāĻ–āĻžāύ⧇ āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• āĻŽāĻžāύ āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻŋ āĻĢāϞāĻžāĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        int x = 5 + 3 * 2;   // āĻāĻ–āĻžāύ⧇ 5 + (3 * 2) āĻāĻ•āϟāĻŋ expression, āϝāĻž 11 Result āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĻ⧇āĻŦ⧇āĨ¤
    2. Logical Expression:

      • āĻāϟāĻŋ āĻļāĻ°ā§āϤ āϝāĻžāϚāĻžāχ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ, āϝ⧇āĻŽāύ True āĻŦāĻž False āϰāĻŋāϟāĻžāĻ°ā§āύ āĻ•āϰāĻžāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        int result = (x > 10 && y < 20);  // Expression: x > 10 āĻāĻŦāĻ‚ y < 20 
    3. Function Call Expression:

      • āĻāĻ•āϟāĻŋ Function Call āĻ“ āĻāĻ•āϟāĻŋ Expression āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻž āĻāĻ•āϟāĻŋ āĻŽāĻžāύ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇āĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        int y = add(5, 3);  // add(5, 3) āĻāĻ•āϟāĻŋ expression
    4. Assignment Expression:

      • Variable āĻāϰ āĻŽāĻžāύ āĻĻ⧇āĻ“ā§ŸāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤

      • āωāĻĻāĻžāĻšāϰāĻŖ:

        int x = 10;  // expression: x = 10

    āϏ⧁āϤāĻžāϰāĻžāĻ‚, Expression āĻšāϞ āĻāĻŽāύ āϕ⧋āύ⧋ Code āϝāĻž āϕ⧋āύ⧋ āĻŽāĻžāύ āϤ⧈āϰāĻŋ āĻŦāĻž āĻ‰ā§ŽāĻĒāĻ¨ā§āύ āĻ•āϰ⧇, āĻāĻŦāĻ‚ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāĻ•āϟāĻŋ Statement āĻāϰ āĻ…āĻ‚āĻļ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ, āϤāĻŦ⧇ āĻāϟāĻŋ āĻāĻ•āĻž āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤


  • Syntax āĻ•āĻŋ?

    Syntax āĻŦāϞāϤ⧇ āĻŦā§‹āĻāĻžā§Ÿ, āĻāĻ•āϟāĻŋ Program āϞ⧇āĻ–āĻžāϰ āύāĻŋ⧟āĻŽāĻžāĻŦāϞ⧀ āĻŦāĻž āĻ•āĻžāĻ āĻžāĻŽā§‹ āϝāĻž āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Programming āĻ­āĻžāώāĻžāϰ āϜāĻ¨ā§āϝ āĻŦ⧈āϧ (valid) āĻāĻŦāĻ‚ āϏāĻ āĻŋāĻ• (correct) Code āϞ⧇āĻ–āĻžāϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāĻŋāĻ•āĻž āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻ­āĻžāώāĻžāϟāĻŋāϰ āĻ—āĻ āύ, āĻļāĻŦā§āĻĻ āĻŦā§āϝāĻŦāĻšāĻžāϰ, āĻāĻŦāĻ‚ āύāĻŋ⧟āĻŽāĻžāĻŦāϞ⧀ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻĻā§‡ā§ŸāĨ¤ Programming āĻ­āĻžāώāĻžāϰ Syntax āĻāϰ āϏāĻ āĻŋāĻ•āϤāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰāĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Program āϟāĻŋ Computer āĻĻā§āĻŦāĻžāϰāĻž āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ Parse āĻāĻŦāĻ‚ Execute āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤

    Syntax āĻŽā§‚āϞāϤ āĻāĻ•āϟāĻŋ Program āĻāϰ āĻ—āĻ āύ āĻāĻŦāĻ‚ āϞ⧇āĻ–āĻžāϰ āύāĻŋ⧟āĻŽāĻžāĻŦāϞ⧀āϕ⧇ āĻŦā§‹āĻāĻžā§Ÿ, āϝ⧇āϗ⧁āϞāĻŋ āϝāĻĻāĻŋ āϭ⧁āϞāĻ­āĻžāĻŦ⧇ āĻ…āύ⧁āϏāϰāĻŖ āĻ•āϰāĻž āĻšā§Ÿ, āϤāĻŦ⧇ Program āϟāĻŋ Compile āĻŦāĻž Run āĻšāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āύāĻžāĨ¤ Programmer āĻāϰ Syntax āĻāϰ āϭ⧁āϞāϗ⧁āϞāĻŋ āϏāĻžāϧāĻžāϰāĻŖāϤ Compiler Error āĻŦāĻž Syntax Error āĻšāĻŋāϏ⧇āĻŦ⧇ Output āĻ āĻĻ⧇āĻ–āĻž āϝāĻžā§ŸāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    Valid(āϏāĻ āĻŋāĻ•) Syntax: C āĻ­āĻžāώāĻžā§Ÿ āĻāĻ•āϟāĻŋ āϏāĻ āĻŋāĻ• "Hello, World!" Print āĻ•āϰāĻžāϰ Program

    #include <stdio.h>
    
    int main() {
        printf("Hello, World!\n");  // āϏāĻ āĻŋāĻ• āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ
        return 0;
    }

    āĻāĻ–āĻžāύ⧇ printf("Hello, World!\n"); āĻāĻ•āϟāĻŋ āϏāĻ āĻŋāĻ• āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏāĨ¤ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āĻĢāĻžāĻ‚āĻļāύ āĻ•āϞ, āϝ⧇āĻ–āĻžāύ⧇ āϏāĻ āĻŋāĻ• āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāϟāĻžāϰ āϏāĻš āĻĢāĻžāĻ‚āĻļāύāϟāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤

    Invalid(āϭ⧁āϞ) Syntax: C āĻ­āĻžāώāĻžā§Ÿ āĻāĻ•āϟāĻŋ āϭ⧁āϞ "Hello, World!" Print āĻ•āϰāĻžāϰ Program

    #include <stdio.h>
    
    int main() {
        printf("Hello, World!\n")  // āϭ⧁āϞ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ: āϏ⧇āĻŽāĻŋāϕ⧋āϞāύ āĻŽāĻŋāϏāĻŋāĻ‚
        return 0;
    }

    āĻāĻ–āĻžāύ⧇ printf("Hello, World!\n") āϞāĻžāχāύ⧇ āϏ⧇āĻŽāĻŋāϕ⧋āϞāύ (;) Missing, āϝāĻž Syntax Error āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤

    āϏ⧁āϤāĻžāϰāĻžāĻ‚ Syntax āĻāϰ āϏāĻ āĻŋāĻ•āϤāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Programmer āĻāϰ āĻ­āĻžāώāĻžāϰ āύāĻŋ⧟āĻŽāĻžāĻŦāϞ⧀ āĻŽā§‡āύ⧇ āϚāϞāĻž āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϜāϰ⧁āϰāĻŋāĨ¤


  • Algorithm āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϟāĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āϕ⧇āύ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ?

    Algorithm āĻšāϞ⧋ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āĻĒāϰāĻŋāĻ•āĻ˛ā§āĻĒāĻŋāϤ āϧāĻžāĻĒ⧇āϰ āĻāĻ•āϟāĻŋ āϏ⧁āϏāĻ‚āĻ—āĻ āĻŋāϤ āĻāĻŦāĻ‚ āĻĒāĻ°ā§āϝāĻžā§ŸāĻ•ā§āϰāĻŽāĻŋāĻ• āĻĒāĻĻā§āϧāϤāĻŋāĨ¤ Algorithm āĻāϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ⧋ āϕ⧋āύāĻ“ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇, āϏ⧇āχ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āĻĒā§āĻ°ā§Ÿā§‹āϜāĻ¨ā§€ā§Ÿ āϧāĻžāĻĒāϗ⧁āϞāĻŋāϕ⧇ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āϏāĻžāϜāĻžāύ⧋ āϝāĻžāϤ⧇ Computer āĻŦāĻž āĻŽāĻžāύ⧁āώ āϏ⧇āϟāĻŋ āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĻ­āĻžāĻŦ⧇ āĻ…āύ⧁āϏāϰāĻŖ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ Algorithm āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ, āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āĻŦāĻž āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āĻ—āĻŖāύāĻž āĻ•āϰāĻž āĻšā§Ÿ, āϝāĻž Programming āĻ­āĻžāώāĻžā§Ÿ Code āĻ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāĻŋāϤ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϝ⧋āĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻž:

    āϧāϰāĻž āϝāĻžāĻ•, āφāĻŽāĻžāĻĻ⧇āϰ āĻĻ⧁āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž āĻĻ⧇āĻ“ā§ŸāĻž āφāϛ⧇ āĻāĻŦāĻ‚ āφāĻŽāϰāĻž āϤāĻžāĻĻ⧇āϰ āϝ⧋āĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āϚāĻžāχāĨ¤

    Algorithm:

    ā§§. āĻĻ⧁āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž A āĻāĻŦāĻ‚ B āχāύāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āύāĻžāĻ“āĨ¤
    ⧍. āĻĢāϞāĻžāĻĢāϞ = A + BāĨ¤
    ā§Š. āĻĢāϞāĻžāĻĢāϞ āφāωāϟāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒā§āϰāĻĻāĻ°ā§āĻļāύ āĻ•āϰ⧋āĨ¤
    

    āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āϏāĻšāϜ Algorithm āϝāĻž āĻĻ⧁āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϝ⧋āĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻŦ⧇āĨ¤

    āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻ¨ā§āύāĻŋāĻŦ⧇āĻļ sort āĻ•āϰāĻž (Bubble Sort):

    Bubble Sort āĻāĻ•āϟāĻŋ Algorithm āϝāĻž āĻāĻ•āϟāĻŋ āϤāĻžāϞāĻŋāĻ•āĻžāϰ āωāĻĒāĻžāĻĻāĻžāύāϗ⧁āϞ⧋āϕ⧇ āϏāĻžāϜāĻŋā§Ÿā§‡ āĻĻā§‡ā§ŸāĨ¤

    Algorithm:

    ā§§. āĻāĻ•āϟāĻŋ āϤāĻžāϞāĻŋāĻ•āĻž Load āĻ•āϰ⧋āĨ¤
    ⧍. āϤāĻžāϞāĻŋāĻ•āĻžāϰ āĻĒā§āϰāĻĨāĻŽ āωāĻĒāĻžāĻĻāĻžāύ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧋āĨ¤
    ā§Š. āĻĒāϰāĻŦāĻ°ā§āϤ⧀ āωāĻĒāĻžāĻĻāĻžāύ⧇āϰ āϏāĻžāĻĨ⧇ āϤ⧁āϞāύāĻž āĻ•āϰ⧋:
       - āϝāĻĻāĻŋ āĻĒā§āϰāĻĨāĻŽ āωāĻĒāĻžāĻĻāĻžāύāϟāĻŋ āĻŦ⧜ āĻšā§Ÿ, āϤāĻžāĻšāϞ⧇ āĻĻ⧁āχāϟāĻŋ āωāĻĒāĻžāĻĻāĻžāύ āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āϏāĻžāĻĨ⧇ āĻŦāĻĻāϞāĻžāĻ“āĨ¤
       - āύāĻž āĻšāϞ⧇, āĻ•āĻŋāϛ⧁ āĻ•āϰ⧋ āύāĻžāĨ¤
    ā§Ē. āĻĒ⧁āϰ⧋ āϤāĻžāϞāĻŋāĻ•āĻž āĻāĻ•āĻŦāĻžāϰ Scan āĻšāĻ“ā§ŸāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒ⧁āύāϰāĻžāĻŦ⧃āĻ¤ā§āϤāĻŋ āĻ•āϰ⧋āĨ¤
    ā§Ģ. āϤāĻžāϞāĻŋāĻ•āĻž āϏāĻžāϜāĻžāύ⧋ āĻšāϞ⧇, output āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒā§āϰāĻĻāĻ°ā§āĻļāύ āĻ•āϰ⧋āĨ¤
    

    āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āϏāĻ‚āĻ–ā§āϝāĻžāϰ Factorial āĻŦ⧇āϰ āĻ•āϰāĻžāϰ Algorithm:

    Factorial āĻāĻ•āϟāĻŋ āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āϏāĻ‚āĻ–ā§āϝāĻž āϝāĻž N! āĻĻā§āĻŦāĻžāϰāĻž āĻĒā§āϰāĻ•āĻžāĻļāĻŋāϤ āĻšā§Ÿ āĻāĻŦāĻ‚ āϤāĻž N āĻĨ⧇āϕ⧇ 1 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻŦ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϗ⧁āĻŖāĻĢāϞ āĻšā§ŸāĨ¤

    Algorithm:

    ā§§. āĻāĻ•āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž N āχāύāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āύāĻžāĻ“āĨ¤
    ⧍. āĻĢāϞāĻžāĻĢāϞ = ā§§āĨ¤
    ā§Š. āϝāϤāĻĻāĻŋāύ N > ā§§, āϤāϤāĻĻāĻŋāύ:
       - āĻĢāϞāĻžāĻĢāϞ = āĻĢāϞāĻžāĻĢāϞ * NāĨ¤
       - N = N - ā§§āĨ¤
    ā§Ē. āĻĢāϞāĻžāĻĢāϞ āφāωāϟāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒā§āϰāĻĻāĻ°ā§āĻļāύ āĻ•āϰ⧋āĨ¤
    

    Algorithm āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻšāϞ:

    1. āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻĒāĻĻāĻ•ā§āώ⧇āĻĒ â‡’ Algorithm āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĒāĻĻāĻ•ā§āώ⧇āĻĒ āĻ¸ā§āĻĒāĻˇā§āϟ āĻāĻŦāĻ‚ āϏ⧁āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻšāϤ⧇ āĻšāĻŦ⧇āĨ¤
    2. āϏāĻŽāĻžāĻĒā§āϤāĻŋ ⇒ Algorithm āϟāĻŋ āĻ…āĻŦāĻļā§āϝāχ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻ‚āĻ–ā§āϝāĻ• Step āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻļ⧇āώ āĻšāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻāϟāĻŋ Infinite Loop āĻŦāĻž āϏāĻŽāĻžāĻĒā§āϤāĻŋāĻšā§€āύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤
    3. Input āĻāĻŦāĻ‚ Output ⇒ Algorithm āĻ āĻ•āĻŋāϛ⧁ Input āĻĨāĻžāĻ•āϤ⧇ āĻšāĻŦ⧇, āϝ⧇āϗ⧁āϞ⧋āϰ āωāĻĒāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āϚāϞāĻŦ⧇ āĻāĻŦāĻ‚ āĻ•āĻŋāϛ⧁ Output āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāĻŦ⧇āĨ¤
    4. āϏ⧁āĻ¸ā§āĻĒāĻˇā§āϟāϤāĻž (Unambiguity) ⇒ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĒāĻĻāĻ•ā§āώ⧇āĻĒ āĻāϤāϟ⧁āϕ⧁ āĻ¸ā§āĻĒāĻˇā§āϟ āĻāĻŦāĻ‚ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻšāϤ⧇ āĻšāĻŦ⧇ āϝāĻžāϤ⧇ āĻāϟāĻŋ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĻ­āĻžāĻŦ⧇ āĻāĻŦāĻ‚ āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžā§ŸāĻŋāϤ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤
    5. āĻ—āĻŖāύāĻžāϝ⧋āĻ—ā§āϝāϤāĻž ⇒ Algorithm āĻāϰ āϏāĻŽāĻ¸ā§āϤ Step āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āĻšāϤ⧇ āĻšāĻŦ⧇ āϝ⧇, Computer āĻŦāĻž āĻŽāĻžāύ⧁āώ āϏāĻšāĻœā§‡āχ āϤāĻž āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    6. āϏāĻžāĻŽāĻ—ā§āϰāĻŋāĻ•āϤāĻž (Finiteness) ⇒ Algorithm āϟāĻŋ āĻ…āĻŦāĻļā§āϝāχ āĻāĻ•āϟāĻŋ āϏ⧀āĻŽāĻŋāϤ āϏāĻ‚āĻ–ā§āϝāĻ• Step āĻ āĻļ⧇āώ āĻšāĻŦ⧇āĨ¤

    Algorithm āĻāϰ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāϗ⧁āϞ⧋ āĻšāϞ:

    1. āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āĻĒāĻĨ ⇒ Algorithm āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āϏ⧁āϏāĻ‚āĻ—āĻ āĻŋāϤ āĻĒāĻĻā§āϧāϤāĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇ āϝāĻž āĻĢāϞāĻ¸ā§āĻŦāϰ⧂āĻĒ Coding āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤
    2. āĻĒā§āϰāĻĻāĻ°ā§āĻļāύāϝ⧋āĻ—ā§āϝāϤāĻž āĻāĻŦāĻ‚ āĻĒ⧁āύāσāĻŦā§āϝāĻŦāĻšāĻžāϰāϝ⧋āĻ—ā§āϝāϤāĻž ⇒ āĻāĻ•āĻŦāĻžāϰ Algorithm āϤ⧈āϰāĻŋ āĻšāϞ⧇, āϤāĻž āĻ…āĻ¨ā§āϝ āĻ…āύ⧇āĻ• Program āĻ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    3. āĻĻā§āϰ⧁āϤāϤāĻž āĻāĻŦāĻ‚ āĻĻāĻ•ā§āώāϤāĻž ⇒ āϏāĻ āĻŋāĻ• Algorithm āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϞ⧇ Program āφāϰāĻ“ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻ•āĻŽ Resource āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϚāϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • Pseudo Code āĻ•āĻŋ? āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϰ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻžāϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ?

    Pseudo Code āĻšāϞ⧋ Programming āĻ­āĻžāώāĻžāϰ āĻŦāĻžāχāϰ⧇ āĻāĻ•āϟāĻŋ āϏāĻšāϜ, āĻŽāĻžāύāĻŦāĻĒāĻžāĻ ā§āϝ āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž Algorithm āĻāϰ āĻŦāĻ°ā§āĻŖāύāĻžāĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻāĻ•āϟāĻŋ Non Programming āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž Program āĻŦāĻž Algorithm āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻĒāĻĻā§āϧāϤāĻŋ āĻŦā§‹āĻāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ Pseudo Code āĻāϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ⧋, āϕ⧋āύ⧋ Programming āĻ­āĻžāώāĻžāϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Syntax āĻŦā§āϝāĻŦāĻšāĻžāϰ āύāĻž āĻ•āϰ⧇, Programmer āĻāϰ āĻŽā§‚āϞ āϧāĻžāϰāĻŖāĻž āĻāĻŦāĻ‚ āĻ•āĻžāĻœā§‡āϰ āĻĒā§āϰāĻŦāĻžāĻš āĻŦāĻ°ā§āĻŖāύāĻž āĻ•āϰāĻžāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖ:

    N āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϝ⧋āĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻž:

    BEGIN
       SET sum = 0
       FOR each number from 1 to N
           ADD number to sum
       END FOR
       PRINT sum
    END
    

    āĻāĻ–āĻžāύ⧇, Pseudo Code āϟāĻŋ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻ•āϰ⧇ āϝ⧇, āφāĻŽāϰāĻž ā§§ āĻĨ⧇āϕ⧇ N āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻŦ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϝ⧋āĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āϝāĻžāĻšā§āĻ›āĻŋāĨ¤

    āĻāĻ•āϟāĻŋ Number(āϏāĻ‚āĻ–ā§āϝāĻž) āĻ•āĻŋ Positive, Negative āύāĻž āĻļā§‚āĻ¨ā§āϝ āϤāĻž Check āĻ•āϰāĻž:

    BEGIN
       IF number > 0 THEN
           PRINT "Positive number"
       ELSE IF number < 0 THEN
           PRINT "Negative number"
       ELSE
           PRINT "Zero"
       END IF
    END
    

    āĻāχ Pseudo Code āϟāĻŋ āĻāĻ•āϟāĻŋ Number Check āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻāϟāĻŋ Positive, Negative āĻŦāĻž āĻļā§‚āĻ¨ā§āϝ āĻšāĻ“ā§ŸāĻž āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇āĨ¤

    Factorial āĻŦ⧇āϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Pseudo Code:

    BEGIN
       SET factorial = 1
       FOR each number from 1 to N
           SET factorial = factorial * number
       END FOR
       PRINT factorial
    END
    

    āĻāĻ–āĻžāύ⧇, Pseudo Code āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻāĻ•āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž N āĻāϰ Factorial āĻŦ⧇āϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāϛ⧇āĨ¤

    Pseudo Code āĻāϰ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝāϗ⧁āϞ⧋ āĻšāϞ:

    1. āϏāϰāϞ āĻ­āĻžāώāĻžā§Ÿ āϞ⧇āĻ–āĻž ⇒ Pseudo Code āĻ Programming āĻ­āĻžāώāĻžāϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Symbol āĻŦāĻž Syntax āύāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϏāĻžāϧāĻžāϰāĻŖ āĻ­āĻžāώāĻžā§Ÿ Program āĻāϰ āĻ•āĻžāĻœā§‡āϰ āϧāĻžāϰāĻž āϞ⧇āĻ–āĻž āĻšā§ŸāĨ¤
    2. āϏāĻšāϜ āĻ“ āĻŦā§‹āϧāĻ—āĻŽā§āϝ ⇒āĻāϟāĻŋ āĻŽā§‚āϞāϤ Programming āϜāĻžāύ⧇āύ āύāĻž āĻāĻŽāύ āĻŦā§āϝāĻ•ā§āϤāĻŋāĻĻ⧇āϰ āϜāĻ¨ā§āϝāĻ“ āĻŦā§‹āĻāĻž āϏāĻšāϜ āĻšā§ŸāĨ¤ āĻāϟāĻŋ Algorithm āĻŦāĻž āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϧāĻžāĻĒāϗ⧁āϞ⧋ āĻ¸ā§āĻĒāĻˇā§āϟāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰ⧇āĨ¤
    3. āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ­āĻžāώāĻžā§Ÿ āĻŦāĻžāρāϧāĻž āĻĨāĻžāϕ⧇ āύāĻž ⇒ āĻāϟāĻŋ āϕ⧋āύ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Programming āĻ­āĻžāώāĻžāϰ āĻ—āĻ āύ āĻ…āύ⧁āϏāϰāĻŖ āĻ•āϰ⧇ āύāĻž, āϤāĻžāχ āφāĻŽāϰāĻž āϝ⧇āϕ⧋āύ⧋ āĻ­āĻžāώāĻžā§Ÿ Pseudo Code āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŋ, āϤāĻŦ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ āχāĻ‚āϰ⧇āϜāĻŋ āĻ­āĻžāώāĻž āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤

    Pseudo Code āĻāϰ āωāĻĒāĻ•āĻžāϰāĻŋāϤāĻžāϗ⧁āϞ⧋ āĻšāϞ:

    1. āϏāĻšāϜ āϏāĻŽāĻžāϧāĻžāύ āĻŦā§‹āĻāĻžāύ⧋ ⇒ Programming āĻ­āĻžāώāĻžā§Ÿ āύāĻž āĻ—āĻŋā§Ÿā§‡, āϏāĻšāϜ āĻ­āĻžāώāĻžā§Ÿ Problem Solve āĻ•āϰāϤ⧇ āϏāĻšāĻžā§ŸāϤāĻž āĻ•āϰ⧇āĨ¤
    2. Program Design ⇒ Coding āĻļ⧁āϰ⧁ āĻ•āϰāĻžāϰ āφāϗ⧇ Problem āĻŦāĻž Algorithm āĻāϰ āĻ•āĻžāĻ āĻžāĻŽā§‹ āĻĒāϰāĻŋāĻ•āĻ˛ā§āĻĒāύāĻž āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤
    3. āĻ­āĻžāώāĻž āύāĻŋāϰāĻĒ⧇āĻ•ā§āώ ⇒ āϕ⧋āύ⧋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Programming āĻ­āĻžāώāĻžāϰ Syntax āĻ…āύ⧁āϏāϰāĻŖ āύāĻž āĻ•āϰāĻžā§Ÿ, āĻāϟāĻŋ āϏāĻšāĻœā§‡āχ āĻāĻ• āĻ­āĻžāώāĻž āĻĨ⧇āϕ⧇ āĻ…āĻ¨ā§āϝ āĻ­āĻžāώāĻžā§Ÿ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤
    4. āĻĻā§āϰ⧁āϤ āϏāĻŽāĻžāϧāĻžāύ ⇒ āϜāϟāĻŋāϞ Problem āϗ⧁āϞāĻŋāϰ āϏāĻŽāĻžāϧāĻžāύ āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āωāĻĒāĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰāϤ⧇ āĻāϟāĻŋ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ āωāĻĒāĻžā§ŸāĨ¤

  • Bug āĻ•āĻŋ ? Debug āĻ•āĻŋ?

    Bug:

    Bug āĻšāϞ⧋ āϕ⧋āύ⧋ Program, Software āĻŦāĻž System āĻ āϝ⧇ āϕ⧋āύ⧋ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻŦāĻž āϭ⧁āϞ āϝāĻž āϤāĻžāϰ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ• āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āĻŦā§āϝāĻžāĻšāϤ āĻ•āϰ⧇āĨ¤ Bug āĻāϰ āϧāϰāύ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āϝ⧇āĻŽāύ Syntax, Logical, Runtime āχāĻ¤ā§āϝāĻžāĻĻāĻŋāĨ¤

    Debug:

    Debug āĻšāϞ⧋ Bug āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰ⧇ āϤāĻž āĻ āĻŋāĻ• āĻ•āϰāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻžāĨ¤ āĻāϟāĻŋ Software Development āĻāϰ āĻāĻ•āϟāĻŋ āĻ…āĻĒāϰāĻŋāĻšāĻžāĻ°ā§āϝ āĻ…āĻ‚āĻļ āĻāĻŦāĻ‚ āĻāϟāĻŋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Tool āĻ“ āĻ•ā§ŒāĻļāϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ•āϰāĻž āĻšā§Ÿ, āϝāĻžāϤ⧇ Software āϟāĻŋ āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


  • āϚāϞ⧁āύ āĻœā§‡āύ⧇ āύāĻŋāχ, Programming āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻāĻ•āϟāĻŋ Problem āĻāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻž āϝāĻžā§Ÿ?

    Programming āĻ•āϰāĻž āĻšā§Ÿ āĻŽā§‚āϞāϤ Computer āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϕ⧋āύ āĻāĻ•āϟāĻž Real Problem āĻāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝāĨ¤ Problem āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āϧāĻžāĻĒ āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ āϏ⧇āϗ⧁āϞ⧋ āĻšāϞāσ

    • Problem āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻāĻŦāĻ‚ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ ⇒ āĻĒā§āϰāĻĨāĻŽā§‡ Problem āϟāĻŋ āĻ•āĻŋ āϤāĻž āĻŦ⧁āĻāϤ⧇ āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤ āĻāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋāϤ⧇ āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ Instruction āϗ⧁āϞāĻŋ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
    • Algorithm Design ⇒ Algorithm āĻšāϞ āĻāĻ•āϟāĻŋ āϧāĻžāĻĒ⧇ āϧāĻžāĻĒ⧇ Instruction āϝāĻž Problem āĻāϰ āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻĒāĻĨ⧇ āύāĻŋāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻāϟāĻŋ Planning Stage āĻ āϤ⧈āϰāĻŋ āĻšāϝāĻŧāĨ¤
    • Coding ⇒ Algorithm āϕ⧇ Programming āĻ­āĻžāώāĻžāϝāĻŧ āϞāĻŋāϖ⧇ āĻĢ⧇āϞāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāϕ⧇ Coding āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤ āĻāχ āϧāĻžāĻĒ⧇, Programmer āĻāϰāĻž Syntax āĻŦāĻž Language āĻāϰ āύāĻŋāϝāĻŧāĻŽ āĻŽā§‡āύ⧇ Code āϞāĻŋāϖ⧇ āĻĨāĻžāϕ⧇āĨ¤
    • Compiling āĻŦāĻž Interpreting: Code āϞ⧇āĻ–āĻž āĻļ⧇āώ⧇, āĻāϟāĻŋāϕ⧇ Compiler āĻŦāĻž Interpreter āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Machine āĻ­āĻžāώāĻžāϝāĻŧ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāĻž āĻšāϝāĻŧ, āϝāĻž Computer āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
    • Debugging ⇒ Program āĻ āϝāĻĻāĻŋ āϕ⧋āύ⧋ Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āĻŦāĻž Bug āĻĨāĻžāϕ⧇, āϤāĻŦ⧇ āϤāĻž āϏāĻ‚āĻļā§‹āϧāύ āĻ•āϰāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāϕ⧇ Debugging āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤
    • Testing ⇒ Program āϟāĻŋ āĻ•āĻžāϜ āĻ•āϰāϛ⧇ āĻ•āĻŋāύāĻž āϤāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāϤ⧇ Program āĻāϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āĻāĻŦāĻ‚ āύāĻŋāĻ°ā§āĻ­āϰāϝ⧋āĻ—ā§āϝāϤāĻž āϝāĻžāϚāĻžāχ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
    • Code Maintenance āĻŦāĻž Update ⇒ Program āϚāĻžāϞ⧁ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒāϰāĻ“, āĻāϟāĻŋ Maintain āĻāĻŦāĻ‚ Update āĻ•āϰāĻžāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāϤ⧁āύ Features āϝ⧋āĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ…āĻĨāĻŦāĻž Error(āĻ¤ā§āϰ⧁āϟāĻŋ) āϏāĻ‚āĻļā§‹āϧāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝāĨ¤

  • āĻāĻ•āϜāύ Beginner āĻšāĻŋāϏ⧇āĻŦ⧇ "āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻāϰ āφāĻĻā§āϝ⧋āĻĒā§āϰāĻžāĻ¨ā§āϤ" āĻŦāχāϟāĻŋ āφāĻŽāϰāĻž āϕ⧇āύ āĻĒ⧜āĻŦ?

āĻāχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž Programming āĻāĻŦāĻ‚ āϤāĻžāϰ Related āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āϜāĻžāύāϞāĻžāĻŽāĨ¤ āĻāĻ–āύ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻžāύāϤ⧇ āĻšāĻŦ⧇ Programming āĻāϰ āφāϰāĻ“ āĻ•āĻŋāϛ⧁ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻŽā§ŒāϞāĻŋāĻ• āĻŦāĻŋāώ⧟ āϝ⧇āϗ⧁āϞ⧋ āĻĒā§āϰāϤāĻŋāϟāĻŋ Programming Language āĻāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āϜāĻžāύāĻž āϞāĻžāĻ—āĻŦ⧇āĨ¤ āĻāχ āĻŽā§ŒāϞāĻŋāĻ• āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻšāϞ, Variable, Datatype, Operators, Conditional Statement, Loop, Array, Function, Object. āĻāχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āĻ—āĻ˛ā§āĻĒ āφāĻ•āĻžāϰ⧇ āĻļ⧇āĻ–āĻžāϰ āϜāĻ¨ā§āϝ āφāĻŽāĻžāĻĻ⧇āϰ āĻāĻ•āϟāĻž āĻŦāχ āĻĒ⧜āϤ⧇ āĻšāĻŦ⧇ āϝ⧇āϟāĻž āĻĒ⧜āĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāĻžāĻĻ⧇āϰ āĻŽā§ŒāϞāĻŋāĻ• āϧāĻžāϰāύāĻžāϗ⧁āϞ⧋ āϖ⧁āĻŦ āĻ­āĻžāϞāĻ­āĻžāĻŦ⧇ āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤ āĻŦāχāϟāĻŋāϰ āύāĻžāĻŽā§‡ āĻšāĻšā§āϛ⧇ “āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻāϰ āφāĻĻā§āϝ⧋āĻĒā§āϰāĻžāĻ¨ā§āĻ¤â€āĨ¤ āĻŦāχāϟāĻŋ āϞ⧇āϖ⧇āϛ⧇āύ Web Development āĻŦāĻž Technology āĻāϰ āϜāĻ—āϤ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āĻ…āύ⧇āϕ⧇āϰāχ āĻĒāϰāĻŋāϚāĻŋāϤ āĻĻ⧁āχāϟāĻŋ āĻŽā§āĻ– āĻŦāĻžāĻ‚āϞāĻžāĻĻ⧇āĻļ⧇āϰ āĻĻ⧁āχāϜāύ āĻ—āĻ°ā§āĻŦāĻŋāϤ āϏāĻ¨ā§āϤāĻžāύ “āĻāχāϚ āĻāĻŽ āύāĻžāψāĻŽ(HM Nayem)” āĻ­āĻžāχ āĻāĻŦāĻ‚ “āϏ⧇āϗ⧁āĻĢāĻž āϤāĻžāϰāĻžāĻžā§āϜ⧁āĻŽ(Shegufa Taranjum)” āφāĻĒ⧁āĨ¤

ā§Šā§¨ā§Ļ āĻĒ⧃āĻˇā§āϟāĻžāϰ āĻāχ āĻŦāχāϟāĻŋāϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§‹āϟ ā§§ā§ĢāϟāĻŋ āĻ…āĻ§ā§āϝāĻžā§Ÿ āĻ°ā§Ÿā§‡āϛ⧇āĨ¤ āĻāχ ā§§ā§ĢāϟāĻŋ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ Programming āĻāϰ Mindset āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āϤ⧈āϰāĻŋ āĻ•āϰāĻŦ, Programming āĻāϰ āĻŽā§ŒāϞāĻŋāĻ• āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻāĻŦāĻ‚ āĻŽā§ŒāϞāĻŋāĻ• āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻļ⧇āĻ–āĻžāϰ āĻĒāϰ āĻ•āĻŋ āĻ•āϰāĻŦ āϤāĻž āύāĻŋā§Ÿā§‡ āφāϞ⧇āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤ āϝ⧇āĻŽāύ -

  • āĻĒā§āϰāĻĨāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻ¸ā§āĻŦāĻĒā§āύ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • āĻāĻ–āĻžāύ⧇ āĻ—āĻ˛ā§āĻĒ āφāĻ•āĻžāϰ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇, āĻāĻ•āϜāύ Beginner āϝāĻ–āύ Programming āĻāϰ āύāĻžāĻŽ āĻļ⧁āύ⧇ āĻŦāĻž Programmer āĻšāĻ“ā§ŸāĻžāϰ āĻ¸ā§āĻŦāĻĒā§āύ āĻĻ⧇āϖ⧇ āϤāĻ–āύ āϏ⧇ āĻ•āĻŋ āĻ•āĻŋ āĻ¸ā§āĻŦāĻĒā§āύ āĻĻ⧇āϖ⧇ āĻāĻŦāĻ‚ āϤāĻžāϰ āĻŽāύ⧇ āĻ•āĻŋ āĻ•āĻŋ āĻŦāĻŋāώ⧟ āωāĻ•āĻŋ āĻĻāĻŋāϤ⧇ āĻĨāĻžāϕ⧇ āϏ⧇āχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡āĨ¤
  • āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āύ⧇āĻļāĻžāϰ āύāĻžāĻŽ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • āĻāĻ–āĻžāύ⧇ āĻ­āĻŋāĻ¨ā§āύ āĻ­āĻŋāĻ¨ā§āύ Perspective āĻĨ⧇āϕ⧇ Programming āϕ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Computer āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻŽāϰāĻž āφāĻŽāĻžāĻĻ⧇āϰ āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ āϕ⧋āύ āϕ⧋āύ Problem āϗ⧁āϞ⧋āϕ⧇ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ āϏ⧇āϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • āĻāĻ›āĻžā§œāĻž Computer āĻāϰ āĻŽā§‚āϞ āĻ•āĻžāϜāϟāĻž āĻ•āĻŋ āϏ⧇āϟāĻž āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āϤ⧃āĻ¤ā§€ā§Ÿ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻŦā§āϝāĻ•ā§āϤāĻŋ āĻ“ āĻ•āĻ°ā§āĻŽāĻœā§€āĻŦāύ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • āĻāĻ–āĻžāύ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇, Code, Mindset, āύ⧇āĻļāĻžāĨ¤ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻāχ āϤāĻŋāύāϟāĻž āĻŦāĻŋāĻˇā§Ÿā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āϞ⧁āĻ•āĻŋā§Ÿā§‡ āφāϛ⧇ Programmer āĻšāĻ“ā§ŸāĻžāϰ āĻŦā§€āϜ āĻāĻŦāĻ‚ āĻāϗ⧁āϞ⧋ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻœā§€āĻŦāύ⧇ āϝ⧇āϕ⧋āύ āĻ•āĻŋāϛ⧁āϤ⧇āχ āϏāĻĢāϞ āĻšāĻ“ā§ŸāĻžāϰ āφāϏāϞ āϚāĻžāĻŦāĻŋāĻ•āĻžāĻ āĻŋ?
    • āĻāĻ–āĻžāύ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇, Programming āĻŦā§āϝāĻ•ā§āϤāĻŋ āĻ“ āĻ•āĻ°ā§āĻŽāĻœā§€āĻŦāύ⧇ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻĒā§āϰāĻ­āĻžāĻŦ āĻĢ⧇āϞāϤ⧇ āĻĒāĻžāϰ⧇?
    • āϝ⧇āĻšā§‡āϤ⧁ Programming āĻĨ⧇āϕ⧇ Result āĻĒ⧇āϤ⧇ āĻ…āύ⧇āĻ• āϏāĻŽā§Ÿ āϞ⧇āϗ⧇ āϝāĻžā§Ÿ āϤāĻžāχ Programming āĻļ⧇āĻ–āĻžāϰ āĻļ⧁āϰ⧁āϤ⧇āχ āφāĻŽāĻžāĻĻ⧇āϰ āĻāϰ āĻ­āĻŦāĻŋāĻˇā§āĻ¯ā§Ž āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇, āĻ­āĻŋāĻ¨ā§āύ āĻ­āĻŋāĻ¨ā§āύ Career āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āϜāĻžāύāϤ⧇ āĻšāĻŦ⧇āĨ¤ āϤāĻžāχ āĻāĻ–āĻžāύ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Job Role āĻāĻŦāĻ‚ āϤāĻžāĻĻ⧇āϰ āĻ•āĻžāϰ āĻ•āĻŋ āĻ•āĻžāϜ āϤāĻž āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • IT āϜāĻ—āϤ⧇ āϝ⧇āĻšā§‡āϤ⧁ Education Background Matter āĻ•āϰ⧇ āύāĻž āĻļ⧁āϧ⧁ Matter āĻ•āϰ⧇ āφāĻŽāϰāĻž Skillful āĻ•āĻŋāύāĻž āϤāĻžāχ āĻ…āύ⧇āϕ⧇ āĻĒ⧜āĻžāĻļā§‹āύāĻž āĻŦāĻžāĻĻ āĻĻāĻŋā§Ÿā§‡ āĻļ⧁āϧ⧁ Programming āĻ•āϰāϤ⧇ āϚāĻžā§ŸāĨ¤ āϤāĻžāχ Programming āĻāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ Academic āĻĒ⧜āĻžāĻļā§‹āύāĻž āĻ•āϤāϟāĻž āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āϤāĻž āύāĻŋā§Ÿā§‡āĻ“ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āϚāϤ⧁āĻ°ā§āĻĨ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āϕ⧋āύ āĻ­āĻžāώāĻž āύāĻž) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • āϝāĻĻāĻŋ Computer āĻļ⧁āϧ⧁ Binary āĻŦ⧁āĻā§‡ āĻĨāĻžāϕ⧇ āϤāĻžāĻšāϞ⧇ āĻāϤ āĻāϤ Programming Language āϕ⧇āύ āĻāϏ⧇āϛ⧇?
    • Programming āĻāĻŦāĻ‚ Programming āĻ­āĻžāώāĻž āĻ•āĻŋ āĻāĻ•āχ āĻŦāĻŋāώ⧟ āĻ•āĻŋāύāĻž?
    • āĻāĻ•āϟāĻž Generation āĻ āĻāĻ•āϟāĻž Language āύāĻž āĻĨ⧇āϕ⧇ āĻāϤāϗ⧁āϞ⧋ Language āϕ⧇āύ āφāϏāϞ⧋?
    • āĻāĻ–āĻžāύ⧇ C Family āĻāϰ āϏāĻĻāĻ¸ā§āϝ āĻ­āĻžāώāĻžāϗ⧁āϞ⧋āϰ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇āĻ“ āĻŦāϞāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Programming Paradigm āĻ•āĻŋ? āĻāϰ āĻĒā§āϰāĻ•āĻžāϰāϭ⧇āĻĻ āĻāĻŦāĻ‚ āĻāϗ⧁āϞ⧋āϰ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤāĨ¤
    • Compiler āĻāĻŦāĻ‚ Interpreter āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Compiled āĻ­āĻžāώāĻž āĻāĻŦāĻ‚ Interpreted āĻ­āĻžāώāĻžāϗ⧁āϞ⧋āϰ āύāĻžāĻŽ āĻāĻŦāĻ‚ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • āĻāϤ āĻāϤ Programming Language āϕ⧋āύāϟāĻž āϰ⧇āϖ⧇ āϕ⧋āύāϟāĻž āĻļāĻŋāĻ–āĻŦ? āϕ⧋āύāϟāĻž āĻļāĻŋāĻ–āϞ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āĻ­āĻžāϞ āĻšāĻŦ⧇ āϏ⧇āχ āĻŦāĻŋāώ⧟ āύāĻŋā§Ÿā§‡ āϏ⧁āĻ¨ā§āĻĻāϰāĻ­āĻžāĻŦ⧇ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • āĻāĻ–āĻžāύ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇, āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻŽāĻžāĻ¤ā§āϰ āϤāĻŋāύāϟāĻŋ Programming Paradigm āĻļāĻŋāϖ⧇ āφāĻŽāϰāĻž āϜāύāĻĒā§āϰāĻŋ⧟ Programming Language āĻ āĻŦāϏ āĻšā§Ÿā§‡ āϝ⧇āϤ⧇ āĻĒāĻžāϰāĻŦāĨ¤
  • āĻĒāĻžā§āϚāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻ•āĻŋ āĻļāĻŋāĻ–āϤ⧇ āĻšāĻŦ⧇) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • āĻāĻ–āĻžāύ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇ āĻāϤ āĻāϤ Programming āĻ­āĻžāώāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻĨ⧇āϕ⧇ āφāĻŽāϰāĻž Beginners āĻāϰāĻž āϕ⧋āύ Programming āĻ­āĻžāώāĻžāϟāĻž āĻĻāĻŋā§Ÿā§‡ āĻļ⧁āϰ⧁ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āĻāĻŦāĻ‚ āϕ⧇āύ āĻāϟāĻž āĻāϟāĻž āĻĻāĻŋā§Ÿā§‡ āĻļ⧁āϰ⧁ āĻ•āϰāĻž āωāϚāĻŋāϤāĨ¤
    • āĻāĻ–āĻžāύ⧇ C, C++, Java, JavaScript, Python Programming āĻ­āĻžāώāĻž āύāĻŋā§Ÿā§‡ āĻāĻ•āϟāĻž āϧāĻžāϰāĻŖāĻž āĻĻ⧇āĻ“ā§ŸāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤ āϝ⧇āĻŽāύ āĻāχ Programming āĻ­āĻžāώāĻžāϗ⧁āϞ⧋ Paradigm āĻ…āύ⧁āϏāĻžāϰ⧇ āϕ⧋āύ āϧāϰāϪ⧇āϰ Programming āĻ­āĻžāώāĻž, āĻāϟāĻž āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āĻŋ āĻ•āĻŋ āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžā§Ÿ, āĻāϟāĻž āϕ⧋āύ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āĻ­āĻžāϞ, āĻāϟāĻž āĻ•āϤāϟāĻž āĻĻā§āϰ⧁āϤ, āĻāϟāĻžāϰ Library Support āϕ⧇āĻŽāύ, Problem Solving āĻāϰ āϜāĻ¨ā§āϝ āĻāχ āĻ­āĻžāώāĻžāϟāĻž āϕ⧇āĻŽāύ, Beginner āĻšāĻŋāϏ⧇āĻŦ⧇ āĻāχ āĻ­āĻžāώāĻž āĻĻāĻŋā§Ÿā§‡ āĻļ⧁āϰ⧁ āĻ•āϰāϞ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āĻ­āĻžāϞ āĻšāĻŦ⧇ āĻ•āĻŋāύāĻž āχāĻ¤ā§āϝāĻžāĻĻāĻŋ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡ āĻŦāϞāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Pseudo Code āĻ•āĻŋ? āĻāϟāĻž āϕ⧇āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ? āĻāϟāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āϤ⧈āϰāĻŋ āĻ•āϰāĻŦ āωāĻĻāĻžāĻšāĻžāϰāĻŖ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻĻ⧇āĻ–āĻžāύ⧋ āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āφāĻŽāϰāĻž āφāϏāϞ Programming āĻļ⧇āĻ–āĻž āĻļ⧁āϰ⧁ āĻ•āϰāĻŦ, āϕ⧋āύ āĻĒā§āϰāĻ•āĻžāϰ Programming āĻ­āĻžāώāĻžāϰ āϜāĻžāĻŽā§‡āϞāĻž āĻ›āĻžā§œāĻž āϏ⧇āχ āĻŦāĻŋāĻˇā§Ÿā§‡āĻ“ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤

    💡 Note: āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ āĻĨ⧇āϕ⧇ āĻĒāĻžā§āϚāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ Beginner āĻāϰ āϏāĻžāĻŽāύ⧇ Programming āĻāϰ āĻāĻ•āϟāĻŋ Big Picture āϤ⧁āϞ⧇ āϧāϰāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤ āϝāĻžāϤ⧇ āĻ•āϰ⧇ Beginners āĻāϰ āĻŽāĻ§ā§āϝ⧇ Programming āĻāϰ āĻāĻ•āϟāĻž Mindset āϤ⧈āϰāĻŋ āĻšā§ŸāĨ¤ āϝ⧇āύ Programming āĻāĻ•āϟāĻž āύ⧇āĻļāĻžā§Ÿ āĻĒāϰāĻŋāĻŖāϤ āĻšā§ŸāĨ¤ āĻ•āĻžāϰāĻŖ Programming āĻļ⧇āĻ–āĻž, āĻāϟāĻž āĻāĻ•āϟāĻž āϞāĻŽā§āĻŦāĻž āĻ­ā§āϰāĻŽāĻŖāĨ¤ āϝāĻĻāĻŋ āĻāϟāĻž āύ⧇āĻļāĻžā§Ÿ āĻĒāϰāĻŋāĻŖāϤ āύāĻž āĻšā§Ÿ āϤāĻžāĻšāϞ⧇ āĻ•āĻŋāϛ⧁ āĻĻāĻŋāύ āĻ•āϰāĻžāϰ āĻĒāϰ āφāϰ āĻ­āĻžāϞ āϞāĻžāĻ—āĻŦ⧇ āύāĻžāĨ¤ āϤāĻžāχ āĻāχ āϚāĻžāϰāϟāĻž āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻāχ āĻŦāĻŋāώ⧟āϟāĻžāϕ⧇ āϗ⧁āϰ⧁āĻ¤ā§āĻŦ āĻĻ⧇āĻ“ā§ŸāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤

  • āώāĻˇā§āĻ  āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻāϗ⧁āϞ⧋āχ āĻŽā§ŒāϞāĻŋāĻ• āϚāĻžāĻšāĻŋāĻĻāĻž) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Fundamental āĻŦāĻž āĻŽā§ŒāϞāĻŋāĻ• āĻŦāĻŋāώ⧟ āĻŦāϞāϤ⧇ āĻ•āĻŋ āĻŦ⧁āĻāĻžā§Ÿ?
    • Programming āĻāϰ āĻŽā§ŒāϞāĻŋāĻ• āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻ•āĻŋ āĻ•āĻŋ? āĻāϗ⧁āϞ⧋ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āĻ…āĻ˛ā§āĻĒ āĻ•āϰ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻāĻŦāĻ‚ āĻāϗ⧁āϞ⧋ āĻļāĻŋāĻ–āϤ⧇ āĻ•āĻŋ āĻĒāϰāĻŋāĻŽāĻžāĻŖ āϏāĻŽā§Ÿ āϞāĻžāĻ—āĻŦ⧇ āϏ⧇āχ āϏāĻŦ āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āϏāĻĒā§āϤāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻŽāĻžāύ⧇ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύāĻļā§€āϞ) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Variable āĻ•āĻŋ? āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇ āφāĻŽāϰāĻž āϕ⧀āĻ­āĻžāĻŦ⧇ Variable āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋ āĻāϟāĻž āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Variable āφāĻŽāĻžāĻĻ⧇āϰ āϕ⧇āύ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻŦāĻž āĻĻāϰāĻ•āĻžāϰ āϏ⧇āϟāĻž āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞ āϰ⧇āϖ⧇ āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Datatype āĻ•āĻŋ? Datatype āϕ⧇āύ āϞāĻžāĻ—āĻŦ⧇? Datatype āĻ•ā§Ÿ āϧāϰāϪ⧇āϰ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇ āϤāĻž āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āĻ…āĻˇā§āϟāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻŽā§‡āĻļāĻŋāύ āϚāĻžāϞāĻ• āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻžāϰ) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Operator āĻ•āĻŋ? āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϧāϰāϪ⧇āϰ Operator, Operation āĻ•āĻŋ?, Operand āĻ•āĻŋ? āĻāχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āύāĻŦāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύ⧇āĻ“ā§ŸāĻžāϰ āĻ•ā§āώāĻŽāϤāĻž) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Condition āĻ•āĻŋ? Condition āφāĻŽāĻžāĻĻ⧇āϰ āϕ⧇āύ āĻĻāϰāĻ•āĻžāϰ? āĻ•ā§Ÿ āϧāϰāϪ⧇āϰ Condition āφāϛ⧇? āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞ āϰ⧇āϖ⧇ āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āĻĻāĻļāĻŽ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻŦāĻžāϞāĻŋāĻļ āĻŦāĻĻāϞ āϖ⧇āϞāĻž) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Loop āĻ•āĻŋ? Loop āφāĻŽāĻžāĻĻ⧇āϰ āϕ⧇āύ āĻĻāϰāĻ•āĻžāϰ? āĻ•ā§Ÿ āϧāϰāϪ⧇āϰ Loop āφāϛ⧇? āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞ āϰ⧇āϖ⧇ āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āĻāĻ•āĻžāĻĻāĻļ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āϏāĻžāϜāĻžāύ⧋ āĻ—ā§‹āĻ›āĻžāύ⧋ āĻĄā§‡āϟāĻž) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Array āĻ•āĻŋ? Array āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇? Array āφāĻŽāĻžāĻĻ⧇āϰ āϕ⧇āύ āĻĻāϰāĻ•āĻžāϰ? āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞ āϰ⧇āϖ⧇ āĻ—āĻ˛ā§āĻĒ āφāĻ•āĻžāϰ⧇ āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āĻĻā§āĻŦāĻžāĻĻāĻļ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āϏāĻŦāĻ•āĻŋāϛ⧁āχ āĻ…āĻŦāĻœā§‡āĻ•ā§āϟ) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Object āĻ•āĻŋ? āϕ⧇āύ āφāĻŽāϰāĻž Object āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ? āĻ•āĻ–āύ Array āφāϰ āĻ•āĻ–āύ Object āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ? āĻāχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻ—āĻ˛ā§āĻĒ āφāĻ•āĻžāϰ⧇ āωāĻĻāĻžāĻšāĻžāϰāĻŖāϏāĻš āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Object āφāϰ Object Oriented Programming āĻāĻ• āĻŦāĻŋāώ⧟ āĻ•āĻŋāύāĻž āϏ⧇āϟāĻž āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āĻ¤ā§āĻ°ā§Ÿā§‹āĻĻāĻļ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āφāĻŽāĻžāϰ āĻāĻ•āϟāĻžāχ āĻ•āĻžāϜ) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āϝāĻž āϝāĻž āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿ āϤāĻž āĻšāϞāσ

    • Function āĻ•āĻŋ? Function āϕ⧇āύ āĻāϏ⧇āϛ⧇? āĻ•āĻ–āύ āφāĻŽāĻžāĻĻ⧇āϰ Function āϞāĻžāĻ—āĻŦ⧇ āφāϰ Function āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻāχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
    • Function Argument, Function Parameter, Function Body, Return Statement āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤
  • āϚāϤ⧁āĻ°ā§āĻĻāĻļ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻŽāĻžāĻĨāĻžā§Ÿ āϚāĻŋāĻ¨ā§āϤāĻž āφāϏ⧇ āύāĻž) ⇒ āφāĻŽāĻžāĻĻ⧇āϰ Programming Basic āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻļ⧇āĻ–āĻž āĻļ⧇āώāĨ¤ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇ Basic āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻļ⧇āĻ–āĻžāϰ āĻĒāϰ āφāĻŽāϰāĻž āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Problem āϖ⧁āĻœā§‡ āĻŦ⧇āϰ āĻ•āϰāĻŦ āĻāĻŦāĻ‚ āϕ⧋āĻĨāĻžā§Ÿ āĻĨ⧇āϕ⧇ Problem āϗ⧁āϞ⧋ āϖ⧁āĻœā§‡ āĻĒāĻžāĻŦ āĻāĻŦāĻ‚ āϏ⧇āϗ⧁āϞ⧋ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āφāĻŽāϰāĻž Solve āĻ•āϰāĻŦ āϏ⧇āχ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡āĨ¤ āφāĻŽāĻžāĻĻ⧇āϰ Programming āĻļ⧇āĻ–āĻžāϰ āĻŽā§‚āϞ āωāĻĻā§āĻĻ⧇āĻļā§āϝāϟāĻž āĻšāĻšā§āϛ⧇ Computer āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻŦāĻžāĻ¸ā§āϤāĻŦ āĻœā§€āĻŦāύ⧇āϰ Problem āϗ⧁āϞ⧋āϕ⧇ Solve āĻ•āϰāĻžāĨ¤ āϤāĻžāχ āφāĻŽāϰāĻž āϝāϤ Problem Solve āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ āφāĻŽāĻžāĻĻ⧇āϰ āϚāĻŋāĻ¨ā§āϤāĻžāϧāĻžāϰāĻž āϤāϤāχ āωāĻ¨ā§āύāϤ āĻšāĻŦ⧇āĨ¤ āϤāĻžāχ āĻāχ āĻŦāĻŋāώ⧟āϟāĻž āύāĻŋā§Ÿā§‡ āĻāĻ–āĻžāύ⧇ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤

  • āĻĒāĻžā§āϚāĻĻāĻļ āĻ…āĻ§ā§āϝāĻžā§Ÿ(āĻļāĻ°ā§āϟāĻ•āĻžāĻŸā§‡ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ) ⇒ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻŽā§‚āϞāϤ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇ Shortcut āĻ Programming āύāĻž āĻļāĻŋāϖ⧇ āϕ⧇āύ Longtime Programming āĻļāĻŋāĻ–āĻžāϰ āĻŽāύ-āĻŽāĻžāύāϏāĻŋāĻ•āϤāĻž āϤ⧈āϰāĻŋ āĻ•āϤāĻž āωāϚāĻŋāϤāĨ¤ āφāĻŽāϰāĻž āφāĻŽāĻžāĻĻ⧇āϰ āφāĻļ⧇āĻĒāĻžāĻļ⧇ āĻ•ā§Ÿā§‡āĻ•āϜāύ āĻŽāĻžāύ⧁āώāϕ⧇ āĻĻ⧇āĻ–āĻŋ āĻ…āĻ˛ā§āĻĒ āĻ•āĻŋāϛ⧁ āĻļāĻŋāϖ⧇ Freelancing āĻ•āϰ⧇ āĻŽāĻžāϏ⧇ āĻ•āĻŋāϛ⧁ āϟāĻžāĻ•āĻž āĻ†ā§Ÿ āĻ•āϰāϤ⧇āϛ⧇ āĻ…āĻ˛ā§āĻĒ āĻŦ⧟āϏ⧇āĨ¤ āĻāϟāĻž āĻāĻ•āϟāĻž āϭ⧁āϞ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤ āϕ⧇āύ āĻāϟāĻž āĻāĻ•āϟāĻž āϭ⧁āϞ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āϏ⧇āϟāĻž āύāĻŋā§Ÿā§‡āĻ“ āĻāχ āĻ…āĻ§ā§āϝāĻžā§Ÿā§‡ āĻ­āĻžāϞāĻ­āĻžāĻŦ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤ āĻāĻ›āĻžā§œāĻž āĻāĻ–āĻžāύ⧇ Less Effective Instant Solution āĻāĻŦāĻ‚ Most Effective Painful Solution āύāĻžāĻŽā§‡ āĻĻ⧁āχāϟāĻŋ Learning Method āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇ āĻāĻŦāĻ‚ āĻāχ āĻĻ⧁āχāϟāĻž Method āĻāϰ āĻŽāĻ§ā§āϝ⧇ āϕ⧋āύāϟāĻž āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āĻ­āĻžāϞ āϏ⧇āϟāĻž āύāĻŋā§Ÿā§‡ āĻ­āĻžāϞ⧋āĻ­āĻžāĻŦ⧇ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤


💡 Note: Programming āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āφāĻŽāϰāĻž āĻ…āύ⧇āĻ• āĻ•āĻŋāϛ⧁āχ āϜāĻžāύāϞāĻžāĻŽāĨ¤ āĻāĻ–āύ āφāĻŽāĻžāĻĻ⧇āϰ āĻĒāĻ›āĻ¨ā§āĻĻ⧇āϰ āϝ⧇āϕ⧋āύ āĻāĻ•āϟāĻž Language(āϝ⧇āĻŽāύ C, C++, Java, JavaScript, PHP, Python āχāĻ¤ā§āϝāĻžāĻĻāĻŋ) Select āĻ•āϰ⧇ āφāĻŽāĻžāĻĻ⧇āϰ Practices āϚāĻžāϞāĻŋā§Ÿā§‡ āϝ⧇āϤ⧇ āĻšāĻŦ⧇āĨ¤

Written By: Shahidul Islam

About

This repository I will write all of basic knowledge about programming. Here I will write about the topics that are common in every programming language.

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published