Forem: Arafat Hossain Ar

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! 🎉

Unit Testing in Laravel: A Practical Approach for Developers

Arafat Hossain Ar — Wed, 20 Nov 2024 19:08:12 +0000

Testing is a critical part of software development, but it often feels like a chore. Fortunately, Laravel makes testing a breeze with its built-in tools, helping developers ensure their applications work as expected without spending endless hours debugging. Whether you’re building a small project or a large-scale application, unit testing can save you from potential headaches by catching issues early.

In this blog, we’ll explore unit testing in Laravel—what it is, why it’s important, and how to get started with writing tests. By the end, you’ll understand how to create and execute tests in Laravel with real-world examples.

What is Unit Testing?
Why Unit Testing is Important
Setting Up Unit Testing in Laravel
Writing Your First Unit Test
Testing Models, Controllers, and Services
Running and Interpreting Tests
Best Practices for Laravel Unit Testing
Final Thoughts

What is Unit Testing?

Unit testing is a type of testing where you write code to test individual units of your application, like functions, methods, or classes. These tests are small, fast, and focus on ensuring a specific piece of code works as expected.

In Laravel, unit tests are typically written using PHPUnit, which comes pre-installed with Laravel.

Why Unit Testing is Important

Unit testing might feel like extra work at first, but the benefits far outweigh the initial effort. Here’s why it’s worth your time:

Catch Bugs Early: Tests help identify bugs before your application goes live, saving you from costly fixes later.
Refactor with Confidence: Knowing your tests will catch any issues makes refactoring safer and more efficient.
Improve Code Quality: Writing tests forces you to think through your code’s logic and edge cases, leading to cleaner, more robust code.
Ensure Consistency: Tests ensure that updates or new features don’t break existing functionality.

Setting Up Unit Testing in Laravel

Laravel is pre-configured for unit testing, so you don’t need to install any additional tools. Here’s how to get started:

Step 1: Check PHPUnit Installation

Laravel includes PHPUnit out of the box. You can check the version by running:

vendor/bin/phpunit --version

Step 2: Create a Test Class

Laravel provides a handy Artisan command to generate a new test class:

php artisan make:test ExampleTest --unit

This creates a test file in the tests/Unit directory:

tests/
├── Unit/
│   └── ExampleTest.php

Step 3: Configure the Testing Environment

Laravel uses the .env.testing file for testing. Copy your .env file and rename it to .env.testing. Update the database configuration to use a separate testing database, ensuring your tests don’t affect your development database.

DB_CONNECTION=sqlite
DB_DATABASE=:memory:

Writing Your First Unit Test

Let’s write a simple test to check if a method in a class returns the expected value.

Example: Testing a Math Helper Function

Create a helper class in app/Helpers/MathHelper.php:

namespace App\Helpers;

class MathHelper
{
    public static function add($a, $b)
    {
        return $a + $b;
    }
}

Write a test for this function in tests/Unit/MathHelperTest.php:

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Helpers\MathHelper;

class MathHelperTest extends TestCase
{
    public function testAddition()
    {
        $result = MathHelper::add(2, 3);
        $this->assertEquals(5, $result);
    }
}

Run the test:

vendor/bin/phpunit

If everything is correct, PHPUnit will output:

OK (1 test, 1 assertion)

Testing Models, Controllers, and Services

Testing Models

Models are central to any Laravel application. Let’s test a simple model method.

Add a User model with a custom method in app/Models/User.php:

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    use HasFactory;

    public function isAdmin()
    {
        return $this->role === 'admin';
    }
}

Write a test in tests/Unit/UserTest.php:

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Models\User;

class UserTest extends TestCase
{
    public function testIsAdmin()
    {
        $user = new User();
        $user->role = 'admin';

        $this->assertTrue($user->isAdmin());
    }
}

Testing Controllers

For controllers, you’ll typically use feature tests, but you can still test individual methods.

Testing Services

Create a service in app/Services/ExampleService.php:

namespace App\Services;

class ExampleService
{
    public function greet($name)
    {
        return "Hello, $name!";
    }
}

Write a test for it:

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Services\ExampleService;

class ExampleServiceTest extends TestCase
{
    public function testGreeting()
    {
        $service = new ExampleService();
        $this->assertEquals('Hello, John!', $service->greet('John'));
    }
}

Running and Interpreting Tests

To run all tests in your project:

vendor/bin/phpunit

To run a specific test file:

vendor/bin/phpunit tests/Unit/ExampleTest.php

The output will show:

Tests that passed.
Tests that failed (with details on what went wrong).

Best Practices for Laravel Unit Testing

Test Small Units: Focus on small, isolated units of code, like a single method or function.
Use Assertions Wisely: Laravel provides many assertion methods, such as assertEquals, assertTrue, and assertCount. Use them to verify expected outcomes.
Mock External Dependencies: Use Laravel’s mocking capabilities to simulate database queries or API calls, ensuring tests are independent of external factors.
Run Tests Regularly: Integrate testing into your development workflow to catch issues early.

Final Thoughts

Unit testing in Laravel doesn’t have to be intimidating. With its built-in tools and seamless integration with PHPUnit, Laravel makes it easy to write and manage tests. By adopting a testing-first mindset, you’ll ensure your application is robust, reliable, and ready for production.

Start small—write a test for a single function or class. As you get comfortable, you’ll see how unit testing can transform your development process. Happy coding!

Machine Learning in PHP: Build a News Classifier Using Rubix ML

Arafat Hossain Ar — Fri, 01 Nov 2024 16:51:39 +0000

Introduction

Machine learning is everywhere—recommending movies, tagging images, and now even classifying news articles. Imagine if you could do that within PHP! With Rubix ML, you can bring the power of machine learning to PHP in a way that’s straightforward and accessible. This guide will walk you through building a simple news classifier that sorts articles into categories like “Sports” or “Technology.” By the end, you’ll have a working classifier that can predict categories for new articles based on their content.

This project is perfect for beginners who want to dip their toes into machine learning using PHP, and you can follow along with the complete code on GitHub.

What is Rubix ML?
Setting Up the Project
Creating the News Classification Class
Training the Model
Predicting New Samples
Final Thoughts

What is Rubix ML?

Rubix ML is a machine learning library for PHP that brings ML tools and algorithms into a PHP-friendly environment. Whether you’re working on classification, regression, clustering, or even natural language processing, Rubix ML has you covered. It allows you to load and preprocess data, train models, and evaluate performance—all in PHP.

Rubix ML supports a wide range of machine learning tasks, such as:

Classification: Categorizing data, like labeling emails as spam or not spam.
Regression: Predicting continuous values, like housing prices.
Clustering: Grouping data without labels, like finding customer segments.
Natural Language Processing (NLP): Working with text data, such as tokenizing and transforming it into usable formats for ML.

Let’s dive into how you can use Rubix ML to build a simple news classifier in PHP!

Setting Up the Project

We’ll start by setting up a new PHP project with Rubix ML and configuring autoloading.

Step 1: Initialize the Project Directory

Create a new project directory and navigate into it:

mkdir NewsClassifier
cd NewsClassifier

Step 2: Install Rubix ML with Composer

Make sure you have Composer installed, then add Rubix ML to your project by running:

composer require rubix/ml

Step 3: Configure Autoloading in `composer.json`

To autoload classes from our project’s src directory, open or create a composer.json file and add the following configuration:

{
    "autoload": {
        "psr-4": {
            "NewsClassifier\\": "src/"
        }
    },
    "require": {
        "rubix/ml": "^2.5"
    }
}

This tells Composer to autoload any classes within the src folder under the NewsClassifier namespace.

Step 4: Run Composer Autoload Dump

After adding the autoload configuration, run the following command to regenerate Composer’s autoloader:

composer dump-autoload

Step 5: Directory Structure

Your project directory should look like this:

NewsClassifier/
├── src/
│   ├── Classification.php
│   └── train.php
├── storage/
├── vendor/
├── composer.json
└── composer.lock

src/: Contains your PHP scripts.
storage/: Where the trained model will be saved.
vendor/: Contains dependencies installed by Composer.

Creating the News Classification Class

In src/, create a file called Classification.php. This file will contain the methods for training the model and predicting news categories.

<?php

namespace NewsClassifier;

use Rubix\ML\Classifiers\KNearestNeighbors;
use Rubix\ML\Datasets\Labeled;
use Rubix\ML\Datasets\Unlabeled;
use Rubix\ML\PersistentModel;
use Rubix\ML\Pipeline;
use Rubix\ML\Tokenizers\Word;
use Rubix\ML\Transformers\TfIdfTransformer;
use Rubix\ML\Transformers\WordCountVectorizer;
use Rubix\ML\Persisters\Filesystem;

class Classification
{
    private $modelPath;

    public function __construct($modelPath)
    {
        $this->modelPath = $modelPath;
    }

    public function train()
    {
        // Sample data and corresponding labels
        $samples = [
            ['The team played an amazing game of soccer'],
            ['The new programming language has been released'],
            ['The match between the two teams was incredible'],
            ['The new tech gadget has been launched'],
        ];

        $labels = [
            'sports',
            'technology',
            'sports',
            'technology',
        ];

        // Create a labeled dataset
        $dataset = new Labeled($samples, $labels);

        // Set up the pipeline with a text transformer and K-Nearest Neighbors classifier
        $estimator = new Pipeline([
            new WordCountVectorizer(10000, 1, 1, new Word()),
            new TfIdfTransformer(),
        ], new KNearestNeighbors(4));

        // Train the model
        $estimator->train($dataset);

        // Save the model
        $this->saveModel($estimator);

        echo "Training completed and model saved.\n";
    }

    private function saveModel($estimator)
    {
        $persister = new Filesystem($this->modelPath);
        $model = new PersistentModel($estimator, $persister);
        $model->save();
    }

    public function predict(array $samples)
    {
        // Load the saved model
        $persister = new Filesystem($this->modelPath);
        $model = PersistentModel::load($persister);

        // Predict categories for new samples
        $dataset = new Unlabeled($samples);
        return $model->predict($dataset);
    }
}

This Classification class contains methods to:

Train: Create and train a pipeline-based model.
Save the Model: Save the trained model to the specified path.
Predict: Load the saved model and predict the category for new samples.

Training the Model

Create a script called train.php in src/ to train the model.

<?php

require __DIR__ . '/../vendor/autoload.php';

use NewsClassifier\Classification;

// Define the model path
$modelPath = __DIR__ . '/../storage/model.rbx';

// Initialize the Classification object
$classifier = new Classification($modelPath);

// Train the model and save it
$classifier->train();

Run this script to train the model:

php src/train.php

If successful, you’ll see:

Training completed and model saved.

Predicting New Samples

Create another script, predict.php, in src/ to classify new articles based on the trained model.

<?php

require __DIR__ . '/../vendor/autoload.php';

use NewsClassifier\Classification;

// Define the path to the saved model
$modelPath = __DIR__ . '/../storage/model.rbx';

// Initialize the Classification object
$classifier = new Classification($modelPath);

// Define new samples for classification
$samples = [
    ['The team played an amazing game of soccer, showing excellent teamwork and strategy.'],
    ['The latest programming language release introduces features that enhance coding efficiency.'],
    ['An incredible match between two top teams ended in a thrilling draw last night.'],
    ['This new tech gadget includes features never before seen, setting a new standard in the industry.'],
];

// Predict categories
$predictions = $classifier->predict($samples);

// Display predictions
foreach ($predictions as $index => $prediction) {
    echo "Sample: " . $samples[$index][0] . "\n";
    echo "Prediction: " . $prediction . "\n\n";
}

Run the prediction script to classify the samples:

php src/predict.php

The output should show each sample text with its predicted category.

Final Thoughts

With this guide, you’ve successfully built a simple news classifier in PHP using Rubix ML! This demonstrates how PHP can be more versatile than you might think, bringing in machine learning capabilities for tasks like text classification, recommendation systems, and more. The full code for this project is available on GitHub.

Experiment with different algorithms or data to expand the classifier. Who knew PHP could do machine learning? Now you do.
Happy coding!

Forem: Arafat Hossain Ar

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

Scaling and infrastructure

Code examples side by side

Sending an event with Pusher in PHP

Sending a message with Socket.io

Common mistakes beginners make

When should you choose which

Final Thoughts

Understanding the Laravel Lifecycle (Explained for Beginners)

Table of Contents

1. What Is the Laravel Lifecycle?

2. Step-by-Step Breakdown

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

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

Step 3: Service Providers Load

Step 4: Middleware Runs

Step 5: Routing and Controllers

Step 6: Models, Database, and Response

3. Real-World Analogy

4. Final Thoughts

Quick Recap of the Flow

Top 10 VS Code Extensions for Laravel Developers in 2025

Table of Contents

1. Laravel - The Official Extension

2. Laravel Blade Snippets

3. Laravel Extra Intellisense

4. Laravel Goto View

5. PHP Intelephense

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

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