Familiarization of basic Linux Commands- time and write

time command 

The time command in Linux is a simple yet powerful tool used to measure how long a program or command takes to execute. It provides details about the real time, user CPU time, and system CPU time used by the process.

What is the time Command?

• Purpose: To measure the execution time of commands or programs.
• Output: Gives you three important metrics:
  1. Real Time: Total elapsed time from start to finish (wall-clock time).
  2. User Time: Time spent executing the program in user mode (on the CPU).
  3. System Time: Time spent on system-level tasks (like input/output operations).

Think of it as a stopwatch for your commands!

Syntax

    time [options] command

Replace command with the command or program you want to measure.

No special permissions are required to use time.

Key Metrics Explained

Here’s what the three metrics mean in detail:

Metric	Description
Real Time	Total time it took for the command to complete, including waiting for resources (disk, network, etc.).
User Time	CPU time spent running the program's instructions in user mode (e.g., calculations, data processing).
System Time	CPU time spent on system tasks like file I/O, memory management, or kernel-level operations.

Using the time Command 

1. Basic Example 

To measure the execution time of a command, prepend it with time.

    time ls

output

real    0m0.003s

user    0m0.001s

sys     0m0.002s

Explanation:

• real: The command took 0.003 seconds to complete.
• user: The CPU spent 0.001 seconds processing the ls command.
• sys: The CPU spent 0.002 seconds handling system calls.

2. Measure a Script's Execution Time

Let’s say you have a script called myscript.sh. To see how long it takes to run, use:

    time ./myscript.sh

The output will show how long the script took to execute and how much CPU time it consumed.

3. Measure Commands with Options

You can use time with any Linux command and its options. For example:

    time find / -name "*.txt"

This command measures how long it takes to search the entire file system for .txt files.

Adding More Details with the -v Option

The -v option (verbose mode) provides additional statistics like:

• Maximum memory used.
• Number of page faults (memory-related operations).
• Voluntary and involuntary context switches.

Example:

    /usr/bin/time -v ls

            Command being timed: "ls"

        User time (seconds): 0.001

        System time (seconds): 0.002

        Percent of CPU this job got: 100%

        Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.003

        Maximum resident set size (kbytes): 512

        Voluntary context switches: 2

        Involuntary context switches: 1

Practical Use Cases

1. Compare Performance

Use time to compare the performance of different commands or scripts. For example:

time sort largefile.txt

time sort --parallel=4 largefile.txt

You can see how parallel processing improves execution time.

2. Measure Script Efficiency

If you write scripts, use time to analyze how efficiently they run and optimize them if necessary.

Using the which time Command

There are two types of time:

1. Built-in Shell Command: Part of most shells (e.g., Bash).
2. Binary Command: Installed as /usr/bin/time with advanced options like -v.

To check which one you’re using, run:

    which time

Real-World Example

Let’s say you want to download a file using wget and measure how long it takes:

    time wget http://example.com/largefile.zip

real    1m12.456s

user    0m0.567s

sys     0m1.234s

Explanation:

• It took 1 minute 12.456 seconds in total (real time).
• The CPU spent 0.567 seconds on user tasks.
• The CPU spent 1.234 seconds on system-level operations like networking.

Conclusion

The time command is an excellent tool for beginners to understand the efficiency of their commands and scripts. It helps you optimize performance, debug issues, and gain insights into system resource usage.

write command

The write command in Linux allows you to send a message directly to another user's terminal. Think of it as a basic way to "chat" with someone logged into the same system.(server)

What Does the write Command Do?

• The write command sends a real-time message to another user.
• Both the sender and receiver must be logged into the same system.
• The message is displayed directly on the receiver's terminal.

It’s like tapping someone on the shoulder in the digital world.

Syntax

    write username [tty]

• username: The name of the user you want to send the message to.
• tty (optional): Specifies the exact terminal session of the user (useful if the user has multiple sessions open).

How to Use the write Command

1. Basic Usage

To send a message to another user:

write binu

After typing this command, you can start typing your message. When done, press Ctrl+D to send the message and exit.

The message will immediately appear on binu’s terminal if he’s logged in.

2. Specifying the Terminal (tty)

If a user has multiple sessions (terminals) open, you might need to specify which one to send the message to. You can find the terminal details using the who command.

    who

Checking if Messaging is Enabled

The recipient must allow messages to be sent to their terminal. By default, messaging is enabled. If it's disabled, the sender will see:

write: binu has messages disabled

Enabling Messages

The user can enable messaging using:

    mesg y

Disabling Messages

To block messages:

    mesg n

When to Use the write Command?

• Communicating with users logged into the same system.
• Quickly sending messages without the need for external chat applications.
• Useful in multi-user systems, especially on servers.

Limitations of the write Command

1. Same System: It works only if both users are logged into the same system.
2. Real-Time Only: The message is displayed in real-time and cannot be saved.
3. No Privacy: If someone is watching the recipient’s terminal, they can see the message too.

Conclusion

The write command is a straightforward and quick way to communicate with other users on the same system. While it’s a bit old-fashioned compared to modern messaging apps, it’s still handy in multi-user environments or for troubleshooting on servers.