Explore By Topic

A Simple Router

Time to give our app some direction—literally! In this video, we introduce a simple but powerful router to handle page requests with clarity and control. 🧭

Here’s what we’ll build:
• Refactor pages into controller classes:
• app/Http/AboutController.php
• app/Http/UploadController.php
• app/Http/PhotoController.php 📂
• Set up Composer PSR-4 autoloading for the App\\ namespace ⚙️
• Build routing logic in index.php, then move it to app/routes.php and eventually into globals.php for reuse 🔁

By the end, our app will be running on a clean routing system—flexible, readable, and easy to extend. Welcome to version v6-create-simple-router. This is where things start to feel real. 🚀

Abstract Classes and Methods

In this video, we tackle the code smell of duplicate code and refactor it into a clean, efficient abstract base class! 🏗️💡 You’ll see firsthand how abstract classes and methods help streamline your PHP projects by promoting reusability and maintainability.

🔍 Here’s what we cover:
✅ Identifying and fixing duplicate code 🤢
✅ Calling the parent constructor for seamless inheritance 🏗️
✅ Changing private properties to protected for better access 🔓
✅ Overriding methods to add custom functionality 🎨

By the end, you’ll have a solid understanding of abstract classes and how they can level up your object-oriented PHP skills! 🚀🔥

💻 Watch now and clean up that messy code! 🎬

Arrays - Working with Lists

Say hello to one of the most useful tools in JavaScript: arrays! In this episode, you’ll learn how to store, access, and manipulate ordered lists of data — like a list of fruits, numbers, or even mixed types. 🧺🔢

🎯 Here’s what you’ll explore:
• What arrays are and why they’re so powerful
• How to create, access, and update array elements
• Common methods like .push(), .pop(), .shift(), .unshift(), .length, and .indexOf() that help you manage your data with ease

🎥 Visual Walkthroughs:
• Real-time examples you can follow and modify on your own
• See arrays grow, shrink, and change as you manipulate them step by step
• Understand how arrays help avoid repetitive code and keep things organized

By the end, you’ll be looping through lists and managing data like a pro, ready to build smarter, more dynamic programs! ⚙️💡

Arrays & Associative Arrays

In this video from the PHP for Beginners series, we dive into arrays—one of the most essential data structures in PHP! You’ll learn about string arrays, numeric arrays, and mixed arrays, along with practical ways to output them using implode() and json_encode(). We’ll also explore how to loop through arrays with foreach, making it easy to process data efficiently.

Next, we move on to associative arrays and multidimensional arrays, perfect for storing structured data. You’ll see how to access and manipulate complex datasets in PHP with ease. By the end of this lesson, you’ll have a solid grasp of how arrays work and how to use them effectively in your projects!

🔹 Perfect for beginners!
🔹 Hands-on examples included.

🚀 Start coding with PHP arrays today!

Auth & Application Workflow

🛠️ Session Enhancements
- Add guest() and user() methods to the Session class
- guest() → returns true if no user is logged in
- user() → returns current user object (or null)

🎨 Navigation Improvements
- Update the top navigation bar to reflect authentication state:
- Show Register / Login links when user is not logged in
- Show user avatar and menu when logged in
- Fix any related JavaScript issues

👤 Gravatar Integration
- Create a new helper class: app/Code/Gravatar.php
- Use the user’s email to generate their avatar
- Display avatar in the nav for logged-in users

🖼️ Conditional Upload View
- Modify the upload page to only display the upload form if the user is logged in

📌 And that ties up the loose ends, landing us at v24-authentication-loose-ends.

Automating Builds with GitHub Actions

Let’s automate our workflow! ⚡ In this final video, we’ll set up a GitHub Actions workflow to automate testing and building our PHP package whenever changes are pushed.

📌 What you’ll learn:
✅ Setting up GitHub Actions for your package
✅ Automating testing and builds
✅ Ensuring your package is always production-ready

🎉 This wraps up our PHP Package Development series—thanks for watching! Don’t forget to like, comment, and subscribe for more!

🔗 Resources:
• GitHub Actions Docs

Blade / Twig Style Templates

In this video, we upgrade our templating engine to support Blade-style syntax, bringing a more expressive and readable feel to our views. Here’s what we did:

Enhanced the View class to support:
- Escaped output: {{ $user->name }}
- Raw output: {!! $user->name !!}

Updated all relevant views to use the new shorthand syntax for cleaner templates.
- 🛠️ Fixed a display issue in photo.show where old_rating wasn’t mapping correctly (it was showing a 4 instead of the correct 1).

✨ With this little dose of syntax sugar, we land at v27-blade-envy — giving our views a modern touch without bringing in a full framework.

Calculator - Converting to OOP

It’s time to level up! 💡 In this video, we take the functional calculator from the PHP for Beginners series and transform it into a clean, modular Object-Oriented project! 🎯

🔍 Quick code review of the existing functions 🔄
📦 Step-by-step conversion of functions into classes 🏗️
💡 Learn how OOP principles improve structure, maintainability, and reusability 🧩

This is the first step in our Final Project—get ready to apply everything you’ve learned so far! 💪🔥 Let’s dive in! 🎬

Calculator - Developer Experience

Great code isn’t just about functionality—it’s about how easy and intuitive it is to use! 💡 In this video, we refine our OOP Calculator to enhance the developer experience, making it cleaner, simpler, and more powerful.

🔹 Reimagining how we’d ideally like to use this calculator in real-world code ✨
🔹 Refactoring for better readability & usability 🏗️
🔹 Making integration effortless for developers 💻

By the end, our calculator will feel natural to use—setting the stage for clean and elegant PHP development! 🔥 Let’s dive in! 🎬

Calculator - Dynamic Operators

What if our calculator could easily support new operations beyond just addition, subtraction, multiplication, and division? 🤔 In this video, we take extensibility to the next level by refactoring our operator logic into a flexible, modular design! 🎯

🔹 Transforming operators into dedicated classes 🏗️
🔹 Creating an Operator Interface for consistency ✅
🔹 Implementing a registration system for dynamic operators 🔄
🔹 Demo: Adding a 🔥 Power Operator for exponentiation! ⚡

By the end, our calculator will be fully extensible—ready to support any operation with ease! 💡 Let’s build it! 🎬

Calculator - Namespaces & Autoloading

n the final episode of our Object-Oriented PHP series, we take our calculator to professional-grade by introducing Namespaces & Autoloading! 🎯

🔹 Understanding the PSR-4 standard for structured code 🏗️
🔹 Adding namespaces to each class with the namespace keyword 📌
🔹 Using use statements to simplify class dependencies 🔄
🔹 Leveraging Composer’s autoload feature for seamless class loading ⚙️

With these best practices, our project is now well-structured, scalable, and ready for the real world! 🌍 Let’s finish strong! 🎬🔥

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! 🎬

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! 💡🔥

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

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! 🌍💡