DEV Community: Arafat Hossain Ar

How to Build a Neural Network From Scratch in Python

Arafat Hossain Ar — Sun, 11 Oct 2026 11:57:09 +0000

Want to understand how artificial intelligence works beyond calling a library function? One way to learn is to build a small neural network yourself.

In this tutorial, we will build a neural network from scratch using pure Python. We will not use TensorFlow, PyTorch, NumPy, or scikit-learn. Everything, including the forward pass, loss calculation, backpropagation, and weight updates, will be implemented using Python's standard library.

Our project will predict whether a student passes an exam based on the number of hours they studied. We will train the model on a small dataset and then test it on examples it has not seen during training.

I also ran the program in VS Code and included the actual output so you can compare your results with mine.

What We Are Building
Set Up the Python Project
Prepare the Dataset
Build a Neural Network From Scratch
Train the Neural Network
Test the Model and Check the Results
How the Neural Network Works
Limitations and Experiments
Final Thoughts

1. What We Are Building

Imagine we have a dataset containing students' study hours and exam results.

For example:

Study hours	Exam result
1	Fail
2	Fail
3	Fail
5	Pass
6	Pass
8	Pass

We could write a simple rule that predicts a pass whenever someone studies for at least five hours. However, that would be a rule we decided on ourselves.

Instead, we will create a neural network that learns from examples by adjusting numerical values called weights and biases.

The training process follows this general sequence:

Training Data
     |
     v
Make a Prediction
     |
     v
Calculate the Error
     |
     v
Update Weights and Biases
     |
     v
Repeat Training
     |
     v
Test on Unseen Examples

The network does not rewrite its Python code while learning. It changes the numerical parameters used to calculate its predictions.

2. Set Up the Python Project

You need Python 3 and a code editor. I used VS Code to run this project.

Create a folder containing these two files:

python-ai-from-scratch/
├── dataset.csv
└── ai.py

Check your Python installation in the terminal:

python --version

We will use three built-in Python modules:

csv to read the dataset.
math to perform mathematical calculations.
random to initialize weights and shuffle training examples.

You do not need to install any third-party packages.

3. Prepare the Dataset

Create a file named dataset.csv and add the following data:

study_hours,passed,split
1,0,train
2,0,train
2.5,0,train
3,0,train
3.5,0,test
4,0,train
4.5,1,train
5,1,train
5.5,1,test
6,1,train
7,1,train
8,1,test

The dataset contains three columns.

study_hours represents the number of hours a student studied.
passed contains the expected result. A value of 0 means fail, while 1 means pass.
split identifies whether a row belongs to the training set or the test set.

The model will learn from the training rows. The three rows marked test will be kept separate until evaluation.

These are synthetic examples created for this tutorial. They are not real student records, and they should not be used to draw conclusions about actual exam performance.

4. Build a Neural Network From Scratch

Now open ai.py and add the complete implementation below.

import csv
import math
import random

random.seed(42)


def sigmoid(value):
    value = max(-500, min(500, value))
    return 1 / (1 + math.exp(-value))


def leaky_relu(value):
    # Keep a small gradient when the input is negative.
    return value if value > 0 else 0.01 * value


def load_dataset(filename):
    train_features = []
    train_labels = []
    test_features = []
    test_labels = []

    with open(filename, newline="") as file:
        reader = csv.DictReader(file)

        for row in reader:
            hours = float(row["study_hours"])

            # Scale study hours to a range from 0 to 1.
            feature = [hours / 8]
            label = int(row["passed"])

            if row["split"] == "train":
                train_features.append(feature)
                train_labels.append(label)
            else:
                test_features.append(feature)
                test_labels.append(label)

    return (
        train_features,
        train_labels,
        test_features,
        test_labels,
    )


class NeuralNetwork:
    def __init__(self):
        # Four neurons in the hidden layer.
        self.hidden_weights = [
            [random.uniform(-1, 1)]
            for _ in range(4)
        ]
        self.hidden_biases = [0.0] * 4

        # One output neuron.
        self.output_weights = [
            random.uniform(-1, 1)
            for _ in range(4)
        ]
        self.output_bias = 0.0

    def forward(self, inputs):
        hidden = []

        for weights, bias in zip(
            self.hidden_weights,
            self.hidden_biases,
        ):
            value = sum(
                weight * item
                for weight, item in zip(weights, inputs)
            ) + bias

            hidden.append(leaky_relu(value))

        output_value = sum(
            weight * value
            for weight, value in zip(
                self.output_weights, hidden
            )
        ) + self.output_bias

        return hidden, sigmoid(output_value)

    def predict(self, inputs):
        return self.forward(inputs)[1]

    def calculate_loss(self, features, labels):
        total_loss = 0.0

        for inputs, target in zip(features, labels):
            prediction = self.predict(inputs)

            # Avoid taking the logarithm of zero.
            p = min(
                max(prediction, 1e-7),
                1 - 1e-7,
            )

            total_loss -= (
                target * math.log(p)
                + (1 - target) * math.log(1 - p)
            )

        return total_loss / len(features)

    def train(self, features, labels, epochs=3000, rate=0.1):
        for epoch in range(epochs):
            # Shuffle training examples for each epoch.
            order = list(range(len(features)))
            random.shuffle(order)

            for index in order:
                inputs = features[index]
                target = labels[index]

                hidden, prediction = self.forward(inputs)

                # Calculate the error at the output layer.
                output_error = prediction - target

                # Preserve the old weights for backpropagation.
                old_output_weights = self.output_weights[:]

                for i in range(len(self.output_weights)):
                    self.output_weights[i] -= (
                        rate * output_error * hidden[i]
                    )

                self.output_bias -= rate * output_error

                # Propagate the error through the hidden layer.
                for i in range(len(self.hidden_weights)):
                    activation_gradient = (
                        1 if hidden[i] > 0 else 0.01
                    )

                    hidden_error = (
                        output_error
                        * old_output_weights[i]
                        * activation_gradient
                    )

                    self.hidden_weights[i][0] -= (
                        rate * hidden_error * inputs[0]
                    )

                    self.hidden_biases[i] -= (
                        rate * hidden_error
                    )

            # Calculate loss after completing the epoch.
            if epoch % 500 == 0:
                loss = self.calculate_loss(features, labels)

                print(
                    f"Epoch {epoch}: "
                    f"Training loss = {loss:.4f}"
                )


if __name__ == "__main__":
    (
        train_features,
        train_labels,
        test_features,
        test_labels,
    ) = load_dataset("dataset.csv")

    model = NeuralNetwork()

    model.train(train_features, train_labels)

    print("\nTest results:")

    correct = 0

    for inputs, actual in zip(test_features, test_labels):
        probability = model.predict(inputs)
        predicted = int(probability >= 0.5)

        if predicted == actual:
            correct += 1

        print(
            f"Study hours: {inputs[0] * 8:g}, "
            f"Actual: {actual}, "
            f"Predicted: {predicted}, "
            f"Score: {probability:.4f}"
        )

    accuracy = correct / len(test_labels)

    print(
        f"\nTest accuracy: {accuracy:.0%} "
        f"({correct}/{len(test_labels)})"
    )

Save the file and run the project from your terminal:

python ai.py

Here is what the main methods do:

load_dataset() reads the CSV file and separates training data from test data.
forward() calculates the network's output.
predict() returns the output score for an input.
calculate_loss() measures the model's prediction error.
train() updates the network's weights and biases.

Each method has a specific responsibility, which makes the code easier to understand and modify.

5. Train the Neural Network

Training means adjusting the network's parameters so that its predictions become closer to the expected answers.

The model starts with randomly initialized weights. During training, it processes examples, calculates prediction errors, and updates its parameters.

Consider this line:

output_error = prediction - target

If the expected result is 1 but the model predicts 0.3, the error is negative. The training update uses this information to move the parameters in a direction intended to reduce the loss.

Two important concepts are involved here.

Backpropagation calculates how the prediction error relates to parameters in the network.

Gradient descent uses those calculations to update the parameters.

The learning rate controls the size of each update:

model.train(
    train_features,
    train_labels,
    epochs=3000,
    rate=0.1,
)

A learning rate that is too large can make training unstable. A rate that is too small can make training progress slowly.

The code trains for 3,000 epochs and prints the training loss every 500 epochs. The loss is calculated after the updates for that epoch have finished.

6. Test the Model and Check the Results

After training, the program evaluates the three examples that were excluded from the training set.

For each example, it prints the study hours, actual label, predicted label, and output score.

I ran this implementation in VS Code. Here is the actual output from my run:

Epoch 0: Training loss = 0.6799
Epoch 500: Training loss = 0.0387
Epoch 1000: Training loss = 0.0099
Epoch 1500: Training loss = 0.0053
Epoch 2000: Training loss = 0.0035
Epoch 2500: Training loss = 0.0026

Test results:
Study hours: 3.5, Actual: 0, Predicted: 0, Score: 0.0009
Study hours: 5.5, Actual: 1, Predicted: 1, Score: 1.0000
Study hours: 8, Actual: 1, Predicted: 1, Score: 1.0000

Test accuracy: 100% (3/3)

The training loss decreased from 0.6799 at epoch 0 to 0.0026 at epoch 2500. This shows that the model became much better at fitting the training examples.

The three test predictions were also correct:

Study hours	Actual result	Predicted result
3.5	Fail	Fail
5.5	Pass	Pass
8	Pass	Pass

The program reports 100% test accuracy because it correctly classified all three test examples.

Accuracy is calculated using this formula:

Accuracy (%) = (Correct Predictions / Total Test Examples) * 100

For this run:

Accuracy (%) = (3 / 3) * 100
Accuracy (%) = 100%

The score values are displayed to four decimal places. Therefore, a printed score of 1.0000 may be a value very close to 1 rather than exactly 1.

There is also an important limitation to keep in mind. The test set contains only three examples. If the model got one prediction wrong, its accuracy would fall to 66.67%.

These results show that the program ran and classified this small test set correctly. They do not prove that it will perform equally well on new or real-world data.

7. How the Neural Network Works

The implementation uses a few mathematical operations to turn input data into predictions.

Forward propagation

Forward propagation passes the input through the hidden layer and then the output layer. Each neuron combines its inputs with weights and adds a bias.

The final output is a score between zero and one.

Leaky ReLU

The hidden neurons use Leaky ReLU as their activation function.

For a positive input, the function returns the input unchanged. For a negative input, it returns a small negative value instead of zero.

This small slope allows gradients to continue flowing through negative activations, reducing the risk of permanently inactive neurons.

Sigmoid

The output neuron uses the sigmoid function:

def sigmoid(value):
    value = max(-500, min(500, value))
    return 1 / (1 + math.exp(-value))

Sigmoid converts a number into a value between zero and one. The model uses 0.5 as its classification threshold:

A score below 0.5 becomes class 0.
A score equal to or above 0.5 becomes class 1.

Loss calculation

The network uses binary cross-entropy to measure how far its predictions are from the expected labels.

A lower loss generally means the model fits the training examples better. However, a low training loss does not guarantee good performance on unseen data.

Backpropagation and gradient descent

Backpropagation calculates the gradients needed to update the network's parameters. Gradient descent then uses those gradients and the learning rate to change the weights and biases.

Together, these steps allow the model to learn from examples without manually writing a rule for every possible input.

8. Limitations and Experiments

This project is intentionally small. It uses one input feature, four hidden neurons, nine training examples, and three test examples.

The dataset is synthetic, and the test set is too small to provide strong evidence of generalization. The results should be treated as a demonstration of how a neural network works, not as a reliable exam prediction system.

Here are a few experiments you can try:

Change the learning rate from 0.1 to 0.01 and compare the training loss.
Increase the number of hidden neurons and see how the training results change.
Add more examples to the dataset and reserve a larger test set.
Add more input features, if you have suitable data.
Save the trained weights and biases so you can reuse the model without training it again.

Change one setting at a time and record what happens. That makes it easier to understand which change caused a difference.

This project is also very different from a large language model. Modern language models use much larger networks, extensive training datasets, and substantial computing resources. Still, the basic ideas of parameters, predictions, loss, and optimization are useful starting points for understanding them.

9. Final Thoughts

We have built a small neural network from scratch using Python's standard library. It reads a dataset, makes predictions, calculates errors, updates its parameters, and evaluates its predictions on separate test examples.

The most useful part of this exercise is being able to inspect the calculations instead of treating model training as a black box.

Start by changing the learning rate, run the program again, and compare the results. Once you understand this version, you can move on to larger datasets and more advanced neural network architectures.

Building a Personal Blog with Laravel: A Real World Project

Arafat Hossain Ar — Sun, 23 Aug 2026 12:26:47 +0000

A personal blog sounds like a simple Laravel project. Create posts, show them on the homepage, and you are done.

But once you start adding search, categories, tags, comments, SEO, authentication, analytics, and an admin panel, things become much more interesting.

I built this Laravel Personal Blog as a real world project to explore those problems instead of building another basic CRUD application.

The complete source code is available on GitHub:

https://github.com/arafat-web/laravel-personal-blog

What Is This Project?
Technology Stack
Main Features
Project Structure
How Visitor Analytics Works
SEO and Content Management
How to Run the Project
What I Learned
Final Thoughts

What Is This Project?

This is a complete single-author blogging platform built with Laravel.

It includes both a public blog and a custom admin panel. The project was built without additional application packages, so most of the important functionality is visible in the codebase itself.

The public side contains:

Homepage
Blog posts
Categories
Tags
Search
Comments
RSS feed
Sitemap
SEO metadata
Post view tracking

The admin panel contains:

Dashboard
Post management
Category and tag management
Comment moderation
User management
General settings
SEO settings
Visitor analytics

Technology Stack

The project uses:

PHP 8.3+
Laravel 13.17
MySQL or SQLite
Blade
Eloquent ORM
JavaScript
CSS
PHPUnit

The current project configuration requires PHP 8.3 and Laravel 13.17.

Main Features

The project goes beyond basic CRUD.

For example, posts can have categories, tags, comments, authors, featured images, publishing status, and view counts.

The Post model defines these relationships using Eloquent:

public function user(): BelongsTo
{
    return $this->belongsTo(User::class);
}

public function categories(): BelongsToMany
{
    return $this->belongsToMany(Category::class);
}

public function tags(): BelongsToMany
{
    return $this->belongsToMany(Tag::class);
}

public function comments(): HasMany
{
    return $this->hasMany(Comment::class);
}

The model also has a published() scope, so the application can easily retrieve only published posts.

Project Structure

The application keeps the normal Laravel structure:

app/
├── Http/
│   ├── Controllers/
│   └── Middleware/
├── Models/
└── Providers/

database/
├── factories/
├── migrations/
└── seeders/

resources/
└── views/
    ├── admin/
    └── blog/

public/
├── css/
└── js/

This keeps the public blog, admin panel, models, middleware, and views separated by responsibility.

How Visitor Analytics Works

One of the more interesting parts of the project is visitor tracking.

Instead of simply increasing a counter every time someone opens a page, the application uses middleware to decide whether a request should count as a visit.

The flow is roughly:

The middleware checks for bots, AJAX requests, JSON requests, and machine-readable endpoints such as the sitemap and RSS feed. It also uses a visitor cookie and IP fallback to prevent repeated requests from being counted as separate visits.

This is a good example of the difference between building a demo and building something closer to a real application.

SEO and Content Management

A blog is not very useful if search engines cannot understand it.

The project includes:

Meta descriptions
Keywords
Open Graph tags
Twitter cards
JSON-LD
Sitemap
robots.txt
Search
SEO settings

These settings can be managed from the admin panel.

The project also includes comments with a moderation system, which is important for a public blog.

How to Run the Project

Clone the repository:

git clone https://github.com/arafat-web/laravel-personal-blog.git
cd laravel-personal-blog

Install dependencies:

composer install

Create the environment file:

cp .env.example .env
php artisan key:generate

Configure your database in .env, then run:

php artisan migrate --seed
php artisan storage:link
php artisan serve

The seeder creates sample content and an admin account. The repository README contains the default development credentials.

What I Learned

The biggest lesson from this project was that a real application is much more than CRUD.

Creating a post is easy.

The interesting problems appear afterward.

How should visitors be counted?

How should bots be handled?

How should comments be moderated?

How should SEO be managed?

How should drafts stay hidden?

How should everything be tested?

These are the problems that make a project worth building.

Final Thoughts

This project started as a personal blog, but it became a practical Laravel project covering authentication, Eloquent relationships, middleware, SEO, analytics, content management, storage, and testing.

If you are learning Laravel, projects like this are useful because you can see how individual Laravel features come together to form a complete application.

The full source code is available here:

https://github.com/arafat-web/laravel-personal-blog

You can use it as a reference, experiment with the existing features, or build your own version on top of it.

How to Use AI Without Ruining Your Programming Skills

Arafat Hossain Ar — Wed, 18 Feb 2026 08:25:55 +0000

AI tools are everywhere now. From code suggestions to instant bug fixes, it feels like you can build things faster than ever. For many developers, especially juniors, AI looks like the perfect shortcut.

When I first started using AI while coding, it felt helpful and dangerous at the same time. Helpful because problems got solved quickly. Dangerous because I noticed I was thinking less and pasting more.

In this blog, I will explain how to use AI as a learning partner instead of a replacement, so your programming skills grow instead of slowly fading away.

Why AI Feels So Powerful
Where AI Actually Helps Developers
How AI Can Quietly Harm Your Skills
Rules for Using AI the Right Way
A Real World Analogy
Practical AI Usage Examples
Final Thoughts

Why AI Feels So Powerful

AI tools feel powerful because they remove friction.

You write a prompt, and suddenly:

Errors are explained
Code is generated
Logic is suggested
Bugs disappear

This creates a false sense of mastery. Things work, but you may not fully understand why they work. That gap is where skills quietly weaken.

AI feels fast. Learning is slow. Most people choose speed without realizing the cost.

Where AI Actually Helps Developers

AI is not the enemy. Used correctly, it can make you a better developer.

AI is genuinely useful for:

Explaining unfamiliar concepts in simple language
Refactoring code after you write it
Pointing out edge cases you missed
Summarizing documentation
Reviewing logic for readability

For example, asking:

“Explain why this loop is slow and how to improve it”

is very different from asking:

“Write the whole solution for me”

One builds understanding. The other replaces it.

How AI Can Quietly Harm Your Skills

The danger is not obvious at first.

You stop struggling

Struggle is where learning happens. If AI solves every problem instantly, your brain never builds problem-solving muscles.

You stop debugging

Debugging teaches you how systems behave under pressure. Skipping it removes one of the most important developer skills.

You lose architectural thinking

AI is good at small solutions. It is not responsible for your system design. If you rely on it too much, your big-picture thinking weakens.

You become prompt-dependent

If you cannot code without asking AI first, your confidence and independence disappear.

Rules for Using AI the Right Way

These rules are simple, but powerful.

Rule 1: Think First, Ask Second

Always try to solve the problem yourself first. Even a bad attempt is valuable.

Rule 2: Ask for Explanations, Not Solutions

Ask AI to explain why something works instead of generating full code.

Rule 3: Rewrite AI Code in Your Own Words

If AI gives code, rewrite it manually. If you cannot rewrite it, you did not understand it.

Rule 4: Never Skip Fundamentals

AI does not replace understanding loops, memory, databases, or networking. You still need those foundations.

Rule 5: Debug Without AI Sometimes

Force yourself to debug issues without AI. This keeps your instincts sharp.

A Real World Analogy

Think of AI like a calculator.

A calculator is useful, but if you never learn basic math, you will not understand whether the result makes sense.

AI is the same. It can assist, but it cannot replace understanding. If you trust it blindly, you lose the ability to judge correctness.

Practical AI Usage Examples

Good AI Usage

“Explain why this query is slow”
“What edge cases should I consider here?”
“Can you review this code for readability?”

Bad AI Usage

“Build the entire feature for me”
“Fix this without explaining why”
“Write production code I do not understand”

The difference is intention. Learning-focused prompts grow skills. Shortcut-focused prompts weaken them.

Final Thoughts

AI is not replacing developers. It is exposing how developers learn.

If you use AI to think less, your skills will decline. If you use AI to understand more, your skills will grow faster than before.

The goal is not to avoid AI. The goal is to stay mentally involved while using it.

AI should feel like a senior developer sitting next to you, explaining things. The moment it feels like a crutch, you are using it the wrong way.

The future belongs to developers who can think, not just prompt.

Is PHP Still a Valuable Programming Language in 2026?

Arafat Hossain Ar — Tue, 27 Jan 2026 05:44:19 +0000

PHP is one of those programming languages everyone seems to have an opinion about. Some say it is outdated. Some say it is dying. Others quietly keep building real products with it every single day.

When I first started with PHP, I also wondered whether learning it was a good long-term decision. With new languages and frameworks appearing every year, it is a fair question to ask.

In this blog, I will break down whether PHP is still a valuable programming language in 2026, using real-world context instead of internet noise.

Why People Think PHP Is Dying
Where PHP Is Still Strong
How PHP Has Evolved
PHP in Real Production Systems
Career Perspective for Developers
When PHP Is a Bad Choice
Final Thoughts

Why People Think PHP Is Dying

PHP has been around for a long time, and that alone makes people suspicious. Many developers associate PHP with old codebases, messy scripts, and poor practices from the past.

Some common reasons people think PHP is no longer relevant:

They worked with legacy PHP code and had a bad experience
They compare PHP to newer languages without context
They assume popularity on social media equals real-world usage

The truth is, most of these opinions come from outdated experiences, not modern PHP.

Where PHP Is Still Strong

PHP still dominates areas that actually matter in production.

It powers:

A large percentage of the web
Content-heavy platforms
Backend systems for SaaS products
CMS-driven businesses
APIs and internal tools

Frameworks like Laravel have changed how PHP applications are structured, tested, and maintained. Modern PHP projects look nothing like the old scripts people complain about.

PHP excels when:

You need fast development
You want predictable hosting
You are building web-first applications
You want a mature ecosystem

How PHP Has Evolved

One mistake people make is judging PHP based on how it worked ten years ago.

Modern PHP includes:

Strong typing options
Improved performance
Better memory handling
Cleaner syntax
Mature tooling and standards

Example of modern PHP style:

class UserService
{
    public function __construct(
        private UserRepository $repository
    ) {}

    public function findActiveUsers(): array
    {
        return $this->repository->getActive();
    }
}

This looks and behaves like modern backend code, not a scripting language from the past.

PHP today is structured, readable, and scalable when written properly.

PHP in Real Production Systems

This is where the discussion usually ends.

Large companies do not choose technologies based on trends. They choose what works.

PHP is used in:

Large-scale e-commerce platforms
High-traffic news websites
Financial systems
Internal enterprise tools

If PHP was truly dying, companies would be migrating away from it in large numbers. That is not happening.

Instead, many teams are modernizing PHP codebases rather than replacing them.

Career Perspective for Developers

From a career point of view, PHP is still a strong option in 2026.

Why:

There is consistent demand
Many businesses already rely on PHP
PHP developers are needed to maintain and improve existing systems
Laravel skills translate well into backend architecture thinking

PHP may not always be the trendiest language, but it pays bills, builds products, and solves problems.

For junior developers, PHP is also easier to enter compared to lower-level backend languages.

When PHP Is a Bad Choice

Being honest matters.

PHP is not ideal when:

You need heavy real-time systems
You are building game engines
You require extremely low-level performance control
Your team is already deeply invested in another ecosystem

Every language has limits. PHP is no exception.

Choosing PHP should be a conscious decision, not an automatic one.

Final Thoughts

PHP is not dying. It is not outdated. It is not irrelevant.

PHP is stable, mature, and practical.

In 2026, PHP continues to be valuable for developers who care about building real applications rather than chasing trends. The language has evolved, the ecosystem is strong, and the demand is steady.

If you learn PHP properly and pair it with modern practices, you are not falling behind. You are building skills that still matter.

The real question is not whether PHP is valuable.
The real question is whether you are writing PHP the right way.

LinkedIn: https://www.linkedin.com/in/arafatweb
Portfolio: https://arafatdev.com/
GitHub: https://github.com/arafat-web

Top 10 VS Code Extensions for PHP Developers in 2026

Arafat Hossain Ar — Sun, 25 Jan 2026 06:28:22 +0000

PHP remains a core language for backend development, powering applications from small websites to large enterprise systems. Visual Studio Code has become the editor of choice for many PHP developers because of its speed, flexibility, and strong extension ecosystem.

When I first started using VS Code for PHP, choosing the right extensions was confusing. There were dozens of options, many overlapping, and some already outdated. Over time, I narrowed things down to a small set of extensions that genuinely improve productivity, reduce bugs, and make PHP development smoother.

In this blog, I’ll walk through the top 10 VS Code extensions for PHP developers in 2026, explain why they matter, and how they help in real-world projects.

PHP Intelephense
PHP CS Fixer
PHP Debug (Xdebug)
Laravel (Official)
Blade Snippets
Docker
GitLens
Code Runner
EditorConfig for VS Code
Thunder Client
Final Thoughts

1. PHP Intelephense

Link: https://marketplace.visualstudio.com/items?itemName=bmewburn.vscode-intelephense-client

PHP Intelephense is still the foundation of PHP development in VS Code. It provides intelligent autocompletion, type inference, error detection, and navigation across large codebases.

In real projects, it helps you:

Catch undefined variables before runtime
Jump between classes and methods instantly
Understand function signatures without opening documentation

For most developers, VS Code without Intelephense does not feel complete.

2. PHP CS Fixer

Link: https://marketplace.visualstudio.com/items?itemName=junstyle.php-cs-fixer

Code consistency becomes critical as projects grow and teams expand. PHP CS Fixer automatically formats your code based on standards like PSR-12.

Example configuration:

{
  "php-cs-fixer.enable": true,
  "php-cs-fixer.enableAutoFixOnSave": true
}

This removes formatting arguments from code reviews and keeps the entire codebase consistent.

3. PHP Debug (Xdebug)

Link: https://marketplace.visualstudio.com/items?itemName=xdebug.php-debug

Debugging with dd() and logs only gets you so far. PHP Debug integrates Xdebug directly into VS Code, allowing you to set breakpoints and inspect variables while the code runs.

Typical usage:

Debug complex request flows
Understand why a condition behaves unexpectedly
Step through framework internals when needed

Once you get comfortable with Xdebug, debugging becomes far less stressful.

4. Laravel (Official)

Link: https://marketplace.visualstudio.com/items?itemName=laravel.vscode-laravel

This is a major change compared to previous years. Laravel now maintains an official VS Code extension that replaces multiple community extensions.

It provides:

Route autocompletion
Blade syntax support
Laravel helper and facade suggestions
Artisan command integration
Improved Laravel project awareness

For Laravel developers in 2026, this single extension covers what used to require several separate tools.

5. Blade Snippets

Link: https://marketplace.visualstudio.com/items?itemName=onecentlin.laravel-blade

Even with the official Laravel extension, Blade Snippets remains useful for faster template writing.

It helps by:

Expanding Blade directives quickly
Reducing repetitive typing
Keeping view files clean and readable

It pairs well with the official Laravel extension.

6. Docker

Link: https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-docker

Most modern PHP applications now run inside containers. The Docker extension allows you to manage containers directly from VS Code.

With it, you can:

Start and stop services
Inspect container logs
Attach debuggers to running containers

This keeps your workflow inside the editor instead of jumping between terminals and tools.

7. GitLens

Link: https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens

GitLens enhances the built-in Git features of VS Code and is invaluable in team environments.

It helps you:

See who last modified a line
Explore commit history per file
Understand why changes were made

This context is extremely useful during debugging and code reviews.

8. Code Runner

Link: https://marketplace.visualstudio.com/items?itemName=formulahendry.code-runner

Code Runner is useful for quick experiments and testing small PHP scripts.

Example:

<?php
echo "Quick test";

You can run this instantly without configuring a full project or server, which is great for learning and prototyping.

9. EditorConfig for VS Code

Link: https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig

EditorConfig ensures consistent coding styles across different editors and operating systems.

It controls:

Indentation
Line endings
File encoding

This becomes especially important when multiple developers work on the same project.

10. Thunder Client

Link: https://marketplace.visualstudio.com/items?itemName=rangav.vscode-thunder-client

Thunder Client is a modern replacement for older REST tools inside VS Code.

It allows you to:

Test APIs
Send HTTP requests
Save collections per project

For backend PHP developers working with APIs, this removes the need for external tools.

Final Thoughts

In 2026, PHP development in VS Code is more useful than ever. Many older extensions are no longer needed, and official tooling has replaced fragmented solutions, especially in the Laravel ecosystem.

By choosing a focused and up-to-date extension set, you reduce noise, avoid conflicts, and build a development environment that actually supports how modern PHP applications are built today.

Start with the essentials, add what you truly need, and keep your editor lean. That alone can noticeably improve both productivity and code quality.

What are your go-to VS Code extensions for php development? Share your recommendations in the comments below!

LinkedIn: https://www.linkedin.com/in/arafatweb
Portfolio: https://arafatdev.com/
GitHub: https://github.com/arafat-web

Pusher vs Socket.io Explained for Beginners

Arafat Hossain Ar — Tue, 13 Jan 2026 10:06:14 +0000

You have probably heard people say things like “just use WebSockets” or “Pusher is easier” when talking about real time features. At first, this topic usually feels confusing, boring, or overly technical, especially if you are still getting comfortable with backend development. In this post, I will break down Pusher vs Socket.io using simple language and real-world examples so you can clearly understand what each one does and when to use them.

What problem are we trying to solve
What is Pusher
What is Socket.io
A simple real-world analogy
Setup and development experience
Control and flexibility
Scaling and infrastructure
Code examples side by side
Common mistakes beginners make
When should you choose which
Final Thoughts

What problem are we trying to solve

Both Pusher and Socket.io exist to solve the same core problem.

How do you send data from the server to the browser instantly without the browser asking for it every few seconds?

Examples of this problem include:

Chat messages appearing instantly
Notifications updating in real time
Live dashboards
Online collaboration features

Without WebSockets or similar tools, you would rely on polling, which is inefficient and slow.

What is Pusher

Pusher is a hosted real time messaging service.

You do not run WebSocket servers yourself. Pusher gives you an API and infrastructure that handles connections, scaling, and message delivery.

You mainly focus on:

Sending events from your backend
Listening for events on the frontend

You do not worry much about servers, load balancing, or connection management.

Key characteristics:

Managed service
Very fast to set up
Paid after a small free tier
Less control over low-level behavior

What is Socket.io

Socket. IO is a JavaScript library that helps you build real time applications using WebSockets.

Unlike Pusher, you host and manage the server yourself.

You are responsible for:

Running the WebSocket server
Scaling it
Handling reconnects and edge cases

Key characteristics:

Open source
Full control
No service cost, but infrastructure cost
More setup and maintenance

A simple real-world analogy

Think of a restaurant.

Using Pusher is like hiring a food delivery service.

You prepare the food and hand it over, and the delivery company takes care of drivers, routes, and timing. You pay for the service, but your workload is smaller.

Using Socket.io is like running your own delivery fleet.

You hire drivers, manage vehicles, plan routes, and deal with breakdowns. You have full control but also full responsibility.

Neither approach is wrong. They serve different needs.

Setup and development experience

Pusher setup

Pusher setup is usually quick.

Create an account
Get app keys
Install a backend SDK
Install a frontend SDK

You can often send your first real time event in under an hour.

This is especially friendly for beginners or small teams.

Socket.io setup

Socket.io requires more steps.

Create a Node.js server
Configure Socket.io
Manage connections
Think about scaling early

This is not bad, but it is more work, especially if your main backend is PHP or Laravel.

Control and flexibility

This is where Socket.io shines.

With Socket.io, you control:

Authentication logic
Custom events
Room management
Message routing

With Pusher, you work within their system.

You trade flexibility for simplicity.

If you need deep customization, Socket.io usually wins.

Scaling and infrastructure

Scaling is the biggest difference.

Pusher handles scaling for you. If traffic spikes, your app usually keeps working.

With Socket.io, scaling means:

Multiple servers
Shared state
Redis or similar tools

This is doable, but not beginner-friendly.

Code examples side by side

Sending an event with Pusher in PHP

$pusher->trigger('chat-channel', 'new-message', [
    'user' => 'Alice',
    'message' => 'Hello world'
]);

What this does:
It sends a real time event called new-message to everyone listening on chat-channel.

Why it matters:
You do not manage connections yourself.

When to use it:
Simple real time features with minimal setup.

Sending a message with Socket.io

io.on('connection', (socket) => {
    socket.on('send-message', (data) => {
        io.emit('new-message', data);
    });
});

What this does:
It listens for a message and broadcasts it to all connected clients.

Why it matters:
You fully control how messages flow.

When to use it:
Complex real time systems that need customization.

Common mistakes beginners make

Choosing Socket.io without understanding scaling
Using Pusher for extremely custom workflows
Mixing real-time tools without a clear plan
Ignoring security and authentication

Start simple. Complexity can always be added later.

When should you choose which

Choose Pusher if:

You want speed and simplicity
You are new to real-time systems
You do not want to manage infrastructure

Choose Socket.io if:

You need full control
You are comfortable managing servers
You expect complex real-time logic

Final Thoughts

Most beginners think the choice is about which tool is better. In reality, it is about responsibility.

Pushers remove responsibility in exchange for cost and limits. Socket.io gives you power in exchange for maintenance and complexity.

If you are still learning backend development, starting with Pusher is often a calmer and safer path. Once you understand real-time concepts well, Socket.io starts to make a lot more sense.

Take the path that reduces friction for your current stage, not the one that sounds more impressive.

Understanding the Laravel Lifecycle (Explained for Beginners)

Arafat Hossain Ar — Sun, 05 Oct 2025 07:21:21 +0000

The Laravel Lifecycle is one of the most asked interview questions for junior developers and for good reason.

At first, it may sound complex, but once you understand how it works, you’ll find it surprisingly elegant and even exciting.

Let’s break it down in simple words and real-world examples.

What Is the Laravel Lifecycle?
Step-by-Step Breakdown
Real-World Analogy
Final Thoughts

1. What Is the Laravel Lifecycle?

In short, the Laravel Lifecycle is the full journey of a user’s request from the moment it enters your application until the response is sent back to the browser.

Think of it like ordering food at a restaurant:

You (the user) make a request (place an order).
The kitchen (Laravel) processes your order.
You get your response (the dish served).

That’s exactly what Laravel does it receives a request, processes it through multiple layers, and returns a response.

2. Step-by-Step Breakdown

Let’s go through each step that happens behind the scenes when you load a Laravel page.

Step 1: The Entry Point – `public/index.php`

Every request starts at public/index.php, which is Laravel’s entry point.

It’s like the main gate of a building no matter where you come from, everyone enters through it.

From here, Laravel starts bootstrapping (preparing) the application.

Step 2: The Bootstrap Process – `bootstrap/app.php`

After entering index.php, the request moves to bootstrap/app.php, where Laravel’s Application Instance is created.

You can think of this as Laravel “waking up” it sets up everything it needs to handle the request.

At this point, Laravel loads the Kernel, which acts like the “traffic manager” of the application.

Step 3: Service Providers Load

Next, Laravel loads all Service Providers.

These are the core building blocks that boot up features like:

Database connections
Event handling
Routing
Caching
Authentication

It’s like a car starting its systems the engine, AC, lights, and brakes all come online before you start driving.

You can find all service providers in config/app.php.

Step 4: Middleware Runs

Before the request reaches your controller, Laravel passes it through Middleware.

Middleware are like security gates they check and filter requests.

Examples include:

Checking if the user is logged in (Auth)
Protecting against CSRF attacks
Managing sessions

If any middleware fails (e.g., user not logged in), Laravel stops the request right there and returns a proper response (like redirecting to a login page).

Step 5: Routing and Controllers

Once the request passes through middleware, Laravel’s routing system decides where to send it.

Example route:

Route::get('/user/profile', [UserController::class, 'show']);

Here’s what happens:

Laravel checks if the route /user/profile exists.
It finds that it should call the show() method of UserController.
Laravel executes that controller method.

You can think of the route as a GPS that directs your request to the correct location.

Step 6: Models, Database, and Response

Inside the controller, Laravel may use Models to interact with the Database.

For example:

$user = User::find(1);
return view('profile', ['user' => $user]);

Here’s what happens behind the scenes:

The controller asks the Model (User) to fetch data from the database.
The database returns the result.
The controller sends that data to a view file (Blade template).
Laravel converts the view into an HTML response and sends it back to the browser.

In short:

Controller → Model → Database → Controller → View → Response

3. Real-World Analogy

Imagine Laravel as a restaurant:

Step	Laravel Component	Restaurant Equivalent
1	`index.php`	Main entrance
2	`app.php`	Kitchen setup
3	Service Providers	Staff preparing tools
4	Middleware	Security checking tickets
5	Routing	Waiter taking your order to the right chef
6	Controller & Model	Chef preparing the meal
7	Response	Meal served to your table

By the time your meal (response) reaches you, Laravel has handled dozens of internal tasks but it all happens in milliseconds!

4. Final Thoughts

The Laravel Lifecycle might look complex at first, but once you understand the flow, it becomes one of the most fascinating parts of the framework.

Understanding this process helps you:

Debug your application more effectively.
Write optimized and organized code.
Appreciate how Laravel handles so much for you behind the scenes.

Quick Recap of the Flow

Entry (index.php)
→ bootstrap/app.php
→ Kernel
→ Service Providers
→ Middleware
→ Routing
→ Controller
→ Model
→ Database
→ Controller
→ View/Response

Laravel makes this entire process feel seamless transforming a simple user request into a powerful, structured response in just a fraction of a second.

Top 10 VS Code Extensions for Laravel Developers in 2025

Arafat Hossain Ar — Mon, 29 Sep 2025 13:20:13 +0000

Hey everyone,

Let's talk about our primary tool: the code editor. A fresh install of VS Code is great, but if you're serious about Laravel development, you're leaving a ton of productivity on the table without the right extensions. The right setup can automate the boring stuff, catch errors, and make your entire workflow feel smoother.

After years of tweaking my own environment, I've narrowed it down to a core set of tools that I use on every single project. These are the extensions that genuinely make a difference in my day-to-day.

Here is my definitive list of the 10 must-have VS Code extensions for any Laravel developer in 2025.

Laravel - The Official Extension
Laravel Blade Snippets
Laravel Extra Intellisense
Laravel Goto View
PHP Intelephense
Laravel Pint
PHP Debug
REST Client
Prettier - Code Formatter
GitLens

1. Laravel - The Official Extension

This is the big one, often overlooked because it's so awesome. It includes everything from Artisan commands right in your command palette to route and view navigation, validation rules completion, and even environment variable management. It's truly an all-in-one powerhouse that streamlines so many daily tasks.

Why it's essential: A comprehensive toolkit that brings many Laravel-specific functionalities directly into VS Code.
Grab it here: Laravel on Marketplace

2. Laravel Blade Snippets

Even with the main Laravel extension, this focused extension for Blade is incredibly valuable. It adds robust syntax highlighting and a massive collection of snippets for Blade directives, conditionals, and loops. Typing b:foreach and hitting tab to get the full structure for a loop is a small thing that saves a ton of time.

Why it's essential: Drastically speeds up the creation and editing of your Blade templates.
Grab it here: Laravel Blade Snippets on Marketplace

3. Laravel Extra Intellisense

This is your go-to for making VS Code truly understand your Laravel project's internal workings. It provides intelligent autocompletion for route names, views, config values, and even validation rules. No more guessing route names or constantly flipping between files. It just works.

Why it's essential: Boosts coding speed and accuracy by providing smart, context-aware autocompletion.
Grab it here: Laravel Extra Intellisense on Marketplace

4. Laravel Goto View

Jumping between your controllers and their corresponding views can be a hassle. This extension makes it trivial. Simply Ctrl+Click (or Cmd+Click on Mac) on a view name in your controller, and you're instantly transported to that Blade file.

// In your controller...
public function show(Post $post)
{
    // Ctrl+Clicking on 'posts.show' takes you directly to the view file.
    return view('posts.show', compact('post')); 
}

Why it's essential: Provides seamless navigation between your PHP logic and your Blade templates.
Grab it here: Laravel Goto View on Marketplace

5. PHP Intelephense

While not Laravel-specific, this is the absolute foundation for any PHP development in VS Code. It offers incredibly fast code completion, signature help, go-to-definition, and detailed diagnostics. It's the engine that powers most of the "smart" features you expect from an IDE for PHP code.

Why it's essential: Transforms VS Code into a robust, high-performance PHP IDE.
Grab it here: PHP Intelephense on Marketplace

6. Laravel Pint

Code consistency is key for maintainable projects and smooth team collaboration. Laravel Pint is the official, zero-configuration PHP code style fixer. This extension integrates Pint directly into VS Code, automatically formatting your PHP files on save according to Laravel's coding standards.

Why it's essential: Automates code formatting, ensuring a clean and consistent style across your PHP codebase.
Grab it here: Laravel Pint on Marketplace

7. PHP Debug

Stop relying solely on dd() for debugging. Learning to use a proper step-debugger is a huge leap in productivity. This extension integrates Xdebug, allowing you to set breakpoints, inspect variables, and step through your code line-by-line. It's invaluable for tracking down complex bugs efficiently.

Why it's essential: Provides professional-grade debugging capabilities directly within your editor.
Grab it here: PHP Debug on Marketplace

8. REST Client

Many Laravel projects involve building and consuming APIs. This extension allows you to send HTTP requests and view the responses directly within VS Code, eliminating the need to switch to external tools like Postman for quick testing. You define your requests in a .http file with a straightforward syntax.

### Get all users from the API
GET http://my-app.test/api/users
Accept: application/json
Authorization: Bearer YOUR_API_TOKEN

###

Why it's essential: Streamlines API testing by keeping it within your development environment.
Grab it here: REST Client on Marketplace

9. Prettier - Code Formatter

While Laravel Pint keeps your PHP tidy, Prettier handles everything else. It's an opinionated code formatter for JavaScript, CSS, JSON, Markdown, and more. It ensures a consistent and clean style across all your front-end assets, making your entire project visually cohesive.

Why it's essential: Ensures consistent code formatting across all non-PHP files in your project.
Grab it here: Prettier - Code Formatter

10. GitLens

This extension significantly enhances VS Code's built-in Git capabilities. GitLens provides invaluable features like inline blame annotations (showing who changed what line and when), a powerful history view, and easy comparison tools. It's crucial for understanding codebase evolution and collaborating effectively.

Why it's essential: Offers deep insights into your Git repository history directly within your editor.
Grab it here: GitLens on Marketplace

FAQs

Q: Do I need to install all of these?
A: Not necessarily. This is a comprehensive list, but you should prioritize extensions that address your biggest pain points. Start with the main "Laravel" extension and PHP Intelephense, then add others as needed.

Q: Are these extensions free?
A: Yes, all extensions mentioned are free to use. Some might offer premium tiers for advanced features, but their free versions provide substantial benefits.

Q: Will these extensions slow down my VS Code?
A: While having many extensions can theoretically impact performance, those listed here are generally well-optimized. VS Code also includes tools to monitor extension performance. It's good practice to disable any extensions you don't actively use.

Final Thoughts

Equipping your VS Code with the right extensions is one of the quickest ways to boost your productivity as a Laravel developer. By using these tools, you can streamline common tasks, ensure code quality, and make your development experience much more efficient and enjoyable.

What are your go-to VS Code extensions for Laravel development? Share your recommendations in the comments below!

LinkedIn: https://www.linkedin.com/in/arafatweb
Portfolio: https://arafatdev.com/
GitHub: https://github.com/arafat-web

Bulk Email Sender v2.0: From Simple Tool to Professional Email Marketing Platform

Arafat Hossain Ar — Sat, 26 Jul 2025 08:33:34 +0000

Hey dev community! 👋

Remember that bulk email sender I built with Laravel a while back? Well, it's gotten a MASSIVE upgrade! What started as a simple tool for sending bulk emails has evolved into a full-fledged email marketing platform. Let me walk you through everything that's new in v2.0!

What Was Missing in v1.0?

Don't get me wrong - v1.0 did its job. You could send bulk emails, and that was pretty much it. But after using it for a while (and getting feedback from the community), I realized it was missing some crucial features:

No proper contact management
Couldn't send individual emails
No way to organize contacts
Basic UI that looked... well, basic
No proper queue system for large campaigns

Sound familiar? Yeah, I know. It was more of a "quick hack" than a professional tool.

What's New in v2.0? (Spoiler: A LOT!)

1. Complete Contact Management System

This was the big one! Now you can:

Add contacts individually or in bulk
Import from CSV/Excel files (with proper validation!)
View all contacts in a clean, paginated table
Edit and delete contacts easily
Export your contact lists

2. Smart Tag System

Want to send emails to just your VIP customers? Or maybe only to people from a specific city? Tags got you covered!

Create custom tags (VIP, City-NYC, Newsletter-Subscribers, etc.)
Assign multiple tags to contacts
Send targeted campaigns to specific tags
Filter contacts by tags

3. Individual Email Feature

Sometimes you don't want to send to everyone. Now you can:

Send personalized emails to specific contacts
Use the same rich text editor
Perfect for follow-ups or personal messages

4. Modern UI Overhaul

Let's be honest - v1.0 looked like it was built in 2010. v2.0 brings:

Clean, modern Bootstrap 5 design
Responsive layout that works on mobile
Proper navigation with breadcrumbs
Dark mode support (because why not?)
Professional sidebar navigation

5. Excel Import/Export

This one was a game-changer for productivity:

Import contacts from CSV/Excel files
Proper validation and error handling
Export your contacts for backup
Sample CSV template provided

6. 🔧 Queue System Integration

No more waiting around for large campaigns! Now using Laravel Queues:

Background email processing
No timeouts on large campaigns
Better server resource management
Real-time progress tracking

Technical Improvements

Code Quality

Proper MVC architecture
Form validation with Laravel's built-in validators
Database relationships and migrations
Queue jobs for email processing
Error handling and logging

Performance

Paginated contact lists
Optimized database queries
Asset optimization with Vite
Proper caching strategies

Security

CSRF protection on all forms
Input sanitization
SQL injection prevention
Secure file uploads

Installation & Setup (It's Still Super Easy!)

# Clone the repository
git clone https://github.com/arafat-web/Bulk-Email-Sender.git
cd Bulk-Email-Sender

# Install dependencies
composer install

# Setup environment
cp .env.example .env
php artisan key:generate

# Setup database
php artisan migrate --seed

# Start the application
php artisan serve
php artisan queue:work

Default login: admin@email.com / 12345678

Real-World Use Cases

Since launching v2.0, I've seen people use it for:

Newsletter Management - Import subscribers, organize by interests with tags
Event Invitations - Send bulk invites, then individual follow-ups
Customer Support - Organize customers by product, send targeted updates
Marketing Campaigns - Segment audiences with tags, track engagement
Community Management - Organize members, send announcements

What I Learned Building This

1. User Feedback is Gold

The v1.0 feedback taught me that users needed more than just "send email to everyone." They needed organization, targeting, and flexibility.

2. UI/UX Matters More Than I Thought

A clean interface isn't just pretty - it actually makes the tool more efficient to use. Who knew? 😅

3. Laravel Queues Are Amazing

Seriously, if you're not using queues for heavy tasks, you're missing out. Game-changer for user experience.

4. Progressive Enhancement Works

Started simple with v1.0, then added features based on actual needs. Much better than trying to build everything upfront.

What's Next?

I'm already thinking about v3.0! Some ideas:

Email templates management
A/B testing for campaigns
Analytics and reporting
API for integrations
Multi-user support

Want to Contribute?

The project is completely open source! Whether you want to:

Report bugs
Suggest features
Submit pull requests
Improve documentation

Everything is welcome! Check out the GitHub repo.

Screenshots Gallery

Here are some more screenshots showing the features in action:

Email Templates

Instant Campaign

Email Accounts Settings

🎉 Final Thoughts

Building v2.0 has been an incredible journey. What started as a simple weekend project has become something I'm genuinely proud of. The Laravel community's feedback and support made this possible.

If you're working on email marketing, managing newsletters, or just need to send bulk emails occasionally, give it a try! And if you find it useful, a ⭐ on GitHub would make my day!

🔗 Links

GitHub: arafat-web/Bulk-Email-Sender
Live Demo: GitHub Pages
My Website: arafatdev.com

What do you think about v2.0? Have you built similar tools? I'd love to hear your thoughts and experiences in the comments below! 👇

Design Your Database with dbdiagram.io (Beginner to Pro)

Arafat Hossain Ar — Thu, 26 Jun 2025 14:29:43 +0000

Designing a database schema can either be a quick sketch or a total nightmare, especially if you're working on a big project or collaborating with a team. But what if you could visually plan, share, and even generate your database schema with just a few lines of easy-to-write code?

That’s exactly what dbdiagram.io helps you do. Whether you're a backend developer, a full-stack dev, or a database enthusiast, this tool will make your life 10x easier.

What is dbdiagram.io?
Why Use dbdiagram.io?
Supported Syntax & Importing From Tools
Let’s Design a Real Example – Blog System Schema
Exporting SQL Scripts
Collaboration & Sharing
Tips for Better Schema Design
Final Thoughts

What is dbdiagram.io?

dbdiagram.io is a free, online database design tool where you can create database diagrams using a simple DSL (domain-specific language) or by importing your schema directly.

No need to install clunky software or memorize ER diagram notations — just focus on what your data should look like, and the tool takes care of the visualization.

Why Use dbdiagram.io?

Easy to use: Just write schema like you're writing a config file.
Fast prototyping: Great for startups, side-projects, or freelance gigs.
Visually shareable: Auto-generates ER diagrams that you can share via links.
Supports real DBs: PostgreSQL, MySQL, SQL Server, Oracle, and more.
Free for individuals and small teams.

Supported Syntax & Importing From Tools

You can use either:

dbml (Database Markup Language) – dbdiagram’s native, super readable DSL
SQL (MySQL/PostgreSQL)
Import from tools like MySQL Workbench, PostgreSQL, Prisma, or Rails.

Let’s Design a Real Example – Blog System Schema

Here's a real-world example of designing a database schema for a blogging platform using dbml syntax.

ER Diagram DSL

Table users {
  id int [pk, increment]
  name varchar
  email varchar
  password varchar
  created_at datetime
  updated_at datetime
}

Table profiles {
  id int [pk, increment]
  user_id int [ref: > users.id]
  bio text
  avatar_url varchar
  created_at datetime
  updated_at datetime
}

Table posts {
  id int [pk, increment]
  user_id int [ref: > users.id]
  title varchar
  content text
  created_at datetime
  updated_at datetime
}

Table comments {
  id int [pk, increment]
  post_id int [ref: > posts.id]
  user_id int [ref: > users.id]
  content text
  created_at datetime
  updated_at datetime
}

Table categories {
  id int [pk, increment]
  name varchar
  created_at datetime
  updated_at datetime
}

Table post_categories {
  post_id int [ref: > posts.id]
  category_id int [ref: > categories.id]
  created_at datetime
  updated_at datetime
  Note: 'Composite Primary Key'
  indexes {
    (post_id, category_id) [pk]
  }
}

Table tags {
  id int [pk, increment]
  name varchar
  created_at datetime
  updated_at datetime
}

Table post_tags {
  post_id int [ref: > posts.id]
  tag_id int [ref: > tags.id]
  created_at datetime
  updated_at datetime
  Note: 'Composite Primary Key'
  indexes {
    (post_id, tag_id) [pk]
  }
}

Table likes {
  id int [pk, increment]
  post_id int [ref: > posts.id]
  user_id int [ref: > users.id]
  created_at datetime
  updated_at datetime
  indexes {
    (post_id, user_id) [unique]
  }
}

Table followers {
  follower_id int [ref: > users.id]
  following_id int [ref: > users.id]
  created_at datetime
  Note: 'User following relationship'
  indexes {
    (follower_id, following_id) [pk]
  }
}

Paste this into https://dbdiagram.io/d, and you’ll instantly see a fully functional, visual representation of a blogging platform’s database (below image). No clicking, dragging, or aligning just clean, readable code.

Exporting SQL Scripts

Once your schema is complete, dbdiagram can generate the equivalent SQL for:

PostgreSQL
MySQL
SQL Server
SQLite

Just hit Export > SQL and you’re ready to run it in your database setup.

Collaboration & Sharing

Version control friendly – Save your dbml code in .dbml files in GitHub
Share via link – Collaborators can view your schema without signing up
Teams – Upgrade to a team plan to collaborate in real-time

Tips for Better Schema Design

Always use id as primary key unless you really need composite keys.
Add created_at and updated_at fields for better tracking.
Use foreign keys to define relationships instead of managing them manually.
Normalize, but don’t over-normalize. Balance is key.
Use ENUM or lookup tables for things like post status, user roles, etc.

Final Thoughts

Whether you're a solo developer working on your next SaaS idea, or part of a big team managing microservices, dbdiagram.io is a game-changer for designing and communicating your database architecture.

It saves you from visual mess, enforces good structure, and helps your team stay aligned, all without needing to open MySQL Workbench.

Useful Links

Try it here: dbdiagram.io
Full documentation: dbdocs.io/docs
GitHub-friendly DBML: https://github.com/holistics/dbml

If you loved this breakdown, let me know! Want me to cover more visual dev tools like this? Drop a comment.

🚀 10 Laravel Eloquent Tricks You Didn’t Know (But Will Love!)

Arafat Hossain Ar — Mon, 21 Apr 2025 15:06:04 +0000

Laravel’s Eloquent ORM is one of the most powerful tools in the PHP ecosystem. But let’s be honest, most developers stick to get(), where(), and find(). Eloquent actually has many hidden features that can help you write cleaner, faster, and more maintainable code.

In this blog, you’ll discover 10 lesser-known Eloquent methods and techniques that will level up your Laravel skills.

withWhereHas() – Filter and Eager Load in One Query
cursorPaginate() – Paginate Large Datasets Efficiently
sole() – Ensure Only One Record Exists
upsert() – Insert or Update Multiple Rows at Once
lazy() – Loop Through Big Data Without Memory Issues
findMany() – Fetch Multiple Records Easily
whereBelongsTo() – Query Using a Model Instance
is() – Compare Models Safely
firstOrCreate() and updateOrCreate() – Atomic Record Handling
tap() – Inspect Queries in the Middle of a Chain

1. withWhereHas() – Filter and Eager Load in One Query

$posts = Post::withWhereHas('comments', function ($query) {
    $query->where('approved', true);
})->get();

Why it’s useful:

Avoids multiple queries
Reduces memory usage
Keeps your code concise

2. cursorPaginate() – Paginate Large Datasets Efficiently

$users = User::orderBy('id')->cursorPaginate(50);

Why it’s useful:

Great for infinite scroll or continuous loading
Handles large datasets without slowing down

3. sole() – Ensure Only One Record Exists

$user = User::where('email', 'admin@example.com')->sole();

Why it’s useful:

Eliminates silent bugs
Ensures data uniqueness and consistency

4. upsert() – Insert or Update Multiple Rows at Once

User::upsert(
    [
        ['email' => 'one@test.com', 'name' => 'User One'],
        ['email' => 'two@test.com', 'name' => 'User Two'],
    ],
    ['email'], // Unique column
    ['name']   // Columns to update
);

Why it’s useful:

Prevents duplicates
Minimizes database load

5. lazy() – Loop Through Big Data Without Memory Issues

User::where('active', true)->lazy()->each(function ($user) {
    // Process user
});

Why it’s useful:

Keeps memory usage low
Perfect for batch jobs, exports, and reporting

6. findMany() – Fetch Multiple Records Easily

$users = User::findMany([1, 3, 5]);

Why it’s useful:

Cleaner syntax
More efficient than multiple queries

7. whereBelongsTo() – Query Using a Model Instance

Post::whereBelongsTo($user)->get();

Why it’s useful:

More readable and expressive
Helps when working directly with models

8. is() – Compare Models Safely

if ($post->author->is($currentUser)) {
    // Perform action
}

Why it’s useful:

Safer than manual comparisons
Works with unsaved models too

9. firstOrCreate() and updateOrCreate() – Atomic Record Handling

$user = User::updateOrCreate(
    ['email' => 'someone@example.com'],
    ['name' => 'Someone New']
);

Why it’s useful:

Avoids duplicate records
Clean and readable

10. tap() – Inspect Queries in the Middle of a Chain

User::where('active', true)
    ->tap(function ($query) {
        logger($query->toSql());
    })
    ->get();

Why it’s useful:

Great for debugging
Keeps the method chain intact

Final Thoughts

Laravel Eloquent is packed with powerful features that go beyond the basics. By using these lesser-known methods, you can write code that is not only more efficient but also easier to maintain and scale.

Whether you're building APIs, admin panels, or full-blown applications, these tips will give your Laravel skills an extra edge.

Useful Links

Official Eloquent Documentation
More Laravel Tips on Dev.to
Follow Me on GitHub for Laravel projects and tutorials

Building a PHP CRUD Application with OOP and MySQL: A Best Practice Guide

Arafat Hossain Ar — Fri, 10 Jan 2025 15:58:16 +0000

When developing PHP applications, managing database operations effectively is crucial. One of the most common operations you’ll perform is CRUD (Create, Read, Update, Delete). Adopting Object-Oriented Programming (OOP) principles helps make your code cleaner, reusable, and scalable. Using MySQL with PHP also ensures that your application can handle data storage efficiently.

In this blog, we’ll go through building a PHP CRUD application with OOP and MySQL. We’ll organize the code using best practices and design patterns that are beginner-friendly yet robust enough for larger projects.

By the end of this guide, you will have a solid foundation for working with databases using OOP principles in PHP.

The Importance of OOP in PHP
Setting Up the Project
Creating the Database
Folder Structure
Connecting to the Database
Creating CRUD Operations
- Create
- Read
- Update
- Delete
Final Thoughts

1. The Importance of OOP in PHP

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to organize code. In PHP, OOP allows you to create classes that represent real-world entities, making your code more modular, reusable, and easier to manage.

When working with databases, applying OOP principles means:

Separation of Concerns: Database logic is encapsulated in a class, separate from the rest of your application logic.
Reusability: You can reuse the database class in multiple parts of the application.
Maintainability: Your code is easier to update and extend as your application grows.

2. Setting Up the Project

Before diving into coding, let’s set up a folder structure that’s easy to maintain. Here’s how your project should be organized:

php-crud/
├── config/
│   └── Database.php
├── controllers/
│   └── UserController.php
├── models/
│   └── User.php
├── views/
│   └── user_list.php
├── public/
│   └── index.php
└── .gitignore

config/Database.php: Contains the database connection logic.
controllers/UserController.php: Handles CRUD operations and communicates with the model.
models/User.php: Contains the logic to interact with the users table in MySQL.
views/user_list.php: Displays user data in a table.
public/index.php: The entry point for the application.

3. Creating the Database

Let’s start by creating the database and a users table in MySQL. You can execute the following SQL queries to set up the database:

CREATE DATABASE php_crud;

USE php_crud;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

This table will store basic user information such as name, email, and created_at.

4. Folder Structure

We’ve already set up the basic folder structure. Here’s a breakdown of each folder’s purpose:

config/: Contains the database configuration and connection logic.
controllers/: Handles requests and calls the appropriate methods from the model.
models/: Represents the business logic and database interactions.
views/: Displays the data to the user.
public/: The public folder contains the index.php file, which will be the entry point for the application.

5. Connecting to the Database

Let’s start by creating a database connection class in config/Database.php:

<?php

namespace Config;

use PDO;

class Database
{
    private $host = '127.0.0.1';
    private $dbName = 'php_crud';
    private $username = 'root';
    private $password = '';
    private $connection;

    public function connect()
    {
        try {
            $this->connection = new PDO(
                "mysql:host={$this->host};dbname={$this->dbName}",
                $this->username,
                $this->password
            );
            $this->connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            return $this->connection;
        } catch (PDOException $e) {
            die("Database connection failed: " . $e->getMessage());
        }
    }
}

This class creates a PDO connection to MySQL and is reusable across your project.

6. Creating CRUD Operations

Let’s create a model for handling user data. This class will interact with the users table and perform CRUD operations.

Create Model (User.php)

<?php

namespace Models;

use Config\Database;

class User
{
    private $conn;

    public function __construct()
    {
        $database = new Database();
        $this->conn = $database->connect();
    }

    public function create($name, $email)
    {
        $sql = "INSERT INTO users (name, email) VALUES (:name, :email)";
        $stmt = $this->conn->prepare($sql);
        $stmt->bindParam(':name', $name);
        $stmt->bindParam(':email', $email);
        return $stmt->execute();
    }

    public function read()
    {
        $sql = "SELECT * FROM users";
        $stmt = $this->conn->prepare($sql);
        $stmt->execute();
        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    public function update($id, $name, $email)
    {
        $sql = "UPDATE users SET name = :name, email = :email WHERE id = :id";
        $stmt = $this->conn->prepare($sql);
        $stmt->bindParam(':name', $name);
        $stmt->bindParam(':email', $email);
        $stmt->bindParam(':id', $id);
        return $stmt->execute();
    }

    public function delete($id)
    {
        $sql = "DELETE FROM users WHERE id = :id";
        $stmt = $this->conn->prepare($sql);
        $stmt->bindParam(':id', $id);
        return $stmt->execute();
    }
}

Create Controller (UserController.php)

<?php

namespace Controllers;

use Models\User;

class UserController
{
    public function createUser($name, $email)
    {
        $user = new User();
        return $user->create($name, $email);
    }

    public function getUsers()
    {
        $user = new User();
        return $user->read();
    }

    public function updateUser($id, $name, $email)
    {
        $user = new User();
        return $user->update($id, $name, $email);
    }

    public function deleteUser($id)
    {
        $user = new User();
        return $user->delete($id);
    }
}

Create View (user_list.php)

<?php
// This file is responsible for displaying the list of users.

require_once __DIR__ . '/../controllers/UserController.php';

$userController = new \Controllers\UserController();
$users = $userController->getUsers();

echo "<h1>User List</h1>";
echo "<table><tr><th>ID</th><th>Name</th><th>Email</th><th>Actions</th></tr>";
foreach ($users as $user) {
    echo "<tr><td>{$user['id']}</td><td>{$user['name']}</td><td>{$user['email']}</td><td><a href='update.php?id={$user['id']}'>Edit</a> | <a href='delete.php?id={$user['id']}'>Delete</a></td></tr>";
}
echo "</table>";
?>

Create the Entry Point (index.php)

<?php

require_once __DIR__ . '/../models/User.php';
require_once __DIR__ . '/../controllers/UserController.php';

$userController = new \Controllers\UserController();

// Example: Create a user
$userController->createUser('John Doe', 'john@example.com');

// Example: Read users
$userController->getUsers();

Final Thoughts

By following OOP principles and applying best practices in PHP, we’ve built a simple and scalable CRUD application. This approach makes it easy to expand your project with new features or improve database interactions.

In this guide, we’ve covered:

A simple and maintainable folder structure.
A reusable Database class for MySQL connections.
A User model that encapsulates all CRUD operations.
A UserController to handle business logic.

This structure makes your PHP applications cleaner, more modular, and easier to extend. You can now take this approach and build larger, more complex applications using OOP and MySQL.

Happy coding! 🎉

DEV Community: Arafat Hossain Ar

How to Build a Neural Network From Scratch in Python

Table of Contents

1. What We Are Building

2. Set Up the Python Project

3. Prepare the Dataset

4. Build a Neural Network From Scratch

5. Train the Neural Network

6. Test the Model and Check the Results

7. How the Neural Network Works

Forward propagation

Leaky ReLU

Sigmoid

Loss calculation

Backpropagation and gradient descent

8. Limitations and Experiments

9. Final Thoughts

Building a Personal Blog with Laravel: A Real World Project

Table of Contents

What Is This Project?

Technology Stack

Main Features

Project Structure

How Visitor Analytics Works

SEO and Content Management

How to Run the Project

What I Learned

Final Thoughts

How to Use AI Without Ruining Your Programming Skills

Table of Contents

Why AI Feels So Powerful

Where AI Actually Helps Developers

How AI Can Quietly Harm Your Skills

You stop struggling

You stop debugging

You lose architectural thinking

You become prompt-dependent

Rules for Using AI the Right Way

Rule 1: Think First, Ask Second

Rule 2: Ask for Explanations, Not Solutions

Rule 3: Rewrite AI Code in Your Own Words

Rule 4: Never Skip Fundamentals

Rule 5: Debug Without AI Sometimes

A Real World Analogy

Practical AI Usage Examples

Good AI Usage

Bad AI Usage

Final Thoughts

Is PHP Still a Valuable Programming Language in 2026?

Table of Contents

Why People Think PHP Is Dying

Where PHP Is Still Strong

How PHP Has Evolved

PHP in Real Production Systems

Career Perspective for Developers

When PHP Is a Bad Choice

Final Thoughts

Top 10 VS Code Extensions for PHP Developers in 2026

Table of Contents

1. PHP Intelephense

2. PHP CS Fixer

3. PHP Debug (Xdebug)

4. Laravel (Official)

5. Blade Snippets

6. Docker

7. GitLens

8. Code Runner

9. EditorConfig for VS Code

10. Thunder Client

Final Thoughts

Pusher vs Socket.io Explained for Beginners

Table of contents

What problem are we trying to solve

What is Pusher

What is Socket.io

A simple real-world analogy

Setup and development experience

Pusher setup

Socket.io setup

Control and flexibility

Step 1: The Entry Point – `public/index.php`

Step 2: The Bootstrap Process – `bootstrap/app.php`