DEV Community: Mujahida Joynab

Linux Commands

Mujahida Joynab — Thu, 20 Aug 2026 16:17:40 +0000

1. `mkdir --help`

Meaning: Shows help for mkdir command

Description: Displays all options and usage rules for creating directories.

2. `clear`

Meaning: Cleans the terminal

Description: Removes all previous output from the terminal screen.

3. `alias c=clear`

Meaning: Creates a shortcut for clear

Description: After this, typing c and pressing Enter will clear the terminal.

4. `/etc/shadow`

Meaning: Stores user passwords

Description: Every hacker wants to access this file because it contains all encrypted passwords.

5. `/etc/passwd`

Meaning: Stores user information

Description: Contains username, UID, GID, home directory, and shell.

6. `/etc/group`

Meaning: Stores group information

Description: Contains group names, GIDs, and group members.

7. `tail -3 /etc/shadow`

Meaning: Shows last 3 lines of shadow file

Description: Displays password info of the last 3 users.

8. `head -3 /etc/shadow`

Meaning: Shows first 3 lines of shadow file

Description: Displays password info of the first 3 users.

9. `cat /etc/group`

Meaning: Shows all groups

Description: Displays all group information and members.

10. `cat /etc/passwd`

Meaning: Shows all users

Description: Displays all user account information.

11. `cat /etc/shadow`

Meaning: Shows passwords of all users

Description: Displays encrypted passwords and password policy details.

12. `whoami`

Meaning: Shows current user

Description: Tells you which user you are currently logged in as.

13. `pwd`

Meaning: Shows current folder

Description: Tells you which directory you are currently in.

14. `useradd --help`

Meaning: Shows help for useradd

Description: Displays all options and rules for creating a new user.

15. `useradd kamal`

Meaning: Creates a new user named kamal

Description: Creates a user account and a group named kamal.

16. `passwd kamal`

Meaning: Sets password for user kamal

Description: Used to set or change the login password for a user.

17. `sudo`

Meaning: Run command as superuser

Description: Means "on behalf of the superuser." Not needed if you are already root.

18. `usermod -s /sbin/nologin kamal`

Meaning: Blocks login for kamal

Description: Changes the user's shell to nologin so they cannot log in.

19. `usermod -s /bin/bash kamal`

Meaning: Unblocks login for kamal

Description: Restores the bash shell so the user can log in again.

20. `history`

Meaning: Shows previously used commands

Description: Displays a list of commands you have run earlier.

21. `su kamal`

Meaning: Switch to user kamal

Description: Logs in or switches to the kamal user account.

22. `exit`

Meaning: Ends current session

Description: Closes shell, returns to previous user, or closes terminal.

23. `usermod -L kamal`

Meaning: Locks kamal account

Description: Locks the user account by adding ! to the password.

24. `usermod -U kamal`

Meaning: Unlocks kamal account

Description: Unlocks the user account by removing ! from the password.

25. `usermod -e 2026-08-27 kamal`

Meaning: Sets expiry date for kamal

Description: Account will automatically expire on the given date.

Key Concepts

Group Explanation:

A group is like a WhatsApp group. If you send a message, all members see it. In Linux, you give permissions (read, write, or both) to a group, and all members get that access.

User Creation Rules:

When you create a user, a group with the same name is automatically created.
User IDs (UID) start from 1000 by default.

Password Status in `/etc/shadow`:

Password set → shows encrypted text
No password → shows ! (account locked)

Shell:

A program that:

Takes user commands
Tells computer to execute them
Shows results
Acts as an interface between user and operating system

Service Users:

Every service in Linux runs as a user.

Quick Reference Table

Command	কাজ
`mkdir --help`	mkdir-এর help দেখায়
`clear`	Terminal পরিষ্কার করে
`alias c=clear`	Shortcut তৈরি করে
`/etc/shadow`	Password থাকে
`/etc/passwd`	User info থাকে
`/etc/group`	Group info থাকে
`tail -3 /etc/shadow`	Last 3 lines দেখায়
`head -3 /etc/shadow`	First 3 lines দেখায়
`cat /etc/group`	সব group দেখায়
`cat /etc/passwd`	সব user দেখায়
`cat /etc/shadow`	সব password দেখায়
`whoami`	Current user দেখায়
`pwd`	Current folder দেখায়
`useradd --help`	useradd-এর help দেখায়
`useradd kamal`	নতুন user তৈরি করে
`passwd kamal`	Password set করে
`sudo`	Super user হিসেবে চালায়
`usermod -s /sbin/nologin kamal`	Login বন্ধ করে
`usermod -s /bin/bash kamal`	Login চালু করে
`history`	আগের commands দেখায়
`su kamal`	kamal user-এ switch করে
`exit`	Session বন্ধ করে
`usermod -L kamal`	Account lock করে
`usermod -U kamal`	Account unlock করে
`usermod -e DATE kamal`	Expire date set করে

Sense of Data: Histograms, Bell Curves, and Beyond

Mujahida Joynab — Thu, 20 Aug 2026 14:22:18 +0000

When a histogram is too wide or too narrow, it becomes less useful for understanding the data.

Both histograms and curves are types of distributions—they show us the probability of measurements.

Collecting data and plotting it on a graph gives us a histogram.
Extracting insights from that graph gives us a distribution.

Example:

Imagine we collect the heights of all our classmates and plot them on a graph. That graph is the histogram.

Then, we analyze that graph to find insights, such as:

What is the tallest height?
What is the shortest height?
What is the average height?
Which height does no one have?
What is the probability of a classmate being exactly 5 feet tall?

Finding these answers and understanding the overall pattern of the data is what we call the distribution.

Normal Distribution

The Gaussian distribution, also known as the Normal Distribution, is shaped like a bell.

This bell shape occurs because most data points are clustered around the average, while only a few are much higher or lower. As a result, the middle of the graph is tall, and the two sides taper off—just like a bell.

If the data is tightly centered around the average, the bell becomes narrow. This indicates low variance.
If the data is spread out far from the average, the bell becomes wide. This indicates high variance.

Central Limit Theorem

If the histogram is not bell-shaped, we can take samples from different groups.

Then, we calculate the average of each group and create a new histogram using those averages.

By doing this, the resulting histogram will tend to form a bell-shaped curve.

This is known as the Central Limit Theorem.

Population: When the number of participants equals the total number of individuals we are studying, we refer to them as the population, and their characteristics are called population parameters.

Blockchain

Mujahida Joynab — Tue, 11 Aug 2026 23:54:56 +0000

Blockchain is a way of storing data in blocks, which are then linked together to form a chain essentially functioning as a database. It records details like who transferred currency to whom, ensuring that the same currency cannot be spent twice.

Think of blockchain as a digital ledger. Now, what if someone tries to create a fake ledger? Since this false ledger would be much smaller than the legitimate one because it’s fabricated on the spot—no one in the network would accept or use it.

At the end of every page (or block) of transactions, a unique hash number is generated. In a blockchain, if one previous hash is altered, it does not automatically change all the previous hashes in the chain.

Linux Commands

Mujahida Joynab — Tue, 11 Aug 2026 23:42:47 +0000

Navigate — Use cd to move around; cd / goes to root, just cd goes home, and cd /etc/audit jumps straight to that folder.

Look around — Use ls -l (or ll) to see detailed file lists; add --help to any command when stuck (like ls --help).

Create things — mkdir folder_name makes a directory, touch file.txt makes an empty file, and vim or nano edits files.

Configure the system — The /etc/ directory holds all config files; for example, change SSH port in /etc/ssh/sshd_config for better security.

Remember superpowers — Always use sudo before editing system files (like sudo vim /etc/ssh/sshd_config) to act as admin.

Network Address Translation

Mujahida Joynab — Fri, 10 Apr 2026 05:33:55 +0000

NET is used due to insufficient number of IPv4 address for all internet connected device .
How NAT Works

NAT usually lives inside your Router. Here is how it handles your data:
The Request: You sit at your laptop (Private IP: 192.168.1.5) and request to see google.com.
The Translation: Your router receives this request. It knows 192.168.1.5 cannot travel on the public internet. It "translates" your private address into the router's Public IP (e.g., 203.0.113.10).
The Table: The router makes a note in its NAT Translation Table. It records which private device requested which website and through which "Port."
The Response: Google sends the data back to your Public IP. The router checks its table, sees the data is meant for your laptop, and passes it back to 192.168.1.5.

Types of NAT
There are three main ways NAT is implemented:
Static NAT: Maps one private IP to one public IP. Usually used for servers inside a network that need to be accessed from the outside.
Dynamic NAT: Maps a private IP to a public IP from a group (pool) of available public IPs.
PAT (Port Address Translation): Also known as NAT Overload. This is what you use at home! It allows thousands of devices to share one public IP by assigning each device a unique "Port Number."

The Benefits of NAT
IP Conservation: We don't need a unique public IP for every single smartphone and tablet on Earth.
Security: NAT acts as a natural firewall. Since your private IP is hidden, hackers on the internet cannot see your device directly; they only see your router's public address.
Flexibility: You can change your internal network setup (add or remove devices) without having to request new IP addresses from your ISP.

Private IP Addresses

Mujahida Joynab — Fri, 10 Apr 2026 01:39:57 +0000

Private IP address are unique within a Local Area Network . It can connected through router using Network Address Translation(NAT) . Private IP addresses range
10.0.0.0 - 10.255.255.255 ; which is class A
172.16.0.0 - 172.31.255.255 ; which is class B
192.168.0.0 - 192.168.255.255 ; which is class C

Subnet mask

Mujahida Joynab — Mon, 02 Mar 2026 14:58:44 +0000

We understand by subnet mask that which bits are fixed and which bits are changeable (host portion).
Example - 192.168.1.0/24
Here first 24 bits are fixed .
Total Bit = 32
Rest = 32 - 24 = 8
and 2^8 - 2 = 254 are changable

Why 2 are subtracted ?
Because 0 and 255 are researved

0 = Network Address (Reserved )(All host bit 0)
Example: 192.168.1.0

255= Broadcast Address (All host bit 1)
Example: 192.168.1.255

Usable IP range: 192.168.1.1 to 192.168.1.254 (254 addresses)

Rectified Linear Unit

Mujahida Joynab — Fri, 13 Feb 2026 14:57:29 +0000

ReLU is the most popular activation function in deep learning because it’s super simple and makes AI learn much faster.

What it does (main point):

Positive input? → Passes it exactly as is to the next layer
Negative or zero input? → Outputs 0 (blocks it, nothing passes)

ReLU(x) = max(0, x)

Why this makes AI learn fast:

No "squashing" like old functions (Sigmoid/Tanh) → gradients don’t vanish
Very fast to compute (just check if > 0)
Many neurons turn off (output 0) → less work, faster training

Quick comparison:

Sigmoid → slow, vanishing gradient
Tanh → better but still slow
ReLU → fast, no vanishing gradient (for positive values)

That's why almost every modern neural network (CNNs, Transformers, etc.) uses ReLU by default.

One small issue: Sometimes neurons "die" (always output 0 and stop learning).

Solution: Use Leaky ReLU or similar if needed.

Main thing in one line:

ReLU lets only positive signals pass through fully and blocks negative ones → this simple rule makes deep learning train fast and powerful.

Softmax Function

Mujahida Joynab — Fri, 13 Feb 2026 14:06:41 +0000

Softmax = a simple trick that turns scores into probabilities (numbers between 0 and 1 that add up to exactly 1).

Imagine you are waiting for Bus 49 and want to guess:

Will there be lots of empty seats?
Will there be only a few empty seats?
Will there be no empty seats at all?

We give each situation a “happiness score”:

Lots of empty seats → score 3 (yay! ❤️)
Few empty seats → score 2 (okay 😐)
No empty seats → score 1 (ugh 😩)

Now softmax magic happens in just two steps:

Step 1: Make each score much bigger using exponential (e^score). This makes good things really stand out!

e³ ≈ 20
e² ≈ 7
e¹ ≈ 3

(We use easy round numbers here — actual values are 20.1, 7.4, 2.7, but close enough!)

Step 2: Add them up and divide to get probabilities.

Total = 20 + 7 + 3 = 30

Now the chances are:

Lots of empty seats → 20 / 30 = ⅔ ≈ 67%
Few empty seats → 7 / 30 ≈ 23%
No empty seats → 3 / 30 = 10%

→ 67% + 23% + 10% = 100% ✓

That’s it! Softmax just says:

“Turn your scores into chances — the better score gets much more chance, but everyone still gets something, and it all adds to 100%.”

The Tiny Formula (you can almost remember it)

For any score z:

probability = eᶻ / (sum of e for all scores)

That’s why in apps, games, or AI models (like ChatGPT choosing the next word), the final answer often comes from softmax — it picks the most likely thing, but softly, with percentages.

What is an Expert System?

Mujahida Joynab — Sat, 13 Dec 2025 05:50:51 +0000

Imagine you have a super-smart robot doctor inside a computer. That's kind of what an Expert System is! It's a computer program that knows a lot about something special and can help make decisions—just like a human expert would.

🧠 How Does It Work? Think of It Like This:

An Expert System has two main parts:

1. The Knowledge Base - The "Brain Library" 📚

This is where all the expert knowledge is stored!

Facts: Simple truths like:
- "My temperature is 103°F" 🌡️
- "I have a headache" 🤕
Rules: "If-Then" instructions that connect facts, like:
- IF temperature > 100°F AND headache = yes
- THEN disease might be fever

2. The Inference Engine - The "Thinking Machine" ⚙️

This is the problem-solver that uses the knowledge base to figure things out! It works in two cool ways:

🔍 Forward Chaining: Starting with facts to reach a conclusion

Facts → "I have high temperature" + "I have headache"
        ↓
    Thinking... 🤔
        ↓
Conclusion → "You might have fever!"

🔍 Backward Chaining: Starting with a goal and checking facts

Goal → "Do I have fever?"
        ↓
    What facts do I need? 🤔
        ↓
Check → Do I have high temperature? Yes!
        Do I have headache? Yes!
        ↓
Conclusion → "Yes, you might have fever!"

🌟 Real-Life Examples You Might Know:

Medical Help: Some computer programs help doctors figure out what illness you might have.

Farm Help: Programs that help farmers know when to water plants or what fertilizer to use.

🛠️ How Do People Make Expert Systems?

Expert System Shells: These are like ready-made toolkits! Programmers add the specific knowledge they need. Some popular ones are:

CLIPS
Jess

📝 Three Main Ways to Store Knowledge:

If-Then Rules: Like a recipe book of decisions
Decision Trees: Like a choose-your-own-adventure book
Frames: Like organized file folders with information

🔍 Why Are They So Careful?

Good expert systems include:

Validation: Making sure the information is correct ✅
Explanation: Being able to explain why they made a decision (Example: "I think you have fever because your temperature is high and you have a headache")
Data Sensitivity: Being careful with private information 🔒

💡 Fun Fact:

There's an expert system called PITUMBERG (you might have meant "PITUBERG" or similar) that shows how these systems can help in specific fields!

✨ In a Nutshell:

Expert Systems = Knowledge Base (what it knows) + Inference Engine (how it thinks)

They help doctors, farmers, engineers, and many others make smart decisions by combining lots of knowledge with logical rules—just like a very helpful robot friend! 🤖💖

Next time you play a detective game or solve a puzzle, remember—you're thinking a bit like an expert system too!

A Complete Guide to Evidence Fusion and Risk Assessment Using Sequential Combination

Mujahida Joynab — Sat, 13 Dec 2025 05:21:55 +0000

Introduction

In decision-making systems, particularly in risk assessment and analysis, we often face the challenge of combining multiple pieces of evidence into a unified perspective. This blog explores an elegant sequential combination method for fusing evidence values (like 100, 1000, or any number of inputs) to determine risk probabilities across multiple categories—from "Very Very Low" to "Very Very High" risk.

The Core Methodology: Sequential Evidence Fusion

The Sequential Combination Formula

The heart of our approach lies in sequentially combining evidence using a weighted fusion method:

Start with the first two evidence values (m₁ and m₂)
Combine them into a single value (C₁)
Take this combined value and fuse it with the third evidence (m₃) to get C₂
Continue this process: Cₙ = fuse(Cₙ₋₁, mₙ₊₁)
Repeat until all evidence is incorporated

This incremental approach allows the system to naturally weigh evidence as it accumulates, creating a dynamic assessment that evolves with each new piece of information.

Mathematical Foundation

The combination formula typically follows a pattern that might look like:

C_k = α·C_{k-1} + β·m_k + γ·(C_{k-1}·m_k)

Where coefficients α, β, and γ are tuned based on:

Evidence reliability
Temporal relevance (if evidence is time-stamped)
Domain-specific importance factors

Normalization: The 1-k Factor

After sequential combination, we apply normalization to ensure our final value falls within a consistent range (typically 0 to 1):

Normalized Value = 1 - k · (some transformation of combined evidence)

Or more generally:

Normalized Score = 1 - f(combined_evidence)

This normalization ensures that higher combined evidence values correspond to higher risk levels, properly scaled for interpretation.

Risk Categorization Framework

Our system classifies risk into 11 distinct categories for granular assessment:

Risk Level	Typical Probability Range	Description
Very Very Low	0-9%	Minimal to negligible risk
Very Low	10-19%	Low probability of adverse outcomes
Low	20-29%	Below average risk
Very Very Medium	30-39%	Lower medium risk
Very Medium	40-49%	Medium-low risk
Medium	50-59%	Average/expected risk level
High Medium	60-69%	Medium-high risk
High	70-79%	Elevated risk requiring attention
Very High	80-89%	Significantly elevated risk
Very Very High	90-100%	Critical risk requiring immediate action

Practical Implementation: From Excel to Actionable Insights

Step 1: Data Preparation

Evidence values stored in Excel (or CSV) format are loaded into the system. These could represent:

Financial transaction amounts
Security alert scores
Medical test results
Quality control measurements
Any numerical evidence relevant to risk assessment

Step 2: Sequential Combination Process

def sequential_combine(evidence_list, alpha=0.4, beta=0.4, gamma=0.2):
    """
    Sequentially combine evidence using weighted fusion
    """
    if len(evidence_list) < 2:
        return evidence_list[0] if evidence_list else 0

    # Normalize evidence to [0,1] range first
    normalized_evidence = [normalize(e) for e in evidence_list]

    # Start with first two pieces of evidence
    combined = alpha*normalized_evidence[0] + beta*normalized_evidence[1] + gamma*(normalized_evidence[0]*normalized_evidence[1])

    # Sequentially combine with remaining evidence
    for i in range(2, len(normalized_evidence)):
        combined = alpha*combined + beta*normalized_evidence[i] + gamma*(combined*normalized_evidence[i])

    return combined

Step 3: Risk Probability Calculation

def calculate_risk_probabilities(combined_score):
    """
    Convert combined score into risk category probabilities
    """
    # This could use a softmax distribution across categories
    # or a Bayesian approach based on historical data
    risk_categories = ["Very Very Low", "Very Low", "Low", 
                      "Very Very Medium", "Very Medium", "Medium",
                      "High Medium", "High", "Very High", "Very Very High"]

    # Generate probabilities (example using transformed sigmoid)
    base_prob = sigmoid_transform(combined_score)

    # Distribute probabilities across categories
    # (Implementation depends on specific distribution model)
    return category_probabilities

Synthetic Data Generation

For testing and validation, we can generate synthetic evidence data:

import numpy as np
import pandas as pd

def generate_synthetic_evidence(num_samples=1000, num_evidence_points=50):
    """
    Generate realistic synthetic evidence data
    """
    data = []

    for _ in range(num_samples):
        # Generate evidence with different patterns
        pattern_type = np.random.choice(['random', 'trending_up', 'trending_down', 'spiky'])

        if pattern_type == 'random':
            evidence = np.random.uniform(0, 1000, num_evidence_points)
        elif pattern_type == 'trending_up':
            base = np.random.uniform(0, 500, num_evidence_points)
            trend = np.linspace(0, 500, num_evidence_points)
            evidence = base + trend
        elif pattern_type == 'trending_down':
            base = np.random.uniform(0, 500, num_evidence_points)
            trend = np.linspace(500, 0, num_evidence_points)
            evidence = base + trend
        else:  # spiky
            evidence = np.random.exponential(200, num_evidence_points)
            spikes = np.random.choice([0, 1], num_evidence_points, p=[0.9, 0.1])
            evidence = evidence * (1 + spikes * np.random.uniform(1, 5, num_evidence_points))

        data.append(evidence)

    return pd.DataFrame(data)

Real-World Applications

1. Financial Fraud Detection

Combine multiple transaction alerts (amount, frequency, location mismatch) into a unified risk score.

2. Healthcare Diagnostics

Fuse various test results and symptoms to assess disease probability.

3. Cybersecurity Threat Assessment

Combine network anomalies, failed login attempts, and suspicious file activities into a comprehensive threat level.

4. Quality Control in Manufacturing

Fuse multiple sensor readings from production lines to predict defect probability.

Advantages of Sequential Combination

Incremental Updates: New evidence can be added without reprocessing all historical data
Computational Efficiency: O(n) complexity for n evidence points
Interpretability: Each combination step can be logged and analyzed
Adaptability: Weights can be adjusted based on evidence reliability
Memory Efficiency: Only need to store the current combined value, not all historical evidence

Challenges and Considerations

Order Sensitivity: Sequential combination may be order-dependent
Weight Calibration: Optimal α, β, γ values require careful tuning
Normalization Consistency: Ensuring consistent scaling across different evidence types
Category Thresholds: Defining clear boundaries between risk levels

Conclusion

The sequential evidence fusion approach provides a robust, scalable framework for combining thousands of evidence points into coherent risk assessments. By normalizing results and distributing probabilities across granular risk categories (from "Very Very Low" to "Very Very High"), decision-makers gain nuanced insights that support better risk management decisions.

Whether you're working with 100 or 100,000 evidence points in Excel, this methodology transforms raw data into actionable intelligence, enabling organizations to make informed decisions in uncertain environments.

Key Takeaway: The power of this approach lies not in any single piece of evidence, but in the sophisticated fusion of all available information, progressively refined through sequential combination to reveal the true underlying risk profile.

CSS

Mujahida Joynab — Sat, 22 Nov 2025 12:08:39 +0000

Font -> Google font
Icon -> Font Awesome cdn
For Responsiveness

flex-wrap : wrap

Hello Banner

Lorem ipsum

DEV Community: Mujahida Joynab

Linux Commands

1. mkdir --help

2. clear

3. alias c=clear

4. /etc/shadow

5. /etc/passwd

6. /etc/group

7. tail -3 /etc/shadow

8. head -3 /etc/shadow

9. cat /etc/group

10. cat /etc/passwd

11. cat /etc/shadow

12. whoami

13. pwd

14. useradd --help

15. useradd kamal

16. passwd kamal

17. sudo

18. usermod -s /sbin/nologin kamal

19. usermod -s /bin/bash kamal

20. history

21. su kamal

22. exit

23. usermod -L kamal

24. usermod -U kamal

25. usermod -e 2026-08-27 kamal

Key Concepts

Group Explanation:

User Creation Rules:

Password Status in /etc/shadow:

Shell:

Service Users:

Quick Reference Table

Sense of Data: Histograms, Bell Curves, and Beyond

Normal Distribution

Central Limit Theorem

Blockchain

Linux Commands

Network Address Translation

Private IP Addresses

Subnet mask

Rectified Linear Unit

Softmax Function

The Tiny Formula (you can almost remember it)

What is an Expert System?

🧠 How Does It Work? Think of It Like This:

1. The Knowledge Base - The "Brain Library" 📚

2. The Inference Engine - The "Thinking Machine" ⚙️

🌟 Real-Life Examples You Might Know:

🛠️ How Do People Make Expert Systems?

📝 Three Main Ways to Store Knowledge:

🔍 Why Are They So Careful?

💡 Fun Fact:

✨ In a Nutshell:

A Complete Guide to Evidence Fusion and Risk Assessment Using Sequential Combination

Introduction

The Core Methodology: Sequential Evidence Fusion

The Sequential Combination Formula

Mathematical Foundation

Normalization: The 1-k Factor

Risk Categorization Framework

Practical Implementation: From Excel to Actionable Insights

Step 1: Data Preparation

Step 2: Sequential Combination Process

Step 3: Risk Probability Calculation

Synthetic Data Generation

Real-World Applications

1. Financial Fraud Detection

2. Healthcare Diagnostics

3. Cybersecurity Threat Assessment

4. Quality Control in Manufacturing

Advantages of Sequential Combination

Challenges and Considerations

Conclusion

CSS

Hello Banner

1. `mkdir --help`

2. `clear`

3. `alias c=clear`

4. `/etc/shadow`

5. `/etc/passwd`

6. `/etc/group`

7. `tail -3 /etc/shadow`

8. `head -3 /etc/shadow`

9. `cat /etc/group`

10. `cat /etc/passwd`

11. `cat /etc/shadow`

12. `whoami`

13. `pwd`

14. `useradd --help`

15. `useradd kamal`

16. `passwd kamal`

17. `sudo`

18. `usermod -s /sbin/nologin kamal`

19. `usermod -s /bin/bash kamal`

20. `history`

21. `su kamal`

22. `exit`

23. `usermod -L kamal`

24. `usermod -U kamal`

25. `usermod -e 2026-08-27 kamal`

Password Status in `/etc/shadow`: