DEV Community: Kareem Khaled

Design Patterns in Laravel: Level Up Your Code with Reusable Solutions

Kareem Khaled — Tue, 02 Jul 2024 10:52:25 +0000

If you're building applications with Laravel, chances are you might have come across people saying, "Design patterns are the way to go." But what, really, are design patterns? And more importantly, how can they make your Laravel applications better?

Through this article, let us go through an exampleapatkan with design patterns, in showing just a re-usable solution in helping you go about writing cleaner, more maintainable, and scalable code. We're going to go through practical examples and real-world scenarios so that you can see how the power of patterns works.

What Are Design Patterns, Anyway?

You could safely define design patterns as blueprints or templates for resolving common problems in programming. Being language-agnostic, they are more about battle-tested strategies experienced developers use and reuse to create reliable software.

Design patterns are embedded in Laravel as a framework, although you can also use them explicitly in your own code. This will bring about the following benefits:

Improved Code Readability: Patterns convey, in a single glance, the intent of the code, even for other developers who might not have known your project.

Maintainability: Changes in code and debugging aren't as painful when the code is structured.

Scalability: Patterns will help you design code that grows and adapts to the evolution of your application.

Faster Development: Reusable patterns will save you time and effort, and you won't have to reinvent the wheel over for each problem. Essential Design Patterns for Laravel Developers

Let's go through a few of the key patterns most appropriate for Laravel applications:

Repository Pattern: This pattern acts as an intermediary between the logic level of your application and the data layer. This gives you a clean interface to the databases, or other data sources, making your code flexible and easier to test.
A good example would be if you were building a blog. In place of having your controllers working directly against Eloquent models, you would abstract that out into something like a PostRepository to abstract away database operations that dealt with posts, such as creation, fetch, save, delete, and so on.
Factory Pattern: Factories make the process of getting an object easy, especially when those objects require setup or dependencies that are complex.
One of the nice features of Laravel is that factories can be used to generate test data for your models. This can enable you to write very realistic tests without having to create the data by hand every time.
Decorator Pattern: Enables the addition of new behaviors to existing objects dynamically without changing their structure.
One could use this in order to realize caching for some service class. In this way, results of some expensive operations can be cached without touching the core logic of the service.
Observer Pattern: The Observer pattern is used to perform events generated by an object to a host of other objects.
One fine example of the Observer pattern is Laravel's event system. You would then be able to create event listeners that respond to some events with other actions. For example, an event that somebody has just become a new user of your website will send a notification or other similar event responses.

Real-World Scenario: Building a Modular E-commerce Platform

Suppose you are asked to build an enormous e-commerce platform. The following is how you could use design patterns to meet this challenge:

Repository Pattern: Handle the data of the products, orders, customers through repositories. It will keep business logic independent of the implementation of a database.
Factory Pattern: Creation of factories to create a realistic set of test data for your models—products, orders, users—to check everything works as it should.
Decorator Pattern: Implement caching on your product catalog to achieve better performance.
Observer Pattern: Use events for actions like sending order confirmation e-mails or updating inventory levels by Result.

Your Turn: Share Your Pattern Prowess

Which design patterns have you applied in your Laravel applications? Did you find any creative ways to use them? Please share your experiences and insights in the comments below! Let's learn from each other and build even better Laravel applications together.

Need a Design Pattern Guru?

If you have any design problems that are bugging you, or if you just want a more in-depth discussion about patterns, please don't hesitate to drop me an email at kareem_khaled@t-horizons.com. Let's chat!

PHP in the Age of AI: Don't Overlook This Web Powerhouse for Your Next Smart Project

Kareem Khaled — Sun, 30 Jun 2024 05:35:16 +0000

Thereafter, PHP might very well prove to be the unsung hero of the AI revolution. While Python gets huge exposure, PHP's varied strengths make it compelling for many AI-fueled web applications. But let me make something clear: This is not about declaring PHP as "the best" for AI. It's a reminder, especially to software engineers: Compare and contrast choices based on the merits of each project, not dismiss PHP when it involves tapping its potential in the AI space.

Why PHP & AI? A Practical Perspective

This is the real deal. Here's why you should just integrate artificial intelligence right into your current PHP stack. It's potentially going to be huge for the following reason.

Leverage Your Existing Expertise: If your team is already fluent in PHP, adding AI features doesn't mean you'll need to start from scratch. You can leverage your current experience and codebase to save hours and resources.

Seamless Integration: PHP is at the core of web development; it will, hence, easily integrate with your web servers, databases, and front-end technologies. This makes it easier to create a unified end-to-end AI-powered solution.

Performance & Scalability: While Python is a preeminent language for research, putting forward a great prototyping, PHP turns out more appropriate in production—especially where performance and scalability are concerns. The mature ecosystem of PHP provides tools and libraries to be leveraged for high-traffic web applications.

Case Study: PHP-Powered AI in Production

Consider a large e-commerce website, in the region of millions of users or products. Suppose the company wants to implement a product recommendation system to boost their sales. Here is why they opted for PHP over Python:

Already Existing Infrastructure: The website was written already in PHP and the development team was deep in terms of knowledge regarding the language, thereby mandating an expensive and time-consuming port to Python.
Performance Requirements: The recommendations engine was to scale a huge amount of data in real-time. PHP, combined with optimized algorithms and caching strategies, could be tuned for the required performance at scale.
Integration with Other Systems: The recommendation engine should be seamlessly implemented into the existing website systems, which were PHP-based catalog, shopping cart, and user profile. This was way easier with a PHP-based solution.

The team trained a machine learning model using the Rubix ML library, which then passively analyzed user behavior and product data to make personalized product recommendations for inclusion in the PHP codebase. Long story short—the result was a huge increase in sales and customer engagement.

Choosing the Right Tool for the Job

This case study demonstrates one very important thing: there is no single answer when developing artificial intelligence. Although Python has an exceptionally high support in research and data science, only now, with PHP, would it be possible to prove that it is indeed an equally powerful choice in AI's integration into web applications.

Consider these factors in the choice of language for your AI project:

Inherited code and competence of your team—build on top of what you already have. Performance and scalability—pick a language that will hold the weight of your workload. System Integration—Your AI pieces should communicate seamlessly with other parts of your application. Easy Deployment and Maintenance—Consider the long-term costs and complexities.

Your AI Journey with PHP Starts Here

Now, it becomes the duty of every software engineer to embrace the best tools for every job. There is nothing wrong with experimenting and looking into the possibilities with AI using PHP. After all, you never know what you might achieve.

Let's Keep the Conversation Going!

I look forward to getting your feedback on this. Have you ever tried using PHP for AI projects? What are your experiences and insights? Share your stories in the comments below or connect with me on kareem_khaled@t-horizons.com. Let us build a more illuminated, intelligent future together with PHP and AI!

Preventing IDM: A Tactical Guide to Protecting Your Video Content on Website

Kareem Khaled — Mon, 17 Jun 2024 18:35:06 +0000

Introduction

Ever put your heart and soul into making a stunning video only to see it being ripped and shared all over the internet without your permission? If you nodding, then most probably IDM is familiar to you. This powerhouse of a tool might be deemed a godsend for users in a zeal of downloading videos, but surely a bane upon creators like us enthralled with the prospects of protection from cyber theft of our treasured content.

Now, here's the challenge:

Any website has no direct access to your system's processes, so we can't simply ask, "Hey, is IDM running?" But, fellow creators, fear not! We're about to outsmart IDM a little with some clever code and tactical maneuvering.

Tell-tale Sign of IDM: The Video Tag

IDM isn't subtle, like most download managers, in targeting a video. It leaves a fingerprint in the form of a custom attribute, "idm_id", on the video tag. This is how IDM keeps track of which videos to snatch. But that very attribute is its Achilles' heel, and we're going to exploit it.

function checkForIDM() {
    const videos = document.getElementsByTagName('video');
    for (const video of videos) {
        if (video.hasAttribute('__idm_id__')) {
            return true; // IDM is likely running
        }
    }
    return false; // IDM not detected (yet)
}

One of our Lines of Defense: The IDM Detector

This JavaScript snippet will check your page for the presence of the "idm_id" attribute once every second. If it is found, we know IDM is on the prowl.

let idmCheckInterval;

function startIDMCheck() {
    idmCheckInterval = setInterval(() => {
        if (checkForIDM()) {
            clearInterval(idmCheckInterval);
            blockContent(); // (see next snippet)
        }
    }, 1000); // Check every second
}

startIDMCheck(); // Begin monitoring immediately

Block and Redirect: When IDM Strikes

If IDM is detected, we need to act fast. Here's how we'll block the content and give the user clear instructions:

function blockContent() {
    const content = document.body.innerHTML;
    document.body.innerHTML = `
        <h1>IDM Detected</h1>
        <p>Please disable IDM and reload the page to view this content.</p>
        <button onclick="location.reload()">Reload</button>
    `;
}

The Bait-and-Switch: Protecting Your Video URL

But we're not done yet. Though we block IDM, it might have taken your video URL. To counter this, we're going to do a little trickery.

When the page loads, embed your video with a fake URL (like some very short, silent video).
After 5 seconds, start a timer.
If there is no IDM activity within those 5 seconds, we know we are in the clear.
Replace this with your actual video source.

const realVideoSrc = "your-actual-video.mp4";
const fakeVideoSrc = "dummy-video.mp4";

function swapVideoSrc() {
    const video = document.querySelector('video');
    video.src = realVideoSrc;
}

setTimeout(() => {
    if (!checkForIDM()) {
        swapVideoSrc();
    }
}, 5000); // Replace after 5 seconds if safe

Don't Forget..

This is a good base but this fight against downloaders never gets really won. You may need to tune these techniques from time to time when new tools are invented .

Let's Chat!

I'd love to hear your thoughts on this approach. Have you faced similar challenges? Do you have other tricks up your sleeve? Feel free to drop a comment below or reach out to me via email at karemkhaled945@gmail.com .
Let's geek out about video protection together!

GraphQL vs. REST: A Dev's Guide to Picking Your API Poison (and Why You Should Argue With Me)

Kareem Khaled — Mon, 17 Jun 2024 02:53:00 +0000

If you're building anything web-related these days, chances are you've got a nagging question at the back of your mind: REST or GraphQL? It certainly feels like the old, trusty workhorse pitted against the shiny new toy in this battle. Which one will be right for your project?

Let's hash this out.

REST: Good Old Days

It is no wonder that REST has been here for a long time; it is very easy and liberal. This method is so easy to understand and start working on. REST operates with the client-server model and uses the following conventional HTTP methods to execute the CRUD: GET, POST, PUT, and DELETE.

The beauty of REST lies in the simplicity and wide adoption. It is almost like a trusty toolbox that everyone knows how to use – a huge amount of documentation, libraries, and tools are available, and pretty much any developer you hire will at least have experience with it.

…but REST isn't perfect….

The probably largest disadvantage of REST at this point is that you always end up either over- or under-fetching data. You either get too much information back at a time, wasting bandwidth and processor cycles, or it makes a bunch of requests to get all the data you want. It's really a pain, especially when it comes to bandwidth-hungry mobile apps.

Another annoyance is the rigidity of REST endpoints. You need to define them up front, and when your front-end requirements change, you have the potential pain of redesigning your API.

GraphQL: The Shiny New Toy

GraphQL was born out of frustrations at Facebook with the limitations of REST. It's a query language that lets one request exactly what is needed and nothing more or less. You basically define a schema that describes your data, and then clients can send in queries to retrieve specific information as per their requirements.

The really cool thing about GraphQL is that there's only one endpoint for all of your requests. That could help a lot in reducing the number of round trips to the server, making your application snappier. And the strongly typed schema allows you to catch errors way too early; it also makes it easier to maintain your API.

Hold Your Horses, GraphQL Ain't All Sunshine and Rainbows

While GraphQL is undoubtedly very powerful, it comes with its set of challenges. First of all, there is a bigger learning curve since you need to understand the concept of schemas, queries, and mutations, which might become overwhelming at the very start.

Another problem is caching. Since GraphQL queries are capable of being so dynamic, having efficient caching strategies in place is trickier compared to REST.

And then there's the performance factor. Unless you're careful, complex GraphQL queries can really tax your server.

The Smackdown: When to Choose Which

So, when should you go with GraphQL and when should you stick with REST? Here's my opinion, but don't worry - I love a good argument about this:

Use GraphQL if:

Your app has complicated data requirements.
You're developing a mobile app and you want to reduce the number of network requests.
You're using microservices architecture.
Your frontend requirements are changing all the time.

Stick with REST if:

You have a small API with simple data requirements.
You are building a public API that must be easily consumed by a broad base of external developers.
Caching is of the highest priority for your app.
The Hybrid Option

Of course, there's no rule saying you must pick one or the other. In many cases, a hybrid approach that combines GraphQL and REST might be the perfect solution.

Now it's your turn!

On a final note, now that I have shared my two cents, I would be interested in hearing from you on what you think. So, have you tried GraphQL or REST in your projects? What was your feeling? Have you had any unexpected challenges? Maybe you just have a bit of a completely different angle about this whole debate.

Drop a line in the comments below, or hit me up on (kareem_khaled@t-horizons.com)

Let's start this chat!