Explore By Video

Control Flow – Loops

Ever wish your code could repeat itself without repeating yourself? That’s the magic of loops — and in this episode, you’ll learn how to write them like a pro. 🌀

🎯 Here’s what we’ll cover:
• Why loops matter: run code multiple times without copying and pasting.
• Use the classic for loop to count or iterate through values.
• Learn the while loop for flexible repetition when the end condition isn’t known in advance.
• Try out the do…while loop, which guarantees at least one execution.
• Understand break and continue for more control inside your loops.

🎥 Visual Walkthroughs:
• See real-time examples of different loop types in action.
• Learn when to use each loop and how they differ in behavior.
• Practice repetition with simple, visual examples to build confidence.

By the end of this episode, you’ll be looping like a champ — and writing code that works smarter, not harder! ♻️⚙️

Controller Basics

In this episode, we tie together Routes, Models, and Views by introducing the Controller — the final piece of Laravel’s MVC architecture.

You’ll learn how to:
✅ Create controllers using php artisan make:controller
✅ Organize request-handling logic into clean, reusable classes
✅ Connect routes to controller methods (actions)
✅ Implement GET and POST routes for taking a survey
✅ Apply route model binding and request/response patterns

We’ll also clean up a few loose ends before diving into survey submissions:
- Add default error pages
- Rename SurveyStatusType → SurveyStatus
- Guard routes against non-active surveys
- Add an index to hash in migrations
- Demonstrate booted() and enum casting in the Survey model
- Simplify the factory by removing hash logic

Copy these commands to follow along:
php artisan make:controller TakeSurveyController

Example routes:
- Route::get('/s/{survey:hash}', [TakeSurveyController::class, 'show'])->name('survey.show');
- Route::post('/s/{survey:hash}', [TakeSurveyController::class, 'store'])->name('survey.store');

📘 Resources
- Laravel Controllers Docs: https://laravel.com/docs/12.x/controllers
- Laravel Routing Docs: https://laravel.com/docs/12.x/routing
- Laravel Model Events Docs: https://laravel.com/docs/12.x/eloquent#events
- Laravel Error Pages Docs: https://laravel.com/docs/12.x/errors#http-exceptions
- Migration Modifications Docs: https://laravel.com/docs/12.x/migrations#modifying-columns

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PHP #WebDevelopment #MVC #Controllers #Routing #Eloquent #TekCasts #LearnToCode

Cookies

HTTP is stateless — every request is brand new.
So… how do we remember users, personalize experiences, or keep them logged in?

That’s where cookies come in 🍪✨

👉 In this episode, you’ll learn how to:

🚀 Read and parse cookie data from incoming requests
⚙️ Set and clear cookies from your server responses
🔐 Understand cookie flags like HttpOnly, Max-Age, and Path
🧠 Explore real-world uses like sessions, personalization, and analytics

By the end, you’ll have a working mental model of how state travels between client and server — and how cookies form the foundation of sessions and authentication in modern web apps.

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment


Official Docs & Resources:
- MDN: HTTP Cookies — https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies
- Node.js HTTP Module — https://nodejs.org/api/http.html
- MDN: HTTP Headers — https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers

Cookies

In this video, we explore Laravel Cookies—what they are, how they work under the hood, and how your Laravel application can set, retrieve, and delete them. Cookies are one of the foundational building blocks for maintaining state in a stateless HTTP world, and understanding them sets the stage for working with sessions effectively. In this video you will learn:

🔹 What Cookies Are
- Why HTTP is stateless and how cookies help solve that
- How cookies allow the server to remember clients across requests
- Where cookies are stored and how they travel between client and server
- Client-side vs server-side visibility (HTTP-only vs accessible from JavaScript)
- Common uses (session identifiers, personalization, analytics, etc.)

🔹 Setting Cookies in Laravel
- You’ll see how Laravel allows you to:
- Queue cookies to be added to the outgoing response
- Attach cookies directly to a response object
- Configure cookie attributes such as expiration time, path, domain, secure mode, and HTTP-only mode
- Work with encrypted cookies (default in Laravel)
- We walk through multiple approaches, and the vid eo explains when you’d use each one.

🔹 Retrieving Cookies
We compare:
- Raw PHP cookie access
- Laravel’s cookie retrieval helpers
- Using the request object to access cookies
- Automatically decrypted values in Laravel

🔹 Deleting Cookies
You’ll see how to invalidate cookies and remove them properly from the browser.

🔹 Production Considerations
We discuss:
- Why you almost always want encrypted or signed cookies
- What types of data should not be stored in cookies
- Practical tips for secure cookie handling

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PHP #WebDevelopment #SoftwareEngineering #BackendDevelopment #CodingBestPractices #TechEducation #LearnToCode #TekCasts

Creating A Master Layout

Let’s streamline our app’s structure even further! In this video, we tackle layout repetition by introducing a master layout—making our pages cleaner and more consistent. 🧼

Here’s what we’ll cover:
• Refactor repetitive layout code into layout/app.view.php using a $page_content placeholder for dynamic content 🧩
• Enhance our view() helper function to accept a third $layout parameter 🧠
• Update controllers to support a page_layout variable for flexibility in rendering 🛠️
• Clean up our individual page views for clarity and focus ✂️
• Bonus: Improve our dd() helper to accept any number of arguments using ...$var 🧪

By the end of this refactor, we’ll be rocking version v8-create-layout—a polished, DRY, and maintainable foundation for future growth. 🚀

Creating Views

Let’s clean up our code and separate logic from markup—the pragmatic way! In this video, we refactor each page to use dedicated view files, making our structure more scalable and maintainable. 🧼📁

Here’s what we’ll do:
• Move HTML into organized view files:
• views/about/index.view.php 🧾
• views/photo/index.view.php 📷
• views/upload/index.view.php ⬆️
• Create a global view() helper function to simplify view rendering across the app 🛠️

This separation of concerns brings clarity to our project and lays the groundwork for a clean MVC structure. By the end, we’ll be rocking version v5-created-views—structured, readable, and ready for action! 🚀

Creating, Removing, & Cloning Elements

Web pages don’t have to be static — with JavaScript, you can build, destroy, and duplicate elements on the fly. In this video, we’ll dive into the core DOM methods that let you take full control over your UI.

Here’s what you’ll master:
🧩 Creating nodes with createElement & createTextNode
📌 Inserting elements using append, appendChild, and prepend
🗑️ Removing nodes gracefully with .remove() and .removeChild()
🪞 Cloning entire elements with cloneNode(true/false)
⚡ Building dynamic UI components—like interactive tables, buttons, and more

You’ll see:
✅ Why innerHTML isn’t always your best friend
✅ How to dynamically add “Remove” and “Clone” buttons to a table
✅ A hands-on demo where rows can be added, deleted, or duplicated — all with clean JavaScript

By the end, you won’t just be reading the DOM — you’ll be shaping it, sculpting it, and breathing life into it 💡🚀

👉 Watch this video and unlock the power to create and control dynamic UIs!

Custom Alerts / Toasts

n this video, we take a practical, hands-on look at Alerts / Toast Messages and how they fit into Laravel’s session-driven workflow.

You’ll learn:
✨ What alerts/toasts are and why real applications rely on them
✨ How to build a clean, reusable alert component on the front end
✨ How to create a smooth developer experience on the back end
✨ How to connect both pieces using Laravel’s session flash data
✨ How to display success, warning, and error messages seamlessly

We walk through the full flow—from triggering messages in your controllers to rendering beautiful toast-style alerts in your UI. This is a foundational building block for providing meaningful feedback to your users.

By the end of the video, you’ll have a custom-built alert system that works across your entire application and follows Laravel’s best practices.

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PHP #WebDevelopment #FullStackDev #BackendDevelopment #CodingTutorial #TekCasts

Custom Middleware

In this video, we explore how to create and use custom middleware in Laravel—one of the most powerful tools for intercepting and transforming HTTP requests and responses.

You'll learn how middleware works behind the scenes, how to build your own, and how to apply it to your routes using both class names and aliases. We walk through several practical examples that demonstrate how middleware can redirect users, modify incoming request data, and even alter outgoing HTML responses.

What We Cover
- Generating custom middleware with Artisan
- Understanding the handle() method lifecycle
- Adding logic before and after the request reaches your controller
- Building a middleware that performs redirects
- Creating route aliases for cleaner middleware usage
- Modifying incoming request data (e.g., normalizing phone numbers)
- Injecting additional content into outgoing HTML responses
- Managing configuration-driven UI banners
- Tagging and pushing source code for versioning

This video provides a solid foundation for writing expressive, maintainable middleware tailored to your application's needs.

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PHP #WebDevelopment #SoftwareEngineering #Coding #Developers #Programming #FullStack #TekCasts

Daily Digest & Task Scheduler

Building features is one thing. Automating insight delivery is where real applications shine.

In this episode, we wire up a Daily Digest Email system that automatically summarizes survey results and delivers them on a schedule—using real Laravel patterns you’ll use in production.

🚀 What You’ll Learn:
- Creating queued jobs for email delivery
- Building Markdown mailables
- Writing custom Artisan commands
- Scheduling recurring tasks with Laravel Scheduler
- Coordinating jobs, commands, and cron
- Production vs development scheduling workflows

🛠 Hands-On Topics:
- SendDigestEmailJob (queued background processing)
- SurveyDigest mailable with Markdown templates
- SendDigestEmails Artisan command
- Daily scheduling with schedule:run
- Cron configuration best practices
- Safe execution with withoutOverlapping() and onOneServer()

🧠 Why This Matters. This episode ties together:
- Jobs & queues
- Commands
- Task scheduling
- Email delivery
- Real-world automation patterns

Exactly how maintainable Laravel applications evolve beyond CRUD.

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PragmaticLaravel #PHP #CleanCode #TekCasts

Daily Stats & Commands

As your application matures, data aggregation and automation become critical.

In this episode of Pragmatic Laravel, we shift from raw survey responses to actionable insights by building daily statistics, dashboards, background jobs, and Artisan commands — all using real-world Laravel patterns.

This isn’t theory. This is how production Laravel apps evolve.

🧠 What You’ll Learn:
- How to design and store daily aggregated survey statistics
- Building a survey dashboard with daily stats & detailed results
- Creating and running custom Artisan commands
- When to use jobs vs commands (and how they work together)
- Generating realistic fake data to test reporting workflows
- Wiring UI actions (like “Refresh”) to backend jobs

🛠 Hands-On Topics Covered:
- Daily Stats Table & Schema
- RecordSurveyStats Job
- Survey Dashboard Views
- Artisan Commands (php artisan make:command)
- Realistic survey result visualization

🧩 Why This Matters: Most tutorials stop at “saving data.”

This episode shows how to:
- Summarize data
- Automate insights
- Prepare for scheduling & reporting
- Build features users actually care about

This is the bridge between CRUD apps and real business software.

▶️ Up Next: Scheduling job using the Laravel Task Scheduler

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PragmaticLaravel #PHP #CleanCode #TekCasts

Data Types

Understanding data types is essential for writing efficient and error-free PHP code! In this video, we’ll break down PHP’s core data types, including strings, integers, floats, and booleans, and show you how they work in real-world applications. You’ll learn how to:

✅ Properly name and assign variables
✅ Work with strings, including concatenation and the differences between single and double quotes
✅ Perform simple math with integers and floats, while exploring PHP’s type juggling
✅ Understand booleans and how PHP dynamically handles truthy and falsy values

By the end of this video, you’ll have a solid grasp of PHP’s data types and be ready to start building dynamic applications with confidence! 🚀

Database Connections / Migrations

Let’s connect our app to the real world of data! In this video, we build a reliable and secure database layer and run our first migrations and seed scripts. This step sets the stage for persistent data handling in our application. 🧱

Here’s what we cover:
• Temporarily hijack index.php for local development and testing purposes 🔧
• Add database/migrate.sql and database/seed.sql to define and populate our schema 🧬
• Use file_get_contents() to load SQL scripts and run them using PDO 🎯
• Define connection settings: host, port, database name, user, and password (with Docker-friendly defaults) 🐳
• Set up secure PDO options for error handling and safe queries 🔐
• Wrap everything in a try/catch to safely execute migrations and seeding 🚨
• Introduce our app’s database structure:
• users – for login info 👤
• photos – uploaded images 📸
• reviews – ratings and comments ⭐📝
• Protect sensitive credentials by moving them into a .env file 🛡️
• Create a Framework/Env.php class to access environment variables cleanly 🌱

By the end of this video, version v11-db-basics will bring real data into play—securely, cleanly, and pragmatically. 🚀

Database Infrastructure

Let’s encapsulate our database logic the pragmatic way! In this video, we refactor our raw database code into a dedicated Database class, making connections and queries more reusable, readable, and testable. 🛠️

Here’s what we’ll do:


Create a Framework/Database class that accepts config parameters in the constructor ⚙️
Expose an exec() method for executing raw SQL 🧾
Add a static instance for quick access to a shared connection 🌐
Introduce helper methods: first() to fetch a single record & all() to fetch multiple records
Write a simple query to fetch a photo by ID and pass it into the view dynamically 📸
Update the View class to properly render passed variables inside templates
Introduce a private render_template() method to handle this cleanly 🧩


By the end of this refactor, we’ll be on version v12-db-encapsulation—with database access that’s clean, powerful, and built to scale. 🚀

Database Migrations

In this episode, we introduce one of Laravel’s most powerful features: database migrations. You’ll learn how migrations act like version control for your database, making schema changes reliable, reversible, and easy to manage across development and production environments.

💡 What You’ll Learn
- How Laravel’s database abstraction layer simplifies working with different databases
- Designing a database schema for the Survey App (surveys, sections, and questions)
- Creating and running migrations with php artisan make:migration and php artisan migrate
- Rolling back and modifying migrations safely
- Configuring your database connection in Laravel
- Verifying your schema and data in your local environment

🧠 By the end of this video, you’ll have a working database structure ready for your Eloquent models — a major milestone toward a fully dynamic survey application.

🔗 Resources
- Laravel Database Docs: https://laravel.com/docs/12.x/database
- Laravel Migrations: https://laravel.com/docs/12.x/migrations

💥 About the Series:
Pragmatic Laravel focuses on building real applications with Laravel — emphasizing clarity, maintainability, and thoughtful design decisions instead of shortcuts or magic.

#Laravel #PHP #TekCasts #WebDevelopment #DatabaseMigrations #FullStack #LaravelTips #SoftwareEngineering #PHPDevelopers