DEV Community: Rita Kairu

Don't Run That Code! Your Guide to Staying Safe from Job Scams with Virtual Machines

Rita Kairu — Thu, 16 Oct 2025 08:59:13 +0000

The digital world is on high alert. There’s been a noticeable surge in cyberattacks targeting jobseekers, LinkedIn users, and people hanging out on platforms like Discord.

These aren’t your average “click this suspicious link” scams. They’re full-on social engineering traps—crafted to convince you to run code or install something that quietly takes over your digital life.

Once you take the bait, the attackers can steal everything—your crypto wallets, personal files, passwords, and even your identity.

Inside the Mind of a Modern Hacker

Original source: X (formerly Twitter)

A recent post on x exposed one of these real, live attacks. The payload as described, was “obfuscated, sneaky, and pure evil” a code so well-hidden that it blended perfectly with legitimate admin functions on a server.

Here’s the scary part: it was active. The moment someone accessed those admin routes, the code would execute with full system privileges.

After decoding the payload, he discovered that it was designed to steal everything—crypto wallets, files, passwords—your entire digital existence.

Even more disturbing, the scammers were strategic such that the infected URL vanished exactly 24 after hours, leaving no trace behind. That kind of disappearing infrastructure isn’t random, it’s intentional, designed to wipe evidence before anyone can investigate.

Bottom line: if you download code or files from an unknown source, assume it’s dangerous until proven otherwise.

How to Protect Yourself: Run Suspicious Code in Isolation

If you ever come across code that looks shady but you still want to analyze it or confirm if it’s safe. Don’t run it directly on your main computer.
That’s what sandboxing and virtualization are for.

A Virtual Machine (VM) or sandbox is like a digital quarantine zone. You can test the suspicious code there safely, without risking your actual files, crypto keys, or system.

Reliable Tools for Safe Testing

Tool	Ideal For	Why It’s Safe
Windows Sandbox	Windows users who want a quick, disposable test space.	Comes built-in with Windows Pro/Enterprise. Creates a clean, temporary OS that wipes itself when closed.
Oracle VM VirtualBox	Anyone wanting more control and free cross-platform use.	Lets you create snapshots—so you can restore your VM to a clean state instantly.
VMware Workstation Player	Users needing top performance and security.	Strong isolation and great performance (free for personal use).

Virtual Machine Safety Tips

A VM is great, but you have to set it up right to keep yourself safe:

Turn off sharing: Disable all Shared Folders and Clipboard Sharing between your real computer and the VM.

Disconnect the internet wherever possible: Use "Host-Only" mode or disable your network entirely.

Stay Anonymous: Don't log into your real accounts or wallets inside the VM.

You can learn more about VM Safety Configuration in this article.

In today’s world of clever cyberattacks, it's okay to be paranoid. Your digital safety comes first.
If someone online asks you to run their code, the safest response is simple: don’t.
But if you absolutely must, do it inside a tightly locked-down, isolated environment.

Because once malware gets out, reclaiming your digital life isn’t easy.

VM Safety Configuration: A Developer's Guide

Rita Kairu — Thu, 16 Oct 2025 08:57:41 +0000

Virtual machines are essential tools for testing untrusted code, analyzing malware, or experimenting with potentially dangerous software. However, a VM is only as safe as its configuration. This guide provides practical examples for hardening your VM setup across popular platforms.

Why VM Safety Matters

A misconfigured VM can compromise your host system through:

Shared resources (folders, clipboard) that create data bridges
Network connections that allow lateral movement
VM escape vulnerabilities in shared services
Accidental credential exposure through auto-login features

1. Disable Shared Folders

Shared folders create a direct bridge between your host and guest systems. Disabling them prevents malware from accessing your real files.

VirtualBox

Via GUI:

1. Select VM → Settings → Shared Folders
2. Remove all shared folder entries
3. Uncheck "Auto-mount" if present

Via Command Line:

# List all shared folders
VBoxManage showvminfo "YourVMName" | grep "Shared folders"

# Remove a specific shared folder
VBoxManage sharedfolder remove "YourVMName" --name "SharedFolderName"

# Remove all shared folders (run for each listed folder)
VBoxManage sharedfolder remove "YourVMName" --name "folder1"
VBoxManage sharedfolder remove "YourVMName" --name "folder2"

VMware Workstation/Fusion

Via GUI:

1. VM → Settings → Options → Shared Folders
2. Select "Disabled"

Via .vmx Configuration File:

# Locate your VM's .vmx file and add/modify:
isolation.tools.hgfs.disable = "TRUE"
sharedFolder.maxNum = "0"

Hyper-V

Via PowerShell:

# Disable all shared folders for a VM
Get-VMIntegrationService -VMName "YourVMName" -Name "Guest Service Interface" | Disable-VMIntegrationService

# Verify it's disabled
Get-VMIntegrationService -VMName "YourVMName" | Select Name, Enabled

2. Disable Clipboard Sharing

The clipboard can leak sensitive data between host and guest, including passwords from password managers.

VirtualBox

Via GUI:

Settings → General → Advanced
- Shared Clipboard: Disabled
- Drag'n'Drop: Disabled

Via Command Line:

VBoxManage modifyvm "YourVMName" --clipboard-mode disabled
VBoxManage modifyvm "YourVMName" --draganddrop disabled

VMware

Via .vmx File:

isolation.tools.copy.disable = "TRUE"
isolation.tools.paste.disable = "TRUE"
isolation.tools.dnd.disable = "TRUE"

Verify Settings:

# On Linux/Mac
grep -i "isolation.tools" /path/to/your-vm.vmx

# On Windows PowerShell
Select-String -Path "C:\path\to\your-vm.vmx" -Pattern "isolation.tools"

Hyper-V

# Disable clipboard integration
Disable-VMIntegrationService -VMName "YourVMName" -Name "Guest Service Interface"

3. Network Isolation

Disconnecting the VM from the internet prevents malware from communicating with command-and-control servers or exfiltrating data.

VirtualBox - Host-Only Network

Setup Script:

#!/bin/bash
VM_NAME="SafetyVM"

# Create host-only network if it doesn't exist
VBoxManage hostonlyif create

# Configure the host-only adapter (usually vboxnet0)
VBoxManage hostonlyif ipconfig vboxnet0 --ip 192.168.56.1 --netmask 255.255.255.0

# Attach VM to host-only network
VBoxManage modifyvm "$VM_NAME" --nic1 hostonly
VBoxManage modifyvm "$VM_NAME" --hostonlyadapter1 vboxnet0

# Disable DHCP server on the host-only network (optional)
VBoxManage dhcpserver modify --netname HostInterfaceNetworking-vboxnet0 --disable

echo "VM configured for host-only networking"

Complete Disconnect:

# Disable all network adapters
VBoxManage modifyvm "YourVMName" --nic1 none
VBoxManage modifyvm "YourVMName" --nic2 none

VMware - Custom Network

Via GUI:

1. VM → Settings → Network Adapter
2. Select "Host-only" or "Custom" (then choose a host-only network)

Via .vmx File:

ethernet0.connectionType = "hostonly"
# Or completely disable:
ethernet0.present = "FALSE"

PowerShell Script for VMware:

# Set to host-only
& "C:\Program Files (x86)\VMware\VMware Workstation\vmrun.exe" `
  -T ws setNetworkAdapter "C:\path\to\vm.vmx" 0 hostonly

# Or disable entirely
& "C:\Program Files (x86)\VMware\VMware Workstation\vmrun.exe" `
  -T ws deleteNetworkAdapter "C:\path\to\vm.vmx" 0

Hyper-V - Internal Network

PowerShell Configuration:

# Create an internal switch (isolated from host)
New-VMSwitch -Name "IsolatedSwitch" -SwitchType Internal

# Connect VM to isolated switch
Get-VM "YourVMName" | Get-VMNetworkAdapter | Connect-VMNetworkAdapter -SwitchName "IsolatedSwitch"

# Or completely disconnect
Get-VM "YourVMName" | Get-VMNetworkAdapter | Disconnect-VMNetworkAdapter

4. Snapshot Management

Snapshots allow you to instantly restore a clean state, critical when testing potentially harmful software.

VirtualBox

Create Baseline Snapshot:

#!/bin/bash
VM_NAME="SafetyVM"
SNAPSHOT_NAME="Clean_Baseline_$(date +%Y%m%d)"

# Ensure VM is powered off
VBoxManage controlvm "$VM_NAME" poweroff 2>/dev/null
sleep 5

# Create snapshot
VBoxManage snapshot "$VM_NAME" take "$SNAPSHOT_NAME" \
  --description "Clean state before testing - $(date)"

echo "Snapshot created: $SNAPSHOT_NAME"

# List all snapshots
VBoxManage snapshot "$VM_NAME" list

Restore Snapshot:

#!/bin/bash
VM_NAME="SafetyVM"
SNAPSHOT_NAME="Clean_Baseline_20240101"

# Power off VM
VBoxManage controlvm "$VM_NAME" poweroff 2>/dev/null
sleep 5

# Restore snapshot
VBoxManage snapshot "$VM_NAME" restore "$SNAPSHOT_NAME"

echo "VM restored to: $SNAPSHOT_NAME"

Automated Test Cycle:

#!/bin/bash
VM_NAME="SafetyVM"
CLEAN_SNAPSHOT="Clean_Baseline"

function test_sample() {
    # Restore clean state
    VBoxManage controlvm "$VM_NAME" poweroff 2>/dev/null
    sleep 3
    VBoxManage snapshot "$VM_NAME" restore "$CLEAN_SNAPSHOT"

    # Start VM
    VBoxManage startvm "$VM_NAME" --type headless
    sleep 30

    # Your testing logic here
    # ...

    # Power off and restore again
    VBoxManage controlvm "$VM_NAME" poweroff
    sleep 3
    VBoxManage snapshot "$VM_NAME" restore "$CLEAN_SNAPSHOT"
}

# Test multiple samples
for sample in /path/to/samples/*; do
    echo "Testing: $sample"
    test_sample
done

VMware

PowerShell Script:

param(
    [string]$VMXPath = "C:\VMs\SafetyVM\SafetyVM.vmx",
    [string]$SnapshotName = "Clean_Baseline"
)

$vmrun = "C:\Program Files (x86)\VMware\VMware Workstation\vmrun.exe"

# Create snapshot
& $vmrun -T ws snapshot $VMXPath $SnapshotName

# Restore snapshot
& $vmrun -T ws revertToSnapshot $VMXPath $SnapshotName

# List snapshots
& $vmrun -T ws listSnapshots $VMXPath

Hyper-V

Checkpoint Management:

# Create checkpoint
$VMName = "SafetyVM"
$CheckpointName = "Clean_Baseline_$(Get-Date -Format 'yyyyMMdd_HHmmss')"

Checkpoint-VM -Name $VMName -SnapshotName $CheckpointName

# Restore checkpoint
Restore-VMCheckpoint -Name $CheckpointName -VMName $VMName -Confirm:$false

# List checkpoints
Get-VMCheckpoint -VMName $VMName | Select-Object Name, CreationTime

# Automated testing function
function Test-InVM {
    param(
        [string]$VMName,
        [string]$CleanCheckpoint
    )

    # Restore clean state
    Stop-VM -Name $VMName -Force -ErrorAction SilentlyContinue
    Start-Sleep -Seconds 5
    Restore-VMCheckpoint -Name $CleanCheckpoint -VMName $VMName -Confirm:$false

    # Start VM
    Start-VM -Name $VMName
    Start-Sleep -Seconds 30

    # Your testing here

    # Restore again
    Stop-VM -Name $VMName -Force
    Restore-VMCheckpoint -Name $CleanCheckpoint -VMName $VMName -Confirm:$false
}

5. Keep Personal Data Out

Prevent credential leakage through configuration and monitoring.

Disable Credential Managers

Windows VM:

# Disable Windows Credential Manager
reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation" /v "AllowDefCredentialsWhenNTLMOnly" /t REG_DWORD /d 0 /f

# Disable saved passwords in browsers (example for Chrome)
reg add "HKCU\Software\Policies\Google\Chrome" /v "PasswordManagerEnabled" /t REG_DWORD /d 0 /f

# Clear stored credentials
cmdkey /list | findstr "Target" | for /f "tokens=2 delims= " %i in ('more') do cmdkey /delete:%i

Linux VM:

#!/bin/bash
# Remove saved credentials
rm -rf ~/.gnome2/keyrings/*
rm -rf ~/.local/share/keyrings/*

# Clear browser profiles
rm -rf ~/.mozilla/firefox/*.default*/key*.db
rm -rf ~/.config/google-chrome/Default/Login\ Data

# Clear bash history
history -c
cat /dev/null > ~/.bash_history

Browser Configuration Script

Python Script for Fresh Browser:

#!/usr/bin/env python3
import os
import shutil
import platform

def sanitize_browsers():
    """Remove browser profiles and credentials"""

    system = platform.system()
    home = os.path.expanduser("~")

    paths_to_clear = []

    if system == "Windows":
        paths_to_clear = [
            os.path.join(os.getenv("APPDATA"), "Mozilla", "Firefox", "Profiles"),
            os.path.join(os.getenv("LOCALAPPDATA"), "Google", "Chrome", "User Data"),
            os.path.join(os.getenv("LOCALAPPDATA"), "Microsoft", "Edge", "User Data"),
        ]
    elif system == "Linux":
        paths_to_clear = [
            os.path.join(home, ".mozilla", "firefox"),
            os.path.join(home, ".config", "google-chrome"),
            os.path.join(home, ".config", "chromium"),
        ]

    for path in paths_to_clear:
        if os.path.exists(path):
            try:
                shutil.rmtree(path)
                print(f"Cleared: {path}")
            except Exception as e:
                print(f"Could not clear {path}: {e}")

if __name__ == "__main__":
    response = input("This will delete browser profiles. Continue? (yes/no): ")
    if response.lower() == "yes":
        sanitize_browsers()
        print("Browser data cleared. Fresh profiles will be created on next launch.")

Network Monitoring

Simple Traffic Monitor:

#!/usr/bin/env python3
"""
Monitor for suspicious outbound connections from VM
Run on host machine
"""
import subprocess
import re
from datetime import datetime

VM_IP_RANGE = "192.168.56.0/24"  # Adjust for your host-only network

def monitor_connections():
    """Watch for any internet-bound traffic from VM"""

    print(f"Monitoring VM network range: {VM_IP_RANGE}")
    print("Press Ctrl+C to stop\n")

    try:
        # Linux/Mac
        cmd = f"tcpdump -n 'src net {VM_IP_RANGE} and not dst net {VM_IP_RANGE}'"
        process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, 
                                   stderr=subprocess.PIPE, text=True)

        for line in process.stdout:
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            print(f"[{timestamp}] ALERT: {line.strip()}")

    except KeyboardInterrupt:
        print("\nMonitoring stopped")
    except Exception as e:
        print(f"Error: {e}")
        print("Note: This script requires tcpdump and root privileges")

if __name__ == "__main__":
    monitor_connections()

Complete VM Setup Script

All-in-One VirtualBox Configuration:

#!/bin/bash
# Complete VM safety setup for VirtualBox

VM_NAME="SafetyVM"
SNAPSHOT_NAME="Clean_Baseline"

echo "=== VM Safety Configuration ==="
echo "VM Name: $VM_NAME"
echo

# 1. Disable sharing
echo "[1/5] Disabling shared folders and clipboard..."
VBoxManage modifyvm "$VM_NAME" --clipboard-mode disabled
VBoxManage modifyvm "$VM_NAME" --draganddrop disabled

# Remove all shared folders
for folder in $(VBoxManage showvminfo "$VM_NAME" --machinereadable | grep SharedFolderName | cut -d'"' -f2); do
    VBoxManage sharedfolder remove "$VM_NAME" --name "$folder"
done

# 2. Isolate network
echo "[2/5] Configuring network isolation..."
VBoxManage modifyvm "$VM_NAME" --nic1 hostonly
VBoxManage modifyvm "$VM_NAME" --hostonlyadapter1 vboxnet0

# 3. Disable unnecessary features
echo "[3/5] Disabling unnecessary features..."
VBoxManage modifyvm "$VM_NAME" --usb off
VBoxManage modifyvm "$VM_NAME" --audio none

# 4. Create snapshot
echo "[4/5] Creating clean snapshot..."
VBoxManage controlvm "$VM_NAME" poweroff 2>/dev/null
sleep 5
VBoxManage snapshot "$VM_NAME" take "$SNAPSHOT_NAME" --description "Safe baseline configuration"

# 5. Verify configuration
echo "[5/5] Verifying configuration..."
echo
echo "=== Configuration Summary ==="
VBoxManage showvminfo "$VM_NAME" --machinereadable | grep -E "(clipboard|draganddrop|nic1|SharedFolder)" 
echo
echo "Snapshots:"
VBoxManage snapshot "$VM_NAME" list
echo
echo "✓ VM safety configuration complete"
echo "⚠ Remember: Never log into real accounts inside this VM"

Best Practices Checklist

Before testing any untrusted code:

[ ] All shared folders removed
[ ] Clipboard sharing disabled
[ ] Network set to host-only or disconnected
[ ] Clean snapshot created
[ ] Browser profiles cleared
[ ] No personal accounts logged in
[ ] Password managers disabled
[ ] VM host system is up-to-date
[ ] Antivirus on host is active
[ ] Backup of important host data exists

Conclusion

VM safety is about defense in depth. Each configuration layer adds protection against malware escaping the sandbox or stealing your data. Always assume the code you're testing is hostile, and never let convenience compromise security.

The few minutes spent configuring these settings properly can prevent hours of incident response—or worse, permanent data loss.

Comparing Modular and Input Handling in Python (With Code Examples)

Rita Kairu — Wed, 10 Jul 2024 14:02:49 +0000

I was working on a some problem sets in the CS50 programming with python course and got stuck while trying to understand the expected solution of a problem presented.

The prerequisite code was provided and the requirement was to add in functions that convert the input string to floating-point numbers representing the dollar amount.

Below are code snippets providing two different approaches to the problem.

The first snippet shows the section added by instructors. I was supposed to fill in the blanks in the dollar_to_float and percent_to_float functions.

The second one outlines my way of approaching the problem. It involved modifying the prerequisite code to get the expected results.

Code 1 (Original Code with Separate Functions)

def main():
    dollars = dollars_to_float(input("How much was the meal? "))
    percent = percent_to_float(input("What percentage would you like to tip? "))
    tip = dollars * percent
    print(f"Leave ${tip:.2f}")

def dollars_to_float(d):
    return float(d.replace("$", ""))

def percent_to_float(p):
    return float(p.replace("%", "")) / 100

main()

Code 2 (Simplified Code Without Separate Functions)

def main():
    dollars = float(input("How much was the meal? "))
    percent = float(input("What percentage would you like to tip? "))
    tip = dollars * percent / 100
    print(f"Leave ${tip:.2f}")

main()

What puzzled me is why the first approach was used, and whether it's a preferred coding practice among developers.

The results were the same, but the way of handling the solution was different based on the following differences:

Differences

Function Definitions:
- Code 1: Defines two separate functions, dollars_to_float and percent_to_float, to handle specific conversions.
- Code 2: Performs the conversions directly within the main function without using separate functions.
Input Handling:
- Code 1: Assumes the input may include currency ($) and percentage (%) symbols and handles their removal within the separate functions.
- Code 2: Assumes the input is a plain number without any symbols, directly converting the input string to a float.
Tip Calculation:
- Code 1: Multiplies the dollars by percent, where percent is already converted to a decimal.
- Code 2: Multiplies dollars by percent and then divides by 100 to convert the percentage to a decimal inline.

Pros & Cons: Which Method is Better and More Commonly Used?

Pros of Code 1:

Modularity: Breaking the conversion logic into separate functions (dollars_to_float and percent_to_float) makes the code more modular. Each function has a single responsibility, making it easier to test and maintain.
Reusability: The separate functions can be reused in other parts of the program if needed.
Clarity: The intent of the conversion is clearer. Each function name describes what it does, which can make the code easier to read and understand.

Pros of Code 2:

Simplicity: The code is simpler and shorter since it doesn't define extra functions. Everything is done inline within the main function.
Directness: The input and conversion logic are handled directly, which can be easier to follow for small scripts.

Common Practice:

Modularity and Clarity: In larger projects or where input handling is complex, Code 1's approach is preferred. It makes the codebase easier to manage and understand. Writing modular code with single-responsibility functions is a common best practice in programming.
Simplicity and Conciseness: For small scripts or when the input is straightforward (e.g., guaranteed to be plain numbers), Code 2's approach is often sufficient and commonly used due to its simplicity.

Conclusion:

I did a little research and learned that for small and straightforward scripts, handling input and conversions directly within the main function is common due to its simplicity and conciseness (code 2).
However, in larger or more complex applications, breaking the logic into separate functions enhances modularity, reusability, and clarity, making the codebase easier to manage and understand (code 1).

More About File Operations in C Including File Descriptors

Rita Kairu — Mon, 12 Feb 2024 10:40:33 +0000

Comprehensive Guide to File Operations and System Calls in C

File operations and system calls are fundamental aspects of programming in C, essential for managing files, performing I/O operations, and interacting with the underlying operating system.

This comprehensive guide will walk you through creating, opening, closing, reading, and writing files, along with the following:

File descriptors,
Standard file descriptors,
I/O system calls,
Flags,
File permissions,
System calls, and
The difference between functions and system calls.

Creating, Opening, Closing, Reading, and Writing Files

Creating and Opening Files:

In C, files are created and opened using the fopen() function provided by the standard library. The fopen() function takes a filename and a mode as arguments and returns a file pointer to the opened file.

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("example.txt", "w+"); // Opens or creates a file named example.txt in write mode
    if (fp == NULL) {
        printf("Error opening file!\n");
        return -1;
    }
    // File operations go here
    fclose(fp); // Close the file when done
    return 0;
}

Closing Files:

To close a file and release its resources, the fclose() function is used. It's essential to close files after performing operations to prevent resource leaks.

fclose(fp); // Close the file pointer 'fp'

Reading from Files:

Reading from files can be achieved using functions like fgetc(), fgets(), or fread() for binary data.

char buffer[255];
fgets(buffer, 255, fp); // Read a line from the file into buffer

Writing to Files:

Writing to files can be done using functions like fputc(), fputs(), or fwrite() for binary data.

fprintf(fp, "This is a formatted string: %s\n", str); // Write a formatted string to the file

File Descriptors

File descriptors are integers used by the operating system to identify open files in a process. They're managed by the kernel and facilitate I/O operations.

Standard File Descriptors:

In POSIX systems, there are three standard file descriptors:

0 (STDIN): Standard input
1 (STDOUT): Standard output
2 (STDERR): Standard error

I/O System Calls

I/O system calls are low-level functions provided by the operating system for performing input and output operations. Common I/O system calls include open(), close(), read(), and write().

`open()` System Call:

The open() system call is used to open files and returns a file descriptor.

int fd = open("example.txt", O_RDONLY); // Opens the file in read-only mode

`close()` System Call:

The close() system call is used to close an open file.

close(fd); // Close the file descriptor 'fd'

`read()` and `write()` System Calls:

The read() and write() system calls are used for reading from and writing to files respectively.

char buffer[255];
read(fd, buffer, sizeof(buffer)); // Read data from the file descriptor 'fd' into buffer

write(fd, "Hello, World!", 13); // Write "Hello, World!" to the file descriptor 'fd'

Flags and File Permissions

Flags and file permissions control the behavior of file operations and define access rights to files. Common flags include O_RDONLY, O_WRONLY, and O_RDWR.

File Permissions:

File permissions determine who can read, write, or execute a file. They are set using the open() system call by passing an additional argument representing the file permissions.

int fd = open("example.txt", O_CREAT | O_WRONLY, 0644); // Create the file with read-write permissions for owner and read-only permissions for group and others

System Calls vs. Functions

System calls are requests made by user-space programs to the operating system kernel, whereas functions are routines provided by libraries or the standard C library. System calls involve a context switch to kernel mode, making them more expensive in terms of performance compared to library functions.

Understanding file operations, file descriptors, I/O system calls, flags, and file permissions is crucial for developing robust and efficient file-handling applications in C.

By mastering these concepts, you'll be equipped to manipulate files and interact with the operating system effectively within your C programs.

A Quick Guide to File Manipulation (I/O) in C

Rita Kairu — Mon, 12 Feb 2024 10:32:02 +0000

File operations in C are essential for reading from and writing to files on the system. They involve several functions and concepts that enable you to manipulate files efficiently. Here's a brief overview of file operations in C:

1. File Pointers

File pointers are used to handle files in C programs.
They are of type FILE and are declared using the FILE structure.
Example: FILE *fp;

2. Opening Files

fopen() function is used to open files.
Syntax: FILE *fopen(const char *filename, const char *mode);
Modes:
- "r": Read mode
- "w": Write mode (creates a new file or overwrites existing content)
- "a": Append mode (appends data at the end of the file)
- "r+": Read/write mode (file must exist)
- "w+": Read/write mode (creates a new file or overwrites existing content)
- "a+": Read/append mode (file is created if it does not exist)
Returns a pointer to the file.

3. Closing Files

fclose() function is used to close files.
Syntax: int fclose(FILE *fp);
It flushes any buffered data and releases the associated file descriptor.

4. Reading from Files

fgetc() reads a character from the file.
fgets() reads a line from the file.
fread() reads blocks of data from the file.
Example:

  char buffer[255];
  fgets(buffer, 255, fp); // Reads a line from the file into buffer

5. Writing to Files

fputc() writes a character to the file.
fputs() writes a string to the file.
fwrite() writes blocks of data to the file.
Example:

  fprintf(fp, "This is a formatted string: %s\n", str);

6. Error Handling

Always check if file operations succeed.
Use feof() and ferror() to handle end-of-file and error conditions respectively.

7. File Positioning

fseek() and rewind() are used to move the file pointer.
ftell() returns the current position of the file pointer.

8. Binary vs. Text Mode

Files can be opened in binary mode by adding 'b' to the mode string.
Binary mode prevents newline translation and treats file contents as binary data.

9. Error Handling

Always check the return values of file operations.
Handle errors gracefully to avoid unexpected behavior.

Sample Code:

#include <stdio.h>

int main() {
    FILE *fp;
    char buffer[255];

    // Open file for writing
    fp = fopen("example.txt", "w+");
    if (fp == NULL) {
        printf("Error opening file!\n");
        return -1;
    }

    // Write to file
    fprintf(fp, "This is just an example!\n");

    // Read from file
    rewind(fp);
    fgets(buffer, 255, fp);
    printf("Content: %s", buffer);

    // Close file
    fclose(fp);

    return 0;
}

Important Points:

Always close files after using them to prevent resource leaks.
Handle file operations errors appropriately.
Use binary mode when dealing with binary data.

Understanding file operations is crucial for many applications, especially those involving data storage and manipulation. Mastering file operations in C allows you to work with files seamlessly.

Linked Lists in C Explained Clearly

Rita Kairu — Thu, 01 Feb 2024 10:14:07 +0000

What is a Linked List?

A linked list is a dynamic data structure with elements called nodes that contain some data and a reference (or pointer) to the next node in the sequence.

Unlike arrays, elements don't have to be stored in a fixed, continuous block of memory. They can dynamically grow or shrink as needed without allocating a contiguous block of memory like arrays.

How Useful are Linked Lists?

They are useful for implementing various data structures and algorithms as they offer efficient insertion and deletion operations, especially when elements need to be added or removed frequently from the middle of the list.

The only disadvantage is that it requires traversing through the list from the beginning when accessing an element, unlike arrays that are efficient for random access.

They are fundamental data structures used for tasks like managing memory allocation, implementing abstract data types (e.g. stacks, queues), and representing complex data relationships.

Basic Types of Linked Lists in C

1. Singly Linked List

Each nodes contains data and a pointer/reference to the next node in the sequence. It forms a unidirectional chain where traversal is possible only in one direction, usually from the head to the end.

2. Doubly Linked List

Each node contains data and two pointers/references: one points to the next node, and the other points to the previous node. This is bidirectional connectivity which allows traversal in both forward and backward directions.

3. Circular Linked List

The last node's pointer points back to the head node instead of NULL, creating a circular structure. This means the traversal can start from any node and loop back to the beginning.

4. Doubly Circular Linked List

This combines the features of doubly linked and circular lists. The nodes point to both the next and previous in a circular fashion.
They offer maximum flexibility for traversal and operations in both directions.

How To Use Linked Lists in C

Define the node structure, which holds the data and the pointer
Create a header pointer, which points to the first node in the list
Add/remove nodes by allocating memory for new nodes and adjusting pointers to link them in and out
Traverse the list by following the pointers from node to node to access data.

3 Basic Steps of Executing Function Pointers in C

Rita Kairu — Wed, 31 Jan 2024 06:19:57 +0000

What Are Function Pointers?

Function pointers point to functions instead of data such as variables. They are variables that store the address of a function rather than a value.
In C, function pointers are used to achieve functionality such as callbacks, dynamic function invocation, and implementing function tables.
Below is a 3-step process of how function pointers are executed in a c program

1. Declaration

Function pointers are declared like any other pointer but with the function's return type and parameters specified.

returnType (*pointerName)(parameters);

2. Assigning Addresses

Function pointers are assigned the address of a function using the function's name.

returnType functionName(parameters)
{
// function body
}

pointerName = &functionName 
// or pointerName = functionName

3. Calling the Function via Pointer

You can call the functioon using the function pointer like you would with the function itself.

(*pointerName)(arguments);

What Do Function Pointers Hold?

Function pointers hold the memory address of a function. They store the address from which the function code's starts in memory. This address points to the entry point of the function's machine code instructions.

Where Function Pointers Point in Memory

Function pointers point to the address in virtual memory where the machine code of the function is loaded during program execution. This address typically resides in the code segment of the program's memory layout.
When you use a function pointer, the processor fetches the machine instructions starting from the memory address stored in the function pointer and executes them accordingly.
Below is a simple example demonstrating how function pointers are executed:

#include <stdio.h>

// Function prototypes
void hello() {
    printf("Hello, ");
}

void world() {
    printf("world!\n");
}

int main() {
    // Declare function pointer
    void (*ptr)();

    // Assign addresses of functions to the pointer
    ptr = &hello;
    // Call hello() function through the pointer
    (*ptr)();

    ptr = &world;
    // Call world() function through the pointer
    (*ptr)();

    return 0;
}

Output:

Hello, world!

In the example above, ptr is a function pointer that points to different functions (hello and world).
Depending on the assignment, it calls the appropriate function.

Merging Your Git Branch to Main: A Simple Step-by-step Guide

Rita Kairu — Mon, 27 Nov 2023 10:48:29 +0000

I'll go straight to the point!

To merge a branch into the main branch in Git, simply follow these steps:

Checkout Main Branch: First, make sure you are on the main branch typing the following command:

   git checkout main

Pull Latest Changes: It's a good practice to ensure your main branch is up-to-date with the remote repository before merging any changes. Use:

   git pull origin main

Merge Branch: Now, you can merge the feature (or any other) branch into the main branch:

   git merge <branch-name>

Replace <branch-name> with the name of the branch you want to merge into the main branch.

If there are no conflicts, Git will automatically perform the merge. If there are conflicts, Git will pause the merge and let you resolve the conflicts manually.

Resolve Conflicts (if any): If there are conflicts, Git will mark the conflicted files. Open those files, and Git will show you the conflicting sections. Manually resolve the conflicts, save the files, and then continue the merge:

   git add <conflicted-file1> <conflicted-file2>  # Add resolved files
   git merge --continue

Commit the Merge: After resolving conflicts (or if there were none), you need to commit the changes:

   git commit -m "Merge branch-name into main"

Push Changes: Finally, push the changes to the remote repository:

   git push origin main

That's it! You've successfully merged the changes from your branch into the main branch.

P.S. It's good practice to merge branches with a clean working directory. So consider committing or stashing any local changes before starting the merge process.

The The Difference Between And in HTML

Rita Kairu — Sat, 20 May 2023 08:16:20 +0000

In HTML, the <script> element is used to include client-side JavaScript code in a web page. The way you include the script can affect when and how the script is executed, which can have implications for the page's behavior and performance. Let's compare the two methods mentioned:

1. `<script>` element

When you use the <script> element with a src attribute, it allows you to reference an external JavaScript file and include it in your HTML document. The syntax for this is as follows:

<script src="path/to/your/script.js"></script>

With this method, the browser will make a separate request to fetch the external script file from the provided path. Once the script is downloaded and executed, it can manipulate the page's DOM, handle events, and perform other actions as needed.

Benefits:

Separation of concerns: You can keep your JavaScript code in separate files, making it easier to manage and maintain.
Caching: Browsers can cache external script files, which means that if multiple pages use the same script, it will be fetched only once, improving loading times for subsequent pages.

2. Inline `<script>`

You can also include JavaScript directly within your HTML file using the inline <script> element without the src attribute. Here's an example:

<script>
  // Your JavaScript code goes here
</script>

With inline scripts, the JavaScript code is executed when the browser encounters it during parsing. This means that the script will be executed immediately, potentially before the whole page is loaded.

Benefits:

Simplicity: For small scripts, you may choose to include the code directly in the HTML to keep things simple.
Access to HTML elements: Since the script is part of the HTML file, it can easily access and manipulate DOM elements defined earlier in the page.

Differences:

Location: The primary difference is that <script> with a src attribute references an external file, while an inline <script> contains the JavaScript code directly within the HTML file.
Timing: External scripts are loaded asynchronously, which means that the browser can continue parsing and rendering the page while the script is being fetched. On the other hand, inline scripts are executed synchronously, potentially delaying the page rendering until the script is fully executed.

In general, it's recommended to use the <script> with the src attribute for most scenarios. This promotes code reusability, maintainability, and better performance due to browser caching. However, inline scripts might still be useful for small, isolated snippets of code or situations where dynamic content requires immediate execution.

Can CSS target elements in a "body" that's not highlighted in HTML?

Rita Kairu — Fri, 20 Jan 2023 09:30:18 +0000

Yes, CSS can target elements in a "body" that's not highlighted in HTML.

CSS selectors allow you to select elements based on various criteria such as their element type, class, ID, or attribute. You can use these selectors to target elements regardless of whether they are highlighted in the HTML or not.

For example, you can use CSS selectors such as body p to select all <p> elements within the <body> element, or .my-class to select all elements with the class "my-class" regardless of their element type.

You can also use attribute selectors to target elements based on their attributes, such as [data-attribute=value] to select elements with a specific attribute and value.

You can also use CSS pseudo-selectors such as :first-child or :last-child to target specific elements within a container, regardless of their type or class.

In summary, CSS provides a wide range of selectors and pseudo-selectors that allow you to target elements based on various criteria, regardless of whether they are highlighted in the HTML or not.

The C Language in a nutshell...

Rita Kairu — Fri, 20 Jan 2023 09:13:49 +0000

Intro...

C is a general-purpose, high-level programming language that was first developed in the early 1970s. It is considered to be one of the most widely used and versatile programming languages in the world. Here are some of the basics of the C programming language:

Syntax

C has a simple and straightforward syntax that is easy to learn and understand. It uses a combination of keywords, variables, and operators to create statements that are executed by the computer.

Data Types

C supports a variety of data types including integers, floating-point numbers, characters, and strings.

Variables

Variables are used to store data in C. They are declared with a specific data type and can be used to store values, expressions, or even the results of calculations.

Operators

C supports a variety of operators such as mathematical operators (e.g. +, -, *, /), comparison operators (e.g. ==, !=, >, <), and logical operators (e.g. &&, ||, !).

Control Flow

C uses control flow statements such as if, else, for, while, and do-while loops to control the flow of execution in a program.

Functions

Functions are used to divide a program into smaller, more manageable pieces. Functions can be defined and called by the main program or by other functions.

Pointers

C uses pointers to manipulate memory directly, they are variables that store the memory addresses of other variables.

Input/Output

C uses a variety of functions such as scanf() and printf() to handle input and output operations.

Libraries

C has a large number of standard libraries that provide a wide range of functions for tasks such as mathematical calculations, string manipulation, and input/output operations.

Compilation

Programs written in C need to be compiled before they can be executed by the computer. The process of compilation converts the source code into machine-readable code.

The difference between and

Rita Kairu — Sat, 01 Oct 2022 10:23:30 +0000

The answer is simple...

<b></b>incorporates the bold text property while <span></span>

doesn't☺

or...

The <b> and <span> tags are both HTML tags used to format text on a web page, but they have different purposes.

The <b> tag is used to make text bold, which means that it will be displayed in a thicker font weight than the surrounding text. This tag is used to highlight important information, such as keywords in a sentence, or to make text stand out.

The <span> tag, on the other hand, is a generic container for inline elements. It is used to group elements together and apply styles to them. It doesn't have any default rendering and it's used mostly in conjunction with CSS selectors. It's used to format text in a specific way, for example, change the color, font, size, or add a background color. It can be used to change the appearance of text, but it doesn't change the font weight.

In summary, <b> tag is used to make text bold, while the <span> tag is used to group elements together and apply styles to them.

DEV Community: Rita Kairu

Don't Run That Code! Your Guide to Staying Safe from Job Scams with Virtual Machines

Inside the Mind of a Modern Hacker

How to Protect Yourself: Run Suspicious Code in Isolation

Reliable Tools for Safe Testing

Virtual Machine Safety Tips

VM Safety Configuration: A Developer's Guide

Why VM Safety Matters

1. Disable Shared Folders

VirtualBox

VMware Workstation/Fusion

Hyper-V

2. Disable Clipboard Sharing

VirtualBox

VMware

Hyper-V

3. Network Isolation

VirtualBox - Host-Only Network

VMware - Custom Network

Hyper-V - Internal Network

4. Snapshot Management

VirtualBox

VMware

Hyper-V

5. Keep Personal Data Out

Disable Credential Managers

Browser Configuration Script

Network Monitoring

Complete VM Setup Script

Best Practices Checklist

Conclusion

Comparing Modular and Input Handling in Python (With Code Examples)

Code 1 (Original Code with Separate Functions)

Code 2 (Simplified Code Without Separate Functions)

Differences

Pros & Cons: Which Method is Better and More Commonly Used?

Pros of Code 1:

Pros of Code 2:

Common Practice:

Conclusion:

More About File Operations in C Including File Descriptors

Creating, Opening, Closing, Reading, and Writing Files

Creating and Opening Files:

Closing Files:

Reading from Files:

Writing to Files:

File Descriptors

Standard File Descriptors:

I/O System Calls

open() System Call:

close() System Call:

read() and write() System Calls:

Flags and File Permissions

File Permissions:

System Calls vs. Functions

A Quick Guide to File Manipulation (I/O) in C

1. File Pointers

2. Opening Files

3. Closing Files

4. Reading from Files

5. Writing to Files

6. Error Handling

7. File Positioning

8. Binary vs. Text Mode

9. Error Handling

Sample Code:

Important Points:

Linked Lists in C Explained Clearly

What is a Linked List?

How Useful are Linked Lists?

Basic Types of Linked Lists in C

1. Singly Linked List

2. Doubly Linked List

3. Circular Linked List

4. Doubly Circular Linked List

How To Use Linked Lists in C

3 Basic Steps of Executing Function Pointers in C

What Are Function Pointers?

1. Declaration

2. Assigning Addresses

`open()` System Call:

`close()` System Call:

`read()` and `write()` System Calls:

1. `<script>` element

2. Inline `<script>`