DEV Community: Ganesh Kumar

From Linear Algebra to OpenCV: Understanding Image Transformations

Ganesh Kumar — Wed, 07 Oct 2026 18:06:44 +0000

Hello, I'm Ganesh Kumar, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. Star us to help devs discover the project, give it a try, and share your feedback to help improve the product.
Python booleans are literals (fixed values) like integers, strings etc.

Every time we open our phone camera, resize an image, or ask GPT something, linear algebra just ran. We didn't call it. We didn't realize it. But we definitely used it unknowingly.

In this article, we will explore linear algebra concepts with real-world examples, especially focusing on how they are used in computer vision and OpenCV.

Why do we need to learn linear algebra?

Let's take an image and resize it, rotate it, zoom in, zoom out, and finally shear it.

By completing this article, you will be able to understand exactly how these transformations are done using simple linear algebra examples.

In high school, we just read definitions and solved for x and y. Even when we encountered application-based questions, we mostly just plugged numbers into formulas without seeing what was actually happening.

Later, when I really wanted to visualize what these linear algebra transformations looked like, I started exploring. That's when I found 3Blue1Brown's series. It started with vectors, followed by matrix multiplication, and built up from there.

I have compiled all these learnings into a single article. We will learn the core concepts, and I will also add some code for doing the basic image operations you saw above. I hope this helps anyone who is just starting to explore linear algebra.

The Building Blocks of Linear Algebra

From Vectors to Linear Combinations, followed by Linear Transformations—these are the fundamental building blocks of linear algebra.

What Is a Vector?

In simple terms, a vector is an arrow pointing in a specific direction with a specific length. It's a way to represent movement from one point to another.

In linear algebra, a vector is rooted at the origin.

Each vector value is calculated with respect to movement parallel to the axes.

For example, $[32]$ : we move 3 units along the x-axis, then 2 units along the y-axis.

Every vector is associated with a pair of numbers.
Every pair of numbers gives exactly one vector.
For 3D space, we add the z-axis.

We mainly perform two operations on vectors:

Addition
Scaling

Vector Addition

As the name itself suggests, vector addition is nothing but adding vectors.

Example:
We take 2 vectors $a = [12]$ and $b = [32]$ and add them.

Then final vector
$c = [1 + 3 2 + 2] = [44]$ .

Vector Scaling

We multiply a vector with a scalar value. This can be used to make the vector longer, shorter or even reverse the direction.

Example:
We take a vector $a = [12]$ and multiply it by a scalar value 2.

Then final vector
$c = [1 \cdot 2 2 \cdot 2] = [24]$ .

Note: The number used for multiplying the vector is called a scalar.
This multiplying of a number with a vector is called scaling.

Linear Combinations

Even though we know how vectors work, there is another way to think about them.

Think of each coordinate as a scalar that stretches a basis vector.

For example, in 2D, we have $i^$ for the x-axis and $j^$ for the y-axis, both unit vectors.

For $v = [12]$

we scale $i^$ by 1 and $j^$ by 2, then add the results to get $v$ .

It is pronounced as "i-hat" and "j-hat".

They add together to form the vector $1 i^+ 2 j^$ .

Both $i^$ and $j^$ are the "basis vectors" of the xy coordinate system.

Any time we scale vectors and add them, it is called a linear combination of $v$ and $w$ .

Why are scaling and adding vectors called a linear combination?

If we fix the direction of a single vector and vary its scalar multiplier, it traces out a 1-dimensional line.

But if we take two independent vectors and freely change both of their scalars, their combinations can reach every single position in the 2D plane.

If the direction of the two vectors is exactly the same (or completely opposite), then no matter how we scale and add them, we end up trapped on a single line.

The set of all possible vectors we can reach from a given set of vectors by linear combination is called the span of those vectors.

This freedom to scale independently and add the results together is exactly why it is called a linear combination.

Vectors vs Points

Usually, to avoid visual clutter when dealing with many vectors, we just represent each vector by its tip (a point). Since every vector starts at the origin, a single point uniquely identifies a vector.

If we plot all possible linear combinations in a 2D plane, the collection of all these vector tips forms an infinite 2D plane (or grid).

When thinking about one or two vectors, it helps to picture them as arrows. But when thinking about an entire span of vectors, it's easier to picture their tips forming a continuous space of points.

If two vectors line up, their span is just a line.

If two vectors are not pointing in the same direction, their span will be the collection of all possible vectors we get by tuning all possible scalars, creating a full 2D space.

It can also be seen as chaining: adding vector tips to tails freely in two independent directions covers the entire flat sheet. This flat sheet is the span of those 2 independent vectors.

Basically, when vectors are "linearly dependent," it means one vector is just a scaled version of another (or lies in the same span). Adding it doesn't give you access to any new dimensions—you are trapped in the space you already had.

Linear Combination in 3D

For 3D, we scale 3 different vectors and add them together.

That is: $a v + b w + c u$ .

The span of this vector set is all possible linear combinations.

If all 3 vectors point along the exact same line (they are all dependent on each other), their combinations only give you a 1D line:

1D Line" width="600" height="600">

If 2 vectors are independent, but the 3rd vector lies perfectly flat in the plane they create (it is dependent), their span is limited to that single 2D sheet. The third vector is redundant because it doesn't unlock any new directions.

2D Plane" width="600" height="600">

But if all 3 vectors are independent—meaning the third vector points in a brand new direction away from the plane formed by the first two—then we unlock the entire 3D space!

3D Space" width="600" height="600">

This situation—where a vector doesn't add any new direction and keeps us stuck in a lower dimension (like a line in 3D, or a flat plane in 3D)—is called linear dependence.

If each vector adds a brand new dimension that wasn't reachable before, we say the set of vectors is linearly independent.

Finally, the basis of a vector space is a set of linearly independent vectors that spans the full space.

Linear Transformations

A transformation is nothing but a function which transforms any input into an output.

With respect to linear algebra, we say a function which transforms an input vector into an output vector.

Why was it named "transformation" instead of "function"?

Transformation implies it has movement. So if we give an input vector and it gives an output vector, then we can say the vector is moving from the input state to the output state.

To understand it as a whole, we can say every possible input vector is moving to its corresponding output vector.

As we also discussed multiple vectors as points, we can say the movement of input points to output points.

Usually the effect of a transformation is cool because it changes the shape of the 2D grid, which is fascinating to watch.

But to understand why "linear" is used in linear transformation, we should understand these core rules to classify it as linear.

What Makes Linear Transformation Different From Normal Transformation?

To classify a transformation as strictly "linear", it must satisfy two mathematical properties:

It preserves vector addition.

T (u + v) = T (u) + T (v)

It preserves scalar multiplication.

T (c v) = c T (v)

These two properties are the formal definition of a linear transformation.

There is also an easier way to visualize this:

Lines remain lines and parallel lines remain parallel.
The Origin stays fixed at $(0, 0)$ .

If the origin moves, or if straight lines become curved, the transformation is not linear.

If either of these rules is broken, it is a non-linear transformation. For example, if grid lines become wavy, or if the grid shifts so the origin moves, it's no longer a linear transformation.

How can we describe it numerically?

The vector $v = [- 1 2]$ is formed by multiplying the unit vectors $i^$ and $j^$ by the scalar values -1 and 2.

We can write this as a matrix multiplying our scalar values. Since $i^$ is mathematically just $[10]$ and $j^$ is $[01]$ , we simply use them as the columns of our matrix:

[1001] [- 1 2] = [- 1 2]

The beautiful property of a linear transformation is that we only need to track where the basis vectors $i^$ and $j^$ land. Every other vector just follows them perfectly.

If a transformation moves $i^$ to $[1 - 2]$ and $j^$ to $[30]$ , then our vector $v$ will land at:

v_{transformed} = - 1 (transformed i^) + 2 (transformed j^)

v_{transformed} = - 1 [1 - 2] + 2 [30] = [- 1 2] + [60] = [52]

We write this mathematically as a Matrix-Vector multiplication! A matrix is just a package containing where $i^$ and $j^$ land as its columns:

[1 - 2 30] [- 1 2] = [(1 \times - 1) + (3 \times 2) (- 2 \times - 1) + (0 \times 2)] = [- 1 + 6 2 + 0] = [52]

Linear transformations squeeze, stretch, rotate, or shear the space such that grid lines stay parallel and evenly spaced.

Matrix Multiplication

So far, we have seen how a matrix can transform a vector.

But what if we want to apply more than one transformation?

For example, we may want to first scale a vector and then rotate it.

We can represent each transformation using a matrix.

If $A$ represents the first transformation and $B$ represents the second transformation, then:

v^{'} = A v

and then:

v^{''} = B v^{'}

Substituting the first transformation:

v^{''} = B (A v)

which can be written as:

v^{''} = (B A) v

Here, $B A$ means $A$ is applied first, then $B$ , so we read from right to left.

This means we can combine multiple transformations by multiplying their matrices together.

The order is important because matrix multiplication is generally not commutative:

A B \neq = B A

So applying transformation $A$ followed by transformation $B$ can give a different result from applying $B$ followed by $A$ .

2D Transformation Matrices

Now that we understand how matrices represent transformations, we can look at some common 2D transformations.

Scaling

To scale a vector along the x and y directions, we use:

[s_{x} 0 0 s_{y}]

For a vector:

[x y]

the transformation becomes:

[s_{x} 0 0 s_{y}] [x y] = [s_{x} x s_{y} y]

Rotation

To rotate a vector by an angle $θ$ , we use:

[cos θ sin θ - sin θ cos θ]

For example, for a 90° rotation:

[01 - 1 0]

which transforms:

[x y] \to [- y x]

Shearing

A shear transformation changes the position of points along one direction.

For example:

[10 k 1]

transforms:

[x y] \to [x + k y y]

These are the same types of transformations we will later apply to images.

Applying These Concepts To An Image

Instead of digging deeper into matrix math, let's look at a practical example! We'll take a simple image of an apple and use OpenCV to apply these basic transformations.

In OpenCV, we can define our 2x3 transformation matrix M and pass it to a single magical function called cv2.warpAffine().

This function takes the mathematical concepts we just explored and applies them to every pixel in the image simultaneously.

Note: In OpenCV, the origin (0,0) is at the top-left corner, and the y-axis points down. This means scaling happens from the top-left. Because y points down, the textbook rotation matrix would turn the image clockwise on screen, so getRotationMatrix2D flips the signs: a positive angle rotates counter-clockwise.

Applying these transformations to an image

To get started, we first load our image using OpenCV and get its dimensions.

import cv2
import numpy as np

# Load our apple image
image = cv2.imread('apple.jpg')
rows, cols = image.shape[:2]

1. Translation (Shifting)

Note: Translation is technically an affine transformation (a linear transformation plus a shift). That's why OpenCV uses a 2×3 matrix: the left 2×2 is the linear part and the third column is the shift.

To move an image, we use a translation matrix. The matrix requires two parameters: tx (shift along the x-axis) and ty (shift along the y-axis). Here, we shift the apple right by 100 pixels and down by 50 pixels.

# Matrix: [1  0  tx]
#         [0  1  ty]
M_translate = np.float32([
    [1, 0, 100],
    [0, 1, 50]
])
translated_apple = cv2.warpAffine(image, M_translate, (cols, rows))

2. Scaling (Zooming)

Scaling changes the size of the image. The matrix uses sx and sy to scale along the x and y axes. Let's zoom in on our apple by making it 1.5x larger. We also need to increase the output dimensions so the image isn't cropped! If we use a scale factor below 1 (e.g., 0.5), it will zoom out instead.

# Matrix: [sx 0  0]
#         [0  sy 0]
M_scale = np.float32([
    [1.5, 0,   0],
    [0,   1.5, 0]
])
scaled_apple = cv2.warpAffine(image, M_scale, (int(cols * 1.5), int(rows * 1.5)))

3. Rotation

Rotating an image requires calculating sines and cosines for the matrix, which can be tedious. Luckily, OpenCV has a built-in helper cv2.getRotationMatrix2D() that generates the affine matrix for us based on the center point and angle. Let's rotate the apple by 45 degrees.

center = (cols // 2, rows // 2)
M_rotate = cv2.getRotationMatrix2D(center, angle=45, scale=1.0)
rotated_apple = cv2.warpAffine(image, M_rotate, (cols, rows))

4. Shearing

Shearing slides each row sideways in proportion to its height. Let's apply a shear along the x-axis.

# Matrix: [1  kx 0]
#         [0  1  0]
M_shear = np.float32([
    [1, 0.5, 0],
    [0, 1,   0]
])
sheared_apple = cv2.warpAffine(image, M_shear, (int(cols + 0.5 * rows), rows))

By defining different transformation matrices, we can squash, stretch, rotate, and move our images however we want. Since it's all based on linear algebra, the computer can process millions of pixels in a fraction of a second using these simple matrix multiplications!

What's Next?

We've just scratched the surface of what OpenCV can do with linear algebra. Now that we've covered the foundational concepts of affine transformations—translating, scaling, rotating, and shearing our images—we've built the perfect stepping stone for more advanced topics.

In future posts, we'll dive deeper into perspective transformations, 3D projections, and how these exact same mathematical principles power everything from augmented reality filters to deep learning computer vision models.

This is just the beginning—stay tuned for more!

Instead of presenting every diff with equal emphasis, LiveReview scores each change by blast radius — how far its impact reaches through your call graph — so you can focus attention where it actually matters.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview is an AI code reviewer that scores every hunk of a diff by blast radius: how far a change reaches through your call graph, how much persistent state it touches, and how well-tested it is. A 3-line change to a shared auth check can outrank a 300-line UI tweak. Your team's attention goes to the highest-risk code first, not spread evenly across every diff.

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Applying Boolean Algebra in Python

Ganesh Kumar — Tue, 29 Sep 2026 17:19:39 +0000

What makes the boolean data type interesting is that booleans can only be one of two values: True or False.

Let's first understand about whatt boolean is.

What Boolean Represents?

In computer scinece Boolean is Data type that is True or False.

We can say it as as 0 and 1 as well.

In python we use this for many cases where we need some conditions.

A boolean value, False, is assigned to is_valid
is_valid = False

See here if we assign "False" to is is_valid
Then it will be string.

Also the word false is treated as a variable
is_valid = false

Takeaway: True and False should be written without quotation marks and with the first letter capitalized to be a boolean.

Boolean Expressions

Any Data type plays very important role in practical use case same way Boolean data type plays good role when it is been used with boolean expressions.

is_blast_radius <= 10

Read the above code as: Is the blast radius is less than or equal to 10.

Questions like "Is the blast radius of code change is less than 10" or "How much current ?" have only two possible answers: yes or no. In programming, yes is represented as True and no as False, and such questions are expressed using boolean expressions.

In the above code, <= is a comparison operator used to compare two values. Let's look at all the comparison operators next.

Comparison Operators

Python has all these comparison operators that can be used to compare values.

Operator	Expression	Read as
`<`	`x < y`	Is x less than y?
`<=`	`x <= y`	Is x less than or equal to y?
`>`	`x > y`	Is x greater than y?
`>=`	`x >= y`	Is x greater than or equal to y?
`==`	`x == y`	Is x equal to y?
`!=`	`x != y`	Is x not equal to y?

Let's try out these operators.

Example: < and <=

>>> x = int(input("Enter x: "))
Enter x: 10
>>> y = int(input("Enter y: "))
Enter y: 20
>>> result = (x < y)
>>> print(f"x < y ---> {result}")
x < y ---> True
>>> result = (x <= y)
>>> print(f"x <= y ---> {result}")
x <= y ---> True
>>> result = (x < 10)
>>> print(f"x < 10 ---> {result}")
x < 10 ---> False
>>> result = (x <= 10)
>>> print(f"x <= 10 ---> {result}")
x <= 10 ---> True

similarly we can use other oprators as well.
Example: == and !=

x = int(input("Enter x: "))
y = int(input("Enter y: "))

result = (x == y)
print(f"x == y ---> {result}")

result = (x != y)
print(f"x != y ---> {result}")

result = (x == 10)
print(f"x == 10 ---> {result}")

result = (x != 10)
print(f"x != 10 ---> {result}")

Output

Enter x: 10
Enter y: 20
x == y ---> False
x != y ---> True
x == 10 ---> True
x != 10 ---> False


name1 = "Alice"
print(name1 == "Alice")   # True
print(name1 == "alice")   # False
print(name1 != "Alice")   # False
print(name1 != "alice")   # True

Logical Operator

There are three logical operators: and, or & not.

And: Checks both values has True to return True or else it will be false.

Or: Any on value should be True to return True or else it will be false.

Not:Will make true to false and false to true.

How Boolean Works

0 is False
print(bool(0))

Non-zero value is True
print(bool(12))

Non-empty string is True

print(bool("Python"))
print(bool("False")) # True

Empty string is False
print(bool(""))

The "False" string is actually True in a boolean context because it's non-empty.

Conclution

Boolean gives true only based on expression we use or when we use to check wheather there is a value stored in any other datatype.

Next we will use in some exprestion mainly in controlling program flow with conditional statements.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Understand the Simplest Program in Python

Ganesh Kumar — Thu, 24 Sep 2026 18:23:22 +0000

We spent a lot of time understanding the basics.

Now let's actually write one.

Writing the Simplest Program

print('yo brohh')
print('What is your name')  # Ask for their name.
my_name = input('>')
print('It is good to meet you, ' + my_name)

print('What is your age?')  # Ask for their age.
my_age = input('>')
print('You unlocked  ' + str(my_age) + ' level on earth')

On running this program, the output will be:

yo brohh
What is your name
>allan
It is good to meet you, allan
What is your age?
>90
You unlocked  90 level living on earth

We can clearly see that we just printed string literals in the command line.

We took input from the input() function.

Again, we asked for the input of age, and we printed it using data type conversion.

Wrapping Up

Now we have some understanding of how these core things work.

In the next article, we will understand more about conditional statements.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Type Conversion in Python

Ganesh Kumar — Wed, 23 Sep 2026 16:52:35 +0000

What is Type Conversion?

The process of converting from one data type to another.

For example:

Converting from str to int.

Under type conversion, Python has two types:

Implicit Conversion - Automatic type conversion
Explicit Conversion - Manual type conversion

Implicit Type Conversion

Whenever Python automatically converts one data type to another, it is known as Implicit Type Conversion.

Let's understand with an example.

We have decimal-point literals and integer literals.

So, decimal values will be defined as the float data type, and integer values will be the int data type.

Now, when we add these two, we will get like this:

integer_num = 123
print("Data Type:", type(integer_num))
float_num = 1.23
print("Data Type:", type(float_num))
new_num = integer_num + float_num

# display new value and resulting data type
print("Value:", new_num)
print("Data Type:", type(new_num))

The output will be like this:

Data Type: <class 'int'>
Data Type: <class 'float'>
Value: 124.23
Data Type: <class 'float'>

We can clearly see the final variable data type was float.

Python specifically does this to avoid data loss.

It always converts a smaller data type to a larger data type.

If we try to convert str to int, Python throws a TypeError.

integer_num = 123
print("Data Type:", type(integer_num))
test_text = "1.23"
print("Data Type:", type(test_text))

final = test_text + integer_num

Output:

Traceback (most recent call last):
  File "d:\Python- Tutorial\code\implicit.py", line 18, in <module>
    final = test_text + integer_num
           ~~~~~~~~~~~^~~~~~~~~~~~~
TypeError: can only concatenate str (not "int") to str

To solve this specific issue, we can follow the following approach.

Explicit Type Conversion

We convert the data type of an object to the required data type.

Let's use built-in functions like int(), float(), str(), etc. to perform explicit type conversion.

Note: There are many more type conversions available. I have covered a few common data types. You can experiment with those.

This type of conversion is also called typecasting because the user casts (changes) the data type of the objects.

Let's actually solve the previous problem.

integer_num = 123
print("Data Type:", type(integer_num))
test_text = "1.23"
print("Data Type:", type(test_text))
float_text = float(test_text)
print("Data Type:", type(float_text))

final = float_text + integer_num
print("Value:", final)
print("Data Type:", type(final))

Here, I used float() to convert from a string to a float.

Key Points to Remember

Type Conversion is the conversion of an object from one data type to another data type.
Implicit Type Conversion is automatically performed by the Python interpreter.
Python avoids the loss of data in Implicit Type Conversion by choosing a bigger data type.
Explicit Type Conversion is also called Type Casting. The data types of objects are converted using predefined functions by the user.
In Type Casting, loss of data may occur as we enforce the object to a specific data type.

What's Next?

We will use all the learning in a program and make use of everything we have learned in a single program.
I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Understanding Literals in Python

Ganesh Kumar — Tue, 22 Sep 2026 16:47:36 +0000

Hello, I'm Ganesh Kumar, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. Star us to help devs discover the project, give it a try, and share your feedback to help improve the product.
In the previous post, I explained how to use variables. Now, in this article, I will discuss Python literals.

What Are Python Literals?

Literals are nothing but the right side of the = operator.

That means they are nothing but values which we are going to store in a variable.

blog = 'dev.to'

Here, blog is a variable and dev.to is a literal.

Different Types of Literals

There are different types of literals in Python. Here are some of the commonly used types.

Numeric Literals

Numerical literals are immutable. That means we can't replace the value, but we can only assign different literals.

This deals with 3 types of numerical values.

Integer Literals

Integer literals are numbers without decimal parts. They also consist of negative and positive numbers, which means they are integers in terms of maths:)

For example, 5, -11, 0, 12, etc.

Floating-Point Literals

Floating-point literals are numbers that contain decimal parts.

Just like integers, floating-point numbers can also be both positive and negative. For example, 2.5, 6.76, 0.0, -9.45, etc.

Complex Literals

Complex literals are numbers that represent complex numbers.

Here, numerals are in the form a + bj, where a is real and b is imaginary. For example, 6+9j, 2+3j.

String Literals

So, in the assignment of a string, any text written inside "" will be considered as a string literal. Even text inside '' is also considered a string.

name = "string"
print(name)
name = 'String'
print(name)

string
String

Character Literals

Similar to strings, character literals also contain the same text written inside ''.

name = 's'
print(name)

Boolean Literals

This deals with storing boolean values, i.e., True and False.

Status = True
print(Status)

Special Literals

result = None

print(result)

We use it to assign null variables.

Collection Literals

This is storing literals in a collection.

# list literal
bike = ["BMW", "Kawasaki", "R15"] 
print(bike)

# tuple literal 
numbers = (1, 2, 3) 
print(numbers)

# dictionary literal
alphabets = {'a':'apple', 'b':'ball', 'c':'cat'} 
print(alphabets)

# set literal
vowels = {'a', 'e', 'i', 'o', 'u'} 
print(vowels)

Wrapping Up

Understand the meaning of literals and their use cases. Now, next, we can understand type conversion.
I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Understanding Variables in Python

Ganesh Kumar — Mon, 21 Sep 2026 18:09:44 +0000

In the previous post, I explained how to use comments. Now, in this article, I will discuss Python variables.

What Are Python Variables?

In maths, we say a variable is a reference point where we actually store a number for doing some operation. Similarly, in a programming language, a variable is a container (storage area) to hold data. For example,

pyhog = 10

Here, pyhog is a variable storing the value 10.

We assign those values using the assignment operator =.

So, any value we can assign.

Assigning Values to Variables in Python

As we can see from the above example, we use the assignment operator = to assign a value to a variable.

Another example where we are storing normal words:

blog = 'dev.to'

print(blog)

# Output: dev.to

Here, we assigned a value inside '' and we print that value using that variable name.

Python is a type-inferred language, so you don't have to explicitly define the variable type. It automatically knows that dev.to is a string and declares the blog variable as a string.

Changing Variable Value

We can actually update the value accordingly.

blog = 'dev.to'

print(blog)

# Output: dev.to

blog = 3

print(blog)

# Output: 3

As Python handles variables dynamically, it allows us to update an int with a string variable holder.

Rules for Naming Variables

There are a few rules which all developers should follow to have some structured code instead of random words.

Each variable should have its meaning.

For example, if I want to store the score of a team, we will use score but not count.

There are many things we actually define.

Other than these meaningful variable naming conventions, we have these rules:

Constant and variable names should have a combination of letters in lowercase (a to z) or uppercase (A to Z), digits (0 to 9), or an underscore (_).

snake_case
MACRO_CASE
camelCase
CapWords

Create a name that makes sense. For example, score makes more sense than i.
If you want to create a variable name having two words, use an underscore to separate them.

my_name
current_salary

Python is case-sensitive. So, num and Num are different variables. For example,

var score = 3 
var Sum = 90
print(num) # 3
print(Num) # 90

Avoid using keywords like if, True, class, etc. as variable names.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

How to Use Comments in Python?

Ganesh Kumar — Sun, 20 Sep 2026 07:23:02 +0000

Hello, I'm Ganesh Kumar, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. Star us to help devs discover the project, give it a try, and share your feedback to help improve the product.
There are a few types of comments we will be using.

Using with #

# Before Print Statement Using Comments
print("yoo ")

Using with ''

'''
Hello, This is a multi-line comment
Second line
'''
print("Yoo ")

This is usually used if there is a multi-line explanation.

Mainly used under a function; on hovering, the extension will just display the comment.

Using to skip some part of the code

# print("Hi")
print("Yoo ")

# will help us to skip the first print statement.

Why Are Comments Usually Used in Production?

A developer will not work all in one; he works in a team. If the team can understand why each function or code is written, others will not spend time understanding the full code.
It is usually used for debugging, skipping some code parts.
For self-reference for future use.

What's next?

As we understood about comments, in the next article we will understand variables,

how they actually work, etc.
I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

How to Do String Manipulation in Python?

Ganesh Kumar — Sat, 19 Sep 2026 16:49:49 +0000

Hello, I'm Ganesh Kumar, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. Star us to help devs discover the project, give it a try, and share your feedback to help improve the product.
Previously, we understood how each value is categorized into a data type.

We actually did some arithmetic calculations with the float and int data types.

Now, let's try to perform some operations on the string data type.

Performing String Concatenation and Replication

We can actually add two string values using the + operator.

'dev' + '.to'
dev.to

Similarly, we can actually create multiple copies of a string value.

('dev' + '.to' + ' ') * 5
'dev.to dev.to dev.to dev.to dev.to '

We can replicate a string using the multiplication operator.

Rules for Performing String Manipulation

We can't add a number directly to a string.

'dev.to' + 90
Traceback (most recent call last):
  File "<pyshell#55>", line 1, in <module>
    'dev.to' + 90
TypeError: can only concatenate str (not "int") to str

Similarly, we can't perform subtraction or division operations on strings.

'dev.to' - '.to'
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    'dev.to' - '.to'
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    'dev.to' - '.to'
TypeError: unsupported operand type(s) for -: 'str' and 'str'

'dev.to' / '.to'
Traceback (most recent call last):
  File "<pyshell#59>", line 1, in <module>
    'dev.to' / '.to'
TypeError: unsupported operand type(s) for /: 'str' and 'str'

There are some limitations, which we will get to know as we continue.

What's Next?

We have covered how values are managed and how we can manipulate them by following certain rules.

Now, we can actually combine these concepts into a code snippet.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Understanding Data Types in Python

Ganesh Kumar — Sat, 19 Sep 2026 03:28:50 +0000

Previously, we understood how expressions work.

Now, we will understand how these values are decided and how Python interprets them.

How Are Expressions Evaluated?

All expressions are combinations of values and operators. These expressions are evaluated to a single value.

Each of these values belongs to a data type.

2, 3, 0, and -1 belong to int(), whereas 29.2 and -12.2 belong to float(). Finally, jk and "lm" are text and belong to string().

Understanding these three data types will help us start writing code.

Integer Data Type

It includes all non-decimal and non-complex numbers from -∞ to +∞.

For example:

-10 is an int
20 is an int

Even 0 is also an int.

Float Data Type

It includes all decimal and non-complex numbers from -∞ to +∞.

For example:

-10.12 is a float
2.32 is a float

String Data Type

It includes any values that are written inside '' or "".

For example:

"hello"
"b"
's'

Wrapping Up

We understood how values are classified by Python.

Let's do some value manipulation with the string data type.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

How Mathematical Expressions Are Solved in Python

Ganesh Kumar — Thu, 17 Sep 2026 17:06:44 +0000

Instead of moving to a complex topic, let's solve simple math problems and get a clear idea of how Python calculations happen.

All basic mathematical calculations are done using expressions.

Let's understand some of the commonly used operators for performing expressions.

How Does Python Solve an Expression?

Let's run these expressions in Python IDLE.

>>> 2 + 2

4

Here, 2 is a value and + is an operator.

It was simple. What if we have to solve a big expression with many operators?

>>> (5 - 1) * ((7 + 1) / (3 - 1))

16.0

To solve this, we need to understand the simple rules of how each operator works and what priority it has.

If you solved math problems in high school, we followed a rule called the BODMAS rule.

After applying those rules, we were able to get the correct answer; otherwise, the result would have been wrong.

Similarly, Python also follows those rules.

Operator	Name	What it does	Example	Result
`()`	Parentheses	Forces this part to be calculated first	`(2 + 3) * 4`	`20`
`**`	Exponentiation	Raises a number to a power	`2 ** 3`	`8`
`*`	Multiplication	Multiplies numbers	`4 * 5`	`20`
`/`	Division	Divides and gives a decimal/float result	`10 / 4`	`2.5`
`//`	Floor division	Divides and rounds down	`10 // 4`	`2`
`%`	Modulus	Gives the remainder	`10 % 4`	`2`
`+`	Addition	Adds numbers	`5 + 3`	`8`
`-`	Subtraction	Subtracts numbers	`5 - 3`	`2`

Note: Parentheses aren't technically an operator; they're used to control the order.

Priority to remember

Priority	Use
1	`()`
2	`**`
3	`*`, `/`, `//`, `%`
4	`+`, `-`

There are many other operators, but these are the basic arithmetic operators we use in Python.

These operators are categorized as arithmetic operators.

Later, based on the use case, we will learn those operators soon.

Wrapping Up

Now we understand basic mathematical operations. In the next article, we can go through the data types of Python.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Why I'm Going Back to the Basics of Python

Ganesh Kumar — Tue, 15 Sep 2026 16:37:53 +0000

Previously, I wrote about understanding the Go programming language. You can see it in this series: link

My usual learning approach in any programming language used to be a problem-and-solution approach.

But this made me focus too much on trying to solve problems with the optimal solution available, either by looking at Stack Overflow, blogs, and absolutely by using LLMs.

Whenever there was a small issue, usually I was able to solve it if it was a repeated issue. But still, it was not giving me the satisfaction that I had done the work.

To find what I was missing in this process, my colleague suggested that I read a book where the book main focus was to keep learning and leave behind the ego of something we feel uncomfortable with while learning. For example, if you feel uncomfortable reading a book, it might be due to an automatic process we have in our brain to avoid learning new stuff.

As I reflected back on my routine, I usually didn't have much learning of new things. Instead, I was just wasting a lot of time unknowingly.

To fix myself by learning and contributing my learning to others, I thought of learning Python, which I had never really learned before but have some anology of how it works.

To challenge myself to learn new things from scratch.

Usually, I have written, read, and debugged already-written Python code.

We should focus on deeply understanding core concepts from scratch.

If you are a new learner or if you don't have Python on your machine, just follow these steps: link

I will probably be updating the blog over a period of time to make this series connected to each other.

Let's get started with this series now.

What is Python?

Python can be referred to as both a code file written following its syntax and rules, and an interpreter that converts this syntax into executable lines and perform execution on your machine.

It has been very widely used in Django backend, automation tools, testing tools, triggering cron scripts like backups, AI/ML training, etc.

Instead of arguing about which is the better language in the programming world, let's focus on learning the underlying basic principles. So, we can implement these in our workflow where they are specifically needed.

Running a Program

As a tradition, we will run a program that prints hello bro!

Open the IDLE window or write the Python code and run it.

print("hello bro!")

It prints like this.

hello bro!

This is how the print() command works.

Anything inside () will be printed in the terminal.
For text to be printed, it should be inside "".

There are many other ways to print a statement. Later, I will show some examples in this series.

What Next?

In the next article, I will go through all the operations we can perform to get a clear idea of how Python actually handles calculations.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

blast-radius-demo.mp4

LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box	Visualize blast radius at a glance	Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)

Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.
A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase:

Building Regression in PyTorch

Ganesh Kumar — Wed, 09 Sep 2026 20:02:36 +0000

Let's first build the simplest possible regression problem ourselves. This will let you see every part of the neural network.

Let create a data for linear regression

We'll create:

y=2x+1

So our training data is:

x	y
1	3
2	5
3	7
4	9
5	11

This is intentionally simple because we already know the answer:

y=2x+1

Our neural network's job is to discover:

w approx 2
and:
b approx 1

Linear Regression Function

Our model is simply:

       x
       │
       ▼
┌─────────────┐
│ Linear      │
│             │
│ y = wx + b  │
└──────┬──────┘
       │
       ▼
       ŷ

In PyTorch:

import torch
import torch.nn as nn

# Dataset
x = torch.tensor([
    [1.0],
    [2.0],
    [3.0],
    [4.0],
    [5.0]
])

y = torch.tensor([
    [3.0],
    [5.0],
    [7.0],
    [9.0],
    [11.0]
])


# Model
model = nn.Linear(1, 1)

print("Weight:", model.weight)
print("Bias:", model.bias)

At this point PyTorch randomly initializes:

and:

Maybe you get something like:

w=0.37

b=-0.12

So the initial model might be:

ŷ =0.37x-0.12

Obviously, that's bad.
And It will randomly change for every run.

Training Neural Network

loss_function = nn.MSELoss()

optimizer = torch.optim.SGD(
    model.parameters(),
    lr=0.01
)

for epoch in range(1000):

    # Forward pass
    prediction = model(x)

    # Calculate MSE
    loss = loss_function(prediction, y)

    # Calculate gradients
    optimizer.zero_grad()
    loss.backward()

    # Update weight and bias
    optimizer.step()

    if epoch % 100 == 0:
        print(
            epoch,
            loss.item(),
            model.weight.item(),
            model.bias.item()
        )

Eventually you'll get approximately:

w=2

b=1

So the model learned:

ŷ =2x+1

Wrapping Up

Finaly this is how it looks like when combined all the steps together:

     Dataset
        │
        ▼
 x = [1,2,3,4,5]
 y = [3,5,7,9,11]
        │
        ▼
┌───────────────┐
│ Linear        │
│               │
│ ŷ = wx + b    │
│               │
│ w = ?         │
│ b = ?         │
└───────┬───────┘
        │
        ▼
    Prediction
        │
        ▼
       MSE
        │
        ▼
  loss.backward()
        │
        ▼
    Gradients
        │
        ▼
 optimizer.step()
        │
        ▼
   Update w, b
        │
        └──────→ repeat

There is no activation function yet.

That's intentional.

Once this is completely clear, we can introduce a hidden layer.

Then we'll change the dataset to something that cannot be represented by a straight line, such as y=x^2.

Your team's attention is limited, and the deluge of AI-generated code is making it harder to keep production reliable and secure without slowing you down.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Instead of presenting every diff with equal emphasis, LiveReview scores each change by blast radius — how far its impact reaches through your call graph — so you can focus attention where it actually matters.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview: Blast-Radius Aware AI Code Review for Business-Critical Systems

LiveReview is an AI code reviewer that scores every hunk of a diff by blast radius: how far a change reaches through your call graph, how much persistent state it touches, and how well-tested it is. A 3-line change to a shared auth check can outrank a 300-line UI tweak. Your team's attention goes to the highest-risk code first, not spread evenly across every diff.
blast-radius-demo.mp4
LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.

The exact math, not a black box Visualize blast radius at a glance Every factor that feeds the score

How does Blast Radius scoring work? (a more technical explanation)
Here's the goal:

A 3-line fix in a function used by 40 other files, that also writes to a database, should score high.

A 300-line UI change in one file, fully covered by…

View on GitHub

Click below to try LiveReview with your codebase: