Laravel vs Symfony Comparison

Framework Features Comparison

Additional Features Comparison

Directory Structure Comparison: Laravel vs Symfony

Throwing in some cool stuff about locations and JSON. Plus, I’ll spotlight something unique to MySQL that PostgreSQL doesn’t offer. Let’s keep it chill and straightforward, like chatting on a sunny beach in Cali.

MySQL: The Go-To for Getting Things Rolling

• Super User-Friendly: MySQL is like your friendly neighborhood guide. It’s super easy to set up and manage, which means you won’t spend hours figuring things out.
• Costs? Nope, It’s free, man! Open-source helps keep those budget blues away.
• Solid Rep for Large Traffic Handling: Scaling up? MySQL can handle the pressure like a pro surfer riding those big waves.
• Widespread Love: With a massive community of users, finding help or resources is as easy as finding a taco truck in SoCal.
• The Unique MySQL Replication: MySQL offers replication features that allow your data to be duplicated across multiple servers easily. PostgreSQL has replication too, but MySQL’s approach is super streamlined and has been in the game longer.

PostgreSQL: The Brainy Contender for Complex Needs

• Data Integrity is King: If your project needs bulletproof accuracy, PostgreSQL is your go-to. It’s all about keeping your data clean and precise.
• Advanced Data Types and Functions: What about JSON and locations? PostgreSQL effortlessly handles complex data like JSON and geospatial data, perfect for when you need more than just the basics.
• Extensibility for Days: It’s like the custom surfboard of databases. You can tweak, extend, and make it exactly what you need.
• PostGIS Extension: For those who need to manage and analyze location data, PostGIS makes PostgreSQL a powerhouse for geographic information systems (GIS).
• Thriving Community and Open-Source: PostgreSQL is backed by a vibrant community, and being open-source means it’s continually evolving.

JSON and Location Handling: The Cool Extras

Both MySQL and PostgreSQL handle JSON, letting you store and query JSON data directly. This is handy for modern web apps where JSON is the leading data exchange language. Regarding location data, PostgreSQL, with its PostGIS extension, is like having GPS on steroids. It lets you do all sorts of spatial queries and analyses, which is incredible for any map-heavy app.

So, whether you’re building a startup from your garage or setting up a complex scientific database, choosing between MySQL and PostgreSQL depends on your needs. MySQL’s ease and efficiency make it perfect for business applications, while PostgreSQL’s robustness suits detailed, complex projects that need to handle intricate data with precision. Just pick the vibe that fits your project’s style!

Roman Primerov

This cheat sheet is a reminder for myself, which might come in handy in the daily life of a PHP and Node.js backend developer.

Container Management

• List running containers: docker ps
• List all containers (including stopped): docker ps -a
• Create a container from an image without starting it: docker create
• Rename a container: docker rename [container] [new-name]
• Remove a container: docker rm [container], use -f to force remove a running container.
• View logs for a container: docker logs [container], use -f --until=[interval] to display logs up to a certain point in time.
• Update a container’s configuration: docker update [container]
• Show container’s port mappings: docker port [container]
• Show running processes in a container: docker top [container]
• Show live resource usage statistics of a container: docker stats [container]
• Show changes to files or directories on a container’s filesystem: docker diff [container]
• Copy files to/from a container: docker cp [file-path] CONTAINER:[path]

Networking

• View available networks: docker network ls
• Remove a network: docker network rm [network]
• Connect a container to a network: docker network connect [network] [container]
• Disconnect a container from a network: docker network disconnect [network] [container]
• Show detailed information about a network: docker network inspect [network]

Image Management

• Create an image from a Dockerfile: docker build [dockerfile-path], use -t [name]:[tag] to tag it.
• Pull an image from a registry: docker pull
• Push an image to a registry: docker push
• Save changes in a container as a new image: docker commit [container] [new-image]
• View all locally stored top-level images: docker images
• Remove an image: docker rmi
• Show history of an image: docker history
• Save an image to a tar archive file: docker save > [tar-file]
• Remove unused images: docker image prune

The docker commands cheat sheet: #CheatSheetDocker

Step 1: Install Spatie Laravel Permission

Start by installing the package via Composer and publishing its configurations:

composer require spatie/laravel-permission
php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider"
php artisan migrate

Step 2: Rollback the Last Migration

If needed, you can rollback the last migration with this command:

php artisan migrate:rollback --step=1

Step 3: Re-run Migrations

If tables were deleted or require recreation, run:

php artisan migrate

Step 4: Update the User Model

Ensure the User model uses the HasRoles trait from Spatie:

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use Spatie\Permission\Traits\HasRoles;

class User extends Authenticatable
{
    use HasRoles;

    // Other model methods...
}

Step 5: Create and Run a Seeder for Roles and Permissions

Create a seeder then populate roles and permissions:

php artisan make:seeder RolesAndPermissionsSeeder
php artisan db:seed --class=RolesAndPermissionsSeeder

Here’s what your seeder might look like:

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use App\Models\User;
use Spatie\Permission\Models\Role;
use Spatie\Permission\Models\Permission;

class RolesAndPermissionsSeeder extends Seeder
{
    public function run()
    {
        // Create roles
        $roleSuperAdmin = Role::create(['name' => 'superadmin']);
        $roleAdmin = Role::create(['name' => 'admin']);
        $roleUser = Role::create(['name' => 'user']);
        // More roles setup...

        // Assign roles to users
        $userOne = User::where('email', 'j@solarneutrino.com')->first();
        if ($userOne) {
            $userOne->assignRole('superadmin');
        }

        $userTwo = User::where('email', 'user@gmail.com')->first();
        if ($userTwo) {
            $userTwo->assignRole('user');
        }
    }
}

Follow these steps to effectively manage roles and permissions in your Laravel 11 application using the Spatie Permission package.

Step 6: Auto-Assign ‘User’ Role on Registration

To automatically assign the «user» role to all newly registered users, you need to modify the registration handling method. This is usually the create method in the RegisterController.

1. Open the RegisterController.php file, typically located in the app/Http/Controllers/Auth directory.

2. Add the role assignment in the create method after creating a new user:

   protected function create(array $data)
   {
       $user = User::create([
           'name' => $data['name'],
           'email' => $data['email'],
           'password' => Hash::make($data['password']),
       ]);
   
       // Assigning the "user" role
       $user->assignRole('user');
   
       return $user;
   }
   

This code snippet ensures that every new user is automatically granted the «user» role upon registration.

Step 7: Using @role and @hasrole Directives in Blade Templates

To manage content visibility based on user roles within Blade templates, Laravel’s Spatie Permission package provides two useful directives: @role and @hasrole. These directives help in rendering content conditionally based on the user’s roles.

Examples:

<!-- Display content only if the user has the "superadmin" role. Checks for any of the specified roles if multiple are provided. -->
@role('superadmin')
    <p>This text can see user from Superadmin group</p>
@endrole

<!-- Alternative way using @hasrole, strictly checks for the specified role. Used for checking a single role. -->
@hasrole('superadmin')
    <p>This text can see user from Superadmin group</p>
@endhasrole

<!-- Display content only if the user has the "user" role. Checks for any of the specified roles if multiple are provided. -->
@role('user')
    <p>This text can see user from User group</p>
@endrole

<!-- Alternative way using @hasrole, strictly checks for the specified role. Used for checking a single role. -->
@hasrole('user')
    <p>This text can see user from User group</p>
@endhasrole

Explanations:

• @role: This directive checks if the current authenticated user has one or more specified roles. If multiple roles are passed (separated by commas), it returns true if the user has at least one of them. In the provided examples, only one role is specified, so the behavior is similar to @hasrole.
• @hasrole: This directive strictly checks if the user has the specified role. It’s ideal for situations where you need to verify the presence of only one specific role. This directive always takes only one role at a time.

These directives are instrumental in controlling what content a user can see based on their roles, enhancing security and user experience by tailoring the UI to meet individual user permissions.

Step 8: Applying Roles to Routes or Route Groups

In Laravel 11, the structure for handling middleware has changed significantly, including the deprecation of the app/Http/Kernel.php file. Middleware can now be applied directly in the routing files such as web.php or api.php. Here’s how to set up and use Spatie Permission Middleware to restrict route access to users with specific roles.

Registering and Applying Middleware

You can register your middleware directly in the routing file. Below is a step-by-step guide on how to apply the Spatie Permission Middleware directly to your routes:

1. Add the Middleware Namespace:

   At the beginning of your routing file (e.g., routes/web.php), add the namespace for the middleware:

   <?php
   use Spatie\Permission\Middlewares\RoleMiddleware;
   ?>
   

2. Apply Middleware to a Route:

   Apply the middleware directly to the routes as follows:

   <?php
   use Illuminate\Support\Facades\Route;
   
   Route::middleware(['auth', 'verified', RoleMiddleware::class . ':superadmin'])
       ->get('/contact-messages', function () {
           return view('contact-messages');
       })->name('contact-messages');
   ?>
   

   Note that we pass the RoleMiddleware class with the role parameter (superadmin) directly into the middleware array.

Laravel 10, 9, …

To secure routes based on user roles, Laravel allows the application of middleware to individual routes or groups of routes. Using Spatie’s permission package, you can enforce role-based access controls effectively.

Applying Roles to a Single Route:

use Illuminate\Support\Facades\Route;

// Ensure you have registered the 'role' middleware in your old version Laravel - Kernel.php after Laravel 11 it can be seeder class or another tinker way. 
Route::get('/admin', function () {
    return view('admin.dashboard');
})->middleware('role:admin');

This route is accessible only to users who have the ‘admin’ role. If a user without this role tries to access it, they will be redirected as defined by your middleware handling.

Applying Roles to a Route Group:

use Illuminate\Support\Facades\Route;

Route::middleware(['role:admin'])->group(function () {
    Route::get('/admin/dashboard', function() {
        return view('admin.dashboard');
    });
    Route::get('/admin/settings', function() {
        return view('admin.settings');
    });
});

This group of routes is secured with the ‘admin’ role, ensuring that all routes within this group require a user to be an ‘admin’ to gain access. This method is particularly effective for sectioning parts of your application that should be restricted to users with specific roles.

Note: It’s important to ensure that your Kernel.php file is properly configured to recognize the Spatie middleware. Add the Spatie middleware to your $routeMiddleware array if it’s not already present:

protected $routeMiddleware = [
    // other middleware
    'role' => \Spatie\Permission\Middlewares\RoleMiddleware::class,
];

Following these best practices not only enhances the security of your application by ensuring proper role-based access control but also aligns with Spatie’s documentation, ensuring you are implementing features in the recommended manner.

For example:

Utilized Laravel Breeze for authentication with frontend-designed Tailwind CSS and Spatie for role-based access control. Integrated Laravel Sanctum for secure token-based API and Laravel Multidomain middleware for simpler project integration. Enhanced security by hosting the admin panel on a separate domain (admin.solarneutrino.com) and (solarneutrino.com). Implemented a contact form with functionalities for email notifications, logging via Eloquent MySQL, and Telegram alerts. Infrastructure set up on EC2, utilizing Route 53 for DNS management and AWS SES for email dispatch.

Node.js

Node.js is a JavaScript runtime built on Chrome’s V8 JavaScript engine. It offers several advantages in microservices development:

• Non-Blocking I/O Model: Node.js excels at handling concurrent requests due to its event-driven, non-blocking I/O model. This makes it ideal for building real-time microservices with high throughput requirements.
• Vast Ecosystem: The Node Package Manager (NPM) is one of the largest open-source ecosystems in the world. This gives developers access to thousands of libraries and tools that can accelerate microservices development.
• JavaScript Everywhere: Node.js allows developers to use JavaScript for both server-side and client-side programming. This streamlines development and fosters better collaboration between frontend and backend teams.
• Scalability: Node.js is designed to be highly scalable. With features like clustering and worker threads, it can efficiently distribute incoming requests across multiple processors, making it well-suited for scaling microservices.
• Active Community and Support: Node.js has a vibrant and active community, which means robust support and regular updates. This ensures that issues are quickly resolved and new features are frequently introduced.

Go

Go, or Golang, is a statically typed, compiled programming language designed at Google. It brings several unique benefits to microservices:

• Concurrency Model: Go’s goroutines and channels provide a simple yet powerful concurrency model. This makes it easy to build high-performing, concurrent microservices that can handle multiple tasks simultaneously.
• Performance: Go is known for its speed and efficiency. Being a compiled language, it offers lower latency and higher throughput, making it excellent for performance-critical microservices.
• Built-In Tools: Go comes with a rich set of built-in tools for testing, benchmarking, and profiling. This simplifies development and helps maintain high code quality in microservices projects.
• Static Typing and Compile-Time Safety: Go’s static typing helps catch errors at compile time, leading to more reliable and maintainable code. This is particularly beneficial in large microservices projects where preventing runtime errors is crucial.
• Simplicity and Clean Syntax: Go is designed for simplicity, which leads to clean, readable code. This is advantageous in microservices development, where maintainability and clarity are key.

Laravel

Laravel is a PHP framework known for its elegance and developer-friendliness. It provides several advantages for microservices:

• Expressive Syntax: Laravel’s expressive and intuitive syntax simplifies development, allowing developers to focus on business logic rather than boilerplate code.
• Rich Ecosystem: Laravel boasts a robust ecosystem of tools and libraries, such as Eloquent ORM and Blade templating. These tools accelerate microservices development by providing solutions for common challenges.
• Built-In Features: Laravel comes with built-in features like routing, authentication, and caching, which are essential for microservices. These features simplify the development process and enhance productivity.
• Scalability: Despite being known for monolithic applications, Laravel can be effectively used for microservices with the help of tools like Lumen (a micro-framework by Laravel). This provides a lightweight and scalable option for microservices architecture.
• Developer Community: Laravel has a strong and active developer community. This means ample resources, tutorials, and support, which is beneficial for developing and maintaining microservices.

Conclusion

Choosing the right technology for microservices development depends on various factors, including team expertise, performance requirements, and project complexity. Node.js excels at handling concurrent requests with its non-blocking I/O model. Go offers superior performance and a robust concurrency model. Laravel provides a rich ecosystem and developer-friendly features.

Each technology has its own strengths and is suited to different scenarios. The choice ultimately hinges on the specific needs of your microservices architecture and the preferences of your development team.

Node.js vs Laravel vs Golang

1. API and Web Service Testing :

Curl simplifies sending requests to APIs and web services, aiding in functionality testing and troubleshooting. It supports various request types (GET, POST, PUT, DELETE) and allows for transmitting different headers and data. Curl can also display detailed request and response information, which is invaluable for debugging.

2. File Downloading :

Curl can download files from web servers, useful for retrieving configuration files, images, scripts, or other data. It can resume interrupted downloads, particularly helpful when dealing with large files.

3. Task Automation :

Curl can automate various tasks like file downloads, API requests, and web service testing. Scripts created with curl can perform repetitive tasks, saving time and effort. Its integration with other tools and programming languages makes curl a powerful tool for automation.

4. Information Gathering :

Curl can collect information from websites by extracting HTML, text, images, or other data. It can process JSON and XML responses, which is beneficial for collecting structured data.

5. Website and Server Monitoring :

Curl can monitor websites and servers by checking site availability, tracking server response times, and monitoring changes in web pages. It can also send notifications via email or other channels if it detects issues.

6. Simulation of User Agent and IP Spoofing :

Curl allows you to simulate different user agents and spoof IP addresses, which is critical when testing how APIs and websites respond to various browsers or geographic locations. This can be particularly useful for developers working on applications that need to behave differently based on user-agent or IP-based rules.

7. Security Testing :

Curl is a valuable tool for security testing of web applications. It can be used to send crafted requests that test for vulnerabilities like SQL injections, XSS, and CSRF, thereby helping developers strengthen their security measures before deployment.

8. Handling Cookies and Sessions :

Curl can manage cookies and sessions, allowing developers to mimic stateful sessions while interacting with web services. This is essential for testing applications that require authenticated sessions or tracking user interactions across multiple requests.

9. Network Diagnostics and Troubleshooting :

Curl provides detailed network diagnostics that help in identifying connectivity issues, slow response times, and other network-related problems. This can be invaluable for optimizing application performance and ensuring high availability.

10. Support for Multiple Protocols :

Besides HTTP, Curl supports a wide range of other protocols including FTP, SMTP, LDAP, and more. This makes it a versatile tool for developers who need to interact with different network services during the development and testing phases.

CheatSheet — curl commands

My LinkedIn post

As we dive into the digital age, the significance of having a technically sound and visually appealing online portfolio cannot be overstated. Whether you’re a recruiter, a fellow developer, or someone interested in the tech world, understanding the components of an effective portfolio is key.

Seamless Integration with Laravel + AWS The combination of Laravel and AWS provides a powerful platform for developers to showcase their technical skills. Laravel’s elegant syntax and feature-rich framework paired with the scalable and secure infrastructure of AWS allows developers like me to build dynamic and robust applications. This setup not only demonstrates technical expertise but also a commitment to using industry-leading technologies.

SEO-Optimized Code In today’s competitive landscape, having an SEO-optimized portfolio is crucial. It ensures that the portfolio not only reaches its target audience but also ranks well on search engines. By integrating SEO strategies right from the coding phase, such as proper use of tags, optimized loading speeds, and mobile responsiveness, the portfolio stands out in Google searches, driving more organic traffic.

Cutting-edge UX/UI Design Aesthetics matter! A portfolio that’s easy on the eyes and offers an intuitive user experience can significantly boost engagement. Using the latest UX/UI design principles, the portfolio provides a seamless navigation experience, showcasing projects and skills in a format that’s both attractive and easy to digest.

Rich Content and Detailed Projects The portfolio highlights various projects with detailed descriptions of the tech stacks used and the challenges overcome. This not only reflects the scope of technical skills but also the problem-solving capabilities essential for a Full Stack Developer.

Ready to Explore More? You can check out my complete portfolio at Solar Neutrino. It’s designed to give you a comprehensive look at my work and the high standards I adhere to in every project. Also, don’t forget to check out the related LinkedIn post where I dive deeper into the functionalities and behind-the-scenes of my portfolio creation.

In conclusion, a well-crafted portfolio is more than just a showcase of projects; it’s a testament to a developer’s dedication to quality, innovation, and continuous learning. Whether you’re in the tech industry or simply have an appreciation for digital craftsmanship, understanding these elements can provide insights into the complexities and beauty of modern web development.

Looking forward to connecting with you and exploring potential collaborations that push the boundaries of technology and design!

Spin Up a New Laravel Project
Hey, ready to lay the groundwork? Fire up the terminal and get those commands rollin’. Create a new directory, jump in, and let Composer work its magic to set up Laravel.


#mkdir blog
#cd blog
#composer create-project laravel/laravel .


Forge Your SSH Key & Personal Access Tokens
Whether you’re ridin’ the waves with SSH or cruising down the HTTPS highway for pushin’ git branches, you’ve got options, dude.
For the SSH route, catch the official wave here:
Generating a New SSH Key

Hitting a wipeout? Debug SSH with this:
SSH Troubleshooting

Catch these vids for a visual on SSH keys and HTTPS tokens:

Manage Repos Like a Pro
Next up, surf on over to GitHub, web or CLI, and create a new repo to house your project.
Scope out this screenshot for how it looks:

Then, roll with these steps to get your repo up using the SSH GitHub vibes:

…or create a new repository on the command line

«`html
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin git@github.com:TjoBiZ/blog-example.git
git push -u origin main
«`

…or push an existing repository from the command line

«`html
git remote add origin git@github.com:TjoBiZ/blog-example.git
git branch -M main
git push -u origin main
«`
Rollin’ with a personal token instead? Swap in this HTTPS remote origin link:

git remote add origin https://github.com/TjoBiZ/blog-example.git

There you have it! Whether you’re coding to the rhythm of the crashing waves or the quiet hum of a coffee shop, these Git commands will keep your projects surf-ready and steady as she goes. Keep it real, keep it coded.

Steps

1. Disable all versions of PHP using mpm_prefork:

   Find out which PHP versions are active:

   apache2ctl -M | grep php

   Then disable them:

   sudo a2dismod php7.4
   sudo a2dismod php8.0
   sudo a2dismod php8.2

2. Disable mpm_prefork and enable mpm_event:

   Disable mpm_prefork:

   sudo a2dismod mpm_prefork

   Enable mpm_event:

   sudo a2enmod mpm_event

3. Enable php-fpm for each version:

   Install php-fpm for each version:

   sudo apt-get install php7.4-fpm
   sudo apt-get install php8.0-fpm
   sudo apt-get install php8.2-fpm

   Enable proxy_fcgi and setenvif:

   sudo a2enmod proxy_fcgi setenvif

   Enable php-fpm configurations:

   sudo a2enconf php7.4-fpm
   sudo a2enconf php8.0-fpm
   sudo a2enconf php8.2-fpm

4. Configure virtual hosts to use php-fpm:

   In each virtual host, replace SetHandler with:

   <FilesMatch \\.php$>
       SetHandler "proxy:unix:/run/php/php7.4-fpm.sock|fcgi://localhost/"
   </FilesMatch>

   Change php7.4 to the corresponding version for each host.

5. Restart Apache:

   sudo systemctl restart apache2

Conclusion

Now, your virtual hosts are configured to use php-fpm and support the HTTP/2 protocol.

Then open some files for debugging with break points
your-site.com/storage/framework/views/xxxxxx.php