Explore By Video

Calculator - Returning Objects

Returning native PHP types can be tricky—often requiring extra knowledge about the return structure. 🤔 But what if we could make our code cleaner, clearer, and more intuitive? 💡

In this video, we take our OOP Calculator to the next level by:
✅ Identifying the challenges of returning native types 🎭
✅ Creating dedicated return type classes 🏗️
✅ Refactoring our calculator to use object returns for a better developer experience 🛠️

By the end, your code will be easier to understand, maintain, and extend! 🔥 Let’s do this! 🎬

Class & Style Manipulation

Ready to take your DOM game up a notch? In this video, we’ll unlock the secrets of making your pages look alive with style changes and class toggles.

✨ You’ll learn how to:
🔹 Add, remove, and toggle classes with ease
🔹 Directly style elements using .style 🎯
🔹 Know when to use CSS classes vs inline styles 🧩
🌙 Build a slick dark mode toggle demo

By the end, you’ll be styling like a pro—your elements won’t just sit there…they’ll respond, adapt, and shine ✨🔥

Classes and Objects

Welcome to the foundation of Object-Oriented Programming (OOP) in PHP! In this episode, we break down one of the most important concepts in OOP—classes and objects.

We’ll start by creating an empty class using the class keyword and explore how a class acts as a blueprint for building objects. Then, we’ll bring it to life by instantiating objects with the new keyword, transforming our blueprint into real, usable instances. You’ll learn how every object is an independent version of a class, ready to hold data and perform actions.

By the end of this video, you’ll have a solid grasp of classes and objects, setting the stage for writing cleaner, modular, and scalable PHP code! 💡🔥

Closures and Lexical Scope

In this episode, we unlock one of JavaScript’s most powerful (and sometimes mysterious) features: closures. You’ll see how functions can “remember” the variables around them, even after the outer function has finished running.

🎯 What you’ll learn:
- Lexical scope — how JavaScript decides which variables a function can access.
- Closures — functions carrying their environment with them.
- Practical use cases:
* A simple counter that remembers its value.
* Using closures to create private data in JavaScript.


💡 Why it matters:
Closures are everywhere in modern JavaScript — from event listeners to libraries and frameworks. Understanding them gives you the power to write smarter, safer, and more reusable code.

By the end, closures won’t feel like “magic” — they’ll be a tool you can confidently use to structure your programs. 🔑

Congrats & Recap

🎉 You did it! 🎉 You’ve completed the “PHP for Beginners” series, and you now have a solid foundation in PHP! In this short recap, we’ll:

✅ Review what we’ve learned—from loops and functions to forms and reusable code.
✅ Celebrate your progress and encourage you to keep coding!
✅ Hint at exciting next steps, like database queries and object-oriented programming.

This is just the beginning of your PHP journey! Keep practicing, keep building, and get ready for more advanced topics. 🚀

Constructor Functions & Prototypes

Before ES6 classes came along, JavaScript had its own way of doing object-oriented programming—using constructor functions and prototypes. In this episode, we’ll take a step back in time and uncover how developers structured code for reusability and efficiency. 🏗️

Here’s what we’ll explore:

🏭 Object factories vs constructor functions—and why constructors gave us more power.
🆕 The magic of the new keyword and how it creates object instances.
🛠 Adding methods through prototypes to keep memory usage efficient.
💡 Why this pattern still matters today (hint: classes are built on top of it!).


By the end, you’ll see how prototypes formed the backbone of JavaScript’s object system—and why understanding them gives you a deeper grasp of how modern classes really work. 🚀

Constructors and Destructors

Time to build it up and tear it down—PHP style! 🚀 In this video, we dive into constructors and destructors, the dynamic duo that controls how objects come to life 🏗️ and gracefully clean up after themselves 🧹.

You’ll learn how constructors automatically set up an object when it’s created, making your code more efficient ⚡. Then, we’ll explore destructors, the unsung heroes that handle cleanup duties when an object is no longer needed.

By the end, you’ll be crafting smarter, more efficient PHP classes like a true OOP wizard! 🧙‍♂️💻

Control Flow – Conditionals

Programming gets powerful when your code can make decisions — and that’s exactly what this episode is all about! Learn how to use conditionals to respond to different situations and write smarter, more dynamic scripts. 🚦

🎯 Here’s what we’ll cover:
• Master the classic if / else if / else structure to control the flow of your program.
• Use boolean conditions to trigger different outcomes based on logic.
• Learn the sleek and compact ternary operator for quick, inline decisions.

🎥 Visual Walkthroughs:
• Build real-time examples that react to changing values like temperature and age.
• Watch how branching logic helps your programs behave differently in different scenarios.
• Break down the syntax so you not only write it — you understand it!

By the end of this episode, you’ll have the tools to write JavaScript that responds to the world around it! 🌍💡

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! ♻️⚙️

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

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!

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. 🚀