RESTful APIs, OpenAPI, and GraphQL.
asyncio
1️⃣ Core Concepts Recap (Very Brief)
pre_save, post_save, pre_delete, post_delete

connect(), disconnect(), @receiver

Synchronous vs asynchronous signals (Django 4.1+)

stack
deque
kinked list
oop
encapsu
polymorphiinheritance
abstract
metaclass
multithread
asyncio
websocket
iterator
generator
type hint
context
testing
timecomplexity
caching
decorator
exception
fileoperation
closure
regex
context manager
solid
factory design pattern
design pattern
itertool
concurrency
memory management
celery
recursive functions
comprehension
docker

  • image
  • compose
  • network
  • volume
  • swarm
  • secret
  • health check
  • jenkins ci cd sql

django
annotate
aggreagte
middleware
serializer
forms
querysets
mixins
authenticationviews
select related prefetch
python semaphone mutexes
signals
django filters
permission
custom managers
channels
django cache
wsgi asgi
class based vies
django testing
pydentic
django constraints
migrations
custom context processors
django file storage api
django subqyert expression
custom user model
queue data struc
array data stryc
single linked list
circular linked list
double linked list
binary search
hash
microservice
graph ql
graph data struc
tree data structure
sentry
oauth

Recursive Fibonacci is inefficient; use memoization or iteration for performance (memoization,iteration ) .
metadata of function
metaclass
Type class
cpu related task and gpu related task
stack
deque
kinked list
oop
encapsu
polymorphiinheritance
abstract
metaclass
multithread
asyncio
websocket
iterator
generator
type hint
context
testing
timecomplexity
caching
decorator
exception
fileoperation
closure
regex
context manager
solid
factory design pattern
design pattern
itertool
concurrency
memory management
celery
recursive functions
comprehension
docker

  • image
  • compose
  • network
  • volume
  • swarm
  • secret
  • health check
  • jenkins ci cd sql

django
annotate
aggreagte
middleware
serializer
forms
querysets
mixins
authenticationviews
select related prefetch
python semaphone mutexes
signals
django filters
permission
custom managers
channels
django cache
wsgi asgi
class based vies
django testing
pydentic
django constraints
migrations
custom context processors
django file storage api
django subqyert expression
custom user model
queue data struc
array data stryc
single linked list
circular linked list
double linked list
binary search
hash
microservice
graph ql
graph data struc
tree data structure
sentry
oauth

logging
Heap and Stack memory
Interpreted or compiled
Dynamic Typing vs. Static Typing
Search algorithms - Binary, Linear
Collection types - Array, Linked List
Hashing, Hashtable, Hashmap

📘 Code Theory Notes #1: Core Programming Concepts Every Developer Should Know
A high-level overview of fundamental concepts like memory models, typing systems, search algorithms, data structures, and hashing—essential for any serious developer.

1️⃣ Heap vs. Stack Memory
Stack: Stores function calls, local variables. Fast access, limited size.

Heap: Stores dynamic/long-lived data like objects. Slower access, but flexible size.

Stack is LIFO; heap is non-linear. Languages manage memory differently (e.g., Python uses heap for everything internally with managed stack frames).

2️⃣ Interpreted vs. Compiled Languages
Compiled: Translated to machine code before execution (e.g., C, Go).

Interpreted: Executed line-by-line by an interpreter (e.g., Python, JavaScript).

Some use a hybrid model (e.g., Python → bytecode → interpreted by virtual machine).

3️⃣ Dynamic Typing vs. Static Typing
Dynamic: Types checked at runtime (Python, JS).

Static: Types checked at compile time (Java, C++).

Static typing enables better tooling, early error detection.

Python supports optional static typing with type hints.

4️⃣ Search Algorithms
🔸 Linear Search
Time complexity: O(n)

Checks each item one-by-one

Use when data is unsorted

🔸 Binary Search
Time complexity: O(log n)

Requires sorted data

Divides list in half each step

5️⃣ Collection Types: Array vs Linked List
Feature Array Linked List
Memory Layout Contiguous Scattered (nodes)
Access Time O(1) (indexing) O(n)
Insertion/Deletion Costly (resize/shift) Cheap (relink nodes)
Use Case Fast access Dynamic insertion
6️⃣ Hashing & Hash Tables / Hashmaps
Hashing: Maps keys to indices using a hash function

Hash Table (or Hashmap): Stores key-value pairs

Time complexity:

Average: O(1) for insert/search/delete

Worst: O(n) if collisions occur

Python's dict, JavaScript's Object, and Java's HashMap are all hash-based

🧠 Next Up (Code Theory #2 ideas):
Sorting Algorithms (Quick, Merge, Bubble)

Big-O Notation & Complexity

Recursion & Iteration

Trees & Graphs

Pointers & References

Bit Manipulation Basics