Software Engineering
This school focuses on the principles, tools, and practices of building reliable, scalable, and efficient software systems. Topics range from programming languages to architectural design, software testing, and DevOps practices.
Languages
Explore the building blocks of software with programming languages. From foundational languages like C++ and Java to modern options like Python and Rust, this topic highlights syntax, best practices, and when to use each language.
PHP
Discover PHP, a versatile server-side language perfect for dynamic web development and database integration.
Object Oriented Programming
Object-Oriented Programming (OOP) is a programming paradigm that organizes code into reusable and modular structures called objects. These objects are created from classes, which define properties (data) and methods (functions) that operate on that data. OOP promotes principles such as encapsulation, which restricts direct access to object data; inheritance, which allows one class to extend another; and polymorphism, which enables different classes to use the same interface. By structuring code in this way, OOP improves maintainability, scalability, and reusability, making it easier to manage and extend applications over time.
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! 🎬
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! 💡🔥
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! 🧙♂️💻
Encapsulation: Public & Private
Ready to lock down your PHP skills? 🚀 In this video, we crack open Encapsulation—a core OOP concept that keeps your code secure, organized, and powerful! 🔐I’ll break down what encapsulation is and why it matters, then dive into real-world examples. You’ll see how getters and setters help you access private properties safely, while letting you enforce business logic behind the scenes 🕵️♂️.
By the end, you’ll be writing cleaner, safer, and smarter PHP code like a pro! ⚡💻
Exceptions & Errors
When things go wrong in your PHP application, how do you handle it? 🤔 In this video, we dive into the art of exception handling and smart error management! 🎯🔹 Throwing & catching exceptions—what, when, and why? 🎭
🔹 Best practices for handling errors (logging, notifications, feature toggles) 📝
🔹 When to use try/catch blocks (external APIs, limited resources) 🔄
🔹 The role of a global exception handler 🛑
🔹 Throwing custom exceptions to make your code more meaningful 🏗️
🔹 Why exceptions can be expensive 💰 and how to use error objects instead ⚡
By the end, you’ll know exactly how to keep your application resilient, stable, and user-friendly! 💪 Let’s dive in! 🎬
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! 🎬
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! 🎬🔥
Namespaces, PSR-4, and Autoloading
Say goodbye to messy, single-file chaos! 😵💫 In this video, we organize and supercharge our PHP projects by breaking them into multiple files. First, we manually load classes using the trusty require keyword 📜—but that’s just the beginning!Next, we introduce the PSR-4 standard, the industry gold standard for structuring PHP code 🏆. And to make life even sweeter, we harness the power of Composer’s autoloading ⚡—letting PHP automatically find and load classes like magic! ✨
By the end, you’ll be writing scalable, maintainable PHP code like a true OOP architect! 🏗️💻
Properties and Methods
Unlock the power of Properties and Methods in PHP OOP! In this action-packed lesson, we dive into public and private properties & methods, breaking down the magic of encapsulation 🔒. Watch as we create a class, instantiate objects, and interact with public properties & methods from the outside 🌎. But wait—what about private ones? 🤔 No worries! I’ll show you how to work with them inside the class like a pro.Get ready to level up your PHP skills one method at a time! ⚡👨💻
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! 🎬
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! 🎥
Why OOP?
Ever felt like your PHP code is a tangled mess of functions, impossible to scale, and a nightmare to maintain? You’re not alone! In this kickoff episode, we dive into why Object-Oriented Programming (OOP) is a game-changer and how it solves common problems found in procedural PHP.We’ll break down the downsides of functional programming—spaghetti code 🍝, duplicated logic 🔁, and function name collisions 💥—and compare it to the structured, reusable, and scalable world of OOP. Through a tabletop comparison, we’ll introduce key OOP concepts like encapsulation, inheritance, and modular design, setting the foundation for everything to come.
By the end of this video, you’ll understand why OOP isn’t just a fancy buzzword—it’s a smarter way to write PHP! 💡🔥