Union Type

Let's say I have two types of users: Admin and Saller.

type TAdmin = {
  name: string;
  email: string;
  permissions: "manager" | "reporter" | "contentManager";
  role: "admin";
};

type TSeller = {
  name: string;
  email: string;
  img?: string | null;
  role: "seller";
};
// This is a normal UserData
const apiSellerUserObject: TAdmin | TSeller = {
  name: "Kim Soo Hyun",
  email: "kim@gmail.com",
  img: null,
  role: "seller",
};

// This is a admin UserData
const apiAdminUserObject: TAdmin | TSeller = {
  name: "Kim Soo Hyun",
  email: "kim@gmail.com",
  role: "admin",
  permissions: "manager",
};

In the above example, both are the types of users, and I imagine I don't know which user is coming from the API request. Because of that, I will give my object data type, whether it is seller or Admin. I will check it after the API request finishes. It's works like the javascript OR [||] operator. In this kind of scenario, Union types are convenient. The main benefit of using it is that I can easily use Union when I'm not sure both types can be set. Shortly speaking, it will just check if one of the type conditions is true, then it will work fine.

Intersection Type

Let's say I wanted to make a new type using the above example's Admin type. In the latest type, I need both the Admin and new properties. And combine them into a single new type called SuperAdmin. Take a look

type TAdmin = {
  name: string;
  email: string;
  permission: "manager" | "reporter" | "contentManager";
  role: "seller" | "admin";
};

type SuperAdmin = Omit<TAdmin, "permission"> & {
  contactInfo: string;
  isNidVerified: boolean;
  permission: "transactionManagement" | "ControlUser";
};

// This is a super normal UserData
const apuSuperAdminObject: SuperAdmin = {
  name: "Kim Soo Hyun",
  email: "kim@gmail.com",
  role: "admin",
  contactInfo: "01908279809",
  isNidVerified: true,
  permission: "transactionManagement",
};

Here, you need to add some extra property in that superAdminObject. Because those two properties are also required, you cannot miss that extra property, as I said, using the intersection operator (&). That's how I can force users consistently to have those in the property in Super Admin. It works like a Javascript AND (&&) operator in which both conditions must be fulfilled. Here is the main benefit of this intersection type. I can take an existing type, modify it on top of a new one, and make it a different one.

Lastly, both types are very handy and useful. Just know when to use what. You can choose the intersection Type when you want both types to meet your condition. Use Union to meet just one condition of those types for your object.

What is Docker?

Docker is a container technology tool for creating and managing containers. If you're wondering what a container is, think of it as a package of code that includes all your project dependencies and libraries needed to run that code. Picture a picnic basket where you carry all the necessary items for a picnic and can share them with your friends.

Images vs Container

Images are the blueprints of your project, holding all your packages and dependencies. For example, they contain your Node.js environment and all your code. On the other hand, a container takes a copy of that Image and runs it in an isolated environment, such as your Node.js server. The exciting part is you can run multiple containers using the same Image, and they will always work the same until you change the Image.

Types of Images

We have two types of images: pre-built existing images from the Docker Hub and another type is a pre-built image on top of your custom image.

Let's see an example.

Here is my Folder Structure

I'm using Node.js. To follow along, pull it from here. First, create a Dockerfile at the root of your project.

1. FROM: is used for a top-level pre-built image upon your custom: Os (Linux Distro) or Any runtime (Node.js). You can find anything on the Docker hub.

2. WORKDIR: Here, you can locate your Image folder, where all the code should be copied from your machine to the Image. Because your local machine file system and image file system are different, I have copied my files to the **/app** directory of the Image in the example.

3. COPY: This command lets you copy a file from your local machine to the Image. I have done this for the second time because of Docker Image Layer-based Architecture, which I will discuss in this section.

   

4. RUN: Here, you can specify which command you must run when the Image is being built.

5. EXPOSE: It exposes a port from your container. But it is optional. You can easily do this by adding a flag on the command line. We will talk about it later in this section.

6. CMD: This command allows you to specify which command you must run after creating an Image. For example, you can use this command to create a container from that Image and run something after building the container.

Understanding Image Layers

The Docker image works on a layer-based Architecture. First, after listing all the commands in the Dockerfile, you execute them individually when you run the [docker build .] command. This will build your Image one by one using the command layers you have given in the Dockerfile. In the Dockerfile, you have a command called [COPY. /app], which copies and pastes your local files into the image file system. Which is different from your local file system. By running that copy command, Docker will remember and cache your files until your local file changes and you rebuild the Image. Then, it will run other listed commands that need to be run after this copy command, which will also be cached.

The above picture shows when I built the Image for the second time without changing my files. Instead, it will use the cache. It won't take as long as it took when I was building it for the first time. Here is a fun part: if I have to change something in my code and rebuild it, although I have only changed one file in the code base, it will re-run all the commands listed after copying my files because it knows something has changed. So the catch is if you wanted to optimise your commands, let's say you don't want to run npm install all the time because you haven't made any changes on the package.json file. You need to copy your package.json file before running the install commands. Then, you can copy all your other files from the code base, and then it won't run when you have just changed something in the code because You haven't installed any packages. Therefore, it comes from the cache. Here is an example :

The next part is coming soon...

A linked list is a data structure or, as you can say, a collection of nodes connected to each other. It's a very popular and efficient Data Structure. There are two types of Linked lists: singly and Doubly. Today, we will see a basic overview of the Linked list. Let's get started.

What is a Pointer?

Now you might be thinking, what is a pointer? Don't worry. I will explain. So first of all, you need a basic knowledge of memory and how computers store our data. When we declare an Array, it will allocate memory contiguously, which means one by one. But this is different in a hashtable and Linked list. In a Linked List, data is stored in various locations, not contiguously. By using the Pointer, we caPointer our Data addresses. Input

integer strings take different memory spaces, so we need to store them in something. Here comes pointers. A pointer can store the address easily. For example, I declared a variable and stored it as an Integer so it would go to my memory space and take 1 - 3 bytes. Now I know the starting address and need to store the end address. That's why we need pointers. I know It's quite a boring explanation, by the way. It's the core of pointers.

Pointers in Linked List

So now we know what a pointer is, we can go on to the Linked List pointer. It is the same as what I have told you in what is a Pointers section. Pointers are the heart of Linked List. Linked means Everything is connected. By the way, here is the catch: Is Everything associated with a pointer? The Pointer is noPointerut, just pointing to its next or previous nodes. Node means you can think of an object with the key of value and a next or previous key with a value of its previous or next node. That's it for now. I will explain it briefly after I dive into Singly and Double Linked Lists.

Next Part is coming soon....