Forem: Sadiqur Rahman

ACID and Transactions in SQL

Sadiqur Rahman — Thu, 12 Oct 2023 11:56:22 +0000

Relational databases rely on certain properties to ensure data reliability and trustworthiness. These properties, summarized by the acronym ACID, stand for Atomicity, Consistency, Isolation, and Durability. In this blog, we will delve into each of these properties using real-life scenarios and examples.

Atomicity: All or None

Atomicity ensures that a transaction is treated as a single unit, which is either fully completed or fully aborted.

Example: Consider a scenario where you transfer $100 from User A to User B:

Initial State:
- User A: $1000
- User B: $500

If, during the transfer, the database crashes after deducting $100 from User A but before adding it to User B, atomicity ensures that the transaction is rolled back to the original state:

Rolled Back State:
- User A: $1000
- User B: $500

Isolation: Guarding Your Transactions from Each Other

At the heart of the term "Isolation" in databases is the idea of protection. Imagine every transaction as a little bubble. Isolation ensures that these bubbles don't burst or mix into each other. By doing this, it keeps our data safe and sound.

Unraveling the Read Phenomena:

When we talk about "read phenomena," we're discussing unexpected things that can happen when transactions overlap. Let's look at each:

Dirty Reads: Imagine peeking into a room while someone is cleaning. Everything is scattered, and it's a mess. Similarly, a dirty read is like viewing data that another transaction is still changing. Since that change might be reversed, what you're seeing might not stick around.
Non-repeatable Reads: Imagine you note down the number of apples in a basket. A minute later, you count again, but the number has changed because someone took or added an apple. This is what happens here; data you read at the start of a transaction might change by the time the transaction finishes.
Phantom Reads: This is like checking a basket for apples and then finding oranges in your next check. It's unexpected! Phantom reads occur when new data appears (like those mysterious oranges) during a transaction.
Lost Updates: Think of two artists painting on the same canvas. If they paint over each other's work, one of their contributions might disappear. Similarly, when two transactions try to change the same piece of data, one of those changes might get overlooked.

Levels of Isolation - Setting the Boundaries:

Different isolation levels dictate how strictly we want to guard our transaction bubbles:

Read Uncommitted: This is like a room with an open door. You can see everything happening inside, whether it's finished or not. You see both ongoing (uncommitted) and completed (committed) changes from other transactions.
Read Committed: Now, the door is slightly closed. You only see things once they're done and settled. This level lets you view only the finished changes from other transactions.
Repeatable Read: Imagine counting the apples in that basket and then putting a protective shield around it so no one can change the count. With this level, any data you read remains consistent throughout your transaction.
Snapshot: This is like taking a photo of the room. Even if things change inside, you'll always look at the photo, keeping things consistent. You see a 'frozen' view of the data from the start of your transaction.
Serializable: Think of a narrow bridge where only one person can pass at a time. Transactions line up and wait their turn, ensuring they don't interfere with each other.

Comparison of Isolation Levels:

Consistency: Imagine It As A Fact-Checker

In the world of databases, "Consistency" is like having a meticulous fact-checker who ensures that everything matches up and there are no contradictions. It ensures that every piece of information in the database is reliable and trustworthy.

Understanding Data Consistency with a Simple Analogy:

Imagine you're flipping through a photo album. Each photo has a number written below it, indicating how many times that photo was liked on a social media platform.

Now, alongside this album, you have a diary that records who liked which photo. If a picture in the album says it has 5 likes, your diary should have 5 entries of people who liked that exact photo. It wouldn't make sense if the album said 5 likes, but the diary only listed 3 names, right? This is what we mean by data consistency - ensuring that related data matches up across different places in the database.

Data Consistency in Simple Terms:

Photo Album (Table 1): Picture of a cat - 5 likes
Diary (Table 2): Alice liked the cat photo. Bob liked the cat photo. Carla liked the cat photo. David liked the cat photo. Emma liked the cat photo.

If there's any mismatch between the photo album and the diary, our trusty fact-checker (Consistency) points it out and says, "Hey, something's not right here!"

Understanding Read Consistency with a Book Example:

Now, let's say you've written a book and you have the master copy (primary). To let more people read it, you create copies (replicas) of the book.

If you make a change to the master copy, like editing a paragraph, the copies should reflect that change too. If someone picks up a copy to read right after you've made an edit, they should ideally see the latest version. If not immediately, then pretty soon after. This ensures that whether someone is reading the master book or one of its copies, they're getting consistent information.

In database terms, even if there's a tiny delay (because making changes everywhere takes a little time), we should reach a point where every copy is updated. This is known as "eventual consistency".

Durability: Think of It As Saving Your Game Progress

In the world of databases, Durability is like saving your progress in a video game. Imagine you're playing a challenging level, and after hours of effort, you finally conquer it. You wouldn't want to risk losing that progress, right? You'd save your game to ensure that even if there's a power outage or your game console restarts, you won't have to play that level again. That's precisely what Durability does for databases; it ensures that once a change is made, it's saved and stays saved, no matter what.

Different Ways to Make Sure Your Game (Data) is Saved:

"Auto-Save" Feature (Write-Ahead Log): Just like some video games automatically save your progress at specific checkpoints, databases have a system where they note down changes even before fully updating everything. It's a quick note-to-self, "Remember to save this change."
Game Diary (Journaling): Some players keep a diary or journal about what they've done in a game. Similarly, databases might store changes in a separate "diary" before making them permanent.
Forced Save Option (Data File Synchronization): Ever had that moment when you manually choose to save your game because you don't trust the auto-save? In the database world, there's a way to force the system to immediately save any new data after a change.
Multiple Save Files (Replication): It's always a good idea to have more than one save file for your game. Likewise, databases often create copies of data across different locations. If one "save file" has issues, there are others to fall back on.
Cloud Backups (Backup and Restore): Just like you might backup your game progress on the cloud, databases also have a system of regularly saving data elsewhere. This way, if something goes wrong, they can "load" from a previous point and restore the game (data).

So, in short, Durability in the database world is all about making sure that once you've made progress (or a change), you won't lose it. It's about saving, re-saving, and having backups for your backups!

The ACID properties provide the backbone for database reliability. From banking to social media updates, these principles ensure that our data remains consistent, reliable, and trustworthy, even in the face of system failures. By understanding these concepts, we gain a deeper appreciation for the robustness and sophistication of modern database systems.

(Header Photo by Patrick Lindenberg on Unsplash)

The Miracle Morning: 6 Morning Habits to be Successful

Sadiqur Rahman — Sun, 07 Aug 2022 15:20:00 +0000

Photo by Sergei A on Unsplash

I was listening to a podcast by Hal Elrod. He explained 6 killer habits that would transform a person. Once I was applying a few of those rules in my daily life and I know for sure that, it works perfectly.

SAVERS

S - Silence (Meditation, Tefekkür). Set the mindset for the goals of the day. As you are being silent, you can use a timer too. Don't read, don't listen to anything, just sit and think. Find a balanced posture between relaxation and alertness. These ten minutes will transform your day to be more effective and more productive, not just another busy day!

A - Affirmation. Be affirmative about the things that you are willing to achieve. Think of the things that you are committed to doing. You could be committed to running every day or to becoming a millionaire or saving 50% or entering a big company. Remind yourself what you are committed to. While being affirmative, think about these four points;

What are you committed to?
Why is it deeply meaningful to you?
What activities are you committed to doing that will lead to success?
When specifically are you committed to doing those activities?

This will raise awareness and make you a real doer.

V - Visualize. Visualize yourself doing the activities with great motivation. Imagine yourself wearing shoes and going outside. And imagine yourself running with great motivation. Imagine yourself doing all the hard work and finally being rewarded with achievements. All the great athletes visualize themselves working hard and achieving their goals.

E - Exercise. Exercise in the morning even if it is for sixty seconds. Even if you go to the gym in the evening, a very short period of exercise will energize you and give you a great start to the day. There are many apps that let you exercise from home. One example would be "Seven minutes Exercise".

R - Read. All of us are in some conditions. Some want to be happy, some want to be wealthy, and some want to be a better person. And there are hundreds of books on each topic. If you read five pages a day, that will accumulate to 150 pages a month. If you persist in this habit, this will eventually transform you into a better version of yourself.

S - Scribe (Write). It is a way to raise awareness and harness positive energy in you. It will take only 5 minutes in the morning. You can write on an app or on a paper. ("Five Minutes Journal" is such an app)

Write three new things that you are grateful for
Three important things that you need to do to achieve your biggest goal

Write them every day, and you will discover that you have so many reasons to be happy. You have achieved so many things in your life, and your next goal is just yet another goal. You would be more confident as you realize that.

Be happy with where you are and what you are doing. Just know that you will reach your goal at the right moment. So don't get stressed or sad. Just enjoy your day and know that gradually you are reaching your goals.

Handle errors centrally in Node.js

Sadiqur Rahman — Mon, 13 Jun 2022 11:55:49 +0000

A very important spice to cook a healthy app, "Handle errors centrally. Not within middlewares". Here is a simple implementation that might help new developers.

Rules:
https://github.com/goldbergyoni/nodebestpractices/blob/master/sections/errorhandling/centralizedhandling.md

Implementation:
https://github.com/despider001/handle-error-centrally

Understand ACID and Transaction

Sadiqur Rahman — Mon, 16 May 2022 07:49:58 +0000

One document which had two pages content was sent to printer

Transaction - Document sent to printer

Atomicity - Printer prints two pages of a document or none.
Consistency - Printer prints half page and the page gets. stuck. The printer restarts itself and prints two pages with all content.
Isolation - While there were multiple print outs in progress - printer prints the right content of the document.
Durability - While printing, there was a power cut- printer again prints documents without any errors.

I really liked this simple exmplaination of transaction and ACID and I thought you guys might also benefit from it.
Ref: Stackoverflow

Exceptional Portfolio(?)

Sadiqur Rahman — Wed, 22 Jul 2020 16:36:00 +0000

It was around 2017, when I was looking for my first job, I wanted to make a portfolio that shows my projects and skills. At the same time, I wanted the website to be fast and exceptional. After it was done, I really liked the portfolio. It's been years since I updated the content. Its not very mobile friendly either, but I still kinda like the portfolio. (Maybe I'm a bit biased 😀)

Here are some weird features I added at that time to attract people 😅

Front page has water wave if you move your cursor (let me know if you notice)
Navigation is on the bottom left (I have never seen a second website having that 😀)
For some reason, I thought removing the scrollbar is a good idea (in chrome you will not see scrollbar)
Skills section has drag-drop functionality (don't ask me why 😀)

Try it on PC (mobile UI wasn't a concern back then 😀)

Portfolio

let me know your experience.

How to design a trello board: Boilerplate

Sadiqur Rahman — Mon, 29 Jun 2020 11:52:32 +0000

👋 Hi there,
For developers, Trello is a very useful tool. There are many different ways to use Trello depending on the project's need. I have a general template that I use almost in all of my projects. I would be more than happy, if that helps one from the community.

Here are the main components;

📜 Product Backlogs: Product backlogs contains all the features that have to be implemented. You can use different tags to identify things like which team would be responsible, priority and so on.

📃 Current Sprint: In this section, you can place all the features that you will implement in this sprint.

🟠 In Progress: On going tasks go here.

🏁 Done: Completed tasks go here.

⚠️ Bugs / Improvements: Bug / Improvement records go here.

💬 Discussion Topics: For the following team meeting, discussion topics could be listed here. You can tick out as you finish discussing. Also you can take notes under comment section for future reference.

📝 Research Topics: Often time, we need to do some research for the project. We can save those information for future reference.

Here is the link to the public board, if that would help anyone.

You can also have a look at the post: Planning for a Project: Boilerplate, which might help you to plan for a project.

Thank you for reading. I hope you liked it. Feel free to share your view. Have a great day 👋

Planning for a Project: Boilerplate

Sadiqur Rahman — Sun, 28 Jun 2020 11:04:40 +0000

Hello great people! 👋
I'm back with some interesting info for you. As software people, we do some planning in our day to day life. One of the most important plans is the planning for our project before we start coding.

A common mistake we (software people) do is that, we think it's very obvious and we don't need to WASTE(!!) time to write them down. Then at some point, we find ourselves overwhelmed with the project!

Generally, I like to write everything down. This way I keep my mind free. Here is my philosophy behind this.

Don't store data in RAM (your mind), when you can store it in a hard disk (paper/ online platform).

Take this example, if I tell you that there will be a software that uses facebook API to send messages to users. To many, it is very INTUITIVE. But the reality is that, it will have a lot of moving parts and if you don't take care of them, you will have a lot of headache soon.

Recently I made a boilerplate to kickoff a project and I thought it may help some of my fellow software people. So, here is the boilerplate that may work fine for small and medium size software.

Consider the stacks as placeholders. Replace with the one that works for you 😉

v1

I believe the flow is very self-explanatory. So I will not give any unnecessary explanation.

v2

In fact, I would like to explain a bit, so that it can address everybody with all sorts of experience level.

Frontend: For frontend you can use HTML, SCSS (highly recommended to use instead of CSS, since it allows you to write reusable code) and JavaScript or any JS framework. Standard stuff.

Backend: As for backend, you can use framework you like (Laravel, Codeigniter, Node.js, Django...). For me, I like Node.js (I would recommend to use TypeScript instead of JS, it will protect you from doing silly mistakes).

Database: You can any database that suits your project. If you would use relations a lot, go for SQL (MySQL, PostgreSQL, MariaDB...), if you feel like you would need some freedom from schema and you will generate a tons of data (e.g IoT), go for NoSQL (MongoDB, ArangoDB, DynamoDB...). For caching, you can try Redis or memcached (When to cache? When you are querying same data over again, and the data does not change very frequently, e.g. number of github repo).

External API: In most of our projects, we happen to use some external API. Example would be, login with facebook/ google, talking to dialogflow/ twilio and so on. Keeping that written would help your team see the big picture.

Email Service: For signup, password recovery and so on, we need to use some sort of email service. I like sendGrid (because its simple and keeps records of all communications), but you can choose anything that works for you. (e.g. Nodemailer).

Testing: If you are working in a team, don't forget to follow Test Driven Development. TDD will enable you to write code fast and securely without having to worry about breaking functions/API. There are many libraries/ frameworks for TDD. Jasmine, mocha, chai, Jest and so on. My choice is Jest.

DevOps: You need a server to put your application. You can choose DigitalOcean, AWS EC2 or any other service. Most probably I would go for linux OS, but EC2 also allows you to have windows system. Then to serve the app, you need a web server. I like Nginx but you can go for Apache if you will. To run Node.js application, you need a process manager. For me, its PM2. Now you got your application running. But how to secure it? (https) You can buy a SSL certificate from a top provider or get a free one from letsEncrypy. As for version controlling, you can use git and github/gitlab/bitbucket as remote repo. If you want to automate the deploying process (CI/CD), you can use Jenkins or CircleCI.

Project Management: To keep track of the project and to make sure that your team is not falling behind the schedule, you need to have some sort of project management implemented. Since we need fast iteration, I would go for Agile management. Trello is a great tool to track your project. (Check this boilerplate to see how you can design a project on trello). For communication, slack is unbeatable. You can have different channels, direct message, document sharing and many more. It is more like a professional whatsApp. Finally, to make sure your team is doing well, arrange some code review sessions once a while. It could be weekly or sprint base. But this will make sure that you are having bad/ inefficient code.

I know it was long, but I think it would help you to have a better and organized plan.

Below is the github repo where you can find the editable file. Feel free to share your opinion. I wish you a very good day 👋

https://github.com/despider001/project-planning

When to leave a job?

Sadiqur Rahman — Sat, 27 Jun 2020 16:21:28 +0000

Everyone talks about how to get a job and how to keep the job. Today I would like to share my view on when to leave a job. To many, it is a very intuitive topic, but I like to put things in a logical order. Here are some signs that should be a good reason to think about leaving.

Respect, Payment and Learning opportunity (RePL in short 😉).

Respect: There could be two different levels of respect. First one is personal respect. If one notice a lack of personal respect in the company, then it should be a good sign for the person to look for a new job. The second type of respect is the respect to the job. If the company does not respect the job they are doing, that should also be a good sign (I mean bad sign). How can a company disrespect the job they are doing right? Well there could be tens of ways. Say your company does not follow standards and good practices, they don't care how you code, rather they just want to finish and pass. One should watch out for those signs.

Learning Opportunity: I personally feel very exhausted if I cannot learn on a regular base. Learning does not only give someone pleasure and relief but also increase his value in his field. If your job is not letting you learn, you should start considering a new job.

Payment: Finally if your company is paying you way less than your current market price, you should look for a new job. Either they don't know your value or worst they don't see your value. In either cases, you should look for an upgrade. (Of course, there could be exceptional cases where the company is going through bad time.)

⚠️ Watch out for RePL!

Those are the signs that give me hard time to continue in a job. Feel free to agree/disagree. Have a great day 👋

Why Not to Use Root User?

Sadiqur Rahman — Thu, 25 Jun 2020 10:42:23 +0000

We all know that it is a bad practice to use root user. But not everyone of us may know the exact reasons. So here are some reasons to remember;

🔐 Security: All the hackers know that there is a root account and they would target the root account to breach in. To be safe and secure, root account should have logins disabled.

📳 Applications' Vulnerability: When an application is served using the root account, in case of vulnerability, hacker can execute code remotely and gain access. Also your application can erase important files or directories mistakenly.

🙊 Mistakes: Just like you and me, everyone else can make mistake. While rushing, one can run a command and find himself like "Holy Root! What have I done!". However, typing in "sudo ..." and password would give someone enough time to think twice.

👉👈 Accountability and Responsibility: To have a clear accountability and responsibility map, users should always use different user accounts based on their roles. This way, we would know who did what and who is responsible for what.

⭐ Solution ⭐: "Least Privilege Principle" is a very good rule of thumb. Give users the least privilege to accomplish a task. This way you are not discriminating your colleagues nor are you having less trust in them. You are in fact making everyone safe, including your colleagues from unintentional mistakes, your users from being compromised and your organization from a humiliation.
Thank you for reading 🙂 Stay safe and healthy 👋

GraphQL in 3 mins!

Sadiqur Rahman — Thu, 25 Jun 2020 10:18:55 +0000

GraphQL is a data query language developed by Facebook in 2012 and they made it public in 2015. Within this 3–4 years, many top companies have adopted GraphQL. Github, Twitter, PayPal, Pinterest, Coursera, New York Times, Shopify are few to name. Nowadays, it seems like, GraphQL has gained enough momentum to be a very 🔥Hot Topic🔥! If this is the case, then we should at least know what it is, right? Lets dive in!

When you say "Data Query Language", it does not make a lot of sense. Lets make it simple.

GraphQL is an alternative to REST API.

In REST API, one App may have hundreds of end points.

/api/users/
/api/posts/
/api/news/
/api/blah/

But for GraphQL, it will have only one!

/graphql       or        /anythingYouLike

Say, you need usernames and emails of users from some-site.com, for some reason. So, you send a GET request to some-site.com/api/users/. It sends you all the usernames and emails along with all the other data it had about the users.

[{
  username: "someName",
  firstName: "Mr.",
  lastname: "someName",
  email: "someName@email.com",
  age: 28,
   .
   .
   .
  and 100 more fields
}, 
{...}, {...}, ... ]

This is very kind of REST API, but might be overwhelming!
For GraphQL, you would send a POST request to some-other-site.com/graphql with the following body

query users {
  username
  email
 }

It would bring you the formatted data you were looking for!

[{
  username: "someOtherName",
  email: "someOtherName@email.com",
}, 
{...}, {...}, ... ]

Sounds cool right? There is more!

As you are building a REST API, you need to use a third party software like "postman" to check if everything is working fine. For GraphQL, it ships with a built-in "Adorable" query interface.

Right section of the image above shows some documentation, which is auto-generated!

Are you excited enough to play with the GraphQL interface? Guess what? I got a demo App for you!

Live: https://despider-graphql.herokuapp.com/graphql
Github: https://github.com/despider001/graphql_event_booking

It is an event booking App, which lets users createEvent, bookEvent or cancelBooking. Just copy-paste the query below in the query section and click the play button to see it in action.

{
  getEvent {
    title
    description
    date
  }
}

GraphQL ships with a lot more fun than what I mentioned above. To learn more, simply google it😉

Have a great day! 👋🏼

Twitter: @Sadiqur_Rahman_

Naming Conventions in 3 mins

Sadiqur Rahman — Thu, 25 Jun 2020 10:10:26 +0000

There are so many different ways you can name your variables (naming conventions). If you are a beginner, most probably you don't care a lot about naming. But if you are working / planning to work in a team, lets learn a bit of naming conventions before you embarrass yourself. 😉
Here are some common conventions;

🐫 Camel Case: First word of the variable has to start with a small letter, then the second or third word will start with capital letter. Examples: newVariable, iLikeCamelCase. Used for assigning string, number, boolean, object, array, list and so on.

👵🏽 Pascal Case: It is like camel case, except for the fact that it starts with a capital letter. Examples: NewVariable, ILikeItToo. Mainly used for declaring a class and it's types (Object Constructor Function, Interface…).

🐍 Snake Case: Here we have small letters with underscore (_) separation, like this_one. They are very handy for object keys and for database fields. This could also be used to declare a really_really_loooong_variable.

🍖 Kebab Case: In this type, small letters are grilled together using hyphens, just-like-this-example. You can use it for routes (url) for instance, if you wish.

😠 Screaming Case: All capital letters, to YELL at people. If you want to hard code a value like TAX=10%, you can use SCREAMING_CASE.

⁉️ Hungarian Notation: In this type, names start with a lowercase prefix to indicate the intention. Example would be sName, nAge. Since in JavaScript, we don't have typing (string, number…), we can use hungarian notation to give a hint about the variable's type (s for string, n for number…).

_Underscore before a variable: This is a very common practice to declare a _privateVariable that cannot be accessed outside of a class.

To sum up, it is always a good practice to apply the "good practices" in your code. This makes your code more understandable, maintainable and most importantly makes you feel cool 😎

I wish you a safe, healthy and happy coding! 👋

Twitter: @Sadiqur_Rahman_