Explore By Video

Setup a Development Environment

Before you start coding in PHP, you need the right tools! In this video, we’ll guide you through setting up a local development environment step by step. You’ll learn how to install PHP, set up a local server using XAMPP, MAMP, or the built-in PHP server, and explore containerized options like Docker. We’ll also discuss different code editors, from lightweight options like Sublime Text to powerful IDEs like PHPStorm and Visual Studio Code. By the end of this video, you’ll have everything configured and ready to start coding in PHP like a pro! 🚀

Simple Frontend Architecture

✨ Before you write thousands of lines of JavaScript, you need a solid foundation.

In this video, we’ll explore how to structure frontend applications so your code stays organized, modular, and maintainable — even as your project grows.

You’ll learn:
⚡ Why separation of concerns prevents “spaghetti JS”
📦 The power of modularization (breaking one big file into smaller, focused ones)
🛠 Principles like YAGNI, DRY, SRP, and Decoupling to guide clean architecture
🔄 How event-driven patterns make your apps more reactive and less fragile

To wrap things up, we’ll also walk through a quick example of creating a custom browser event — showing how components can communicate without tight coupling.

👨‍💻 This isn’t about writing tons of code — it’s about learning the architectural principles that make every line of code easier to understand and maintain.

Software

Now that the hardware’s wired up, it’s time to breathe life into the Smart Garage Door with code! 🚀

In this episode, we walk through the entire software that powers the project — written with clean, object-oriented design to keep things modular and maintainable 🧼👨‍💻.

We do a full code review and break down the key classes that make everything tick:

🔹 DoorSensor – encapsulates logic for detecting the door’s position
🔹 DoorButton – handles interactions with the door opener button
🔹 GarageDoor – the high-level controller that integrates with Apple Home using HomeSpan. It pulls it all together and exposes the device as a HomeKit accessory 🍏🏠

You’ll see how these components work together — and how dependency injection keeps things clean by passing DoorSensor and DoorButton instances right into the GarageDoor class constructor.

Whether you’re into embedded dev, smart home integrations, or just love clean code, this video dives into the software heart of the project. Let’s build smart! 💡💻

Static HTML to PHP

It’s time to bring our static site to life! In this video, we take the first step toward dynamic content by converting our plain HTML files into PHP. 🧩

Here’s what we’ll cover:
• Renaming .html files to .php ✅
• Updating the navigation links in two key places on each page for consistency 🔗

By the end of this video, our project will be PHP-ready and set up for future enhancements. This version is tagged in the repo as v2-php-files for easy reference. 🏷️

It’s a small change with big impact—let’s keep the momentum going! 🚀

Static Methods and Properties

Ever wondered when to use static properties and methods? 🤔 In this video, we break it all down! 🔍

We’ll start with a quick refresher on normal properties and methods, then dive into their static counterparts. 🏗️ What’s the difference? Static members belong to the class—shared across all instances—while normal members are instance-specific. 🌎➡️📦

But wait—static properties aren’t constants! ⚠️ We’ll explore constant properties using const and discuss real-world use cases where static methods shine. ✨

By the end, you’ll know exactly when and why to use static members in your PHP projects! 💡💻 Let’s go! 🎬

Submitting Reviews

It’s time to let users have their say! In this video, we implement the “Leave a Review” feature, allowing users to submit feedback on photos directly from the app. 💬

Here’s what’s packed into version v17-leave-review:


Add a POST route to handle form submissions 🛤️
Stub out the PhotoController::store method as our entry point for review handling
Wire up the review form and hook it into the controller 🧵
Introduce basic validation to catch missing fields or bad data 🧼
Add temporary dd('TODO') calls as placeholders for future redirects
Build the SQL insert logic using the photo_id from the query string 🔗
Validate that the photo exists before inserting a review to maintain data integrity 🔒
Refactor the Database class:
Rename exec() to raw() for clarity
Add a new execute() method to handle parameterized inserts and return the number of affected rows ⚙️


By the end of this video, users can leave their thoughts—and our app takes one more step toward being fully interactive. 🌟

Survey App Mockup Review

Welcome to the Laravel Survey App series — where we’ll transform a static HTML survey page into a powerful, data-driven Laravel application! 🚀
In this first episode, we’ll review the project mockup, explore the data model, and outline the core features that will shape the app. You’ll get a clear vision for what we’re building — from admin dashboards and dynamic surveys to real-time results and data visualization.

🔍 In this video, we’ll cover:

Reviewing the static HTML survey design
Discussing the data model (surveys, sections, questions, responses)
Defining the key app features for admins and users
Linking to the GitHub repo for source code access
Tagging the initial version: git tag video_01


🧠 What You’ll Learn
You’ll see how to think like a Laravel developer from the start — modeling data relationships, planning for dynamic rendering, and setting up a roadmap for a real-world web app.

🛠️ Resources
🔗 Laravel Home Page → https://laravel.com/
💻 GitHub Repo → https://github.com/rcravens/laravel_survey_app

📺 Up Next
Next episode: Getting Started with Laravel — we’ll install Laravel and bring in our static HTML mockup to kick off the build!

Take Survey Fingerprinting

In this episode of Laravel: The Pragmatic Way, we explore how to generate a unique “fingerprint” for survey participants using a combination of PHP and JavaScript signals.

You’ll learn what fingerprinting is, why it matters, the ethical considerations, and how to integrate a JavaScript fingerprinting library into your Laravel workflow.

🧠 What You’ll Learn
- A method of producing a unique identifier using user “signals.”
- Why fingerprinting must be handled with caution — privacy, consent, regulation concerns.
- Which data you can access server-side vs client-side.
- Including adding routes, generating fingerprints, and pre-filling survey responses.

🪪 Example Signals
- PHP Signals (server-side): IP address, User-Agent, Accept-Language, Accept headers, Referer header, Cookies
- JavaScript Signals (client-side): Everything PHP offers plus installed fonts, plugins/extensions, platform info, screen resolution, OS, touch capabilities, GPU/audio/video data, and more.

🛠️ Survey Workflow Changes
1. Install the JS Fingerprinting Library: https://github.com/jackspirou/clientjs

2. Update the route /s/{survey:hash}
- No longer shows questions directly
- Generates the fingerprint
- Provides a “Take Survey” link: /s/{survey:hash}/{fingerprint}

3. Create the route /s/{survey:hash}/{fingerprint}
- Ensures a SurveyResponse record exists
- Passes SurveyResponse + SurveyResponseAnswers to the view
- Pre-fills previous answers automatically


#Laravel #PHP #WebDevelopment #Fingerprinting #Security #Controllers #Forms #JavaScript #FullStackDevelopment #TekCasts #LearnLaravel #Routes #SurveyApp

Template Literals

Say goodbye to clunky string concatenation! In this episode, you’ll discover template literals — a modern way to handle strings in JavaScript that makes your code cleaner and easier to read.

🎯 What you’ll learn:

Backtick (`) syntax — the foundation of template literals.
Variable interpolation — insert variables directly into strings.
Multi-line strings — create readable text without messy \n escapes.
Expressions & functions — embed calculations or function calls right inside your strings.


💡 Why it matters:
Template literals are one of those “quality of life” features you’ll use everywhere — from building user messages to formatting HTML templates. Once you start, you’ll never want to go back to + string concatenation.

By the end of this episode, you’ll be writing strings that are not just smarter, but also more expressive. ⚡️

Terminal - Shells, Basics, Help

This video is part of the Linux Crash Course series. This video will introduce the Linux Terminal and how to efficiently navigate command history, cursor position, and how to obtain help on any command.

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

Text Editors - Nano, Vim, Emacs

This video is part of the Linux Crash Course series. This video will continue exploring the Linux File System. In this video I will introduce three common text editors found on Linux systems.

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

The Event Loop

JavaScript may look simple, but under the hood it’s powered by the Event Loop — the secret sauce that lets your code juggle tasks, handle async operations, and keep your apps responsive. In this video, we’ll break down exactly how it works (without frying your brain 🥓).

Here’s what you’ll learn:
📚 Call stack basics – how functions get pushed, popped, and executed
⏱️ Synchronous vs asynchronous execution – what runs now vs what runs later
🕒 Macrotasks – like setTimeout and setInterval
⚡ Microtasks – like Promises and queueMicrotask
🧪 A hands-on demo where we predict and then prove the order of console logs using timers & promises

You’ll finally understand:
✅ Why some logs show up before you expect them
✅ Why promises are “faster” than timeouts
✅ How the browser keeps things efficient, even when you’re spamming microtasks

By the end, you’ll see the Event Loop not as magic, but as your best friend in building smooth, non-blocking web apps 🚀

👉 Watch now and unlock the inner workings of JavaScript’s brain 🧠⚡

The HTTP Module

Every web app starts with a server — and in Node.js, that journey begins with the HTTP module. In this episode of JavaScript on the Server, we’ll peel back the curtain on how requests and responses actually flow between the browser and your app.

✨ What you’ll learn:
- Why the HTTP module is the core engine of Node.js servers
- How the client-server request/response cycle really works
- Building a minimal web server from scratch (no frameworks required!)
- Getting hands-on with the req (IncomingMessage) and res (ServerResponse) objects
- Key concepts to set you up for routing, APIs, and beyond


Whether you’re new to backend dev or just curious how Node powers the web, this episode will give you the foundation you need to level up.

📚 Helpful Links
- Node.js HTTP Module: https://nodejs.org/api/http.html
- Request/Response Cycle Overview: https://backend.turing.edu/module2/lessons/how_the_web_works_http
- Node.js HTTP Request Object: https://www.w3schools.com/nodejs/nodejs_http.asp
- Node.js HTTP Response Object: https://www.w3schools.com/nodejs/obj_http_serverresponse.asp

🔗 More TekCasts Learning
- 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

Timers and Intervals

Timers are everywhere in JavaScript: countdowns, clocks, animations, polling APIs… but they don’t always behave the way you expect. In this video, we break them down so you can use them with confidence.

You’ll learn:
⏳ setTimeout – schedule code to run later
🔁 setInterval – repeat actions at intervals
❌ Canceling timers – clearTimeout, clearInterval
🧑‍💻 Real-world use cases – clocks, countdowns, polling APIs
⚠️ Pitfalls – interval drift, blocked UI, when not to rely on timers

We’ll demo:

- Building a start/pause digital clock
- Defusing a “time bomb” ⏱💣 with clearTimeout
- Seeing timer drift in action when the event loop is overloaded


By the end, you’ll know not just how to use timers—but how to spot when they lie to you 🕵️‍♂️

Traits

Ever struggled with duplicate code across multiple classes? What if you can’t put it in a base class? 🤔 PHP doesn’t support multiple inheritance, but fear not—Traits come to the rescue! 🦸‍♂️

In this video, we’ll identify duplicate logic, discuss why it doesn’t belong in the base class, and then refactor using a Trait to keep our code clean, reusable, and DRY! 💡✨

By the end, you’ll be wielding Traits like a pro! 🏆 Let’s dive in! 🎥