DEV Community: Ganesh Kumar

Applying Boolean Algebra in Python

Ganesh Kumar — Tue, 29 Sep 2026 17:19:39 +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.

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.

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:

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:

The terminal you see is just UI, and the shell is where all the operations happen

Ganesh Kumar — Thu, 03 Sep 2026 15:10:49 +0000

Hello, I'm Ganesh, 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.

You heard it right; even I didn't know about this until I started understanding how terminals actually work.

We often use terminals, whether it's the default terminal in Linux, macOS, or Windows, or integrated terminals in IDEs like VS Code.
We use them to run commands, scripts, and tools to automate our work.

But, when we run a command, we often only see the output of the command, not what happens in the background.

So, in this article we will explore how terminals and shells actually work.

What Is Terminal? How does it actually work?

A terminal is a software application that provides a text-based interface to the operating system. It allows you to run commands, scripts, and tools to automate your work.

Very similar to modern-day frontend, the terminal, which is there on the monitor, is just a simple UI that displays data.

Any letter, command, or anything typed in the terminal will be constantly sent to the shell in bytes, where the shell understands these bytes and executes commands based on them.

These constant sending and receiving are done over PTY, also called pseudo-teletype, which is a pseudoterminal emulator that creates a channel between the terminal and the shell.

For example:

ls
>
my_folder
my_folder.zip
test.py

So, once you type l terminal, the terminal starts sending these bytes to the shell, and it registers in the shell. Continued with s and then followed with enter, then the shell understands it and executes the command ls and sends a response to the terminal.

How Shell Acts as the Backend of the Terminal

Any command, even your up arrow mark, left arrow mark, right arrow mark, scroll, delete, backspace, etc., is all sent in bytes to the shell, and the shell understands these bytes and executes commands based on them. and sends a response to the terminal, and you see them in your terminal.

That is why sometimes if there is some crash between any two ends, it will cause weird output in terminal ]]^A something like that.

Shell has direct access to the kernel, where it executes predefined instructions on behalf of the user's cmd.

Conclusion

Terminal, ghosty, warp, etc., are just frontends for shell which is the backend that executes commands and show results in frontend UI.

Understanding this will bring bigger idea on how we can design a system on these and how many other tools are built on top of these.

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.