DEV Community: Shariful Ehasan

Laravel PDF Generator: Comparing Two Popular Packages

Shariful Ehasan — Tue, 30 Dec 2025 06:03:01 +0000

PDF generation is a common requirement in Laravel applications. From invoices and reports to certificates, order summaries, and user documents, PDFs are widely used because they are easy to download, share, and store.

Laravel does not provide built-in support for generating PDF files. To solve this, developers rely on third-party Laravel pdf generator packages that convert HTML or Blade views into PDF documents. Among all available options, Spatie Laravel PDF and Barryvdh Laravel DomPDF are two of the most popular and reliable choices.

Although both packages serve the same purpose, they follow very different approaches internally. Understanding how they work helps developers choose the right solution based on design complexity, hosting environment, and project requirements.

Spatie Laravel PDF – Modern PDF Generation with Browser Accuracy

Spatie Laravel PDF is a modern Laravel package developed by the Spatie team, well known for building high-quality tools for the Laravel ecosystem. This package generates PDFs by rendering Blade views in a headless Chromium browser using the Browsershot library.

Because it relies on a real browser engine, the rendered PDF closely matches how the page appears in a web browser. This makes it an excellent choice for applications that use modern frontend technologies and require high design accuracy.

Key Features of Spatie Laravel PDF:

Full support for modern CSS including Tailwind CSS, Flexbox, and Grid
High-quality, pixel-perfect PDF rendering
Direct Blade view integration
Browser-based rendering for layout accuracy
Suitable for complex and branded document designs

Installation is straightforward:

composer require spatie/laravel-pdf

Since the package depends on browser-based rendering, Node.js and Chromium (or Puppeteer) must be available on the server. These dependencies are commonly supported on VPS, Docker-based setups, and modern hosting platforms.

A basic usage example looks like this:

use Spatie\LaravelPdf\Facades\Pdf;

return Pdf::view('pdfs.invoice', ['invoice' => $invoice])
    ->format('a4')
    ->download('invoice.pdf');

Beyond basic downloads, the package allows developers to save PDFs to storage, stream them in the browser, configure margins and orientation, add headers and footers, and even execute JavaScript during rendering.

Spatie Laravel PDF is best suited for projects where visual quality, branding consistency, and modern UI support are important.

Laravel DomPDF – Simple and Lightweight PDF Generation

Laravel DomPDF is a long-established wrapper around the DomPDF library and has been widely used in Laravel projects for its simplicity and reliability. The package is written entirely in PHP and does not depend on external tools or browser engines.

This package works by parsing HTML or Blade output and converting it directly into a PDF using PHP. Because no browser is involved, setup is minimal and performance is predictable, especially for simple documents.

Key Features of Laravel DomPDF:

Simple and fast installation
No Node.js or Chromium dependency
Lightweight and PHP-only solution
Works well for basic layouts and text-heavy documents
Stable and widely adopted in Laravel projects

composer require barryvdh/laravel-dompdf

No additional system-level dependencies are required, making it suitable for shared hosting environments and restricted servers.

A basic usage example is shown below:

use Barryvdh\DomPDF\Facade\Pdf as DomPdf;

$pdf = DomPdf::loadView('pdfs.invoice', ['invoice' => $invoice]);

return $pdf->download('invoice.pdf');

Laravel DomPDF supports streaming PDFs in the browser, saving them to storage, and configuring paper size and orientation. It integrates smoothly with Blade templates and is easy to learn for beginners.

However, because it supports only limited CSS standards, complex layouts and modern frontend frameworks may not render as expected. Advanced styling features such as Flexbox, Grid, and Tailwind CSS are not fully supported.

Conclusion

Both Spatie Laravel PDF and Laravel DomPDF are excellent Laravel packages for generating PDF files, but they are designed for different use cases.

Spatie Laravel PDF is ideal for modern applications that require accurate layouts, advanced CSS support, and professional document design. It is best suited for projects where PDFs must closely match the website’s appearance.

Laravel DomPDF is better suited for straightforward PDF generation, especially when working with simple layouts or limited hosting environments. Its ease of use and dependency-free setup make it a reliable option for many applications.

Git Stash Made Simple: Save Your Work Without Committing

Shariful Ehasan — Sun, 21 Dec 2025 06:47:11 +0000

Ever been midway through a feature and suddenly need to fix a bug or pull updates? That’s where Git stash comes in. It lets you temporarily save uncommitted changes without creating a commit, giving you a clean working directory to switch tasks—without losing progress.

How It Works

Git stash saves your current changes (staged or unstaged) on a stack, resets your working directory to the last commit, and lets you reapply those changes later. Stashes live locally—they aren’t pushed to GitHub.

Quick Commands

git stash → stash tracked files
git stash -u → include untracked files
git stash push -m "message" → stash with a note
git stash list → see all stashes
git stash apply → reapply latest stash
git stash pop → reapply and remove stash

You can also create a new branch from a stash using git stash branch <name> —super handy for experimenting.

Example Workflow

Save your half-done feature:

git stash push -m "Half-done login feature"

Switch to main, fix a bug, commit your changes.
Return to your feature branch:

git stash pop

Conflicts? Resolve them like any merge conflict.

Tips for Beginners

Always add a message with -m to remember what’s in each stash.
Use -u to include new files you haven’t tracked yet.
Clean up old stashes with git stash drop or git stash clear.
For longer work, consider creating a temporary branch instead.

Git stash keeps your workflow flexible and clean, letting you handle interruptions without messy “WIP” commits. Master it, and you’ll switch tasks like a pro.

@auth vs @if(auth()->check()) - which one are you still writing and why?

Shariful Ehasan — Wed, 10 Dec 2025 06:04:08 +0000

We've all done it. Some of us still do.

But if you're writing @if(auth()->check()) just to show/hide something for logged-in users, you're making your Blade files noisier than it needs to be.

Let's fix that — permanently.

The Old Way: `@if(auth()->check())`

@if(auth()->check())
    <p>Welcome back, {{ auth()->user()->name }}!</p>
    <a href="/dashboard">Dashboard</a>
@else
    <a href="/login">Log in</a>
    <a href="/register">Register</a>
@endif

It works. It's valid PHP.
But it's generic, verbose, and hides intent.

The Right Way: `@auth` and `@guest`

@auth
    <p>Welcome back, {{ auth()->user()->name }}!</p>
    <a href="/dashboard">Dashboard</a>
@endauth

@guest
    <a href="/login">Log in</a>
    <a href="/register">Register</a>
@endguest

Or even cleaner with @else:

@guest
    <a href="/login">Log in</a>
    <a href="/register">Register</a>
@else
    <p>Welcome back, {{ auth()->user()->name }}!</p>
    <a href="/dashboard">Dashboard</a>
@endguest

Feature	`@auth` / `@guest`	`@if(auth()->check())`	Winner
Readability	Instant understanding	Requires reading the condition	`@auth`
Brevity	Less code, less noise	More typing	`@auth`
Intent	Directive name says exactly what it does	Generic `if`	`@auth`
Multiple guards	`@auth('admin')` — clean	`auth()->guard('admin')->check()` — ugly	`@auth`
Safety	Can't accidentally call method on null user	Easy to forget `check()` first	`@auth`
Laravel recommendation	First-class citizen	Only for complex cases	`@auth`

Real Navigation Example (What Every App Has)

<nav class="flex items-center space-x-6">
  @auth
    <x-dropdown>
      <x-slot name="trigger">
        <button class="flex items-center space-x-3">
          <img src="{{ auth()->user()->avatar }}" class="w-8 h-8 rounded-full">
          <span>{{ auth()->user()->name }}</span>
        </button>
      </x-slot>

      <x-dropdown-link href="/profile">Profile</x-dropdown-link>
      <x-dropdown-link href="/settings">Settings</x-dropdown-link>
      <x-dropdown-link href="/logout" method="POST">Log Out</x-dropdown-link>
    </x-dropdown>
  @else
    <a href="/login" class="btn">Log in</a>
    <a href="/register" class="btn btn-primary">Sign up</a>
  @endauth
</nav>

Clean. Professional. Self-documenting.

When You Actually Need `@if(auth()->check())`

Only one valid reason exists:
You need to combine authentication with other logic.

@if(auth()->check() && auth()->user()->is_admin)
    <a href="/admin" class="text-red-600 font-bold">Admin Panel</a>
@endif

@if(auth()->check() && auth()->user()->hasActiveSubscription())
    <span class="badge badge-pro">PRO</span>
@endif

@auth can't do complex conditions — and that's fine. It's not supposed to.

The Hybrid Pattern Everyone Actually Uses

@auth
    <p>Hello, {{ auth()->user()->name }}!</p>

    @if(auth()->user()->is_admin)
        <a href="/admin">Admin Dashboard</a>
    @endif

    @if(auth()->user()->hasRole('moderator'))
        <span class="text-purple-600">Moderator</span>
    @endif
@endauth

@guest
    <p>Please <a href="/login">log in</a> to continue.</p>
@endguest

Final Recommendation

Use @auth and @guest for every simple authentication check.
Use @auth('admin') when you need a specific guard.

Fall back to @if(auth()->check() && ...) only when you have to combine the login state with other conditions (roles, subscriptions, etc.).
And inside class bindings, just write auth()->check().

Stop writing @if(auth()->check()) for basic checks.
Laravel built a cleaner, safer, more expressive tool for exactly this purpose. Use it.

Laravel Eloquent’s create() Methods

Shariful Ehasan — Sun, 16 Nov 2025 07:38:03 +0000

Laravel Eloquent makes working with databases easy, safe, and efficient. Its create() family helps you insert, update, or prevent duplicate records with minimal code. Here’s a quick guide.

create() – Simple Insert

Inserts a new record using mass assignment.
Requires $fillable or $guarded in the model.
Throws an error if a record already exists.

User::create([
    'name' => 'John Doe',
    'email' => 'john@example.com',
    'password' => bcrypt('secret')
]);

firstOrCreate() – Insert If Missing

Searches for a record first.
Creates a new record only if it doesn’t exist.
Returns a saved model.

User::firstOrCreate(
    ['email' => 'a@a.com'],
    ['name' => 'AA', 'password' => bcrypt('pass')]
);

firstOrNew() – Prepare Without Saving

Similar to firstOrCreate(), but doesn’t save if not found.
Returns an unsaved model instance for further modifications.

$user = User::firstOrNew(['email' => 'a@a.com'], ['name' => 'AA']);
$user->password = bcrypt('secret');
$user->save();

updateOrCreate() – Upsert (Update or Insert)

Finds a record and updates if it exists.
Creates a new record if not found.

User::updateOrCreate(
    ['email' => 'a@a.com'],
    ['name' => 'Updated Name', 'status' => 'active']
);

Tips

Always protect mass assignment with $fillable.
Use firstOrCreate() to avoid duplicates in seeders.
Use updateOrCreate() for upserts.
Use firstOrNew() when you need extra control before saving.

Master these methods to write cleaner, safer, and more efficient database code!

Laravel Policies: Do You Really Use Them in Real Projects?

Shariful Ehasan — Tue, 16 Sep 2025 05:11:35 +0000

Laravel Policies are a powerful feature for managing authorization logic in a clean, reusable way. They allow developers to define access control rules for specific models, keeping authorization logic separate from controllers and views. But are they really used in real-world projects, or are they just a shiny feature that sounds good on paper? Let’s dive into their practical use, benefits, and when you might skip them.

What Are Laravel Policies?

Policies in Laravel are classes that organize authorization logic for a specific model or resource. They’re typically used with Laravel’s Gate or the authorize() method to control access to actions like viewing, creating, updating, or deleting resources. For example, a PostPolicy might define who can edit or delete a blog post.


namespace App\Policies;

use App\Models\Post;

use App\Models\User;

class PostPolicy

{

public function update(User $user, Post $post)

{

return $user->id === $post->user_id;

}

}

You register policies in the AuthServiceProvider and use them in controllers or middleware to enforce access rules.

Why Use Policies in Real Projects?

Organized Code: Policies centralize authorization logic, making it easier to maintain than scattering checks across controllers or Blade templates.
Reusability: A single policy can be reused across multiple controllers, routes, or even API endpoints.
Scalability: As your application grows, policies make it easier to manage complex authorization rules without duplicating code.
Testability: Policies are easy to unit test, ensuring your authorization logic is robust.

In real projects, policies shine in applications with multiple user roles or complex permissions. For instance, in a SaaS app with admins, editors, and viewers, policies ensure that only authorized users can perform specific actions. I’ve seen them used effectively in e-commerce platforms to restrict product management to sellers or in CMS systems to limit content editing to specific roles.

When Are Policies Overkill?

Not every project needs policies. For small apps with simple authorization (e.g., "only admins can do X"), basic middleware or simple if checks might suffice. Policies add overhead in terms of setup and maintenance, so if your app has minimal authorization needs, you might skip them to avoid over-engineering.

For example, in a small blog with just one admin, a simple check like $user->isAdmin() in a controller might be enough. Policies become more valuable when you have multiple models, roles, or fine-grained permissions.

Real-World Usage

In my experience, policies are common in mid-to-large Laravel projects. For instance:

Enterprise Apps: Policies are used to enforce role-based access control (RBAC) for different departments or user types.
APIs: Policies pair well with Laravel’s resource controllers to secure API endpoints.
Open-Source Projects: Many popular Laravel packages and projects, like Laravel Nova or Spatie’s Permission package, integrate with or rely on policies for authorization.

However, some developers opt for alternatives like Spatie’s Laravel Permission package, which provides a more flexible role and permission system. Policies are still relevant but may be combined with such packages for added functionality.

Tips for Using Policies Effectively

Keep Them Simple: Don’t overload policies with complex logic; break it down into clear, single-responsibility methods.
Use with Middleware: Leverage Laravel’s can middleware to apply policies at the route level.
Combine with Gates: Use policies alongside Gates for one-off authorization checks.
Document Your Logic: Clearly comment your policies to make them easier to understand for other developers.

Conclusion

Yes, Laravel Policies are used in real projects, especially where clean, maintainable authorization logic is critical. They’re not mandatory for every project, but they’re a fantastic tool for scaling applications with complex access control needs. If you’re working on a Laravel project with multiple roles or resources, give policies a try—they’ll likely save you time and headaches in the long run.

What’s your experience with Laravel Policies? Do you use them, or do you prefer another approach? Share your thoughts below!

How AI Empowers Programmers

Shariful Ehasan — Mon, 04 Aug 2025 07:23:06 +0000

Artificial Intelligence (AI) has become a game-changer for developers, transforming how we code, debug, and deliver projects. AI tools are not just fancy add-ons—they’re essential partners that boost productivity, creativity, and problem-solving. Whether you’re a solo coder or part of a large team, here’s how AI is empowering programmers today.

1. Writing Code Faster with AI Assistants

AI-powered coding assistants like GitHub Copilot, Tabnine, or even Grok (yep, that’s me!) are revolutionizing code creation:

Code Suggestions: AI generates boilerplate code, function stubs, or entire algorithms based on context. For example, type “create a REST API endpoint” and get a working snippet in seconds.
Autocompletion: AI predicts the next line of code, saving keystrokes and mental energy. It’s like having a pair-programming buddy who knows every library.
Multi-Language Support: From Python to JavaScript to Go, AI tools adapt to your language of choice, reducing the need to memorize syntax.

Use AI to scaffold repetitive tasks (e.g., CRUD operations) and focus your energy on high-level architecture.

2. Debugging with Precision

Debugging can be a time sink, but AI is making it faster and less painful:

Error Detection: AI tools analyze code in real-time, flagging potential bugs before you even run the program. Think missing semicolons, null pointer risks, or logic errors.
Root Cause Analysis: AI can trace errors back to their source, suggesting fixes based on patterns in your codebase or external libraries.
Example: Tools like DeepCode or SonarQube’s AI-driven analysis can catch security vulnerabilities or performance bottlenecks early.

Combine AI debugging with unit tests to catch edge cases humans might miss.

3. Learning and Documentation Made Easy

AI is a fantastic learning companion:

Explain Code: Struggling with a complex regex or an unfamiliar API? AI can break it down in plain English. For instance, ask me to explain a chunk of legacy PHP, and I’ll make it crystal clear.
Generate Docs: AI can auto-generate documentation from code comments or function signatures, saving hours of manual work.
Upskilling: AI-powered platforms like freeCodeCamp or LeetCode’s AI hints help you practice and learn new concepts interactively.

Use AI to summarize dense technical docs or Stack Overflow threads when researching solutions.

4. Automating Repetitive Tasks

AI excels at handling the boring stuff:

Code Refactoring: Tools like Sourcegraph or AI-driven IDE plugins can suggest cleaner, more efficient ways to structure your code.
Test Generation: AI can write unit tests or integration tests based on your code’s logic, ensuring better coverage with less effort.
Workflow Automation: From formatting code with Prettier to setting up CI/CD pipelines, AI can recommend or even implement automation scripts.

Use AI to generate boilerplate for new projects—think Dockerfiles, package.json, or even database schemas.

5. Enhancing Collaboration

AI streamlines team workflows:

Code Reviews: AI tools like CodeClimate or PullRequest use machine learning to highlight potential issues in pull requests, reducing manual review time.
Contextual Suggestions: AI can suggest improvements based on team coding standards or past reviews, ensuring consistency.
Communication: AI-powered chatbots can summarize meeting notes or translate technical jargon for cross-functional teams.

Integrate AI into your Git workflow to catch style violations or suggest optimizations before merging.

6. Boosting Creativity and Problem-Solving

AI isn’t just about efficiency—it sparks creativity:

Algorithm Design: Need a sorting algorithm or a machine learning model? AI can propose solutions tailored to your use case.
Prototyping: AI can generate UI mockups, API designs, or database schemas, letting you experiment faster.
Inspiration: Tools like Grok can brainstorm ideas or suggest alternative approaches when you’re stuck on a problem.

Use AI to explore new frameworks or libraries by asking for sample implementations or comparisons.

7. Staying Updated with Trends

The tech world moves fast, and AI helps you keep up:

Trend Analysis: AI can scrape X posts or dev blogs to highlight trending tools, frameworks, or best practices.
Personalized Learning Paths: AI-driven platforms recommend tutorials or courses based on your skill level and goals.
Example: Ask an AI like me about the latest JavaScript framework updates, and I’ll give you a curated rundown.

Set up AI-powered RSS feeds or newsletter summaries to stay informed without drowning in content.

8. Ethical and Secure Coding

AI helps ensure your code is robust and responsible:

Security Scanning: AI tools like Snyk or OWASP ZAP identify vulnerabilities, such as SQL injection or XSS risks, in real-time.
Bias Detection: For machine learning projects, AI can flag biased datasets or unfair algorithms.
Compliance: AI can enforce coding standards or regulatory requirements, like GDPR-compliant data handling.

Always review AI-generated code for security and accuracy—AI is a helper, not a replacement.

Challenges to Watch Out For

AI isn’t perfect. Over-reliance can lead to:

Blind Trust: AI suggestions might not always fit your context. Always validate outputs.
Skill Erosion: Relying too much on AI for basic tasks can weaken core coding skills.
Cost: Some AI tools require paid subscriptions, so weigh the cost-benefit for your needs.

Final Thoughts

AI is like a super smart intern who’s always ready to help—but you’re still the lead developer. By leveraging AI for coding, debugging, learning, and collaboration, you can ship better code faster while staying creative and competitive. What’s your favorite way to use AI in your workflow? Drop a comment—I’d love to hear how AI’s empowering your coding journey!

How Do You Structure Complex Queries Using Laravel’s Query Builder?

Shariful Ehasan — Fri, 01 Aug 2025 21:09:25 +0000

Laravel's Query Builder is one of its most powerful tools—clean, expressive, and flexible. But as queries get more complex, involving joins, subqueries, filters, dynamic conditions, etc., things can start getting messy or repetitive.

How do you manage and structure complex queries using Laravel’s Query Builder?

Possible angles to share:

Do you break logic into reusable scopes or services?
Do you prefer using the Eloquent ORM over the Query Builder—or a mix of both?
Have you built your own helper functions or query macros?

Handling NULL Values in SQL: Best Practices and Common Pitfalls

Shariful Ehasan — Thu, 24 Jul 2025 05:40:17 +0000

If you’ve spent any time working with SQL, you’ve probably run into NULL values. They can be a bit tricky, like trying to solve a puzzle with a missing piece. In SQL, NULL means “unknown” or “missing,” and it can make your queries behave in unexpected ways if you’re not careful. In this article, I’ll walk you through what NULL values are, share some best practices for handling them, and point out common pitfalls to avoid—all in simple, human terms. Let’s get started!

What Is NULL in SQL?

In SQL, NULL is not zero, an empty string, or a blank space. It’s a special marker that indicates a value is missing or unknown. For example, if a customer’s phone number is NULL in a database, it doesn’t mean their phone number is “0” or “”; it means you don’t know their phone number at all.

NULL values pop up in real-world scenarios all the time:

A user skips an optional field in a form (like “Middle Name”).
Data is missing due to incomplete imports.
A calculation can’t produce a result (like dividing by zero).

The trick with NULL is that it doesn’t behave like other values. It can trip you up in comparisons, calculations, and joins if you’re not prepared. Let’s explore how to handle it right.

Best Practices for Handling NULL Values

Here are some practical tips to work with NULL values effectively:

1. Use IS NULL and IS NOT NULL for Comparisons

You can’t use = or != to check for NULL because NULL isn’t a value—it’s the absence of one. Instead, use IS NULL or IS NOT NULL.

Suppose you have a Customers table with a Phone column, and you want to find customers without a phone number:

SELECT Name
FROM Customers
WHERE Phone IS NULL;

This query finds all customers where the Phone column is NULL. Using WHERE Phone = NULL won’t work—it’ll return nothing because NULL doesn’t equal anything, not even itself!

2. Handle NULL in Calculations with COALESCE or NULLIF

NULL can mess up calculations. For example, if you add a number to NULL (like 5 + NULL), the result is NULL. To avoid this, use the COALESCE function, which returns the first non-NULL value in a list.

Imagine a Sales table with a Discount column that’s sometimes NULL. To calculate the final price, you can treat NULL as 0:

SELECT Product, Price - COALESCE(Discount, 0) AS FinalPrice
FROM Sales;

Here, COALESCE(Discount, 0) replaces NULL with 0, so the calculation works.

Another handy function is NULLIF. It returns NULL if two values are equal, which is useful for avoiding errors like division by zero.

SELECT Amount / NULLIF(Divisor, 0) AS Result
FROM Calculations;

If Divisor is 0, NULLIF turns it into NULL, preventing a division error.

3. Be Careful with Joins

NULL values in join columns can cause rows to disappear. For example, in an INNER JOIN, if the joining column has NULL in one table, those rows won’t match and will be excluded.

You have a Customers table and an Orders table, joined on CustomerID. If CustomerID is NULL in either table, those rows won’t appear in an INNER JOIN:

SELECT Customers.Name, Orders.OrderID
FROM Customers
INNER JOIN Orders
ON Customers.CustomerID = Orders.CustomerID;

To include rows with NULL values, consider using a LEFT JOIN or RIGHT JOIN and handle NULL explicitly in your WHERE clause.

4. Use Default Values When Inserting Data

To avoid NULL values in the first place, set default values for columns when creating tables or inserting data. This ensures there’s always a meaningful value.

When creating a table, you can set a default:

CREATE TABLE Employees (
    EmployeeID INT,
    Name VARCHAR(50),
    Phone VARCHAR(15) DEFAULT 'Not Provided'
);

Now, if no phone number is provided during an INSERT, the value will be “Not Provided” instead of NULL.

5. Filter NULLs in Aggregations

Aggregate functions like SUM, AVG, or COUNT ignore NULL values, which can be good or bad depending on your goal. For example, COUNT(column) only counts non-NULL values, while COUNT(*) counts all rows.

In a Sales table, to count how many sales have a discount:

SELECT COUNT(Discount) AS DiscountedSales
FROM Sales;

This skips NULL values. If you want to count all rows, including those with NULL:

SELECT COUNT(*) AS TotalSales
FROM Sales;

Common Pitfalls to Avoid

NULL values can lead to some classic mistakes. Here’s what to watch out for:

1. Assuming NULL Equals Something

As mentioned, NULL = NULL is not true in SQL. Always use IS NULL or IS NOT NULL. If you write WHERE column = NULL, you’ll get no results, even if NULL values exist.

Fix:

-- Wrong
SELECT * FROM Customers WHERE Phone = NULL;

-- Correct
SELECT * FROM Customers WHERE Phone IS NULL;

2. Forgetting NULL in Logical Conditions

In SQL, NULL in logical expressions (like AND, OR, NOT) can lead to unexpected results. For example:

TRUE AND NULL = NULL
FALSE AND NULL = FALSE
TRUE OR NULL = TRUE
FALSE OR NULL = NULL

This can affect your WHERE clauses. Always test queries with NULL values to ensure they behave as expected.

SELECT Name
FROM Customers
WHERE Phone = '123-456-7890' OR Phone IS NULL;

This ensures you catch both specific phone numbers and NULL values.

3. Ignoring NULL in Joins

If you’re not careful, an INNER JOIN might exclude rows with NULL in the joining column. Always check your data to see if NULL values exist in key columns, and consider using LEFT JOIN or RIGHT JOIN if you need to include them.

4. Overusing NULL

While NULL is useful for representing missing data, overusing it can make your database harder to work with. If a column rarely needs to be NULL, consider using a default value instead, like an empty string or 0.

A Real-World Scenario

Let’s say you’re managing an online store’s database with a Products table that includes a Stock column. Some products haven’t had their stock counted yet, so Stock is NULL. You want to list all products and show their stock, with 0 for uncounted products:

SELECT ProductName, COALESCE(Stock, 0) AS AvailableStock
FROM Products;

This query replaces NULL with 0, making the output clear and usable for reports.

Wrapping Up

Handling NULL values in SQL is all about understanding what they mean and using the right tools to manage them. Stick to IS NULL for comparisons, use COALESCE or NULLIF for calculations, and be mindful of joins and aggregations. By setting default values and testing your queries, you can avoid common pitfalls and keep your data clean.

Best Programming Language to Learn in 2026 and Why?

Shariful Ehasan — Mon, 21 Jul 2025 13:26:24 +0000

Choosing the right programming language is becoming both more important and more difficult. Whether you're a beginner trying to get started or an experienced developer looking to stay ahead of the curve, the language you invest time in learning can significantly shape your future in tech.

🚀 Some things to consider:

AI and machine learning are exploding — will Python keep its crown, or will new players emerge?
Web development is always in motion — can JavaScript maintain its dominance, or will frameworks and alternatives (like TypeScript, Bun, or even WebAssembly) take the lead?
Systems and backend programming are seeing strong growth — will Rust or Go become the next big thing in performance-critical or cloud-native apps?
Mobile development is changing — where do Flutter (Dart), Kotlin, or Swift stand?
Could a new or lesser-known language rise to prominence by solving modern problems better than today’s popular ones?

💡 Questions to spark ideas:

Which language are you currently learning or planning to learn in 2026?
What do you think employers will be looking for?
Are there languages that are underrated today but could explode in popularity?
How much do things like community support, learning curve, or tooling matter in your decision?

👥 Let’s crowdsource insights from developers across the world.
Whether you’re a student, freelancer, software engineer, or hobbyist, your perspective can help others make an informed choice.

Drop your thoughts below 👇

5 Useful VS Code Extensions for PHP Development

Shariful Ehasan — Sat, 19 Jul 2025 14:40:03 +0000

Visual Studio Code (VS Code) is a favorite among PHP developers because it’s lightweight, customizable, and packed with extensions that can supercharge your workflow. Whether you’re building a simple website or a complex Laravel application, the right extensions can make coding faster, cleaner, and more enjoyable. Here are five must-have VS Code extensions for PHP development that will boost your productivity and make your code shine.

1. PHP Intelephense

What it does: PHP Intelephense is a powerful extension that provides intelligent code completion, real-time error checking, and navigation features like "go to definition" and "find references." It’s like having a smart assistant that understands your PHP code.

Why it’s great: It speeds up coding with accurate suggestions for functions, classes, and variables, even in large projects. It also highlights syntax errors as you type, helping you catch mistakes early. The free version is solid, but the paid version ($12 lifetime license) adds advanced features like symbol renaming.

Pro tip: Disable VS Code’s built-in PHP suggestions to avoid duplicate completions. In settings.json, add: "php.suggest.basic": false.

2. PHP Debug

What it does: This extension integrates Xdebug into VS Code, allowing you to set breakpoints, inspect variables, and step through your PHP code to find and fix bugs.

Why it’s great: Debugging with var_dump() or die() is a hassle. PHP Debug lets you pause execution, check variable values, and trace your code’s flow right in the editor. It’s a game-changer for troubleshooting complex logic in frameworks like Laravel or Symfony.

Pro tip: Ensure Xdebug is installed on your server and configure the php.validate.executablePath in VS Code to point to your PHP executable.

3. PHP CS Fixer

What it does: PHP CS Fixer automatically formats your PHP code to follow standards like PSR-2 or PSR-12, ensuring consistency and readability.

Why it’s great: Clean, standardized code is easier to read and maintain, especially in team projects. This extension can format your code on save, fixing things like indentation, spacing, and brace placement automatically.

Pro tip: Install PHP CS Fixer globally via Composer (composer global require friendsofphp/php-cs-fixer) and enable format-on-save in VS Code: "editor.formatOnSave": true.

4. Laravel Blade Snippets

What it does: For Laravel developers, this extension provides snippets and auto-completion for Blade templates, Laravel’s templating engine.

Why it’s great: It speeds up writing Blade views with shortcuts for common directives like @foreach, @if, and @section. It also includes syntax highlighting and formatting, making your templates easier to work with.

Pro tip: Combine this with the Laravel Artisan extension to run Artisan commands directly from VS Code for a seamless Laravel workflow.

5. PHP DocBlocker

What it does: PHP DocBlocker simplifies adding PHPDoc comments to your functions, classes, and properties, generating documentation blocks with a single keypress.

Why it’s great: Well-documented code is crucial for collaboration and maintenance. This extension auto-generates @param, @return, and other tags, saving you time and ensuring your code is clear to others (or your future self!).

Pro tip: Press /** above a function and hit Enter to let PHP DocBlocker generate a complete docblock template.

Wrapping Up

These five extensions PHP Intelephense, PHP Debug, PHP CS Fixer, Laravel Blade Snippets, and PHP DocBlocker turn VS Code into a powerhouse for PHP development. They help you write cleaner code, debug faster, and streamline your workflow, whether you’re working on vanilla PHP or a Laravel project. Install them from the VS Code Marketplace, tweak their settings to fit your needs, and watch your productivity soar. Happy coding!

How Do You Manage PHP Dependencies Effectively in Your Projects?

Shariful Ehasan — Sun, 13 Jul 2025 19:37:04 +0000

Managing dependencies is one of the most critical parts of building reliable, maintainable PHP applications. Whether you’re developing a Laravel-based web app, a WordPress plugin, or a custom PHP project from scratch, how you manage your dependencies can make or break your development workflow.

Most of us use Composer, PHP’s standard dependency manager, but effective dependency management goes beyond just running composer install or composer update.

Do you lock specific versions, or allow flexibility with ^ and ~ operators?
How do you avoid dependency conflicts when integrating multiple third-party packages?
Do you regularly audit your dependencies for security vulnerabilities (e.g., using composer audit, or external tools)?

Whether you're a solo developer or part of a large team, managing dependencies effectively is essential to keeping your codebase healthy and maintainable in the long run.

Let’s share tips, horror stories, and best practices to help each other improve!

👇 Drop your insights and strategies in the comments!

Using CSS Subgrid to Simplify Complex Layouts

Shariful Ehasan — Sun, 13 Jul 2025 05:27:25 +0000

Creating complex layouts with CSS Grid is awesome, but aligning nested elements—like items inside a grid cell—can get tricky. That’s where CSS Subgrid comes in. It lets child elements inherit the grid lines of their parent, making it easier to keep everything aligned. Let’s explore how Subgrid works and build a practical example to see it in action.

What is CSS Subgrid?

CSS Subgrid is an extension of CSS Grid. It allows a nested grid (inside a grid item) to use the same grid lines as its parent grid. This means you don’t have to redefine column or row sizes for child elements—they just follow the parent’s structure. It’s perfect for things like card layouts, product listings, or dashboards where nested content needs to stay perfectly aligned.

Why Use Subgrid?

Consistency: Child elements align perfectly with the parent grid, no matter how complex the layout.

Less Code: You don’t need extra CSS or media queries to match sizes.

Responsive: Subgrid adapts to the parent grid’s responsive settings automatically.

A Simple Example: Product Listing

Let’s create a product listing with cards that have aligned titles, prices, and buttons, even though each card has nested content. We’ll use Subgrid to keep everything neat.

HTML Structure

We’ll have a parent grid for the product cards, and each card will have its own grid for internal content (like title, price, and button).

<div class="grid-container">
  <div class="card">
    <h2>Product One</h2>
    <p class="price">$29.99</p>
    <button>Add to Cart</button>
  </div>
  <div class="card">
    <h2>Product Two</h2>
    <p class="price">$49.99</p>
    <button>Add to Cart</button>
  </div>
  <div class="card">
    <h2>Product Three</h2>
    <p class="price">$19.99</p>
    <button>Add to Cart</button>
  </div>
</div>

CSS with Subgrid

Here’s how we set up the parent grid and use Subgrid for the cards.

/* Parent grid */
.grid-container {
  display: grid;
  grid-template-columns: repeat(3, 1fr); /* 3 equal columns */
  gap: 20px;
  padding: 20px;
  max-width: 1200px;
  margin: 0 auto;
}

/* Each card is a grid item with its own grid */
.card {
  display: grid;
  grid-template-rows: auto auto 1fr; /* Rows for title, price, button */
  gap: 10px;
  padding: 15px;
  border: 1px solid #ddd;
  border-radius: 8px;
  /* Inherit the parent's column structure */
  grid-template-columns: subgrid;
  grid-column: span 1; /* Each card takes one column of the parent */
}

/* Style the card content */
.card h2 {
  font-size: 1.5rem;
  margin: 0;
}

.card .price {
  font-size: 1.2rem;
  color: #2ecc71;
}

.card button {
  padding: 10px;
  background: #3498db;
  color: white;
  border: none;
  border-radius: 4px;
  cursor: pointer;
}

.card button:hover {
  background: #2980b9;
}

What’s Happening Here?

Parent Grid: The .grid-container sets up a 3-column grid with grid-template-columns: repeat(3, 1fr).
Subgrid: Each .card uses display: grid and grid-template-columns: subgrid, so it inherits the parent’s column structure. This ensures all cards align perfectly with the parent grid’s columns.
Rows in Cards: We define rows with grid-template-rows: auto auto 1fr to organize the title, price, and button vertically.
Responsive: Since the cards inherit the parent’s columns, they’ll adjust automatically if the parent grid changes (e.g., with media queries).

Output

Making It Responsive

Let’s add a media query to make the layout stack on smaller screens.

@media (max-width: 768px) {
  .grid-container {
    grid-template-columns: 1fr; /* Stack cards in one column */
  }
}

With Subgrid, the cards will still align perfectly because they inherit the parent’s single-column layout. No need to tweak the card’s internal grid!

Benefits of This Approach

Alignment: The title, price, and button in each card line up across all cards, even if their content varies in length.
Simplicity: No need to manually set column widths or use extra divs to force alignment.
Flexibility: You can easily change the parent grid (e.g., from 3 columns to 2 or 1), and the cards adapt without extra CSS.

Browser Support

Subgrid is supported in all modern browsers (Chrome, Firefox, Safari, Edge) as of 2025. For older browsers, you can use a fallback like regular CSS Grid or Flexbox. For example:

/* Fallback for browsers without Subgrid */
@supports not (grid-template-columns: subgrid) {
  .card {
    grid-template-columns: 1fr; /* Simple single-column fallback */
  }
}

Try It Out!

Subgrid is a game-changer for layouts with nested content. Try tweaking the example above—maybe add more columns, adjust the gaps, or style the cards differently. You can also experiment with Subgrid for rows by using grid-template-rows: subgrid if your parent grid defines rows.

DEV Community: Shariful Ehasan

Laravel PDF Generator: Comparing Two Popular Packages

Spatie Laravel PDF – Modern PDF Generation with Browser Accuracy

Key Features of Spatie Laravel PDF:

Laravel DomPDF – Simple and Lightweight PDF Generation

Conclusion

Git Stash Made Simple: Save Your Work Without Committing

How It Works

@auth vs @if(auth()->check()) - which one are you still writing and why?

The Old Way: @if(auth()->check())

The Right Way: @auth and @guest

Real Navigation Example (What Every App Has)

When You Actually Need @if(auth()->check())

The Hybrid Pattern Everyone Actually Uses

Final Recommendation

Laravel Eloquent’s create() Methods

Tips

Laravel Policies: Do You Really Use Them in Real Projects?

What Are Laravel Policies?

Why Use Policies in Real Projects?

When Are Policies Overkill?

Real-World Usage

Tips for Using Policies Effectively

Conclusion

How AI Empowers Programmers

1. Writing Code Faster with AI Assistants

2. Debugging with Precision

3. Learning and Documentation Made Easy

4. Automating Repetitive Tasks

5. Enhancing Collaboration

6. Boosting Creativity and Problem-Solving

7. Staying Updated with Trends

8. Ethical and Secure Coding

Challenges to Watch Out For

Final Thoughts

How Do You Structure Complex Queries Using Laravel’s Query Builder?

How do you manage and structure complex queries using Laravel’s Query Builder?

Handling NULL Values in SQL: Best Practices and Common Pitfalls

What Is NULL in SQL?

Best Practices for Handling NULL Values

1. Use IS NULL and IS NOT NULL for Comparisons

2. Handle NULL in Calculations with COALESCE or NULLIF

3. Be Careful with Joins

4. Use Default Values When Inserting Data

5. Filter NULLs in Aggregations

1. Assuming NULL Equals Something

2. Forgetting NULL in Logical Conditions

3. Ignoring NULL in Joins

4. Overusing NULL

A Real-World Scenario

Wrapping Up

Best Programming Language to Learn in 2026 and Why?

🚀 Some things to consider:

💡 Questions to spark ideas:

5 Useful VS Code Extensions for PHP Development

1. PHP Intelephense

2. PHP Debug

3. PHP CS Fixer

4. Laravel Blade Snippets

5. PHP DocBlocker

Wrapping Up

How Do You Manage PHP Dependencies Effectively in Your Projects?

Using CSS Subgrid to Simplify Complex Layouts

What is CSS Subgrid?

Why Use Subgrid?

HTML Structure

CSS with Subgrid

Benefits of This Approach

Browser Support

Try It Out!

The Old Way: `@if(auth()->check())`

The Right Way: `@auth` and `@guest`

When You Actually Need `@if(auth()->check())`