• UUID1 vs UUID4 🔑

    In many of the applications we build today, there is often a need to have a unique identifier for any piece of data we use in our application. The universally unique identifier, or UUID, was designed to provide a consistent format for any ID we use for our data. Another problem UUIDs were here to solve, was to not give a potential adversary any information about the data it represented.

    As it turns out, making something unique and untraceable is not as straightforward as it seems. I mean, how do you ensure that there is just one copy of the identifier you made, and no more? And even then, how do you make sure that there is no correlation between any two identifiers?

    The answer is, you can’t do both. This is a tradeoff between uniqueness and randomness that is represented by v1 and v4 of UUID generators.


  • How to make a responsive telegram bot 🔩

    This tutorial will go through a straightforward set of steps to get a responsive telegram bot up and running from scratch


    I spent a considerable amount of time figuring out how to make a functional telegram bot. I mean sure, the official introduction is good, but theres a lot of stuff about what bots are, and a few scattered instructions about the API, but not enough of structure for a beginner to get up and running quickly.

    So, heres how to make a responsive telegram bot with the least amount of hassle :


  • We should use emojis more 😇

    Emojis have finally become mainstream! Yet, their use is restricted to only IM chats and Facebook status updates. For some reason emojis are not considered serious enough to be used in work related emails, blog posts, or printed media (There are exceptions to this of course, but thats the thing; they are exceptions).

    This reputation has stemmed from the good old days of text-smileys – you know : :-) :-( :[email protected] ;) :’( , and for good reason. text-smileys often mixed in with the actual text of the content and so it made it very difficult to read large blocks of text with stuff like ;-) scattered throughout. Emojis are different. Emojis stand out✨. This is important, because anything that stands out in a piece of text tends to catch the readers attention first. Whenever you quickly skim through a long article, what catches your eye first? It’s the images and diagrams you look at that gives you a general feel for what the article stands for. Emojis now give you this power of emphasis at the sentence level 💪.


  • An incremental tutorial on promises in javascript 🐾


    Promises are arguably one of the trickiest concepts to grasp in the javascript world, and even if you know how to use them, it’s difficult to explain how they actually work.
    This FAQ style tutorial is meant for both beginners and intermediates in the world of promises. If you’re a beginner and have trouble grasping what a promise even is, then go on ahead and start from the first question. If you know a little about promises, jump through the questions until you find one on interest (the sections in this tutorial are of increasing complexity as you go further)


  • A beginners guide to SQL 🐘

    Is it “SELECT * WHERE a=b FROM c” or “SELECT WHERE a=b FROM c ON *” ?

    If you’re anything like me, SQL is one of those things that may look easy at first (it reads just like regular english!), but for some reason you can’t help but google the correct syntax for every silly query.
    Then, you get to joins, aggregation, and subqueries and everything you read just seems like gibberish. Something like this :

    SELECT members.firstname || ' ' || members.lastname
    AS "Full Name"
    FROM borrowings
    JOIN members
    ON members.memberid=borrowings.memberid
    JOIN books
    ON books.bookid=borrowings.bookid
    WHERE borrowings.bookid IN (SELECT bookid
      FROM books
      WHERE stock>(SELECT avg(stock)
        FROM books))
    GROUP BY members.firstname, members.lastname;

    Yikes! This would scare any new comer, or even an intermediate developer looking at SQL for the first time. It shouldn’t have to be like this.

    It’s always easy to remember something which is intuitive, and through this guide, I hope to ease the barrier of entry for SQL newbies, and even for people who have worked with SQL, but want a fresh perspective.


  • Creating a MongoDB replica set using Docker 🍃

    architecture diagram

    Replication is a technique used my MongoDB to ensure that your data is always backed up for safe keeping, in case one of your database servers decide to crash, shut down or turn into Ultron. Even though replication as a concept sounds easy, it’s quite daunting for newcomers to set up their own replica sets, much less containerize them.
    This tutorial is a beginner friendly way to set up your own MongoDB replica sets using docker.


  • What snapchat did right 👻


    Snapchat has taken the world by storm. It started out as a platform to send short temporary photos or videos to your friends, and slowly evolved into a platform for sharing snapshots of your life with everyone, and to view snapshots of your friends lives, and also the lives of other people around the world (through events).

    As of this writing, Snapchat’s valuation is at a whopping $16 billion. The weird thing is, there is nothing unique you can do on snapchat that you can’t do on facebook, google+ (lol), or instagram. There must be something that attracts so many users to snapchat, and it can’t all be just about the short-term nature of the content you upload.


  • A simplified approach to calling APIs with redux ⏬

    Redux has taken the web development by storm, and after the success of react and flux, it has made the flux philosophy more accessible through its simplified approach. Although, something has always bothered me about redux :

    Why is it so complicated to call APIs?!

    The async actions tutorial given in the documentation is no doubt a scalable approach to handling these kind of situations, but it’s not very simple, and you would need to go over it a couple of times before you get used to the idea. Sometimes, we need a simpler method for addressing API calls in apps that are not-so-complex.

    This post will go through an alternative design pattern, to make async actions and API calls easier for smaller apps (and perhaps for larger ones as well), while respecting the three principles of redux and one way data flow.


subscribe via RSS