Explore By Video

Higher-Order Functions

In this episode, we explore a superpower of JavaScript: higher-order functions — functions that can take other functions as inputs or return new functions as outputs.

🎯 What you’ll learn:
- What higher-order functions are and why they’re important.
- Functions as arguments with real-world examples using map, filter, and forEach.
- Functions returning functions to create flexible, configurable behaviors.
- A practical Pub/Sub pattern (publish/subscribe) — showing how higher-order functions enable reusable and event-driven code.


💡 Why it matters:
Understanding higher-order functions is a game-changer. They’re the foundation for functional programming patterns, modern libraries, and frameworks. Once you master them, you’ll start seeing opportunities to write code that’s cleaner, more modular, and easier to extend.

By the end of this episode, you’ll know how to bend functions to your will — letting them build, transform, and orchestrate other parts of your program. ⚡️

How the Web Works

Ever wondered what happens behind the scenes when you visit a website? In this video, we break down the fundamentals of how the web works, focusing on how PHP processes requests and responses on the server. You’ll learn about HTTP & HTTPS, how browsers communicate with web servers, and what happens when you enter a URL. We’ll also explore key HTTP concepts like request methods, headers, response codes, and more. Plus, we’ll walk through a live example using browser developer tools to see it all in action. By the end, you’ll have a clear understanding of how PHP fits into the bigger picture of web development! 🚀

Image Uploads & Storage

Real-world file handling without the fluff! In this episode of Pragmatic Laravel, we add image uploads to our public survey marketing pages and tie up the loose ends that turn a feature into something production-ready.

You’ll learn how Laravel’s filesystem abstraction works and how to apply it cleanly in both create and edit flows—without overengineering.

✨ What we cover in this video:

🔹 Laravel Storage Fundamentals
- How Laravel supports multiple disks (local, public, S3, FTP, etc.)
- Why the Storage facade matters
- When abstraction actually helps

🔹 Hands-On Implementation
- Review existing filesystem configuration
- Run php artisan storage:link
- Add image upload fields to forms
- Handle uploads in controllers
- Persist image paths cleanly
- Reuse the same logic for create & edit flows

💥 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

Inheritance

Inheritance—one of the core pillars of Object-Oriented Programming! 💡 But how does it actually work in PHP? 🤔

In this video, we’ll break it down step by step:
✅ What inheritance is and why it’s useful
✅ How a child class can inherit properties & methods from an abstract base class 🏗️
✅ The rules & limitations of PHP’s single inheritance 🔒
✅ Use inheritance to extend an existing class with new properties & methods that add functionality 🎯

By the end, you’ll be harnessing inheritance like a pro—structuring your code for maximum reusability and maintainability! 💻🔥 Let’s dive in! 🎬

Inheritance

Ready to level up your JavaScript classes? 🚀 In this episode, we’ll explore how objects can inherit behavior from one another, making our code more powerful and reusable.

Here’s what we’ll cover:

🌳 Why Inheritance matters for organizing and scaling your code.
🔗 Using extends to create child classes.
🧩 Leveraging super() to tap into parent constructors.
✍️ Overriding methods to customize behavior for specific classes.


We’ll bring it all together with an Animal → Dog example, showing how subclasses can extend functionality while keeping your code DRY and elegant. 🐾

By the end, you’ll have the tools to structure your JavaScript programs like a true object-oriented pro. ⚡

Interfaces

Welcome to the world of Interfaces—where we take PHP code structure to the next level! 🎯💡 In this video, we explore how interfaces help us write cleaner, more flexible, and more maintainable code.

✨ What’s inside?
✅ The power of explicitly defining types for parameters & return values 🏷️
✅ Extracting an interface from an abstract base class 🔄
✅ Converting methods using the interface keyword ✍️
✅ Decomposing large interfaces into smaller, focused ones 🔧
✅ Leveraging interfaces as parameter & return type constraints 🔗

By the end, you’ll see how interfaces bring ultimate flexibility and extensibility to your PHP projects! 🚀🔗 Watch now and level up your OOP game! 🎬🔥

Intro to Composer & Packagist

Welcome to the PHP Package Development series! 🎉 In this first video, we introduce the problem we’re solving and explore the world of package management systems. You’ll learn what Composer and Packagist are, why they matter, and how they simplify PHP development.

📌 What you’ll learn:
✅ What are package management systems?
✅ Introduction to Composer & Packagist
✅ Why use Composer for PHP projects?

🔔 Subscribe for more PHP content!

🔗 Resources:
• Composer Documentation
• Packagist

Intro to Databases

It’s time to level up from file-based storage! In this episode, we explore why databases exist, how they solve key scalability problems, and how to use SQLite to manage structured data in Node.js.

💥 You’ll see how to:
👉 Compare file-based vs. database storage
👉 Understand relational vs. document databases
👉 Install and use SQLite in Node.js
👉 Implement full CRUD operations (Create, Read, Update, Delete)
👉 Explore when to choose SQLite, PostgreSQL, or MongoDB

💡 Relevant Links

- SQLite official: https://www.sqlite.org/index.html
- SQLite Node: https://www.npmjs.com/package/sqlite3
- PostgreSQL official: https://www.postgresql.org/
- MongoDB official: https://www.mongodb.com/


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

Intro to Node

👉 Ever wondered why JavaScript isn’t just for the browser anymore? In this kickoff video, we’ll explore the rise of server-side JavaScript — from its humble beginnings in Netscape (1995) ⚡️ to the game-changing release of Node.js in 2009.

💥 You’ll learn:
- A quick history of JavaScript and how it went from a “sidekick” language to running the backend of the web.
- What makes Node.js special: the V8 engine, event-driven architecture, and non-blocking I/O.
- Why developers love using one language across the full stack (frontend, backend, and even databases!).
- Real-world use cases: APIs, real-time apps, CLI tools, microservices, and even IoT robots 🤖.

⚡️ Plus, we’ll demo how the same console.log works in the browser and in Node.js, and spin up a tiny web server that responds with "Hello from the server!".

👉 Perfect if you’re new to Node or curious about why companies everywhere are betting big on JavaScript beyond the browser.

💡 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:
- Node.js Documentation: https://nodejs.org/en/docs/
- MDN JavaScript Guide: https://developer.mozilla.org/en-US/docs/Web/JavaScript

Introduction - History, Quick Setup

This video is part of the Linux Crash Course series. This video will discuss the history of Linux and help prepare a sandbox where you can practice as you follow along.

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

Introduction & Overview

Welcome to PHP: The Pragmatic Way! In this video, we set the stage for an exciting journey into dynamic web development. 🌐

We’ll start by touring the project’s goals, showing you where we’re landing and what’s ahead. The rule is simple: all the PHP code is ours! We begin with static HTML pages and gradually convert them into dynamic applications. 💻

Along the way, we’ll cover:
• Extracting a layout to avoid repetition 🔄
• Refactoring into an MVC architecture 🏗️
• Building a “mini-framework” to streamline development ⚙️

You’ll also learn how this framework introduces powerful features like routing, sessions, databases, models, views, and controllers. 🛠️

We’ll stick to best practices throughout—focusing on clean, secure, and maintainable code that’s easy to use. By the end of this series, you’ll be ready to implement these principles in your own projects!

Prerequisites: Basic PHP and OOP knowledge are recommended to get the most out of this series. Ready to dive in? Let’s go! 🚀

Introduction to Async Functions

Async programming doesn’t have to feel like juggling chainsaws. In this episode, we’ll unravel the magic of async and await—two keywords that make working with asynchronous code in JavaScript cleaner, easier, and far more readable. 🚀

We’ll start by exploring why async matters: JavaScript is single-threaded but non-blocking, so operations like network requests need special handling. You’ll see how we moved from callbacks ➝ Promises ➝ async/await, and why this evolution makes your code shine. ✨

Next, you’ll learn:

🔑 What makes an async function special (spoiler: it always returns a Promise).
⏸ How await pauses execution until a Promise settles—without freezing your app.
💻 Real-world examples, including a simulated network request written both with .then() and the async/await style.
🛡 How to handle errors gracefully with try/catch.


By the end, you’ll feel confident writing asynchronous JavaScript that’s elegant, predictable, and easy to read. ⚡

Introduction to Middleware

Your Node.js server just got superpowers 💥

We’re taking your app beyond the basics by introducing one of the most powerful architectural patterns in modern web development — middleware ⚙️

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

🚀 Implement your own middleware system from scratch in Node.js
🔒 Add authentication checks with custom middleware classes
🧠 Use router groups to apply middleware cleanly and efficiently
🪄 Chain multiple middleware functions to handle complex logic
🧩 Understand how frameworks like Express build on this same concept

By the end, your Node.js app will have a clean, modular flow that scales effortlessly 💪

💡 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

Previous episodes in this series:
- Sessions: https://tekcasts.com/play/javascript-on-the-server-sessions
- Validation Improvements: https://tekcasts.com/play/javascript-on-the-server-validation-improvements
- Flash Messages: https://tekcasts.com/play/javascript-on-the-server-flash-messages
- Authentication Basics: https://tekcasts.com/play/javascript-on-the-server-authentication-basics

Libraries / Docs mentioned:
- Node.js http: https://nodejs.org/api/http.html
- Node.js URL: https://nodejs.org/api/url.html

Introduction to Recursion

In this episode, we unlock the power of recursion — functions that call themselves! 🔄 You’ll see why recursion needs a clear exit point (the base case), and how this elegant approach can simplify tricky problems. Together, we’ll walk through three hands-on examples:


⏱ A countdown timer that rockets to blast off!
✖️ Factorial computation (the classic recursion demo)
🔀 A recursive bubble sort that organizes chaos step by step


By the end, recursion will go from intimidating to intuitive — a tool you’ll actually want in your problem-solving toolkit. 🚀

Invalid Form Submissions

In this video, we tackle the next critical part of the form experience—handling invalid submissions with grace. When a user submits a form with missing or incorrect data, we want to redirect them back, repopulate the form, and show helpful error messages. 💡

Here’s what we build in version v19-redirect-with-errors:


- Define the ideal usage:
- session()->invalid($errors)->redirect_back();
- Then… we make it real! 💥
- Introduce invalid() and redirect_back() methods in the Session class
- Store transient $old and $errors values to survive the redirect and improve UX ✨
- Refactor Session::old() into a more flexible Session::flash() and flash_message() pattern 🔁
- Improve the old($key, $default) helper to escape HTML using htmlspecialchars() for security 🛡️
- Add a validation_message() helper to display specific errors next to form fields
- Update the review form:
- Loosen validation so comment is optional
- Add hidden rating input with default of 0
- Test with extreme values (e.g., rating=10, long name) to confirm validation is triggered
- Clean up temporary debug outputs (like var_dump()) and finalize the flow ✅


This update makes your app smarter, friendlier, and much more user-friendly when things go wrong. A polished user experience, even on failure? Now that’s pragmatic. 🚀