Explore By Series

Pragmatic Laravel

Pragmatic Laravel is a project-based course designed to teach Laravel the way it’s actually used in real applications — by building one from the ground up.

Instead of jumping between isolated examples, you’ll work through a single, cohesive project: a fully-featured survey application. Starting with a static HTML mockup, you’ll progressively transform it into a dynamic, production-ready Laravel app using best practices throughout.

Each module builds naturally on the last, introducing new concepts when they become relevant — just like real development work.

💥 What You’ll Build & Learn
As the project evolves, you’ll implement real features you’d expect in a professional Laravel application, including:
- Blade layouts, components, and reusable views
- Clean routing and controller organization
- Database design, migrations, seeding, and Eloquent relationships
- Form handling, validation, and error workflows
- Authentication and authorization
- Middleware, sessions, and request lifecycles
- RESTful resources and admin tooling
- Email notifications and background workflows
- Survey analytics, dashboards, and reporting
- Public-facing pages and deployment considerations

By the end of the course, you won’t just understand how Laravel works — you’ll understand how to structure, grow, and maintain a real Laravel project.

👉 Who This Course Is For
This course is ideal for:
- Developers who already know PHP and basic Laravel concepts
- Laravel users who feel stuck in “tutorial hell”
- Developers who want to learn why things are done a certain way, not just what to type
- Anyone who wants a realistic Laravel project they can learn from — or reference later

If you’re looking for quick tips or surface-level introductions, this probably isn’t for you.
If you want depth, context, and practical experience, you’re in the right place.

🎬 Course Format
- 17 structured modules
- 50 long-form videos
- 16+ hours of in-depth instruction
- One continuous, real-world project
- Immediate access to all lessons

The videos are intentionally long-form, allowing ideas to be fully explained and implemented — because real understanding doesn’t happen in five-minute clips.

It’s a deep dive into practical Laravel — one that connects concepts to craftsmanship. ⚡

Pragmatic Node.js

Node.js is often introduced through quick examples or heavy frameworks that hide what’s really happening behind the scenes. While that can get something running fast, it often leaves developers unsure how servers work, how requests flow through an application, or how JavaScript behaves outside the browser.

Pragmatic Node.js takes a different approach.

This is a long-form, project-based series designed to help you understand Node.js from the ground up. Instead of abstract examples, you’ll build a real backend application step by step, learning how the Node runtime works and how real-world server-side applications are structured.

💥 What You’ll Build & Learn
In this course, you’ll build a complete Node.js application without relying on a framework. Along the way, you’ll learn how to:
- Create and configure a Node.js server from scratch
- Handle HTTP requests and responses
- Implement routing and application flow
- Work with asynchronous code and the event-driven model
- Manage data persistence and application state
- Build APIs and backend services
- Implement authentication and session handling
- Structure a maintainable backend codebase
- Prepare your application for real-world deployment

Every concept is introduced in context, so you’re always learning why something exists and when to use it.

👉 Who This Course Is For
This course is ideal for developers who:
- Already know JavaScript and want to use it on the server
- Feel comfortable with frontend JavaScript but struggle with backend concepts
- Have used Node.js frameworks but want to understand what’s happening underneath
- Want to build real backend applications with confidence

If you’re looking for a quick overview or a copy-paste tutorial, this probably isn’t the right course. But if you want a solid mental model of how Node.js works and how backend systems are built, you’re in the right place.

🎬 Course Format
This is a project-based, long-form video series organized into focused modules. Each module builds on the last as the application grows naturally over time.

Instead of rushing through topics, we take the time to explain decisions, tradeoffs, and best practices. You’ll see how real applications evolve, not just how isolated features are implemented.

The goal isn’t just to teach you Node.js — it’s to help you think like a backend developer.

By the end of this series, you won’t just recognize Node.js concepts — you’ll understand how to apply them to real-world applications. You’ll be able to reason about backend architecture, asynchronous behavior, and application flow with confidence.

If you’re ready to move beyond surface-level tutorials and truly understand Node.js, this series was built for you.

JavaScript in the Browser

Ready to move beyond static web pages and bring your sites to life? This course takes you on a hands-on journey through JavaScript in the browser, showing you how to manipulate the DOM, handle user interactions, fetch live data, and structure real frontend applications — all without relying on heavy frameworks.

You’ll start by learning how the browser works under the hood 🛠️, exploring the DOM and how JavaScript connects with HTML and CSS. From there, you’ll dive into events and interactions, mastering the art of capturing clicks, forms, and user input to build dynamic, interactive UIs.

Next, you’ll peel back the curtain on timing and execution, uncovering how the event loop, timers, and async behavior make JavaScript tick ⏱️. You’ll then learn how to work with data and networking, using the Fetch API, understanding AJAX’s legacy, and tapping into powerful browser APIs like localStorage and geolocation 🌍.

But building apps isn’t just about features — it’s also about resilience. You’ll learn how to gracefully handle errors and keep your UI smooth even when things go wrong 🛡️.

Finally, you’ll put it all together: designing a simple frontend architecture, building a small project that ties everything together, and then zooming out for a big-picture look at frameworks. You’ll see why libraries like jQuery were game-changers historically 📜 and get an overview of the modern ecosystem of frameworks and libraries 🪶.

By the end of this course, you’ll have the confidence to:
• 🎯 Manipulate the DOM and control the browser environment
• 🖱️ Handle events and build interactive user experiences
• ⏳ Understand the event loop and asynchronous behavior
• 🌐 Fetch and store data with modern browser APIs
• 🏗️ Structure code for maintainability and scalability
• 🔎 See where frameworks fit into the bigger picture of frontend development

👉 If you’re comfortable with the basics of JavaScript and ready to master how it powers the browser, this course will give you the tools, insights, and confidence to take your web projects to the next level.

JavaScript Fundamentals

Ready to unlock the power of the web? Whether you’re dreaming of building websites, launching interactive apps, or diving into a dev career, JavaScript is your gateway—and this course is your launchpad. 🧑‍💻💥

In “JavaScript for Beginners”, you’ll go from zero to confident coder with a hands-on, modern approach to the world’s most popular programming language. Step-by-step, we’ll guide you through the fundamentals, demystify the syntax, and get you writing real code fast. 💻✨

💡 What you’ll learn:
• 🧠 Core Language Fundamentals: Understand variables, data types, operators, and control flow—build the logic behind the magic.
• 🔁 Loops & Functions: Write clean, reusable code with powerful function patterns.
• 📦 Collections: Master arrays and objects—tools you’ll use everywhere in JavaScript.
• 💥 Intermediate Power-Ups: Destructuring, error handling, template literals, and more to level up your scripts.
• 🌀 Function Wizardry: Closures, higher-order functions, and even recursion? Yes, you can.
• 🏗 Object-Oriented JavaScript: From prototypes to modern ES6 classes and inheritance.
• 🔗 Modules & What’s Next: A sneak peek into modular code and your next steps in the JavaScript journey.

🛠️ You’ll also:
• Set up a coding environment
• Use browser dev tools like a champ
• Build a solid foundation for DOM scripting and frameworks like React

⸻

Whether you’re brand new to coding or switching gears into web development, this course will leave you energized and equipped. By the end, you won’t just know JavaScript—you’ll be using it like a pro. ⚔️🔥

Let’s code something awesome. Your journey starts here! 🌟

Pragmatic PHP

Pragmatic PHP is a hands-on, project-based training series designed to teach PHP by doing. Instead of jumping between disconnected snippets or abstract theory, you’ll learn by building a real, production-ready web application from the ground up — the way professional developers work.

From the very first lesson, you’ll apply core PHP concepts in context. You’ll explore how all the moving parts of a full application fit together — from routing requests and managing state, to interacting with data and handling authentication — so you understand both how and why things are done.

This isn’t a surface-level tutorial series. It’s structured so that each piece you add reinforces what came before and prepares you for what comes next, just like real software development.

💥 What You’ll Build & Learn
As the project evolves throughout the series, you’ll implement real features and see how PHP works in practice, including:

- MVC and custom routing — organize your code and control app flow
- Database integration — insert, update, and query data with confidence
- Sessions & state management — keep track of users and data across requests
- Authentication basics — build secure login and registration workflows
- Form handling & validation — process input safely and elegantly
- Reusable components & maintainable structure — write code you can build on
- Deployment considerations — prepare your app for real-world hosting

By the end of the course, you won’t just understand PHP syntax — you’ll understand how to apply PHP to solve real problems, structure professional applications, and maintain code over time.

👉 Who This Course Is For
This course is ideal for:
- Developers who know the basics of PHP but want real-world experience
- Programmers who’ve learned concepts in isolation and want to connect the dots
- Anyone ready to move beyond toy examples into real application development
- Developers who want to build maintainable, real-world PHP applications without relying on heavy frameworks

If you’re looking for quick tips or isolated feature demos, this isn’t the right fit.
If you want depth, continuity, and real engineering context, you’re in the right place.

🎬 Course Format
- 9 structured modules
- 30 long-form videos
- 7+ hours of in-depth instruction
- Practical project-based progression — see how features interact
- Clear lessons with real workflows — no superficial shortcuts
- Core PHP fundamentals applied in context — not just theory
- Immediate access to all lessons

The videos are intentionally long-form, allowing ideas to be fully explained and implemented — because real understanding doesn’t happen in five-minute clips.

Ready to take your PHP skills to the next level? Join me in this practical, hands-on series! ⚡

ESP32 - Smart Garage Door

Build your own HomeKit-enabled smart garage door — step by step!

In this four-part TekCasts series, we take a deep dive into building a fully functional Smart Garage Door using an ESP32 microcontroller and Apple HomeKit integration via HomeSpan. Whether you’re a maker, developer, or smart home enthusiast, this project walks you through the entire process — from idea 💡 to installation 🔧 to iPhone control 📲.

🔹 Episode 1: What is a Smart Garage Door?
See the final product in action and learn how we combine door position sensing, remote control, and Apple Home integration to solve a real-world problem.

🔹 Episode 2: Hardware & Schematics
Explore how the ESP32 connects to four custom sub-circuits with detailed schematics, and see the actual build with real hardware photos and video.

🔹 Episode 3: Software
Walk through the object-oriented codebase powering the smart garage door. Learn how each feature is encapsulated into classes and integrated with Apple’s HomeKit ecosystem using HomeSpan.

🔹 Episode 4: WiFi Configuration & Pairing
Securely configure WiFi credentials without touching the code, then pair your device with Apple Home for full remote control and notifications.

🔗 Resources included:
• GitHub Project Repo: https://github.com/rcravens/esp32_smart_garage_door
• HomeSpan Library (HomeKit Integration): https://github.com/HomeSpan/HomeSpan

By the end of this series, you’ll have a powerful, secure, and polished smart garage door system — and the skills to extend it even further. Let’s build something smart together! 🛠️🚀

PHP Object Oriented Programming

This action-packed video series takes you on a journey from the fundamentals of Object-Oriented Programming (OOP) in PHP to advanced techniques, helping you write cleaner, more maintainable, and scalable code.

We kick things off by exploring why OOP matters and how it solves common issues like messy, hard-to-maintain code. You’ll learn how to create classes and objects, define properties and methods, and harness encapsulation 🔒 to control data access. As we progress, we’ll dive into constructors, destructors, namespaces, and autoloading 📦, making your code more efficient and modular.

From there, we explore inheritance & polymorphism 🎭, showing you how to extend classes and implement interfaces for flexible, reusable designs. You’ll master traits, static methods, and the final & parent keywords to control class behavior. Then, we tackle exception handling ⚠️, teaching you how to manage errors like a pro with custom exceptions.

In the final stretch, we bring everything together with real-world patterns, including the Singleton pattern (logger class) 🔁 and Dependency Injection 💡 for writing decoupled, testable code. To top it off, we’ll refactor a calculator app from scratch 🛠️, applying OOP best practices to build a fully optimized application.

Whether you’re just starting out or looking to level up your PHP skills, this series will equip you with everything you need to master OOP and write better PHP code! 🚀🔥

PHP Fundamentals

Welcome to PHP for Beginners, a complete step-by-step guide to learning PHP from the ground up! Whether you’re a total beginner or looking to refine your backend development skills, this series covers everything you need to know to start building dynamic, data-driven websites with PHP.

What You’ll Learn:

✅ The fundamentals of PHP and how it powers the web
✅ Setting up your development environment (XAMPP, MAMP, Docker, and more)
✅ Writing your first PHP script and understanding PHP syntax
✅ Working with variables, data types, arrays, and strings
✅ Controlling program flow with conditionals and loops
✅ Creating and using functions efficiently
✅ Handling user input, forms, and validation for secure web applications
✅ Embedding PHP in HTML and structuring reusable code
✅ Debugging, error handling, and best practices
✅ A hands-on final project to put your PHP skills to the test!

By the end of this series, you’ll have a strong foundation in PHP development, enabling you to create dynamic websites, process user input, and build real-world applications. Get ready to code and bring your web development ideas to life! 💻🔥

PHP Package Development

Want to create your own PHP package and share it with the world? In this series, we’ll walk through the entire process of building, testing, publishing, and automating a PHP package using Composer, Packagist, and GitHub Actions.

📌 What you’ll learn in this series:
✅ Understanding Composer & Packagist
✅ Structuring your PHP package
✅ Writing tests with PEST
✅ Publishing your package on Packagist
✅ Automating builds with GitHub Actions

By the end of this series, you’ll have a fully functional, test-driven PHP package that others can install and use with Composer. Whether you’re building an open-source library or a private package for your team, this guide will help you do it the right way.

🔔 Subscribe and follow along to become a PHP package pro!

🔗 Resources:
• Composer
• Packagist
• PEST Testing Framework
• GitHub Actions

Let’s build something awesome! 💡🔥

Linux Crash Course

Get up to speed with Linux quickly in this hands-on crash course designed for beginners and aspiring system administrators. Learn essential skills like navigating the file system, creating and managing files, understanding permissions, searching for files efficiently, and leveraging powerful tools like redirection and pipes. We’ll also dive into text editors, user management, ACLs, and process control—giving you the practical knowledge needed to confidently work in a Linux environment. Whether you’re new to Linux or need a refresher, this series will help you build a solid foundation fast.