DEV Community: Nelson Orina

Building a University Resource Sharing Platform: My Laravel Learning Journey

Nelson Orina — Mon, 05 Jan 2026 09:25:43 +0000

As part of my software development journey, I'm building the Strathmore Resource Exchange (SRE) - an internal marketplace for university students to share academic resources. Here's what I've learned so far about Laravel development, routing, and file handling.

The Project Vision

SRE solves two problem for Strathmore University students:

Outdated academic materials - Official exam banks lag years behind
Cluttered marketplace - Selling items via social media is insecure

The platform allows students to:
. Share past papers, textbooks, calculators
. Buy/sell items within a trusted ecosystem
. Access verified, recent study materials

Tech Stack

. Backend: Laravel 11 (PHP)
. Frontend: Vue 3 with Inertia.js
. Database: MySQL
. File Handling: Spatie Media Library

Key Learning #1: Resourceful Routing in Laravel

One of the most powerful Laravel features I discovered is resourceful routing. With just one line of code, you can create 7 complete CRUD routes:

Route::resource('listings', ListingController::class)

This single line generated:

HTTP Method	URL	Controller Method	Purpose
GET	`/listings`	`index()`	Display all listings
GET	`/listings/create`	`create()`	Show form to create a listing
POST	`/listings`	`store()`	Store a new listing
GET	`/listings/{listing}`	`show()`	Show a single listing
GET	`/listings/{listing}/edit`	`edit()`	Show form to edit a listing
PUT / PATCH	`/listings/{listing}`	`update()`	Update an existing listing
DELETE	`/listings/{listing}`	`destroy()`	Delete a listing

The Magic of Route Model Binding

When you type-hint a model in your controller

public function show(Listing $listing)

Laravel automatically:

Takes the ID from the URL (/listings/5)
Finds the Listing with ID 5
Injects it into your method
Returns 404 if not found

Middleware Group for Security

I learnt to protect routes using middleware groups:

Route::middleware(['auth','verified'])->group(function(){
   Route::resource('listings', ListingController::class);
});

This ensures only authenticated users can access these routes in our marketplace.

Key Learning #2: Spatie Media Library for File Handling

Handling file uploads (PDFs for past papers, images for items) was a challenge until I discovered Spatie Media Library.

How It Works:

1. Installation & Setup

composer require spatie/laravel-medialibrary
php artisan vendor:publish --provider="Spatie\MediaLibrary\MediaLibraryServiceProvider"
php artisan migrate

2. Model Configuration

use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\InteractsWithMedia;

class Listing extends Model implements HasMedia
{
    use InteractsWithMedia;

    public function registerMediaCollections(): void
    {
        $this->addMediaCollection('past_papers')
            ->acceptsMimeTypes(['application/pdf'])
            ->singleFile();

        $this->addMediaCollection('listing_images')
            ->acceptsMimeTypes(['image/jpeg', 'image/png'])
            ->singleFile();
    }
}

3. Database Structure

Spatie creates a media table that stores:
. File metadata (name, size, mimetype)
. Polymorphic relationship to any model
. Collection names for organization

4. File Upload in Controller

public function store(Request $request)
{
    // Create the listing
    $listing = Listing::create([...]);

    // Handle file based on type
    if ($request->hasFile('file')) {
        $collection = $request->type === 'paper' 
            ? 'past_papers' 
            : 'listing_images';

        $listing->addMediaFromRequest('file')
                ->toMediaCollection($collection);
    }
}

5. Retrieving Files

public function show(Listing $listing)
{
    // Get the file URL
    $listing->file_url = $listing->getFirstMediaUrl(
        $listing->type === 'paper' ? 'past_papers' : 'listing_images'
    );

    return view('listing.show', compact('listing'));
}

Benefits of Spatie Media Library:

. Automatic file organization - Files stored in structured folders
. Multiple collections - Separate past papers from item images
. Easy retrieval - Simple methods to get file URLs
. Type validation - Restrict to PDFs or images
. Polymorphic relationships - Reusable across different models

Key Learning #3: Eloquent Relationships & Eager Loading

Database Structure:

// Listings belong to Users and Units
Schema::create('listings', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->foreignId('unit_id')->nullable()->constrained();
    // ... other fields
});

Model Relationships:

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

    public function unit()
    {
        return $this->belongsTo(Unit::class);
    }
}

The N+1 Query Problem & Solution:

$listings = Listing::all();
foreach ($listings as $listing) {
    echo $listing->user->name;  // Makes separate query for EACH listing!
}
// Result: 1 query for listings + N queries for users = N+1 queries

**With eager loading (GOOD):**
$listings = Listing::with(['user', 'unit'])->get();
// Result: Only 3 queries total!

Key Learning #4: Conditional Validation

For my use case, I needed different validation rules based on listing type:
. Past papers: Require PDF files (max 10MB)
. Other items: Require images (max 5MB)

use Illuminate\Validation\Rule;

$request->validate([
    'file' => Rule::when($request->type === 'paper', [
        'required', 'file', 'mimes:pdf', 'max:10240'
    ], [
        'required', 'image', 'mimes:jpg,jpeg,png', 'max:5120'
    ]),
]);

This uses Laravel's Rule::when() to apply different validation rules conditionally.

Key Learning #5: Inertia.js with Vue

Server-Side (Laravel Controller):

public function index()
{
    return Inertia::render('Listings/Index', [
        'listings' => Listing::with(['unit', 'user'])->paginate(12)
    ]);
}

Client-Side (Vue Component):

<template>
  <div v-for="listing in listings.data" :key="listing.id">
    <h2>{{ listing.title }}</h2>
    <p>{{ listing.description }}</p>
  </div>
</template>

<script setup>
import { defineProps } from 'vue'
const props = defineProps(['listings'])
</script>

Benefits of Inertia.js:

. Single-page app feel without building an API
. Server-side rendering benefits
. Shared validation errors between Laravel and Vue
. File uploads work seamlessly

Laravel Models, Migrations, & Relationships: Setting Up The 'Post' Feature

Nelson Orina — Sat, 08 Nov 2025 18:25:04 +0000

Welcome back! With secure user authentication in place, we can now focus on building the core functionality of our blog: creating and managing posts. This post will walk you through setting up a new Eloquent Model and its corresponding database table, and establishing the crucial one-to-many relationship between a user and their posts.

What We'll Cover Today

Generating the Post Model and Migration file.
Defining the necessary database columns for our posts.
Understanding and setting up the one-to-many relationship between User and Post.
Configure the Post model's $fillable property for mass assignment.

Step 1:Generating the Post Model and Migration

Just as the User model connects our application to the users table, we need a Post Model to interact with a future posts table. Laravel provides a powerful Artisan command to generate both files simultaneously.

1.The Artisan Command

Open your terminal in your project's root directory and run:

php artisan make:model Post -m

2.Verification

You should now have two new files:

Model: app/Models/Post.php
Migration: database/migrations/YYYY_MM_DD_HHMMSS_create_posts_table.php (The timestamp ensures migrations run in the correct order).

Step 2:Defining the `posts` Database Structure

The migration file is where we design the structure of our posts table. A blog post needs several key columns, including the content and, critically, a way to link it back to the user who created it.

1.Update the Migration File

Open the new migration file(...create_posts_table.php) and modify the up() method to look like this:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
            $table->string('title');
            $table->longText('body');
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};

2.Key Columns Explained

$table->id():The primary key, a unique auto-incrementing identifier for the post.
$table->foreignId('user_id'):This is the Foreign Key. It's the critical link to the users table. It will store the id of the user who owns this post.
->constrained():A shortcut that tells Laravel this user_id column references the id column on the plural form of the table(users).
onDelete('cascade'):This is a powerful database-level rule. If a user is deleted, all of their associated posts will also be automatically deleted.This ensures data integrity.
$table->string('title'): A simple string column for the post's title.
$table->text('body'): A larger text column suitable for the main content of a blog post.

Step 3:Running the Migration

Now that the structure is defined, we run the same command from our previous post to create the actual table in the database.

1.The Command

php artisan migrate

2.Verification

Check your database with a management tool (like HeidiSQL). You should now see a new table named posts with the columns we defined, including the user_id foreign key.

Step 4: Configuring the `Post` Model

With the table created, we configure the Post.php model to safely interact with the database, just as we did for the User model.

1.Set the `$fillable` Property

Open app/Models/Post.php and add the $fillable property. This protects against unexpected mass assignment by explicitly defining which fields can be filled in a single Post::create([...]) command.

// app/Models/Post.php

namespace App\Models;

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

class Post extends Model
{
    use HasFactory;

    // Define the columns that can be mass-assigned
    protected $fillable = [
        'user_id',
        'title',
        'body',
    ];
}

Step 5:Establishing the Eloquent Relationship

This is the most crucial step for a working blog application. We need to tell Laravel that a single user can have multiple posts, and a post belongs to only one user.

1. The `user` Model: One-to-Many(Has Many)

A user can have many posts. We define a relationship method named posts in the User model.

// app/Models/User.php

// ... other properties and methods

class User extends Authenticatable
{
    // ... other properties

    /**
     * Get the posts for the user.
     */
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

The Benefit: Now, you can retrieve all posts by a user like this: $user->posts.

2. The `Post` Model:Inverse of One-to-Many(Belongs To)

A single post belongs to one user. We define a relationship method named user in the Post model.

// app/Models/Post.php

// ... other properties and methods

class Post extends Model
{
    // ... $fillable property

    /**
     * Get the user that owns the post.
     */

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

The Benefit: Now, you can retrieve the author of any post like this: $post->user.

Wrapping Up: What We've Accomplished

We created the Post Model and a new posts table with the essential user_id foreign key.
We secured the model using the $fillable property.
We established the powerful, two-way, one-to-many relationship between User and Post using Eloquent methods (hasMany and belongsTo).

In the next post, we will use this foundation to build the Post Creation Controller and the Blade Forms to finally let our users add content to the blog.

Laravel Models & Authentication: Setting Up User Registration & Login

Nelson Orina — Sun, 02 Nov 2025 17:28:37 +0000

In our previous tutorial, we built a registration form and handled form submission with a controller. Now, let's take the next step and implement complete user authentication using Laravel's built-in features.

What We'll Cover Today

Running Laravel's default migration for authentication
Understanding the User model and database structure
Completing our registration functionality
Adding login/logout features
Understanding Laravel's security features

Step 1:Running the Default Authentication Migration

To implement user authentication, the first thing we need is a secure place to store user information, like names, emails, and, most importantly hashed passwords.

Fortunately, Laravel includes the entire necessary database structure by default. We just need to run the standard migration command to create the tables.

1.The Migration Command

Open your terminal in the root directory of your Laravel project and run the following command:

php artisan migrate

2.What Just Happened?

When you run php artisan migrate on a new project, Laravel looks in the database/migrations directory and executes any pending migration files. The key file for authentication is the one that creates the users table.

This table is foundational for Laravel's authentication system and includes all columns we need.

3.Verification

To confirm the table was created successfully, you can check by using a database management tool (like Heidi). You should see a new users table ready to accept registration data.

With the database structure in place, we can now move on to the code that interacts with this table

Step 2:Understanding the User Model and Database Structure

In Laravel, the bridge between your application code and your database tables is called an Eloquent Model. For authentication, this role is filled by the default User model.

1.Locating the User Model

The default User model is located in:

app/Models/User.php

2.The Model's Role

The User.phpfile is an essential class that does three critical things:

Connects to the Table:By default, Laravel models follow a naming convention:a singular model name (User) is mapped to a plural table name (users). The User model knows exactly how to read and write data to the users table we created in Step 1.
Enables Eloquent Features:This model gives you access to Laravel's powerful query builder, Eloquent ORM. Instead of writing raw SQL, you can use clean PHP methods like User::all() or User::create([...]).
Implements Authentication Traits:You'll notice the User model uses the Illuminate\Foundation\Auth\User class and the HasApiTokens, Notifiable, and HasFactory traits. These are built-in Laravel features that handle password hashing, session management, and other security requirements.

3.Key Model Properties

Two properties within the User.php file are important to understand for security and bulk actions:

$fillable:This array defines the columns in the users table that can be mass-assigned(i.e., filled in a single operation, like a form submission).

protected $fillable = [
    'name',
    'email',
    'password', // We'll use this in the next step!
];

$hidden:This array specifies any attribute that should not be visible when the model is converted to an array or JSON(like when returning user data in an API response).

protected $hidden = [
    'password', // Crucial: Keeps the hashed password private
    'remember_token',
];

In the next step, we'll use the $fillable fields on this User model to complete our registration process and actually save a new user to the database.

Step 3:Completing Our Registration Functionality

The core of secure registration is taking the data submitted from the form, validating it, and then saving it to the users table while ensuring the password is securely hashed.

1.Update the Registration Controller

You'll need to modify the method in your registration controller (e.g., RegisteController.php) that handles the POST request from the form.
We will use the User model and the Hash facade to save the data.

<?php 

namespace App\Http\Controllers; 

use App\Models\User; 
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Illuminate\Support\Facades\Hash; // Import the Hash facade

class RegisterController extends Controller{
   public function register(Register $register){
      $incomingValues = $request->validate([
'name' => ['required','min:3', 'max:255'],
'email' => ['required','email',Rule::unique('users','email')]
'password' => ['required','min:8'],
])
$user = User::create([
'name' => $incomingValues['name'],
'email' => $incomingValues['email'],
'password' => Hash::make($incomingValues['password']),//Hashing the password before storing it 
]);
auth()->login($user);//Log the user in immediately
return redirect('/');

}
}

Key Takeaways from the Code

Hash::make($request->password):This is the most important part! Never store raw passwords. Laravel's Hash facade uses strong, one-way encryption to hash the password.The actual password is not recoverable, which keeps your users secure even if your database is compromised.
User::create([...]):This uses the Eloquent Model's mass assignment feature(which relies on the $fillable property we discussed in Step 2) to quickly create and save the new user record.

Now, a user successfully submitting the registration form will create a secure record in your database. Next, we'll leverage this secure record to implement the full login and logout flow.

Testing the Registration

Fill out your registration form
Submit and check your database, you should see a new user with hashed password
You should be automatically logged in and redirected

Step 4:Adding Login and Logout Features

Laravel makes handling sessions and authenticating users remarkably simple using the Auth facade.

1.Implementing the Login Logic(Session Creation)

The login process involves two main steps: displaying the form and processing the credentials.

A. The Login Controller Method

You'll need a method in your controller (e.g., LoginController.php) to handle the form submission. We use the Auth::attempt() method, which automatically does the heavy lifting:

It fetches a user from the database based on the email(or whatever field you set as the authentication identifier).
It takes the submitted, unhashed password and compares it against the hashed password stored in the database.
If the credentials match, it creates a secure session for the user.

//In your LoginController.php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth; //Import the Auth facade

//..inside the class ...
public function authenticate(Request $request){
//1.Validate the input fields
$credentials = $request->validate([
'email' => ['required','email'],
'password' => ['required'],
]);

//2.Attempt to log the user in 
if(Auth::attempt($credentials)){
$request->session()->regenerate();

return redirect('/')->intended('/dashboard');
}

}

Auth::attempt($credentials):The magic happens here. It tries to find a user matching the email and verifies the password hash.
$request->session()->regenerate():This is a security best practice in Laravel to prevent session fixation attacks after a successful login.
redirect()->intended('/dashboard'):This is another helpful Laravel feature. It redirects the user to the URL they were trying to access before they were sent to the login page

2.Implementing the Logout Logic(Session Destruction)

Logging a user out is much simpler. It involves destroying the user's current session and revoking their authentication status.

A. The Logout Controller Method

You can place this in the same LoginController.php or a separate LogoutController.php:

//In your LoginController.php 
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

//...inside the class... 
public function logout(Request $request)
{
   //1.Logout the user
   Auth::logout(); 
   //2.Invalidate the existing session
   $request->session()->invalidate(); 
    //3.Regenerate the CSRF token
   $request->session()->regenerateToken(); 
   //4.Redirect to the homepage or login page
   return redirect('/');
}

Auth::logout():Clears all authentication information from the current session.
$request->session()->invalidate():Invalidates the current session, ensuring it can't be reused
$request->session()->regenerateToken():Regenerates the Cross-Site Request Forgery (CSRF) token for the next user session.

3.Setting up Routes

Finally, make sure you have the routes defined to point to these new controller methods:

\\In your routes/web.php 

<?php

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\UserController;

Route::get('/', function () {
    return view('home');
});

Route::post('/register', [UserController::class, 'register']);
Route::post('/logout', [LoginController::class,'logout']);
Route::post('/login', [LoginController::class,'login']);

Note:We use a POST route for logout, not a GET. This is another security best practice to prevent attackers from tricking users into logging out via a simple link click.

Step5: Understanding Laravel's Security Features

We have built user authentication, but we have also implemented several critical, behind the scenes security measures simply by using Laravel's built-in tools. This step reassures you, the readers, about the robustness of this application.

1. Password Hashing

As we discussed in Step 3, we use Hash::make() instead of storing raw passwords. This is the single most important security feature.

How it works:Laravel uses a modern, slow hashing algorithm which takes the user's password and transforms it into a long, non-reversible string.
The Benefit:If your database is ever compromised, the attacker only gets impossible-to-decrypt hash strings, not your users' actual passwords. This protects both your application and your users' security on other websites.

2. Session Fixation Prevention

Laravel automatically handles the creation and management of user sessions, including defending against one common attack:

Session Fixation:This is an attack where a hacker tricks a user into logging in with a session ID the hacker already knows.
Your Defense:When you include request()->session()->regenerate(); in your login method, you instructed Laravel to generate a brand new, unique session ID after a successful login. This instantly destroys the old, potentially compromised session ID, rendering any hacker's pre-set ID useless.

3.Cross-Site Request Forgery (CSRF) Protection

If you're using Laravel forms(or using @csrf blade directive), you already have powerful protection against CSRF.

What is CSRF?It's an attack where a hacker tries to force a logged-in user to submit a malicious request(like changing their password or making a purchase) without their knowledge.
Your Defense:Laravel requires a hidden, unique CSRF token to be included with every non-GET request (like POST, PUT, etc.). If the token doesn't match, Laravel rejects the request automatically. This token is tied to the user's secure session, preventing unauthorized external requests.

4.Input Sanitization

While you must still validate your input (which we did), Laravel's framework and its ORM, Eloquent, are inherently designed to protect against SQL Injection.

SQL Injection:This is an attack where a user inputs malicious SQL code into a form field (like entering ' OR 1=1; -- into a username field) to manipulate your database queries.
Your Defense:When you use Eloquent commands like User::create($incomingFields), Laravel automatically sanitizes all input, treating it strictly as data and not as executable code. This makes SQL injection attacks virtually impossible through Eloquent.

Wrapping Up: What We've Accomplished

We have successfully integrated complete user authentication into our application. By following these five steps, we now have a secure functional system:

Ran the default migration to create the essential users table.
Utilized the User Eloquent Model as the primary interface to our database.
Secured registration using Hash::make() to encrypt passwords.
Implemented smooth Login and Logout with the Auth facade.
Gained powerful, passive security from Laravel, including CSRF and SQL Injection protection.

We are now ready to build out the features of our application with confidence, knowing the identity and security of our users are handled.

Laravel Form Handling & Controllers: Building a Registration Form

Nelson Orina — Sun, 26 Oct 2025 06:07:45 +0000

In our previous post, we set up Laravel and created basic routes and views. Now, let's dive into one of the most fundamental aspects of web development; handling form submissions with controllers.

Instead of building a complete CRUD application all at once, we'll focus on a single, manageable piece - creating a registration form and processing it with a controller.

What We'll Build Today

We'll create a simple user registration form that:

Displays a clean registration form
Handles form submission with a controller
Validates user input
Demonstrates Laravel's security features

Step 1:Creating the Registration Form View

First navigate to the resources folder then the views folder.
Here create a new file home.blade.php. Inside this file we'll come up with a simple HTML file that has a registration form.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Simple Blog Registration</title>
</head>
<body>
    <div style="border: 1px solid black;">
        <h2>Register</h2>

        <form action="/register" method="post">
            @csrf
            <input type="text" placeholder="name" name="name"/>
            <input type="email" placeholder="email" name="email"/>
            <input type="password" placeholder="password" name="password"/>
            <button type="submit">Submit</button>
        </form>
    </div>
</body>
</html>

Explanation:

The Essential @csrf Directive: Notice the line @csrf. This is a Blade directive that Laravel automatically expands into a hidden input field containing a security token. This token prevents Cross-Site Request Forgery (CSRF) attacks. Anytime you create a POST, PUT, or DELETE form in Laravel, you must include @csrf!

Step 2:Setting Up Routes

Now, let's configure our routes to handle both displaying the form and processing the submission:

<?php

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\UserController;

Route::get('/', function () {
    return view('home');
});

Route::post('/register', [UserController::class, 'register']);

Explanation:

We define two routes that look similar but serve completely different purposes because of their HTTP verb:

Route::get('/'): A standard GET request, used to simply fetch and display the home view (the form).
Route::post('/register'): A POST request, which is specially designed to send data to the server. This route does not display a view, it directs the data to our Controller for processing.

Step 3:Creating the Controller

Now we move to the brain of the operation, the Controller.

To create the controller, run the following Artisan command in your terminal to create the Controller file:

php artisan make:controller UserController

This creates the file app/Http/Controllers/UserController.php.

Code snippet:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller
{
    public function register(Request $request){
        $incomingFields = $request->validate([
            'name' => 'required',
            'email' => 'required|email',
            'password' => 'required'
        ]);
        return "Hello from controller";
    }
}

The Power of the Controller

The most important part of this code is the Request $request parameter in the method signature.

The Request Object:When the router directs the data flow here, it packages all the form information, headers, and metadata into a single, powerful object: $request. The controller's primary job is to interact with this object.

The first thing we do is call $request->validate([...]). This line is doing heavy lifting:

It collects the form fields(name,email,password).
It checks each field against the rules you defined.
If any rule fails, Laravel stops the script, sends the user back to the form, and stores the errors for us to display. No need for manual redirection or error handling!

What's Next

We have successfully built the full circuit: View -> Route -> Controller.

Currently, we only validate the data. In the next part, we will discuss Database Migrations and Eloquent Models to set up our user table and complete the "Create" step by securely hashing the password and saving the user record to the database!

Getting Started with Laravel.

Nelson Orina — Sat, 18 Oct 2025 16:34:42 +0000

So, you've heard about Laravel, the most popular PHP framework for a reason. It's elegant, powerful, and makes web development a joy. But starting can seem daunting. Worry not! This guide will walk you through creating your very first Laravel application, from setting up your environment to running a "Hello, World" page.

What We'll Cover:

Setting Up Your Environment
Installing Laravel
Understanding the Project Structure
Running Your Development Server
Creating Your First Route & View

Step 1:Setting Up Your Environment
Before we can write any Laravel code, we need the right tools. Laravel requires PHP, a package manager called Composer, and some PHP extensions.

For Ubuntu/Linux Users
If you're using Ubuntu or another Debian-based distribution, open your terminal and follow these steps:

1.Update Your Package List

sudo apt update

2.Install PHP with Required Extensions
Laravel requires several PHP extensions. Install them all with :

sudo apt install php php-cli php-fpm php-json php-common php-mysql php-zip php-gd php-mbstring php-curl php-xml php-bcmath php-json

3.Install Composer

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
sudo chmod +x /usr/local/bin/composer

4.Install and Configure a Database
For MySQL:

sudo apt install mysql-server mysql-client
sudo mysql_secure_installation

For PostgreSQL:

sudo apt install postgresql postgresql-contrib

5.Verify Your Installation

php --version
composer --version

You should see version numbers for both.

For Windows Users
The easiest way is to use Laragon:

Download and install Laragon(choose the "Full" version)
It automatically includes PHP, Composer, MySQL, and more
Launch Laragon and you're ready to go!

For Mac Users
Use Laravel Herd for the simplest setup:

Download and install Laravel Herd
It automatically manages PHP versions and includes Composer 3 . It is incredibly simple and just works

Manual Installation (Any OS)

PHP:Download from php.net

2.Composer:Follow instructions at getcomposer.org

3.Database:Install MySQL, PostgreSQL, or SQLite

Verify everything is working:

php --version
composer --version

Step 2:Installing Laravel
Now for the fun part! We'll use Composer to create a new Laravel project.

1.Open your terminal
2.Navigate to the directory where you want to keep your projects (e.g., cd ~/Sites or cd C:\Apache\htdocs).
3.Run the following command to create a new project named my-first-blog:

composer create-project laravel/laravel my-first-blog

This command will download all the necessary Laravel files and dependencies. It might take a few minutes.
Once it's done navigate into your new directory:

cd my-first-blog

Step 3:A Quick Look at the Project Structure
Let's open the my-first-blog folder in any code editor(like VSCode). Here are the key folders you will work with:

app/: The heart of your application. This is where you'll write your models, controllers, and core logic.
config/: Contains all the configuration files for your app(database, mail, etc.).
database/: Houses your database migrations, seeders, and factories.
public/: The web server's document root. Your index.php file is here. This is the only folder accessible to the public.
resources/: Contains your views(Blade templates), CSS, and JavaScript (if using Vite).
routes/: This is where you define your application's endpoints. The web.php file is where we'll start.

Step 4:Running Your Development Server
Laravel comes with a built-in development server that's perfect for local testing.

Make sure you are in your project's root directory (my-first-blog) in the terminal and run:

php artisan serve

Artisan is Laravel's command-line tool.
The terminal will output something like:

Starting Laravel development server: http://127.0.0.1:8000

Open your web browser and go to http://127.0.0.1:8000. You should see the default Laravel welcome page.
Congratulations! Your Laravel application is now live.

Step 5:Creating Your First Route and View
Let's move beyond the default page and create a simple "Hello, World!" page.

1.Define a Route:
Open the routes/web.php file. You'll see a default route. Let's add a new one.

<?php

use Illuminate\Support\Facades\Route;

//This is the default route that shows the welcome page
Route::get('/', function(){
   return view('welcome');
});

//This is our new route
Route::get('/hello', function(){
   return "Hello, World!";
});

Save the file. Now, go to http://127.0.0.1:8000/hello in your browser. You should see the plain text "Hello, World!".

2.Create a View (A Proper HTML Page):
Returning plain text is fine, but let's create a proper HTML page.

Go to the resources/views/ folder.
Create a new file called hello.blade.php.
Add some simple HTML to this file:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>My First Laravel Page</title> 
   </head>
   <body>
      <h1>Hello from my first Laravel View</h1>
      <p>This is HTML, served from a Blade template.</p>
   </body> 
</html>

3.Update the Route to Use the View:
Now, go back to routes/web.php and change the /hello route to return this view instead of the plain text.

Route::get('/hello',function(){
   return view('hello');//This points to resources/views/hello.blade.php
});

Refresh your browser at http:/127.0.0.1:8000/hello. You should now see your styled HTML page!

What's Next?
You've successfully set up your environment, installed Laravel, and created your first custom page! From here, you can expore:

Blade Templating for more dynamic views
Controllers to organize your code better
Database & Eloquent ORM to work with data

Introduction to Playwright.

Nelson Orina — Sat, 04 Oct 2025 13:29:50 +0000

Introduction

The web today isn't what it used to be. For years, I relied on request and BeautifulSoup to extract data from the web.It worked perfectly until it didn't. I hit a wall when websites started loading content dynamically with JavaScript. That's when I discovered Playwright.

What is Playwright?
Playwright is an open-source automation framework developed by Microsoft. It allows you to control modern browsers with simple code. Instead of just fetching static HTML Playwright:

Renders the full page, executing all JavaScript just like a human user.
Interacts with elements like clicking buttons, filling forms, scrolling, and even waiting for content to load as needed.
Works consistently across all modern browsers.

Why Use Playwright?
Here are just a few things you can do with it:

Scrape dynamic websites that load content via JavaScript
Write end-to-end test for complex web applications.
Automate repetitive tasks like form submissions or screenshots.

In this first post, I'm going to document my first steps with Playwright. We'll move from theory to practice by installing it and writting a simple script to scrape a site that would have been impossible with my old toolkit.

Getting Started with Playwright

Now that we know why Playwright matters, let's actually install it and run our first script. I'll use Python here, but Playwright also works with Node.js, Java and .NET.

Step 1: Install Playwright

First, let's install the Playwright package using pip:

pip install playwright

Once installed, we need to install the browser binaries. Playwright can control Chromium, Firefox, and WebKit(Safari):

playwright install

This command installs the necessary browsers so Playwright can control them.

Challenge Encountered: Missing Host Dependencies
After running the playwright install command, I encountered a warning that initially confused me. While the browsers were successfully downloaded and placed in the cache, the Playwright host system validation noted that my Linux operating system was missing essential libraries needed for the browsers to actually run.

Here is the exact warning I received:

Playwright Host validation warning: 
╔══════════════════════════════════════════════════════╗
║ Host system is missing dependencies to run browsers. ║
║ Please install them with the following command:      ║
║                                                      ║
║      sudo playwright install-deps                    ║
║                                                      ║
║ Alternatively, use apt:                              ║
║      sudo apt-get install libwoff1\                  ║
║      ... [and a long list of other libraries]        ║
║                                                      ║
╚══════════════════════════════════════════════════════╝

Resolving the Dependency Issue
The good news is that the Playwright team anticipated this and provided two clear solutions.

Solution A: Using the Recommended Playwright Command

Playwright provides a single, easy-to-use command specifically for installing these system dependencies:

sudo playwright install-deps

I attempted to run this command outside of my virtual environment, but it immediately failed:

orina@Orina:~$ sudo playwright install-deps 
[sudo] password for orina: 
sudo: playwright: command not found

The issue here is that the playwright command is installed within my isolated Python virtual environment (venv). Even though I was running it with sudo, my system's global PATH did not include the virtual environment's binary directory, leading to the command not found error.

To correctly use this command, I would have needed to either:

Use the absolute path to the executable inside the venv: sudo /path/to/venv/bin/playwright install-deps
Or, run the command while inside the venv and use the -E flag with sudo to preserve the environment variables: sudo -E playwright install-deps

Solution B: Manually Installing Dependencies with apt (The Fix I Used)

Rather than debugging the path issue, the most reliable and straightforward fix was to use the list of packages provided for my Linux distribution and installing the directly onto the hosts system using apt-get:

sudo apt-get install libwoff1 libvpx9 libevent-2.1-7t64 libgstreamer-gl1.0-0 libgstreamer-plugins-bad1.0-0 libwebpdemux2 libharfbuzz-icu0 libenchant-2-2 libsecret-1-0 libhyphen0 libmanette-0.2-0 libflite1 gstreamer1.0-libav

Step 2: Writing Our First Playwright Script

Now that we have all dependencies installed, let's create our first Playwright script. I'll break this down into manageable parts with detailed explanations.

Create a file called first_scraper.py and let's build it step by step.

Part 1: Import and Basic Setup

from playwright.sync_api import sync_playwright

def main(): 
   #The sync_playwright() context manager handles browser lifecycle 
   with sync_playwright() as p:

Explanation

from playwright.sync_api import sync_playwright: We import the synchronous API. Playwright also has an async API, but we're starting with synchronous for simplicity.
with sync_playwright() as p: This context manager automatically handles starting and stopping Playwright. The p variable gives us access to the Playwright instance.

Part 2: Launching the Browser

#Launch a Chromium browser instance 
#headless=False means we'll see the browser window 
browser = p.chromium.launch(headless=False)

Explanation

p.chromium.launch(headless=False): This launches a Chromium browser.
- headless=False means the browser window will be visible. For production scripts, you'd set this to True to run in the background.
- You could also use p.firefox.launch() or p.webkit.launch() for other browsers.
The browser variable represents the browser instance we'll work with.

Part 3: Creating a Page and Navigation

#Create a new page (tab) in the browser
page = browser.new_page()

##Navigate to a website
page.goto('https://webscraper.io/test-sites/e-commerce/more')

Explanation

browser.new_page(): Creates a new tab/page in the browser. Most of our interactions will happen through this page object.
page.goto('https://webscraper.io/test-sites/e-commerce/more'): Tells the browser to navigate to the specified URL. Playwright automatically waits for the page to load.

Part 4: Interacting with the Page

#Get the page title and print it 
title = page.title()
print(f"Page title: {title}")

#Take a screenshot of the entire page 
page.screenshot(path='screenshot.png')
print("Screenshot saved as 'screenshot.png'")

Explanation

page.title(): Returns the title of the current page (what you see in the browser tab).
page.screenshot(path='screenshot.png'): Captures a screenshot of the entire visible page and saves it to a file.

Part 5: Finding and Extracting Content

#Extract the main heading using a CSS selector 
heading = page.text_content('h1')
print(f"Main heading: {heading}")

#Extract all paragraph text 
paragraphs = page.query_selector_all('p') 
print("Paragraphs found:")
for i, paragraph in enumerate(paragraphs,1): 
   print(f"{i}. {paragraph.text_content()}")

Explanation

page.text_content('h1'): Finds the first <h1> element and extracts its text content.
page.query_selector_all('p'): Finds ALL <p> elements on the page and returns a list.
enumerate(paragraphs,1): Loops through the paragraphs with numbering starting at 1.
paragraph.text_content(): Extracts text from each paragraph element.

Part 6: Cleanup

   #Close the browser
   print("Closing browser...")
   browser.close()

if __name__ == '__main__':
  main()

Explanation

browser.close(): Properly closes the browser and releases system resources. This is important to prevent memory leaks.
if name = 'main': Standard Python practice that ensures the main() function only runs when the script is executed directly.

Complete Script

Here's the complete script put together:

from playwright.sync_api import sync_playwright

def main():
    with sync_playwright() as p:

        browser = p.chromium.launch(headless = False)

        page = browser.new_page()
        page.goto('https://webscraper.io/test-sites/e-commerce/more')

        title = page.title()
        print(f"Page title: {title}")

        page.screenshot(path='screenshot.png')
        print("Screenshot saved as 'screenshot.png'.")

        heading = page.text_content('h1')
        print(f"Main heading: {heading}")

        paragraphs = page.query_selector_all('p')
        print ("Paragraphs found:")
        for i, paragraph in enumerate(paragraphs, 1): 
            print(f"{i}. {paragraph.text_content()}")

        print("Closing browser...")
        browser.close()

if __name__ == "__main__":
    main()

Running Our Script

Save the file and run it with:

python first_scraper.py

You should see:

A browser window opening and navigating to ---
Output in your terminal showing the page title, heading, and paragraphs.
A screenshot file created in your directory.

Here is the output on the terminal:

Here is the screenshot taken:

Step 3: Seeing Playwright's Real Power

While our first script works great, you might be thinking: "This looks similar to what I could do with requests + BeautifulSoup." And you'd be right; for this simple example.

But remember the dynamic content problem I mentioned in the introduction? Let me show you why Playwright is truly special. Try this quick experiment:

Create a file called `requests_vs_playwright.py`:

import requests 
from bs4 import BeautifulSoup 
from playwright.sync_api import sync_playwright

def compare_versions():

    """Compare JavaScript vs non-JavaScript versions of the same site"""

    print("COMPARISON: JavaScript vs Static Content")

    # Test the JavaScript version with requests (will fail)
    print("1.Testing Request on JavaScript version:")

    response = requests.get('https://quotes.toscrape.com/js/')
    soup = BeautifulSoup(response.content, 'html.parser')
    quotes = soup.find_all('div', class_='quote')
    print(f"Quotes found: {len(quotes)}")
    print(" Requests cannot see JavaScript rendered content")

    # Test the non-JavaScript version with requests
    print("2.Testing Request on non-JavaScript version:")
    response = requests.get('https://quotes.toscrape.com/')
    soup = BeautifulSoup(response.content, 'html.parser')
    quotes = soup.find_all('div', class_='quote')
    print(f"Quotes found: {len(quotes)}")
    print(" Requests can see static content")

    # Test the JavaScript version with Playwright
    print("3.Testing Playwright on JavaScript version:")
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto('https://quotes.toscrape.com/js/')
        quotes = page.query_selector_all('div.quote')
        print(f"Quotes found: {len(quotes)}")
        print(" Playwright can see JavaScript rendered content")

        browser.close()

if __name__ == "__main__":
    compare_versions()

In this file we are scrapping data from two similar sites the difference is one of the sites renders its content using JavaScript while the other utilizes a static html file. From the output of this file when you run python requests_vs_playwright.py you will notice that the first test case that is scrapping using requests & BeautifulSoup finds 0 quotes, on the other hand the third test case that is scrapping the same JavaScript webpage using Playwright finds all the quotes even though they are being rendered using JavaScript. The second test case is using requests & BeautifulSoup but it scrapping a webpage that utilizes static html files, that is why it is able to find the quotes.

Why This Matters:

The JavaScript version ('/js/') loads quotes dynamically after the page loads
Requests only sees the initial HTML skeleton - no quotes
Playwright waits for JavaScript to execute and sees the complete page
This is exactly the problem that made me switch to Playwright

Please try running this script on your own and observe the difference.

Expected output:

What We've Accomplished

In this first journey with Playwright, we've:

Identified the problem with traditional scraping tools for modern web applications.
Successfully installed Playwright and resolved real world dependency issues.
Written our first automation script that can navigate, extract content, and take screenshots.
Proven Playwright's superiority for dynamic content with an undeniable side-by-side comparison.

The most important takeaways is playwright sees what requests cannot and it renders JavaScript exactly like a human user, making previously "unscrapable" websites accessible again.

What's Next in Our Playwright Journey

This is just the beginning. In the next posts, we'll explore:

Interactice scraping - clicking buttons, filling forms, handling dropdowns.
Smart waiting strategies - waiting for elements, network idle, and custom conditions.
Authentication handling - logging into websites and maintaining sessions.
Advanced data extraction - tables, pagination, and complex data structures
Performance optimization - making our scripts faster and more reliable.

Stay tuned for the next post where we'll make our script truly interactive.

In the meantime, I'd love to hear about yout experiences with Playwright. Have you encounteres other dynamic content challenges? What websites are you thinking of automating? Let me know in the comments.

Mastering BeautifulSoup: Parsing, Navigating, and Extracting Data Like a Pro

Nelson Orina — Mon, 29 Sep 2025 18:35:43 +0000

Introduction

In our first tutorial, we learnt the basics of web scraping. Now, let's dive deeper into BeautifulSoup's powerful features.

1. Finding Elements: `find()` vs `find_all()`

Single vs Multiple Elements

<div class="product">
   <h3 class="title">Product 1</h3>
   <a href="/product1">View Product</a>
</div>

<div class="product">
   <h3 class="title">Product 2</h3>
   <a href="/product2">View Product</a>
</div>

#find() - returns FIRST matching element
first_product = soup.find('div', class_='product')

print(first_product)
#Output is the first div 

#find_all() - returns LIST of all matching elements
all_products = soup.find_all('div', class_='product')

print(all_products)
# Output: [<div class="product">...</div>, <div class="product">...</div>]

Practical Examples

#Get the first h1 tag
main_title = soup.find('h1')

#Get all paragraph tags
all_paragraphs = soup.find_all('p')

#Get all links
all_links = soup.find_all('a')

2. CSS Selectors with `select()` and `select_one()`

Powerful Selection Methods

<div class="product">
   <h3 class="title">Product 1</h3>
   <a href="/product1">View Product</a>
</div>

<div class="product">
   <h3 class="title">Product 2</h3>
   <a href="/product2">View Product</a>
</div>

#select_one() - returns first match (like find())
first_product = soup.select_one('.product')

print(first_product)
#Output is the div holding product one 

#select() - returns all matches (like find_all())
all_products = soup.select('.product')
print(all_products)
#Output is both divs in this case as they are of the same class.

CSS Selector Examples

#Select by class 
products = soup.select('.product-item')

#Select by ID 
header = soup.select('#main-header') 

#Complex selectors
featured_products = soup.select('div.product.featured')
product_titles = soup.select('div.product > h3.title')

select() is often more flexible than find_all() because you can use full CSS selectors, including nested element targeting.

3. Extracting Attributes and Data

Once we've located elements, the next step is usually to extract the actual information inside them such as text, links, or image URLs.

Extracting Text From Elements

Often, we just need the text content inside an element. You can access this using the .text or .get_text():

Getting Attributes

<div class="product">
   <h3 class="title">Product 1</h3>
   <a href="/product1">View Product</a>
</div>

<div class="product">
   <h3 class="title">Product 2</h3>
   <a href="/product2">View Product</a>
</div>

product_titles = soup.select('div.product > h3.title')

for title in product_titles:
   print(title.text)

#Output:
#Product 1
#Product 2

Both .text and .get_text() work the same way for most cases, so you can use whichever you prefer.

Extracting Attributes (href,src,etc.)

If you need to get the value of an attribute (like a link's href or an image's src), use .get():

#Extract all links and print their href values 
links = soup.find_all('a')
for link in links:
   print(link.get('href'))

#Output:
# /product1
# /product2

images = soup.find_all('img')
for img in images:
   print(img.get('src'))

#Output:
#/images/product1.png
#/images/product2.png

Pro Tip:

You can combine both text and attributes. For example, printing both the product name and its link:

products = soup.select('div.product')
for product in products:
   title = product.select_one('h3.title').text
   link = product.select_one('a').get('href')
   print(f"{title} -> {link}")

#Output: 
# Product 1 → /product1
# Product 2 → /product2

This is the typical pattern you'll use when building real scrappers, find the container element, then drill down into it to extract the data you need.

4.Handling Missing Data Gracefully

Sometimes websites may have missing fields, and trying to access them directly can cause AttributeError. A helper function like this ensures your scraper doesn’t break when data is missing.

Safe Data Extraction Techniques

def safe_extract(element, selector, default="Not available"):
    """Safely extract text from element with fallback"""
    found = element.find(selector)
    return found.text.strip() if found else default

# Usage in scraping loop
for product in products:
    name = safe_extract(product, 'h3')
    price = safe_extract(product, '.price', '$0.00')
    rating = safe_extract(product, '.rating', 'No rating')

    # Extract optional attributes safely
    image = product.find('img')
    image_src = image.get('src') if image else 'default.jpg'

5.Error Handling Pattern

Always wrap network calls in try/except blocks to prevent your script from crashing on connection issues:

try:
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    products = soup.find_all('div', class_='product')
    if not products:
        print("No products found - check your selectors!")

except Exception as e:
    print(f"Error during scraping: {e}")

Conclusion

In this tutorial, we moved beyond the basics and learned:

How to use find()/find_all() and CSS selectors (select()/select_one())
How to extract text and attributes from elements
How to combine data points for structured results
How to handle missing elements safely
How to implement error handling for more reliable scrapers

With these techniques, you can now confidently scrape more complex websites and built robust, maintainable web scrapers.

Complete End to End Example

Here is a simple scrapper that takes data from a sample e-commerce platform and prints out the details.

#importing the BeautifulSoup library and requests module
from bs4 import BeautifulSoup 
import requests

# Fetching the content of a webpage and parsing it with BeautifulSoup
# The URL is a test site for web scraping
url = "https://webscraper.io/test-sites/e-commerce/scroll"

#Sending a GET request to the URL 
#This returns a response object
request = requests.get(url)


soup = BeautifulSoup(request.content,"html.parser")
cards = soup.select('div.product-wrapper')
for card in cards:
    image = card.select_one('.img-fluid').get('src')
    price = card.select_one('span').text
    #The strip is used to remove any leading or trailing whitespace
    title = card.select_one('a.title').text.strip()
    description = card.select_one('p.description').text
    rating = card.select_one('p.review-count > span').text

    print(f"Title: {title}")
    print(f"Description: {description}")
    print(f"Price: {price}")
    print(f"Rating: {rating}")
    print(f"Image URL: {image}")
    print("-" * 40)

Title: Apple MacBook...
Description: Apple MacBook Air 13", Intel Core i5 1.8GHz, 8GB, 256GB SSD, Intel HD 6000, RUS
Price: $1347.78
Rating: 11
Image URL: /images/test-sites/e-commerce/items/cart2.png
----------------------------------------
Title: HP 250 G3
Description: 15.6", Core i5-4210U, 4GB, 500GB, Windows 8.1
Price: $520.99
Rating: 13
Image URL: /images/test-sites/e-commerce/items/cart2.png
----------------------------------------
Title: Lenovo ThinkPa...
Description: Lenovo ThinkPad Yoga 370 Black, 13.3" FHD IPS Touch, Core i5-7200U, 8GB, 256GB SSD, 4G, Windows 10 Pro
Price: $1362.24
Rating: 12
Image URL: /images/test-sites/e-commerce/items/cart2.png
----------------------------------------

First Steps Into Web Scraping

Nelson Orina — Sat, 27 Sep 2025 05:05:09 +0000

1. Setting up Environment
In order to start web scraping with python you first have to set up your development environment.

Firstly, navigate to your project

cd path/to/your/project

and run the command python -m venv venv . This creates a virtual environment in your project's root directory called venv.

Secondly, activate the created virtual environment by running the command source venv/bin/activate on mac or linux.
For windows run the command source venv/Scripts/activate for GitBash
Command Prompt: venv\Scripts\activate.bat
PowerShell: venv\Scripts\Activate.ps1

A virtual environment isolates your projects python dependencies from the rest of your system. This means you can have multiple projects in the same machine, each with its own python version and library version without conflict. This also makes it easier to share your projects with others by listing all your dependencies on a requirements.txt file

Once you activate your virtual environment, your terminal prompt will change. You’ll see the name of the virtual environment in parentheses before your username, for example:

(venv) user@User:~/Personal/WebScraping$

This is a clear sign that your project is running inside its own isolated Python environment. From here, any packages you install (like requests or beautifulsoup4) will only be available inside this project, not system wide which is exactly what we want.

2. Installing Necessary Packages
Now that our virtual environment is active, we can now install the necessary packages we need for web scraping.

The most common libraries used for beginners is:

Requests -> used to send HTTP requests and download web pages.
beautifulsoup4 -> a powerful tool that works hand-in-hand with a html parser. It takes the structured data created from the raw HTML and gives you a simple way to search, navigate and extract information from it.

You can install this libraries by running:

pip install requests beautifulsoup4

Once installation is done, it's a good idea to save you dependencies in a file called requirements.txt. This makes it easy to recreate the same environment later or share it with others.

pip freeze > requirements.txt

Now your requirements.txt will list all the installed packages.

3 Writing your First Scraper

Here is a simple Python web scraper that fetches a web page and prints its title.

This example is great for beginners because it shows the entire scraping flow in just a few lines of code:

1.Send an HTTP request to download a page.

2.Parse the page’s HTML with BeautifulSoup.

3.Extract a specific element (the h2 tag in this case).

4.Print the result.

# Import the BeautifulSoup class from the bs4 library
from bs4 import BeautifulSoup  

# Import the requests module to send HTTP requests
import requests  

# Define the target URL (this is a demo e-commerce site for practicing web scraping)
url = "https://webscraper.io/test-sites/e-commerce/scroll"

# Send a GET request to the URL
# This will download the HTML content of the page and return a response object
response = requests.get(url)

# Parse the HTML content of the page using BeautifulSoup
# The "html.parser" is a built-in parser that converts the raw HTML into a navigable tree
soup = BeautifulSoup(response.content, "html.parser")

# Find the first <h2> element on the page and extract its text content
# .text gets only the text between the tags, without the HTML tags themselves
title = soup.find('h2').text

# Print the result to confirm that everything worked correctly
print("Title:", title)

Here is the expected output of the above script:

4.Important: Web Scraping Best Practices

Before we continue, it's crucial to understand the legal and ethical aspects of web scraping:

Always check robots.txt (e.g., https://website.com/robots.txt)
Respect rate limits - don't overwhelm servers
Check the website's Terms of Service
Use scraping for legitimate purposes only
Consider using official APIs when available

5.Recap
In this tutorial, you've successfully:

Set up an isolated Python development environment using virtual environments.
Installed essential web scraping libraries (requests and beautifulsoup4)
Written your first functional web scraper that extracts data from a live website
Learned crucial best practices for ethical and responsible scraping.

While requests and BeautifulSoup are perfect for learning the fundamentals, modern web scraping often requires more advanced tools. In upcoming posts, we'll explore Playwright for handling JavaScript-heavy sites and n8n for building complete automation workflows without code.

DEV Community: Nelson Orina

Building a University Resource Sharing Platform: My Laravel Learning Journey

The Project Vision

Tech Stack

Key Learning #1: Resourceful Routing in Laravel

The Magic of Route Model Binding

Middleware Group for Security

Key Learning #2: Spatie Media Library for File Handling

How It Works:

1. Installation & Setup

2. Model Configuration

3. Database Structure

4. File Upload in Controller

5. Retrieving Files

Benefits of Spatie Media Library:

Key Learning #3: Eloquent Relationships & Eager Loading

Database Structure:

Model Relationships:

The N+1 Query Problem & Solution:

Key Learning #4: Conditional Validation

Key Learning #5: Inertia.js with Vue

Server-Side (Laravel Controller):

Client-Side (Vue Component):

Benefits of Inertia.js:

Laravel Models, Migrations, & Relationships: Setting Up The 'Post' Feature

What We'll Cover Today

Step 1:Generating the Post Model and Migration

1.The Artisan Command

2.Verification

Step 2:Defining the posts Database Structure

1.Update the Migration File

2.Key Columns Explained

Step 3:Running the Migration

1.The Command

2.Verification

Step 4: Configuring the Post Model

1.Set the $fillable Property

Step 5:Establishing the Eloquent Relationship

1. The user Model: One-to-Many(Has Many)

2. The Post Model:Inverse of One-to-Many(Belongs To)

Wrapping Up: What We've Accomplished

Laravel Models & Authentication: Setting Up User Registration & Login

What We'll Cover Today

Step 1:Running the Default Authentication Migration

1.The Migration Command

2.What Just Happened?

3.Verification

Step 2:Understanding the User Model and Database Structure

1.Locating the User Model

2.The Model's Role

3.Key Model Properties

Step 3:Completing Our Registration Functionality

1.Update the Registration Controller

Key Takeaways from the Code

Testing the Registration

Step 4:Adding Login and Logout Features

1.Implementing the Login Logic(Session Creation)

A. The Login Controller Method

2.Implementing the Logout Logic(Session Destruction)

A. The Logout Controller Method

3.Setting up Routes

Step5: Understanding Laravel's Security Features

1. Password Hashing

2. Session Fixation Prevention

3.Cross-Site Request Forgery (CSRF) Protection

4.Input Sanitization

Wrapping Up: What We've Accomplished

Laravel Form Handling & Controllers: Building a Registration Form

What We'll Build Today

Step 1:Creating the Registration Form View

Explanation:

Step 2:Setting Up Routes

Explanation:

Step 3:Creating the Controller

The Power of the Controller

What's Next

Getting Started with Laravel.

Introduction to Playwright.

Getting Started with Playwright

Step 1: Install Playwright

Step 2:Defining the `posts` Database Structure

Step 4: Configuring the `Post` Model

1.Set the `$fillable` Property

1. The `user` Model: One-to-Many(Has Many)

2. The `Post` Model:Inverse of One-to-Many(Belongs To)

Create a file called `requests_vs_playwright.py`:

1. Finding Elements: `find()` vs `find_all()`

2. CSS Selectors with `select()` and `select_one()`