DEV Community: Md Imtiyaz Ahmed

How Neural Networks Actually Work — A Thread for Curious Minds

Md Imtiyaz Ahmed — Wed, 27 May 2026 16:43:07 +0000

Everything starts from something you already know:

y = mx + c

That's just a line. But stack enough of them, connect them, and add non-linearity? You have a neural network.

Here's the full breakdown

━━━━━━━━━━━━━━━

📌 TRAINING — How the Model Learns

We don't know the best values of m and c at first. So we:

Start with random values
Predict ŷ = mx + c
Compare with the actual value (y)
Compute the loss (error):

L = (y − ŷ)²

This is Mean Squared Error (MSE). Our goal? Minimize this loss.

━━━━━━━━━━━━━━━

📐 Gradients — The Learning Step

We use differentiation to see how changing m or c affects the loss.

These are called gradients. Then we use gradient descent:

m_new = m_old − η · (∂L/∂m)
c_new = c_old − η · (∂L/∂c)

Where η = learning rate (how fast the model updates).

━━━━━━━━━━━━━━━

🔗 From Line to Neural Network

Now imagine multiple inputs — x₁, x₂, x₃...

y = w₁x₁ + w₂x₂ + w₃x₃ + ... + b

→ wᵢ = weight for each input (how important that input is)
→ b = bias (like c, helps shift the curve)

Each xᵢ, wᵢ pair = one "connection strength."

This is one neuron.

━━━━━━━━━━━━━━━

🏗️ The Network Structure

→ Input Layer: where data enters (x1, x2, x3...)
→ Hidden Layers: learn complex features
→ Output Layer: gives the final prediction

Each neuron connects to neurons in the next layer. Every connection has its own weight.

Output of each neuron = f(W · X + b)

━━━━━━━━━━━━━━━

⚡ Activation Functions — Adding Non-Linearity

If we combine weighted inputs linearly, the model can only learn straight lines. Real-world data is non-linear — so we add activation functions:

• Sigmoid → probabilities (0 to 1)
• ReLU → max(0, x) — adds non-linearity, efficient
• Tanh → centered around 0
• Softmax → multi-class classification

These allow the network to model complex, curved decision boundaries.

━━━━━━━━━━━━━━━

🌐 Universal Approximation Theorem

This is the heart of deep learning.

"A neural network with enough neurons and layers can approximate any function in the world — no matter how complex — as long as you have enough data and training."

Translation: They can model any pattern, from stock prices to language semantics.

━━━━━━━━━━━━━━━

🔢 Why Matrices?

Instead of computing one weight at a time, we represent inputs, weights, and biases as matrices:

Y = f(WX + b)

This allows vectorized computation — very fast on GPUs.

━━━━━━━━━━━━━━━

🔁 Backpropagation — Learning in Multi-Layer Networks

When you have many layers:

The model predicts an output
You compute loss (how wrong it is)
You send this error backward layer by layer — adjusting weights at each step using gradients

That's backpropagation — the backbone of neural network training.

━━━━━━━━━━━━━━━

🧾 Key Concepts Summary

• Weights (W) → strength of connection between neurons
• Bias (b) → shifts decision boundary
• Activation Function → adds non-linearity
• Loss Function → measures error
• Gradient Descent → minimizes loss by adjusting weights
• Backpropagation → passes errors backward

━━━━━━━━━━━━━━━

🔄 The Visual Flow:

Input Layer → Hidden Layer(s) → Output Layer
→ Weighted Sum → Activation
→ Loss Computation
→ Backpropagation
→ Update Weights

Repeat until the network learns patterns perfectly.

━━━━━━━━━━━━━━━

🌍 Real-World Analogy

Think of it like how humans learn:
• Inputs = sensory data
• Weights = attention/importance we give each input
• Bias = our default tendency
• Activation = whether our brain reacts or not
• Loss = how wrong we were
• Gradients = how we adjust next time

━━━━━━━━━━━━━━━

💡 In Short:

Neural networks = layers of weighted connections that transform input → output, learning to minimize loss through gradient-based optimization and non-linear activation.

Meaningful Names (Clean Code) — Why it is important for software developers?

Md Imtiyaz Ahmed — Sat, 13 Feb 2021 14:11:56 +0000

Robert Martin (Uncle Bob) once said,

"Any fool can write code that computers understand. Good programmers write code that humans can understand"

Many of us take pride in ourselves when we provide a solution and write code for a complex problem, but what makes you a complete developer when you write code which your fellow developers can easily understand and giving meaningful names to the variables, functions and classes plays a vital role in that.

Let me tell you why?

I did understand this principle of clean code after a few years into professional coding when I struggled to understand my own code written just a few months ago. You must have us gone through a situation where you would like to prefer writing a fresh code for a bug fix or changes in the requirements instead of incorporate changes to existing code of other developers. These codes are technical debts to the team and organization and if you are also one of them who does not put deliberate effort to keep your code clean and followed the principles of clean codes, someone else down the line reading your code will feel the technical debt you have written that will increase the burden for maintainability, scalability and code debugging.

Providing meaningful names is one of the many principles of clean code and I feel providing meaningful names is the most important one.

Here are the rules for providing meaningful names

Naming Classes:
One class should carry only one responsibility. Hence this intent should reflect through the class name. A good rule of thumb while naming classes and methods is to think of nouns while naming class and verbs while naming methods.

Not Clean

Builder 
Processor 
WebsiteBO 
Utility

Above class names do not tell what specific single responsibility it holds and hence becomes magnet class for other developers as they shove other responsibilities to these classes.

Clean

User 
QueryBuilder 
ProductRepository

Naming Method:
By method name reader should understand what is there inside the method and should have only one job to do.
Not Clean

send()
get()
export()

Clean

sendMail()
getValidUser()
exportZipFile()

Not Clean

//Code 1
Public Boolean sendSuccessMail( User user){
  If(user.status == STATUS.active && 
          isValidUserMail(user.mail)){                   
      //code for generating emailId,subject and email body
     MailUtils.sendMail(mailId,subject,body);
   }
}
```


code 1 breaks 2 rules of clean code. It not only performs two responsibilities and but also its name does not indicate its jobs clearly. Which may cause lots of problem in future.

Let's look at the better version but still not clean


```
Code 2
Public Boolean checkValidUserAndSendSuccessMail( User user){
If(user.status == STATUS.active && isValidUserMail(user.mail)){
   //code for generating emailId,subject and email body
   ....
   MailUtils.sendMail(mailId,subject,body);
  }
}
```


Code 2 with method name `checkUserAndSendSuccessMail` is somewhat better in terms of clear intent, but it still carries more than one responsibility which is not good for code reusability and codebase may end up with many duplicate codes and in many places, you may need different logic for user validation or only mail send. And if there is any change in user validation code, it will not only impact user validation test cases but also send mail test cases.

Clean Code


```
Public Boolean checkValidUser ( User user){
  return user.status == STATUS.active && 
                   isValidUserMail(user.mail)
}
Public Boolean sendSuccessMail( User user){
  //code for generating emailId,subject and email body
  ...
  MailUtils.sendMail(mailId,subject,body);
}

Boolean isValidUser = checkValidUser(user);
   If(isValidUser){
      sendSuccessMail(user)
    }
```


`Warning signs for methods carrying multiple jobs: AND, OR, IF etc
Avoid Abrr like isUsrRegis, regisDone`

***Naming Boolean variable:***
Boolean variable should always ask questions and should be symmetrical when used in pair.

Not Clean


```
send
complete
close
login
open/completed
```


if you declare these kinds of variable, the reader will face problem to understand the use of these variables later in code something like `if(login == true)`

Clean


```
loggedIn
isMailSent
isValidationDone
closed
open/close (symmetric)
```



***Conditions:***
Write implicit code around boolean variables

Not Clean


```
If(isValidationDone == true)
```


Clean


```
if( isValidationDone)
```


Not Clean


```
Boolean isEligibleforDiscount;
If(purchaseAmount >3000){
   isEligibleforDiscount = true;
}else{
   isEligibleforDiscount = false
}
```


Clean


```
Boolean isEligibleforDiscount = purchaseAmount >3000;
```


Use positive conditions

Not Clean


```
If(!isUserNotValid)
```


Clean


```
If(isValidUser)
```


User ternary operator
Avoid using “stringly-typed”/”hard-coded” value

Not Clean


```
If(process.status == “completed”)
```


Instead of stringly typed value, we can use Enums and keep all the status of the process in a single place and we can get rid of typos with strongly typed and help maintain code base with a single place to change.

Avoid using magic numbers
Not Clean


```
If( employee.yearsWorked > 10){
}
```


replace constant or enums with magic number

Clean


```
Int promotionEligibleYears = 10;
If(employee.yearsWorked > promotionEligibleYears)
```


>“Programming is the art of telling another human what one wants a computer to do” — Donal Knuth


For more knowledge on the clean code principles, you can go through below listed resources

***References & Resources:***
[Clean Code: Writing Code for Humans](https://www.pluralsight.com/courses/writing-clean-code-humans)
[Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)](https://www.amazon.in/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)

Follow me [Twitter](https://twitter.com/imimtiyaz9)    [Linkedin](https://www.linkedin.com/in/md-imtiyaz-ahmed-092a6597/)