Digital Padhai – Free Computer Notes, IT-ITeS & Vocational Notes for Class 9 & 10

🗣️ Computer Languages
कंप्यूटर भाषाएँ

1. परिचय

Computer Language का मतलब है कंप्यूटर से बात करने का तरीका। जैसे हम किसी दोस्त को हिंदी/अंग्रेजी में बोलते हैं, वैसे ही कंप्यूटर से बात करने के कई तरीके हैं। पर कंप्यूटर को आख़िर में 0 और 1 (बाइनरी) ही समझ में आता है। इसलिए इंसान-readable भाषाओं को कंप्यूटर-readable (binary) में बदला जाता है।

2. मुख्य प्रकार (सरल शब्दों में)

(A) मशीन भाषा (1st Generation)

कैसी दिखती है: केवल 0 और 1, जैसे 10110011.
कहां उपयोग: CPU सीधे यही समझता है।
फायदा: सबसे तेज़; ट्रांसलेट की ज़रूरत नहीं।
नुकसान: पढ़ना/लिखना मुश्किल, बहुत एरर-प्रोन, मशीन-विशिष्ट।
उदाहरण: कुछ बाइनरी कोड “रजिस्टर में मान रखें” या “जोड़ करें” जैसा निर्देश दे सकते हैं।

(B) असेम्बली भाषा (2nd Generation)

कैसी दिखती है: छोटे शब्द (mnemonics) — जैसे MOV A, B, ADD A, 1.
कैसे काम करती है: Assembler इन्हें मशीन कोड (binary) में बदल देता है।
फायदा: मशीन भाषा से आसान, तेज़।
नुकसान: मशीन पर निर्भर, पोर्टेबल नहीं।
छोटा उदाहरण (pseudo-assembly):

MOV A, 5 ; A में 5 रखो
MOV B, 3 ; B में 3 रखो
ADD A, B ; A = A + B (A अब 8 होगा)
MOV C, A ; परिणाम C में रखो

(C) उच्च-स्तरीय भाषाएँ (High-Level Languages, 3rd Generation)

कैसी दिखती हैं: इंसानी भाषा जैसी (आसान), जैसे Python, C, Java।
कैसे काम करती हैं: इन्हें Compiler या Interpreter से मशीन कोड में बदला जाता है।
फायदा: सीखने में आसान, पोर्टेबल, जल्दी विकास।
नुकसान: कभी-कभी assembly से धीमी।
उदाहरण (Python):

a = 5
b = 3
print("Sum =", a + b) # आउटपुट: Sum = 8

C में वही काम:

#include <stdio.h>
int main() {
int a = 5, b = 3;
printf("Sum = %d\n", a + b);
return 0;
}

3. Translator (किसे किसमें बदलते हैं)

Assembler: assembly → machine code.
Compiler: पूरा source → machine code (example: C compiler).
Interpreter: लाइन-दर-लाइन execute करता है (example: Python interpreter).
Mixed (जैसे Java): पहले code को bytecode में बदलते हैं, फिर JVM उसे रन/translate करता है।

Compiled program चलने का तरीका (C):

Source लिखो → 2. Compile करो → 3. Executable चलाओ।

Interpreted program (Python):

Source लिखो → Interpreter सीधे पढ़कर चलाता है।

4. 4th और 5th Generation (संक्षेप में)

4GL: ज़्यादा English जैसा, database और रिपोर्ट के लिए — जैसे SQL, MATLAB।
5GL: AI और समस्या-सुलझाने पर जोर — जैसे Prolog (logic programming)।

5. त्वरित तुलना (सरल तालिका)

विशेषता मशीन असेम्बली उच्च-स्तरीय स्तर सबसे नीचा कम उच्च (मानव-समान) उदाहरण 10110011 MOV A, B Python, C, Java ट्रांसलेटर चाहिए? नहीं Assembler Compiler/Interpreter पोर्टेबिलिटी बहुत कम कम अधिक उपयोग में आसानी बहुत मुश्किल मध्यम बहुत आसान

6. किसे पहले सीखें (सलाह)

शुरुआत के लिए: Python सबसे अच्छा — सिंपल और जल्दी समझ आता है।
गहराई सीखने के लिए: C (क्योंकि यह कंप्यूटर के पास होती चीज़ों की नज़दीक है)।
हार्डवेयर/एम्बेडेड: बाद में Assembly सीखें।
Machine code सिर्फ समझना ज़रूरी है, रोज़ लिखने की ज़रूरत नहीं।

7. अभ्यास (जवाब सहित)

print("Hi") → Python.
ADD A, B → Assembly.
अगर कोड पहले से एक .exe बनाता है और फिर चलाते हैं → यह compiled भाषा का काम है (जैसे C)।
Python में 2 और 3 जोड़कर दिखाइए:

print(2 + 3) # आउटपुट: 5

8. छोटा सारांश

मशीन = कंप्यूटर की भाषा (0/1).
असेम्बली = छोटे निर्देश, assembler से binary में बदले जाते हैं.
हाई-लेवल = पढ़ना-लिखना आसान, compiler/interpreter की मदद से चलते हैं.
शुरुआत Python से करें; फिर जरूरत के हिसाब से C/Assembly सीखें।

1. What is a Computer Language?

A computer language is a way to tell the computer what to do.
Think of it like giving instructions to a friend: you can speak in very short secret codes (machine), use short words (assembly), or speak in full sentences (high-level languages). Computers, however, only understand 0 and 1 (binary). Languages let humans write instructions that are later turned into binary.

2. Main Types (simple)

(A) Machine Language (1st Generation)

What it looks like: only 0s and 1s, e.g. 10110011.
How it works: those bits tell the CPU exactly what to do.
Good: runs fastest, no translator needed.
Bad: impossible to read, hard to write, different for each CPU (machine-dependent).
Example idea: one binary number could mean “load a number into register A”, another binary number could mean “add registers”.

(B) Assembly Language (2nd Generation)

What it looks like: short English-like words (mnemonics), e.g. MOV A, B, ADD A, 1.
How it works: an assembler converts these mnemonics into machine code (binary).
Good: easier than machine code, faster execution, you control hardware.
Bad: still tied to specific hardware, not portable.
Small example (pseudo-assembly):

MOV A, 5 ; put 5 into register A
MOV B, 3 ; put 3 into register B
ADD A, B ; A = A + B (now A = 8)
MOV C, A ; store result from A into C
This assembly will be turned into binary by assembler.

(C) High-Level Languages (3rd Generation)

What it looks like: close to English and math; easy to read. Examples: Python, C, Java, C++.
How it works: you write code, then a compiler or interpreter (or both) turn it into machine code so CPU can run it.
Good: easy to learn, portable (work across many machines), fast development.
Bad: usually slower than assembly/machine because of translation and extra layers.
Example (Python):

a = 5
b = 3
print("Sum =", a + b) # prints: Sum = 8

Same idea in C:

#include <stdio.h>
int main() {
int a = 5, b = 3;
printf("Sum = %d\n", a + b);
return 0;
}

3. Translators — How code becomes 0s and 1s

Assembler: converts assembly → machine code.
Compiler: converts whole high-level program → machine code (e.g., C compilers).
Interpreter: reads and runs code line-by-line (e.g., Python interpreter).
Hybrid (e.g., Java): source → bytecode (by compiler) → JVM executes/compiles-to-machine at runtime.

Steps for compiled language (like C):

Write source code (C file).
Compile → machine code (executable).
Run the executable on the computer.

Steps for interpreted language (like Python):

Write script (.py).
Interpreter reads and executes lines immediately.

4. 4th and 5th Generation (short)

4GL (Fourth Gen): More English-like, used for databases and reports — e.g., SQL, MATLAB (in parts), Visual Basic tools.
5GL (Fifth Gen): Focus on solving problems using constraints and AI ideas — e.g., Prolog used in AI research and logic programming.

5. Quick Comparison (easy table)

Feature Machine Assembly High-Level Level Lowest Low High (human-like) Example 10110011 MOV A, B Python, C, Java Needs translator? No Assembler Compiler / Interpreter Portability Very low Low High Ease of use Very hard Moderate Easy

6. Which to learn first (advice)

For beginners: start with Python — very easy and makes concepts clear.
To learn how computers work: learn C next.
For hardware/embedded work: learn Assembly later.
Machine code you only need to know conceptually.

7. Tiny Exercises (with answers)

Identify the language: print("Hello") → Python.
Identify the language: MOV A, B → Assembly.
If code is transformed into an executable file before running, it is likely a compiled language (e.g., C).
Convert the idea “add 2 and 3 and print” into Python:

print(2+3) # prints 5

8. Short Summary

Machine = CPU language (0/1).
Assembly = short codes, needs assembler.
High-level = easy, write quickly, needs compiler/interpreter.
Start learning with high-level (Python), move to C and assembly when you want deeper control.

Last Updated: 12-09-2025 09:59 AM | Posted by: Er. Manoj Kumar

🗣️ Computer Languagesकंप्यूटर भाषाएँ