DEV Community: Tahzib Mahmud Rifat

Solidity Imports Explained: VFS, Remappings, and What Ethereum Actually Sees

Tahzib Mahmud Rifat — Sun, 15 Feb 2026 18:41:15 +0000

Introduction

If Ethereum only stores bytecode…
Then how does it access OpenZeppelin after deployment?

When you write:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

It feels like your contract somehow “depends” on OpenZeppelin at runtime.

But here’s the truth:

Ethereum never sees your imports.
Ethereum never loads external files.
Everything happens at compile time.

In this article, we’ll break down:

What actually happens when you write import
What the Virtual File System (VFS) is
What an import callback does
How Foundry remappings work
What finally gets deployed to Ethereum

Let’s go deep.

1. First Important Concept: Compile Time vs Runtime

There are two completely different phases:

Compile Time

Solidity files are read
Imports are resolved
Code is merged
Bytecode is generated

Runtime (On Ethereum)

Only bytecode exists
No source files
No imports
No remappings
No VFS

This distinction is critical.
Everything related to import happens during compilation not on-chain.

2. What Really Happens When You Write `import`

Suppose you write:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("Test", "TST") {}
}

Here's what actually happens:
1. Your tool (Foundry/Hardhat/Remix) reads your file.
2. It sees the import.
3. It resolves the path (using remappings if needed).
4. It loads the OpenZeppelin file.
5. It sends all source code to the Solidity compiler.
6. The compiler merges everything.
7. It produces a single bytecode blob.

After that:
There is no import anymore.
OpenZeppelin’s ERC20 code becomes part of your contract’s bytecode.

3. What Is the Virtual File System (VFS)?

The Solidity compiler does not directly depend on your computer’s folder structure.

Instead, it maintains an internal structure called:

Virtual File System (VFS)

Think of it as an in-memory map like this:

"contracts/MyToken.sol" → source code
"lib/openzeppelin/.../ERC20.sol" → source code

Important facts:

It exists only during compilation.
It lives inside the compiler process.
It is not a real folder.
It disappears after compilation finishes.

The VFS ensures that compilation is deterministic and platform-independent.

4. What Is an Import Callback?

When the compiler encounters:

import "./B.sol";

It must obtain the contents of B.sol.

But the compiler itself does not know:

How to read from your disk
How to fetch HTTP
How to read from IPFS
How to resolve npm packages

So it uses something called:

Import Callback

An import callback is simply a function provided by the environment that:

Receives the import path
Fetches the file
Returns the file contents to the compiler

Examples:

solc CLI → loads from your local filesystem
Remix → can fetch HTTP/IPFS/NPM
Foundry/Hardhat → read files and pass them via Standard JSON input

The compiler just says:

“Give me the file content for this import.”

The callback does the fetching.

5. Foundry Remappings: Why `@openzeppelin/` Works

You may wonder:

If OpenZeppelin is stored locally in:

lib/openzeppelin-contracts/

Why do we write:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

Instead of:

import "lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";

The answer is: remappings.

In foundry.toml, you might see:

@openzeppelin/=lib/openzeppelin-contracts/

This means whenever you see:
@openzeppelin/

Replace it with:

lib/openzeppelin-contracts/

So:

@openzeppelin/contracts/token/ERC20/ERC20.sol

Becomes:

lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol

Remappings:

Make imports cleaner
Avoid hardcoding folder structure
Improve portability
Keep dependencies abstract

The compiler itself does not understand @openzeppelin.
Foundry translates it before compilation.

6. What Gets Deployed to Ethereum?

After compilation, the compiler outputs:

ABI
Bytecode
Metadata

When you deploy to mainnet:

forge create MyToken --rpc-url ...

Only this gets sent to Ethereum:

0x608060405234801561001057600080fd5b506040516101...

That hex string is:

Fully compiled machine code.

It already contains:

ERC20 logic
Inherited functions
All storage layout
Constructor logic

Ethereum does not:

Fetch OpenZeppelin
Load external files
Process imports
Know about remappings

It simply executes bytecode.

7. Full Lifecycle Summary

Let’s connect everything.

You write:

Solidity files
Imports
Remappings

Foundry:

Resolves remappings
Loads files
Feeds them to the compiler

Compiler:

Stores files in VFS
Resolves imports
Merges code
Produces bytecode

Ethereum:

Receives bytecode
Stores it
Executes it

No imports exist on-chain.

Final Takeaway

Imports are a compile-time convenience feature.

They:

Help you structure code
Manage dependencies
Reuse libraries

But they do not exist at runtime. Once deployed, your smart contract is just bytecode.

Understanding this difference between:

Compile-time behavior
Deployment-time artifact
Runtime execution

Namespace Pollution in Solidity: A Small Mistake with Big Consequences

Tahzib Mahmud Rifat — Sat, 14 Feb 2026 18:23:08 +0000

NameSpace Pollution

⚠️ Why This Is Dangerous (Namespace Pollution)
Let’s say Math.sol contains:

library Math {
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }
}

And later someone updates Math.sol and adds:
contract Helper {}
Now every file that has:
import "./Math.sol";

automatically gets access to:

Math
Helper

Even if you didn’t expect Helper to exist.

This is called:
🚨 Namespace Pollution

Risk of Name Conflicts

Imagine two different files both define:

contract Ownable {}

If you write:

import "./File1.sol";
import "./File2.sol";

Your code may suddenly stop compiling due to a naming conflict.

Explicit imports prevent this:

import{ Ownable as OwnableV1} from "./File1.sol";
import{ Ownable as OwnableV2} from "./File2.sol";

Now everything is clear and controlled.

Unexpected Breakage in the Future

Let's say today Utils.sol contains:

contract A {}

You import it using:

import "./Utils.sol";

Later, someone updates Utils.sol and adds:

contract Helper {}

Now Helper silently appears in your contract’s global scope. If you already have a Helper contract, your build may suddenly fail. You didn’t change your code but it broke.

That’s dangerous in large teams and production systems.

Reduced Readability

When auditors or teammates read your code:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

They don’t immediately know what you're using.
But when you write:

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

It’s obvious. Clear dependencies make:

Audits easier
Code reviews faster
Security analysis cleaner Professional Solidity code should always make dependencies explicit.

Does It Affect Gas?

No.
Import style does not affect:

Gas cost
Runtime performance
Deployment cost
Bytecode size (unless you inherit or use additional code)

The compiler only includes what is actually used. Namespace pollution is a developer experience issue, not a blockchain performance issue.

You want your existing MetaMask connect-wallet system to work with Anvil, the local Ethereum network from Foundry.

Tahzib Mahmud Rifat — Tue, 15 Apr 2025 13:03:21 +0000

✅ Goal:

You want your existing MetaMask connect-wallet system to work with Anvil, the local Ethereum network from Foundry.

Prerequisite: 1. Foundry

🧠 What Happens by Default?

When you run anvil, it:

Spins up a local testnet at http://127.0.0.1:8545
Creates 10 funded accounts, each with a private key (these are local and safe to use in dev)

BUT — MetaMask doesn't know about Anvil unless you manually add it.

✅ Step-by-Step: Connect MetaMask to Anvil

Start Anvil

bash: anvil

You'll see something like this:

Listening on 127.0.0.1:8545
Private Keys:
0x1234abcd... (address: 0xABC...)

2. Add Anvil Network to MetaMask

Open MetaMask → go to Settings > Networks > Add Network Manually and fill in:

Field Value

Network Name: Anvil (Localhost)
New RPC URL: http://127.0.0.1:8545
Chain ID: 31337
Currency Symbol: ETH(Anything)
Block Explorer URL: (leave blank)

✅ Chain ID must be 31337 (default for Anvil).

3. Import Anvil Account into MetaMask

Copy one of the private keys from Anvil terminal, then:

In MetaMask, click your avatar → "Import Account"
Paste the private key

Now you're using the same account that your Foundry scripts use — super helpful for testing both sides.

Now you will see the ETH and accounts.

[NB: If you don't see any ETH/GO/or value , then, refresh the network by selecting another network and then again come the Anvil. Now it should show the values]

# Getting Started with Cursor AI

Tahzib Mahmud Rifat — Thu, 03 Apr 2025 19:03:18 +0000

Getting Started with Cursor AI

Here's your comprehensive guide to using Cursor AI effectively.

Basic Commands

/add - Add a new chat
/clear - Clear current chat
/help - Show command list
/new - Start fresh workspace

Code Generation Tips

Cursor AI works best when you provide clear, specific instructions about what you want to build.

Be specific about programming language
Mention frameworks or libraries you want to use
Specify any particular coding style or conventions
Include relevant context about your project

Best Practices

Start with a clear problem statement
Break complex tasks into smaller parts
Review and test generated code
Ask for explanations when needed

Code Review Features

Cursor AI can help review your code:

Identify potential bugs
Suggest optimizations
Check for security issues
Recommend best practices

Troubleshooting

Common Issues
- If AI generates incorrect code, try rephrasing your request
- For complex projects, provide more context
- If stuck, use /clear and start fresh
- Check your syntax when asking for specific languages

Tips for Better Results

To get the most out of Cursor AI:

Use natural language
Provide examples when possible
Specify error handling requirements
Ask for documentation when needed

Keyboard Shortcuts

Action	Shortcut
Generate Code	Ctrl + K
Accept Suggestion	Tab
Next Suggestion	Alt + ]
Previous Suggestion	Alt + [

Getting the Best Results from Cursor AI

How To Get The Best Results from Cursor AI

Planning

Cursor Directory(cursor.directory: Create and add a .cursorules file in the root of your project

The instructions in the .cursorules file will be included for features such as Cursor Chat and CTRL+K.

The more specific your rules for your project, the better.

Tagging Docs

Since AI models may have outdated information or default to older versions, tagging specific documentation helps ensure accuracy.

Asking other AI

If Cursor seems stuck, try consulting another AI model and share Cursor's failed attempts.

Things Cursor AI is Great At:

Documentation—writing code documentation is much easier now
Explaining code & teaching
Adding comments to code
Duplicating existing code patterns

Python pip installation problem

Tahzib Mahmud Rifat — Sun, 02 Mar 2025 09:07:30 +0000

PIP vs OneDrive: A Permission Battle!

Tahzib Mahmud Rifat ・ Feb 9 '25

#pip #python #warning #ai

Optimizing Storage Layout with Solidity Struct Clustering

Tahzib Mahmud Rifat — Sun, 02 Mar 2025 09:05:48 +0000

what is solidity struct clustering?

In Solidity, struct clustering refers to a technique used to optimize the storage layout of structs within a contract. This technique helps minimize gas costs by efficiently packing data into storage slots, reducing the number of storage accesses required.

Here's a breakdown of struct clustering and its benefits:

What is Struct Clustering:

When you define a struct in Solidity, the compiler lays out its members in storage slots. Each storage slot is 32 bytes (256 bits) wide. If a struct's members do not fill a slot completely, the remaining space is padded with zeros to fill the slot. This can lead to inefficient use of storage if not managed properly.

Struct Clustering involves organizing struct members in a way that minimizes padding and optimizes the use of each storage slot. This is achieved by placing smaller variables (like bool, uint8, etc.) together to fill slots more efficiently.

Benefits of Struct Clustering:

Reduced Gas Costs: By minimizing the number of storage slots used, you reduce the number of SSTORE operations required to update the contract's state. Each SSTORE operation costs gas, so fewer operations mean lower gas costs.
Improved Performance: Efficient storage layout can improve the performance of your contract by reducing the number of storage accesses needed during execution.
Better Scalability: As your contract grows in complexity, optimizing storage becomes crucial for maintaining performance and keeping costs under control.

Example of Struct Clustering in the image

In the efficient layout, isEmployed and yearsOfExperience are placed together to minimize padding and make better use of storage slots.

Best Practices:

Order Variables by Size: Place larger variables first (e.g., uint256, address), followed by smaller ones (e.g., bool, uint8).
Group Small Variables: Cluster small variables together to fill slots efficiently.
Test and Optimize: Use tools like Remix or Truffle to analyze storage layout and optimize as needed.

By applying struct clustering techniques, can significantly improve the efficiency and scalability of Solidity contracts.

solidity #smartcontract #blockchain #web3 #ethereum #security #struct #gasoptimization

PIP vs OneDrive: A Permission Battle!

Tahzib Mahmud Rifat — Sun, 09 Feb 2025 17:21:46 +0000

ERROR of python

When ever pip is used this warning is showed. The warnings indicate that pip is running into permission issues when trying to access or write to a folder (specifically, your OneDrive Documents folder). This can happen if some environment variables (like those for temporary files or SSL logging) are pointing to a location where you don’t have the necessary permissions.

Below are steps you can follow to fix the problem:

1. Check and Unset the SSLKEYLOGFILE Variable
Sometimes the SSLKEYLOGFILE environment variable is set (often for debugging SSL connections) and points to a protected folder. To check and clear it:

Open Command Prompt and run:

            echo %SSLKEYLOGFILE%

If the output shows a path like C:\Users\88018\OneDrive\Documents\… , that’s likely causing the issue.

Unset it for the current session by running:

   set SSLKEYLOGFILE=

Try installing your package again.

2. Redirect Your Temporary Directories
Pip uses temporary directories for caching and downloads. If these directories are set to a OneDrive folder, you may run into permission issues. You can change them as follows:

Create a new temporary folder (if it doesn’t already exist):
mkdir C:\Temp
Set the TEMP and TMP environment variables to point to this folder:

    set TEMP=C:\Temp
    set TMP=C:\Temp

3. Try Installing Packages Again
After unsetting SSLKEYLOGFILE and setting your temporary directory, try installing a package with pip. For example:

pip install numpy --no-cache-dir --cache-dir C:\Temp or
pip install flask --no-cache-dir --cache-dir C:\Temp

4. Run as Administrator (If Needed)
If you still see warnings or errors, try running the Command Prompt as an Administrator:

Press Win + S, type cmd, right-click Command Prompt, and select Run as administrator.
Then run your pip install command again.

In the PyCharm terminal

In your PyCharm environment the variable still appears to be active. This is why when you run pip in PyCharm’s integrated terminal (which is using PowerShell), you still encounter the same permission errors.

There are a few ways to resolve this within PyCharm:

Remove SSLKEYLOGFILE in the PyCharm Terminal Session Since you’re using PowerShell in PyCharm, you need to use PowerShell syntax to inspect and remove environment variables:

Check the variable in PowerShell:

run:

powershell

echo $env:SSLKEYLOGFILE
This should display the value if it’s still set.

Remove the variable for the current session:

Run:
Remove-Item Env:SSLKEYLOGFILE
or you can also do:

powershell

$env:SSLKEYLOGFILE = ""
Verify that it’s gone:

Run again:

powershell

echo $env:SSLKEYLOGFILE
You should now get no output (or an empty line).

Now try installing numpy:

powershell

pip install numpy

Set Up PyCharm’s Environment Variables Permanently If you’d like this change to apply every time you open a terminal or run a configuration from PyCharm, you can adjust your run/debug configurations or the default terminal settings:

Option A: Edit Run/Debug Configurations
In PyCharm, go to Run > Edit Configurations.
Select your project’s configuration (or create a new one).
In the Environment variables field, add:

Key: SSLKEYLOGFILE
Value: (leave it blank) Click OK to save. This ensures that whenever you run scripts or commands via PyCharm’s run configurations, the SSLKEYLOGFILE variable will be overridden to an empty value.

Option B: Modify PyCharm’s Terminal Settings
PyCharm’s integrated terminal inherits environment variables from your system. If your system still has the SSLKEYLOGFILE variable set, you might want to override it in PyCharm:

Go to File > Settings (or PyCharm > Preferences on macOS).
Navigate to Tools > Terminal.
In the Shell integration section, you can modify the Environment variables field. Add:

Key: SSLKEYLOGFILE
Value: (leave it blank) Apply and restart the PyCharm terminal.

Verify and Install After removing or overriding the variable in PyCharm, verify by running in the PyCharm terminal:

powershell

echo $env:SSLKEYLOGFILE
You should see no output. Then try:

powershell

pip install numpy
If everything is set up correctly, pip should now connect without encountering the permission error.

GPT link: https://chatgpt.com/share/67a8e209-6e6c-8000-b5b3-3ad21f9ea979

Docker for Node.js Developers: A DevOps Guide to Efficient Deployment

Tahzib Mahmud Rifat — Mon, 08 Jul 2024 17:29:40 +0000

Introduction

We're working on "Docker for Node.js Developers: A DevOps Guide to Efficient Deployment". We'll explore how to master containerization with Docker and transform our Node.js application deployment. We'll learn to optimize workflows, manage dependencies, and deploy to cloud platforms, reducing errors and increasing efficiency. We'll get our application to market faster with Docker.

Creating custom image and Docker file

1 . At first we initialize the node, npm i -y
2 . Install express, npm i express
3 . create a app.js file for server,

const express = require("express")

const app = express()

app.get("/", (req, res) => {
    res.send("<h2> Hi there , I am Tahzib!!! wait there i am  comming </h2>")
})


const port = process.env.PORT || 3000;

app.listen(port, ()=> console.log(`Listening on port ${port}`));

4 . Create a Dockerfile,

FROM node:22.3-alpine3.19

WORKDIR /app

COPY package.json .  

#Here the (.) means the current directory it is same as /app Here package.json file will be copied to /app directory

RUN npm install


#Why we are copying the whole directory to app directory and whats the purpose of copying package.json separately?

#Its beacuse Docker image works in layers, It means FROM is a layer and WORKDIR is a layer and RUN is a layer,
# And all the layer is cached, so that if COPY package.json is not changed then it will skip this layer , same for RUN command

# But in last copy which copy all the files of the directory becuse we migt need to change anything in the application .

#The summary is , copying twice will give optimization When it will see there is no change in package.json then it will not copy it and comes to RUN and same for RUN and it will then come to other files and only copy other files.


#---------------------      docker ignore -------------------

#Here copy will copy all the files we have in . directory but we dont need the node_modules , same way there might be lots of files and folder we don't need. So That we can use docker ignore file which will help us to ignore the unneccessary files.

COPY . ./

#Its the port number where the server will run

ENV PORT 3000
EXPOSE $PORT


#Entry Point for the container
CMD ["npm", "run", "dev"]

# In the context of the dev script in your package.json file, the command nodemon -L app.js will start nodemon in legacy watching mode, watching for changes to the app.js file and restarting the application when changes are detected.

#CMD [ "nodemon", "app"]


# i think this might work for global nodemon CMD [ "nodemon", "app.js"]



#NOTE: docker run -v pathtofolderlocation:pathtofolercontainer -d --name node-app -p 3000:3000  node-app-image

#docker run -v D:\BackendDevelopment\NodeDocker:/app -d --name node-app -p 3000:3000  node-app-image

5 . Now we a .dockerignore file. The dockerignore file has the ability to avoid such list of files that we does not need to copy while we built the image.

Here, we have some file list like, node_modules, Dockerfile, .dockerignore, .git and .gitignore. We might have to fill more later to ignore the files that we don't need to copy in our container.

6 . We need to add the nodemon for continuous refresh,

In package.json, we need modify the scripts. we have to add the start and dev according to our imgae.

7 . Next we have to built the image, by giving,

docker build -t node-app-image .
Let's break down the docker build command:

docker build: This is the Docker command to build a Docker image from a Dockerfile.
-t node-app-image: This option specifies the tag or name for the resulting Docker image. In this case, the image will be named node-app-image. The -t option is short for --tag.
.: This is the build context, which is the directory that contains the Dockerfile and any other files required for the build process. The dot (.) represents the current working directory, which is D:\BackendDevelopment\NodeDocker in this case.

So, when you run the command docker build -t node-app-image., Docker will:

Look for a file named Dockerfile in the current directory (D:\BackendDevelopment\NodeDocker).
Read the instructions in the Dockerfile to build the Docker image.
Create a new Docker image with the name node-app-image.
Use the files in the current directory as the build context, which means Docker will copy the files into the image during the build process.
In summary, this command tells Docker to build a new image named node-app-image using the instructions in the Dockerfile located in the current directory (D:\BackendDevelopment\NodeDocker).

8 . We check the image by giving, docker imgaes

Create Container

docker run -v ${pwd}:/app:ro -v /app/node_modules --env PORT=4000 -d --name node-app -p 3000:4000 node-app-image

docker run: This command is used to run a Docker container from a Docker image.

-v ${pwd}:/app:ro: This option mounts a volume from the host machine to the container. Here's what it does:

${pwd} is a variable that represents the current working directory (in this case, D:\BackendDevelopment\NodeDocker).
:/app specifies the directory in the container where the volume will be mounted. In this case, it's /app.
:ro means the volume is mounted as read-only. This means that the container can read files from the host machine, but cannot modify them.
So, this option mounts the current working directory on the host machine to the /app directory in the container, allowing the container to access the files in the current directory, but not modify them.

-v /app/node_modules: This option mounts another volume, but this time, it's a "virtual" volume that allows the container to persist data even after the container is restarted or deleted. This is useful for storing dependencies installed by npm or yarn, so that they don't need to be reinstalled every time the container is restarted.

--env-file ./.env: This option tells Docker to load environment variables from a file named .env in the current directory. The .env file typically contains sensitive information such as database credentials, API keys, or other configuration settings. By loading these variables from a file, you can keep them separate from your code and avoid hardcoding them.

-d: This option tells Docker to run the container in detached mode, which means the container will run in the background, and you won't see its output in the terminal.

--name node-app: This option gives the container a name, node-app, which can be used to reference the container in other Docker commands.

-p 3000:4000: This option maps a port from the host machine to a port in the container. In this case, it maps port 3000 on the host machine to port 4000 in the container. This allows you to access the application running inside the container by visiting http://localhost:3000 in your browser.

node-app-image: This is the name of the Docker image that the container will be created from.

So, when you run this command, Docker will:

Create a new container from the node-app-image image.
Mount the current working directory on the host machine to the /app directory in the container, allowing the container to access the files in the current directory.
Mount a virtual volume at /app/node_modules to persist dependencies installed by npm or yarn.
Load environment variables from the .env file in the current directory.
Run the container in detached mode.
Give the container the name node-app.
Map port 3000 on the host machine to port 4000 in the container.
This command sets up a Node.js application to run in a Docker container, with the application code mounted from the host machine, environment variables loaded from a file, and the ability to access the application from the host machine via port 3000.

Deleting State Volumes

docker volume ls , will show all the volumes that we create.

2 . We can delete them using,

docker volume rm <id>
docker volume prune Or we can delete them while removing the container. For that we can use: docker rm node-app -fv

Docker Compose

So, we can see our command goes big for running a single container. And when we move to multiple container then it is very difficult to run such big commands and it is very easy to fall in typos. To solve that we have docker compose.

Dockerfile vs Docker compose

We need a Dockerfile to create a Docker image, which is a packaged version of our application. The Dockerfile defines how to build the image, including the dependencies and configuration required to run our application.

We need Docker Compose to define and run a multi-container application, which consists of multiple services that work together. Docker Compose makes it easy to manage the dependencies between services, scale individual services, and restart services when they fail.

At first we need a file named docker-compose.yaml. The file must have the (.yaml) extension.

    services:
      node-app:
        build: . 
        ports:
          - "3000:3000"
        volumes:
          - ./:/app
          - /app/node_modules
        environment:
          - PORT=3000

Ignore the preview, because i docker compose the indentation is very important, we use 4 space in every indentation. Follow the image,

And now the moment of truth, give command,

docker compose up

We can see the image and running container,

To remove the container we can simply give ,docker compose down. But it will keep the volume data. To remove the volume also we need to give , docker compose down -v

1 . So we have one problem here, Though we can down the docker compose but when give the docker compose up -d , -d for detached mode and the 2nd time when we gave this then it will add the changes because docker compose is so dumb. To keep the changes and create the new image we have to give,

We change the port: 4000, docker compose up -d --build

Again we give the port to 3000 and build the image,

Actually volume keeps the track of the files from them localhost to containers.

Development vs Production configs

Till now we just use the docker for our development but the production does not work that way. We can't simply deploy what we have edited. We show the users the clean portion. For that we simply use multiple docker compose file. Different files for different use.

3 new files are created,

1 . docker-compose.dev.yml ,

services:
  node-app:
    volumes:
      - ./:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
    command: npm run dev

2 . docker-compose.prod.yml,

services:
  node-app:
    environment:
      - NODE_ENV=production
    command: node app.js

3 . docker-compose.yml,

services:
  node-app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - PORT=3000

and kept the previous docker compose file as docker-compose.bacup.yml.

The most important , we have to use separate commands for production and development,

Dev: docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build

Production: docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d -build

We can see lots of docker-compose files which are not needed in the container. We can easily remove them by inserting them to .dockerignore file.

[ means any file that matches the previous portion ]

But We have to solve another issue, Now the RUN command in Dockerfile is running for both development and production while building and for both condition we are running npm install, which is not needed for production. To, solve this issue we need some changes in our Docker file.

New RUN command, with $NODE_ENV as variable and it will be received as argument. So we set it as argument variable. and we remove the previous RUN command. And new RUN command is shell scripting code.

ARG NODE_ENV

RUN if [ "$NODE_ENV" = "development" ]; \
        then npm install; \
        else npm install --only=production; \
        fi

2 . Next we change in docker-compse.dev.yml file,

added build , context and args.

3 . Same for docker-compose.prod.yml,

And the terminal commands are same for production and development.

But we don't need the --build any more because we add that to the compose file.

Adding a mongo container

mongo:
    image: mongo
    restart: always
    environment:
      - MONGO_INITDB_ROOT_USERNAME=admin
      - MONGO_INITDB_ROOT_PASSWORD=password

Added this mongo service, and run this command to termina, docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d .
Then open in shell command mode, giving , docker exec -it devopswithnodejs-mongo-1 sh
Now give, mongosh -u "amidn" -p "password"

And you are successfully logged into the mongodb server.

You can check the database using mongodb database commands.

Keep in mind from now, we can not use -v tag for docker compose down , because the mongo volume is now persistent .

Communication between containers

Install mongoose , npm i mongoose
Down all the containers and build again because of new package,

docker compose -f docker-compose.yml -f docker-compose.dev.yml down

3 . Now we are going to build the image again,

docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build

Next is connect the database,

4 .

in the place of admin: use the user name we gave for db

After admin, we have : and then we have to give the password that we gave for mongo. Then the IP address of the mongo container. But Here comes the network thing. Because both mongo and nodejs are in same network so we don't need the ip we can use the image name.
To check the network list

Here our network name is devopswithnodejs_default. And to inspect it we can give, docker network inspect devopswithnodejs_default

Adding config.js

It is not a mandatory part ,

Create config directory and config.js file.

inside that give,

module.exports = {
    MONGO_IP: process.env.MONGO_IP || "mongo",
    MONGO_PORT: process.env.MONGO_PORT || 27017,
    MONGO_USER: process.env.MONGO_USER,
    MONGO_PASSWORD: process.env.MONGO_PASSWORD
}

2 . Use them on app.js,

const express = require("express")
const mongoose = require( "mongoose");
const { MONGO_USER, MONGO_PASSWORD, MONGO_IP, MONGO_PORT } = require("./config/config");

const app = express()

mongoose.connect(`mongodb://${MONGO_USER}:${MONGO_PASSWORD}@${MONGO_IP}:${MONGO_PORT}/?authsource=admin`).then(()=> console.log("Successfully connected to dB")).catch((e) => console.log("Error is: ", e));

app.get("/", (req, res) => {
    res.send("<h2> Hi....., I am Tahzib, wait there i am  comming </h2>")
})

const port = process.env.PORT || 3000;

app.listen(port, ()=> console.log(`Listening on port ${port}`));

And keep in mind to use, docker compose down and docker compose up.

to check and verify the connection,

Yo may see some warnings for mongo connection. These are for using older version of mongo. If you face the problem use AI, how to add the dependencies to mongo. And you are done.

Container bootup order

We have two containers one node and other is mongo. Here, if the node container runs first then it will not find the mongo container and which will cause error. So that, we use dependencies on docker-compose file which will give us the order.

depends_on: # It neans it dpends to mongo container , so the node container will run after the mongo contaner.
      - mongo

and for the safety we can use a function which will try to connect the container in every 5se,

const connectWithRetry = () => {
    mongoose.connect(`mongodb://${MONGO_USER}:${MONGO_PASSWORD}@${MONGO_IP}:${MONGO_PORT}/?authsource=admin`).then(()=> console.log("Successfully connected to dB")).catch((e) => { console.log("Error is: ", e);
        setTimeout(connectWithRetry, 5000);
    })
}

connectWithRetry();

and for connection check we can give, docker logs devopswithnodejs-node-app-1 -f

Building a CRUD application

1 . Added these 2 lines to app.js,

const postRouter = require("./routes/postRoutes")
app.use(express.json())

2 . Now we are going to create 3 folders and inside them 3 files. Like: folder->file,

controllers->postController.js
models->postModels.js
routes->postroutes.js

Here are the file data,

postController.js

const Post = require("../models/postModel")

exports.getAllPosts = async (req, res, next) => {
    try {
        const posts = await Post.find();

        res.status(200).json({
            status: "success",
            results: posts.length,
            data: {
                posts,
            },
        })
    } catch(e) {
        res.status(400).json({
            status: "fail",
        })
    }
}

//localhost:3000/posts/:id

exports.getOnePost = async(req, res, next) => {
    try {
        const post = await Post.findById(req.params.id);

        res.status(200).json({
            status: "success",
            data: {
                post,
            },
        })
    } catch(e) {
        res.status(400).json({
            status: "fail",
        })
    }
}


exports.createPost = async(req, res, next) => {
    try {
        const post = await Post.create(req.body);

        res.status(200).json({
            status: "success",
            data: {
                post,
            },
        })
    } catch(e) {
        res.status(400).json({
            status: "fail",
        })
    }
}


exports.updatePost = async(req, res, next) => {
    try {
        const post = await Post.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true,});

        res.status(200).json({
            status: "success",
            data: {
                post,
            },
        })
    } catch(e) {
        res.status(400).json({
            status: "fail",
        })
    }
}


exports.deletePost = async(req, res, next) => {
    try {
        const post = await Post.findByIdAndDelete(req.params.id);

        res.status(200).json({
            status: "success",
        })
    } catch(e) {
        res.status(400).json({
            status: "fail",
        })
    }
}

postModel.js

const mongoose = require("mongoose");

const postSchema = new mongoose.Schema({
    title: {
        type: String,
        require: [true, "Post must have title"],
    },
    body: {
        type: String,
        required: [true, "post must have body"],
    }
})

const Post = mongoose.model("Post", postSchema)

module.exports = Post;

postRoutes.js

const express = require("express")

const postController = require("../controllers/postController");

const router = express.Router();

router
    .route("/")
    .get(postController.getAllPosts)
    .post(postController.createPost)

router
    .route("/:id")
    .get(postController.getOnePost)
    .patch(postController.updatePost)
    .delete(postController.deletePost)

module.exports = router;

Inserting data to database

We are going to use Postman to insert data.

use this api for posting data, http://localhost:3000/api/v1/posts
Use the HTTP method POST.

2 . Use GET method to see all the data using the same api

Sign up and Login

At first we are going to create a user model in models directory. Like: models->userModel.js

const  mongoose = require("mongoose")

const userSchema = new mongoose.Schema({
    username: {
        type: String,
        require: [true, 'User must have a user name'],
        unique: true,
    },
    password: {
        type: String,
        require: [true, 'User must have a password'],
    },
})

const User = mongoose.model("User", userSchema)

module.exports = User

2 . Now we create a controller for it, it is authController.js in controllers directory.

const User = require("../models/userModel")

exports.signUp = async(req, res) => {
    try{
        const newUser = await User.create(req.body)
        res.status(201).json({
            status: "success",
            data: {
                user: newUser,
            },
        })
    }catch(e){
        res.status(400).json({
            status: "fail"
        })
    }
}

3 . Now we need the routes. So we create userRoutes.js in routes directory.

const express = require("express")

const authController = require("../controllers/authController")

const router = express.Router()

router.post("/signup", authController.signUp)

module.exports = router;

4 . Last we have to add the middleware in app.js .

const userRouter = require("./routes/userRoutes")
app.use("/api/v1/users", userRouter)

And we are done, we can check it on postman.

API,

http://localhost:3000/api/v1/users/signup

Body:

{
    "username": "Tahzib",
    "password": "password"
}

Till now our password is saved as plain text. To encrypt it we are going to use bcrypt package.

npm i bcrypt

NOTE: use bcrypt

Now make the docker compose down and up again with build.

docker compose -f docker-compose.yml -f docker-compose.dev.yml down
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build

I officially end my backend journey here, time to explore other tech stacks. Goodbye, and sorry for sudden death of this post.

Cells with Odd Values in a Matrix(LeetCode-easy)

Tahzib Mahmud Rifat — Sun, 30 Jun 2024 09:18:08 +0000

INTRODUCTION

We, have given two array one is main array matrix and other is indices[is a 2D array]. Each indices value consist two things one is row value and another is column value, indices[i] = [ri, ci]. And our task is to simply increment by 1 the whole row and whole column.

NOTE: Because indices is 2D array, so we can easily get the row value using row = indices[i][0] , and the column value using col = indices[i][1]

Examples

Hints

Steps

Create an array of size m, n
Set the row value and col value from indices
Increment the whole row and col by 1
Check the main matrix values for ODD number.
Return the counter.

Java Code

class Solution {
    public int oddCells(int m, int n, int[][] indices) {
        int[][] mat = new int[m][n];
        for (int i = 0; i < indices.length; i++) {
            int row = indices[i][0];
            int col = indices[i][1];

            for (int j = 0; j <n; j++) {
                mat[row][j]++;
            }
            for (int j = 0; j <m; j++) {
                mat[j][col]++;
            }
        }

        int count = 0;
        for (int i = 0; i <m; i++) {
            for (int j = 0; j < n; j++) {
                if(mat[i][j] % 2 != 0){
                    count++;
                }
            }
        }
        return count;
    }
}

Output

Docker for Beginners (Windows)

Tahzib Mahmud Rifat — Tue, 25 Jun 2024 17:59:03 +0000

What is Docker

Docker is a platform that allows us to package and run applications inside lightweight, isolated environments called containers. These containers include all the necessary dependencies and code needed to run our app consistently across different machines. Unlike traditional virtual machines, Docker containers share the same host operating system, making them efficient and portable. Docker simplifies version control, dependency management, and ensures consistent environments for development and production. It’s a powerful tool for streamlining software deployment and scaling. 🚀

Before

After

Own isolated environment and own operating system which is linux based.
Packed with all configuration
One command to install the app

Application deployment

So before docker , the configuration of the server needed
There might dependencies conflict
Misunderstandings
Text doc for deployment

so after the containers,

No environmental configuration on the server - except docker runtime
Developers and Operations works together to the package the application in a container

What is a container

The container is a layer of images.
Mostly linux base image, because small in size[ alpine: 3.10]
And the application image is on top.

Lets install Postgres:9.6

1st go to DockerHub
Search postgres

3 . Choose your desired version, i choose 9.6

4 . For windows, open wsl and run docker run postgres:9.6

Difference between Image and Container

Image is an actual package or software that we want to run. It can be moved around
Actually when we start the application is called container. And when we run the image, then it first bring to a container and then we run it and called container

Difference between Docker and Virtual machine

Docker image is much smaller like couple of megabytes and vm might be couple of gigabytes
Docker container start and runs faster but the vm is much slower
If we want to run some linux based application on windows then it will not run, because the the OS kernel is not same. Thats why we need to use the Docker tool box

Basic Docker commands

docker pull
docker run
docker start
docker stop
docker ps
dokcer exec-it
docker logs

Installing redis image

Just go to docker hub
Search redis

3 . open wsl , run command docker pull redis

4 . Now we have to put the redis image to a container to run it. For that just give the command, docker run redis

To check the running images, open a new terminal and give, docker ps
To stop the running image give ctrl + c
docker run, command runs new container when we use it.
Here are some key differences between the two commands:
Attached vs Detached Mode: The main difference is that docker run attaches to the container, while docker run -d runs the container in detached mode.

Output: With docker run, you will see the output of the container in your terminal. With docker run -d, you will not see the output.
Container Management: With docker run, you can manage the container directly from your terminal. With docker run -d, you will need to use other commands like docker ps and docker stop to manage the container.

In summary, docker run is used to start a container and attach to it, while docker run -d is used to start a container in detached mode, allowing it to run in the background.

Attached mode

Here the container is attached with the terminal

Detached mode

9 . Now in detached mode, to stop the container for some reason we can use, docker stop <id>

10 . To start again use , docker start <id>

11 . Suppose we stops the container for today and came back tomorrow and want to start from where left, to do that we can use, docker ps -a which will show all the running and not running container logs

12 . Now if want to run 2 redis of different versions, we have to use docker run redis:version , here the version is- which version image we want to run in our container. docker run pulls image and runs the container.
So the docker run does two command in one, one is docker pull and the other one is docker run

Here we can see, both redis versions are running on port: 6379/tcp, which is also the container port number.
But the problem is in tcp we can not use single port for multiple application in our localhost . To solve this issue we have to bind port.

13 . To bind the port at first we have to stop all the running redis images.

Then run,

docker run -p6000:6379 -d redis for 1st one,

for the second one we will run it on port 6001 same way but remember 6379 is the container port.

We can see 2 different redis application runnig on 6001, 6000.

docker log & docker exec -it

To check why one container is not working properly , using the docker log

docker logs <id>
or docker logs <name>

but it is difficult to remember the container name. To solve this problem we can name the container as we like.

3 . So we have two container currently running,

at first we have to stop one using, docker stop <id>
Now give the command , docker run -d -p6001:6379 --name redis-older redis:7.0

then we can use docker logs by the given name

docker logs redis-older

Docker exec -it

We can easily open the terminal of the current container using, docker exec -it
We have container named redis-old
now give, docker exec -it redis-old /bin/bash

note: we can use the container id also instead of name(redis-old)

Then we went to home directory and run env command
To exit we simply give exit

Developing with containers

Install express, mongo-express by,
docker pull mongo
docker pull mong-express

We are going to create a new network

To create a new network, give: docker network create mongo-network
to check the network list: docker network ls

Run mongo containers

The default container port for mongo is 27017
docker run -d -p 27017:27017 \ -e MONGO_INITDB_ROOT_USERNAME=admin \ -e MONGO_INITDB_ROOT_PASSWORD=password \ --name mongodb \ --net mongo-network \ mongo

id: 74bd46402e9cebdf13c2265a01b072807dd7d97bb83ae569193e35c191f67f60

3 . Same way run the mongo-express,

docker run -d -p 8081:8081 \ -e ME_CONFIG_MONGODB_ADMINUSERNAME=admin \ -e ME_CONFIG_MONGODB_ADMINPASSWORD=password \ -e ME_CONFIG_MONGODB_SERVER=mongodb \ --net mongo-network \ --name mongo-express \ mongo-express

id: 6847ec9032c3673c6c61fc0f89e1b2baa5cbb44bea27eeedf0d67a1e384ec109

4 . Now we can easily check , if mongo-express is connected or not by, docker logs <id>

5 . Now go to browser and search, localhost:8081

and give username: admin,
password: pass

And you will see the home page,

Docker Compose

Previously we use run commands to start our containers and created a network to communicate between them. But what if we need to run 10 containers at a time and create a network to communicate them, it will be very difficult to run 10 commands for each containers. To solve this issue we can use Docker Compose File , which will contain all the commands in a structured way.

1 . Version: 3 // version of docker compose
2 . Services: // here all the container names goes
3 . mongodb: // container name
4 . image: mongo // which image we are using here mongo
5 . port:
-27017:27017 // this is the tcp port number host:container
6 . environment:
-MONGO_INITDB_ROOT_USERNAME=admin MONGO_INITDB_ROOT_PASSWORD=password // environment variables

7 . mongo-express: // new container name
8 . image: mongo-express // image
9 . ports: -8081:8081 // port number

environment: .... // environment variables

But there is one thing is missing that is Docker Network, Actually in docker compose file we don't need that, docker compose itself takes care of creating a common network.

Let's create a docker compose file

In docker compose file(yaml file) the indentation is important. We have a demo project where we have the docker compose file,

version: '3'
services:
  mongodb:
    image: mongo
    ports:
     - 27017:27017
    environment:
     - MONGO_INITDB_ROOT_USERNAME=admin
     - MONGO_INITDB_ROOT_PASSWORD=password
  mongo-express:
    image: mongo-express
    ports:
     - 8081:8081
    environment:
     - ME_CONFIG_MONGODB_ADMINUSERNAME=admin
     - ME_CONFIG_MONGODB_ADMINPASSWORD=password
     - ME_CONFIG_MONGODB_SERVER=mongodb

save it as, mongo.yaml

Now the question is how to run the compose file !!.
At first we go to the location where we save the compose file using the terminal.

The docker compose is also installed with docker is installed. Its a package

now give, docker-compose -f mongo.yaml up
Here, the command -f means the mode of the document is file

Here we can see new network has been created and two new containers also.

Previously to stop the containers we have to use docker stop, but in docker compose we can use

docker-compose -f mongo.yaml down

And it will shutdown all the container in the compose file, and also the network that had been created by docker compose.

after shutdown,

NOTE: The command is used for downing the compose file is actually a container restart and we will lost every data that we worked in previous container.

Dockerfile - Building our own Docker Image

1 . FROM: node // which gives us the installed node
2 . ENV: // which are the environment variable
3 . RUN : // executes any linux commands , here the directory will be created using mkdir
4 . COPY: // It executes on the HOST machines
5 . CMD: // entry point command

To create our own image we need two thigs, 1. name, 2. Tag
At first go to the folder that contains Dockerfile, run the command-> docker build -t my-app:1.0 .

Dockerfile:

FROM node:22.3-alpine3.19

ENV MONGO_DB_USERNAME=admin \
    MONGO_DB_PWD=password

RUN mkdir -p /home/app

COPY ./app /home/app

# set default dir so that next commands executes in /home/app dir
WORKDIR /home/app

# will execute npm install in /home/app because of WORKDIR
RUN npm install

# no need for /home/app/server.js because of WORKDIR
CMD ["node", "server.js"]

To check, give docker images,

We can run the image using, docker run my-app:1.0 and see the logs, docker logs <id>
to open it exec mode,

Privet Docker Registry

Create and account on aws.amazon.com
Serach ECR service
Create a repository
Named the repo my-app

5 . Now we are going to push the docker image that we created.

6 . At first we need to create an account on aws.amazon.com.

7 . Install AWS CLI, CLI installer .

verify installation using, aws --version

8 . Now we need to do aws configure, before that we need to create a IAM account.

From the user we have to create a user and click on the user and create an access key,

Now we can configure the aws cli using , aws configure and put the access key id there.

Now we are going to create an ECR repository which is a private registry,

In services search ECR and go to private portion and click on create repository

Now , give name to your repo, i gave my-app and keep the other things as it is,

10 . Now Click on the created repo , my-app,

Then view push command,

Copy The first command and paste it to powershell,

if you get this error,

then, go to IAM user,

Them Add permission

Create Inline policy

Select JSON,

And remove all code and add this,

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ECRLogin",
      "Effect": "Allow",
      "Action": "ecr:GetAuthorizationToken",
      "Resource": "*"
    }
  ]
}

Now the error must be solved. And give this command,,

it will show you,

Now we will come back later and we see the

Image Naming in Docker Registry

Normally in docker hub, we have the short name of the docker image but in aws ECR we have write the full mode.

So we are going to use this, docker tag my-app:1.0 339712908553.dkr.ecr.eu-north-1.amazonaws.com/my-app:1.0
By giving this we create a duplicate image with different name because of the tag,

Now we are going to use the 4th command but we will the latest with 1.0.

[Some images are taken from Tech with nanas YT channel]

Ways to inspect elements on websites that Disabled inspect DevTool

Tahzib Mahmud Rifat — Sun, 23 Jun 2024 14:08:08 +0000

Even if a website tries to disable DevTools, we can still access them using the browser's menu. Here are the ways to do it:

Chrome:

Click on the three vertical dots (⋮) in the top right corner of the browser window.
Select More tools > Developer tools.
Alternatively, you can press Alt + D and then press Enter to focus on the address bar, and then press F12.

Firefox:

Click on the three horizontal lines (≡) in the top right corner of the browser window.
Select Web Developer > Toggle Tools.
Alternatively, you can press Ctrl + Shift + E (Windows/Linux) or Cmd + Opt + E (Mac).

Edge:

Click on the three horizontal dots (…) in the top right corner of the browser window.
Select More tools > Developer tools.
Alternatively, you can press F12.

Safari:

Click on Safari in the top menu bar.
Select Preferences > Advanced.
Check the box next to Show Develop menu in menu bar.
Then, click on Develop in the top menu bar and select Show Web Inspector.
Alternatively, you can press Cmd + Opt + I.
By using these methods, you can bypass any attempts to disable DevTools and still access them.

Brave Browser :

Menu: Click on the three horizontal lines (≡) in the top right corner of the browser window.
Select More tools > Developer tools.
Keyboard shortcut: Press Ctrl + Shift + I (Windows/Linux) or Cmd + Opt + I (Mac).
Address bar: Press Alt + D and then press Enter to focus on the address bar, and then press F12.

These methods should allow you to access DevTools in Brave Browser, even if a website tries to disable them.

Note: Brave Browser is based on Chromium, so the keyboard shortcuts and menu options are similar to those in Google Chrome.

REST API

Tahzib Mahmud Rifat — Tue, 23 Apr 2024 15:34:19 +0000

We should not use only 3000 or 5000 for our port number. We should use user available port number. For that we need , process which is a global object then we need env its a property of process and then PORT.

conts port = process.env.PORT || 3000
app.listen(port, () => {console.log(Started listening ${port})`}

Query String Parameter

There are the query which are added to **url **after question mark(?).

http://localhost:5000/api/posts/2024/24?sortBy=name

How to read query parameter

res.send(req.query)

Handling Get Request

courses.find(c => c.id === parseInt(req.params.id))

find is used for finding value of an array. => will return a boolean value which is compared with parseInt. Because req.params.id returns a string value.

How to response to HTTP Post request

The HTTP response to Post method,

app.use(express.json())
app.post('/api/courses', (req, res) => {
    const course = {
        id: courses.length + 1,
        name: req.body.name
    }
    courses.push(course)
    res.send(course)
})

PostMan

we need Post Man desktop for local work

req.params.id and req.body.name are both used to access data sent to the server, but they are typically used in different contexts.

req.params.id: This is used to access route parameters in Express. When you define a route with a parameter in Express, such as /users/:id, any value passed in the URL after /users/ will be accessible as req.params.id. Route parameters are typically used for identifying a specific resource in RESTful APIs. For example, in a URL like /users/123, 123 would be accessible as req.params.id.

app.get('/users/:id', (req, res) => {
    const userId = req.params.id;
    // Use the userId to retrieve user data from a database, for 
example
});

req.body.name: This is used to access data sent in the body of a POST or PUT request. When you submit a form or send data in the body of a request, you can access that data using req.body. For example, if you have a form field named name, you can access its value using req.body.name. javascript

app.post('/submit-form', (req, res) => {
    const name = req.body.name;
    // Use the name submitted in the form
});

Input Validation

In a typical HTTP request-response cycle, you can only send one response back to the client. Once a response is sent using res.send(), res.json(), res.sendFile(), or similar methods, the server cannot send another response for the same request. Any code after sending the response will not be executed in the context of handling that particular request.

For validation we use npm joi,

npm i joi

`
app.post('/api/courses', (req, res) => {
//handleing with joi
const schema = {
name: Joi.string().min(3).required()
}
const result = Joi.ValidationError(req.body, schema)

    if(result.error){
        res.status(400).send(result.error.details[0].message)
        return;
    }
    // ---
    const course = {
        id: courses.length + 1,
        name: req.body.name
    }

    courses.push(course)
    res.send(course)
})

DEV Community: Tahzib Mahmud Rifat

Solidity Imports Explained: VFS, Remappings, and What Ethereum Actually Sees

Introduction

1. First Important Concept: Compile Time vs Runtime

2. What Really Happens When You Write import

3. What Is the Virtual File System (VFS)?

4. What Is an Import Callback?

5. Foundry Remappings: Why @openzeppelin/ Works

6. What Gets Deployed to Ethereum?

7. Full Lifecycle Summary

Final Takeaway

Namespace Pollution in Solidity: A Small Mistake with Big Consequences

NameSpace Pollution

Risk of Name Conflicts

Unexpected Breakage in the Future

Reduced Readability

Does It Affect Gas?

You want your existing MetaMask connect-wallet system to work with Anvil, the local Ethereum network from Foundry.

✅ Goal:

You want your existing MetaMask connect-wallet system to work with Anvil, the local Ethereum network from Foundry.

🧠 What Happens by Default?

✅ Step-by-Step: Connect MetaMask to Anvil

2. Add Anvil Network to MetaMask

Field Value

3. Import Anvil Account into MetaMask

# Getting Started with Cursor AI

Getting Started with Cursor AI

Basic Commands

Code Generation Tips

Best Practices

Code Review Features

Troubleshooting

Tips for Better Results

Keyboard Shortcuts

How To Get The Best Results from Cursor AI

Python pip installation problem

PIP vs OneDrive: A Permission Battle!

Tahzib Mahmud Rifat ・ Feb 9 '25

Optimizing Storage Layout with Solidity Struct Clustering

what is solidity struct clustering?

solidity #smartcontract #blockchain #web3 #ethereum #security #struct #gasoptimization

PIP vs OneDrive: A Permission Battle!

ERROR of python

In the PyCharm terminal

Docker for Node.js Developers: A DevOps Guide to Efficient Deployment

Introduction

Creating custom image and Docker file

Create Container

Deleting State Volumes

Docker Compose

Dockerfile vs Docker compose

Development vs Production configs

Adding a mongo container

Communication between containers

Adding config.js

Container bootup order

Building a CRUD application

postController.js

postModel.js

postRoutes.js

Inserting data to database

Sign up and Login

Cells with Odd Values in a Matrix(LeetCode-easy)

INTRODUCTION

Examples

Hints

Steps

Java Code

Output

Docker for Beginners (Windows)

What is Docker

Before

After

Application deployment

What is a container

Lets install Postgres:9.6

Difference between Image and Container

Difference between Docker and Virtual machine

Basic Docker commands

Installing redis image

2. What Really Happens When You Write `import`

5. Foundry Remappings: Why `@openzeppelin/` Works