DEV Community: Beatris Ilieva

Python Functions vs Methods: Differences, Definition, and Examples

Beatris Ilieva — Sat, 18 Oct 2025 17:54:29 +0000

Functions and methods are both callable code blocks in Python, but they operate differently. Functions are standalone blocks of code, while methods are functions bound to objects.

Definition: Functions and Methods

A function is a standalone block of reusable code that performs a specific task. Functions are called directly without reference to an object:

any([False, False, True])
len("Hello")
sum([1, 2, 3])

A method is a function that belongs to an object. Methods are called using dot notation on that specific object:

my_list = [1, 2, 3]
my_list.pop()

my_string = "hello"
my_string.upper()

The dot (.) is the indicator that we are accessing a method attached to an object.

Methods are defined within a class definition. When we create an object (an instance) from that class, the object has access to all methods defined in its class. This principle applies to both built-in types and custom classes we write. For example, the list type is defined as a class in Python's source code, and methods like .pop() and .append() are defined within that class. When we create a list object, we create an instance of the list class and access its methods. The same applies to strings, dictionaries, and all other built-in types.

Key Difference: Object Attachment

The primary distinction between functions and methods lies in their attachment to objects. Methods are defined within a class and operate on instances of that class. Functions exist independently in the namespace.

Methods Belong to Specific Data Types

Each data type in Python has methods designed specifically for that type:

String methods:

text = "hello"
text.upper()              # Returns "HELLO"
text.lower()              # Returns "hello"
text.replace("l", "x")    # Returns "hexxo"

List methods:

my_list = [1, 2, 3]
my_list.append(4)         # Adds 4 to the list
my_list.remove(2)         # Removes 2 from the list
my_list.pop()             # Removes and returns the last item

Dictionary methods:

my_dict = {"name": "Alice", "age": 30}
my_dict.keys()            # Returns the keys
my_dict.values()          # Returns the values

Functions Work Across Multiple Data Types

Functions are designed as general-purpose tools that operate on multiple types of data:

len([1, 2, 3])            # Works with lists
len("hello")              # Works with strings
len((1, 2, 3))            # Works with tuples

sum([1, 2, 3])            # Works with lists
sum((1, 2, 3))            # Works with tuples

any([False, False, True]) # Works with lists
any((False, True))        # Works with tuples

Mutating and Non-Mutating Operations

A critical distinction exists between methods and functions that modify data and those that do not.

Mutating Methods

Some methods alter the object they are called upon. The original object is modified:

my_list = [3, 1, 2]
my_list.sort()            # Modifies my_list
print(my_list)            # Output: [1, 2, 3]

my_list = [1, 2, 3]
my_list.pop()             # Removes the last item
print(my_list)            # Output: [1, 2]

Non-Mutating Methods and Functions

Other methods and most functions return a value or create a new object without modifying the original:

my_list = [1, 2, 3]
result = my_list.count(2)     # Does not modify my_list
print(my_list)                # Output: [1, 2, 3]

my_list = [3, 1, 2]
sorted_list = sorted(my_list) # Returns a new list
print(my_list)                # Output: [3, 1, 2] - unchanged
print(sorted_list)            # Output: [1, 2, 3] - new list

length = len([1, 2, 3])       # Returns a value

Key Takeaways

Functions are standalone code blocks that can be called directly without reference to an object
Methods are functions bound to specific objects and accessed using dot notation
Functions typically work across multiple data types, while methods are specific to their data type
Mutating operations modify the original object, while non-mutating operations return a new value or object without changing the original
The dot (.) notation indicates that we are calling a method on an object
When choosing between a method and a function, consider whether the operation should modify the original data

List Comprehension in Python: Syntax, Examples, and When to Use Regular For Loops

Beatris Ilieva — Sat, 18 Oct 2025 17:18:31 +0000

What is List Comprehension?

List comprehension is a concise syntax for creating a new list by applying an expression to each item in an iterable. An iterable is any object that can be looped through, such as a list, range, or string. List comprehension is faster and more Pythonic than regular for loops.

Why is List Comprehension Faster?

Python itself is written in the C programming language. The Python interpreter—the program that reads and executes our Python code—was created using C and then compiled into machine code. When we use list comprehension, we call optimized C code that has already been compiled into machine code. In contrast, a regular for loop requires Python to interpret each line and translate it to machine code one step at a time. Since the C code is already compiled and ready to execute, list comprehension runs much faster, especially with large lists.

When to Use List Comprehension

List comprehension works best in specific situations. We should use list comprehension for simple transformations such as multiplying, filtering, or converting values. It is ideal when the code fits on one line and remains easy to read. We should also use list comprehension when we need a new list as the result and when we want better performance with simple operations.

When to Use Regular For Loops

There are cases where a regular for loop is more appropriate. We should use a regular for loop for complex logic with multiple conditions or multiple operations inside the loop. We should also use a regular for loop when readability would suffer from compression. Additionally, we should use a regular for loop when we do not need to create a new list and are just processing data. Finally, we should use a regular for loop for deep nesting with more than two levels.

Examples of List Comprehension and For Loops

Example 1: Simple Transformation with List Comprehension

When we need to transform each element in a list, list comprehension provides a clean and efficient solution.

# Example 1: Simple transformation - squaring numbers
# With list comprehension (concise and fast)
numbers = [1, 2, 3, 4, 5]
squared = [n ** 2 for n in numbers]
print(squared)  # Output: [1, 4, 9, 16, 25]

# With regular for loop (more verbose)
numbers = [1, 2, 3, 4, 5]
squared = []
for n in numbers:
    squared.append(n ** 2)
print(squared)  # Output: [1, 4, 9, 16, 25]

Both approaches produce the same result. The list comprehension approach requires fewer lines of code and executes faster.

Example 2: Filtering with a Condition

List comprehension becomes even more valuable when we need to filter items based on a condition.

# Example 2: With condition - filtering even numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = [n for n in numbers if n % 2 == 0]
print(evens)  # Output: [2, 4, 6, 8]

The condition if n % 2 == 0 filters the list to include only even numbers. This single line accomplishes both filtering and list creation.

Example 3: When Not to Use List Comprehension

When logic becomes too complex, a regular for loop provides better readability.

# Example 3: When NOT to use list comprehension - complex logic
# Bad (hard to read)
result = [x * 2 if x % 2 == 0 else x * 3 if x % 3 == 0 else x for x in range(10)]

# Good (clear and readable)
result = []
for x in range(10):
    if x % 2 == 0:
        result.append(x * 2)
    elif x % 3 == 0:
        result.append(x * 3)
    else:
        result.append(x)
print(result)  # Output: [0, 3, 4, 9, 8, 15, 12, 21, 16, 27]

The second version with a regular for loop is much easier to understand. We can see exactly what conditions are checked and what actions are taken in each case.

Key Takeaways

List comprehension is a concise syntax for creating a new list by applying an expression to each item in an iterable such as a list, range, or string
List comprehension is faster and more Pythonic than regular for loops for simple transformations
Python is written in C, and list comprehension calls optimized C code that has already been compiled into machine code
Use list comprehension for simple transformations, filtering, or converting values when the code fits on one line and is easy to read
Use regular for loops for complex logic with multiple conditions, multiple operations inside the loop, or deep nesting with more than two levels
Readability is important: a slower but readable solution is often better than a faster solution that is difficult to understand
List comprehension creates a new list, while regular for loops can be used just for processing data without creating a new list
Performance benefit of list comprehension comes from its optimized implementation, but clarity should always take priority in code design

Python Lists vs Tuples: Mutable vs Immutable Data Structures and When to Use Each

Beatris Ilieva — Sat, 18 Oct 2025 16:13:35 +0000

When we work with collections of data in Python, we have several options available. Two of the most fundamental data structures we encounter are lists and tuples. While they appear similar at first glance, they have important differences that make each one suitable for different situations.

What Makes Lists and Tuples Different?

The core difference between lists and tuples relates to a concept called mutability.

A list is mutable, which means we can add, remove, or modify elements after the list has been created.

A tuple is immutable, which means once we create it, we cannot change it. The data stays exactly as we set it up. If we try to modify a tuple, Python will stop us with an error.

When Should We Use Lists?

We should use a list when we need a collection that will change over time. Lists are perfect for situations where we add, remove, or update information.

A practical example is a to-do list application. We start with some tasks, and throughout the day we add new tasks, mark some as complete (and remove them), or change task descriptions.

# List - mutable
tasks = ['write code', 'review PR']
tasks.append('deploy')  # Works fine
tasks[0] = 'refactor code'  # Can modify
print(tasks)  # ['refactor code', 'review PR', 'deploy']

When Should We Use Tuples?

We should use a tuple for data that should not change. Tuples are perfect for fixed data that represents something that should stay constant throughout our program.

Tuples have two additional advantages. First, tuples are slightly faster than lists because they are immutable. Python does not need to manage changes or reindex elements when we add or remove items. Second, tuples serve as a clear signal to other developers reading our code. When someone sees a tuple, they understand that this data is meant to stay constant and should not be modified.

A practical example is storing geographic coordinates. The latitude and longitude of a city do not change, so we can safely store them in a tuple to indicate they are fixed data.

# Tuple - immutable
coordinates = (40.7128, -74.0060)  # NYC latitude, longitude
coordinates[0] = 41.8781  # TypeError: 'tuple' object does not support item assignment

Important detail to understand: if a tuple contains mutable objects like lists inside it, those objects themselves can still be modified. The tuple stores references (addresses) to objects, not the objects themselves. The immutability of the tuple protects the references it holds—we cannot change which objects the tuple points to, add new references, or remove them. However, if an object that the tuple points to is mutable, we can modify that object directly. The tuple itself does not change—we still cannot add or remove elements from the tuple—but the mutable objects within it can be changed.

# Tuple with mutable object inside
config = ('production', ['server1', 'server2'])
config[1].append('server3')  # This works - modifying the list inside
print(config)  # ('production', ['server1', 'server2', 'server3'])

Key Takeaways

Lists are mutable: we can add, remove, and modify elements after creation
Tuples are immutable: once created, they cannot be changed (though mutable objects inside them can be)
Use lists for collections that change, such as to-do lists or shopping lists
Use tuples for fixed data that should not change, such as coordinates or configuration values
Tuples offer a slight performance benefit because Python does not need to manage changes
Tuples communicate intent: other developers understand that the data is meant to be constant

What is the Difference Between Mutable and Immutable Objects in Python? What is a Hash Table and Why Does Python Use Them?

Beatris Ilieva — Sat, 18 Oct 2025 15:20:01 +0000

Understanding Mutable and Immutable Objects

Mutable objects in Python are objects that can be changed after creation, like lists, dictionaries, and sets. Immutable objects cannot be changed after creation, like strings, integers, floats, and tuples.

The key difference is what happens when we try to modify them. With immutable objects, we do not actually change the value. A new object is created in memory instead. For example, if we define a variable x equal to 5 and then perform x = x + 1, the original integer has not been changed. A new integer object with value 6 has been created, and now x points to this new object. The garbage collector will eventually clear the old integer object because no variable refers to it anymore.

With mutable objects, when we modify the content, the object stays in the same place in memory. If we have a list and append an item to it, the same list object is being modified, not creating a new one.

# Immutable objects - creates new objects
x = 5
print(id(x))  # Output: 140234567891234 (example ID)
x = x + 1
print(id(x))  # Output: 140234567891264 (different ID - new object!)
print(x)      # Output: 6

# Mutable objects - modifies the same object
my_list = [1, 2, 3]
print(id(my_list))  # Output: 140234567892345
my_list.append(4)
print(id(my_list))  # Output: 140234567892345 (same ID - same object!)
print(my_list)      # Output: [1, 2, 3, 4]

How Function Behavior Differs with Mutable and Immutable Objects

This distinction is important because it affects how objects behave when we pass them to functions. When we pass an immutable object to a function and modify it within that function, the modifications do not affect the original variable. When we pass a mutable object to a function and modify it within that function, the modifications do affect the original object.

# Function behavior with mutable vs immutable
def modify_immutable(x):
    x = x + 1  # Creates new object
    return x

def modify_mutable(lst):
    lst.append(4)  # Modifies same object

num = 5
result = modify_immutable(num)
print(num)     # Output: 5 (unchanged)
print(result)  # Output: 6

my_list = [1, 2, 3]
modify_mutable(my_list)
print(my_list)  # Output: [1, 2, 3, 4] (changed!)

Understanding Hash Tables and Why Mutability Matters

To understand why mutability is so important in Python, we need to explore how dictionaries actually work internally. Python dictionaries use a data structure called a hash table, which relies on a fundamental principle: keys must never change.

What is a Hash Function?

A hash function is a mathematical function that takes any input—like a string or number—and converts it into a fixed-size number called a hash value. The key characteristic is that it is deterministic, meaning the same input always produces the same hash value. For example, "name" might always convert to 2834572, and "age" might convert to 9184736.

How Hash Tables Provide Fast Lookups

A hash table is a data structure that uses a hash function to map keys to specific memory locations. When we store a key like "name", Python converts it into a number that tells Python exactly where to store or find the value in memory. Instead of searching through items one by one, Python jumps directly to the right location.

# Dictionary
user_ages = {
    'Alice': 25,
    'Bob': 30,
    'Charlie': 35
}
print(user_ages['Bob'])  # Instant lookup, no matter how many users

# Behind the scenes (simplified):
# hash('Bob') -> 9184736 -> go directly to that memory location -> find 30

Python dictionaries and sets use hash tables internally. This is why dictionary lookups are so fast—O(1) on average—even with millions of items.

Why Keys Must Be Immutable

Keys must be immutable objects like strings, numbers, or tuples. If a key could change after being stored, its hash value would change too, and Python would not be able to find it anymore.

Since mutable objects can be modified after creation, their hash values are not stable. That is why we cannot use mutable objects—such as lists or dictionaries—as dictionary keys. Only immutable objects can serve as keys because their hash values remain constant throughout their lifetime.

# Why keys must be immutable
valid_key = ('latitude', 'longitude')  # Tuple - immutable, works fine
coordinates = {valid_key: 'NYC'}

invalid_key = ['latitude', 'longitude']  # List - mutable
# locations = {invalid_key: 'NYC'}  # TypeError: unhashable type: 'list'

# Valid - immutable keys
valid_dict = {
    "name": "John",      # String - immutable ✓
    42: "answer",        # Integer - immutable ✓
    (1, 2): "tuple"      # Tuple - immutable ✓
}

# Invalid - mutable keys
try:
    invalid_dict = {[1, 2]: "list"}  # List - mutable ✗
except TypeError as e:
    print(e)  # Output: unhashable type: 'list'

Key Takeaways

Mutable objects can be changed after creation. When modified, the object in memory is altered, not replaced
Immutable objects cannot be changed after creation. Attempts to modify them result in new objects being created
Function parameters behave differently based on mutability. Mutable objects passed to functions can be modified externally; immutable objects cannot
Hash functions take any input and convert it into a fixed-size number called a hash value in a deterministic way
Hash tables use hash functions to map keys to memory locations, enabling very fast O(1) lookups
Dictionary keys must be immutable because mutable objects have unstable hash values. If a key changed, its hash would change and Python could no longer find it

Is Python a Statically or Dynamically Typed Language? What's the Difference?

Beatris Ilieva — Sat, 18 Oct 2025 13:53:05 +0000

Python is a dynamically typed language. This means developers do not need to specify what type of data a variable will hold when creating it. Instead, Python determines the type during runtime as the code executes. In contrast, statically typed languages such as C require developers to declare the type of every variable upfront, before the code runs.

What is Dynamic Typing?

With dynamic typing, any value can be assigned to a variable, and Python automatically determines its type:

# Python (dynamically typed)
name = "Alice"           # This is a string
name = 42                # Now it is an integer - no problem
name = [1, 2, 3]         # Now it is a list - still acceptable
name = 3.14              # Now it is a float - no error

print(type(name))        # Output: <class 'float'>

The interpreter determines what type each variable holds as it encounters it. Developers have complete freedom to change a variable's type at any point.

What is Static Typing?

With static typing, a variable's type must be declared when it is created. Once declared, that variable can only hold values of that specific type:

// C (statically typed)
int age = 25;           // This is an integer
age = "Alice";          // COMPILATION ERROR - compilation stops here

The compiler checks all type declarations before the program runs. If there is a type mismatch, compilation fails and the program cannot start. The compilation process stops immediately at the first error, so subsequent lines are never reached or evaluated.

The Key Difference: When Are Errors Caught?

This is the fundamental distinction between the two approaches:

Statically typed languages (C):

Type errors are caught during compilation (before the program runs)
If there is a type mismatch, the code fails to compile and the program cannot run
Errors are prevented before deployment to production

Dynamically typed languages (Python):

Type errors are caught during runtime (while the program is running)
The program starts successfully, but crashes when execution reaches a line with incompatible types
Errors are only discovered when that specific code path is executed

When Does the Error Appear? A Practical Example

With a statically typed language like C, a type error prevents the entire program from running:

// C (statically typed)
int age = 25;
age = "Alice";          // COMPILATION ERROR - compilation stops here
                        // The program never runs

With Python, the program runs until the problematic line is executed:

# Python - error caught at runtime
def add_numbers(a, b):
    return a + b

result = add_numbers(5, 10)           # Executes successfully: 15
result = add_numbers(5, "hello")      # RUNTIME ERROR: TypeError

With Python, the first call executes successfully. The error only appears when the program reaches the second call with incompatible types. The program runs without issue until that specific line is executed.

Safety Trade-offs

Statically typed languages are "safer" in one important sense: Type errors can never reach production because they are caught during compilation. This is why many mission-critical systems (banks, aerospace, medical devices) use statically typed languages like C, C++, or Java.

However, dynamically typed languages offer distinct advantages:

Faster development: Code can be written more quickly without explicit type declarations
Flexibility: Generic functions can be written that work with multiple data types
Easier prototyping: Experimentation and iteration can proceed more rapidly

Dynamic typing represents a trade-off: developers gain flexibility and development speed, but sacrifice early error detection through compilation.

Python's Evolution: The Best of Both Worlds

In recent years, Python has evolved to include type hints (introduced in Python 3.5). Type hints allow developers to optionally annotate variable and function types, though Python remains dynamically typed at runtime:

# Modern Python with type hints (optional)
def add_numbers(a: int, b: int) -> int:
    return a + b

result = add_numbers(5, 10)           # Works: 15
result = add_numbers(5, "hello")      # Python executes this line without objection
                                       # but raises TypeError at runtime

Type hints are purely optional annotations; Python does not enforce them during execution. However, separate static analysis tools such as mypy can examine the code before runtime and detect type inconsistencies:

# mypy checks types before execution
$ mypy your_file.py
error: Argument 1 to "add_numbers" has incompatible type "str"; expected "int"

This approach provides the advantages of both paradigms: developers retain the flexibility and rapid development speed of dynamic typing, while gaining access to type checking before runtime through optional tooling.

Important Note: Design Choice, Not Necessity

Static versus dynamic typing is independent from compiled versus interpreted.

Python could theoretically be statically typed. For example, a statically typed version of Python could require developers to declare types upfront, and the interpreter could check those types during execution.
Similarly, C could theoretically be dynamically typed. A dynamically typed version of C could allow developers to create variables without declaring types, and the compiler could check the types of the values that variables hold during compilation instead of requiring upfront type declarations. For example, instead of requiring int age = 25;, a dynamically typed compiled language could allow age = 25; and automatically determine that the variable age currently holds an integer value.

The actual choices made by language creators reflect different priorities:

Python's designers chose dynamic typing to prioritize ease of use and rapid development
C's designers chose static typing to prioritize performance and early error detection

Each choice reflects different priorities and intended use cases.

Key Takeaways

Python is dynamically typed: Types are checked during runtime, not at compile-time
In dynamically typed languages type declarations are not required: although type hints can be optionally added
In dynamically typed languages type errors appear during execution: when incompatible operations are attempted
Static typing catches errors earlier: but requires explicit type declarations upfront
Python's type hints with mypy provide type checking without sacrificing dynamic flexibility

Is Python an interpreted or compiled language? How does Python code execution work?

Beatris Ilieva — Sat, 18 Oct 2025 13:50:34 +0000

When learning to program, one of the fundamental concepts developers encounter is the distinction between compiled and interpreted languages. Languages like C are often described as "compiled," while Python is called "interpreted." But what does this distinction actually mean? The answer lies in understanding how code is transformed from human-readable instructions into machine code that the CPU (Central Processing Unit) can execute.

Understanding the CPU

The CPU is the brain of the computer. It does all the work—it reads instructions, does calculations, saves information, and makes decisions. The most important thing to know is that the CPU only understands machine code. The CPU cannot understand the code we write in Python or C.

This is the main reason we need compilers and interpreters. They translate our code into machine code so the CPU can understand and follow our instructions.

Another important fact: different computers have different CPUs that speak different "languages." For example, a program written for an Apple MacBook will not work on a Windows laptop without changes. Each computer needs its own special machine code.

What is Compilation?

Compilation is the process of translating an entire program from source code into machine code before execution begins.

When a developer writes code in a compiled language like C, the compiler reads all the source code and translates it completely into machine code. This machine code is specific to the target CPU. The resulting program can then run and the CPU executes it directly.

The Compilation Process in C

Imagine a developer writes a program in C. The compiler reads the entire program and translates it all into machine code before anything runs:

Source Code (original program)
    ↓ [Compiler translates everything]
Machine Code (executable program)
    ↓ [CPU executes it]
Output

This happens only once. After the compilation is done, the program is ready to use. Every time someone runs the program, the CPU executes the machine code directly—no more translation is needed.

Key Characteristics of Compilation

Everything is translated first: Before the program runs, the entire code is changed into machine code
Errors are found before running: If there are problems with the code, the compiler finds them and stops. The program will not run until the errors are fixed
Machine code is made for one type of CPU: If we need the program to work on a different CPU type, the code must be compiled again for that CPU
Programs run very fast: Once the program is translated, the CPU runs it directly without anything slowing it down

What is Interpretation?

An interpreter is a program that reads our code and follows the instructions one line at a time. Unlike a compiler, an interpreter does not translate everything first. Instead, it reads each line, understands it, and tells the CPU what to do—all while the program is running.

The Interpretation Process in Python

A developer writes a Python program:

# hello.py
print("Hello, World!")

Then runs it:

python hello.py

Here is what happens:

Source Code (hello.py)
    ↓ [Python interpreter reads each line]
    ↓ [Interpreter tells CPU what to do]
Output: "Hello, World!"

The interpreter reads the code line by line while the program is running. It translates each line and immediately tells the CPU what to do.

Key Characteristics of Interpretation

Line by line: The code is read and executed one line at a time while the program runs
Errors appear during running: If there is a problem in the code, you only find out when the program reaches that line
Works on any computer: The same code can run on Mac, Windows, etc. without any changes
Slower execution: The interpreter is working while the program runs, so it is slower than compiled programs

The Development Experience: A Practical Comparison

The differences between compiled and interpreted languages become very apparent during development:

Compiled Language Workflow (C)

1. Write code in C
2. Translate it all to machine code using compiler
3. If errors exist → Fix code → Go back to step 2
4. If no errors → Run the program
5. Test and look at results

The problem: Every time you change the code, you must translate it all again. For very large programs, this can take a long time.

Interpreted Language Workflow (Python)

1. Write code in Python
2. Run interpreter: python program.py
3. Observe output immediately
4. If errors exist → Fix code → Go to step 2
5. Code runs immediately; no waiting for compilation

Advantage: Developers see results immediately, enabling rapid iteration and experimentation.

Python's Hybrid Approach: The Best of Both Worlds

Python is neither purely compiled nor purely interpreted. Instead, it uses a hybrid approach that combines benefits of both.

Understanding Bits and Bytes

Before exploring how code is translated, it is important to understand the basic units of computer information.

A bit is the smallest unit of information a computer can understand. It is either 0 or 1 (on or off).

A byte is a group of 8 bits. It is the smallest unit of information that has its own address. This means the computer can locate and save one byte at a specific place in memory. Bytes are used to store all data—numbers, letters, colors, sounds—everything in your computer is made of bytes.

Examples:

The letter "A" = 1 byte = 8 bits = 01000001
The number "5" = 1 byte = 8 bits = 00000101

All of these bits and bytes form machine code—the special language that computers understand, made only of 0s and 1s, like 10110000.

How Python Actually Works

Source Code (.py file)
    ↓ [Python compiler - first time only]
Bytecode (.pyc file - cached in __pycache__)
    ↓ [Python interpreter - every execution]
Machine Code (executed by CPU)

Step 1: Compilation to Bytecode

When a Python module is imported for the first time, Python compiles the source code to bytecode—an intermediate format that is simpler than source code but not executable by the CPU.

# user.py
class User:
    def __init__(self, username: str):
        self.username = username

When this module is imported, Python creates:

user.py → compiled to → user.cpython-313.pyc (cached bytecode)

Step 2: Interpretation of Bytecode

Every time the Python program runs, the Python interpreter reads the cached bytecode and translates it to machine code instructions that the CPU can execute.

python program.py (first run)
    → Uses cached .pyc file
    → Interpreter translates bytecode to machine code
    → CPU executes

python program.py (second run)
    → Uses same cached .pyc file
    → Interpreter translates bytecode to machine code again
    → CPU executes

Important note: The __pycache__ directory and .pyc files are created only for imported modules, not for the main script being executed. Python automatically updates these cached bytecode files whenever the source code changes.

Why This Hybrid Approach?

Portability: Bytecode is universal across platforms. The same .pyc file works on Mac, Windows, etc. Different Python interpreters on each platform translate that bytecode to their platform's native machine code.

user.cpython-313.pyc (universal bytecode)
    ↓
    ├─→ [Interpreter on Mac] → machine code → CPU executes
    ├─→ [Interpreter on Windows] → machine code → CPU executes

Development speed: Developers write Python code and see results immediately.

Caching performance: By caching bytecode, Python avoids recompiling the same code repeatedly, providing a performance boost on subsequent runs.

Key Takeaways

Compilation translates an entire program to machine code before execution; execution is fast but development iteration is slow
Interpretation translates and executes code during runtime; development is fast but execution is slower
Machine code is CPU-specific; different computers require different machine code
Bytecode is a universal intermediate format that can be translated to different machine code for different computers
Python uses a hybrid approach: code is compiled to bytecode once (and cached), then interpreted to machine code each time it runs
The __pycache__ directory contains cached bytecode for imported modules, automatically updated when source code changes
Understanding these concepts helps explain why Python is faster to develop with but slower to execute than C

Understanding First-Class Functions and Higher-Order Functions in JavaScript

Beatris Ilieva — Tue, 18 Mar 2025 13:56:48 +0000

📋 Table of Contents

What is a First-Class Function in JavaScript
What is a Higher-Order Function in JavaScript
Built-in Higher-Order Functions in JavaScript
What is a Pure Function?
Key Takeaways

What is a First-Class Function in JavaScript

JavaScript treats functions as first-class citizens, meaning functions can be used just like any other value. This characteristic allows functions to:

Be assigned to variables.
Be passed as arguments to other functions.
Be returned as results from other functions.

Passing a Function as an Argument

One of the most common applications of first-class functions is passing them as arguments to other functions:

const sum = (a, b) => a + b;

function execute(operation, operandA, operandB) {
    return operation(operandA, operandB);
}

const result = execute(sum, 1, 2);
console.log(result); // 3

Here, sum is a function that gets passed into execute as an argument, demonstrating the first-class function concept.

What is a Higher-Order Function in JavaScript

A higher-order function is a function that either:

Accepts another function as an argument, or
Returns a function as a result, or
Does both.

The execute function in the previous example is a higher-order function because it takes another function (operation) as an argument.

Let's now create an example where a function returns another function:

function greetingBuilder(salutation, title) {
    return function (name) {
        return `${salutation}, ${title} ${name}!`;
    };
}

const greetAWoman = greetingBuilder('Hello', 'Mrs.');
const greetAMan = greetingBuilder('Hello', 'Mr.');

console.log(greetAWoman('Sarah')); // Hello, Mrs. Sarah!
console.log(greetAMan('John')); // Hello, Mr. John!

Why Use Higher-Order Functions

Higher-order functions allow code reuse and abstraction. In the example above, greetingBuilder is a reusable function that generates different greeting functions based on the given parameters.

Built-in Higher-Order Functions in JavaScript

JavaScript provides built-in higher-order functions such as map() and reduce(). These methods require a function as an argument to determine their behavior:

const arr = [1, 2, 3, 4, 5];

const mappedResult = arr.map(element => element * 2);
console.log(mappedResult); // [2, 4, 6, 8, 10]

const reducedResult = arr.reduce((acc, curr) => acc + curr);
console.log(reducedResult); // 15

Here, map() and reduce() accept functions to perform operations on array elements, making them excellent examples of built-in higher-order functions.

What is a Pure Function

A pure function is a function that always returns the same output for the same input and has no side effects.

Example of an Impure Function

The function below is impure because its result depends on an external factor (Math.random()), making it unpredictable:

const arr = [1, 2, 3, 4, 5];

function notPure(input) {
    let sum = 0;

    input.forEach(number => {
        const randomNum = Math.random();

        if (randomNum > 0.5) {
            sum += number;
        }
    });

    return sum;
}

Example of a Pure Function

In contrast, this function is pure because it always returns the same output for the same input:

const arr = [1, 2, 3, 4, 5];

function pure(input) {
    let sum = 0;

    input.forEach(number => {
        sum += number;
    });

    return sum;
}

console.log(pure(arr)); // 15

Key Takeaways

First-Class Functions: Functions in JavaScript can be assigned to variables, passed as arguments, and returned from other functions.
Higher-Order Functions: Functions that either accept other functions as arguments or return functions.
Built-in Higher-Order Functions: Methods like map() and reduce() allow efficient data manipulation.
Pure Functions: Functions that always return the same result for the same input and do not produce side effects.

Thank you for reading!

I would be grateful to understand your opinion.

How the Call Stack, Heap, and Closures Work in JavaScript

Beatris Ilieva — Tue, 18 Mar 2025 13:55:32 +0000

📋 Table of Contents

Introduction
The Call Stack and Execution Contexts
The Stack and the Heap
Closure vs No Closure
Understanding Closures and Garbage Collection
Key Takeaways

Introduction

Before you continue, you might want to read Understanding Execution Context and the This Keyword in JavaScript.

In JavaScript, the call stack is a critical concept in how functions are executed. It stores the execution contexts of functions as they are called, and the way JavaScript manages memory through the stack and heap directly influences the behavior of variables and closures. Let’s break down the core concepts step by step.

The Call Stack and Execution Contexts

The call stack is a data structure that stores execution contexts in a last-in, first-out (LIFO) manner. The call stack is where the JavaScript engine keeps track of function calls. When one function calls another, the execution context of the calling function is pushed onto the call stack. A function's execution context stays on the call stack until the function finishes executing and returns, at which point its context is popped off the stack.

For example:

function first() {
    second();
}

function second() {
    console.log('Hello from second!');
}

first();

Here’s how the call stack would look:

first() is called, so its execution context is pushed onto the stack.
second() is called inside first(), so the execution context of second() is pushed onto the stack.
After second() finishes executing, its context is popped off the stack, and the flow returns to first().

The Stack and the Heap

JavaScript uses two types of memory for storing values: the stack and the heap.

The stack is a small, fast memory area where primitive data types (such as numbers, strings, and booleans) are stored. Variables containing primitive values are pushed and popped from the stack quickly.

The heap is a much larger memory area used for storing reference types (such as objects, arrays, and functions). When a reference type is created, a pointer to its memory location is stored on the stack, while the actual data resides in the heap. If an object is nested within another object, the reference to the nested object points to another location in the heap.

Primitive vs Reference Types

Primitive data types (e.g., numbers, strings, booleans) have their values stored directly in the stack.

Example:

let age = 30; // Stored in the Stack
let name = 'Alice'; // Stored in the Stack

Reference data types (e.g., objects, arrays, and functions) have their memory locations (pointers) stored in the stack, while the actual data is stored in the heap. If an object is nested within another object, the reference to the nested object points to another location in the heap.

Example:

const person = {
    name: 'John',
    age: 25
};
// The object itself is stored in the Heap
// The variable 'person' in the Stack holds a reference to it

Closures also reside in the Heap because they retain access to outer scope variables even after their execution context has been removed.

Closure vs No Closure

Now, let's compare two similar functions to see the difference between closures and functions that don't form closures.

Example 1:

function outer() {
    let number = 1;

    return function inner() {
        console.log(number++);
    };
}

const innerFunction = outer();
innerFunction(); // 1
innerFunction(); // 2
innerFunction(); // 3

Example 2:

function outer() {
    let number = 1;

    function inner() {
        console.log(number++);
    }

    inner();
}

outer(); // 1
outer(); // 1
outer(); // 1

Explanation of Differences:

In Example 1, the inner function is returned by the outer function, and keeps a reference to number even after outer has finished executing. This forms a closure. As a result, each call to innerFunction() increments the value of number from where it left off.

In Example 2, the inner function is called immediately within the outer2 function. Once inner is called, the value of number is logged and inner finishes execution. Since no closure is formed, each time outer2 is called, the value of number starts at 1 again.

Why This Happens:

Closures (Example 1) allow a function to retain access to variables in its outer scope, even after the outer function has finished execution. The variable number is part of the closure, and its value persists across calls to innerFunction.

Non-closures (Example 2) do not retain the state of variables between function calls. The number variable is created and used within the scope of outer2, and since the function is called anew each time, the number variable is reset to 1.

Understanding Closures and Garbage Collection

In the previous examples, we saw that the closure holds onto the variables of the outer function, even after the outer function’s execution context has been removed from the stack. This happens because the closure keeps a reference to the variable, preventing it from being garbage collected. The garbage collector will only remove variables that are no longer reachable, and in the case of closures, the variable remains accessible.

For example, in the following case:

function outer() {
    let number = 1;

    return function inner() {
        console.log(number++);
    };
}

const innerFunction = outer();
innerFunction(); // 1
innerFunction(); // 2
innerFunction(); // 3

The outer function creates a local variable number and returns the inner function.
The inner function forms a closure over number—it retains access to the number variable even after outer has returned.
The execution context of outer is removed from the call stack, but the variable number stays in the heap as part of the closure.
Every time innerFunction() is called, it accesses the number variable from the closure, incrementing its value.

Although the execution context of outer is removed from the call stack after the inner function is returned, the variable number remains in memory due to the closure created by inner.

Key Takeaways

The call stack manages function execution contexts.
The Stack Memory stores primitive values and references to objects.
The Heap Memory stores actual objects, arrays, functions, and closures.
Closures retain variables from their outer function in the Heap to ensure accessibility.

Thank you for reading!

I would be grateful to understand your opinion.

Understanding Execution Context and the `This` Keyword in JavaScript

Beatris Ilieva — Tue, 18 Mar 2025 13:43:32 +0000

📋 Table of Contents

Introduction
Execution Context
Function Context
This Keyword
Key Takeaways

Introduction

Two important concepts in JavaScript that often confuse developers, especially those new to the language, are Execution Context and the this keyword. In this article, we will break these concepts down, explain how the function context is set, and explore how this behaves in different situations.

Execution Context

Every function in JavaScript is executed in its own execution context. The execution context is essentially the environment in which the function is executed. It holds the scope of variables, the this binding, and the chain of scopes for a function.

What is inside the Execution Context?

The Variables:

The execution context contains all the variables declared within the function. These variables are created when the function is called and cease to exist once the function finishes executing. This is because they are tied to the execution context, and when the function returns, the execution context is removed from the call stack, taking its variables with it.
This Binding:

The execution context also defines what this refers to. The value of this is determined based on how a function is invoked. It refers to the Function Context.
Scope Chaining:

In JavaScript, inner functions can access variables from their outer scopes. The execution context helps set up the scope chain, ensuring that when a variable is accessed in an inner function, the JavaScript engine knows where to look for it.

Function Context

The function context refers to the object that is being referenced by the this keyword. In other words, this refers to the Function Context, which is the object that the function is currently operating within.

Key Points

The execution context is where the function’s variables, scope, and this binding are defined.
The function context is where the this keyword refers to an object, and it is set depending on how the function is invoked.

`This` Keyword

The this keyword refers to the object that is executing the current function. The context of this depends on how the function is called, not where it is defined. Let's take a closer look at different ways in which a function can be invoked and how the this context changes in each case.

Ways to Invoke a Function

As a global function
As an object method
As a callback function passed to an event listener
Using call(), apply(), and bind() methods

Let's examine each case in detail.

Invoke as Global Function

When a function is invoked in the global scope, the this keyword refers to the global object (in Node.js, it refers to the module).

Example:

function sayHi() {
    console.log(`Hi, my name is ${this.name}!`);
}

// Invoke as global function
sayHi(); // Hi, my name is undefined!

In this example, this.name returns undefined because the global context does not have a name property.

Invoke as a Method

When a function is invoked as a method of an object, the this keyword refers to that object.

Example:

function sayHi() {
    console.log(`Hi, my name is ${this.name}!`);
}

const person = {
    name: 'John',
    sayHi
};

person.sayHi(); // Hi, my name is John!

Here, this refers to the person object, so this.name is John.

However, if the function is invoked as an inner function of a method, the context may change.

function sayHi() {
    console.log(`Hi, my name is ${this.name}!`);
}

const person = {
    name: 'John',
    greet() {
        sayHi();
    }
};

person.greet(); // Hi, my name is undefined!

In this case, this.name returns undefined because sayHi is invoked in the global context, not as part of the person object.

Invoke as a Callback

When a function is passed as a callback to an event listener, the this context refers to the DOM element that the event is attached to.

Example:

<input type="button" value="Click" name="Button" />

<script>
    const inputElement = document.querySelector('input');

    inputElement.addEventListener('click', sayHi);

    function sayHi() {
        console.log(`Hi, my name is ${this.name}!`); // Hi, my name is Button!
        console.log(this);
    }
</script>

Here, this refers to the input element, and this.name is Button.

Arrow Function Context

Arrow functions behave differently than regular functions. They do not have their own this context. Instead, they inherit the this context from their parent function.

Example:

const sayHiOuterArrow = () => {
    console.log(`Hi, my name is ${this.name}!`);
};

const person = {
    name: 'John',
    greet() {
        function sayHi() {
            console.log(`Hi, my name is ${this.name}!`);
        }

        const sayHiArrow = () => {
            console.log(`Hi, my name is ${this.name}!`);
        };

        console.log(this.name); // John

        sayHi(); // Hi, my name is undefined!
        sayHiArrow(); // Hi, my name is John!
    }
};

person.greet();

In this case, sayHiArrow() correctly logs John because it inherits this from the greet method, while sayHi() does not.

Explicit Binding

JavaScript provides three methods for explicitly binding the this context: call(), apply(), and bind().

Call

The call() method invokes a function with a specified this context.

Example:

function sayHi() {
    console.log(`Hi, my name is ${this.name}!`);
}

const newContext = {
    name: 'John'
};

sayHi.call(newContext); // Hi, my name is John!

Apply

The apply() method is similar to call(), but instead of passing arguments individually, we pass them as an array.

Example:

function sayHi(salutation, name) {
    console.log(`Hi ${salutation} ${name}, my name is ${this.name}!`);
}

const newContext = {
    name: 'John'
};

sayHi.apply(newContext, ['dear', 'Michel']); // Hi dear Michel, my name is John!

Bind

The bind() method returns a new function with the this context set, which can be invoked later.

Example:

function sayHi(salutation, name) {
    console.log(`Hi ${salutation} ${name}, my name is ${this.name}!`);
}

const newContext = {
    name: 'John'
};

const modifiedSayHi = sayHi.bind(newContext);
modifiedSayHi('dear', 'Michel'); // Hi dear Michel, my name is John!

Key Takeaways

Execution Context: Each function runs in its own execution context, which includes variables, this binding, and scope chaining.
Function Context: The object that this refers to depends on how the function is invoked. this Keyword: 1. Always refers to an object. 2. Its value is determined at the time of function invocation.
Ways to Invoke a Function:
1. Global Function: this refers to the global object (window in browsers, global in Node.js).
2. Method Call: this refers to the object the method belongs to.
3. Callback Function (Event Listener): this refers to the element that triggered the event.
4. Arrow Function: Inherits this from its enclosing scope.
5. Explicit Binding: call(): Calls a function with a specified this value. apply(): Works like call(), but accepts an array of arguments. bind(): Returns a new function with this bound, which can be called later.

Thank you for reading!

I would be grateful to understand your opinion.

Asynchronous Programming in JavaScript: A Beginner’s Guide

Beatris Ilieva — Mon, 17 Mar 2025 16:10:01 +0000

📋 Table of Contents

Introduction
Multi-Threaded vs Single-Threaded in JavaScript
AJAX
Synchronous vs Asynchronous Programming
Fetch API
Summary

Abbreviations

JS: JavaScript
AJAX: Asynchronous JavaScript and XML

Introduction

Before you continue, you might want to read A Beginner’s Guide to HTTP and REST Services.

A request to the backend is an asynchronous operation. When we send a request to the backend to fetch content from a database, we have no control over how long it will take to process. The backend first receives the request, processes it, queries the database, processes the retrieved data, and only then returns a response. The total time required depends on various factors, such as server load, network congestion, and internet speed.

In some cases, the process may take a few seconds, which is a long time in the context of software applications. If users are forced to wait without being able to interact with the application, it results in a poor user experience—such as a frozen screen until the response arrives.

This is where asynchronous programming comes into play. It allows the code to continue executing normally while the request is processed in the background. Once the request is complete, the result is displayed without interrupting the user experience.

Multi-Threaded vs Single-Threaded in JavaScript

Before you continue, you might want to read Understanding the Event Loop: The Heart of Asynchronous JavaScript.

In general, multi-threaded means that multiple processes can run simultaneously, with two programs executing in parallel, independently of each other. On the other hand, synchronous code runs sequentially, within a single process.

JS, however, is a single-threaded language, meaning it executes code in one process at a time. But here’s the interesting part: despite being single-threaded, JS allows asynchronous operations. This means that even though JS processes tasks one at a time, it can still handle tasks like network requests, allowing other code to run in the meantime.

So, how can JS be asynchronous if it’s not multi-threaded? The key lies in the event loop mechanism, which lets JS offload tasks to be executed later, without blocking the main thread. This gives the illusion of parallel execution while maintaining a single thread of execution.

AJAX

AJAX is a technique for fetching data from a remote server in the background without disrupting the user experience. It allows web applications to send and receive data asynchronously, meaning the page doesn’t need to reload to update its content.

With AJAX, JS instructs the browser to send requests to the server, retrieve data, and dynamically update the webpage without requiring a full refresh. This approach enhances user experience by enabling smooth interactions, such as loading new content, submitting forms, or fetching search results without interruptions.

AJAX Workflow

Initial Page Load

When a user visits a webpage, the browser makes an HTTP request to the server to fetch the necessary resources, such as HTML, CSS, JS, images, and fonts. This initial page load involves multiple requests, not just one, as each resource must be fetched separately. Once all these resources are loaded, the web application becomes interactive and starts running in the browser. At this point, the client-side JS is ready to handle dynamic content and further user interactions.

User Interaction

Once the page is loaded, JS is responsible for making the application interactive. When a user triggers an event—such as clicking a button or submitting a form—the application does not reload the entire page. Instead, an AJAX request is initiated to communicate with the server in the background.

Request to the RESTful Server

The AJAX request is sent to the server, which processes the request and sends back a response. Most of the time, the server responds with data in a lightweight format like JSON.

Processing and Rendering

After the data is received, the client processes the response and dynamically updates the page as needed. This could involve rendering new content, updating UI elements, or displaying messages to the user. The processing of data happens asynchronously, ensuring the application remains responsive while handling the background request.

Synchronous vs Asynchronous Programming

Synchronous Programming

Synchronous programming means that the code is executed line by line, one command after the other. Each operation must complete before the next one can begin. This results in a predictable flow of execution, but it can be inefficient if some operations take a long time to complete (e.g., network requests). Here’s an example of synchronous code:

console.log(1);
console.log(2);
console.log(3);

In this case, the numbers will be printed one after another in the exact order.

Asynchronous Programming

Asynchronous programming allows certain tasks, like fetching data from a server, to run in the background while other code continues to execute. This prevents blocking the entire program, keeping the application responsive. In JS, asynchronous code can execute concurrently, meaning the total execution time depends on the longest task, and the program remains functional while waiting for the result.

Approaches to asynchronous programming

Callbacks

Let's look at an example using the built-in setTimeout() function. This function accepts two arguments: a callback (a function to execute) and a delay (the time after which the callback will be executed). With setTimeout(), the callback is executed asynchronously after the specified time.

console.log('Before');
setTimeout(function () {
    console.log('Meanwhile');
}, 2000);
console.log('After');

In a synchronous context, we'd expect to see the following:

'Before'
Wait for 2 seconds
'Meanwhile'
'After'

However, the actual output is:

Before;
After;
Meanwhile;

Explanation:

console.log('Before') is executed immediately.
setTimeout() delegates the callback function to be executed later (after 2 seconds).
console.log('After') is executed immediately after setTimeout() is called, even before the callback runs.

Now, what if we set the callback to execute after 0 seconds?

console.log('Before');
setTimeout(function () {
    console.log('Meanwhile');
}, 0);
console.log('After');

The output remains the same:

Before;
After;
Meanwhile;

This happens because synchronous actions always execute before asynchronous ones, even if the delay is set to 0. The callback is still placed in the event queue and will only be executed after the current stack is cleared.

Promises

A Promise is a JS object that represents a value that may be available in the future, or never. It is commonly used to handle asynchronous operations, such as fetching data from a server.

Promise States

A Promise can be in one of three states:

Pending → The operation is still in progress.
Fulfilled → The operation was successful, and we have the result.
Rejected → An error occurred, and the operation failed.

Creating a Promise

To create a Promise, we use the Promise class and provide an executor function. This function takes two parameters:

resolve(value) → Called when the operation succeeds.
reject(reason) → Called when the operation fails.

Here’s an example simulating a rocket launch mission 🚀:

function launchRocket() {
    return new Promise((resolve, reject) => {
        console.log('🚀 Initiating launch sequence...');

        setTimeout(() => {
            if (Math.random() < 0.5) {
                resolve(
                    '🎉 The rocket has successfully landed on Mars! 🏆'
                );
            } else {
                reject(
                    '🔥 Mission failed! The rocket exploded in space. 💥'
                );
            }
        }, 3000); // Simulating a 3-second delay
    });
}

Using a Promise

Once we have a Promise, we handle its outcome using:

.then(successCallback) → Executes when the Promise is fulfilled.
.catch(errorCallback) → Executes when the Promise is rejected.

const mission = launchRocket();

mission
    .then(result => {
        console.log(result); // Runs if the mission succeeds
    })
    .catch(error => {
        console.log(error); // Runs if the mission fails
    });

console.log('📡 Monitoring rocket status...'); // This runs immediately (non-blocking)

If success:

🚀 Initiating launch sequence...
📡 Monitoring rocket status...
(Wait 3 seconds...)
🎉 The rocket has successfully landed on Mars! 🏆

Otherwise:

🚀 Initiating launch sequence...
📡 Monitoring rocket status...
(Wait 3 seconds...)
🔥 Mission failed! The rocket exploded in space. 💥

Async/Await

Async/Await is a more readable way to work with promises in JavaScript. It provides a cleaner and more intuitive syntax compared to using .then() and .catch().

async functions always return a promise, even if you don't explicitly return one. If a value is returned, it's automatically wrapped in a resolved promise.
The await keyword can only be used inside async functions. It pauses the execution of the function at that point until the promise resolves or rejects.
While the code inside an async function looks synchronous, it is non-blocking and will not freeze the rest of the program. It still allows asynchronous operations to run, but the function execution itself pauses at each await until the promise is settled.

function launchRocket() {
    return new Promise((resolve, reject) => {
        console.log('🚀 Initiating launch sequence...');

        setTimeout(() => {
            if (Math.random() < 0.5) {
                resolve(
                    '🎉 The rocket has successfully landed on Mars! 🏆'
                );
            } else {
                reject(
                    '🔥 Mission failed! The rocket exploded in space. 💥'
                );
            }
        }, 3000);
    });
}

async function startMission() {
    try {
        const result = await launchRocket();
        console.log(result);
    } catch (err) {
        console.log(err);
    }
}

startMission();

Key Points

async keyword: Declares a function as asynchronous, which will always return a promise.
await keyword: Pauses the execution of the function until the promise resolves or rejects.
Synchronous-looking code: Inside an async function, code looks like it's executing synchronously, but it still works asynchronously behind the scenes.
Error handling: Use try/catch to handle errors with async/await, just like synchronous code.

Fetch API

The Fetch API is a way to make HTTP requests in JavaScript, and it’s built on Promises.

Promise: fetch() returns a promise that resolves to the response of the request.
Response: The response from a fetch() request is a Stream, which means it’s processed asynchronously.
Default Method: By default, fetch() uses the GET method, so we don’t need to specify it unless we're making a request with another HTTP method (like POST or PUT).
Options Parameter: When sending a request with a body (e.g., POST or PUT), we need to pass an options object where we specify the method, headers, and body.
Body and Headers: When sending data in the body of a request, it should be a JSON string. We must also include headers to tell the server that we're sending JSON data (e.g., 'Content-Type': 'application/json').

GET Request

A GET request is used to retrieve data from a server.

fetch('https://jsonplaceholder.typicode.com/posts/1') // returns a promise
    .then(response => response.json()) // returns a promise
    .then(result => console.log(result))
    .catch(error => console.log(error.message)); // handle errors

Result:

{
  userId: 1,
  id: 1,
  title: 'sunt aut facere repellat provident occaecati excepturi optio reprehenderit',
  body: 'quia et suscipit\n' +
    'suscipit recusandae consequuntur expedita et cum\n' +
    'reprehenderit molestiae ut ut quas totam\n' +
    'nostrum rerum est autem sunt rem eveniet architecto'
}

POST REQUEST

A POST request is used to send data to the server, such as creating a new resource.

fetch('https://jsonplaceholder.typicode.com/posts', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        title: 'My First Post',
        body: 'This is a test post.',
        userId: 1
    })
})
    .then(response => response.json())
    .then(result => console.log(result))
    .catch(error => console.log('Error:', error));

Result:

{
  title: 'My First Post',
  body: 'This is a test post.',
  userId: 1,
  id: 101
}

PUT Request

A PUT request is used to update an existing resource on the server.

fetch('https://jsonplaceholder.typicode.com/posts/1', {
    method: 'PUT',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        id: 1,
        title: 'Updated title',
        body: 'Updated content',
        userId: 1
    })
})
    .then(response => response.json())
    .then(result => console.log(result))
    .catch(error => console.log('Error:', error));

Result

{ id: 1, title: 'Updated title', body: 'Updated content', userId: 1 }

DELETE Request

A DELETE request is used to delete a resource from the server.

fetch('https://jsonplaceholder.typicode.com/posts/1', {
    method: 'DELETE'
})
    .then(response => console.log('Deleted:', response.ok))
    .catch(error => console.error('Error:', error));

Result:

Deleted: true;

By using the Fetch API, we can perform asynchronous operations like retrieving and sending data to a server without blocking the rest of our code.

Summary

In this guide, we've explored the key concepts and techniques involved in asynchronous programming in JS.

Asynchronous Programming allows us to perform tasks like network requests without blocking the rest of our code, which improves user experience by keeping applications responsive.
JS is single-threaded, yet through asynchronous operations and the event loop, it can handle tasks concurrently.
AJAX is a set of techniques that allows JS to instruct the browser to fetch data from the server in the background and update the UI dynamically, without reloading the page, ensuring smooth interactions.
Synchronous vs Asynchronous programming contrasts how tasks are executed: synchronously (sequentially) and asynchronously (non-blocking).
Promises are a foundational concept in handling asynchronous operations, offering methods like .then() and .catch() to manage success and error cases.
Async/Await provides a cleaner and more intuitive syntax for working with Promises, making asynchronous code look and behave more synchronously.
Fetch API allows us to make HTTP requests, such as GET, POST, PUT, and DELETE, leveraging Promises to handle responses asynchronously.

Thank you for reading!

I would be grateful to understand your opinion.

Understanding the Event Loop: The Heart of Asynchronous JavaScript

Beatris Ilieva — Mon, 17 Mar 2025 15:52:19 +0000

📋 Table of Contents

Introduction
Step-by-Step Explanation of the JavaScript Event Loop Execution
Data Structures: Call Stack and Event Queue
Key Takeaways

🔗 Live Demo: Click Here

🎥 Demo Video:

Introduction

JavaScript is a single-threaded language, meaning it can only execute one task at a time on the main thread. However, this doesn't mean JavaScript can't handle multiple tasks simultaneously. The key to understanding this behavior lies in the Event Loop.

The Event Loop allows JavaScript to perform asynchronous operations, such as waiting for a network request or timer, without blocking the main thread. By offloading tasks to be executed later, JavaScript creates the illusion of parallel execution while still maintaining its single-threaded nature.

In this article, we’ll take a closer look at how the Event Loop manages both synchronous and asynchronous tasks. We’ll walk through how JavaScript handles operations, manages callbacks, and uses the Event Loop to ensure that asynchronous tasks don't block the execution of synchronous code.

To help visualize this process, we provide a series of visualizations that illustrate each step of how JavaScript handles tasks. These visualizations are based on a specific code example, which is shown throughout the images to simplify the explanation. Each visualization is accompanied by a description to clarify what's happening at each step. This approach helps us see how tasks move through the Call Stack, the Event Queue, and how the Event Loop orchestrates everything.

Data Structures: Call Stack and Event Queue

In this article, we’ll also briefly touch on the two main data structures that help JavaScript manage synchronous and asynchronous tasks:

🍽️🍽️🍽️ Call Stack: The Call Stack is where JavaScript keeps track of synchronous functions that are executing. It works like a stack of plates in the kitchen sink — as each plate gets added, it’s placed on top of the stack. When the sink gets full, the plate that is added last is the first to be removed. Similarly, when a function is called, it’s added on top of the stack, and once it finishes executing, it’s removed from the top.

☕🚶‍♂️🚶‍♀️ Event Queue: The Event Queue holds asynchronous tasks waiting to be processed. It works like a line at a coffee shop. The first person in line is the first to get coffee, meaning the first task added in the queue will be the first one to be processed once the Call Stack is clear.

Step-by-Step Explanation of the JavaScript Event Loop Execution

For better visualization, all synchronous execution contexts are pushed onto the call stack, ready to be executed.

🚀 console.log('Start'); is executed immediately, producing "Start" as output.

⏸️ The Event Loop is paused while synchronous code runs in the main thread.

⏳ The setTimeout(() => { zeroSecondsLater(); }, 0); function is asynchronous.

🔄 The JavaScript engine delegates it to the Browser API.

📩 Since the delay is 0ms, the Browser API processes the request immediately and moves the zeroSecondsLater callback to the Event Queue.

🔄 setTimeout(() => { console.log('3 seconds later'); }, 3000); is delegated to the Browser API, which starts a 3-second timer.

⏳ Similarly, setTimeout(() => { console.log('4 seconds later'); }, 4000); is delegated to the Browser API, which starts a 4-second timer.

⏩ Meanwhile, synchronous code continues executing in the main thread without waiting for these timers.

🛑 Important: The Call Stack executes only synchronous functions and must complete all synchronous tasks before handling anything else. The Event Loop does not move callbacks from the Event Queue to the Call Stack until all synchronous code has finished executing.

🚀 console.log('End'); is executed immediately, producing "End" as output.

👀 At this point, the Call Stack is empty, signaling the Event Loop to check the event queue.

🎧 The Event Loop waits for the Call Stack to become empty and then moves the first callback from the Event Queue to the Call Stack for execution.

🔁 The zeroSecondsLater(); callback is moved from the event queue to the call stack.

📩 The Browser API completes the 3-second timer and moves console.log('3 seconds later'); to the Event Queue.

📩 One more second has passed so the Browser API moves console.log('4 seconds later'); to the Event Queue, placing it after the console.log('3 seconds later'); callback.

🔄 The zeroSecondsLater(); callback invokes oneSecondLater();.

🔄 oneSecondLater(); invokes console.log.

💬 "1 second later" is printed in the console.

🔄 Then, zeroSecondsLater(); invokes twoSecondsLater();.

🔄 twoSecondsLater(); invokes console.log.

💬 "2 seconds later" is printed in the console. All the synchronous code has been executed and the callback function zeroSecondsLater() completes its execution. At this point, the Call Stack becomes empty, signaling the Event Loop to begin processing callbacks from the Event Queue.

👀 The Event Loop moves console.log('3 seconds later'); from the Event Queue to the Call Stack.

🚀 The function executes, producing "3 seconds later" in the console.

👀 Again, the Call Stack is empty, allowing the Event Loop to move console.log('4 seconds later'); from the Event Queue to the Call Stack.

🚀 The function executes, producing "4 seconds later" in the console.

Key Takeaways

✅ Only synchronous code is executed in the Call Stack (Execution Stack) on the main thread. The Event Loop does not move callbacks from the Event Queue to the Call Stack until all synchronous code has finished executing

✅ Asynchronous functions (e.g., setTimeout) are delegated to the Browser API, which processes them in parallel while synchronous code continues.

✅ Callbacks enter the Event Queue based on when they were processed by the Browser API, not necessarily in the order they were requested.

✅ The Event Loop waits for the Call Stack to be empty before moving a callback from the Event Queue to the Call Stack.

Thank you for reading!

I would be grateful to understand your opinion.

A Beginner’s Guide to HTTP and REST Services

Beatris Ilieva — Fri, 14 Mar 2025 11:37:09 +0000

📋 Table of Contents

Introduction
Abbreviations
HTTP
Web Client and Web Server
HTTP Request Methods
HTTP Request
HTTP Response
Status Codes
REST Services
Summary

Abbreviations

WWW (World Wide Web) – A system of interlinked web pages and resources accessible via the internet.
HTTP (Hypertext Transfer Protocol) – The foundation of web communication, enabling clients (browsers) and servers to exchange data.
CRUD (Create, Read, Update, Delete) – The four basic operations performed on data in an application.
REST (Representational State Transfer) – An architectural style for designing web services based on standard HTTP methods.
URI (Uniform Resource Identifier) – A string used to uniquely identify a resource on the web.

Introduction

When we talk about the web, we often use the terms Internet and WWW interchangeably, but they refer to different things. The Internet is the vast global network that connects computers and devices, while the WWW is a service that runs on top of this network, allowing us to access websites and exchange information through HTTP.

HTTP

WWW is a service on the Internet that enables communication between a Client (such as a web browser) and a Server. This interaction happens through HTTP, a text-based protocol that defines the rules for transferring web resources like HTML, CSS, JavaScript, JSON, images, and fonts—powering the web as we know it. Without following these rules, communication between the client and server would fail.

Regardless of the backend or frontend technology we use, we must always follow HTTP rules to make requests from the client and send responses from the server.

To put it simply, HTTP is a text-based protocol that defines how communication between a Client and a Server occurs through the WWW service. The goal is to transfer web resources such as JSON, HTML, JavaScript, CSS, images, fonts, and more—between the client and the server.

HTTP operates on a request-response model. The client initiates the communication by making a request, and the server responds. Each request has only one corresponding response.

Web Client and Web Server

A Web Client is software that interacts with a Web Server. The most common web client is a Web Browser (e.g., Chrome, Firefox, Safari).

A Web Server is software that listens for incoming requests on a specific port. It processes these requests and returns an appropriate response to the client. The server runs continuously awaiting requests.

Together, the Web Client and Web Server communicate to deliver content and functionality on the web.

HTTP Request Methods

With HTTP methods, we specify the action that should be performed on the server. A method is a property of the request that tells the server the client's intention, such as creating, retrieving, updating, or deleting data.

🔍 GET: By sending a GET request, we ask the server to retrieve a resource. An example of a GET request is opening a website’s home page. The server responds by sending all the necessary resources (HTML, CSS, JavaScript, fonts, etc.) so we can see the page content.
✉️ POST: By making a POST request, we tell the server that we intend to create new data. For example, when a user registers on a website, a POST request is sent with their username, email, and password. The server processes this data and creates the account.
🔄 PUT: By making a PUT request, we indicate that we want to modify existing data. For example, if a user submits an incorrect first name during registration and needs to correct it, they can send a PUT request with the updated information.
🛠️ PATCH: A PATCH request is used for making partial updates to a resource. The key difference between PATCH and PUT is that PUT requires sending the entire updated resource, whereas PATCH allows updating only specific fields. For example, if a blog post has a title, author, and description, and we want to update only the title:
1. PUT: We must send the entire updated resource, including the title, author, and description.
2. PATCH: We can send only the new title, leaving the other fields unchanged.
🗑️ DELETE: By sending a DELETE request, we instruct the server to remove a resource. For example, if a user decides to close their account, a DELETE request can be sent to remove their data.
🔎 HEAD: A HEAD request is used to retrieve only the headers of a response, without the response body. This is useful for checking metadata (such as content length or last modified date) before making a full request.
⚙️ OPTIONS: The OPTIONS request may be used to check which HTTP methods are supported by the server for a specific URL.

HTTP Request

An HTTP request consists of two main parts:

Request Headers

Contain metadata about the request, ensuring that it reaches the server with the necessary information.

Request Line

The first line of the request, which includes the HTTP method, the path (URL), and the HTTP version being used:

GET / Username / RepoName / issues / new HTTP() / 1.1;

Host Header

Specifies the domain name of the server. The client first checks with a Name Server (DNS), which resolves the domain into an IP address before making the request:

Host: github.com;

Other Request Headers

Additional headers provide extra information about the request. In this example, we specify that the request body is formatted as JSON, allowing the server to correctly parse the received text:

Content-Type: application/json

Request Body

The actual content of the request, typically included in methods like POST and PUT, but not in GET requests. In the example below, the body contains the title and description of an issue, formatted as a JSON string:

<CRLF> (indicates a new line)
{
    "title": "Found a bug",
    "description" "Working on it"
}
<CRLF>

HTTP Response

An HTTP response has a structure similar to a request.

Response Headers

Status Line

The status code indicates whether the request was successful or not. It consists of a numeric status code and a corresponding status message, informing the client about the outcome of the request.

HTTP/1.1 200 OK

Other Response Headers

In this example, the server specifies that the returned content is in HTML format so that the browser knows how to parse and render it correctly:

Content-Type: text/html

Response Body

The response body contains the actual content sent by the server.

<CRLF>
    <html>
        <head>
            <title>Some Title</title>
        </head>
        <body>
            <h1>Test HTML page</h1>
        </body>
    </html>
<CRLF>

Status code

HTTP status codes indicate the outcome of a request. They are grouped into different ranges based on their meaning:

200 (and similar) – The request was successfully received, processed, and responded to by the server.
301/302 - The requested resource has been moved to a different location
400 (and similar) – The request was received and understood, but there was an issue on the client's side (e.g., missing resource, bad request format). These are not server errors but rather issues caused by the request itself.
500 (and similar) – The request was sent correctly, but an internal server error occurred while processing it. This indicates a problem on the server's side.

REST Services

REST is an architectural style for client-server communication over HTTP. It provides a set of best practices that, when followed, create a consistent and predictable structure for web applications. By adhering to REST principles, backend developers build APIs that are easy to understand and work with, while frontend developers can construct requests with a standardized approach.

Resource

A resource is a logically distinct part of an application. For example, in a social media platform, resources might include users, photos, posts, and comments.

Resources are typically named as plural nouns, and we can perform CRUD (Create, Read, Update, Delete) operations on them using HTTP methods:

Create -> POST
Read -> GET
Update -> PUT/PATCH
Delete -> DELETE

REST allows us by only knowing the name of the resource to be able to perform all CRUD operations.

RESTful API / RESTful Service

A RESTful API or RESTful Service refers to a server that follows REST principles.

Examples

Create a new article (POST request to create a resource)

POST: https://some-service.org/articles

Get all articles (Retrieve all resources)

GET: https://some-service.org/articles

Get a specific article (Use a unique identifier)

GET: https://some-service.org/articles/73635

Delete an article (Remove a resource)

DELETE: https://some-service.org/articles/73635

Replace an existing article (Update the entire resource)

PUT: https://some-service.org/articles/73635

Modify an existing article (Partial update)

PATCH: https://some-service.org/articles/73635

As seen in the examples above, REST allows us to perform all CRUD operations using a consistent URI structure. By simply knowing the resource name and following REST principles, we can easily interact with the API.

Summary

In this article, we explored the fundamentals of HTTP and REST services, essential concepts for web communication. We started with an overview of HTTP, understanding how clients and servers interact using requests and responses.

We then examined different HTTP request methods like GET, POST, PUT, DELETE, and PATCH, along with how headers and status codes work.

Next, we introduced REST, a structured approach to designing APIs that promotes scalability and consistency.

By understanding these concepts, we can confidently work with web services, interact with APIs, and build scalable applications that follow web standards. 🚀

Thank you for reading!

I would be grateful to understand your opinion.