Introduction to Programming - Types of Languages, Memory Management

🧠 1. Procedural Programming

🔍 Definition:

A programming paradigm based on procedures (or routines/functions). It’s like following a step-by-step recipe.

🔑 Key Features:

• Top-down execution

• Global state

• Functions act on data

• Code is structured into procedures, not objects

✅ Examples:

• C, Pascal, Bash, Early versions of Python, JavaScript

🧪 Code Example (JS-style procedural):

let total = 0;

function addToCart(price) {
  total += price;
}

addToCart(100);
addToCart(50);

console.log(total); // 150

⚠️ Downsides:

• Global state is risky

• Harder to scale

• Code reuse is limited

🧠 2. Object-Oriented Programming (OOP)

🔍 Definition:

A paradigm where everything revolves around objects — bundles of data (properties) and behaviors (methods).

🔑 Key Features:

• Classes and Objects

• Encapsulation (hide internal state)

• Inheritance

• Polymorphism

• Mutability

✅ Examples:

• Java, C++, Python (OOP style), TypeScript

🧪 Code Example:

class Cart {
  constructor() {
    this.total = 0;
  }

  add(price) {
    this.total += price;
  }

  getTotal() {
    return this.total;
  }
}

const cart = new Cart();
cart.add(100);
cart.add(50);

console.log(cart.getTotal()); // 150

✅ Benefits:

• Modular code

• Easier to manage complex systems

• Reusability via inheritance

⚠️ Downsides:

• Can become bloated

• Inheritance abuse

• Mutability can lead to bugs

🧠 3. Functional Programming (FP)

🔍 Definition:

A paradigm where functions are first-class citizens. Everything is treated as pure functions and immutable data.

🔑 Key Features:

• Pure functions (no side effects)

• Immutability

• Higher-order functions

• Declarative style

• Composability

✅ Examples:

• Haskell, Elixir, Clojure, JS (FP style)

🧪 Code Example (Same cart):

const addToCart = (cartTotal, price) => cartTotal + price;

const total1 = addToCart(0, 100);
const total2 = addToCart(total1, 50);

console.log(total2); // 150

✅ Benefits:

• Highly testable

• Easy to debug

• Parallelism-friendly (no shared state)

• Reusable, composable functions

⚠️ Downsides:

• Verbose or less intuitive at first

• Can be harder to write stateful apps

🔁 Comparison Table

🔚 Summary

• Procedural → Good for simple tasks, scripting, linear logic

• OOP → Best for large apps, user-based systems (e.g., ecommerce, games)

• Functional → Great for data processing, predictable logic, concurrency (e.g., search engines, real-time data)

---

🔷 Static Typed Languages

📌 Definition:

In statically typed languages, the type of a variable is known at compile-time. You have to define or infer the type before running the program.

🧠 Key Features:

• Type checking happens before code runs

• Errors are caught early

• Requires you to declare or infer types

✅ Examples:

TypeScript, Java, C, C++, Rust, Go, Kotlin

🔎 Example:

let age: number = 25;
age = "twenty"; // ❌ Type error during compilation

✅ Pros:

• Fewer bugs at runtime

• Better auto-completion (intellisense)

• Safer refactoring

• IDE support is 🔥

⚠️ Cons:

• More boilerplate

• Slower for quick scripts

🔶 Dynamic Typed Languages

📌 Definition:

In dynamically typed languages, types are determined at runtime. You don’t declare types; they’re inferred when the code runs.

🧠 Key Features:

• Type checking happens during execution

• More flexible

• Variables can change type

✅ Examples:

JavaScript, Python, Ruby, PHP, Lua

🔎 Example:

let age = 25;
age = "twenty"; // ✅ No error — works at runtime (might cause bugs)

✅ Pros:

• Less code to write (faster to prototype)

• Great for small scripts or quick tasks

• Very flexible

⚠️ Cons:

• Bugs can occur at runtime

• Harder to maintain large codebases

• Type-related bugs go unnoticed till crash

🆚 Summary Table

---

Memory management

• stack and heap memory

  

  ☕ Stack vs Heap

  🔷 Stack (Thread Stack)

  • Stores method calls, local variables, and reference pointers

  • Memory is automatically managed

  • Each thread has its own stack

  • Faster but smaller

✅ Example:

    void greet() {
      int x = 10;         // x stored in stack
      String name = "Abhee"; // reference in stack, actual string in heap
    }

When greet() finishes → local vars are removed from stack

🔶 Heap

• Stores objects, arrays, class instances

• Shared across all threads

• Cleaned up by Java’s Garbage Collector (GC)

• Larger but slower access

🔁 How Java Manages Memory

♻️ Garbage Collector (In Java)

• Frees heap memory for unreachable objects

• Automatically runs in background

• No manual free() like in C/C++

🔥 TL;DR

🗂 Stack = Per-thread, fast, for temporary stuff (primitives, refs)
🧺 Heap = Shared, for objects, slow but flexible, GC-managed

Thanks to kunalkushwaha for great video!