Explore By Video

Event Loop & Async Basics

👉 JavaScript is single-threaded… so how does Node.js handle multiple tasks at once without freezing up? ⚡️

In this episode, we break down the event loop and explore the core async patterns every Node developer needs to know:

💥 You’ll learn:
- The single-threaded event loop and how Node.js handles I/O using libuv.
- Why non-blocking execution makes Node.js great for scalable servers.
- Callbacks (and why they can lead to callback hell 😱).
- Promises as a cleaner, modern alternative.
- Async/Await — syntactic sugar that makes async code look synchronous.


⚡️ With practical code examples, you’ll see how to move from nested callbacks ➡️ chained promises ➡️ clean async/await.

👉 Key takeaway: Mastering async is essential for writing reliable Node.js applications.

💡 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 & References:
- Node.js Blocking vs Non-blocking: https://nodejs.org/en/learn/asynchronous-work/overview-of-blocking-vs-non-blocking
- MDN Promise Docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
- MDN Async/Await Guide: https://developer.mozilla.org/en-US/docs/Learn_web_development/Extensions/Async_JS/Promises
- Understanding libuv: https://zmushegh.medium.com/understanding-libuv-the-powerhouse-behind-node-js-b5349c8f0d75

Events & Listeners

In this episode, we introduce event-based programming to the survey application and take a big step toward a decoupled, scalable architecture.

Instead of tightly coupling business logic inside controllers, we model real application behavior using events and listeners — allowing the system to react naturally to state changes and user actions. This is where the workflow starts to feel alive.

What You’ll Learn:

⚡ Event-Based Programming Concepts:
• What events are (and what they are not)
• Decoupling producers from consumers
• Synchronous vs asynchronous execution
• Why events scale better than conditionals

🛠 Hands-On Laravel Events:
• Creating observable events
• Creating multiple listeners
• Dispatching events from your domain
• Queuing listeners for background execution
• Convention-based auto-discovery

📚 Official Docs: https://laravel.com/docs/12.x/events

🗺 What’s Next: Laravel Commands

💡 This episode lays the foundation for truly reactive Laravel applications.
If you’ve ever felt your controllers getting “too smart,” this is the pattern you’ve been looking for.

💥 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

Exceptions

Errors happen, but how you handle them makes all the difference! In this video we dive into PHP exceptions and how they improve error handling.

We start by manually guarding against invalid data using if statements, then take it to the next level by introducing exceptions, covering:

✅ Throwing exceptions – How to signal when something goes wrong.
✅ Catching exceptions – Gracefully handling errors without breaking your code.
✅ Why exceptions are better than manual checks in many cases.

By the end of this tutorial, you’ll understand how to handle errors cleanly and professionally in PHP.

Exceptions & Errors

When things go wrong in your PHP application, how do you handle it? 🤔 In this video, we dive into the art of exception handling and smart error management! 🎯

🔹 Throwing & catching exceptions—what, when, and why? 🎭
🔹 Best practices for handling errors (logging, notifications, feature toggles) 📝
🔹 When to use try/catch blocks (external APIs, limited resources) 🔄
🔹 The role of a global exception handler 🛑
🔹 Throwing custom exceptions to make your code more meaningful 🏗️
🔹 Why exceptions can be expensive 💰 and how to use error objects instead ⚡

By the end, you’ll know exactly how to keep your application resilient, stable, and user-friendly! 💪 Let’s dive in! 🎬

Extracting Layout Components

In this video, we take a major step toward cleaner, more maintainable code by refactoring our static HTML into reusable layout components. ✂️➡️🧩

We’ll extract repeated sections of HTML into their own PHP partial view files:
• layout/_nav.view.php 🧭
• layout/_page_head.view.php 🧠
• layout/_header.view.php 🏷️
• layout/_page_foot.view.php 👣

This makes our pages easier to manage and sets the stage for a powerful layout system in future steps. 💡

By the end of this video, our project will be refactored and tagged as v3-layout-files—modular, organized, and ready to grow. 🚀

Fetch API Basics

Unlock the power of the Fetch API and take your JavaScript skills to the next level! ⚡️
In this video, you’ll discover how to:


Make lightning-fast GET requests with fetch()
Transform API responses into usable JSON 🔄
Handle errors like a pro (404s, network issues, and more) 🛑
Write cleaner, modern code with Promises and async/await ✨


Whether you’re pulling in jokes, quotes, or real-world data, this lesson gives you the tools to connect your app to the web 🌍 and make it truly dynamic.

👉 Hit play and start fetching like a pro! 🚀

File System - Create, Copy, Move, Link

This video is part of the Linux Crash Course series. This video will continue introducing the Linux File System. In this video you will learn how to create / remove directories, copy / move files, and everything you need to know about links.

Github Repo: https://github.com/rcravens/linux-crash-course

File System - Permission

This video is part of the Linux Crash Course series. This video will continue exploring the Linux File System. In this video you will learn about permissions and how to secure access to files.

Github Repo: https://github.com/rcravens/linux-crash-course

File System - Wildcards, Find, Search

This video is part of the Linux Crash Course series. This video will continue exploring the Linux File System. In this video you will learn how to search the file system for files or content inside those files.

Github Repo: https://github.com/rcravens/linux-crash-course

File System Basics - Navigation

This video is part of the Linux Crash Course series. This video will introduce the Linux File System. In this video you will learn how to navigate the file system.

Github Repo: https://github.com/rcravens/linux-crash-course

File-Based Storage

Ever wondered how to persist data without setting up a full database? In this episode, we explore file-based storage in Node.js — a simple way to read, write, and manage data using the filesystem.

Perfect for small projects, prototypes, or when you just need to get things done quickly ⚙️💾

👉 You’ll learn how to:
- Read and write JSON files asynchronously using fs/promises
- Implement full CRUD (Create, Read, Update, Delete) operations
- Handle data safely and understand file-based storage limitations
- Prepare your app for a transition to a real database later


💡 Relevant Links
Node.js Docs:
- Reading Files: https://nodejs.org/en/learn/manipulating-files/reading-files-with-nodejs
- Writing Files: https://nodejs.org/en/learn/manipulating-files/writing-files-with-nodejs

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

Final Refactor

Your JavaScript framework is complete 🧠⚙️

In this final refactor, we polish our custom Node.js MVC framework — bringing everything together into a clean, organized, and extensible foundation worthy of real-world projects 💪

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

🧩 Move core classes like BaseController and BaseModel into the app layer
🧠 Refine the Router to handle static assets and feed request body data to middleware
🔒 Strengthen encapsulation and enforce single responsibility
✍️ Apply DRY principles and consistent coding style across the codebase
🎁 Add a fun “Easter Egg” route using your new framework

By the end, you’ll have built a lightweight but powerful Node.js framework — and gained a deep understanding of how professional frameworks like Express are designed under the hood 🚀

💡 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

Libraries mentioned:
- Node.js http: https://nodejs.org/api/http.html
- Node.js fs: https://nodejs.org/api/fs.html
- Node.js path: https://nodejs.org/api/path.html

Final Review & Refactor

This video is all about the last layer of polish — a final walkthrough to tidy up code, views, and structure across the project. Here’s what we touched:

🖼️ Views
- index.view.php: added wider screen support with max-w-7xl.
- Removed a duplicate header to clean up the layout.

🧱 Framework Cleanup
- Database.php: fixed IDE issues and added helpful annotations.
- globals.php: minor tweaks to smooth dev experience.
- Model.php: highlighted PHPDoc comments, reviewed skip(), take(), and orderBy() methods.
- Session.php and View.php: both got the “FII” treatment (Fix IDE Issues).

📦 Http Layer
- Policies:
- UserPolicy: FII.
- Controllers:
- AuthenticationController, PhotoController, RegisterController, ReviewController, and UploadController: all reviewed and cleaned up.

🌐 Public Entry Point
- index.php: adjusted try/catch block for better error handling and clarity.


🎯 And that wraps things up at v28-review-refactor — setting the stage for a maintainable, scalable app with a solid foundation.

Fingerprint Refactoring

In this video, we tighten up our survey flow by performing several important refactors across models, routes, and controllers. These changes lay the groundwork for securely capturing survey responses and preventing duplicates.

Topics Covered
- Adding model relationships: Survey → responses, SurveyQuestion → answers
- Introducing a fingerprint-based protection to avoid duplicate survey submissions
- Updating database migrations to support hashed response identifiers
- Creating a clean, structured route layout for:
✔️ Viewing a survey
✔️ Submitting a fingerprint
✔️ Viewing the survey questions
✔️ Submitting survey answers
- Refactoring TakeSurveyController to support the new workflow

💥 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 #FullStack #LaravelTutorial #Programming #SurveyApp #TechEducation #LaravelDevelopers #BuildInPublic #TekCasts

First Review & Refactor

It’s time to pause and sharpen the tools. In this video, we take a step back to review our progress and clean up our codebase, because maintainability is key to sustainable development. 🛠️

Here’s what we tackle in version v16-framework-refactor:


Emphasize the value of regular review and refactor sessions 🧠
Review our entry point (public/index.php) and extract logic into a new App class 📦
Create Framework/App as a singleton with a start() method to centralize bootstrapping 🚀
Address messy relative paths like '../../' by creating a dedicated Path helper class 🧭
Build Framework/Path as a singleton and introduce helpers like app(), root(), require_app(), and require_root()
Refactor all path-related code to use these clean, expressive helpers 📁
Move globals.php into the Framework directory to keep framework-related code encapsulated
Clean up and clarify all require/import statements 🔄


This refactor sets us up for a cleaner, more organized foundation—making our mini-framework easier to navigate, extend, and love. 💡