Forem: John Wilson

Temporary Email: Privacy Guardians in the Digital Age

John Wilson — Wed, 02 Jul 2025 02:15:15 +0000

In today's world of increasing information security awareness, more and more people are focusing on online privacy protection. Questions like "When should I use a temporary email?" and "What risks exist when using my real email?" frequently appear in daily conversations. This article will delve into the value of temporary email addresses, share practical scenarios, and provide security advice to help you better protect your personal privacy in the digital world.

Typical Application Scenarios for Temporary Email

1. AI Product Trials

With the booming development of AI technology, ChatGPT, Midjourney, and various AI writing tools are emerging one after another, most requiring email registration to experience them. However, not every AI product is worth leaving your real email information for.

Real Case: I once had high expectations for a highly recommended AI drawing tool and registered with my real email without hesitation. The product experience was mediocre, but I began receiving product update emails every day. Although unsubscribing is an option, who can guarantee that your email address hasn't been sold to other marketing agencies?

Optimization Strategy: First try with a temporary email, and if the product is truly excellent, consider re-registering with your real email – protecting your privacy while not missing out on quality services.

2. Software Downloads and Trials

Many software manufacturers adopt a "free trial" marketing strategy that seems attractive on the surface but often comes with:

Frequent reminder emails about the trial period ending soon
Continuous feature upgrade notifications
Various "user research" and "product feedback" requests

Personal Experience: After downloading an image editing software, my inbox received over 30 related emails in just one month! Experience tells me that temporary email addresses are ideal for these situations.

3. Development and Testing Work

For programmers, product managers, or testers, temporary emails are essential tools:

Registration Process Testing: Verifying the completeness and reliability of email sending functions
Multi-User Scenario Simulation: Evaluating system performance under different user conditions
Function Verification: Testing key features like email notifications and password resets
Stress Testing: When creating numerous test accounts is needed

During product testing phases, you might need to create dozens of test accounts. Using real emails is not only impractical but would also lead to inbox management chaos.

4. Competitive Analysis Research

When conducting market research, registering for competitors' services to understand their product strategies and marketing methods is a common practice. Using temporary emails has significant advantages here:

Effectively protects identity information, avoiding exposure of research intentions
Specifically observes competitors' email marketing strategies and user communication methods
Prevents marketing emails from interfering with daily work and personal inboxes

5. One-Time Event Participation

Online prize drawings, free resource downloads, and webinars usually require providing an email address. These situations are particularly suitable for temporary emails:

No longer receiving related emails after the event ends, reducing information interference
Avoiding having your email added to various marketing databases
Important notifications (such as winning information) are usually communicated through other channels

Potential Risk Analysis of Using Real Email Addresses

Many people might think "it's just a few spam emails," but the actual risks far exceed imagination:

1. Commercial Trading of Email Addresses

This is the most prevalent risk. Unscrupulous websites may sell user email information to marketing companies, causing your email to appear in countless marketing databases. One of my friends receives hundreds of spam emails daily because of this, making management difficult.

2. Phishing Email Threats

When your email is exposed in various databases, the probability of becoming a phishing attack target greatly increases. Scammers will impersonate websites you've registered with, sending fake emails like "account abnormality" or "password about to expire" to induce clicking on malicious links.

3. Chain Leakage of Personal Information

Email addresses are usually associated with other personal information, such as real names and phone numbers. Once an email leaks, it may trigger wider exposure of personal information, constituting privacy security risks.

4. Decreased Work Efficiency

Spam email flooding seriously affects normal email processing efficiency. Data shows that professionals may spend 30 minutes or more daily clearing spam emails, which is undoubtedly a waste of time resources.

Email Security Usage Strategies

Layered Management Approach

I recommend adopting a "layered use" strategy, rationally allocating services of different importance:

Core Email: Dedicated to the most important services, such as bank accounts, work communications, and main social media
Daily Email: Used for general service registrations, such as e-commerce platforms and commonly used software
Temporary Email: Suitable for one-time needs, test experiences, and trial evaluations

Choosing Reliable Temporary Email Services

There are many temporary email services in the market. When choosing, consider these key factors:

Service Stability: Ensuring stable access when needed
Security Guarantees: Not recording or leaking email content, protecting user privacy
User Experience: Intuitive and concise interface, convenient and efficient operation
Feature Completeness: Supporting multiple domain choices, providing email favorites functionality

Practical Application Experience Sharing

While recently using Temp Mail for work, I discovered a particularly practical application scenario:

When testing the new user registration process for the company, I needed to create multiple test accounts. Previously, when using other temporary email services, I frequently encountered problems like domains being blocked or emails expiring too quickly, causing testing interruptions. This service solved key pain points:

Provides multiple domain choices, ensuring there are always available options
Email favorites feature supports long-term retention of test emails
Fast generation speed, seamlessly integrated into the testing process

Now, I save commonly used test emails as favorites and call them directly when needed, greatly improving work efficiency.

Regular Maintenance Management

Even if you adopt a layered strategy, you should regularly maintain your email:

Clean up unnecessary emails, keeping the inbox tidy
Proactively unsubscribe from mailing lists you no longer follow
Regularly update email addresses and security settings for important services
Check suspicious login or registration emails to detect security threats early

Conclusion

Temporary email, as a simple yet practical technical tool, can effectively protect personal privacy and improve work efficiency in various scenarios. The key is to clearly understand when to use it and when not to.

Remember this core principle: For services of questionable reliability or only temporary use, choose Temporary email for important services used long-term, use your real email.

In the digital age of information explosion, learning to protect personal privacy has become an essential skill. Temporary email may be small, but it can provide an extra layer of protection for your digital life. By reasonably utilizing this tool, you can better control personal information security while enjoying digital convenience.

Recommended Temporary Email Services

Further Understanding Cargo and Crates.io

John Wilson — Wed, 25 Jun 2025 04:48:33 +0000

In Rust, "release profiles" are predefined and customizable sets of settings with different options that allow programmers to control compilation options flexibly. Each profile is independent.

Cargo mainly has two profiles: the dev profile used when running cargo build, and the release profile used when running cargo build --release. The dev profile is the default suitable for development, while the release profile is suitable for building optimized release binaries.

You may see these names in the build output:

$ cargo build
   Compiling cargo1 v0.1.0 (/rust/cargo1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.67s
$ cargo build --release
   Compiling cargo1 v0.1.0 (/rust/cargo1)
    Finished release [optimized] target(s) in 0.11s

The output shows dev and release, indicating that the compiler is using different settings.

If you do not explicitly add [profile.] sections in your project's Cargo.toml, Cargo uses default settings for all profiles. You can override any subset by adding the corresponding [profile.] section. For example, the default opt-level values for dev and release are:

[profile.dev]
opt-level = 0

[profile.release]
opt-level = 3

The opt-level controls how much optimization Rust applies to the code. It ranges from 0 to 3. Higher optimization levels increase compile time, so during development you may prefer faster compile times at the cost of less optimization. Hence, dev has default opt-level of 0. Release builds, intended to be compiled once and run multiple times, benefit from more optimization, so release defaults to opt-level 3.

You can override defaults in Cargo.toml. For example, to use optimization level 1 for development builds:

[profile.dev]
opt-level = 1

This will increase optimization in dev builds but not as aggressively as the release profile.

Documentation Comments

Documentation comments start with triple slashes /// and support Markdown. They must be placed immediately before the item being documented. Create a new project:

$ cargo new learn_cratel
$ cd learn_cratel
$ cargo new mylib --lib

Open mylib's lib.rs and add a documentation comment to the default add function:

/// Adds two usize values
pub fn add(left: usize, right: usize) -> usize {
    left + right
}

Run cargo doc to generate HTML documentation from the comments. This calls rustdoc and outputs docs into target/doc.

Running cargo doc --open builds the docs and opens them in your browser. You can see how the documentation renders when following the add function.

You can add more detailed comments:

/// Adds two numbers
/// # Example
/// ```
{% endraw %}

/// let left = 1;  
/// let right = 2;  
/// assert_eq!(3, mylib::add(left, right));  
///
{% raw %}

pub fn add(left: usize, right: usize) -> usize {
left + right
}



Here, the description and an example section demonstrate how to use the add function.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y97jpolgd562kthxae6a.webp)

### Testing Documentation Examples
The sample code inside doc comments also acts as tests. cargo test runs these docs tests to help make sure examples don't break after code changes. Running cargo test produces:

Doc-tests mylib

running 1 test
test src/lib.rs - add (line 3) ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.18s



If an example assertion fails, cargo test reports it as a failure.

### Inner Documentation Comments

The //! style documents the enclosing item itself and appears at the beginning of files, commonly at crate root (src/lib.rs) or module roots. It documents the crate or module as a whole.

Example in src/lib.rs:

//! # My Crate
//!
//! learn_cratel is a utility collection

/// Adds two numbers
/// # Example
/// ```

/// let left = 1;

/// let right = 2;

/// assert_eq!(3, mylib::add(left, right));

///

pub fn add(left: usize, right: usize) -> usize {
    left + right
}

//! comments appear on the crate's top-level documentation page above the list of public items when running cargo doc --open.

Publishing Crates to Crates.io

We have used dependencies from crates.io, but you can also publish your own crates to share code with others. crates.io is a distribution platform for open-source Rust code.

Create a Crates.io Account

Before publishing, you need an account and an API token from crates.io. Log in using your GitHub account (currently the only supported login). Get your token from https://crates.io/me/.

Then run:

$ cargo login your_api_token

This stores your token in ~/.cargo/credentials. Keep this token secret.

Publish to Crates.io

Once logged in, publish a specific crate version to make it available for others to depend on.

Publishing is permanent; versions cannot be overwritten or deleted. This preserves stable code for dependent projects. Version numbers follow semantic versioning but you can publish any version.

If you run cargo publish and see an error like:

Caused by:
  the remote server responded with an error: missing or empty metadata fields: description, license. Please see https://doc.rust-lang.org/cargo/reference/manifest.html for how to upload metadata

It means description and license fields are missing in your Cargo.toml. Add them:

description = "This is a test project"
license = "MIT OR Apache-2.0"

Publish again, and it should succeed:

$ cargo publish
    Updating crates.io index
warning: manifest has no documentation, homepage or repository.
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
   Packaging mylib-hekang v0.1.0 (/rust/learn_cratel/mylib)
   Verifying mylib-hekang v0.1.0 (/rust/learn_cratel/mylib)
   Compiling mylib-hekang v0.1.0 (/rust/learn_cratel/mylib/target/package/mylib-hekang-0.1.0)
    Finished dev [unoptimized + debuginfo] target(s) in 0.84s
    Packaged 3 files, 1.3KiB (901.0B compressed)
   Uploading mylib-hekang v0.1.0 (/rust/learn_cratel/mylib)
    Updating crates.io index
    Waiting on `mylib-hekang` to propagate to crates.io index (ctrl-c to wait asynchronously)
    Updating crates.io index
...

Now your code is shared with the Rust community, and anyone can add it as a dependency.

Publishing New Versions

When updating your crate, increment the version in Cargo.toml following semantic versioning and run cargo publish again.

Yank Crate Versions

You cannot remove published versions but can "yank" them to mark them as deprecated for new projects. Existing projects using that version continue to work, but new dependencies won’t use it.

To yank version 0.1.0:

$ cargo yank --vers 0.1.0
    Updating crates.io index
    Yank mylib-hekang@0.1.0

To undo the yank:

$ cargo yank --vers 0.1.0 --undo
    Updating crates.io index
    Unyank mylib-hekang@0.1.0

Yanking does not delete code; if secrets were published accidentally, regenerate new versions with fixes.

Analyzing and Visualizing Nginx Access Logs with GoAccess

John Wilson — Thu, 19 Jun 2025 05:41:52 +0000

Nginx access logs contain a wealth of information, but directly reading them can be a daunting task for most people. Fortunately, we have powerful tools like GoAccess that help us easily analyze and visualize Nginx access logs.

Tool Installation

Debian-based Systems (e.g., Ubuntu)

You can install GoAccess with the following commands:

sudo apt-get update
sudo apt-get install goaccess

Red Hat-based Systems (e.g., CentOS)

Install with:

sudo yum -y install goaccess

Installing from Source Code

If you wish to install GoAccess from source, follow these steps. First, download the source package:

wget https://tar.goaccess.io/goaccess-1.4.tar.gz

Extract and compile:

tar -xzvf goaccess-1.4.tar.gz
cd goaccess-1.4/
./configure --enable-geoip --enable-utf8
make && sudo make install

Tool Configuration

GoAccess needs configuration to correctly parse Nginx access logs. The config file is usually at /etc/goaccess/goaccess.conf.

For the default Nginx log format, you can simply use the --log-format=COMBINED parameter.

If you've set a custom log format in your Nginx configuration, specify the corresponding log format in the GoAccess config file. For example:

log-format %h %^[%d:%t %^] "%r" %s %b "%R" "%u"

You also need to define the date and time formats so GoAccess can parse timestamps correctly, e.g.:

date-format %d/%b/%Y
time-format %H:%M:%S

Log Analysis

Run GoAccess in the terminal to enter its interactive interface, which displays log analysis results.

For example:

goaccess /var/log/nginx/access.log --log-format=COMBINED

GoAccess can also generate an HTML report, viewable in your browser. The following command will create a report.html file with comprehensive statistics and charts:

goaccess /var/log/nginx/access.log -o report.html --log-format=COMBINED

To enable real-time monitoring and generate a dynamically updating HTML report, use:

--real-time-html --daemonize

Sample full command:

goaccess /var/log/nginx/access.log -o /var/www/html/report.html --log-format=COMBINED --real-time-html --daemonize

Understanding the Analysis Results

GoAccess provides a wealth of statistics and charts, helping you comprehensively understand your website’s visitors, including:

Overview

Metric	Description
Total Hits	Shows the total website visits
Unique Visitors	Counts unique IP addresses
Data Transferred	Total data sent (MB or GB)

Visitor Information

Metric	Description
IP Rankings	IP addresses by visit count
Browsers & OS	Visitor browser and OS details

Request Information

Metric	Description
Methods	Number of different HTTP methods
Status Codes	HTTP status (200 = OK, 404 = Not Found, etc.)
URL Rankings	Most accessed URLs

Performance Analysis

Metric	Description
Time Distribution	Requests per time period
Slowest Requests	Requests with longest response times

Advanced Usage

Besides basic analytics, GoAccess supports advanced features such as pipes and filters.

For real-time analysis, run:

tail -f /var/log/nginx/access.log | goaccess -p /etc/goaccess/goaccess.conf

To analyze and merge multiple log files:

goaccess -p /etc/goaccess/goaccess.conf access.log.1 access.log.2

Let me know if you need more explanation or have any other questions!

Temporary Email: A Developer’s Practical Notes on Privacy Tools

John Wilson — Thu, 12 Jun 2025 15:23:46 +0000

Last week, while collecting various API documents and developer tools for a new open-source project, I encountered a frustrating issue: nearly every developer resource website required me to register and verify an email address. Afterward, my inbox started filling up with marketing emails and promotional notifications.

At that moment, I realized I needed a temp mail.

The Problem and the Solution

As a developer, I frequently need to register for many services: testing new APIs, downloading SDK documentation, signing up for test accounts to verify registration flows in my apps… Using my real email every time means my inbox is forever flooded with marketing emails and notifications.

A friend once joked, “Your main email isn’t a work tool anymore; it’s a battlefield for marketing campaigns.” Though exaggerated, that hit the nail on the head.

When I needed to create 20 test accounts to verify a new registration flow I was developing, a temp mail became my lifesaver.

What is a Temporary Email?

Temporary email (also called a disposable or anonymous email) has become an indispensable tool in my development work. It requires no registration—just open the website and instantly get a usable email address. Use it and toss it away, simple and efficient.

The first time I used a temp mail, I was surprised at its simplicity—no complicated interface, no mandatory sign-up, just a randomly generated email address and a message inbox. As a fan of minimalistic design, it was exactly what I wanted.

My Practical Use Cases

In daily development, I find temporary email especially useful in these scenarios:

Bulk Testing Registration Flows: When I need to verify an app’s registration logic, creating 10 different test accounts is incredibly easy. No more worrying about “email already registered” errors!
API Service Comparison Testing: Last month, I needed to compare three different payment API providers. Each required registering a developer account, so using temporary emails let me quickly sign up and obtain test credentials without the hassle of marketing emails afterward.
Downloading Developer Resources: Many SDKs, tutorials, and developer tools are hidden behind “free download” email verifications. Temporary emails let me quickly receive these resources without risking privacy leaks.
Temporary Team Collaboration: Once, while collaborating briefly with external developers, we used a temporary email to register a shared project management platform. After the project ended, the email naturally expired, leaving no trace.

Experience and Suggestions

After months of practice, here are some lessons from using temporary emails:

Advantages:

Improved Development Efficiency: No more email issues during testing, so I can focus on code and functionality.
Privacy Protection: My main inbox sees far fewer spam emails; important messages are no longer drowned out.
Hassle-Free Use: No need to remember extra passwords or accounts—just open the site and use it.

Limitations:

Major platforms like GitHub and AWS detect and block temporary email domains, which is reasonable because these platforms require reliable identity verification.
Some temporary email services are unstable. I once experienced a service outage while waiting for an important API key email.

Recommendations

Currently, I use the following temporary email services, which I find stable and user-friendly:

From $0 to $300 per Month: A Friend's Indie Maker Story

John Wilson — Sat, 15 Mar 2025 04:22:38 +0000

Recently, my friend decided to embark on the path of indie developer and made a temporary email site: tempmail100.com. As a bystander, I witnessed him starting from scratch, figuring it out step by step, and finally achieving $300 monthly ad revenue. Today, I'd like to share his experience and hope to give some inspiration to those who want to step into the indie developer industry.

1. From idea to realization

My friend's initial intention is very simple: to make a practical temporary mailbox tool to help users quickly sign up for some temporary services without exposing their real mailboxes. He chose the direction of
temporary mailbox mainly because of the clear market demand and relatively low technical threshold.

He spent a few weeks from design to development, and finally launched tempmail100.com. The page design of the website is very simple, and the user experience is also very smooth, especially the function of “generate mailbox with one click”, which is simply too convenient.

2. Technology stack and SEO optimization

As an independent developer, my friend was very pragmatic in his technology selection. He chose a lightweight tech stack to ensure that the site would be responsive and easy to maintain. At the same time, he did the following things in order to improve the site's SEO performance:

Outbound link building: he took the initiative to share his project on some technical forums (e.g. V2EX, X, etc.), which attracted a lot of developers to click and discuss. These external links not only brought traffic, but also improved the weight of the website.
Keyword Optimization: He cleverly incorporated keywords such as “temporary email” and “free email generation” in the title, description and content of his website to ensure that search engines can better crawl and index it.
Social media promotion: He also shared some development tips and tricks on Twitter (X), attracting many users to try it out.

3. Payments

In order to keep the site running, a friend decided to bring in Stripe as a payment collection tool. In order to access Stripe, he even registered a US company! Although the process was a bit complicated, he eventually succeeded in accessing Stripe, and users can pay to unlock some advanced features, such as longer mailbox expiration dates, customized mailbox prefixes, and so on. Although there aren't many paying users yet, this provides him with a steady source of income.

In addition, he also places ads on his website through Google AdSense. With the increase in traffic, the ad revenue has gradually increased, and recently even reached the achievement of $10 per day. Although this number may seem small, it's a good start for an indie developer who is just starting out.

4. Challenges and the future

Of course, the road for indie developers isn't always smooth. My friend also encountered some challenges, such as how to continuously attract new users and how to deal with competitors. However, he always stays optimistic and keeps optimizing the product to improve the user experience.

In the future, he plans to continue to improve the site's features, such as adding multi-language support and improving the stability of the mailbox. At the same time, he also hopes to further enhance the website's popularity and traffic through more SEO optimization and social media promotion.

Conclusion

My friend experience made me realize that indie developers are full of challenges but also full of possibilities. If you have a similar idea, you might as well try it boldly, maybe the next successful indie developer is you!

linktree: https://linktr.ee/dearjohnwilson