I’ve been working for months on a project that uses AWS Lambda + Python + FastAPI + Docker. I tried to debug a Lambda following several tutorials, AI, Medium articles, and YouTube videos without success. Almost all of them were obsessed with using AWS SAM, which I don’t use at all. So I took advantage of a quiet Sunday afternoon in my dungeon (I mean basement), and finally found a way to make it work. I’ll show you how below and I hope it helps you. 😉

Introduction

First things first.

To debug an AWS Lambda function locally with Docker and VSCode, the idea is to run the function inside a Dockercontainer with a Lambda, and then connect the VS Code debugger to a Python process inside the container. What worked for me was importing Mangum + debugpy in the image, and using it to start the FastAPI server.

Don’t worry, I’ll explain everything step by step.

Requirements

• Docker (I use OrbStack).
• VS Code with the Python extension installed + Remote — Containers. You probably have both installed.

Example Project Structure

Before going into details, a possible folder structure for this project could be:

.
├── lambda.py
├── Dockerfile
└── .vscode/
   └── launch.json

• lambda.py: contains the FastAPI app and the handler with Mangum.
• Dockerfile: defines the image based on AWS Lambda Python.
• .vscode/launch.json: configuration so that VS Code can “attach” the debugger to the container.

Let’s continue.

Dockerfile: Base Image and Dependencies

Now let’s create a Dockerfile using the official AWS Lambda for Python image and add the necessary dependencies:

FROM public.ecr.aws/lambda/python:3.13

WORKDIR /app

RUN pip3 install fastapi mangum debugpy --target "${LAMBDA_TASK_ROOT}"

COPY lambda.py ${LAMBDA_TASK_ROOT}/lambda.py

CMD [ "lambda.handler" ]

I suppose you know what Lambda_TASK_ROOT is, right? It’s an environment variable that AWS Lambda automatically sets to the directory where the function runs. In this case, we’re installing the dependencies in that directory so they’re available when the function runs.

Mangum, for those who don’t know, is an adapter that allows you to run ASGI applications (like FastAPI) in an AWS Lambda environment.

I used pip to keep the example simple, but you can use poetry or pipenv if you prefer. The key is to install the dependencies in the Lambda working directory ${LAMBDA_TASK_ROOT} so they're available when the function runs.

Lambda Function Code (FastAPI + Mangum)

import debugpy  # type: ignore
from fastapi import FastAPI  # type: ignore
from mangum import Mangum  # type: ignore

app = FastAPI()
debugpy.listen(("0.0.0.0", 5678))
print("Waiting for debugger to attach...")
debugpy.wait_for_client()

# curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"resource": "/", "path": "/", "httpMethod": "GET", "requestContext": {}, "multiValueQueryStringParameters": null}'
@app.get("/")
def read_root():
    is_testing = True
    message = "Hello, world!"
    return {
        "message": message,
        "is_testing": is_testing,
    }

handler = Mangum(app)  # Adapter for AWS Lambda

This code creates a GET / route and then defines handler = Mangum(app) so that the Lambda correctly invokes the FastAPI application. In VS Code you can set breakpoints inside any of these functions/lines once the application is running in debug mode.

Add a breakpoint for example at the return of the read_root function.

VS Code Configuration for Debugging

Now let’s configure VS Code to connect to the Docker container and debug the Lambda function. In the .vscode/launch.json file:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Attach to remote Lambda",
            "type": "python",
            "request": "attach",
            "connect": {
                "host": "localhost",
                "port": 5678
            },
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}",
                    "remoteRoot": "/app"
                }
            ]
        }
    ]
}

Everything should be ready. It should look like this:

Build and Run the Container

With a single line, like a pro: 😎

docker build -t lambda-debug . && docker run --rm -p 9000:8080 -p 5678:5678 --name lambda-debug-container lambda-debug

• - - rm: Removes the container when it stops. Remember that Lambdas only run once and then are destroyed, so this is useful to avoid leaving orphan containers.
• -p 9000:8080: publishes port 8080 of the container to the host on localhost:9000. It listens for requests on /2015-03-31/functions/function/invocations to invoke the function, but this may vary depending on your Lambdaconfiguration. Check the AWS documentation for more details.
• -p 5678:5678: Important. This publishes the port where debugpy will listen for the debugger connection.

Remember: Every time you make a code change, you’ll need to rebuild the image and restart the container. I need to find a way to automate this, or maybe there’s something so you can make requests without having to restart the container for a Lambda.

Now open another terminal and run the following command to invoke the main function of the Lambda:

curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"resource": "/", "path": "/", "httpMethod": "GET", "requestContext": {}, "multiValueQueryStringParameters": null}'

In the first terminal, you should see a message like this:

Waiting for debugger to attach...

Now, in VS Code, open Run & Debug (Ctrl or cmd+Shift+D) and select the configuration we created earlier: Python: Attach to remote Lambda. Then click the green start button or press F5 to start the debugger.

If everything went well, and you set a breakpoint, you should see in the debug window the variables and the code stopped at the breakpoint. From here you can inspect variables, run commands in the console, and do whatever you want.

That’s it. No conclusions or tips. Just… “Enjoy” the debugging process as much as I do! 😉

Time to clap 👏 & follow me! 👯

On my blog, you can read news/tutorials about Raspberry Pi, Linux, macOS, DevOps, development, and all the things you and I want to learn.
Visit my LinkedIn profile here!

Thank you!

macOS is a versatile operating system, but having the right all the difference for those in the terminal.

With Homebrew, managing essential command-line applications becomes effortless. Below, I’ll highlight some of the most indispensable tools in my workflow, each installed and updated via Homebrew, to streamline tasks, enhance productivity, and supercharge the terminal experience. 😊

1. Axel: Light UNIX Download Accelerator

Command: brew install axel

axel is a high-performance download accelerator that simplifies file downloads. Utilizing multiple connections to fetch data significantly reduces download times without complicating the command-line experience.

I use it to download iso images, as seen in the capture above.

2. Bat: Enhanced cat with Syntax Highlighting

Command: brew install bat

Bat takes the humble cat command to the next level. Featuring syntax highlighting, Git integration, and line numbers… It’s perfect for developers and DevOps who need to read code or configuration files at a glance.

3. Broot: Intuitive Directory Tree Navigation

Command: brew install broot

Broot reinvents how you browse directories, offering a visually pleasing tree view combined with fuzzy searching. It’s an indispensable tool for navigating complex file systems quickly and efficiently.

4. Curl: Web File Transfer Workhorse

Command: brew install curl

Curl is a Swiss Army knife for transferring data. Whether testing APIs or downloading files, it’s a must-have for any developer or network engineer.

For example:

alias ipe="curl -s ipecho.net/plain | tee >(pbcopy)"
get_info_from_ip() { # Ex: get_info_from_ip 217.160.0.196
    curl -s "https://ipapi.co/$1/json/" | jq
}
get_latest_release() { # Ex: get_latest_release laravel/laravel
    curl --silent "https://api.github.com/repos/$1/releases/latest" |
        grep '"name":' |
        sed -E 's/.*"([^"]+)".*/\1/'
}

5. Eza: Modern ls Replacement

Command: brew install eza

Eza breathes new life into the ls command with a modern aesthetic, colorized output, and support for Git integration, too. It’s both visually appealing and packed with features.

In the capture above, command ll means:

alias ll='eza -lh --git --group-directories-first -s extension --icons'

6. FFmpeg: Multimedia Powerhouse

Command: brew install ffmpeg

FFmpeg is the ultimate tool for handling audio and video. From transcoding to streaming, its versatility covers almost every multimedia task you can imagine.

7. fzf: Command-Line Fuzzy Finder

Command: brew install fzf

fzf allows you to quickly search through files, commands, and directories with its fuzzy matching algorithm. Integrating seamlessly with other tools is essential for productivity If you use it with zsh.

8. Git: Version Control System

Command: brew install git

No development environment is complete without Git. This distributed version control system is the backbone of modern software collaboration, making it essential for developers.

Some of my most used Git aliases:

alias g.bah="git reset --hard; git clean -df"
alias g.brs="git for-each-ref --sort=-committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'"
alias g.l="git log --oneline --decorate --graph"
alias g.la="git log --pretty=format:'%C(yellow)%h | %ad%Cred%d | %Creset%s%Cblue | [%cn]' --decorate --date=short"

You can visit my article about Git here on my blog!

9. GnuPG: Secure Encryption

Command: brew install gnupg

GnuPG provides robust encryption for secure communication and data storage. It’s widely used for email encryption, file signing, and key management.

10. Jq: JSON Processor Extraordinaire

Command: brew install jq

Jq makes working with JSON data a breeze. Whether formatting, querying, or transforming JSON, it’s a lifesaver for developers and data analysts.

11. Ncdu: Disk Usage Analyzer

Command: brew install ncdu

ncdu is an interactive tool that provides detailed insights into disk usage. Its intuitive interface helps you identify and clean up large files and directories.

12. Pyenv: Python Version Manager

Command: brew install pyenv

Managing multiple Python versions is a breeze with Pyenv. It’s indispensable for developers working on diverse projects requiring different Python versions, but I’m migrating to uv on my projects and using Poetry at work.

13. Python@3.11: Cutting-Edge Python Interpreter

Command: brew install python@3.11

macOS already has Python installed by default. You can install the Python version you need. It’s the backbone of countless scripts, applications, and libraries.

14. Sevenzip: High-Ratio File Compression

Command: brew install sevenzip

Sevenzip delivers outstanding compression and decompression performance for various formats, making it an essential utility for handling large files efficiently.

Example for compressing and splitting a file:

7zz a -t7z -v3500m largemovie.7z most_large_movie_ever.mkv

15. ShellCheck: Lint Tool for Shell Scripts

Command: brew install shellcheck

ShellCheck helps you write better, safer shell scripts by identifying potential bugs and offering actionable suggestions. It’s a must for anyone automating tasks.

16. yt-dlp: Advanced Video/Audio Downloader

Command: brew install yt-dlp

A fork of the popular youtube-dl, yt-dlp boasts additional features for downloading videos and audio from a wide array of platforms. It’s powerful, reliable, and feature-rich.

Here is an example of an alias I use to download YouTube videos:

alias ydload='yt-dlp -U & cd $HOME/Downloads && yt-dlp --concurrent-fragments 4 -q --no-check-certificates -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best" --merge-output-format mp4 --write-auto-sub --sub-lang en'

17. z: Smarter Directory Traversal

Command: brew install z

z learns your directory habits, allowing you to jump to frequently visited folders with minimal typing. It’s an invaluable timesaver for frequent navigators.

These essential macOS command-line applications enhance my productivity every day. Whether you’re a developer, sysadmin, or power user, these tools will elevate your macOS experience. 💪

I’m pretty sure you have your favorite essential tools. Keep it, and don’t show me in the comments. I don’t want to use them…

(Now is when you stop reading, go to comments, and drop all your tools like a Good Samaritan to prove your apps are the best).

Ready to supercharge your terminal? Open up your favorite shell, run brew install, and… Start exploring!

Time to clap 👏 & follow me! 👯

On my blog, you can read news/tutorials about Raspberry Pi, Linux, macOS, DevOps, development, and all the things you and I want to learn.
Visit my LinkedIn profile here!

Thank you!

I don’t tell you a lie when I advise you that if you’re not using AI in your day-to-day life, you’re missing a great opportunity.

WE CAN’T ESCAPE!.

This is moving fast and you do not need to be convinced that it can help you in all the processes you perform, in the profession you have. In this article, I’ll tell you how I use it as a developer and maybe in another article, as a writer.

GitHub Copilot

I’m not going to spend much time telling you what I write in this section either. For $20 you have an assistant on your IDE that helps you write code. It’s not perfect by the way, but it saves you time and I’m impressed with the Wow 😱 effect.

Sometimes, it even gives you solutions you hadn’t thought of (and at first it makes you angry as a human that you are). It’s like the smart-ass dude who’s correcting you and giving you solutions without asking him… Funny that I came to mind Eddie Deezen acting in the movie WarGames.

Not everything is as beautiful as it seems, because sometimes it gives you solutions that are not the most optimal, and you have to review them (there are hundreds of memes about this, here is one 😂 ). But hey, that’s what it is this year. The next one, we’ll see…

By the way, in VSCode remember to install the two essential extensions to get the most out of it: GitHub Copilot and GitHub Copilot chat. You also have an extension for use with GitHub Codespaces, which allows you to use Copilot in the cloud.

I recommend looking at the playlists on the Visual Studio Code YouTube channel. I leave you some tips that I use in my day to day:

· Ideal for small scripts: It is one of the features I use most. I have created scripts to automate tasks that took time and now I have them in a snap. For example, a script that cleans the external storage systems before ejecting in Rust (and I don’t have much idea of this language), another that downloads YouTube playlists…

· Make my tests!: What we most hate as programmers, but that helps us a lot. Our friend helps you write the tests, but It’s not thinking about them. You give him a little push, you’ll see how fast the dirty work does.

· Use keyboard shortcuts: If you use VSCode like me, I recommend that you learn the keyboard shortcuts it offers. Cmd + Ito ask him inline, Shift + Cmd + H opens the side chat so you can ask him.

· Use / in the chat: If you type / in the chat, it gives you a list of commands that you can use to improve the response. In my case, I use a lot @workspace to give me solutions according to my workspace, but you have many others: /help, #file:index.html, /explain, @vscode, etc.

· Ask what you want: It’s an AI, so don’t be afraid: How can I build this project? How do I install the dependencies? Where are the middlewares? Can you give me the secret to get rich? Remember that if you don’t want generic results, you have to specify @workspace or @file to get solutions that fit your workspace. It is not the same build me a class Calculator that build me in PHP a class Calculator documenting the methods and typing the parameters.

· Errors in the code or Terminal: If you get an error when executing your code, you can ask Copilot what is happening. Select the error and paste it into the chat. If the problem comes from the terminal, select the code, press the right mouse button, and choose the Explain this option. You can also click on the sparkles ✨ that appear on the left of your prompt.

· On your smartphone, too!: If you use GitHub on your smartphone, you can use GitHub Copilot. 😍

· When all fails or doesn’t get the solution you’re looking for: Don’t get upset. What I do is create a new chat and ask again. Above all, it happened to me when he offered you code that comes from some public project. You must specify in the settings within GitHub Copilot that you want to (or not) give you solutions using public code by turning on or off the option Suggestions matching public code (duplication detection filter).

· Let that generate the for your commits: If you don’t like to write comments for commits, tap the icon ✨. The good thing is that it is learning from your comments and will give you solutions more according to your style.

Help in the Terminal

When I have to write a command I don’t know or don’t remember, I always go to Warp, the Terminal that has built-in serial AI. It’s like a Copilot for the Terminal and it’s cross-platform. If you haven’t tried it, I recommend it. So write what you want to do and it gives you the solution. Easy and fast… It’s free, but it has payment plans.

Yes, Copilot in the Terminal!

GitHub Copilot can also help you with terminal commands in three different ways: you specify the word @terminal before your chat question, with Cmd + I in the terminal view inside VSCode or you can use GitHub Copilot in the CLI.

Code reviews

If you use a GitHub or GitLab account, you can incorporate Sourcery into your workflow. In my case, when I make a pull request, it gives me suggestions on how to improve my code. For open-source projects is free.

AI agents

Although it is not a tool that I use daily (yet), I find this concept interesting to mention. They explain it very well in this article by Zapier. I’ll let my AI explain it to you:

Imagine you have a bot that helps you do repetitive tasks, such as letting you know if a server is down, telling you if a pull request has been approved, or letting you know if an issue has been closed. Well, that’s what AI Agents mean.

Here at Medium, you have a specific topic you can find here
. For reference, the AgentGPT project is a good example of what I’m talking about. Check it out!

As a learning tool

I think it’s one of the best tools you can have to learn how to code.

In case you are starting with a new language or framework, my advice is to create a markdown file with a header type with sentences like How to make a CRUD in Python or Introduction to Rust programming. Behold how it begins to give you ideas and sections continuously.

Tell me what you know about my PDFs

I worked as a project manager for the last two years, and I accumulated a lot of reports. If a client requested any data, I had to look for it among hundreds of Word documents or PDFs.

When I found the private-gpt repo, all I had to do was ask for any information from a chat, and it was returned to me along with the name of the file where it was quickly and (almost) effective.

It is a tool that I recommend if you have to deal with many documents and your brain does not remember the commissions that were agreed on six months ago. The best: privately and locally.

Other AI you can use

If you are not convinced or do not want to pay for GitHub Copilot, there are other options.

For example, Tabnine in its Basic plan, uses autocomplete code and is a GitHub Copilot first cousin. Another approach is DeepCode, which is a code analyzer that helps you find errors and improve your code.

The above-mentioned Sourcery can also help you in this regard and it is very easy to implement it. You can see the documentation for VSCode here.

Do you know Continue? It is a very young extension for VSCode and JetBrains. It seems Copilot, but locally. That is, the model must be supplied by you using Ollama or similar (list of models here). You can get more info here.

There are many sites specializing in AI for developers, such as Phind or Userway, but I recommend those you can use within your IDE, to make it easier to use and “learn” to give you code according to your workspace.

Final words

It’s funny what happens with this technology: if you don’t use it, you stay behind, and if you use it, it’s like that new co-worker who has put you aside so that you learn everything you know and the company can hire you in the future. 😅

According to some analysts, there is still a lot left for that to happen (five years!), although others believe that it is one more tool and that it will simply modify the way we interact with machines.

Allow me, in the meantime, to enjoy the advantages that it offers me to improve my writing, either of code or of prose, and to continue helping me in those works that take me more time than I would like.

As an example of what I am talking about, I have written the word we, and look at what the autocomplete of Copilot tries to convince me of:

We have to be aware that AI is not the enemy, but a tool that can help us to be more efficient in our work. — 🤖

Whatever you say, dude. Whatever you say… 🤦

Time to clap 👏 & follow me! 👯

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi, Linux, macOS, DevOps, development, and all the things you and I want to learn.
I’m looking for a job, so visit my LinkedIn profile here! Thank you!

CONTENT UPDATED: This post was updated on June 23, 2024. 🚀

The best part that you are reading my posts is that I don’t need to convince you with tons of resources like a dirty trickster to follow me. The resources I share with you are the best roadmaps for programming languages I found, now in 2024. Those are my personal preferences, and here are not all the language programming, only the ones I’m interested in according to my career, but I’m sure you will find them useful.

Laravel

If you like Laravel, you probably follow Povilas Korop, the creator of Laravel Daily. He has a great roadmap for Laravel and is very updated.

Link: laraveldaily.com/roadmap-learning-path

PHP

For PHP, I recommend the roadmap from PHP the Wrong Way. It’s a very complete guide for beginners and advanced users. You have a lot of resources and tutorials to start with PHP, from the basics to the advanced.

Link: phpthewrongway.com | OK, here you have the link to phptherightway.com, too. 😉

Front-End

I’m not like front-end, but as a freelance, I need to know the basics. I chose the roadmap from geeksforgeeks because It’s very complete and updated. Check the tutorials and resources they provide (very useful, but ssh!… Don’t tell anyone).

They have a MERN roadmap too, but I’m not a big fan of that stack. Maybe because I haven’t used it yet. Do you recommend it?

Link: geeksforgeeks.org/frontend-developer-roadmap

Open Source Guides

If you are interested in contributing to open-source projects, you should check the next guides. They have a lot of resources and guides: Starting an open source project, contributing, licensing, best practices, and more.

Coded with ❤️ by GitHub and friends.

Link: opensource.guide

Developer roadmaps

If you are a developer, you should check the roadmap from Kamran Ahmeds. It’s a very complete guide for people like you. From role to basic & advanced skill.

Link: roadmap.sh

I will leave you with another great resource called Exercism: A platform that provides coding exercises for different programming languages. Practice your skills and learn new languages.

Link: exercism.org

DSA

Many developers always recommend learning Data Structures and Algorithms with the Princeton University courses. I’m not a big fan of those courses (and they are a bit boring). If you are interested in this topic, you really should check the roadmap from Techie Delight. They have a lot of resources and tutorials with practical examples and multi lingual.

Final thoughts

Being a developer or starting a new career in programming is a challenge. Sometimes you can feel overwhelmed, but with the right resources, you can achieve your goals.

I forgot to mention If you are a complete newbie, you should check the CS50’s Introduction to Computer Science from Harvard University. It’s a great course to start with the right foot.

I’m sure you will find this post useful, so add it to your bookmark right now! 😄

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi, Linux, macOS, DevOps, development, and all the things you and I want to learn.
I’m looking for a job, so visit my LinkedIn profile here! Thank you!

I have a problem with the software on my OS, maybe It’s a disease, I don’t know. The reason:

I NEED TO KEEP ALL MY APPS UPDATED

I try not to have many of them, but the apps I have installed need the latest updates. How do I get it? With some apps that help me on that mission. Do you want to know which ones? Keep reading!

Latest

Latest is a free and open-source app that checks if all your apps are up to date. It’s a simple app that shows you a list of all your installed apps and the latest version available.

You can update them with a single click or one by one. It supports apps downloaded from the Mac App Store and apps that use Sparkle for updates, which covers most of the apps on the market.

If the app is not supported, you can open the app through Latest and check for updates manually.

Link: github.com > Latest

Cork

It’s a fast GUI for Homebrew apps!

In the past, I used to update my apps with the terminal, but with Cork, I can do it with a single click (even when I love the Terminal).

It’s a paid app, but you have the chance to compile and use it for free. It has many other features to handle visually your Homebrew apps: search, fix, install, uninstall,…

It just works & It’s a great tool to keep your apps updated. Dot.

Link: github.com > Cork

Python cleanup script for macOS

mac-cleanup-py is a powerful cleanup script for macOS. It helps you in the next tasks: Empty Trash, delete unnecessary logs & files and clear cache from OS or some apps. You can enable specific apps to clean up, like Xcode or Android Studio. It has a very useful dry mode to see what it will do before running it.

Link: github.com > mac-cleanup-py

Custom function

So I think this is something all developers should have in their .*rc file: A simple function that checks if there are any updates available for the installed apps. For example, I use this function in my .zshrc file:

update_all() {
    if [[ -f /usr/local/bin/composer ]]; then
        composer self-update
        composer global update
    fi

    softwareupdate --all --install --force
    brew outdated && brew update && brew upgrade && brew cleanup
    ## Add yours here!
}

Conclusion

Now you have no excuse to keep your macOS updated. Of course, you can still use manual methods, but with these apps, you can have more control over the process in less time. Do you use any other app to achieve that? Let me know! 😃

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi, Linux, macOS, DevOps, development, and all the things you and I want to learn.
I’m looking for a job, so visit my LinkedIn profile here! Thank you!

Finally, we reach the last principle of the SOLID series. The Dependency Inversion Principle is the most complex of all, but I’ll try to explain it in a simple way.

I remember being asked about this principle in a recent job interview and I didn’t know what to say. Many times you know what it is by concept, but explaining it with an example (in English, which is not my tongue language) is hard. If it happens to you, the best thing to do is to be honest and say so. It’s okay and the interviewer will appreciate it.

Let’s review all the principles we have seen:

Single Responsibility Principle: A class should have only one reason to change.
Open/Closed Principle: A class should be open for extension but closed for modification.
Liskov Substitution Principle: You should be able to use any subclass in place of its parent class.
Interface Segregation Principle: A class should not be forced to implement an interface it doesn’t use.
Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions.

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. Also, abstractions should not depend on details. Details should depend on abstractions. A lot of words, I know, but we’ll look at it right now. Besides, I think this principle is the one that will help you the most in the long run.

Let’s see some examples to better understand it:

// Bad
class MySQLConnection {
    public function connect() {
        return "Database connection";
    }
}

class PasswordReminder {
    private $dbConnection;

    public function __construct(MySQLConnection $dbConnection) {
        $this->dbConnection = $dbConnection;
    }
}

In this example, the PasswordReminder class depends on the MySQLConnection class. If you want to change the database connection to another type, you will have to modify the PasswordReminder class. This does not follow the Dependency Inversion Principle.

To solve this, you can use an interface:

interface DBConnectionInterface {
    public function connect();
}

# The MySQLConnection class implements this interface, providing its own implementation of the connect() method.
class MySQLConnection implements DBConnectionInterface {
    public function connect() {
        return "Database connection";
    }
}

class PasswordReminder {
    private $dbConnection;

    public function __construct(DBConnectionInterface $dbConnection) {
        $this->dbConnection = $dbConnection;
    }
}

Now, the PasswordReminder class depends on the DBConnectionInterface interface, not on the MySQLConnection class. If you want to change the database connection, you only need to create a new class that implements the DBConnectionInterface interface. This makes PasswordReminder more flexible and less coupled to a specific database connection implementation.

Do you not find it easy? Let’s see another example:

interface StorageInterface {
    public function save($data);
}

class FileStorage implements StorageInterface {
    public function save($data) {
        // Save data to a file
    }
}

class DatabaseStorage implements StorageInterface {
    public function save($data) {
        // Save data to a database
    }
}

class UserController {
    private $storage;

    public function __construct(StorageInterface $storage) {
        $this->storage = $storage;
    }

    public function store($data) {
        $this->storage->save($data);
    }
}

$fileStorage = new FileStorage();
$userController = new UserController($fileStorage);
$userController->store("Some data");

In this example, the UserController class depends on the StorageInterface interface, not on the FileStorage or DatabaseStorage classes. This allows you to easily change the storage type without having to modify the UserController class.

We also note that UserController does not know how information is stored (details), it only knows that it is stored. The DatabaseStorage and FileStorage classes are the details and depend on the StorageInterface abstraction.

I hope you have enjoyed the last article about SOLID principles. In the future, I plan to investigate other design patterns.

Stay tuned! 😄

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi & Linux, and soon about Mac, DevOps, development, and all the things you and I want to learn.
I’m looking for a job, so visit my LinkedIn profile here! Thank you!

We are almost ending the series of articles about the SOLID principles. Here you have a brief explanation of each principle to review them:

Single Responsibility Principle: A class should have only one reason to change.
Open/Closed Principle: A class should be open for extension but closed for modification.
Liskov Substitution Principle: You should be able to use any subclass in place of its parent class.
Interface Segregation Principle: A class should not be forced to implement an interface it doesn’t use.
Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Today we are going to focus on the Interface Segregation Principle. It’s very easy to understand, I promise. ❤️

This principle states that a class should never be forced to implement an interface that it doesn’t use. If you implement an interface in a class, but only utilize a few of its methods, It indicates that you are violating this principle. An Example:

// Bad
interface Bird {
    public function fly();
    public function swim();
}

class Eagle implements Bird {
    public function fly() {
        return "I can fly";
    }
    public function swim() { <- Forced to implement a method that it does not need
        return "I can't swim";
    }
}

class Penguin implements Bird {
    public function fly() { <- Forced to implement a method that it does not need
        return "I can't fly";
    }
    public function swim() {
        return "I can swim";
    }
}

In this example, the Bird interface has two methods: fly and swim.

The Eagle and the Penguin classes implement both methods, but the Penguin class only should implement the swim method (Have you ever seen a penguin flying?), and Eagle should implement the fly method. This violates the Interface Segregation Principle.

An example of the correct way to implement the Interface Segregation Principle:

// Good
interface Bird {
    public function fly();
}

interface Swimmer {
    public function swim();
}

class Eagle implements Bird {
    public function fly() {
        return "I can fly";
    }
}

class Penguin implements Swimmer {
    public function swim() {
        return "I can swim";
    }
}

Now we have two interfaces: Bird and Swimmer. The Eagle class implements the Bird interface, and the Penguin class implements the Swimmer interface. This way, we are following the principle we are discussing. Easy, right? 😄

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi & Linux, and soon about Mac, DevOps, development, and all the things you and I want to learn.

I’m looking for a job, so visit my LinkedIn profile here! Thank you!

In the noble art of coding, you should remember the SOLID principles always. Sometimes, I forget some of them, so here is a brief explanation of each principle:

Single Responsibility Principle: A class should have only one reason to change.
Open/Closed Principle: A class should be open for extension but closed for modification.
Liskov Substitution Principle: You should be able to use any subclass in place of its parent class.
Interface Segregation Principle: A class should not be forced to implement an interface it doesn’t use.
Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Today we are going to focus on the Liskov Substitution Principle.

This principle states that “functions that use pointers or references to base classes must be able to use objects of a derived class without knowing it”.

In other words, derived classes must be completely substitutable for their base classes. If a derived class cannot be substituted for a base class, then the class hierarchy is not well designed and violates Liskov’s substitution principle.

Here you have an example of PHP about it:

// Bad

class Bird {
    public function fly() {
        return "I can fly";
    }
}

class Penguin extends Bird {
    public function fly() {
        return "I can't fly";
    }
}

function letItFly(Bird $bird) {
    return $bird->fly();
}

echo letItFly(new Bird()); // "I can fly"
echo letItFly(new Penguin()); // "I can't fly"

In this example, Penguin is a subclass of Bird. However, not all birds can fly, so when we try to make a Penguin fly, we get an unexpected result. This violates Liskov’s substitution principle.

A better way to do this would be to have a Bird base class and a Flyable interface that only implement birds that can fly:

class Bird {
}

interface Flyable {
  public function fly();
}

class Sparrow extends Bird implements Flyable {
  public function fly() {
    return "I can fly";
  }
}

class Penguin extends Bird {
}

function letItFly(Flyable $bird) {
  return $bird->fly();
}

echo letItFly(new Sparrow()); // "I can fly"

In this example, if we try to fly a Penguin, we will get a compile-time error, because Penguin does not implement the Flyable interface.

Another example:

// Bad

class Animal {
  public function eat() {
    return "I can eat";
  }
}

class Lion extends Animal {
  public function eat() {
    return "I can eat meat";
  }
}

class Rabbit extends Animal {
  public function eat() {
    return "I can eat vegetables";
  }
}

class Plant extends Animal {
  public function eat() {
    throw new Exception("Plants do not eat");
  }
}

function feed(Animal $animal) {
  return $animal->eat();
}

echo feed(new Lion()); // "I can eat meat"
echo feed(new Rabbit()); // "I can eat vegetables"
echo feed(new Plant()); // Exception: Plants do not eat

// Good

class LivingEntity {
}

interface Eatable {
  public function eat();
}

class Lion extends LivingEntity implements Eatable {
  public function eat() {
    return "I can eat meat";
  }
}

class Rabbit extends LivingEntity implements Eatable {
  public function eat() {
    return "I can eat vegetables";
  }
}

class Plant extends LivingEntity {
}

function feed(Eatable $entity) {
  return $entity->eat();
}

echo feed(new Lion()); // "I can eat meat"
echo feed(new Rabbit()); // "I can eat vegetables"

I hope we can understand the principle. See you in the next one! 😉

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi & Linux, and soon about Mac, DevOps, development, and all the things you and I want to learn.

I’m looking for a job, so visit my LinkedIn profile here! Thank you!

First of all, here you have the four principles of SOLID:

Single Responsibility Principle: A class should have only one reason to change.
Open/Closed Principle: A class should be open for extension but closed for modification.
Liskov Substitution Principle: You should be able to use any subclass in place of its parent class.
Interface Segregation Principle: A class should not be forced to implement an interface it doesn’t use.
Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions.

The Open/Closed principle states that “software entities (classes, modules, functions, etc.) must be open for extension, but closed for modification”. So, once a software entity is developed and tested, it should be possible to extend its behavior without having to modify its source code.

Look at the following code:

class Rectangle {
  public $width;
  public $height;

  public function __construct($width, $height) {
    $this->width = $width;
    $this->height = $height;
  }
}

class Circle {
  public $radius;

  public function __construct($radius) {
    $this->radius = $radius;
  }
}

class AreaCalculator {
  public function calculate($shapes) {
    $area = [];
    foreach ($shapes as $shape) {
      if ($shape instanceof Rectangle) {
        $area[] = $shape->width * $shape->height;
      } elseif ($shape instanceof Circle) {
        $area[] = $shape->radius * $shape->radius * pi();
      }
    }

    return array_sum($area);
  }
}

In this example, if you wanted to add a new form, you would have to modify the AreaCalculator class and add a new condition in the calculate method. In other words, Open/Closed principle says that you should be able to add new functionality to a class without modifying it.

The example above violates the Open/Closed principle.

A better way to do this would be to define an area method in each form and then call that method in AreaCalculator:

interface Shape {
  public function area();
}

class Rectangle implements Shape {
  public $width;
  public $height;

  public function __construct($width, $height) {
    $this->width = $width;
    $this->height = $height;
  }

  public function area() {
    return $this->width * $this->height;
  }
}

class Circle implements Shape {
  public $radius;

  public function __construct($radius) {
    $this->radius = $radius;
  }

  public function area() {
    return $this->radius * $this->radius * pi();
  }
}

class AreaCalculator {
  public function calculate($shapes) {
    $area = [];
    foreach ($shapes as $shape) {
      $area[] = $shape->area();
    }

    return array_sum($area);
  }
}

Now, if you wanted to add a new form, you would just have to create a new class that implements the Shape interface and defines the area method. The AreaCalculator class would not have to be modified to accommodate the new form. Therefore, it would comply with the Open/Closed principle.

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi & Linux, and soon about Mac, DevOps, development, and all the things you and I want to learn.

I’m looking for a job, so visit my LinkedIn profile here! Thank you!

In the noble art of coding, you should remember the SOLID principles always. Here is a brief explanation of each principle:

· Single Responsibility Principle: A class should have only one reason to change.
· Open/Closed Principle: A class should be open for extension but closed for modification.
· Liskov Substitution Principle: You should be able to use any subclass in place of its parent class.
· Interface Segregation Principle: A class should not be forced to implement an interface it doesn’t use.
· Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Today, we are going to focus on the Single Responsibility Principle.

Here you have an example of PHP about it:

class Order
{
    private $items = [];

    public function addItem($item)
    {
        $this->items[] = $item;
    }

    public function calculateTotal()
    {
        $total = 0;
        foreach ($this->items as $item) {
            $total += $item->getPrice();
        }
        return $total;
    }
}

class Item
{
    private $name;
    private $price;

    public function __construct($name, $price)
    {
        $this->name = $name;
        $this->price = $price;
    }

    public function getPrice()
    {
        return $this->price;
    }
}

$item1 = new Item('Taco', 2.99);
$item2 = new Item('Burrito', 4.99);

$order = new Order();
$order->addItem($item1);
$order->addItem($item2);

$total = $order->calculateTotal();
echo "Total: $" . $total; // Total: $7.98

The Single Responsibility Principle (SRP) states that a class must have only one reason to change. This means that a class must have only one responsibility and must have no more than one reason to be modified.

In the code above, we can identify two classes: Order and Item. These classes follow the principle of single responsibility, as each has a single responsibility and has no more than one reason to change.

The Order class is responsible for representing an order and performing operations related to it, such as adding elements to the order calculating the total, and handling the logic of the order.

The Item class represents an item and provides methods for obtaining its price. It has the responsibility to represent an article and provide information about it.

As we can see, each class has a unique responsibility and there is no mix of features in any of them.

This is beneficial because if in the future we need to make changes in the logic of the order, we just need to modify the Order class. Similarly, if we need to make changes in the representation or behavior of an article, we just need to modify the Item class. This facilitates code maintenance and reduces the risk of errors when making changes.

I hope this example helps you to understand the principle of single responsibility and how to apply it in your code. 🙂

This article was published for the first time on the blog misapuntesde.com, where you can read news/tutorials about Raspberry Pi & Linux, and soon about Mac, DevOps, development, and all the things you and I want to learn.

I’m looking for a job, so visit my LinkedIn profile here! Thank you!