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:

1. Newsletter Management - Import subscribers, organize by interests with tags
2. Event Invitations - Send bulk invites, then individual follow-ups
3. Customer Support - Organize customers by product, send targeted updates
4. Marketing Campaigns - Segment audiences with tags, track engagement
5. 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! 👇

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.

Table of Contents

1. What is dbdiagram.io?
2. Why Use dbdiagram.io?
3. Supported Syntax & Importing From Tools
4. Let’s Design a Real Example – Blog System Schema
5. Exporting SQL Scripts
6. Collaboration & Sharing
7. Tips for Better Schema Design
8. 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.

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

Table of Contents

1. withWhereHas() – Filter and Eager Load in One Query
2. cursorPaginate() – Paginate Large Datasets Efficiently
3. sole() – Ensure Only One Record Exists
4. upsert() – Insert or Update Multiple Rows at Once
5. lazy() – Loop Through Big Data Without Memory Issues
6. findMany() – Fetch Multiple Records Easily
7. whereBelongsTo() – Query Using a Model Instance
8. is() – Compare Models Safely
9. firstOrCreate() and updateOrCreate() – Atomic Record Handling
10. 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

Set up a model to work with

Let’s use a simple User model and the interface of a repository, we don’t really need the details here. But let’s assume we have some assertion library that we use to validate that every model created is valid.

class User
{
    public function __construct(
        public string $email,
        public string $name,
        public string $password,
    ) {
        Assert::email($email);
        Assert::notEmpty($name);
        Assert::password($password, strength: 3);
    }
}
interface UserRepository
{
    public function save(User $user): void;
}

So main use case, we get data for a new user, it validates that the name is not empty, the email is a valid email and that the password complies with whatever we defined as strength level 3. Then we send it to the repository and save it. Job done.

$user = new User(
    $request->get('email'),
    $request->get('name'),
    $request->get('password'),
);
$repository->save($user);

Problem: Model properties that should not be read

So now we want to read a user by email from the database to return a json representation of it for a client to present some user profile. What happens if we add a read method to our repository reusing the same model?

interface UserRepository
{
    public function save(User $user): void;
    public function get(string $email): User;
}
// Inside some controller class
return new Response(
    json_encode(
        $repository->get($request->get('email'))
    ),
);

So what are we getting here?

{
  "email": "peter@dailybugle.com",
  "name": "Peter Parker",
  "password": "$2y$10$OEaTphGkW0HQv4QNxtptQOE.BSQDnpwrB.\/VGqIgjMEhvIr22jnFK"
}

The first thing that should cross our minds when we watch this is that passwords, even encrypted, should never, ever be sent in any kind of communication from the server. So this is an important security concern.

Even if this is probably the worst possible case of an information leak caused by using a write model as a read model, it’s not the only one. Another common issue is just sending irrelevant information to the client. For example, we could have an active boolean we can use for enabling or disabling users that would be useless for the client, because if the user is not active the request will respond with a 404 Not Found. Irrelevant data means that we are sending bytes that will never be consumed, hurting performance. It may be little, but everything adds and this has an easy solution.

So what do we do? Provide a return with a restricted list of data? This could solve these problems.

class User
{
    // ...

    public function read(): array
    {
        return [
            'email' => $this->email,
            'name' => $this->name,
        ];
    }
}

But there are more issues to solve, let’s see.

Problem: Unnecessary validations

Talking about performance, we have validations in the model constructor, but are those needed when we fetch data that is already in the database? They must have been valid the moment they were stored, so it can be argued that running those validations again is a waste.

But not only a waste, it can be a real problem. Validations might evolve and that can impact the ability to fetch results if we use a write model which makes use of validations. Suppose an application that validates that emails for users have a valid email format, but at some point another rule is added to blacklist some domains in email addresses. The validation is updated, but the existing users can’t really be updated, because they still expect communications via that email address.

Now we get a request for a list of 100 users in which one of them has a blacklisted domain, what happens? The whole request is considered an error. And what do we send the user? A 400 Bad Request response like if some user input was wrong? This is not the client’s fault but the server’s. In this case it should be some kind of 500 error.

To avoid this, I’ve seen some complex solutions involving Reflection and an instance without constructor. If we really had to use the write model in cases we don’t want to validate I would move the assertions to a static constructor though, like this.

class User
{
    public function __construct(
        public string $email,
        public string $name,
        public string $password,
    ) {}

    public static function create(string $email, string $name, string $password): self
    {
        Assert::email($email);
        Assert::notEmpty($name);
        Assert::password($password, strength: 3);

        return new self($email, $name, $password);
    }
}

This way, when creating a new model that requires validation I can do User::new(), and use the constructor when fetching data from the database. Solves some issues, but there are more.

Problem: Adding extra data to the model

Another common situation is the client requiring some more data for the view. In our example, the view might need to show the number of comments that a user has created in the system. That’s not part of the model, but it looks wasteful not to add that in the same HTTP response and keep the client waiting for a second one just because the data does not match the write model.

Even if we try to add the data in the same request, sticking to this write model means that we can’t use a single database request to get the whole set of data, though in many cases that could be solved with a simple SQL join. Instead we get the write model and then do another database request to fetch the missing data, and compose it before sending it to the client.

return new Response(
    json_encode(
        array_merge(
            $repository->get($request->get('email')),
            ['comments' => $commentRepository->count($request->get('email'))]
        )

    ),
);

It works, but it means an extra database query with it’s impact in the performance. And it also hurts re-usability, as you can’t just call the repository somewhere else, you also need to copy and paste the comments part.

Problem: Are inserts and updates really the same?

For a last problem, this is not really a write vs read model, but when we are updating a model, can we really use the same class that we use when creating it?

So if we create a new user with this model, we expect name, email and password. For creating a user that’s ok, but in our example our security expert requires that passwords are updated in a specific way, which involves the user requesting a password change, an email being sent to the user with a limited time token and then validating that token to accept the new password.

The password should never be updated in any other way, so what do we do if we use the same model we already have for updating the user? We will have two different places in the code where we update the user, one for password, another for anything else.

interface UserRepository
{
    public function save(User $user): void;
    public function update(User $user): void;
}
// Updating name
$user = new User(
    $request->get('email'),
    $request->get('name'),
    'WHAT DO WE DO WITH PASSWORD HERE?',
);

$repository->update($user);
// Updating password
$user = new User(
    $request->get('email'),
    'WHAT DO WE DO WITH NAME HERE?',
    $request->get('password'),
);

$repository->update($user);

Now we have to deal with data in the model that must not be processed, which will make our repository implementation unnecessarily more complex. It will also force the model creation to provide data that will not be available and will not be used, making code much harder to understand. And finally, we introduce a fragile implementation that, if used incorrectly, can cause the update of something that should not be updated, just because it is in the model. If we process the user name change in a way that triggers a password update, that’s a serious problem.

Solution: Individual model for each case

How can we solve all the problems when reading a user? A dedicated model will do.

final readonly class UserRead
{
    public function __construct(
        public string $email,
        public string $name,
        public int $commentCount,
    ) {}
}

We can have another repository to fetch it.

interface UserReadRepository
{
    public function get(string $email): UserRead;
}

This implementation, assuming a relational SQL database, would not select the password form the table which is not in the read model, solving problem number 1. This read model does not include validations solving problem number 2. And this model has a place for the comments count that can be implemented in the new repository by using a join in a single query, solving problem number 3.

Even more, if we have more representations of a user, we should have a different read model to cover each one. We could have a UserWithLastCommentsRead for example.

And for the update problems? You probably guessed. Individual models for each update.

final readonly class UserDataUpdate
{
    public function __construct(
        public string $email,
        public string $name,
    ) {
        Assert::notEmpty($name);
    }
}
final readonly class UserPasswordUpdate
{
    public function __construct(
        public string $email,
        public string $password,
    ) {
        Assert::password($password, strength: 3);
    }
}
interface UserRepository
{
    public function save(User $user): void;
    public function updateData(UserDataUpdate $userDataUpdate): void;
    public function updatePassword(UserPasswordUpdate $userPasswordUpdate): void;
}

Now there are no mistakes or unnecessary data. Each update is isolated and it is much more protected from bugs.

Note that in the update models I didn’t add the email validation. That is intentional because it is going to be used to find the user, and if we have an evolved validation, as commented before, we would not be able to find older users with emails that are not valid anymore, but still in the database anyways.

Last words

This is really not that different as we model objects in the real world. We never consider everything about a real life object in a particular context. For example a car.

If a car is modeled by a driver, we can expect the positioning of the seat and the rear mirrors to be really important, while at the same time it is irrelevant for a mechanic doing some maintenance. The mechanic will probably be more concerned about metrics on the engine that are not important to the driver. And a kid at the school learning about transport methods will probably just care about it being a land transport with 4 wheels.

If we use different models for the same real life objects we can definitely do the same for our code models.

Traditionally, setting up AI models involves a series of complex steps, including purchasing GPUs, installing drivers, configuring networks and storage, setting up environments, and downloading models. With this integration, developers can bypass these hurdles, streamlining the process significantly.

Industry expert Liu Dingding highlighted the significance of this development for startups, noting that it provides a seamless, ready-to-use AI solution. "Since users no longer need technical expertise or deal with hardware procurement, they can concentrate on leveraging AI for their business applications," Liu stated. He also emphasized that this move reflects a growing trend of collaboration among Chinese tech firms, fostering a cooperative environment in the competitive tech landscape.

This announcement follows closely on the heels of Huawei's recent launch of the DeepSeek R1/V3 inference service on its cloud platform. Huawei claims that models deployed on its platform can achieve performance comparable to global high-end graphics processing unit (GPU) models.

DeepSeek has been gaining global recognition for its groundbreaking AI capabilities. Many international tech companies, including U.S.-based GPU maker Nvidia, are integrating DeepSeek into their platforms, acknowledging its technological prowess. Notably, DeepSeek's AI assistant recently became the most downloaded mobile AI app across 140 markets, with India leading in new user adoption.

However, it's worth noting that some countries have recently moved to block the Chinese AI platform, citing "security concerns."

The collaboration between Tencent Cloud and DeepSeek marks a significant step in making advanced AI solutions more accessible to developers, particularly benefiting startups and small enterprises. This partnership not only streamlines the deployment process but also exemplifies the increasing cooperation among Chinese tech companies in the global AI arena.

Set up a model to work with

Let’s use a simple User model and the interface of a repository, we don’t really need the details here. But let’s assume we have some assertion library that we use to validate that every model created is valid.

class User
{
    public function __construct(
        public string $email,
        public string $name,
        public string $password,
    ) {
        Assert::email($email);
        Assert::notEmpty($name);
        Assert::password($password, strength: 3);
    }
}

interface UserRepository
{
    public function save(User $user): void;
}

So main use case, we get data for a new user, it validates that the name is not empty, the email is a valid email and that the password complies with whatever we defined as strength level 3. Then we send it to the repository and save it. Job done.

$user = new User(
    $request->get('email'),
    $request->get('name'),
    $request->get('password'),
);

$repository->save($user);

Problem: Model properties that should not be read

So now we want to read a user by email from the database to return a json representation of it for a client to present some user profile. What happens if we add a read method to our repository reusing the same model?

interface UserRepository
{
    public function save(User $user): void;
    public function get(string $email): User;
}

// Inside some controller class
return new Response(
    json_encode(
        $repository->get($request->get('email'))
    ),
);

So what are we getting here?

{
  "email": "gulzaib@test-email.com",
  "name": "Gulzaib",
  "password": "$2y$10$OEaTphGkW0HQv4QNxtptQOE.BSQDnpwrB.\/VGqIgjMEhvIr22jnFK"
}

The first thing that should cross our minds when we watch this is that passwords, even encrypted, should never, ever be sent in any kind of communication from the server. So this is an important security concern.

Even if this is probably the worst possible case of an information leak caused by using a write model as a read model, it’s not the only one. Another common issue is just sending irrelevant information to the client. For example, we could have an active boolean we can use for enabling or disabling users that would be useless for the client, because if the user is not active the request will respond with a 404 Not Found. Irrelevant data means that we are sending bytes that will never be consumed, hurting performance. It may be little, but everything adds and this has an easy solution.

So what do we do? Provide a return with a restricted list of data? This could solve these problems.

class User
{
    // ...

    public function read(): array
    {
        return [
            'email' => $this->email,
            'name' => $this->name,
        ];
    }
}

But there are more issues to solve, let’s see.

Problem: Unnecessary validations

Talking about performance, we have validations in the model constructor, but are those needed when we fetch data that is already in the database? They must have been valid the moment they were stored, so it can be argued that running those validations again is a waste.

But not only a waste, it can be a real problem. Validations might evolve and that can impact the ability to fetch results if we use a write model which makes use of validations. Suppose an application that validates that emails for users have a valid email format, but at some point another rule is added to blacklist some domains in email addresses. The validation is updated, but the existing users can’t really be updated, because they still expect communications via that email address.

Now we get a request for a list of 100 users in which one of them has a blacklisted domain, what happens? The whole request is considered an error. And what do we send the user? A 400 Bad Request response like if some user input was wrong? This is not the client’s fault but the server’s. In this case it should be some kind of 500 error.

To avoid this, I’ve seen some complex solutions involving Reflection and an instance without constructor. If we really had to use the write model in cases we don’t want to validate I would move the assertions to a static constructor though, like this.

class User
{
    public function __construct(
        public string $email,
        public string $name,
        public string $password,
    ) {}

    public static function create(string $email, string $name, string $password): self
    {
        Assert::email($email);
        Assert::notEmpty($name);
        Assert::password($password, strength: 3);

        return new self($email, $name, $password);
    }
}

This way, when creating a new model that requires validation I can do User::new(), and use the constructor when fetching data from the database. Solves some issues, but there are more.

Problem: Adding extra data to the model

Another common situation is the client requiring some more data for the view. In our example, the view might need to show the number of comments that a user has created in the system. That’s not part of the model, but it looks wasteful not to add that in the same HTTP response and keep the client waiting for a second one just because the data does not match the write model.

Even if we try to add the data in the same request, sticking to this write model means that we can’t use a single database request to get the whole set of data, though in many cases that could be solved with a simple SQL join. Instead we get the write model and then do another database request to fetch the missing data, and compose it before sending it to the client.

return new Response(
    json_encode(
        array_merge(
            $repository->get($request->get('email')),
            ['comments' => $commentRepository->count($request->get('email'))]
        )

    ),
);

It works, but it means an extra database query with it’s impact in the performance. And it also hurts re-usability, as you can’t just call the repository somewhere else, you also need to copy and paste the comments part.

Problem: Are inserts and updates really the same?

For a last problem, this is not really a write vs read model, but when we are updating a model, can we really use the same class that we use when creating it?

So if we create a new user with this model, we expect name, email and password. For creating a user that’s ok, but in our example our security expert requires that passwords are updated in a specific way, which involves the user requesting a password change, an email being sent to the user with a limited time token and then validating that token to accept the new password.

The password should never be updated in any other way, so what do we do if we use the same model we already have for updating the user? We will have two different places in the code where we update the user, one for password, another for anything else.

interface UserRepository
{
    public function save(User $user): void;
    public function update(User $user): void;
}

// Updating name
$user = new User(
    $request->get('email'),
    $request->get('name'),
    'WHAT DO WE DO WITH PASSWORD HERE?',
);

$repository->update($user);

// Updating password
$user = new User(
    $request->get('email'),
    'WHAT DO WE DO WITH NAME HERE?',
    $request->get('password'),
);

$repository->update($user);

Now we have to deal with data in the model that must not be processed, which will make our repository implementation unnecessarily more complex. It will also force the model creation to provide data that will not be available and will not be used, making code much harder to understand. And finally, we introduce a fragile implementation that, if used incorrectly, can cause the update of something that should not be updated, just because it is in the model. If we process the user name change in a way that triggers a password update, that’s a serious problem.

Solution: Individual model for each case

How can we solve all the problems when reading a user? A dedicated model will do.

final readonly class UserRead
{
    public function __construct(
        public string $email,
        public string $name,
        public int $commentCount,
    ) {}
}

We can have another repository to fetch it.

interface UserReadRepository
{
    public function get(string $email): UserRead;
}

This implementation, assuming a relational SQL database, would not select the password form the table which is not in the read model, solving problem number 1. This read model does not include validations solving problem number 2. And this model has a place for the comments count that can be implemented in the new repository by using a join in a single query, solving problem number 3.

Even more, if we have more representations of a user, we should have a different read model to cover each one. We could have a UserWithLastCommentsRead for example.

And for the update problems? You probably guessed. Individual models for each update.

final readonly class UserDataUpdate
{
    public function __construct(
        public string $email,
        public string $name,
    ) {
        Assert::notEmpty($name);
    }
}

final readonly class UserPasswordUpdate
{
    public function __construct(
        public string $email,
        public string $password,
    ) {
        Assert::password($password, strength: 3);
    }
}

interface UserRepository
{
    public function save(User $user): void;
    public function updateData(UserDataUpdate $userDataUpdate): void;
    public function updatePassword(UserPasswordUpdate $userPasswordUpdate): void;
}

Now there are no mistakes or unnecessary data. Each update is isolated and it is much more protected from bugs.

Note that in the update models I didn’t add the email validation. That is intentional because it is going to be used to find the user, and if we have an evolved validation, as commented before, we would not be able to find older users with emails that are not valid anymore, but still in the database anyways.

Last words

This is really not that different as we model objects in the real world. We never consider everything about a real life object in a particular context. For example a car.

If a car is modeled by a driver, we can expect the positioning of the seat and the rear mirrors to be really important, while at the same time it is irrelevant for a mechanic doing some maintenance. The mechanic will probably be more concerned about metrics on the engine that are not important to the driver. And a kid at the school learning about transport methods will probably just care about it being a land transport with 4 wheels.

If we use different models for the same real life objects we can definitely do the same for our code models.

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.

Table of Contents

1. The Importance of OOP in PHP
2. Setting Up the Project
3. Creating the Database
4. Folder Structure
5. Connecting to the Database
6. Creating CRUD Operations
   • Create
   • Read
   • Update
   • Delete
7. 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! 🎉

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.

Table of Contents

1. What is Unit Testing?
2. Why Unit Testing is Important
3. Setting Up Unit Testing in Laravel
4. Writing Your First Unit Test
5. Testing Models, Controllers, and Services
6. Running and Interpreting Tests
7. Best Practices for Laravel Unit Testing
8. 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

1. Test Small Units: Focus on small, isolated units of code, like a single method or function.
2. Use Assertions Wisely: Laravel provides many assertion methods, such as assertEquals, assertTrue, and assertCount. Use them to verify expected outcomes.
3. Mock External Dependencies: Use Laravel’s mocking capabilities to simulate database queries or API calls, ensuring tests are independent of external factors.
4. 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 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.

Table of Contents

1. What is Rubix ML?
2. Setting Up the Project
3. Creating the News Classification Class
4. Training the Model
5. Predicting New Samples
6. 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!

Table of Contents

1. What is PSR-12?
2. Why is PSR-12 Important?
3. Key Rules of PSR-12
   • File Structure
   • Namespaces and Use Declarations
   • Classes and Methods
   • Control Structures
   • Comments and Documentation
4. How to Apply PSR-12 in Your PHP Projects
5. Tools to Help You Follow PSR-12
6. Final Thoughts

What is PSR-12?

PSR-12 is a coding style guide for PHP, developed by the PHP-FIG (Framework Interoperability Group). It builds upon the previous PSR-2 standard, providing an updated set of rules that reflect modern PHP practices and improve consistency across codebases.

Think of PSR-12 as the blueprint for writing clean, readable, and maintainable PHP code. By following PSR-12, developers can ensure that their code adheres to a standardized structure, making it easier to collaborate with others and to work on open-source projects.

Why is PSR-12 Important?

Coding standards like PSR-12 aren't just about nitpicking over spaces and tabs. Here’s why they matter:

• Readability: Code that follows a standard style is easier to read, especially for developers new to a project.
• Collaboration: If everyone follows the same rules, working together becomes smoother and more efficient.
• Maintainability: Clean, consistent code is easier to debug, test, and extend over time.
• Interoperability: In open-source projects or when integrating third-party libraries, following a common standard ensures compatibility across different codebases.

Key Rules of PSR-12

Let’s dive into some of the key rules that PSR-12 lays out. While there are many smaller guidelines, here are the ones that stand out the most.

1. File Structure

• Opening Tag: PHP files must use the <?php tag and should not use short tags.
• Encoding: Files must be encoded in UTF-8 without a BOM (Byte Order Mark).
• Line Length: Lines should not be longer than 120 characters, but lines up to 80 characters are preferred.
• Blank Lines: There should be no blank lines after the opening PHP tag or before the closing tag. Additionally, there must be a single blank line before return statements, and between method definitions.

2. Namespaces and Use Declarations

PSR-12 requires that namespaces and use declarations follow a specific order to improve clarity:

• Namespace Declaration: The namespace declaration must be the first line after the opening PHP tag. There must be one blank line after the namespace.
• Use Declarations: All use declarations must be grouped together after the namespace declaration and separated by a blank line. Additionally, there must be one blank line after the last use statement.

Example:

<?php

namespace App\Controllers;

use App\Models\User;
use App\Repositories\UserRepository;

class UserController {
    // Class implementation
}

3. Classes and Methods

PSR-12 enforces some strict rules on how classes, properties, and methods should be declared:

• Class Declaration: The class keyword must be followed by a space, then the class name. Open curly braces { must be placed on the same line as the class declaration, with closing braces } on their own line.
• Properties: Visibility (public, protected, private) must be declared for all properties.
• Methods: Similar to class declarations, the function keyword must be followed by a space, then the method name. Visibility must be declared for all methods.

class UserController {
    private $userRepository;

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

4. Control Structures

Control structures like if, for, and switch must follow certain rules:

• Structure: There must be one space between the control keyword and the opening parenthesis. Curly braces {} must always be used, even for single-line statements.
• Indentation: All blocks inside control structures must be indented by one level (typically four spaces).

if ($user->isAdmin()) {
    echo "User is an admin";
} else {
    echo "User is not an admin";
}

5. Comments and Documentation

Comments are crucial for explaining why certain parts of the code exist. PSR-12 emphasizes the need for proper, clear comments.

• Block Comments: Use /* */ for multi-line comments, and place a blank line before the comment.
• Single-line Comments: Use // for inline comments, and ensure that comments are meaningful.

// Fetch user from the repository
$user = $userRepository->find($id);

/*
 * If user is not found, throw an exception.
 * This helps in handling invalid user IDs.
 */
if (!$user) {
    throw new NotFoundException();
}

How to Apply PSR-12 in Your PHP Projects

To follow PSR-12 in your projects, you can manually adhere to the guidelines when writing code, but the best way to ensure compliance is by using automated tools.

First, get familiar with these general practices:

• Use consistent indentation: Four spaces are required for indentation.
• Limit line length: Try to keep your lines under 120 characters, although 80 characters are preferred for better readability.
• Organize code structure: Follow the rules for class declarations, visibility, and control structures.

Tools to Help You Follow PSR-12

Manually ensuring that your code follows PSR-12 can be time-consuming, but there are tools that can help you automate this process.

1. PHP_CodeSniffer

One of the most popular tools for ensuring your PHP code follows PSR-12 is PHP_CodeSniffer. It analyzes your code and points out where you're deviating from the standard.

To install and use it:

composer require "squizlabs/php_codesniffer=*"

Then, run it against your code:

./vendor/bin/phpcs --standard=PSR12 src/

2. PHP CS Fixer

Another useful tool is PHP CS Fixer. It not only detects issues but can also fix your code to comply with PSR-12 automatically.

composer require friendsofphp/php-cs-fixer

Run the fixer with:

./vendor/bin/php-cs-fixer fix src/

3. PHPStorm

If you use PHPStorm, you can configure it to follow PSR-12. Go to Settings -> Editor -> Code Style -> PHP and set the standard to PSR-12.

Final Thoughts

Following PSR-12 in your PHP projects is about more than just adhering to arbitrary rules. It’s about making your code cleaner, more readable, and easier to maintain—whether you're working alone or with a team. By following PSR-12, you're not just writing code for yourself but for the entire PHP community.

Adopting this standard is a step towards writing professional, consistent, and maintainable PHP code. Use the tools mentioned to make the process easier, and watch how clean and organized your projects become!

Happy coding!

The Laracon US 2024 keynote delivered by Taylor Otwell brought thrilling updates to the Laravel community. Here are the major highlights:

1. Laravel VS Code Extension

One of the most exciting announcements was the introduction of a dedicated Laravel extension for Visual Studio Code. This tool provides built-in features like enhanced autocomplete, inline diagnostics, and intelligent suggestions to speed up development and improve coding accuracy.

2. Concurrency Facade & defer() Helper

A powerful new Concurrency Facade was introduced, allowing developers to handle parallel task execution more efficiently. Alongside this, the new defer() helper will help offload time-consuming tasks to the background, making the app more responsive without complicated setups.

New Defer Helper

New Concurrency Facade

3. Inertia v2.0

Otwell also announced Inertia v2.0, bringing new features like asynchronous requests and prefetching, resulting in faster and more dynamic applications. This version helps developers build modern single-page applications (SPAs) without compromising speed and performance.

4. Laravel Cloud

Perhaps the most groundbreaking announcement was Laravel Cloud, a new platform designed to make app deployment effortless. This platform allows developers to deploy their Laravel applications with minimal configuration while offering built-in scalability and performance optimizations. Laravel Cloud promises to make the deployment process as simple as pushing code to a Git repository.

5. Laravel Echo & WebSockets Updates

The updates also included improvements to Laravel Echo, enhancing real-time communication in applications. This brings better integration with WebSockets and makes it easier to develop applications with real-time features like notifications and live updates.

Conclusion

Laracon US 2024 highlighted Laravel’s continuing evolution, focusing on boosting developer productivity and improving application performance. The new VS Code extension, Concurrency tools, and Inertia v2.0 offer solutions for common development challenges, while Laravel Cloud provides a robust, easy-to-use deployment platform. These updates ensure that Laravel continues to empower developers to build faster, more scalable applications with less complexity.

For a detailed look at the announcements, visit the full article.

In today's fast-paced development world, managing projects and tasks efficiently is crucial for every developer. I'm excited to introduce Task Manager, an open-source project management tool built with Laravel. This tool is inspired by the functionalities of popular platforms like ClickUp and Trello, offering a flexible and user-friendly interface to streamline your project management tasks.

Key Features

Task Manager is designed to enhance your productivity with several key features:

• Project Organization: Easily create and manage multiple projects, and maintain your projects.
• Task Management: Add, edit, delete, and move tasks across different statuses with drag-and-drop functionality.
• Notes and Files: Attach detailed notes and files to your tasks or projects, ensuring you have all the necessary information at your fingertips.
• Reminders and Routines: Set reminders for deadlines and define routine tasks that recur at specified intervals.

Getting Started with Task Manager

Getting started with Task Manager is straightforward. Here’s a quick setup guide:

1. Clone the Repository:

   git clone https://github.com/arafat-web/Task-Manager.git
   cd Task-Manager
   

2. Install Dependencies:

   composer install
   

3. Environment Setup: Duplicate .env.example to .env and fill in your database and mail settings.

4. Generate Application Key:

   php artisan key:generate
   

5. Database Migrations:

   php artisan migrate --seed
   

6. Serve the Application:

   php artisan serve
   

   Access the application at http://localhost:8000.

Credentials

Email: admin@example.com Password: secret

Demo and Screenshots

Explore how Task Manager looks and functions through these screenshots and imagine how it can transform your project management experience.

Dashboard

Projects

Tasks

How to Contribute

Contributions are welcome! If you have improvements or bug fixes, please feel free to fork the repository, make changes, and submit a pull request. For any issues, queries, or suggestions, open an issue on GitHub.

Stay Connected

For more insights and updates, follow me on [LinkedIn] (https://www.linkedin.com/in/arafat-hossain-ar-a174b51a6/), Github, Facebook, and my website.

Table of Contents

1. Introduction
2. Laravel: The Artisan's Choice
   • Why Laravel?
   • Key Features
   • Performance Metrics
   • Use Case
3. Symfony: The Enterprise Powerhouse
   • Why Symfony?
   • Key Features
   • Performance Metrics
   • Use Case
4. CodeIgniter: The Lightweight Contender
   • Why CodeIgniter?
   • Key Features
   • Performance Metrics
   • Use Case
5. Performance Comparison Table
6. Which PHP Framework Reigns Supreme?
7. FAQs

Laravel: The Artisan's Choice

Why Laravel?

Laravel has emerged as one of the most popular PHP frameworks, thanks to its elegant syntax, extensive ecosystem, and vibrant community. It simplifies tasks like routing, authentication, and caching, making development a breeze.

Key Features:

• Eloquent ORM: Laravel's built-in ORM makes database interactions intuitive and efficient.
• Blade Templating Engine: A powerful yet simple templating engine that enhances performance.
• Artisan CLI: Command-line interface for automating repetitive tasks.
• Robust Security: Out-of-the-box protection against common security threats like SQL injection and XSS.

Performance Metrics:

• Execution Speed: Laravel 11 boasts an impressive execution speed, often clocking in at around 50-60 milliseconds per request.
• Response Time: On average, response times hover around 100 milliseconds, making it a responsive choice for dynamic web applications.

Use Case:

Laravel is perfect for applications that require rich features and extensive customization, such as e-commerce platforms and content management systems.

Symfony: The Enterprise Powerhouse

Why Symfony?

Symfony is renowned for its flexibility, scalability, and reusable components, making it a favorite among enterprises and large-scale applications. Its modularity allows developers to pick and choose the components they need, ensuring a tailored solution.

Key Features:

• Modular Architecture: Highly customizable and reusable components.
• Twig Templating Engine: Fast and secure templating system.
• Strong Community: Backed by a large, supportive community and excellent documentation.
• Advanced Security: Comprehensive security features for enterprise-level applications.

Performance Metrics:

• Execution Speed: Symfony 7 shows strong performance with execution speeds around 40-50 milliseconds per request.
• Response Time: Typically, response times are around 90 milliseconds, providing quick interactions for users.

Use Case:

Symfony shines in enterprise environments where robustness and scalability are paramount, such as corporate intranets, large-scale web services, and high-traffic websites.

CodeIgniter: The Lightweight Contender

Why CodeIgniter?

CodeIgniter is celebrated for its simplicity, small footprint, and ease of use. It's an excellent choice for developers seeking a framework with minimal configuration and a lightweight approach.

Key Features:

• Lightweight: Minimal setup with a small footprint.
• Exceptional Performance: Known for its blazing-fast performance.
• Easy Learning Curve: Perfect for beginners due to its straightforward approach.
• Flexibility: Allows developers to use only what they need without heavy dependencies.

Performance Metrics:

• Execution Speed: CodeIgniter 4.5 leads with execution speeds often around 30-40 milliseconds per request.
• Response Time: With response times averaging 70 milliseconds, it offers one of the quickest interactions among PHP frameworks.

Use Case:

Ideal for small to medium-sized applications where performance is crucial, such as lightweight websites and simple APIs.

Performance Comparison Table

To give you a clearer picture, here's a comparative table showcasing the execution speeds and response times of these top PHP frameworks:

Which PHP Framework Reigns Supreme?

Choosing the best PHP framework ultimately depends on your specific needs and project requirements:

• For feature-rich, customizable applications: Laravel is your go-to with its elegant syntax and extensive features.
• For enterprise-level, scalable applications: Symfony's flexibility and robust components make it the top choice.
• For lightweight, high-performance applications: CodeIgniter stands out with its simplicity and speed.

Each framework has its strengths, and understanding these can guide you to the best choice for your next web development project.

FAQs

1. Which PHP framework is the fastest?

   • CodeIgniter typically offers the fastest execution and response times among the top frameworks.

2. Is Laravel suitable for beginners?

   • Yes, Laravel’s intuitive syntax and extensive documentation make it accessible for beginners.

3. Can Symfony handle high-traffic applications?

   • Absolutely, Symfony is designed for scalability and can efficiently manage high-traffic environments.

I'm excited to introduce my latest project, Bulk Email Sender! Managing email communication for your business, events, or personal contacts can be a daunting task. That's why I created Bulk Email Sender, a simple and powerful tool designed to streamline your email outreach efforts.

What is Bulk Email Sender?

Bulk Email Sender is a user-friendly application that enables you to effortlessly send emails to a large audience. Whether you're managing a business, organizing events, or just want to connect with many people, this project simplifies the process of sending bulk emails. Say goodbye to the hassle of managing multiple recipients individually – with Bulk Email Sender, you can import your contacts from an Excel file, design your email template, and send your messages in a matter of clicks.

Technologies Used:

• Laravel 10: Utilizing the latest features and improvements from Laravel for a robust backend.
• PHP 8: Harnessing the power of PHP's latest version for efficient and secure server-side processing.

Key Features:

• Effortless Import: Import email addresses seamlessly from Excel files.
• HTML Email Support: Craft visually appealing emails using HTML templates.
• One-Time Sender: Send your emails with a single click.
• Contribution Friendly: Open-source project on GitHub, welcoming issues and pull requests.

How to Use Bulk Email Sender:

1. Select 'One Time Sender'.
2. Import your contacts from an Excel file.
3. Design your email template using the HTML editor.
4. Click send, and your emails are on their way!

Get Involved:

I invite you to get involved with the Bulk Email Sender project! Whether you find a bug, have a feature request, or want to contribute, your input is valuable. Feel free to create issues or contribute code through pull requests on our GitHub repository.

Conclusion:

Simplify your email communication and enhance your outreach efforts with Bulk Email Sender. It's designed with ease of use in mind, making it accessible for businesses, event organizers, and anyone looking to streamline their email campaigns.

Ready to simplify your email communication? Check out Bulk Email Sender on GitHub and start sending emails effortlessly today!

Happy emailing! 🚀

PHP, a versatile scripting language, offers a range of features to make developers' lives easier. Among these, the foreach loop stands out as a convenient tool for iterating over arrays and objects. However, there's a hidden gem within PHP's foreach loops – the use of the & symbol. In this comprehensive guide, we'll delve into the world of PHP foreach loops and explore how leveraging the & symbol can take your coding skills to the next level.

Understanding PHP Foreach Loops

Before we dive into the specifics of the & symbol, let's revisit the basics of PHP foreach loops. These loops are designed for iterating over arrays and objects, providing a clean and concise way to access and manipulate their elements.

$fruits = ['apple', 'banana', 'cherry'];

foreach ($fruits as $fruit) {
    echo $fruit . ' ';
}
// Output: apple banana cherry

The Power of '&' – Creating References

The & symbol in PHP foreach loops allows us to create references to array elements or object properties rather than working with copies. This distinction can have a profound impact on how you manipulate data within the loop.

$fruits = ['apple', 'banana', 'cherry'];

foreach ($fruits as &$fruit) {
    $fruit = strtoupper($fruit);
}

// $fruits now contains ['APPLE', 'BANANA', 'CHERRY']

Here, we've transformed the original array's elements to uppercase using the reference created with &.

Common Use Cases for '&' in Foreach Loops

While not every loop requires the use of &, there are situations where it can be incredibly useful:

Modifying Array Elements by Reference

$numbers = [1, 2, 3, 4];
foreach ($numbers as &$number) {
    $number *= 2;
}
// $numbers becomes [2, 4, 6, 8]

Creating Dynamic References

$variables = ['var1', 'var2', 'var3'];
foreach ($variables as $varName) {
    $$varName = 'initialized';
}
// $var1, $var2, and $var3 are now initialized variables

Efficiently Handling Large Datasets

// Process large dataset efficiently using references
$largeData = fetchData();
foreach ($largeData as &$dataItem) {
    processData($dataItem);
}

Pitfalls and Best Practices

While using & in foreach loops can be powerful, it comes with potential pitfalls. Here are some best practices to keep in mind:

Unset References

$fruits = ['apple', 'banana', 'cherry'];
foreach ($fruits as &$fruit) {
    // Some logic here
}
unset($fruit); // Important to unset the reference

Avoid Nesting References

$matrix = [[1, 2], [3, 4]];
foreach ($matrix as &$row) {
    foreach ($row as &$value) {
        // Avoid nesting references – can lead to unexpected behavior
    }
}

Alternatives to '&' in Foreach Loops

In some cases, you can achieve similar results without using references:

Using array_map

$numbers = [1, 2, 3, 4];
$numbers = array_map(function ($number) {
    return $number * 2;
}, $numbers);
// $numbers becomes [2, 4, 6, 8]

Conclusion

Mastering PHP foreach loops and understanding the power of & for references can significantly improve your coding efficiency. While this feature should be used judiciously to avoid unintended consequences, it offers a valuable tool for working with arrays and objects. By following best practices and considering alternatives, you can confidently navigate the world of PHP loops and elevate your programming skills.

1. Debugging Assistance:

"Help me debug my code: I'm facing an issue with [specific problem] in [programming language/framework]. Can you guide me through the debugging process?"

2. Learning Pathways:

"Suggest the best online courses and tutorials for mastering frontend technologies like HTML, CSS, and JavaScript."

3. Framework Comparisons:

"Compare and contrast popular JavaScript frameworks like React, Angular, and Vue.js. What are their strengths and ideal use cases?"

4. Design Tips:

"Provide tips for creating intuitive user interfaces. What are the best practices for UI/UX design in web development?"

5. Performance Optimization:

"Share techniques for optimizing website performance. How can I reduce page load times and improve overall responsiveness?"

6. Security Measures:

"What are the essential security practices for web applications? How can I safeguard against common vulnerabilities like XSS and CSRF attacks?"

7. Responsive Design Guidelines:

"Explain the principles of responsive web design. What CSS techniques can I use to create mobile-friendly layouts?"

8. Database Integration:

"Guide me on integrating a database into my web application. What are the steps for connecting and querying a database using [specific technology]?"

9. SEO Best Practices:

"What are the SEO strategies for improving a website's visibility on search engines? How can I optimize my website's content and structure for better rankings?"

10. Version Control Help:

"Explain the basics of Git version control. How can I create repositories, commit changes, and manage branches effectively?"

11. Progressive Web Apps (PWAs):

"Share insights on Progressive Web Apps. What are the key features, and how can I convert my website into a PWA for enhanced user experience?"

12. Web Accessibility:

"Explain the importance of web accessibility. What are the guidelines and techniques for making web applications accessible to users with disabilities?"

13. API Integration:

"Guide me on integrating third-party APIs into my web project. What are the best practices for authentication and error handling?"

14. Code Review Assistance:

"Review my code for [specific feature/section] in my web application. Are there any improvements or optimizations I could make?"

15. Security Headers:

"What are security headers, and how can I implement them in my web application to enhance security?"

16. Testing Strategies:

"What are the different types of testing (unit, integration, end-to-end) in web development? How can I implement effective testing strategies in my projects?"

17. Deployment Best Practices:

"Share best practices for deploying web applications. What services can I use for hosting, and what steps are involved in the deployment process?"

18. Cross-Browser Compatibility:

"How can I ensure my web application works seamlessly across different web browsers? What are the common challenges and solutions for cross-browser compatibility?"

19. Content Management Systems (CMS):

"Compare popular CMS platforms like WordPress, Joomla, and Drupal. What are their strengths, and how can I choose the right CMS for my project?"

20. Continuous Learning Resources:

"Recommend online communities, forums, and newsletters where web developers can stay updated with the latest trends, tools, and best practices."

By utilizing these ChatGPT prompts, web developers can tap into a wealth of knowledge and expertise, making their development journey more informed and efficient. Remember, the key to success in web development lies not only in solving problems but also in the continuous pursuit of knowledge and the willingness to explore new ideas and technologies. Happy coding! 🚀✨

Understanding the Basics of Flexbox

At its core, Flexbox is designed to provide a more efficient way to layout, align, and distribute space among items in a container, even when their size is unknown or dynamic. Before we dive into the properties, let's understand the fundamental concepts of Flexbox:

1. Flex Container: Any container set to display: flex; becomes a Flex Container. It enables a flex context for all its direct children.

2. Flex Items: Direct children of a Flex Container automatically become Flex Items and are laid out using the Flexbox model.

Exploring Flexbox Properties

1. justify-content: Aligning Along the Main Axis

This property aligns Flex Items along the main axis of the Flex Container.

• flex-start (default): Items are packed toward the start of the main axis.
• flex-end: Items are packed toward the end of the main axis.
• center: Items are centered along the main axis.
• space-between: Items are evenly distributed with the first item at the start and the last item at the end.
• space-around: Items are evenly distributed with equal space around them.

.container {
    display: flex;
    justify-content: space-around; /* Items distributed with space around them */
}

2. align-items: Aligning Along the Cross Axis

This property aligns Flex Items along the cross axis of the Flex Container.

• flex-start: Items are aligned at the start of the cross axis.
• flex-end: Items are aligned at the end of the cross axis.
• center: Items are centered along the cross axis.
• baseline: Items are aligned such that their baselines align.
• stretch (default): Items are stretched to fill the container.

.container {
    display: flex;
    align-items: center; /* Items centered along the cross axis */
}

3. flex-direction: Specifying the Main Axis

This property defines the direction in which the main axis of the Flex Container points.

• row (default): Main axis runs from left to right.
• row-reverse: Main axis runs from right to left.
• column: Main axis runs from top to bottom.
• column-reverse: Main axis runs from bottom to top.

.container {
    display: flex;
    flex-direction: column; /* Main axis runs from top to bottom */
}

4. flex-wrap: Controlling Wrapping of Flex Items

This property controls whether the Flex Items should wrap to the next line if they exceed the container's width.

• nowrap (default): Items are not wrapped.
• wrap: Items wrap to the next line if necessary.
• wrap-reverse: Items wrap to the previous line if necessary.

.container {
    display: flex;
    flex-wrap: wrap; /* Items wrap to the next line if necessary */
}

5. align-self: Aligning Individual Flex Items

This property allows the default alignment set by align-items to be overridden for individual Flex Items.

• auto (default): Inherits the value from its parent align-items property.
• flex-start: Item is aligned at the start of the cross axis.
• flex-end: Item is aligned at the end of the cross axis.
• center: Item is centered along the cross axis.
• baseline: Item is aligned such that its baseline aligns.
• stretch: Item is stretched to fill the container.

.item {
    align-self: flex-start; /* Item is aligned at the start of the cross axis */
}

Practical Examples: Applying Flexbox Properties

Example 1: Creating a Horizontal Navigation Bar

<div class="nav-bar">
    <div class="nav-item">Home</div>
    <div class="nav-item">About</div>
    <div class="nav-item">Services</div>
    <div class="nav-item">Contact</div>
</div>

.nav-bar {
    display: flex;
    justify-content: space-around;
    background-color: #333;
    color:

 white;
    padding: 10px 0;
}

.nav-item {
    flex: 1;
    text-align: center;
}

In this example, the navigation items are evenly distributed within the .nav-bar container, creating a responsive horizontal navigation bar.

Example 2: Building a Flexible Card Layout

<div class="card-container">
    <div class="card">Card 1</div>
    <div class="card">Card 2</div>
    <div class="card">Card 3</div>
</div>

.card-container {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-around;
}

.card {
    flex: 0 1 30%; /* Each card takes up 30% of the container width */
    margin: 10px;
    padding: 20px;
    border: 1px solid #ccc;
    text-align: center;
}

Here, the .card-container uses Flexbox properties to create a responsive card layout that adjusts its width based on the screen size.

Conclusion: Empowering Web Design with Flexbox

Flexbox provides a powerful and intuitive way to create responsive layouts in CSS. By understanding and mastering its properties, you can craft visually appealing and user-friendly designs that adapt seamlessly across various devices. With Flexbox, the complexities of layout design are simplified, allowing developers to focus on creating engaging user interfaces. So, experiment with these properties, explore their capabilities, and elevate your web design skills to new heights. Happy coding! 🚀✨