Forem: Abdelrahman Dwedar

Bloom Filters Applied In Real-Life Application - Laravel Prototype

Abdelrahman Dwedar — Thu, 20 Mar 2025 06:59:54 +0000

The Problem

When we have something frequent and at the same time intensive it's just one of the biggest challenges we might face.

A good example of that is something like uniqueness validation; we need to add a new email to the database but to do that we need to check for every single email that's already in the database.
And that's the intensiveness of it. We perform a full table scan --or in the best case index-- so we make sure that this table doesn't have a single instance of that email.

Take a case where you have millions of users in your table of users, and you need to make sure that the email is unique for each user who logs in. The validation will indeed take so long, and the user will be bothered.
Not to mention the amount of risk you put on the database doing that huge scan on a huge amount of data on a simple task as validation.

Taking our example of around 10 million users, we'll need ~10-60 seconds without indexing.
While maybe with indexing it might take a few seconds.

These numbers are not solid, just for referencing how much it might take.

Being in the industry for a while you'll know --from the get-go--, that having less query on the database is always better.
That is why we started Caching Layer like Redis (which will also be used in this blog). And search engine tools like Elastic search. And relying on message brokers like RabbitMQ for keeping a queue.

Using other tools to minimize the need to do queries is something we often do in software engineering generally, and this case is no different.
The best solution for such a case is Bloom Filters, which I'll explain in detail in the next section.

Solution: Bloom Filters

Taking about Bloom Filters we need to understand that it's not actually just a tool. It is really a data structure that is great for such cases as the one we are talking about here.

General Principle

Bloom Filter consists of these two main components:

bit array
multiple hash functions

What we do is that when some new item is inserted we use each of the hash functions on it, and they have to give us an index on the bit array to set as 1. And when we apply all the hash functions we fill the bit array in certain places which will all be 1 if we checked with the same hash functions.

So When we get some new insert after that we use the hash functions on them again and if all the indexes that the hash functions were already filled with 1 in the bit array that means that this new item "might be inserted before" (will elaborate this later).

Example

Let's take our email case as an example of that.

When we insert a new email (for example "abdelrahman.dwedar.7350@gmail.com") we start by running the hash functions on it and let's just for simplicity imagine that the results were: 7, 1, 5.

So our bit array will now look like this:

[0, 1, 0, 0, 0, 1, 0, 1, 0, 0]

Notice that we have 1 in the indexes resulting from the hash functions.

If we now try to reinsert "abdelrahman.dwedar.7350@gmail.com" again we'll have all of them as 1 already so we suspect that it might have been inserted before.

False-positive nature of bloom filters

Bloom filters are a false-positive data structure, when the case is false it is indeed a solid false. Yet If it's true it might be action false.

How does that happen exactly?

Let's have an example on the same bit array with the indexes 7, 1, and 5 being filled. You might be inserting "new_email@gmail.com" yet your hash functions resulted also 7, 1, 5 which means it's filled in the bit array, which means that it might be inserted, so you'll now need to do a full scan.

Yet the good part is that we're sure in case they were not all filled that the new item was never inserted before.

Why use it?

As bloom filters use a bit array and very fast hashing functions like FNV or Murmur, that results us a very fast check if it was inserted before with a false-positive result.

Using bloom filters makes you make full scan much less, as whenever it gives you false you're 100% assured that it was not added the the database before.

I recommend you read more about bloom filters to gain a better understanding of it, so I added a few valuable resources I used in the references.

Bloom Filters: Redis Implementation

Redis Implementation

Redis is key-value data store. Most used as a cache layer, it stores the data in-memory which makes it faster to reach any time. And its nature as a key-value data store which is similar to hash maps it has great both read & write speed.

I'll be using Redis for that. Redis by default doesn't have implementation for bloom filters, yet you can have it by adding the Redis Probabilistic Data Structures Module to Redis, or using the redis-stack docker image. (In my prototype I used the docker image).

Using Redis will take the overhead of making the bloom filter from scratch in our application, and also helps with auto-scaling (which is out of the scope of this article) for later.

Redis Commands

If you ever used Redis before you'll know that we use commands like APPEND {key} {value}.

We have some commands for Bloom filters in Redis as well, all of them start with BF.
I won't be mentioning every single one of them, but I'll tell you the most important ones.

BF.RESERVE {key} {error_rate} {capacity} [EXPANSION expansion]: Creates an empty Bloom filter with a single sub-filter for the initial specified capacity and with an upper bound error_rate.
BF.ADD {key} {item}: Adds an item to a Bloom filter.
BF.INSERT {key} ITEMS {item} [item...]: Creates a new Bloom filter if the key does not exist using the specified error rate, capacity, and expansion, then adds all specified items to the Bloom Filter. (accepts at least one item)
BF.EXISTS {key} {item}: Determines whether a given item was added to a Bloom filter.

I think by just the naming you can understand how it works. We'll use BF.RESERVE to create a new Bloom filter, and then we use BF.ADD or BF.INSERT to add new items to it (and the hash function will run internally). Whenever we want to make a check if an item exists in the Bloom filter we use BF.EXISTS (which also runs the hash functions internally).

Simply like that we now have a ready-to-go Bloom filter for a high-scale application also powered by the auto-scaling features of Redis.

Laravel Custom Validation Rules

What are Laravel validation rules?

To give a more real-life example we need an application, and in the application layer I'd use Laravel, in Laravel we can have validation rules, like the following:

<?php

$validated = $request->validate([
    'title' => 'required|unique:posts|max:255',
    'body' => 'required',
]);

In this example, we have title and body as the fields of the request, and the validation rules applied are required, unique, and max.

To make it simple:

required: as its name indicates; it makes a field required and if not added it gives you an error
unique: you have to add a unique field, and the name after : is the name of the table it checks the uniqueness on
max: check for the max character length in our case

The used rules are default ones that come from Laravel itself. You can learn more about them in the documentation.

Making a Custom Validation Rule

Laravel also gives you the flexibility to add custom rules as you wish.

In our case, the unique validation rule is not enough, as it goes directly to the database and makes a full table scan.

We need something custom for that.
By following the documentation for making custom validation rules, we can create a new rule by running this command:

php artisan make:rule BloomUnique

Then we have a template for the new rule.
After I made the changes by using Redis with the BF.EXISTS this is the final code:

<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Support\Facades\Redis;
use App\Models\User;

class BloomUnique implements ValidationRule
{
    protected $filterName;

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

    /**
     * Run the validation rule.
     *
     * @param  \Closure(string): \Illuminate\Translation\PotentiallyTranslatedString  $fail
     */
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (Redis::executeRaw(['BF.EXISTS', $this->filterName, $value])) {
            // Check database only if Bloom filter indicates possible existence
            if (User::where($this->filterName, $value)->exists()) {
                $fail('The :attribute has already been taken.');
            }
        }
    }
}

I use the Redis class to execute the BF.EXISTS command on the filterName added to the request. Yet we're not done, if it exists in the Bloom filter that doesn't mean it's for sure there, we still need to make a table scan to check if it's actually in the database.

Yet in case we didn't find it in the Bloom filter at all, we are sure it was never inserted before.

We use the $fail function to indicate that it's not passing, and we add the error message as a parameter.

Prototype

Explained

I have made a prototype for this using Laravel and Redis. I also used Docker to run them.

I made the case where we just use the default unique validation rule.
Then I made the case where we used the custom rule BloomUnique.

Each case is in a separate Git branch, the case with normal unique is in the branch named without-bloom-filters, and the other case with the custom rule is in the branch named with-bloom-filers.

I also added seeders using Laravel built-in seeder to add testing data.

How to run?

Clone the Repository

git clone https://github.com/AbdelrahmanDwedar/bloom-filters-validation-laravel-prototype.git
cd laravel-bloom-validation

Setup Sail (For using docker)

composer require laravel/sail --dev
php artisan sail:install

Setup the environment

cp .env.example .env
./vendor/bin/sail artisan key:generate

Then add the configuration for the database

DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=laravel

Also, add the configuration for Redis

REDIS_HOST=redis
REDIS_PASSWORD=null
REDIS_PORT=6379

Start the docker containers, and install dependencies

./vendor/bin/sail up -d
./vendor/bin/sail composer install

Use the custom-made commands to prepare the setup

./vendor/bin/sail artisan benchmark:prepare
./vendor/bin/sail artisan benchmark:perform

These are two custom commands I made for this prototype, the first one benchmark:prepare task is:

migrations with a fresh database
run the seeder

And for the benchmark:perform task is to

run the benchmarks
display them in a table in the terminal

Conclusion

Bloom filters is a great tool we might use to solve the issue of having to always make full-table scans in cases of checking if some field exists in the database.
We can use it in real-life scenarios by leveraging Redis implementation in it, which I personally admire.

This prototype is just to show how it might be used in some real-life scenarios using the Laravel application, we leveraged adding custom rules in Laravel for better code readability and separation of concerns.

I have added some resources you can learn more from in the references below if you need more information about it.

References

The Actual Difference Between Lambda and Regular Functions (Using PHP)

Abdelrahman Dwedar — Wed, 29 Jan 2025 15:19:37 +0000

The Problem Of Function Context

When we pass a function as a parameter or something like that, and we want to use some variables from outside of the function we need to use the use keyword.

This can be found in Laravel or Lumen in the group routing.

Notice how using the use keyword is necessary here:

$router->group(['prefix' => 'admin'], function() use ($router) {
    $router->get('users', function() {
        // Matches the "/admin/users" URL
    });
});

The code above is from the docs of Lumen, if we would rewrite that code using the lambda functions (arrow functions) here it will have all the other variables outside of the function available in it.

Rewrite With Lambda Functions

Notice how we didn't need to have the use keyword here and it's much cleaner.

$router->group(['prefix' => 'admin'], fn() => (
    $router->get('users', fn() => (
        // Matches the "/admin/users" URL
    ));
));

That's one of the most important parts of lambda functions, and it is what makes them able to create closures (closures are beyond the scope of this article) and many other functional concepts.

Some Other Cases

In some other languages, there's no use keyword and functions don't have any knowledge about the context around it.

In that case, how would you have similar behavior?

You'll need to pass them as parameters each time, and we don't want that indeed.

The Effect Of Communities On Us

Abdelrahman Dwedar — Thu, 29 Jun 2023 18:57:45 +0000

In this article, I'm going to talk about communities, their good, bad, and ugly. Having a look at how communities have an effect on us, and if that effect is indeed good or not.

Disclaimer: I'm not trying to attach any particular community, simply trying to open some eyes to how communities have an effect on us, and how to avoid some of the bad effects and the signs to get away from some community for your own good.

Let me first ask you to not take my word on any of the topics and check yourself on these things, measure how much you get and not from any community and see if you need that community at that time.

How do communities work?

This sounds like a weird question, you'll probably say something like that:

It's a group of people that have similar interests so they gathered together.

And you're right, but there's more to it, we as humans like to feel a sense of belonging, our interest is someone else's as well, so that gives us some sense of happiness, mostly caused by some feeling of acceptance.

Then the community will empower you for doing things. That thing can be sometimes beneficial but can be not, depending on a lot of factors we'll discuss later on.

Also keeping in mind that we're actually affected by everything we consume, whatever we listen to, read, or discuss, will indeed have some effect on us and how we think about things, so being in a community (mostly talking the same opinions and same ideologies) will indeed make you have a similar mindset and believe in the same things, whether it was right or wrong.

Whenever we consume something our brains store it and keep processing it (please research that yourself, I'm not well informed about how that works exactly, so it'll be better to check for yourself).

The good in communities

I'm going to mention some of the benefits of communities, but I assume that you already know most of them, so I don't need to go through it that deeply, so I'll add them and have more focus on the bad sides since we all can see the benefits but the disadvantage aren't discussed often.

Empowerment

Communities are great at making us feel better and cheering us to achieve more and more. Whenever you feel down while doing things the community will help you feel better and keep going and take good care of you.

It's also beneficial on a financial side, they'll help you share your ideas and projects and get more eyes on it.

Generally, Empowerment culture is a norm in most communities which is great!

Help!!

Say you're stuck on some problem, usually, the community can help you find the solution or even give you the solution.

That can be more appealing in open-source, while you're making some project people in the community might help you find bugs through issues, and help you make newer functionalities through pull requests. That's an amazing advantage you get from being in a community, you'll get that kind of help which helps you learn new things and understand problems.

That could also appeal to the amount of libraries, frameworks, and modules, the bigger the community the more libraries and modules will be made and published to help you improve your work.

Resources

The community can provide a lot of resources for us to learn from blogs, podcasts, books, tips, videos, courses, etc...

This is a very important benefit of communities, they give you those resources and also share them as well.

I don't have much more to say about resources between communities as it's already very appealing to anyone.

The bad in communities

In this section I'm going to focus a little more than the last, it's more important for me to show the bad in communities so you can think about it and evaluate it for yourself and maybe avoid the bad things. Please have some sense of sportsmanship while reading and think about these topics and compare them to reality.

I'm going to also give some examples without saying the community that has that mindset, I'll mention some tools as well as examples.

Mind Jail

When you're in a community, you aren't with everyone, you're just with the people in that community with the same thoughts, that is what brought you together from the beginning. You'll be somehow jailed in the ideas and thoughts of that particular community.

These ideas could be wrong, and they might have some ideologies within them. An example: "Use a single programming language for everything", is a popular one, thinking that everything is going to be much easier if you just used a single language, while that's not necessarily true.

This is going to give you a pause in your growth as you'll just keep up with a single thing, whether that's a framework, library, language, etc...

Being so attached to some tool is the worst thing you could do to yourself in software development, our profession continuously changes, and it never stops changing, the tools will be continuously changing over time, and you need to learn something to use not to be attached to it.

This is limiting for your mind and thinking process, you'll have only one perspective of things - which is the perspective of the community - which is very unhelpful for you and how you think about things, especially if the community is closed to any other ideas and not welcoming any new perspectives.

TRENDS

Are trends even helpful?

Could be. But not in most cases especially when you have a closed perspective community (as mentioned in the last section).

Trends are when something is popular among the people of some community, and that's common between communities, this framework is trending and that library is the current thing.

Trends are just useless in most cases, could be beneficial if it's just introducing something new so people can try it and that thing doesn't get hyped, and can be very misleading for a lot of people - especially beginners - as it sounds like something that might be important to know in a lot of cases, while it's a waste of time (This is discussed more in the FOMO section).

Sometimes that trend might be over some new tool, or new technology, or even over something that was there for years but now it's being hyped.

If you remember in the year 2022 a very big part of the tech community was all about Web3 and crypto, everybody was talking about it and starting some startups and publishing things about it and having talks about it. And in the current year (2023) it's all about AI all of a sudden, with the same things, talks, people talking, startups, etc...

As you might already notice as well it's just repeating itself over and over again, that's just how trends work, if you were involved in that you probably have tried to do things about it, have some talks learn some things here and there (even though that wasn't your initial interest but just because people are talking about it). And all the sudden it changes and no one is interested in it anymore, you'll be frustrated, and might feel so bad about it that it's going to stop you instead of pushing you.

I see trends as some kind of poison for our minds that we consume from the media, it's frustrating to keep up with them and not that beneficial after all. You'll be much happier without trends around you all the time, it's important to not let that control your mind.

Trends can be also about some technology or even solutions, some people in the back-end communities keep talking about some solutions (just giving an example: sharding) and technologies, which mostly have an unneeded cost and complexity and are often considered as over-engineering.

I try to stay away from trends, as they don't help me but rather the very bad impact they leave on me and my work.

FOMO

FOMO (Fear Of Missing Out), it's when there's something that a lot of people are talking about and might be involved in, to a level where you feel like you're missing out on something and that thing might be important and beneficial to you. It's so attached to the trends section, and often trends are what causes FOMO.

This appeals very well when we say to ourselves these words:

This technology might be actually the future of software, I have to learn that to just keep up and not lose my job or be outdated, I have to use it and get into it.

Mostly these thoughts are wrong, most tools rarely ever die, and even if they died as a developer you should be able to move to any other tool easily. It's important to understand that our job is more about solving problems and making new features than changing stacks, or even goals.

We end up moving from one tool to another for no reason but because we're afraid of missing out on something new and better than what we used to use. You can mostly use any tool to achieve what you want, and the fear of missing out you have is just lying to you that you couldn't cope with the new tools faster without taking that much time. Or that you wouldn't find a job with your stack or tools, as I said you should be as a developer able to change the tools pretty easily if you understand the fundamentals well (also worth mentioning that most tools will get you a job and rarely you wouldn't find any jobs at all for tools).

In most cases, communities are the main source of these concerns, with the trends and the new tools that the community talks about all the time, it turns out to be very frustrating to cope with them.

Conclusion

Communities are not all evil and indeed are not all good. We have to be careful what to pick from the communities and what to leave, and not get too attached to some thoughts that communities carry along. You also need to choose who to follow and who to not, as we (as humans) process everything that enters our minds and can be influenced by what others say.

Consider checking out different perspectives to see any topic from different angles which is very helpful, and try to use different tooling other than what the community says, check things that are liked, and some of what is hated, see yourself and never rely on any other person's thoughts to decide for you want to use, use what's needed not what's liked/loved by some community. Lead yourself, and never follow.

In summary; communities can help you in a lot of things like empowering you and pushing you towards working harder and smarter and giving you that cheering you might need sometimes, helping you with problems you face and helping you find good resources or even publishing your work for a larger audience. But also it has a lot of things we should be careful of falling into like filling your mind with their thoughts and only their thoughts and putting you in what I call a "mind jail", or pulling you into trends which don't help you improve and sometimes (often) really harmful for your mental health (I sometimes say that trends are the poison for our mental health), or even give you FOMO and make you learn things you don't need and waste a big part of your time or even ruin your learning if you're not very organized with what you should learn and what not.

A lot of these issues aren't just related to our profession (software development) but it's universal issues in most communities. Feel Free to share your thoughts and experiences as well as to share knowledge.

Resources

For further information about the community and its effects on humans generally, there are a few researches if you're interested (notice that not all of them actually focus on the programmer's side it's general for humankind, and it's mostly from a Psychological point of view).

JavaScript Struggles - Part 7 | functions

Abdelrahman Dwedar — Sat, 25 Feb 2023 16:46:13 +0000

Function in JavaScript just like most other languages is here to write less code and eliminate duplication. When we use a function it has to do something that's repeated and we wanted to isolate that piece of code.

In this article, I'll be explaining how functions work in JavaScript, and I'll explain as well the new ES6 arrow functions that everybody uses and tell you when is it great and when it makes nonsense to use.

Let's start!!

Writing Functions In JavaScript

In JavaScript, we use the keyword function to make a new function (yes we write the whole word function).

As I mentioned earlier in the past articles about variables we need some keywords (like var, let or const) to define that this is a variable and its type which var make it a global variable.

While in the function when we want to create an argument that we can use it within the function we DO NOT use any keyword, we just add the name of the argument.

function greetUser(username) {
    console.log(`Hello there, ${username}`);
}

How Do Functions Work Behind The Scenes

Since JavaScript is an interpreted language, it has to run things step by step.

It's also worth mentioning that JavaScript also uses a garbage collector just in time running, so the functions are read every time you use them anywhere else again and again.

How does it work exactly? Let's say we have this piece of code:

let user = {
    firstName: "Abdelrahman",
    lastName: "Dwedar",
    age: 17
}

function printUserInfo(user) {
    user.age++;
    console.log(`This user name is ${user.firstName} ${user.lastName}, and they are ${user.age} years old.`);
}

printUserInfo(user);

As you might understand from the graph functions have their own process, something else you might have to understand is that they also have their own variable declaration process. So every variable that's defined within the function will just get defined after calling that function even if it was a global variable (using the var keyword).

Notice that I didn't mention the declaration of the function itself in the main process, as functions aren't as variables, variables have to be declared before using them, while functions can be declared after calling them the interpreter will find the function declaration and run it (Unlike what's happening is a language like C where a function has to be declared before it's called).

What Are Arrow Functions?

We can think of arrow functions as a smaller version of functions. It's a function that uses a new syntax that was introduced by ES6. It's mostly used for simple events that don't deserve their function, and it is worth mentioning that it's returning by default, so you don't need to return the value by the keyword return.

Also, you can't use the this keyword within any arrow function. Which can be bad in some cases (thinking of the Vue2 example that will be mentioned later in this article)

Syntax:

(num) => {return num1 < 100}; // You can use it like this

(num) => {num1 < 100}; // you don't need to have the return

(num) => num1 < 100; // if it's just one action there's no need for the brances

example:

let firstNumber = 10;
let secondNumber = 29;

function lessOrMoreThan50(num) {
    console.log(num < 50);
}

lessOrMoreThan50((firstNumber, secondNumber) => Math.abs(firstNumber - secondNumber));

As you see we used the arrow function as an argument of the lessOrMoreThan50 function (this is just an example to show the case of using the arrow function).

Its best use-case is getting some event done to be passed directly to something else like a function or even a loop.

You can also store the arrow function in a variable like so:

const numbersList = [1, 4, 5, 22, 31, 11, 23];

const oddNumbersInList = (numbersList) => {
    oddNumbersList = [];
    for (let num in numbersList) {
        if ((num % 2) === 1) {
            oddNumbersList.append(num);
        }
    }

    return oddNumbersList;
}

oddNumbersInList(numbersList);

Difference Between Normal & Arrow Functions

I'll start by saying that I prefer using normal functions in most cases, and I'll explain why I like it more, and I'll also add some of the main differences between the two methods.

The Appear Of The Function

For me and a lot of developers, we find ourselves seeing the normal function as a function, while just seeing the arrow function used as a function instead makes it sound weird, it's more obvious for the eye when seeing the function the keyword that the following is a function that can be called somewhere else.

So when I see a normal function I know it's going to be used somewhere else, unlike when I see a variable containing an arrow function, it sounds more like a variable by just seeing the var, let, and const keywords.

function buildArch1() {
    ...
}

const buildArch2 = () => {
    ...
}

Also seeing the last code example above, you can see that the arrow function is more to type compared to the normal function.

Also if you tried to type it yourself you'll find yourself getting your fingers away from the home raw more in the arrow function.

Where It Can Be Called

The last section might be considered a personal preference. But this one is different, as it's part of the placing of your code.

When we make an arrow function and store it in a variable it's treated as a variable mainly.

Putting the explanation of the function process and the knowledge you know generally about variables (they have to be declared before being called).

You have to declare the arrow function before it's called! You can't have the callee function after the caller function (which is the considered practice for clean code).

Let's have some code examples.

// this code will work 
function createNewProfile(user, username, age) {
    user.name = username;
    user.age = age;
    createId(username); // This will work
}

function createId(username) {
    ...
}

// this will now work
const createNewProfile = (user, username, age) => {
    user.name = username;
    user.age = age;
    createId(username); // This will give you an error
}

const createId = (username) => {
    ...
}

Notice that the one that didn't work is the one using the arrow function, the reason for that is that the arrow function is treated as a variable, so it must be declared before it's used even in another function. Unlike normal functions which get declared when it's called like it was explained in the functions process section above.

Usage within an object

One of the most used data patterns in ES6 is the object, you can find that it was the main build block of the Vue2 and we were using it in different ways to get things done.

example from the Vue document:

<script>
export default {
    methods: {
        increment() {
            this.count++;
        }
    }
}
</script>

In the document, they mentioned that you can't use the this keyword in any arrow function which made them recommend using the above syntax.

There's also another unpopular way of doing the same thing:

<script>
export default {
    methods: {
        increment: function() {
            this.count++;
        }
    }
}
</script>

Just seeing this makes you prefer the first one, but both of them are the same.

while the arrow functions will look like this (it will NOT work):

<script>
export default {
    methods: {
        increment: () => {
            this.count++; // This will not work as the this keyword doesn't work in arrow functions
        }
    }
}
</script>

Conclusion

I talked a bit deeper this time, as functions aren't just some random thing, it's an important concept in programming that has a lot to it, especially in languages like JavaScript.

If you didn't understand any part (and that's fine) you can contact me through Twitter and I'll try to give you simpler examples or give you some ideas to try yourself.

This article focused on the functions area in JavaScript, but a lot of these concepts apply to a lot of other languages.

It's also important to note that I'm not telling anyone to just use normal functions, I like arrow functions and we need them, but only using them because other developers do is no good. Understand then decide if you need it or not. I suggest using arrow functions where it's simple action or an action that doesn't need to be separated from the rest or it'll be incomplete if it was separated.

I hope you enjoyed the article and got something out of it, till the next time! ;)

JavaScript struggles - part 6 | truthy & falsy values

Abdelrahman Dwedar — Thu, 21 Jul 2022 19:10:00 +0000

When we use most of programming languages or scripting languages we have some values that isn't a boolean valaue but it works as so.

We mostly call it truthy & falsy values.

Content table

Truthy values
falsy

Truthy Values

Personally I like to think of truthy values as a variable that have an actual value in it.

Sort of messy?
Think of it like that:

A value that isn't empty is a valuable value, but when it's empty it's not.

Let's see some examples

We'll use the `!!` keyword to turn the value into boolean value t check what is the output.

String

console.log(!!"Hello"); // true

let text = "Hi there";
console.log(!!text); // true

Number

console.log(!!18); // true

let num = 88;
console.log(!!num);

Other

Any object ({}) or Array ([]) are truthy values, even if they were empty!!
So be aware if you want to use an object or array for storing, you have to get the values inside of the array or object.

Falsy Values

A falsy value is the opposite of the truthy values.

String

console.log(!!""); // false

Number

console.log(!!0); // false

console.log(!!NaN); // false

To know more about NaN check out the article about numbers

Other

The null object is also falsy value.

console.log(!!null); // false

Use Cases

There's of cause some amazing use cases of knowing this, you can stop a process if the value wasn't a number like so, as if you turned a text into number it turn into NaN and it's a falsy value.

if (inputValue) {
  ... // Actions
}

Thanks for reading I hope you gain new things out of this article 😄

JavaScript Struggles - Part 5 | Data Types

Abdelrahman Dwedar — Wed, 29 Jun 2022 10:11:51 +0000

Hey there! 👋🏻
We're now going to explain the data types of JavaScript, I'm only going to talk this time about the data types itself, ⚠️ I'm not going to explain the (truthy & false) subject now ⚠️.

This's just a basic view of the data types of JavaScript.

Data types:-

Undefined
Null
Number
String
NaN

Undefined

Undefined is actually a data type in JavaScript.
Even though that is weird, but you'll get used to it.

it's the default data type if you didn't assign anything in the variable.

var varName; 

console.log(typeof varName); // outputs: undefined

Null

Null is a data type that have to be assigned.
The best use of it is to find the undefined variables.

Also important to know that null is an object so whenever you want to check the data type of a variable that contains a null it'll return "object".

var nullVariable = null;
var nothingHere;

console.log(nullVariable == nothingHere); // that will output true

But the confusing sometimes, but no worries I covered it already on a previous post

Number

The data type number is so familiar for most developers, it have a number. :)

Simple right?

But sometimes JavaScript has to be JAVASCRIPT, and add some weird things around it.
It's considered bad at math, or to be more specific; it's actually bad at float-point

Which I'll cover in upcoming post, so stay tuned.

String

String is actually so simple.

It's just like the string of any other language but with some features.

There's 3 ways of using string in JavaScript:

Single quote 'string'
Double quote "string"
And the backticks

Single quote `'string'`

The single quotes is used just as the normal string.

let stringVar = 'Hello world!';

Double quote `"string"`

This is the normal string itself!!
I think it doesn't need an explanation.

Backticks

What is even backticks?
It's the string that uses ` instead of " or '

It's actually the best practice in my opinion for JavaScript at it provides the furmated string feature with it as you use it, also enables using multiple lines (it doesn't apply on web as you need to use <br />).

let furmattedString = `the answer is ${5 + 5}`;

console.log(furmattedString); // the answer is 10

let multilineString = `Hello there!
I'm Abdelrahman!`;
console.log(multilineString);
/*
Hello there!
I'm Abdelrahman!
*/

NaN

I've already explained NaN in previous post
So let me be the lazy developer I am and not repeat that again 🥱

That's all for now! I hope you gain anything new from this post. 😄

JavaScript Struggles - Part 4 | Comparing

Abdelrahman Dwedar — Sun, 28 Nov 2021 07:39:32 +0000

Here we go again!

This one is very easy but we all have to know it, you may already heard about it somewhere else too.
If you weren't familiar with JS's comparing way keep going. If you're then this post is not for you. 😊👏🏻

There's two ways of comparing variables in JavaScript:

Two Equal Signs (==)
Three Equal Signs (===)

Two Equal Signs (==)

Most majority of programming languages uses == as the one and only comparing operator, but in JavaScript we're special. 😏

== is only comparing the value of the variable, ignoring the data type of it; so if there's a number that is equal to a number inside the string it'll always be true.

E.g.

console.log('0' == 0); // Outputs: true

console.log(1 == true); // Outputs: true

The data type of the variable will not be changed after the comparison

Some of Its Uses
We can use it to check if the number is not 0 or an empty string.

let num = 0;
let word = "";

console.log(num == true); // Outputs: false
console.log(word == true); // Outputs: false

num = 5;
word = "Hey!";

console.log(num == true); // Outputs: true
console.log(word == true); // Outputs: true

Three Equal Signs (===)

We use this as the normal comparing operator, that's only working with JavaScript, TypeScript, PHP.

What === actually does is that it compares the value and the data type.

E.g.

console.log("0" === 0); // Outputs: false

/* They must be of the same data type. */
console.log("0" === "0"); // Outputs: true

=== is the most used one. Probably because it's the easy way of conparing and we all understand it even if JavaScript wasn't your first language.

Thanks for reading! 😌

I hope this may be helpful for someone.

JavaScript Struggles - Part 3 | String Auto Converting

Abdelrahman Dwedar — Fri, 19 Nov 2021 16:00:28 +0000

One of the weirdest things that JS do is converting string variable to numbers by itself.

When does it convert string to number?

We have 4 operators that can turn the string to number when the string value is numbers:

Plus (+)
Minus (-)
Multiply (*)
Divide (/)

Plus (+)

In JavaScript the plus operator have two cases.

1- When you use the + with a string that only have numbers it'll be converted automatically to number.

console.log('1'+'2'); // Outputs: 3

2- When you use the + with a string that contains text, it'll not be converted to number; it'll be added to the text.

console.log("Hey"+"There"); // Outputs: HeyThere

Minus (-)

Whenever we use - in our code the string automatically get converted to number.

E.g.

console.log('5' - 1); // Outputs: 4
console.log('5' - '2'); // Outputs: 3

Multiply (*)

Whenever we use * in our code the string automatically get converted to number.

console.log('5' * 3); // Outputs: 15
console.log('5' * '2'); // Outputs: 10

Divide (/)

Whenever we use / in our code the string automatically get converted to number.

console.log('6' / 2); // Outputs: 3
console.log('9' / '3'); // Outputs: 3

Thanks for reading! 😁

JavaScript Struggles - Part 2 | Numbers

Abdelrahman Dwedar — Sat, 30 Oct 2021 02:12:36 +0000

I personally didn't understand how do JS act with number, but after I learnt about it.

We have to understand what's the data types of JavaScript, and how to use them. Let me help you with it. 😄

In JS we have three data types for numbers: `Number`, `null`, `NaN`.

I'll explain each of them and give an example for each of them.

Number: The main Number data type.
null: intentional absence of any object value.
NaN: Not a Number.

Number

whether it's integer like: 1
or float like: 1.3

It is number, if there was a decimal number it'll add it, if not it'll sow up as normal integer.

console.log(5/2); // Outputs: 2.5
console.log(4/2); /// Outputs: 2

We usually use Number() to turn the variable to number.

NULL

Null basically is none. If you made undefended variable it'll equal null.

And it doesn't mean that it's an empty string or 0.

let nothing; // This variable is undefined.

console.log(null == nothing); // Outputs: true
console.log(null == 0); // Outputs: false
console.log(null == ""); // Outputs: false

That happens because `null` only equals the undefined variable. `null` and `undefined` are equal but not identical.

Null usage

We can use null data type as 0, since it's an object.
Let's try it:
the_number = null; 
the_number++; // Add 1 to the null variable

console.log(the_number); // Outputs: 1
So we can use null it instead of 0.

We can add that null is an object data type

NaN

NaN stands for Not a Number, and it appears if you you have a filled string and converted it to number.

let thing = "Something";

console.log(Number(thing)); // Outputs: NaN

But if you compared NaN with other NaN it'll return
false.

let thing = "Something";

console.log(Number(thing)); // NaN
console.log(Number(thing) == NaN); // false

How to fix this?

Use the isNaN() method instead.

let something = "Value";

console.log(isNaN(something)); // True
console.log(isNaN(Number(something))); // True

JavaScript Struggles - Part 1 | Defending Variables

Abdelrahman Dwedar — Wed, 27 Oct 2021 11:25:29 +0000

Defending variables in JS have its own way.

We have three ways to defend a variable let, var, const.

	Var	Let	Const
Changeable	✔	✔
Block Scope		✔	✔
Global Scope	✔
Make Arrays	✔	✔	✔

We mostly use let because of the block scope which I'll explain in the below. 👇🏻

Let

The keyword let makes a variable only useable within the scope it made in, you can't use it outside that scope.

E.g.

Var

The keyword var makes a global variable, you can use it everywhere in the code.

E.g.

Const

The keyword const makes an unchangeable variable, you can't change its value.

E.g.

What language do I start with? (personal opinion)

Abdelrahman Dwedar — Sat, 16 Oct 2021 19:51:12 +0000

How can we choose our first languages? 🤔

We have to take 5 main standards into account:

How easy it's
The big of their communities
The amount of free resources
The easy you can run the code (Their IDEs are easy)
The most in-demand

How easy it's

The starting language for you has to be easy or you might hate programming from the beginning, so you don't have to start with something like C++ or Java, it's not about how "cool" that language is, it's about how much you understand it and comfortable with it.

print("Easy")

console.log("Fast");

puts "and";

<?php
echo "smooth";

Start with easy programming languages like Python, JavaScript, Ruby, PHP.

The most important thing that you don't think that programming itself is easy, that may cause you to stop and get bored.

The big of their communities

Starting with a language that has a big community will make starting with it much easier.

You can start with something easy like PHP, Ruby, etc... but why do we start with Python & JS?
because they have a really big community that can help you whenever you're stuck. and you need that help while starting. BUT you can start with others too.

Programming Language Communities - An update

SlashData Team ・ Nov 10 '20

#programming #javascript #python #devrel

The amount of free resources

When you start learning to program the resources is the most important thing to think about, some languages don't have easy-to-get resources.

Some useful resources for beginners can be: W3Schools, SoloLearn, StackOverFlow, TutorialsPoint

Resources are very important especially if you're self-learning.

So find a programming language that has a lot of recourses

Pro-Tip: Reading the docs is very useful to understand any language, you'll find most of them in devdocs.io.

The easy you can run the code (Their IDEs are easy)

Running, debugging and testing is so important for any programmer\developer and you have to learn it, but if it isn't easy that'll take so much time of you just trying to run it while you can use other languages like Python or such and run it easily and that'll make you well progress in lesser time.

You can use Visual Studio or Visual Studio Code since it can run lots of languages and they're easy to use.

The most in-demand

The best language to start with is the one that you can work with once you finish learning it, or at least you have more years of experience since you started earlier, which indeed will increase your chance of finding a job.
So you have to choose a language you might start with after learning it, so you have to know what do most companies search for.

The Most In-Demand Programming Languages in 2021

Click on the picture to check the resource

This list is only for 2021, if you are reading this in like 2024, 2025, etc... the in-demand languages will be changed probably, so you have to Google it yourself 😄

Recommendations

You're not required to follow all the standards of this post, there are more important ones, so you have to just measure them, don't take it for granted. Good luck. 👍🏻

Keep in mind:

Keep in mind that depending on the field you'll work in, you have to choose your first language since some languages are better in fields that others aren't; such as JS or PHP to web development, C# or C++ to game development, Python to AI & Machine Learning etc...
Do not be intolerant of the language you will start with or force others to start with it as well.
Don't stop learning, and don't reject learning a new language for no reason.
When you learn your first language; focus more on learning the basics of programming itself, not just learning the language.
Thank you for reading 😊
I've love to hear what do you think about that topic in the discussion below.

Forem: Abdelrahman Dwedar

Bloom Filters Applied In Real-Life Application - Laravel Prototype

The Problem

Solution: Bloom Filters

General Principle

Example

False-positive nature of bloom filters

Why use it?

Bloom Filters: Redis Implementation

Redis Implementation

Redis Commands

Laravel Custom Validation Rules

What are Laravel validation rules?

Making a Custom Validation Rule

Prototype

Explained

How to run?

Clone the Repository

Setup Sail (For using docker)

Setup the environment

Start the docker containers, and install dependencies

Use the custom-made commands to prepare the setup

Conclusion

References

The Actual Difference Between Lambda and Regular Functions (Using PHP)

The Problem Of Function Context

Rewrite With Lambda Functions

Some Other Cases

The Effect Of Communities On Us

How do communities work?

The good in communities

Empowerment

Help!!

Resources

The bad in communities

Mind Jail

TRENDS

FOMO

Conclusion

Resources

JavaScript Struggles - Part 7 | functions

Writing Functions In JavaScript

How Do Functions Work Behind The Scenes

What Are Arrow Functions?

Difference Between Normal & Arrow Functions

The Appear Of The Function

Where It Can Be Called

Usage within an object

Conclusion

JavaScript struggles - part 6 | truthy & falsy values

Content table

Truthy Values

We'll use the !! keyword to turn the value into boolean value t check what is the output.

String

Number

Other

Falsy Values

String

Number

To know more about NaN check out the article about numbers

Other

Use Cases

Thanks for reading I hope you gain new things out of this article 😄

JavaScript Struggles - Part 5 | Data Types

Data types:-

Undefined

Null

Number

String

Single quote 'string'

Double quote "string"

Backticks

NaN

JavaScript Struggles - Part 4 | Comparing

Here we go again!

Two Equal Signs (==)

Three Equal Signs (===)

Thanks for reading! 😌 I hope this may be helpful for someone.

JavaScript Struggles - Part 3 | String Auto Converting

When does it convert string to number?

We'll use the `!!` keyword to turn the value into boolean value t check what is the output.

Single quote `'string'`

Double quote `"string"`

Thanks for reading! 😌

I hope this may be helpful for someone.

In JS we have three data types for numbers: `Number`, `null`, `NaN`.

That happens because `null` only equals the undefined variable. `null` and `undefined` are equal but not identical.

We can add that `null` is an object data type