(Diyu was my work alias — don’t laugh…)

Download the SEO Presentation (PDF)

SEO Basic Standards Document: https://shimo.im/doc/aLMG4FtoLZ8JRoKC

SEO Casual Discussion Notes: https://shimo.im/doc/7GVFl8rwU2snuY6X

But it has one drawback: it doesn’t support custom domains.

Don’t worry though — this article will walk you through the simplest, zero-cost method to bind a custom domain to your Bento.me page.

1. Prerequisites

1. You need to have a Bento.me personal page
2. Register / prepare a Cloudflare account
3. Own an independent domain and transfer its DNS management to Cloudflare

2. Create a Cloudflare Worker Project

Enter the following command in your terminal to create a basic Cloudflare Worker:

npm create cloudflare@latest

Then follow the prompts in the terminal:

• In which directory do you want to create your application?

  • Default or custom — either is fine

• What type of application do you want to create?

  • Select “Hello World” Worker

• Do you want to use TypeScript?

  • Select NO (use the arrow keys to choose)

• Do you want to use git for version control?

  • Select Yes

• Do you want to deploy your application?

  • Select Yes (if this is your first time, it will automatically open a browser for login)

Once complete, a folder will appear in the corresponding directory. Open it with a code editor such as Visual Studio Code.

3. Set Environment Variables

1. Edit the wrangler.toml file and add the following at the end:

[vars]BENTO_USERNAME = "len" # Replace with your Bento page ID — mine is bento.me/lenBASE_URL = "https://bento.imzl.com" # Replace with your custom domain

2. Create a .dev.vars file in the project root directory and paste the following:

BENTO_USERNAME="len" # Replace with your Bento page IDBASE_URL="http://127.0.0.1:8787"

4. Create the Worker

1. Edit the /src/index.js file and replace its contents with the following:

/* * Setting up a custom domain for Bento.me * Author: len * Details: https://imzl.com/bento-add-domain.html * Original source: https://jayfranco.hashnode.dev/ */// Event listeneraddEventListener('fetch', event => {  // When a fetch event occurs, respond with the result of handleRequest  event.respondWith(handleRequest(event.request));});// Parse response based on content typeasync function parseResponseByContentType(response, contentType) {  // If there's no content type, return the response as text  if (!contentType) return await response.text();  // Handle differently based on content type  switch (true) {    case contentType.includes('application/json'):      // If JSON, return as a JSON string      return JSON.stringify(await response.json());    case contentType.includes('text/html'):      // If HTML, use HTMLRewriter to transform the response      const transformedResponse = new HTMLRewriter()        .on('body', {          element(element) {            // Custom CSS and JS can be added to the HTML page here            element.append(              `                <style>                  // Add your custom CSS here                </style>                `,              { html: true },            );            element.append(              `                <script>                  // Add your custom JS here                </script>                `,              { html: true },            );          },        })        .transform(response);      // Return the transformed response as text      return await transformedResponse.text();    case contentType.includes('font'):      // If the content type is a font, return as ArrayBuffer      return await response.arrayBuffer();    case contentType.includes('image'):      // If the content type is an image, return as ArrayBuffer      return await response.arrayBuffer()    default:      // For all other content types, return as text      return await response.text();  }}// Function to handle all requestsasync function handleRequest(request) {  // Extract the path from the request URL  const path = new URL(request.url).pathname;  // By default, the URL is set to "https://bento.me" + path  let url = 'https://bento.me' + path;  // If the path contains 'v1', change the URL to 'https://api.bento.me' + path  if (path.includes('v1')) {    url = 'https://api.bento.me' + path;  }  // If the URL is "https://bento.me/", append the BENTO User ID  if (url === 'https://bento.me/') {    url = 'https://bento.me/' + BENTO_USERNAME;  }  // Define basic headers for the fetch request  let headers = {    'Access-Control-Allow-Origin': '*',    'Access-Control-Allow-Methods': 'GET,HEAD,POST,OPTIONS',  };  // Fetch the URL with the defined headers  const response = await fetch(url, { headers });  // Extract the content type from the response headers  const contentType = response.headers.get('content-type');  // Parse the response based on content type  let results = await parseResponseByContentType(response, contentType);  // If the result is not an ArrayBuffer,  // replace all calls to the bento API with our BASE_URL  // This is a workaround for CORS errors  if (!(results instanceof ArrayBuffer)) {    results = results.replaceAll('https://api.bento.me', BASE_URL);  }  // Add the content type to the headers  headers['content-type'] = contentType;  // Return a new response with the results and headers  return new Response(results, { headers });}

2. Navigate to the project folder in your terminal and run the code to preview:

npm run dev

3. Once everything looks good, deploy to production:

npm run deploy

5. Configure the Custom Domain in Cloudflare

1. First, make sure the domain you want to bind has its DNS managed by Cloudflare.
2. Go to “Workers and Pages” and find the Worker project you just pushed.
3. Under “Settings - Triggers,” add your custom domain and wait for it to take effect.
4. Now you can visit bento.imzl.com to see your Bento page.

2008

• Bitcoin: A Peer-to-Peer Electronic Cash System — Where it all began. The Bitcoin whitepaper, written by someone under the pseudonym “Satoshi Nakamoto.”

2011

• Bitcoin — by Fred Wilson

2013

• Coinbase — by Chris Dixon
• Why I’m Interested in Bitcoin — by Chris Dixon

2014

• Why Bitcoin Matters — by Marc Andreessen

2016

• Ethereum Is the Forefront of Digital Currency — by Fred Ehrsam
• Fat Protocols — by Joel Monegro

2017

• Value of the Token Model — by Fred Ehrsam
• A Beginner’s Guide to Ethereum — by Linda Xie
• The Meaning of Decentralization — by Vitalik Buterin
• Thoughts on Tokens — by Balaji Srinivasan
• Crypto Tokens: A Breakthrough in Open Network Design — by Chris Dixon
• Analyzing Token Sale Models — by Vitalik Buterin
• Cryptocurrency’s Netscape Moment — by Elad Gil
• Permissionless — by Alok Vasudev
• The Slow Death of the Firm — by Nick Tomaino
• Big Banks and Blockchain — by Elad Gil

2018

• Why Decentralization Matters — by Chris Dixon
• And What Has the Blockchain Ever Done for Us? — by Balaji Srinivasan
• Stablecoins: Designing a Price-Stable Cryptocurrency — by Haseeb Qureshi

2019

• Yes, You May Need a Blockchain — by Balaji Srinivasan
• The Future of Decentralized Finance — by Linda Xie
• The Pseudonymous Economy — by Balaji Srinivasan

2020

• Credible Neutrality as a Guiding Principle — by Vitalik Buterin
• A Beginner’s Guide to Decentralized Finance (DeFi) — by Sid Coelho-Prabhu
• The Ownership Economy — by Jesse Walden
• Bitcoin for the Open Minded Skeptic — by Matt Huang
• Creators, Communities, and Crypto — by Fred Ehrsam
• What Explains the Rise of AMMs? — by Haseeb Qureshi
• Ethereum Is a Dark Forest — by Dan Robinson and Georgios Konstantopoulos

2021

• Surviving Crypto Cycles — by Fred Ehrsam
• The Value Chain of the Open Metaverse — by Packy McCormick
• MEV and Me — by Charlie Noyes
• NFTs Make the Internet Ownable — by Jesse Walden
• NFTs and a Thousand True Fans — by Chris Dixon
• A Beginner’s Guide to DAOs — by Linda Xie
• The Most Important Scarce Resource Is Legitimacy — by Vitalik Buterin
• The Great Online Game — by Packy McCormick
• India and Crypto — by Balaji Srinivasan
• Own the Internet — by Packy McCormick
• Why Web3 Matters — by Chris Dixon
• Composability Is Innovation — by Linda Xie
• The Strongest Crypto Gaming Thesis — by gubsheep
• Endgame — by Vitalik Buterin
• Trading the Metagame — by Cobie
• The Mirrortable — by Balaji Srinivasan
• Bitcoin Explained in Plain Language: How It Works — by Zhang Yang

2022

• 2021 NFT Annual Review — by 1confirmation
• Soulbound — by Vitalik Buterin
• Hyperstructures — by Jacob Horne
• Sufficient Decentralization for Social Networks — by Varun Srinivasan

2023

• Ten Coins to Rule Them All — by Wang Yishi

1. Install Node.js
2. git clone https://github.com/atomicals/atomicals-js.git
3. cd atomicals-JavaScript
4. npm install -g typescript
5. npm run build
6. npm install -g yarn
7. yarn install
8. yarn cli wallet-init // This is the command to create a wallet

The last step creates a wallet. After running the command, a wallet.json file will be generated in the folder, containing your mnemonic phrase and private key. Make sure to back up this file securely.

Once the wallet is created, two addresses are automatically generated: Primary Address and Funding Address.

Primary: Used to receive Atomicals ecosystem assets.
Funding: A transit wallet used during the minting (mining) process. Typically, you deposit the required amount of BTC into the Funding address for minting the corresponding assets.

Common Commands

Minting FT Command:

yarn cli mint-dft dmint --satsbyte 30

yarn cli mint-dft quark --satsbyte=100

dmint and quark are token names — replace them with the corresponding FT asset name.
satsbyte sets the miner fee. Setting it to 100 means minting at a rate of 100 sats/KB.

Minting Image NFT Command:

yarn cli mint-nft "\punk0000.png" --satsbyte 30 --satsoutput 1000 --bitworkc 233

Checking Balance:

npm run cli balances

As a staunch Starknet supporter, I believe this is a unique opportunity for community members — whether developers, content creators, event organizers, or active participants in technical discussions — to be recognized and rewarded.

Application Process and Timeline

Applications open on October 30, 2023 and close on November 23. The review committee will make its decisions by December 29. Interested individuals and projects should submit their applications within this period.

Who Can Apply?

The ECMP is open to individuals who have actively contributed to the Starknet ecosystem. Whether through technical discussions, organizing events, publishing branded content, or any other means of adding vitality and resources to the ecosystem — all such individuals should consider applying.

Evaluation Criteria

The evaluation criteria include impact, significance, effort, and originality. This means it’s not just about lines of code — it also encompasses your impact on the community, the importance of your work to the project, the effort you’ve put in, and the originality of your contributions.

Application Process

Both projects and individuals need to submit applications through the provided link, including their Telegram ID, email address, and Starknet wallet address. Each project and individual will be evaluated by the committee.

Application link: https://ecmp.starknet.io/form-individual

Starknet official announcement: https://community.starknet.io/t/announcing-the-early-community-member-program/102092

Important Notes

It is important to note that sanctioned individuals, residents of sanctioned countries, and US-affiliated persons are not eligible to participate.

This program marks a significant step in the growth and development of the Starknet community. It not only rewards the unsung heroes but also encourages more people to join and contribute to the ecosystem. If you are a dedicated Starknet supporter, don’t miss this opportunity.

hCaptcha is a human verification service similar to Google reCAPTCHA. It is designed to identify and distinguish human users from bots, and to help prevent common web automation attacks such as DoS, malicious bot attacks, and excessive web scraping.

From my own experience, I’m not sure how effective hCaptcha is at blocking bots, but it certainly causes a great deal of inconvenience for actual humans. So let’s figure out a way to bypass hCaptcha and its frequent, pointless image verification challenges:

Bypass hCaptcha via the Accessibility Service

1. Sign up for the accessibility service through this link. Please use a valid, active email address.

2. Check your inbox and click the “Get Accessibility Cookie” button in the email. The link should look something like this:
   https://accounts.hcaptcha.com/verify_email/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

3. Obtain the hCaptcha Cookie via the link

• Clicking the button will redirect you to the hCaptcha settings page.
• Click the “Set Cookie” button, and wait until the text “Cookie set.” appears below the button — then you’re done.

The next time you encounter an hCaptcha challenge, you only need to click the verification checkbox — no more annoying image puzzles.

[Note] hCaptcha has actually documented their accessibility service as well. See the details here.

This article is intended as a popular science piece. It uses analogies to explain Bitcoin’s fundamental principles without delving into the granular details of algorithms and protocols.

The article presents a fictional village called “Bitcoin Village” and tells a story, step by step, explaining Bitcoin’s motivation, the problems it solves, and the objectives and design of its key components.

Bitcoin Village and the Barter System

Once upon a time, there was a small village called Bitcoin Village, home to a few hundred households. The village was virtually isolated from the outside world, living a self-sufficient existence. Without large-scale trade, the villagers had always relied on barter — Old Zhang would trade a sack of flour for one of Old Li’s sheep, and Mrs. Wang would swap a basket of wild fruit for two feet of Mrs. Liu’s cloth. The villagers had been living this simple life all along.

Commodity Money

One day, the villagers decided that barter was just too inconvenient, so the entire village gathered for a meeting to discuss how to solve this problem. Someone proposed using something easily divisible and rare — gold, for example — as a medium of exchange. They would create a conversion table mapping goods to gold: one gram of gold equals one sheep, one gram of gold equals one sack of flour, and so on. Now Old Zhang no longer had to lug a heavy sack of flour all the way to Old Li’s house to trade for a sheep. He could simply pull out a gram of gold, head to Old Li’s, and lead a sheep home. Old Li could then use that gram of gold to buy a sack of flour from anyone willing to sell, or trade it for anything else of equivalent value.

Thus Bitcoin Village entered the era of commodity money.

Symbolic Money

But it didn’t last. Before long, the drawbacks of commodity money became apparent. Gold mines near Bitcoin Village were scarce, and mining and smelting gold was extremely time-consuming and labor-intensive. Meanwhile, gold was constantly being lost to wear, misplacement, or deliberate hoarding. The villagers gathered once again to brainstorm a solution. Someone said, “We don’t actually need to use real gold. Just take any piece of paper, write ‘one gram of gold’ on it, and as long as everyone in the village agrees that this piece of paper equals one gram of gold, problem solved.” Everyone nodded in agreement, but a new issue immediately arose: real gold requires mining and smelting, mines are limited, and the process costs time and resources — no one can conjure vast quantities of gold out of thin air. But writing on paper? As long as you have enough paper and ink, you can write as much as you want. It would devolve into a contest of who has more paper at home — before you know it, ten thousand sheets might buy you just one sheep (this is, in fact, what economics calls inflation).

Good point, everyone thought. But then someone proposed a solution: these notes would only be valid if written by the village elder — a man of great respect whose handwriting everyone recognized. The elder would write out a number of notes and distribute them to each household based on their gold reserves. For example, if Old Zhang had two hundred grams of gold, the elder would issue him two hundred notes, each reading “one gram of gold,” and take Old Zhang’s gold as collateral. In this way, the elder collected all the village’s gold and issued equivalent paper notes. The villagers could now use these notes as currency, and since everyone recognized the elder’s handwriting, no one else could forge them. If anyone’s notes became too worn, they could exchange them for fresh ones at the elder’s house. Furthermore, the elder promised that anyone wishing to convert back to real gold need only return the notes and receive the equivalent amount. Since the gold amount recorded on the notes matched the actual gold stored at the elder’s house, as long as the strict principle of “destroy old notes, issue new ones” was followed, every valid note could always be redeemed for its corresponding amount of real gold.

Thus Bitcoin Village entered the era of symbolic money (paper currency). The village elder assumed the roles of both government and bank.

Centralized Virtual Currency

A few more years passed. The village elder, exhausted from the daily grind of verifying old notes, writing new ones, and meticulously maintaining all the records, eventually worked himself to death.

Bitcoin Village convened another general assembly to discuss what to do. The elder’s son, Ergouzi (literally “Second Doggy”), volunteered to take up his father’s pen and shoulder the responsibility of currency issuance. This young village leader was clever. After a few days of work, he realized he didn’t actually need to write all those paper notes. He could simply do this: have the villagers turn in all their paper notes, destroy them, and instead record each household’s balance in a ledger. From then on, if someone wanted to make a payment — say Old Zhang wanted to pay Old Li one gram of gold for a sheep — the two would simply call Ergouzi, explain the transaction, and Ergouzi would open his ledger, verify that Old Zhang had at least one gram of gold on record, subtract one gram from Old Zhang’s account, and add one gram to Old Li’s. Transaction complete. Upon hearing Ergouzi’s confirmation over the phone, Old Li could confidently let Old Zhang take the sheep.

Thus Bitcoin Village entered the era of centralized virtual currency. No villager needed to make physical payments anymore; the payment process became nothing more than number changes in the ledger maintained by Ergouzi.

Distributed Virtual Currency

Ergouzi was clever, but sometimes too clever for his own good. One day, staring at the ledger, he thought: “The entire village’s wealth is whatever I say it is — couldn’t I just…” On impulse, he secretly transferred ten grams of gold from Old Zhang’s account to his own.

He thought it was the perfect crime, but Old Zhang happened to keep his own records. One day, when Old Zhang tried to make a payment, Ergouzi told him his account was empty. Old Zhang checked his own books — he clearly still had ten grams — and went to confront Ergouzi. The discrepancy revealed the unauthorized transfer.

The scandal broke wide open. Ergouzi’s impeachment was inevitable, but the incident also exposed a fundamental flaw in having the ledger concentrated in one person’s hands:

• The entire system depends on the personal integrity of the ledger keeper. If this person breaks the rules and arbitrarily alters the ledger, the entire monetary system collapses.
• If this person’s house catches fire or the ledger is stolen, it would be equally devastating to the entire system.

Just as everyone was at a loss, a reclusive scientist in the village named Satoshi Nakamoto took the stage. He told everyone he had designed a virtual currency system called Bitcoin that didn’t rely on any central authority, and it could solve all the problems above. Then he calmly laid out his plan.

Let’s see how Satoshi designed this system.

Infrastructure Setup

Satoshi first announced that the existing ledger system would need the following modifications:

1. The ledger would no longer record each villager’s balance. Instead, it would only record individual transactions — specifically, the payer, payee, and amount of each transaction. As long as the ledger’s initial state is established and every transaction record is reliable and time-ordered, each person’s current balance can be calculated.
2. The ledger would change from private to public. Any villager who wanted it could obtain the complete current ledger, containing every transaction record from the ledger’s creation to the present.

The moment he said this, the crowd erupted. The first point was fine, but the second was nearly unacceptable — the ledger records every villager’s transactions, wouldn’t this expose everyone’s privacy?

Satoshi remained calm and produced a pair of peculiar objects.

Identity and Signature Mechanism (Public Key Cryptography)

Satoshi told everyone not to panic. Under his system, no one would transact using their real identity. Instead, each person would use a unique pseudonym.

He showed the two items in his hands, calling them the “secret stamp” and the “stamp scanner.” He would give every household one of each. Their functions:

• The secret stamp can imprint a mark on paper. Each stamp’s imprint contains a string of characters unique to the entire village, but invisible to the naked eye. Nor can the stamp be reverse-engineered by examining its imprint.
• The stamp scanner can scan a stamped mark, read the hidden information, and display a string of characters on its LCD screen.

With these two ingenious devices, villagers could transact without revealing their true identities, and the hidden character string would serve as each household’s pseudonym. The precise mechanism for using stamps and scanners in transactions is detailed below.

Establishing a Virtual Mining Organization (Mining Groups)

Next, Satoshi recruited virtual miners from across the village. The requirements:

• Miners work in groups; a group can be a single household or several households combined.
• Being a miner doesn’t affect normal currency usage.
• Miners must dedicate some time each day to Bitcoin “mining” activities, but unlike gold mining, virtual miners don’t need to go into the field with tools — they can work from home.
• Miners have a certain probability of earning a reward; the more effort put into mining, the higher the probability.
• Miners can quit at any time, and new miners can join at any time.

Before long, about one-fifth of the villagers joined the mining organization, forming seven groups.

Creating the Initial Ledger (Genesis Block)

Next, Satoshi announced that based on Ergouzi’s ledger, all collateralized gold would be returned to each villager according to the recorded balances. Ergouzi’s ledger would then be permanently destroyed.

Satoshi then produced a new ledger. On the first page, he recorded several transactions. Notably, the “payer” column for all these entries read “System,” while the payees were the hidden character strings corresponding to each household’s stamp — representing the system’s initial allocation of a small number of bitcoins to each household. The amounts were very small, just a few coins each, and some unlucky households didn’t receive any at all.

Satoshi then said: since there are very few bitcoins in circulation right now, everyone can go back to using gold as currency for the time being. Since I’m not the village leader, I have no authority to force anyone to accept Bitcoin — everyone can decide for themselves. But as bitcoins flow through transactions and mining activity continues, the supply will gradually increase.

Payment and Transactions

After all this groundwork, we finally arrive at the main event: how payments work in this system. Let’s use Old Zhang paying Old Li 10 bitcoins as an example.

The Payer Signs the Transaction Slip

To pay 10 bitcoins, Old Zhang first asks Old Li for his identifier string — say “ABCDEFG.” Old Zhang’s own identifier is, say, “HIJKLMN.” Old Zhang writes a slip reading “HIJKLMN pays 10 bitcoins to ABCDEFG,” stamps it with his secret stamp, and hands the slip to Old Li. Additionally, to facilitate tracing the origin of these funds, the slip must note where this money came from and which ledger page recorded the source transaction. In this case, Old Zhang’s 10 bitcoins came from the system’s initial allocation, recorded on the ledger’s first page.

The Payee Verifies the Signer

Upon receiving the slip, Old Li needs to confirm it was indeed signed by “HIJKLMN” (i.e., Old Zhang). This isn’t difficult. The slip must bear a secret stamp. Old Li takes out his stamp scanner, scans the stamp, and if the characters displayed on the LCD match the payer’s identifier (in this case, “HIJKLMN”), the signature is confirmed. Thanks to the secret stamp mechanism, no one else can forge a stamp, and anyone can verify whether the signer matches the stated payer simply by scanning.

The Payee Confirms the Payer’s Balance

So far, the system still has a problem. Through the secret stamp, the payee can confirm the payer indeed signed the slip, but cannot independently verify whether the payer has sufficient funds. In the previous centralized system, Ergouzi was responsible for checking balances and notifying payees whether transactions were valid. Now that Ergouzi’s been fired, who handles accounting and transaction validation?

As mentioned earlier, Satoshi designed this as a distributed currency system that doesn’t rely on any central figure. The entity that ultimately bears this responsibility is the mining organization mentioned previously. Old Zhang, Old Li, and every other villager using Bitcoin for transactions all depend on the miners’ work to complete their transactions.

The Miners’ Work

The miners’ work is the core of the entire system and also its most complex part. Let’s walk through their tasks and objectives step by step.

Mining Tools

As the saying goes, “A craftsman must first sharpen his tools.” While Bitcoin miners don’t need pickaxes, shovels, or headlamps, they do need some essential equipment.

Initial ledger. Each group first makes their own copy of the initial ledger, which has only one page recording the system’s first allocation.

Blank ledger pages. Each group has a supply of blank ledger pages. Each page contains only the ledger structure with no content filled in — the rules for writing content are described below. Here’s what a blank ledger page looks like; the meaning of each field will be explained later.

Code generator (hash function). Satoshi also distributed several code generators to each mining group. This device is remarkable: insert a completed ledger page and the machine automatically prints a 256-character string of "0"s and "1"s in the “This Page’s ID” field. The truly magical properties of the code generator are:

• The generated ID depends solely on the content written on the ledger page — it’s independent of who wrote it, the handwriting style, the time of writing, and other factors.
• Ledger pages with identical content always produce the same ID, but changing even a single character produces a completely different ID.
• When printing an ID, the code generator also requires all transaction slips referenced on the page to be inserted. The machine scans for consistency between the transaction slips and the written entries, especially the secret stamps. If any stamp doesn’t match its stated payer, the machine refuses to print.
• When a pre-printed ledger page is inserted, the machine verifies whether the ID was genuinely machine-printed and whether the ID matches the content. The ID cannot be forged.
• Transaction slip mailbox. Each mining group must hang a collection box at their door for receiving transaction slips.
• Bulletin board. Each mining group also needs a bulletin board for posting public notices.

With these tools in hand, the mining organization can get to work.

Collecting Transaction Slips

Satoshi established that anyone initiating a transaction must not only give the transaction slip to the payee but also make several copies and deliver them to every mining group’s mailbox.

Mining groups periodically collect all accumulated transaction slips from their mailboxes.

Filling Out the Ledger

The group then takes a blank ledger page, writes these transactions into the “Transaction List” section, finds the last page of their current ledger, and copies that page’s ID into the “Previous Page ID” field. Note there’s also a “Lucky Number” field — they can fill in any number they like, such as 12345. Then they insert the page into the code generator, which prints an ID. One ledger page is now complete.

If you thought the miners’ job was that simple, you’d be sorely mistaken. Satoshi imposed a fiendish rule: a ledger page is only valid if the first 10 digits of its ID are all zeros.

Based on what we know about the code generator, the only way to change the ID is to change the page’s content. The “Transaction List” and “Previous Page ID” can’t be arbitrarily modified, so the only option is to change the Lucky Number. Thus, to produce a valid ledger page, miners must repeatedly copy out ledger pages with different Lucky Numbers, inserting each one into the code generator. If the resulting ID doesn’t meet the requirement, that page is wasted. They repeat this process until a valid ID is generated.

We know that if each digit of the ID is random, miners must try, on average, over 1,000 different Lucky Numbers to get one valid ID.

So why would miners relentlessly grind away at this seemingly meaningless task? Remember the rewards mentioned earlier — that’s their motivation. Satoshi decreed: the first transaction on every ledger page is “The system pays this group 50 bitcoins.” In other words, if you generate a valid ledger page and it’s accepted by all mining groups, this transaction is also accepted, and your mining group earns 50 bitcoins.

This is why miners are called miners, and why, as mentioned earlier, the supply of bitcoins gradually increases through transactions and mining activity. Below is an example of the mining process, where the group’s public Bitcoin address is “UVWXYZ.”

When the Lucky Number reached “533,” the system generated a valid ledger page.

Confirming the Ledger

When a mining group is lucky enough to produce a valid ledger page, they must immediately notify the other groups to get their work confirmed and earn their reward. As mentioned, there are currently seven mining groups in the village, so the lucky group must transcribe six copies and rush them to the other six groups for confirmation.

Satoshi decreed that when any group receives a ledger page from another group, they must immediately pause their own mining work and perform verification.

Three things need to be confirmed:

1. The page’s ID is valid.
2. The previous page referenced is valid.
3. The transaction list is valid.

For the first check — this is straightforward. Simply insert the received page into the code generator for verification. If it passes, the ID is valid.

For the second check — compare the “Previous Page ID” on the received page against the last page ID in this group’s own ledger. If they match, it’s confirmed. If not, trace backward through the existing ledger to find the matching page. If no matching “Previous Page ID” can be found at all, the group discards the received page and refuses confirmation.

Note that this mechanism ensures that if all groups hold the same set of ledger pages, they can all assemble them in the same order. Since each page’s ID depends on the previous page’s ID, the code generator’s mechanism guarantees that the relative ordering of all valid ledger pages is consistent across every group (there may be branches, but no loops — more on this later).

Finally, confirming the transaction list’s validity means verifying that each payer in every transaction has sufficient balance. Since each transaction includes information about where the funds came from, along with the ID of the ledger page recording the source transaction — for example, HIJKLMN wants to pay ABCDEFG 10 bitcoins and notes that these 10 bitcoins came from a previous payment from OPQRST to HIJKLMN — the verification process first confirms whether this earlier transaction exists, and then checks whether HIJKLMN hasn’t already spent those 10 bitcoins elsewhere. Once all this is confirmed, the transaction’s validity is established.

The first transaction is the 50-bitcoin system reward to the group that produced the page — everyone accepts this by default. For the remaining transactions, the tracing method above can confirm whether HIJKLMN truly has 10 bitcoins to pay ABCDEFG.

If all the above verifications pass, the group accepts the ledger page as valid, appends it to their main ledger, abandons their current work-in-progress, and continues future mining based on this updated main ledger.

Ledger Confirmation Feedback

For the mining group that sent out the page: if they subsequently receive a page from another group whose “Previous Page ID” is the ID of the page they sent out, that means their work has been accepted — because another group is already building on top of it. At this point, they can roughly consider their 50 bitcoins earned.

Additionally, whenever a group generates a new valid page or confirms another group’s page, they post the latest accepted transactions on their bulletin board. Payees who see their transaction acknowledged by the various groups can be fairly confident the money has arrived in their account, and they can reference this transaction as the source of funds in future payments.

This is the complete Bitcoin payment system. Let’s now analyze why this system can sustain itself and what risks it may face.

Analysis of the Operating Mechanism

Although the basic rules of Bitcoin have been explained, the villagers still had many questions. So Satoshi held a special Q&A session to address common concerns. Below is a summary of the most frequently raised issues.

Core Q&A

What if two valid ledger pages are received simultaneously?

Note that in the mechanism described above, mining groups work in parallel. It’s entirely possible that a group receives two different ledger pages, both based on the current last page of the group’s main ledger, and both perfectly valid. What then?

Satoshi explained that groups should not organize the ledger linearly but rather as a tree structure. At any given time, the longest branch serves as the main ledger, while other branches are preserved. For example, if a group simultaneously receives valid pages A and B, they should organize them as a fork, like this:

The black line represents the current main chain. At this point, either page can be chosen as the main branch — let’s say A:

If a new page is produced based on A, the main chain extends:

If this trend continues, it means everyone is essentially working off A as the main chain, and B will be forgotten. But it’s also possible that B suddenly becomes the longer branch:

In that case, we need to switch to B as the main chain and continue working from there.

Looking at the big picture, although different groups’ main chains may temporarily diverge at any given moment, the overall direction remains consistent. Those minor branches that occasionally sprout due to timing differences are quickly buried in history.

What if miners forge the ledger?

Satoshi explained that as long as the majority of the mining organization is honest, the system remains reliable. He addressed this from several angles.

First, thanks to the secret stamp mechanism, no one can forge someone else’s identity for payments, because the code generator checks all transaction slips’ stamps during ID generation and refuses to print if any stamp doesn’t match its stated payer.

Furthermore, honest miners will never approve illegitimate transactions (such as one where the payer has insufficient balance).

Therefore, the only possible attack vector is this: after the payee has confirmed receipt, the attacker creates an alternative transaction on a different branch, cancels the previous payment, and spends the same funds again to someone else (the so-called “double-spending” problem). Let’s illustrate with an example.

Suppose an attacker has 10 bitcoins and plans to pay this same amount to two victims, A and B, getting both transactions accepted.

Step one: The attacker plans to buy 10 bitcoins’ worth of gold from Victim A. He signs a transaction slip transferring 10 bitcoins to Victim A.

Step two: This transaction gets confirmed in the latest ledger page and is posted by the mining groups. Victim A sees the announcement, confirms the bitcoins have arrived, and gives the attacker gold worth 10 bitcoins.

Step three: The attacker goes back to the ledger page just before the one containing the transaction with Victim A and creates a new branch, generating enough pages to overtake the original branch. Since the attacker’s branch is now the main chain, the branch containing Victim A’s payment becomes a side branch. The mining organization no longer recognizes the earlier transfer, and Victim A’s 10 bitcoins are reversed.

Step four: The attacker can now sign another transaction slip, paying the same 10 bitcoins to Victim B. Once Victim B confirms receipt, they hand over gold of equivalent value.

At this point, the attacker has spent the same 10 bitcoins twice, purchasing equivalent gold from two victims. The attacker could repeat this trick — cancel the transaction with Victim B, and pay the same funds to yet another person…

To counter this attack, Satoshi’s recommended solution is that payees should not immediately confirm a transaction when it first appears on the bulletin board. Instead, they should wait and watch for the mining groups to post six more confirmation pages after the one containing their transaction, and only confirm receipt if the original page hasn’t been rolled back.

Satoshi explained that the fiendish ID rules were specifically designed to defend against this. As described earlier, generating a valid ledger page is no trivial matter — it requires massive effort trying different Lucky Numbers, and the process is entirely a matter of luck. If a ledger page containing your incoming payment has six more pages built on top of it, it becomes extremely difficult for an attacker to overtake the current main chain from a branch that’s six pages behind — unless the attacker commands more manpower than all the honest miners combined.

Moreover, if an attacker had that much manpower, it would be far more profitable to simply mine honestly than to waste such enormous resources on this kind of attack. This eliminates the motivation for attacks at a fundamental level.

Won’t bitcoins keep increasing indefinitely, causing severe inflation?

Satoshi said, “I’ve thought of this too. I forgot to mention earlier — the operating manual I gave to the mining organization specifies that initially, generating one ledger page earns a group 50 bitcoins. But every 210,000 pages, the reward halves. For example, after 210,000 pages, each new page earns 25 bitcoins; after 420,000 pages, 12.5 bitcoins; and so on. By the time the ledger reaches 6,930,000 pages, there will be no more rewards for generating new pages. At that point, the total supply of bitcoins will be approximately 21,000,000 — this is Bitcoin’s total supply cap, so it won’t increase indefinitely.”

With no rewards, no one will mine, and there’ll be no one to confirm transactions

By then, miners’ income will shift from mining rewards to transaction fees. For instance, when making a transfer, you can designate 1% as a transaction fee paid to the group that generates the ledger page. Groups will prioritize confirming transactions with higher fees.

If the number of miners keeps growing, will bitcoins be generated faster?

No. Satoshi explained that while anyone can freely join or leave the mining organization, causing the number of miners to fluctuate — and each miner does receive a code generator — he has already built a difficulty adjustment mechanism into the code generators. The more generators currently in operation, the lower each machine’s efficiency, ensuring the rate of new ledger page generation remains constant.

Although everyone uses pseudonyms, if someone’s pseudonym is leaked and the ledger is public, couldn’t all their transactions be traced?

Indeed. For example, to transact with someone, you necessarily need their pseudonym to fill in the transaction slip’s payee field. However, Satoshi said he can provide an unlimited number of secret stamps, and he recommends using a different stamp for each transaction. This way, tracing the ledger won’t reveal all transactions belonging to a single person.

Q&A complete.

Notes

This article uses accessible analogies to explain Bitcoin’s operating mechanism. A few things to note:

For the sake of clarity, I’ve made many simplifications, so some mechanistic details may not perfectly match the actual Bitcoin protocol. However, the overall philosophy and key principles are consistent.
Since many concepts from the computer world (such as public key cryptography and network transmission) don’t have perfect real-world equivalents, some parts of the story may feel a bit forced or unrealistic.
This article describes the technical principles and operating mechanism of the Bitcoin network itself. When trading Bitcoin on exchanges like Mt. Gox, the exchange acts as an intermediary and does not follow the mechanism described above.

References

1. Bitcoin Whitepaper (English)
2. Bitcoin Whitepaper (Chinese)
3. Bitcoin Wiki (English)
4. Cloud Wu’s Blog: “Basic Principles of Bitcoin”

via. Original article

A product person must first understand the balance between business value and user value — that is, what do we gain through the product, and what does the user gain? This is the innermost core of user experience. From there, you peel back the layers one by one. Unfortunately, most products on the market are fixated on the surface layer — the flashy, eye-catching design and interaction. I’ve always felt this is the lingering poison of the book “Everyone Is a Product Manager.”

A good product, beyond having a thorough grasp of the five layers of experience, must also have foresight. A big, comprehensive product is easy to copy, but at the cost of time — and your strategy, tactics, and resource allocation may not even be aligned. What’s truly impressive is your product sequencing: each move serves as the setup for the next. Simplicity doesn’t mean you haven’t thought things through — quite the opposite. See far, step close, think more, do less. Validate, then iterate fast.

And a truly outstanding product? It finds the critical mission within a red ocean and strikes with dimensional advantage.

Since 2010, I’ve been blogging for over a decade^[1], having changed domains five times, themes over a dozen times, and CMS platforms twice^[2]. Perhaps because of my design background^[3], I was overly fixated on the presentation layer — chasing aesthetics and perfection. With plenty of free time as a student, I poured enormous effort into themes, plugins, and server maintenance. Others might see this as a waste of time, but for me back then: the thrill of tinkering to satisfy my own needs and ideas could only be described as “euphoria.”

This is why I say: independent blogging has three great pleasures — themes, domains, and CMS platforms. But pleasure is for yourself; value is for your readers.

The value of a blog lies in its content — good, useful content.

Blog Theme: Clean is enough. It should present content clearly and be easy to read — a bit rough around the edges is perfectly fine. A search box so readers can find what they’re looking for, and a comment box so you can converse with them — that’s all you need.

Domain: Ideally short and memorable at a glance, but it’s no big deal if it isn’t. Domains carry less and less weight these days. The principle should be: use what you have, as long as it works. Don’t be like me, constantly switching. I only do it because of a personal hang-up, but it’s really not necessary. If the content is good enough, I’ll bookmark even the most ungainly domain.

CMS Platform: As long as it works — the simpler, the better, even. Don’t let the tool limit you, and don’t make the startup cost of writing too high. These days I just finish writing in my notes app and paste-publish with one click, completely ignoring all those bells and whistles in the backend. The unformatted, plain-text approach to writing is simply wonderful.

This might sound a bit “utilitarian,” but as long as you’re comfortable, anything goes.

What I’m really doing here is a reflection — one I should have written four years ago. I used to be overly obsessed with surface-level flash (and this goes beyond blogging). Being a designer, there was nothing wrong with that per se. It wasn’t until I transitioned to product management that I realized beneath the dazzling surface lies something invisible. User experience isn’t just about the framework and presentation layers — dig deeper and you’ll find structure, scope, and strategy. It’s not enough to just make features look good and feel smooth. The balance between business value and user value — that’s the true core of experience.

When it comes to writing and blogging, the quality of your domain or the beauty of your theme are by no means prerequisites for a good blog. Strive for quality, but don’t obsess over perfection. Put your energy into the content — that’s what truly matters.

Distinguishing between “truly wealthy” and “pretending to be wealthy” is important. At minimum, one should meet the following two criteria to be considered “wealthy” — Andrew Hallam shares this view:

1. Being able to choose not to work without worrying about making ends meet.
2. Holding investments that guarantee lifetime earnings at twice the national median household income. (In 2020, Shanghai’s median household annual income was 240,000-600,000 RMB.)

iOS Workday Smart Alarm

iOS alarms have never supported automatic on/off based on China’s official public holidays. Today I came across a fully automated solution via Shortcuts on @scomper’s blog. It works by subscribing to a Chinese public holiday calendar combined with Shortcuts, or through an online API plus Shortcuts processing.

Full tutorial here: iOS Workday Alarm Clock

iPhone 12

The iPhone 12 is finally here — pre-orders open at 8 PM tomorrow. I’ve been using my iPhone 7 for four years, so it’s finally time for an upgrade. This time I won’t be buying through the official Apple Store. I’ll look into supplier channels or Pinduoduo instead — the price difference should be enough to cover installment fees.

Resume

I’ve been helping Teacher Wu revise his resume recently, which has also sparked the idea of updating my own. My past few job switches didn’t require a resume, so the current version still reflects my time as a designer. I can set aside some time this weekend to put together a product-focused resume and take stock of my years in product management along the way.

Last night while taking a shower, it struck me again. In the world of Xianxia (cultivation fantasy) novels, there are all kinds of cultivation methods. Cultivating spiritual energy internally, tempering the body externally, refining pills with one hand and forging artifacts with the other. Isn’t this exactly analogous to the various professional roles in my work — product management, operations, business development, and so on?

And the geniuses of the cultivation world? Perhaps they are the ones who can both venture outward and cultivate their inner strength.

Some people possess formidable spiritual power. Others combine that spiritual power with being a rare pill-refining master. The more disciplines one masters, the higher one’s “cultivation talent and realm.” And in this system, cultivation talent and realm refer more to diligence, serendipity, the passage of time, and the insights gained from life-or-death battles.

Indeed, all paths lead to the same destination.

Seen in this light, this infinite game grows ever more fascinating — ever more “gamified.”

I asked @desin (the author of the “I Love Boiled Fish” blog) if there was a way to add classes without writing JavaScript. He suggested I look into the content filter documentation. After some research, the problem was solved.

Here’s the code — feel free to use it as reference. Copy the following and paste it right below the <?php line in your theme’s functions.php file:

# Automatically add img-res class to img tags in post contentfunction img_paragraph($content){    return preg_replace('/<img([^>]+)?>/', '<img$1 class="img-res">', $content);}add_filter('the_content', 'img_paragraph');

Similarly, if you want to target p tags, the code would be:

# Automatically add mt1em, mb1em, and lh-180 classes to p tags in post contentfunction p_paragraph($content){    return preg_replace('/<p([^>]+)?>/', '<p$1 class="mt1em mb1em lh-180">', $content);}add_filter('the_content', 'p_paragraph');

It turns out that when WordPress upgrades its core, themes, or plugins, it switches to maintenance mode. During this time, visiting the front end displays “Briefly unavailable for scheduled maintenance. Check back in a minute.” If the upgrade goes smoothly, it returns to normal within seconds. However, poor network conditions or other issues can cause the upgrade to stall, leaving WordPress permanently stuck in maintenance mode — both front end and back end showing “Briefly unavailable for scheduled maintenance. Check back in a minute.”

How to Fix This

Delete the .maintenance file in your website’s root directory.

.maintenance is a hidden file that typically won’t show up when browsing via FTP. I recommend using SSH instead. Follow these steps:

1. cd /home/xxx/xxx — navigate to the root directory of the affected WordPress site.
2. ls -a — list all files in the current directory, including hidden ones. Check if .maintenance exists; if so, proceed to delete it.
3. rm -rf .maintenance — press Enter to delete. Problem solved.

This not only improves the visitor experience but also transfers domain authority and search engine indexing. This article documents the methods for implementing 301 redirects.

Using WordPress to Implement URL-Specific 301 Redirects

1. Please note: this method requires keeping the original WordPress files on the old domain. If you’ve already run a SQL find-and-replace on the domain in the original codebase and the old domain no longer has a separate WordPress installation, this method won’t work.
2. Locate the wp-blog-header.php file in your WordPress root directory and add the following code below the first <?php line:

// WordPress domain change 301 redirect// Replace imzl.com with your new domainif (strtolower($_SERVER['SERVER_NAME'])!='imzl.com'){$URIRedirect=$_SERVER['REQUEST_URI'];if(strtolower($URIRedirect)=="/index.php"){$URIRedirect="/";}header('HTTP/1.1 301 Moved Permanently');header('Location:https://imzl.com'.$URIRedirect);exit();}

3. Replace the corresponding file on your server. Done.

Using Nginx to Implement URL-Specific 301 Redirects

This method does not require keeping the WordPress codebase.

1. Locate your Nginx configuration file and add the following code below the server_name directive:

// Replace imzl.com with your new site's domainreturn 301 https://imzl.com$request_uri;

2. Upload the modified Nginx configuration file and restart Nginx via terminal using the service nginx restart command.

These past few days, my WeChat Moments feed has been flooded again. The story that went viral was written by a young man named Niko, titled “Youth Shall Not Be Bullied,” calling out Youku and Momo. The gist is that Niko and a few friends planned an event to “photograph the Earth from a weather balloon” — and they pulled it off. Afterward, an editor surnamed Wang from Youku contacted Niko to discuss a collaboration. After learning the full details of the kids’ planning and execution, this editor shelved the shoot under various pretexts, then went ahead and had someone else produce a creative short film based on the same concept.

Niko provided emails, audio recordings, and video evidence to support his accusations. The story largely checks out with Niko’s account. The article has been shared over 100,000 times, sparking a massive wave of public outrage against Youku and Momo.

Judging the matter on its own merits, the editor surnamed Wang at Youku deserves condemnation. Using “collaboration” as a pretext, he gained the kids’ trust, extracted key information, then kicked them to the curb. Sound familiar? You may have encountered variations of this playbook: a company planning a redesign invites several design agencies to bid, listens to all their creative pitches, then cancels the bidding process under various excuses — only to base their redesign on those agencies’ proposals. Or a VC invests in one product, then meets with several of its competitors, extracts their strategies, and feeds them to the team they’ve already funded…

Behind all of this lies a single mentality: stealing ideas doesn’t count as stealing — it’s not even a thing. I’ve been through this a few times myself. I wanted to build a product, and the other party also wanted to build something similar. They claimed they wanted to bring me on board, talked with me extensively to understand my ideas, then booted me out with the excuse that I wasn’t a good fit for their team. The resulting product was riddled with my original ideas. Fortunately, it ended up being lukewarm — otherwise I might have stepped forward to brag about it and gotten my fifteen minutes of fame too.

I can’t guarantee that “The Kids Who Chased Balloons” isn’t a publicity stunt. In an internet awash with manufactured controversies, any topic inevitably carries a whiff of hype. Niko clearly came out of this incident with substantial gains — perhaps even more exposure than a smooth collaboration with Youku would have brought. After all, people who sympathize with the underdog and consider themselves righteous still make up the majority. As for Momo, who appeared to be an innocent bystander, they too seem to have benefited enormously — without spending a dime, they got another massive wave of shares and comments (exposure), and even harvested sympathy through their PR response. Youku, sitting at the center of the storm, could have also come out as a winner if they’d handled things properly — but alas… well.

As for the truth of the matter, outsiders can only speculate. Only those directly involved will ever truly know.

By default, WordPress or your hosting provider controls the maximum upload file size. If you try to upload a file exceeding the preset limit, the upload will fail. This article explains several ways to customize the upload file size limit.

Check the Default WordPress Upload File Size

Navigate to “Media - Add New” in the dashboard menu. On this page, you’ll find your site’s current default upload size limit. As shown in the screenshot below, my WordPress site has a default upload limit of 10MB. In this article, I’ll demonstrate several methods to change this limit to 20MB — feel free to set your own value.

Contact Your Hosting Provider

If you’re using a managed WordPress hosting platform, these platforms typically offer a default option to customize the file upload size limit (in most cases, the settings page can be found in your server management dashboard).

Take Cloudways as an example: after logging in, navigate to the “Settings & Packages” page from the menu. In the UPLOAD SIZE field, enter your desired maximum upload file size and click Save.

Modify or Create a php.ini File

php.ini is a configuration file located in the root directory. Some providers may name it “php5.ini.” It contains a series of settings including maximum upload file size, maximum execution time, upload directory, global variable controls, and more.

For security reasons, most hosting providers keep it hidden. To find this file, you’ll need to access the server’s root directory and may need to show hidden files. If you still can’t find it, create one yourself — just make sure the configuration it contains is correct. If you’re unsure what configuration values to include, a quick search will turn up plenty of detailed guides.

To set the maximum upload size to 20MB, we need to change upload_max_filesize to 20 and post_max_size to around 25MB.

upload_max_filesize = 20Mpost_max_size = 25Mmemory_limit = 30M

Note: “M” stands for “MB.” memory_limit should be equal to or greater than upload_max_filesize — to be safe, I’ve set it to 30MB.

Modify/Create an .htaccess File

.htaccess stands for “distributed configuration file.” It’s a configuration file used by the Apache server. It’s typically located in the root directory and may be hidden — you can find it by enabling the display of hidden files.

If you locate this file, simply copy and paste the following code to achieve our goal:

php_value upload_max_filesize 20MBphp_value post_max_size 25MBphp_value memory_limit 30MB

Modify WordPress Configuration

The three methods above are what I consider the most reliable approaches. If none of them work, you can try pasting the following code into WordPress’s wp-config.php or your active theme’s functions.php:

@ini_set( 'upload_max_size' , '20MB' );@ini_set( 'post_max_size', '25MB');@ini_set( 'memory_limit', '30MB' );

Control Upload Size via a WordPress Plugin

One of the main reasons I love WordPress is its comprehensive ecosystem, with countless plugins that can solve virtually any problem. If you’d rather skip the manual configuration, I recommend a plugin called “Increase Max Upload Filesize.”

Search for and install it from the backend plugin directory. Once installed, go to its settings page and enter the desired size limit in bytes (1,024,000 bytes = 1 MB). If, like me, you want to set it to 20MB, simply enter 20480000 and click Save.

Still Haven’t Solved Your Problem?

If none of the five methods listed above resolved your issue, it’s simple — you can leave a comment and let me know, or reach out to your hosting provider via support tickets or email. They should be able to help.

If you’re the sole user of your WordPress site, you can always upload files via FTP to /wp-content/uploads/, then use the Media from FTP plugin to make those FTP-uploaded files appear in your media library.

From an efficiency standpoint, I’m not a fan of reinventing the wheel, so I searched for some existing code snippets. This post is purely a memo for myself.

Exclude Specific Posts or Pages by ID

//Exclude specific posts or pages by ID from search resultsfunction Bing_search_filter_id($query) {if ( !$query->is_admin && $query->is_search) {$query->set('post__not_in', array(13,14));//IDs of posts/pages to exclude}return $query;}add_filter('pre_get_posts','Bing_search_filter_id');

Exclude All Posts Under Specific Categories

//Exclude all posts under specific categories from search resultsfunction Bing_search_filter_category( $query) {if ( !$query->is_admin && $query->is_search) {$query->set('cat','-11,-13'); //Category IDs; prefix with minus sign to exclude; without the minus sign, search is limited to that category}return $query;}add_filter('pre_get_posts','Bing_search_filter_category');

Exclude All Pages from Search Results

//Exclude all pages from search resultsfunction search_filter_page($query) {if ($query->is_search) {$query->set('post_type', 'post');}return $query;}add_filter('pre_get_posts','search_filter_page');

This feature is quite unfriendly for my use case. When I enter code in the editor, what gets displayed isn’t the original code, and readers who copy it are in for a bad time. If your blog, like mine, doesn’t really need this feature, you might as well disable WordPress’s full-width/half-width character conversion altogether.

Add the following code to your current theme’s functions.php file:

//Disable content conversionremove_filter('the_content', 'wptexturize');//Disable excerpt conversionremove_filter('the_excerpt', 'wptexturize');//Disable comment conversionremove_filter('comment_text', 'wptexturize');

Done. If you, like me, prefer writing in a plain-text environment, you can also combine this with the method described in “Change the WordPress Editor Default View to HTML/Text” to make the WordPress editor default to the non-visual text editor with character conversion disabled.

Every time I head to the WordPress backend to publish an article, I have to click “Text” first before I can paste in my content. It’s just too tedious.

So, as per the usual routine, let’s tweak the WordPress default settings and switch the editor’s default view to “HTML/Text.”

Add the following to your current WordPress theme’s functions.php:

add_filter('wp_default_editor', create_function('', 'return "html";'));

And that’s it — done.

How to fix the theme recognition issue under LNMP:

1. Locate php.ini — it’s typically found in the /usr/local/php/etc directory on the server.
2. Open php.ini, search for “disable_functions”, find and remove “scandir” from the list that follows, then save the file.
3. Restart the PHP service on your server for the changes to take effect.