Salman Ghori Developer Portfolio

High vs low level, compiled vs interpreted, static vs dynamic typing. Programming languages are classified based on abstraction from hardware, how they execute code, type checking mechanisms, and supported programming styles, helping developers choose the right tool for efficiency, readability, and performance.

Explanation in Simple Terms

Programming languages are like different tools in a toolbox—some are basic hammers (low-level), others are power tools (high-level). They vary in how close they are to the computer's 'brain' (hardware), how code runs, how strict they are with data types, and the style of writing code.
Think of it as languages for humans to talk to machines: Low-level is like speaking in binary code (hard but direct), high-level is like English (easy but needs translation). Compiled languages prepare the whole meal in advance, interpreted cook it as you eat.
Real-life example: Building a house. Low-level (assembly) is like laying bricks one by one manually—precise control but tedious. High-level (Python) is like using pre-made modules and blueprints—faster but less control over every nail. Compiled (C++) is planning and building everything upfront for speed; interpreted (Python) is adjusting as you go for flexibility.

Abstraction Level

Low-level: Closer to hardware, like machine code or Assembly (direct memory access), or C (some abstraction but still manages pointers). Pros: High performance, fine control. Cons: Error-prone, hard to read.
High-level: Abstract away hardware details, focusing on logic, like Python (easy syntax), Java (platform-independent). Pros: Faster development, readable. Cons: Slower execution, less control.

Execution Model

Compiled: Code translated to machine code before running (e.g., C++, Go). Pros: Faster runtime. Cons: Compile time errors, platform-specific.
Interpreted: Code executed line-by-line at runtime (e.g., Python, Ruby). Pros: Quick testing, portable. Cons: Slower, runtime errors.
Hybrid: Compiled to bytecode, then interpreted by a VM (e.g., Java's JVM, C#'s .NET). Balances speed and portability.

Typing

Static: Types checked at compile time (e.g., C++, Java). Pros: Catches errors early, optimizes code. Cons: More verbose.
Dynamic: Types resolved at runtime (e.g., Python, JavaScript). Pros: Flexible, less code. Cons: Runtime errors, slower.

Paradigms

Procedural: Step-by-step instructions (e.g., C).
Object-Oriented: Data as objects with methods (e.g., Java, C++).
Functional: Treats computation as functions avoiding state (e.g., Haskell, parts of JavaScript).
Declarative: Describes what to do, not how (e.g., SQL for queries).

C++ Basics in Context of Language Types

C++ is a high-level language with low-level capabilities (e.g., pointers). It's compiled (to machine code via g++), statically typed (declare int x;), and multi-paradigm (supports procedural, OO with classes, functional with lambdas).
Key concepts: Use #include for headers, int main() as entry, compile with g++ file.cpp -o output, run ./output. Static typing means you must specify types like int, string, preventing mismatches early.

Simple C++ skeleton:

#include <iostream>
using namespace std;

int main() {
    int n = 5;  // Static typing: must declare type
    cout << "Hello, C++! " << n << endl;
    return 0;
}
// Compile and run: Fast execution after compilation.

Example Problem: Hello World with Type Demonstration

Problem: Write a program that declares variables of different types and prints them, illustrating static typing in C++. Compare mentally to dynamic in Python (n=5 vs int n=5).
This is understandable for beginners: Shows basic syntax, type declaration, and why static typing catches errors early (e.g., can't assign string to int without error).

C++ Code Example:

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 25;               // Integer type
    double height = 5.9;        // Floating-point
    string name = "Alice";    // String type
    // age = "twenty-five";   // Error! Static typing prevents this
    cout << "Name: " << name << ", Age: " << age << ", Height: " << height << endl;
    return 0;
}

Output:
Name: Alice, Age: 25, Height: 5.9

Contrast: In Python (dynamic), name = 'Alice'; name = 25; // No error, type changes at runtime.

Mini Example

C++ (static, compiled): int n = 5;
Python (dynamic, interpreted): n = 5

Practice Problems

1. Write a C++ program to add two numbers. Hint: Declare int a, b; use cin for input, cout for output.
2. Experiment with types: Try assigning a float to int in C++ and see the compile error. Hint: int x = 3.14; // Truncates, but for strings it errors.
3. Research and code a simple procedural function in C++ (e.g., factorial). Hint: Use recursion or loop, declare return type.

Quiz to Test Understanding

Question 1: What type of language is C++ in terms of execution? (A) Interpreted (B) Compiled (C) Hybrid
Answer: B
Question 2: In static typing, when are type errors caught? (A) Runtime (B) Compile time (C) Never
Answer: B
Question 3: Give an example of a high-level interpreted language and why it's flexible. (Short answer)
Answer: Python; dynamic typing allows quick changes without declaring types, good for scripting.

Types of Programming Languages