kenji.blog

[Complete Guide] What is a Quantum Computer? ~The Ultimate Computing Principle from Scratch~

Sat, 05 Sep 2026 22:10:00 +0900

Introduction: The “Paradigm Shift in Computing” Brought by Quantum Computers

In recent years, not a day goes by without seeing the term “quantum computer” in the news or technical articles. Sci-fi-like stories are often told, such as “calculations that would take current supercomputers thousands of years can be finished in minutes” or “all current cryptographic technologies might be broken.” Giant IT companies like Google, IBM, and Microsoft, as well as universities and startups worldwide, are fiercely competing to commercialize this dream technology.

However, if asked, “What exactly is a quantum computer?”, few people could answer accurately. Many have a vague image of a “magic box that can calculate all combinations simultaneously,” but strictly speaking, that is incorrect.

In this article, we will thoroughly explain from the basics how quantum computers fundamentally differ from classical computers (the PCs and smartphones we usually use), and how they utilize mysterious phenomena of quantum mechanics such as “Superposition,” “Entanglement,” and “Quantum gates” for calculations, in a professional yet easy-to-understand manner. By the time you finish reading this article, you should clearly understand the essential greatness of quantum computers and their current challenges.

Chapter 1: The Crucial Difference Between Classical and Quantum Computers

To understand how a quantum computer works, we first need to review how the “classical computers” we currently use operate.

Comparison Table: Classical Computers vs Quantum Computers

Item	Classical Computer	Quantum Computer
Basic Unit	Bit (0 or 1)	Qubit (superposition of 0 and 1)
State Representation	Deterministic	Probabilistic (undetermined until observed)
Calculation Method	Sequential processing (requires physical cores for parallelization)	Quantum parallelism (manipulates exponential states simultaneously)
Excels at	Arithmetic operations, everyday data processing	Prime factorization, quantum chemistry calculations
Error Tolerance	Very strong	Very weak (requires cryogenic environments and error correction)

The World of Classical Computers: The “Bit” of 0 or 1

Classical computers represent all information in a state of either “0” or “1”. This is called a Bit. Physically, it is represented by whether the voltage of a transistor on a semiconductor chip is high (1) or low (0). The high-quality photos on your smartphone, the text you are reading now, and your favorite YouTube videos are all ultimately reduced to a massive sequence of 0s and 1s. Computation is nothing more than the process of applying operations to this sequence of 0s and 1s by combining basic logic circuits such as AND, OR, and NOT. This is a very reliable and deterministic world. If the input is the same, you will always get the same output.

The World of Quantum Computers: The “Qubit” That is Both 0 and 1

On the other hand, the smallest unit of information in a quantum computer is called a Qubit (Quantum bit). The biggest feature of a qubit is that, unlike a classical bit which is strictly either “0” or “1”, it can take on a state where “0 and 1 are mixed with specific probabilities.” This is called “Superposition”.

For example, if a classical bit is a coin placed with either “heads” or “tails” facing up, a qubit is often compared to a “coin constantly spinning in the air.” A spinning coin cannot be said to be heads or tails; both states are superimposed. And the moment the coin falls to the floor and stops moving (in quantum mechanics, this is called “observation”), it is determined as either “heads” or “tails” for the first time.

Quantum computers incorporate this very property unique to the microscopic world (quantum mechanics)—where “the state is not determined until observed”—directly into the information processing process.

Chapter 2: Three Quantum Mechanical Properties That Fundamentally Change Computing

The source of the astonishing computing power of quantum computers is not simply a high clock frequency or small components. It lies in utilizing the laws of physics themselves as computational resources. The following three quantum mechanical phenomena are the keys.

1. Superposition and Exponential Information Capacity

As mentioned earlier, a qubit can simultaneously hold the states of both 0 and 1. One qubit is a “superposition of 0 and 1,” but what happens when you increase the number of qubits?

1 Qubit: Superposition of 2 states (0, 1)
2 Qubits: Superposition of 4 states (00, 01, 10, 11)
3 Qubits: Superposition of 8 states
N Qubits: Superposition of $2^N$ patterns

With just 50 qubits, you can simultaneously hold $2^{50}$ (about 1.1 quadrillion) states. And with just 300 qubits, you can hold $2^{300}$ patterns at once—a number greater than all the atoms in the universe! This exponential information holding capacity is the foundation of a quantum computer’s potential. It is physically impossible for a classical computer to store more states in memory than there are atoms in the universe.

2. Entanglement: Spooky Action at a Distance

Quantum entanglement is such a counter-intuitive and mysterious phenomenon that Albert Einstein called it “Spooky action at a distance” and refused to accept it throughout his life.

When multiple qubits enter a state of “quantum entanglement,” they become strongly linked to each other, forming a shared destiny: “when the state of one is determined, the state of the other is instantly determined, no matter how far apart they are.”

For example, suppose we have two entangled qubits A and B (each in a superposition of 0 and 1). If we observe A and find it to be “0,” the state of B is instantly determined (for example, to definitely be “1”), exceeding the speed of light, which is the limit of information transmission. In quantum computers, this entanglement is used to represent complex correlations between multiple qubits and perform massively parallel information processing. Without entanglement, the computing power of quantum computers would not be much different from that of classical computers.

3. Quantum Interference: The Magic That Brings Out the Right Answer

You might think, “If it can hold all patterns simultaneously, couldn’t it calculate them all at once in parallel and output the answer instantly?” This is the most common misconception about quantum computers. Even if you calculate in a superposition state, you must “observe” to finally know the answer. However, the moment you observe, the state randomly collapses into one of the $2^N$ patterns. This would just give you a random answer.

Here is where “Quantum Interference” comes in. When waves collide, they strengthen each other where their wavelengths match, and cancel each other out where they are out of sync (the principle is essentially the same as noise-canceling headphones).

An excellent “quantum algorithm” masterfully manipulates quantum states during the computation process so that “the probability amplitudes of states (waves) leading to the correct answer amplify each other” and “the probability amplitudes of states leading to incorrect answers cancel each other out.” It is designed so that when ultimately observed, the “correct answer” pops out with a probability as close to 100% as possible. Designing this interference process well is the very essence of quantum programming.

Chapter 3: How Do They Compute? “Quantum Gates” and “Quantum Circuits”

Just as classical computers use logic gates (AND, OR, NOT, etc.) to perform calculations, quantum computers apply operations called “Quantum Gates” to qubits to advance calculations. A combination of multiple quantum gates is called a ** Quantum Circuit**.

The state of a qubit is mathematically represented as a point on the surface of a 3-dimensional sphere called a “Bloch sphere.” The North Pole is “0”, the South Pole is “1”, and the equator represents a state where “0 and 1 are equally superimposed.” A quantum gate is nothing more than an operation that rotates the state (vector) on the surface of this sphere.

Let’s introduce some representative quantum gates.

1. Hadamard Gate (H Gate)

This is the most fundamental gate unique to quantum computers, not found in classical computers. When a qubit exactly in the “0” state passes through an H gate, it creates a “perfect superposition state” (a point on the equator of the Bloch sphere) where 0 and 1 are observed with exactly 50% probability each. As an initialization step for quantum computation, many algorithms begin by applying this H gate to all qubits.

2. Pauli Gates (X, Y, Z Gates)

These gates correspond to the NOT gate (flipping 0 to 1, and 1 to 0) of classical computers. On the Bloch sphere, they correspond to 180-degree rotations around the X, Y, and Z axes. The X gate, in particular, flips the North Pole (0) to the South Pole (1), working exactly the same as a classical NOT gate. The Z gate has the role of flipping the “phase” (like the timing of a wave) of a superposition, which is extremely important for causing quantum interference.

3. CNOT Gate (Controlled NOT Gate)

This is a hyper-important gate for creating quantum entanglement. It uses two qubits (a control bit and a target bit). It operates as follows: “If the control bit is 1, flip the state of the target bit (apply an X gate). If the control bit is 0, do nothing.” At first glance, it looks like a simple IF conditional branch, but what happens if the control bit is in a “superposition state of 0 and 1”? The target bit becomes a “superposition of flipped and unflipped states,” and the destinies of the two bits become completely linked. The two qubits beautifully become “entangled.”

By placing and applying these gates in sequence from left to right like a musical score, complex algorithms are executed.

Chapter 4: What Are Quantum Computers Good At, and What Are They Bad At?

Here is an important fact: quantum computers are not omnipotent gods. For everyday tasks like web browsing, video rendering, Excel macro processing, or running general smartphone apps, quantum computers will probably never surpass classical computers. Classical computers, which are already highly optimized and boast overwhelming speed and low cost, are better suited for these sequential processes.

Quantum computers truly shine only when applied to “specific problems where the combinations of calculations explode exponentially for classical computers, taking time comparable to the age of the universe.” This is called “Quantum Supremacy” or “Quantum Advantage.”

What Quantum Computers Excel At (Killer Applications)

1. Prime Factorization and Cryptanalysis (Shor’s Algorithm)

Currently, secure communications on the Internet (such as credit card payments and sending personal information) are protected by “RSA encryption,” which is based on the premise that “prime factorization of huge numbers is practically impossible (takes an enormous amount of time) for classical computers.” However, by using “Shor’s Algorithm” discovered by mathematician Peter Shor in 1994, a quantum computer can skillfully use interference to solve this at a dramatic speed (polynomial time). Because of this, there is a risk that the current cryptographic systems will collapse in the future, and central banks and government agencies worldwide are rushing to transition to “Post-Quantum Cryptography.”

2. Quantum Chemistry Calculations, New Materials, and Drug Discovery

The behavior of molecules and atoms in the natural world originally follows the laws of quantum mechanics. When trying to simulate the behavior of complex molecules on a classical computer, the combinations of electron interactions explode, hitting the computational limits even for relatively small molecules. As Nobel laureate Richard Feynman said, “Nature isn’t classical, dammit, and if you want to make a simulation of nature, you’d better make it quantum mechanical,” quantum computers exert overwhelming native power in material simulations. Breakthroughs that solve humanity’s challenges are expected, such as the design of revolutionary new drugs, the discovery of room-temperature superconductors, the development of highly efficient solar cells and battery materials, and the synthesis of energy-efficient fertilizers.

3. Combinatorial Optimization Problems and Search (Grover’s Algorithm)

Quantum algorithms also demonstrate power for problems that involve finding the optimal choice from an enormous number of options (logistics route optimization, financial portfolio optimization, etc.). By using “Grover’s Algorithm,” the target data can be found from an unsorted database in the square root of the time it would take a classical computer. For example, if there are 100 million pieces of data, a search that takes a maximum of 100 million tries classically can be completed in just about 10,000 tries.

Chapter 5: The Hardware Walls In the Way: “Decoherence” and “Quantum Error Correction”

Although theoretically magically powerful, the path to practical application of quantum computers is blocked by extremely high and steep physical walls. The biggest enemy is “Noise”.

The “superposition” and “quantum entanglement” of qubits are extremely delicate and fragile states. Even the slightest ambient heat, electromagnetic fluctuation, or cosmic rays can instantly cause that magical state to collapse, turning it into just a classical bit. This phenomenon is called “Decoherence”.

The Fierce Competition of Physical Implementation Methods

Currently, there is a battle for supremacy worldwide regarding how to physically create these delicate qubits.

Superconducting Method: Adopted by Google, IBM, Amazon, etc. It uses loop-shaped superconducting circuits and controls the quantum state by cooling it to a cryogenic temperature close to absolute zero (about -273°C) using massive refrigerators. It is currently the most advanced method and the easiest to scale up the number of qubits, but the cooling equipment is huge and expensive.
Trapped Ion Method: Adopted by IonQ, Quantinuum, etc. It traps ions (atoms) in a vacuum using electromagnetic fields and controls them by shining precise lasers. Its strength is that all qubits are uniform and can maintain their state for a long time (long coherence time), but the operation speed is slower compared to superconducting.
Photonic Method: Focused on by PsiQuantum, etc. It uses particles of light (photons). It has the great advantage of not requiring a cryogenic environment and mostly operating at room temperature, while being highly compatible with existing silicon chip manufacturing and fiber-optic communication technologies.
Topological Method: Researched for a long time by Microsoft. It is an ambitious approach trying to create qubits fundamentally robust against environmental noise (resistant to errors) by utilizing the topological properties of special particles called anyons. It is theoretically the strongest, but the physical realization hurdle is considered the highest.

The Path to the Ultimate Goal: “Fault-Tolerant Quantum Computer (FTQC)”

Calculation errors (like bit flips from cosmic rays) also exist in today’s classical computers, but they are perfectly corrected by “error-correcting codes,” so we can use our smartphones without ever noticing an error. To perform practical large-scale calculations on a quantum computer, similar “Quantum Error Correction (QEC)” is essential.

However, because quantum states have the property of “breaking when observed,” there is a fatal dilemma: you cannot directly look inside (observe) to check for errors. To avoid this, theories have been established (like surface codes) that skillfully combine many unstable “physical qubits” to build one stable “logical qubit” that can detect and correct errors. However, it is said that 1,000 to 10,000 physical qubits are needed to create just one logical qubit. Executing Shor’s algorithm using thousands of logical qubits would require a massive system with millions to tens of millions of physical qubits overall.

We are currently in what is called the era of NISQ (Noisy Intermediate-Scale Quantum) devices. These are transitional machines operating with tens to hundreds of qubits without error correction. Experts predict that it will take a long-term research and development period of 10 to several decades to realize the ultimate goal, a fully error-correctable “Fault-Tolerant Quantum Computer (FTQC)”.

Chapter 6: History and Future Prospects of Quantum Computers

Finally, let’s take a bird’s-eye view of how quantum computers were born and where they are heading.

From the Birth of the Theory to the Demonstration of “Quantum Supremacy”

1980s: Physicists Paul Benioff and Richard Feynman proposed the concept of a computer using the principles of quantum mechanics. The phrase “If you want to make a simulation of nature, you’d better make it quantum mechanical” was the starting point.
1994: Peter Shor published a quantum algorithm for prime factorization (Shor’s algorithm). It shocked the world and triggered a massive influx of research funding.
1996: Lov Grover published Grover’s algorithm to speed up data search.
**2019 **: A historical milestone. Google announced that using its 53-qubit superconducting processor “Sycamore,” it completed a random number generation verification calculation in about 200 seconds that would have taken a classical supercomputer 10,000 years (so they claimed). This caused a sensation as the world’s first declaration of demonstrating “Quantum Supremacy” (although IBM and others later improved the classical supercomputer algorithm and argued it could be calculated in a few days, leading to heated debates).
From 2023 onwards: IBM announced the processor “Condor” with over 1,000 qubits. Furthermore, early demonstrations of error correction technology are being reported one after another, such as Harvard University’s success in creating and manipulating “logical qubits.”

Towards the Technology of the Next Generation

A quantum computer is not merely a “next-generation CPU with a faster clock speed.” It is a true paradigm shift in computer science, fundamentally rewriting the concept of computation itself with the rules of quantum mechanics that govern the microscopic world.

We will probably not have a “personal quantum smartphone” that fits in our pockets during our lifetime (and there is no need for one). However, the future is steadily approaching where powerful quantum data centers behind cloud networks like AWS and Azure might one day suddenly discover a cure for an incurable disease, or calculate dream clean energy materials to solve global warming (for example, catalysts to synthesize ammonia from atmospheric nitrogen at room temperature).

We are currently in a dawn comparable to the 1940s ENIAC, which ran on punch cards while the heat from its massive vacuum tubes made the whole room hot. However, top-level researchers and engineers worldwide are pooling their wisdom, and technical breakthroughs are reported daily. We, who can witness the evolution of this new “dawn of computing” in real time, can be said to live in a historically very exciting era.

The door to the quantum world has just been opened. Keep an eye on future developments.

This article aims to explain the basic concepts of quantum computing in an easy-to-understand manner for business professionals and the general public interested in technology. Please note that some rigorous mathematical and physical definitions (such as bra-ket notation and details of complex probability amplitudes) have been partially simplified.

[PQC] The Complete Guide to Post-Quantum Cryptography in the Quantum Computer Era

Sat, 05 Sep 2026 22:09:22 +0900

Introduction: The “Threat” Quantum Computers Pose to Cryptography

Currently, many of the communications we conduct daily on the internet—such as online banking payments, website browsing (HTTPS), messaging app exchanges, and blockchain/crypto asset transactions—are protected by a technology called “Public Key Cryptography”. Specifically, algorithms like RSA and Elliptic Curve Cryptography (ECC) form the foundation supporting the reliability of our modern digital society.

These cryptographic methods rely on mathematical hard problems, such as “prime factorization of large numbers” and the “discrete logarithm problem,” which would take astronomical amounts of time for current classical computers (including supercomputers) to solve. However, when “quantum computers,” which have been making remarkable progress in recent years, become practically viable, this premise will be fundamentally overturned.

Shor’s Algorithm, introduced by Peter Shor in 1994, mathematically proved that a sufficiently powerful quantum computer could solve prime factorization and discrete logarithm problems in an extremely short time. This means there is a risk that all cryptographic communications currently protecting the internet will eventually be decrypted (an issue known as Y2Q: Years to Quantum, or Q-Day).

Even more serious is the existence of the “Harvest Now, Decrypt Later” attack method (stealing and storing data now to decrypt it in the future when cryptography can be broken). Data that needs to remain confidential for decades, such as state secrets, corporate intellectual property, and personal biometric information, may already be the target of theft with the premise of future decryption.

To respond to this unprecedented crisis, cryptographers and research institutions around the world are working together to develop Post-Quantum Cryptography (PQC), a next-generation cryptographic technology designed to maintain security against attacks by quantum computers. This article will explain the basics of PQC, the mechanisms of its major algorithms, and the latest trends in global standardization driven by the National Institute of Standards and Technology (NIST).

What is Post-Quantum Cryptography (PQC)?

Post-Quantum Cryptography (PQC) is a general term for cryptographic algorithms designed to run on existing classical computers while also being resistant to attacks by large-scale quantum computers expected in the future (such as Shor’s algorithm).

It is often confused with “Quantum Cryptography” or “Quantum Key Distribution (QKD),” but these take entirely different approaches. Quantum Cryptography (QKD) is a hardware-based technology that uses the physical laws of quantum mechanics (such as the property that observing a quantum state changes it) to make eavesdropping on communication paths physically impossible. It requires dedicated optical fibers and specialized equipment, posing challenges related to deployment costs and distance limitations.

On the other hand, PQC is strictly a software-based cryptographic technology based on “mathematics.” Therefore, it can be integrated into existing internet infrastructure, servers, smartphones, and browsers as software updates, making it highly applicable to the real world. IT companies and government agencies around the world consider replacing (migrating) the currently used RSA and ECC with PQC as an urgent priority.

The 4 Major Mathematical Approaches Supporting PQC

Various PQC algorithms have been proposed based on mathematical hard problems (such as NP-hard problems) that cannot be solved efficiently even with a quantum computer. Here, we introduce the four main categories currently in the mainstream.

Major Approaches to Post-Quantum Cryptography (PQC)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


graph LR
 PQC[Post-Quantum Cryptography PQC] --> L[Lattice-based Cryptography]
 PQC --> H[Hash-based Cryptography]
 PQC --> M[Multivariate Cryptography]
 PQC --> C[Code-based Cryptography]

 L --> L1(FIPS 203: ML-KEM)
 L --> L2(FIPS 204: ML-DSA)

 H --> H1(FIPS 205: SLH-DSA)

 style PQC fill:#f9f,stroke:#333,stroke-width:2px

1. Lattice-based Cryptography

Currently, “Lattice-based Cryptography” is considered the most promising and mainstream approach in the field of PQC. It bases its security on problems related to points (lattice points) regularly arranged in a multidimensional space. Famous problems include the “Shortest Vector Problem (SVP)” and the “Learning With Errors (LWE) problem.”

Mechanism Overview: Imagine countless points arranged in a grid within a very high-dimensional (hundreds to thousands of dimensions) space. Finding a specific lattice point is easy in 2 or 3 dimensions, but in hundreds of dimensions, no efficient algorithm has been found for either classical or quantum computers. The LWE problem, in particular, exploits the property that “if small ’noise (errors)’ is intentionally added to a system of linear equations, deducing the original variables becomes drastically harder.”

Pros:

Applicable to both Key Encapsulation Mechanisms (KEM) and digital signatures.
Extremely fast processing speeds (sometimes faster than RSA and ECC).
Well-balanced with relatively small key and ciphertext sizes.

Many of the algorithms currently being standardized by NIST (such as ML-KEM and ML-DSA) adopt this lattice-based cryptography.

2. Hash-based Cryptography

Hash-based cryptography is a PQC algorithm specialized for digital signatures. Its security relies entirely on the collision resistance and one-wayness of secure “cryptographic hash functions” like SHA-2 and SHA-3.

Mechanism Overview: It starts with a one-time signature scheme called “Lamport Signature.” By bundling this in a tree-structured data format called a “Merkle Tree,” it allows for multiple signatures using a single key pair.

Pros:

The foundation of its security is extremely solid, carrying a strong proof that it is “secure as long as the hash function is secure.”
Due to its low reliance on mathematical structures, the risk of unexpected decryption methods being discovered is low.

Cons:

Cannot be used for Key Encapsulation (KEM); only applicable to digital signatures.
Tends to have larger signature sizes.
There are “stateful” and “stateless” variants. The stateful ones (like XMSS) require strict management of the number of key uses, making implementation difficult.

NIST has standardized “SLH-DSA (formerly SPHINCS+)” as a stateless hash-based signature.

3. Multivariate Cryptography

Multivariate cryptography bases its security on the difficulty of solving systems of multivariate quadratic polynomial equations (the Multivariate Quadratic problem, or MQ problem). This problem is known to be NP-hard.

Mechanism Overview: The sender creates a ciphertext (or signature) by substituting plaintext (or hash values) into complex equations with numerous variables provided as the public key. The legitimate receiver holds “hidden information (a trapdoor) that transforms the structure of the equations into an easily solvable form” as a private key, and uses this for decryption (or signature verification).

Pros:

Signature sizes are very small.
Signature verification speeds are extremely fast. Suitable for IoT devices with limited resources.

Cons:

Public key sizes are very large (ranging from tens to hundreds of kilobytes).
There have been cases where prominent algorithms (like Rainbow) were broken by classical attacks in the past, making it somewhat more challenging to establish trust in its security compared to other methods.

4. Code-based Cryptography

Code-based cryptography applies the theory of “error-correcting codes,” which are used to correct errors over communication channels, to cryptography. The “McEliece Cryptosystem,” proposed in 1978, is the most famous and one of the oldest in PQC.

Mechanism Overview: The sender encodes the plaintext using the receiver’s public key (a generator matrix of an error-correcting code with a hidden structure) and intentionally adds errors (noise) before sending. The receiver removes the errors using their private key to retrieve the plaintext. An attacker must correct the errors from a seemingly random code without knowing its structure, a problem known as general “syndrome decoding,” which has been proven to be NP-hard.

Pros:

Has been thoroughly studied for over 40 years without any effective attacks being found, so confidence in its security is extremely high.
Fast encryption and decryption processing.

Cons:

Public key sizes are massive (sometimes reaching several megabytes). Therefore, it is difficult to use in environments with limited communication bandwidth or memory (such as TLS handshakes).

Latest Trends in NIST’s PQC Standardization

The US National Institute of Standards and Technology (NIST) began soliciting next-generation post-quantum cryptography algorithms globally in 2016, and has undergone several years of rigorous evaluation rounds.

In 2024, NIST finally published the following three algorithms as official Federal Information Processing Standards (FIPS). This has laid a solid foundation for organizations worldwide to begin implementing them in production environments.

Established FIPS Standards (2024)

FIPS 203: ML-KEM (Formerly: CRYSTALS-Kyber)
- Use Case: Key Encapsulation Mechanism (KEM) / Encryption & Key Exchange
- Underlying Tech: Lattice-based Cryptography (Module-LWE)
- Features: It offers an excellent balance of key size and speed, serving as the default PQC key exchange for general internet use, such as web communications (TLS) and secure messaging apps.
FIPS 204: ML-DSA (Formerly: CRYSTALS-Dilithium)
- Use Case: Digital Signatures
- Underlying Tech: Lattice-based Cryptography (Module-LWE)
- Features: The primary standard for digital signatures. It allows for efficient processing and will become the new standard for all electronic signature applications, including software signing and document authentication.
FIPS 205: SLH-DSA (Formerly: SPHINCS+)
- Use Case: Digital Signatures
- Underlying Tech: Hash-based Cryptography (Stateless)
- Features: Plays a crucial role by serving as a backup in case vulnerabilities are ever found in lattice-based cryptography. Although the signature size is larger, it is suitable for applications requiring long-term reliability.

The Pursuit of Further Diversity

While NIST has completed the initial standardization process, it continues to explore further algorithms. In particular, because the standards lean heavily toward “lattice-based cryptography,” ensuring Crypto Diversity is seen as critical. The evaluation of code-based cryptography and others is ongoing as backup standards for key exchange, aiming to make the foundation of PQC even more robust in the future.

PQC Migration Scenarios and Challenges: The Importance of “Crypto-Agility”

With the release of official standards from NIST, government agencies, financial institutions, and tech companies around the world will begin transitioning (migrating) from existing RSA/ECC to PQC in earnest. Guidelines from organizations like the NSA (National Security Agency) also recommend early completion of this migration.

Adopting a Hybrid Approach

Because PQC algorithms are new, they have not withstood the “test of time” compared to classical cryptography. Considering the risks of hidden bugs in implementations or the discovery of new attack methods, a “Hybrid Approach” is recommended during this transitional period. This method involves performing key exchanges by combining proven existing cryptography (e.g., ECDHE) with the new PQC (e.g., ML-KEM). Trial introductions of this approach are rapidly advancing in major browsers and cloud services.

Achieving Crypto-Agility

What companies and system developers must focus on most moving forward is ensuring “Crypto-Agility.” When flaws are found in algorithms or new standards emerge, it is essential to have a flexible architectural design that allows cryptographic algorithms to be swapped or updated quickly without stopping the system.

Creating a Cryptography Bill of Materials (CBOM) to accurately grasp “where,” “what cryptography,” and “for what purpose” it is being used within a company’s systems is a critical first step toward PQC migration.

Conclusion: Preparing for the Coming “Q-Day”

The evolution of quantum computers will bring tremendous benefits to humanity, while simultaneously posing the greatest threat to the cryptographic security that forms the foundation of our modern digital society. Post-Quantum Cryptography (PQC) is no longer a “research topic of the distant future.” Following the milestone of NIST’s publication of the FIPS standards, PQC has fully entered the phase of “implementation and migration.”

Given the threat of “Harvest Now, Decrypt Later,” transitioning to PQC is an immediate, top-priority task for all organizations handling highly sensitive data. By deeply understanding next-generation cryptographic technologies and enhancing your system’s crypto-agility, we can safely navigate the approaching quantum computer era.

Will Quantum Computers Really Break RSA Encryption? ~Shor's Algorithm and the Current State of the Art~

Sat, 05 Sep 2026 22:09:21 +0900

Introduction: The Intersection of Cryptography and Quantum Computers

In modern Internet society, “public-key cryptography” is the foundation for protecting the secrecy of communications. A representative example of this is “RSA encryption,” developed in 1977 by Ron Rivest, Adi Shamir, and Leonard Adleman. From online shopping payments we use every day to website browsing (HTTPS) and email transmission/reception, RSA encryption functions as the heart of the Internet infrastructure.

However, it has been pointed out that the advent of “quantum computers” could fundamentally overturn this security. Media outlets sometimes run sensational headlines like, “Once quantum computers are completed, passwords and codes worldwide will be decrypted in seconds.” But is this really true?

In this article, we delve deeply into the mechanisms of GNFS (General Number Field Sieve), a classical cryptanalysis method, and “Shor’s Algorithm,” the definitive cryptanalysis algorithm using a quantum computer. We will explain advanced concepts like Quantum Fourier Transform and period finding in an easy-to-understand manner, and examine in detail the current state of quantum hardware in the NISQ (Noisy Intermediate-Scale Quantum) era and the hurdles required to actually break RSA-2048.

The Core of RSA Encryption: The Difficulty of Prime Factorization

The security of RSA encryption relies on a very simple asymmetry in mathematics. It is based on the fact that “it is easy to multiply two enormous prime numbers together, but it is extremely difficult to find the original two prime numbers (prime factorization) from the result of that multiplication (a composite number).”

For example, suppose we have two prime numbers, $ p = 61 $ and $ q = 53 $. Calculating this multiplication $ N = p \times q = 3233 $ is instantaneous. However, if given only the number “3233” and asked, “Which prime numbers were multiplied to get this?”, the computational complexity explodes as the numbers get larger.

In the currently mainstream RSA-2048, a massive composite number $ N $ with a key length of 2048 bits—about 617 decimal digits—is used. If this $ N $ can be factored into primes, the encryption is as good as broken.

The Challenge by Classical Computers: GNFS (General Number Field Sieve)

To solve the prime factorization problem, mathematicians and cryptographers have developed various algorithms over the years. Among them, the fastest currently on classical computers is the General Number Field Sieve (GNFS).

GNFS is a method that extends computations in the ring of integers to more abstract algebraic number fields (Number Fields) to analyze and factorize a huge number $ N $. The rough flow is as follows:

Polynomial Selection: Find a polynomial $ f(x) $ with appropriate degrees and coefficients that has $ N $ as a root.
Data Collection (Sieving): Over the field of rational numbers and algebraic number fields, search for a massive amount of pairs of numbers that can be factored into small prime numbers (Smooth numbers). This process is called “sieving” and is the most time-consuming part.
Matrix Generation and Reduction: Based on the collected relations, generate a huge sparse matrix (a matrix where most components are 0) and find a solution using linear algebraic methods (such as the Block Lanczos algorithm).
Square Root Calculation: Finally, calculate the square root over the algebraic number field and derive the factors (prime factors) of $ N $.

The computational complexity of GNFS is non-asymptotically evaluated as $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $. This is called “sub-exponential” time complexity. While faster than exponential time, it is still far slower than polynomial time.

In fact, in 2020, an international research team succeeded in the prime factorization of RSA-250 (an 829-bit, 250-digit composite number) using GNFS. This calculation gathered computing resources from around the world and spent an enormous amount of computing time, roughly 2,700 CPU core years. However, when it comes to 2048 bits, the required computational complexity is said to swell to trillions of times the lifespan of the universe, making it impossible to decrypt within a realistic time frame using classical methods, no matter how many supercomputers are run in parallel.

The Trump Card of Quantum Computers: Shor’s Algorithm

Enter “Shor’s Algorithm,” announced by Peter Shor in 1994. This algorithm was groundbreaking because it could solve the prime factorization problem on a quantum computer in polynomial time ( $ O((\log N)^3) $ ). The difference between sub-exponential time and polynomial time is decisive; in theory, the use of quantum computers means the complete destruction of RSA encryption.

The Overall Flow of Shor’s Algorithm

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[Input number N to be factored] --> B[Select a random integer a]
 B --> C{Greatest Common Divisor<br>of a and N}
 C -->|Greater than 1| D[Luckily discovered a prime factor!]
 C -->|1 Mutually prime| E[Quantum computer takes the stage]
 E --> F[Find the period r of the function<br>f_x = a^x mod N<br>using Quantum Fourier Transform]
 F --> G{Is period r even and<br>a^r/2 ≢ -1 mod N?}
 G -->|Yes| H[Calculate greatest common divisor gcd_a^r/2 ± 1, N]
 H --> I((Prime factorization successful!))
 G -->|No| B

Shor’s algorithm does not solve the prime factorization problem directly, but rather uses theorems from number theory to transform it into another problem called the “Period Finding Problem,” and solves that rapidly by leveraging the characteristics of a quantum computer.

Step 1: Reduction from Prime Factorization to the Period Finding Problem (Classical Processing)

The first step of the algorithm is performed on a classical computer. For the number $ N $ you want to factorize, pick a random integer $ a $ ( $ 1 < a < N $ ) that is coprime to $ N $ (their greatest common divisor is 1). If by chance the greatest common divisor is not 1, the common divisor found at that point is a prime factor of $ N $, and decryption is complete, but the probability of this is extremely low.

Next, consider the following sequence of modulo equations: $ f(x) = a^x \pmod N $

If we substitute $ x = 1, 2, 3, \dots $ into this function $ f(x) $, the values may seem random, but because we are calculating within a finite range, it will always return to the original value somewhere and repeat the same sequence of numbers. The period of this repetition is called $ r $. In other words, the problem of finding the smallest positive integer $ r $ such that $ a^r \equiv 1 \pmod N $, this is the “Period Finding Problem”.

If this period $ r $ is found, and $ r $ is an even number, then $ a^r - 1 \equiv 0 \pmod N $, and using the factorization formula, it can be transformed into: $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $ From here, by using the Euclidean algorithm to calculate the greatest common divisor of $ N $ and $ a^{r/2} \pm 1 $, a prime factor of $ N $ can be obtained with extremely high probability.

Finding the period $ r $ on a classical computer ultimately requires an exponential number of steps and cannot be sped up. However, a quantum computer can find this period $ r $ in an instant (in polynomial time).

Step 2: Preparation and Superposition of Quantum States

This is where the quantum computer comes into play. Quantum computers use “Qubits”, which can simultaneously hold the states of “0” and “1”. In Shor’s algorithm, two registers are prepared: a register to store inputs (the first register) and a register to store calculation results (the second register).

First, a quantum gate operation called a Hadamard gate is applied to all qubits in the first register. As a result, the first register becomes an equal superposition state of all conceivable values of $ x $ (from $ 0 $ to $ 2^n-1 $, where $ n $ is a sufficiently large number of bits).

In other words, inside the quantum computer, a state is created where countless input values $ x=0, 1, 2, 3, \dots $ exist simultaneously in parallel.

Step 3: Quantum Modular Exponentiation

Next, taking the superposition state of the first register as input, calculate $ f(x) = a^x \pmod N $ and store the result in the second register. Because this calculation is executed as a unitary transformation on a quantum circuit, the calculation of $ f(x) $ for all $ x $ is performed “simultaneously and in parallel (quantum parallelism)” while maintaining the superposition.

The space of the entire quantum system at this point is an enormous superposition of states: $ |x, a^x \bmod N\rangle $

However, if we simply measure (observe) the second register here, a single random value of $ a^x \bmod N $ will be probabilistically selected, and the $ x $ of the first register will be fixed to one value in conjunction with it. This is exactly the same as calculating it once on a classical computer, and the period $ r $ cannot be found.

Under the rules of quantum mechanics, you cannot directly peek into the contents of a superposition state. So how do we extract the global information of the overall “period”?

Step 4: Quantum Fourier Transform (QFT)

The true brilliance of Shor’s algorithm that breaks through this wall is the application of the Quantum Fourier Transform (QFT) to the first register.

Before making a measurement, we analyze the wave properties of the function $ f(x) $. Suppose we observed the second register. Suppose a value $ y $ was obtained. Then, the state of the first register collapses to a “superposition of all $ x $ such that $ a^x \pmod N = y $”. These values of $ x $ will be in a state that is discretely arranged at intervals of period $ r $, such as $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $ (a kind of comb-like probability amplitude distribution).

We apply the Quantum Fourier Transform (QFT) to this state. Just as the classical discrete Fourier transform converts a time-domain signal into the frequency domain, QFT causes interference in the probability amplitudes of the quantum state.

When QFT is applied, due to quantum interference effects, the probabilities of incorrect answers that do not resonate with the period $ r $ (where phases do not align) cancel each other out and approach zero (destructive interference), and only the probability of the correct answer that carries the information of the period $ r $ is amplified (constructive interference).

Step 5: Measurement and Continued Fraction Expansion (Classical Post-Processing)

When the first register is measured after applying QFT, an integer $ c $ close to the form $ c \approx \frac{j \cdot 2^n}{r} $ is obtained with very high probability (where $ j $ is an unknown integer and $ 2^n $ is the size of the register).

By returning this measurement result $ c $ to a classical computer and creating a fraction $ \frac{c}{2^n} \approx \frac{j}{r} $, and then calculating an approximate value using a mathematical method called “Continued fraction expansion”, the denominator, the period $ r $, can be successfully brought to light.

Once $ r $ is known, the prime factors of $ N $ can be calculated using the formula from Step 1, and the RSA encryption is completely broken.

The Capability and Challenges of Current Quantum Computers (NISQ)

While Shor’s algorithm is theoretically perfect, if asked, “Will RSA encryption be broken tomorrow?”, the answer is a definitive “No.” The reason lies in the limitations of current quantum computer hardware technology.

The NISQ (Noisy Intermediate-Scale Quantum) Era

We currently exist in an era known as “NISQ”. NISQ devices have tens to hundreds of physical qubits, but they are extremely vulnerable to noise.

Qubits are susceptible to external environmental influences such as heat and electromagnetic waves, and “decoherence” (loss of quantum entanglement) where the quantum state breaks down, and “gate errors” during gate operations occur frequently. If one tries to execute a very deep quantum circuit (with an enormous number of calculation steps) like Shor’s algorithm, errors accumulate during the calculation, and the final output becomes completely meaningless noise.

Physical Qubits and Logical Qubits

What is indispensable for solving this error problem is “Quantum Error Correction”. While error correction codes are also used in classical computers, quantum error correction is extremely complex due to the “no-cloning theorem” which forbids the duplication of quantum states.

In quantum error correction, an ideal, error-free “logical qubit” is created by combining a large number of noisy “physical qubits” using techniques such as the “Surface Code”.

Assuming current error rates, it is estimated that approximately 1,000 to 10,000 physical qubits will be required to create one logical qubit. This is called “error correction overhead”.

What Resources Are Needed to Break RSA-2048?

So, how many resources are actually needed to run Shor’s algorithm to decrypt RSA-2048?

According to a groundbreaking resource estimation in a 2021 paper by Craig Gidney (Google) and Martin Ekerå, if an optimized Shor’s algorithm is used and error correction by surface codes is performed, the following resources will be required:

Number of logical qubits: Approx. 4,096
**Number of physical qubits : ** Approx. 20 million (Assuming an error rate of about $10^{-3}$)
Computation time: Approx. 8 hours (Millions to billions of physical gate operations required)

In contrast, what is the current state of quantum hardware? The superconducting quantum processor “Condor” announced by IBM at the end of 2023 has 1,121 qubits. In addition, groundbreaking research on the generation of logical qubits (such as the generation of 48 logical qubits using a neutral atom quantum computer by Harvard University and QuEra, etc.) has appeared, but we are not yet at the stage where we can continuously execute “perfect, noise-free calculations” for a long time.

Scaling up from a few thousand physical qubits to 20 million practical physical qubits (and a system that is interconnected, operates stably at cryogenic temperatures, and can process control signals at ultra-high speeds) presents a tremendous engineering wall (wiring problems, limits of cooling capacity, bloating of control electronics). Many experts predict that it will take at least 10 to 30 years, or even longer, to realize a “Fault-Tolerant Quantum Computer (FTQC)” capable of breaking RSA-2048.

The Creeping Threat of “Store Now, Decrypt Later” and the Dawn of PQC

It is premature to think, “We are safe since it will still take more than 10 years.” Currently, there is data that must remain secret for decades to come, such as national classified information, medical data, and long-term infrastructure designs.

What is feared here is the threat of an attack method known as “Store Now, Decrypt Later”. Malicious nations or organizations intercept all communication data currently encrypted with RSA or ECC (Elliptic Curve Cryptography) and store it in storage. Then, 10 or 20 years later, the moment a powerful quantum computer is completed, they use Shor’s algorithm to decrypt all past data and expose secrets.

To counter this time lag threat, the standardization process for “Post-Quantum Cryptography (PQC)” has been rapidly advancing, primarily led by NIST (National Institute of Standards and Technology).

PQC is a new cryptographic algorithm based on mathematical problems that are difficult to solve even with a quantum computer (i.e., Shor’s algorithm cannot be applied). The main approaches include the following:

Lattice-based cryptography: Based on problems such as LWE (Learning with Errors). The mainstream in NIST standardization (Kyber, Dilithium, etc.).
Code-based cryptography: Relies on the difficulty of the decoding problem of error-correcting codes.
Multivariate cryptography: Relies on the difficulty of solving systems of multivariate quadratic equations.
Hash-based signatures: Digital signatures that rely solely on the security of hash functions.

Major software and platforms such as Google Chrome and Apple’s iMessage have already started introduction testing and hybrid implementation of PQC.

Conclusion

Quantum computers are transitioning from a pipe dream in the world of science fiction to a real engineering challenge. Shor’s algorithm is a great intellectual achievement of humanity that merges mathematics and quantum mechanics, but at the same time, it harbors a “destructive power” that shakes the foundations of our digital society.

RSA encryption will not suddenly become unusable tomorrow. However, considering the evolution of quantum technology and the risk of “Store Now, Decrypt Later,” a large-scale migration that will remain in cryptographic history—the transition to PQC—has already begun. We are now witnessing the front lines of a paradigm shift in information security.

[Complete Anatomy] Understanding the Strongest Cryptanalysis Algorithm "GNFS" by Implementing it in C++

Sat, 05 Sep 2026 13:04:59 +0900

[Complete Anatomy] Understanding the Strongest Cryptanalysis Algorithm “GNFS” by Implementing it in C++

The “RSA cryptography” fundamentally supports the modern Internet. Its robustness relies on the mathematical belief that “factoring huge composite numbers is practically impossible with current computers.”

However, humanity has never given up. Currently, for classical computers (regular computers, not quantum computers), there exists the **strongest and most advanced algorithm of humanity ** for performing giant prime factorizations. That is the “General Number Field Sieve (GNFS)”.

In this article, we will strictly model the state-of-the-art computational logic of GNFS in C++ (using the multiple-precision integer boost::multiprecision from the Boost library), publish the entire implementation code, and thoroughly explain the depths of “algebraic number theory” behind it.

Please enjoy the mystery of mathematics and the brute force of computer science that wrestles it down, along with the source code.

1. GNFS State-of-the-Art Logic Framework (Full Source Code)

First, here is the full picture of the C++ implementation of GNFS that we will explain this time. The actual number field sieve (such as CADO-NFS) is an ultra-massive distributed system spanning hundreds of thousands of lines, but this code extracts the “5 essential pipelines (phases)” that make up GNFS, designs them as classes, and models them in a minimal configuration without losing their mathematical meaning.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Using Boost.Multiprecision for multiple-precision integers
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve State-of-the-Art Logic Framework
//
// This code strictly models the 5 pipelines of state-of-the-art GNFS used in
// CADO-NFS etc., as a class design in C++ (Boost).
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung's algorithm)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Algebraic side polynomial f(x)
 std::vector<cpp_int> g; // Rational side polynomial g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Initial polynomial generation based on base-m expansion (actually uses more advanced lattice basis reduction LLL)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // Simple base-m expansion (degree d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Simple approximation of m (approximation without using Boost functions)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving
// ============================================================================
// In recent GNFS, instead of Line Sieve, Special-q Lattice Sieving by
// Franke-Kleinjung et al. is the de facto standard.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (Omitted) In reality, it generates primes and filters them using Legendre symbols, etc.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // Mock implementation: Actual lattice sieving scans hundreds of GB of memory space block by block.
 // It maps (a, b) pairs to lattices for each special prime q (a = i*q + j*...),
 // and executes a sieve that maximizes cache efficiency.

 // Add one dummy relation for demo
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (Singleton removal and clique merging)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (removing relations with primes that appear only once)
 // 2. Clique merging (merging relations to make a sparse matrix denser)
 // In reality, it compresses a matrix of hundreds of millions of rows down to several million using algorithms like Union-Find.
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann method)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // In modern supercomputing environments, the Block Wiedemann method (Coppersmith implementation),
 // which is more suitable for distributed computing than the Block Lanczos method, is used as the state-of-the-art.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // Iterates matrix-vector multiplication of a sparse matrix,
 // and finds multiple solution vectors (kernels) where M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // List of dependencies
 // Dummy data
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. Compute the rational side square root V (simple integer arithmetic)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Compute the algebraic side square root gamma (Montgomery's method, etc.)
 // Find an element gamma in the huge algebraic field O_K, and map it to the real world using the homomorphism map phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Assuming that sequences of Quadratic Characters were added in Phases 2 and 4
 // to bypass the obstruction of the ideal class group and the unit group.

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Huge composite number N to factor, such as RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Degree of the polynomial (normally select degree 5-6 for numbers over 130 digits)
 int degree = 6;

 // Initialize pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Actual bounds are tens of millions to hundreds of millions
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Polynomial selection
 poly_select.select(N);

 // 2. Sieving process
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filtering (matrix compression)
 filter.reduce_matrix(relations);

 // 4. Linear algebra (nullspace search over GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Algebraic square root computation and GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

Now, how does this code destroy the cryptographic wall? I will break down and explain the meticulous algorithm and advanced mathematics phase by phase.

2. The Final Goal of GNFS: $X^2 \equiv Y^2 \pmod N$

The goal that not only GNFS but most modern large integer factorization algorithms aim for is to find a non-trivial pair $(X, Y)$ that satisfies the following congruence:

$$X^2 \equiv Y^2 \pmod N$$

This equation means that “the remainders of $X^2$ and $Y^2$ divided by $N$ are equal”. If we transform this: $X^2 - Y^2 \equiv 0 \pmod N$ In other words, $(X-Y)(X+Y)$ becomes a multiple of $N$.

If $X \not\equiv \pm Y \pmod N$ (a non-trivial solution), then between $(X-Y)$ and $N$, there exists a “common divisor greater than 1 and less than $N$”. Here, if we compute $\gcd(X-Y, N)$ using the Euclidean algorithm, the prime factors of $N$ can be easily found.

However, finding these $X$ and $Y$ is like looking for a needle in a desert. Thus, GNFS takes the genius approach of creating two worlds, the “real integer world” and the “algebraic field of polynomials world”, and distributing the computation.

3. Phase 1: Polynomial Selection

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Calculation of m = N^(1/d) and base-m expansion
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

The first step of GNFS is to create a “magic polynomial” to bridge the two worlds. For a huge number $N$, we choose an integer $m$. Usually, it is chosen such that $m \approx N^{1/d}$ (in the code, a polynomial of degree $d=6$ is assumed).

Then, $N$ is expanded in base $m$, and its coefficients are used to construct the polynomial $f(x)$.

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

This polynomial $f(x)$ has the extremely important property that “substituting $m$ for the variable $x$ evaluates exactly to $N$ ($f(m) = N$)”. In other words, $f(m) \equiv 0 \pmod N$. The rational side polynomial is defined as $g(x) = x - m$.

This strongly connects the “algebraic field world $\mathbb{Z}[\alpha]$” ruled by the root $\alpha$ of $f(x)=0$, and the normal “rational (integer) world $\mathbb{Z}$”, via a “ring homomorphism” of $x \to m$.

In state-of-the-art systems like CADO-NFS, it takes months to search for the “most convenient polynomial $f(x)$” using KleinJung’s algorithm and the LLL lattice basis reduction algorithm, so that the coefficients of the polynomial do not become excessively large, and primes are likely to appear (become smooth) in the subsequent steps.

4. Phase 2: Special-q Lattice Sieving

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Maps (a, b) pairs to lattices for each special prime q,
 // and executes a sieve that maximizes cache efficiency.
 // ...
 }
};

Once the two worlds are prepared, the next step is to search for “smooth numbers (numbers composed entirely of small prime factors)” in both worlds. An infinite number of integer pairs $(a, b)$ are generated, and the following two values are calculated:

Rational side value: $a - bm$
Algebraic side norm: $b^d f(a/b)$

The goal of GNFS is to collect tens of millions to hundreds of millions of these “pairs (Relations) where both the rational side and algebraic side values can be completely factored into only small prime factors”.

In the early GNFS, a “Line Sieve” was used, lining up $(a, b)$ on the $xy$ plane and sequentially dividing them by primes from the edges. However, this caused frequent cache misses due to accessing various parts of memory, and its weakness was being extremely slow.

Therefore, the current state-of-the-art code uses the “Special-q Lattice Sieve” method. By fixing a moderately large prime $q$, we restrict the calculation targets to only “pairs of $(a, b)$ where the algebraic side value is always divisible by $q$”. Since $(a, b)$ satisfying this condition form a “lattice” on the plane, the jump width of calculated addresses becomes constant, fitting perfectly into the CPU’s L1/L2 cache. With the introduction of this lattice sieving, the calculation speed of GNFS improved dramatically.

5. Phase 3: Filtering

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (removing relations with primes that appear only once)
 // 2. Clique merging (merging relations to make a sparse matrix denser)
 }
};

Hundreds of millions of relations collected over months by computers around the world in Phase 2. However, if this is thrown as-is into the next “step of solving simultaneous equations (matrix calculation)”, the supercomputer’s memory will blow up.

Thus, an ultra-compression process of the matrix called Filtering is performed.

Singleton removal Suppose a huge prime $p$ appeared “only once” in hundreds of millions of relations. Since our goal is to “make the exponents of all primes even (multiples of 2)”, a prime that appears only once can never be made even. Therefore, relations containing that prime are immediately removed (purged) as “useless garbage”. As this happens in a chain reaction, the data that had hundreds of millions of rows is rapidly reduced.
Clique merging Furthermore, by multiplying (adding) relations that share specific primes together, it reduces the number of rows while compressing the sparse (empty) matrix into a denser state (using a method similar to clique search in graph theory).

With this optimization, the massive sparse matrix is dramatically compressed to a computable size.

6. Phase 4: Linear Algebra over GF(2) (Block Wiedemann Method)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Iterates matrix-vector multiplication of a sparse matrix,
 // and finds multiple solution vectors (kernels) where M * x = 0 mod 2.
 }
};

Finally, the core of the puzzle. We multiply the collected relations to find the “combination where the exponents of all prime factors become even”.

Mathematically, this means using a huge matrix $M$ whose elements are the “even/odd (i.e., 0 or 1)” of the exponent of each prime, and a vector $x$ representing which relations to use, and finding the solution vector $x$ (nullspace/kernel) such that: $M \cdot x \equiv 0 \pmod 2$

We must solve a system of simultaneous equations for a matrix of an enormous size, millions of rows by millions of columns. With standard Gaussian elimination, the computational complexity would be $O(N^3)$, and the calculation wouldn’t finish until the end of the universe.

Thus, the “Block Wiedemann method” is adopted in state-of-the-art implementations. This is a type of Krylov subspace method that leverages the fact that the matrix $M$ is “extremely sparse (mostly 0s)” to derive a solution by iteratively performing matrix-vector multiplications. Unlike the older Block Lanczos method, the Block Wiedemann method can completely divide the computational process across multiple clusters, making it overwhelmingly powerful for parallel computing in modern distributed cloud computing and supercomputers.

7. Phase 5: Algebraic Square Root and Cryptographic Collapse

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Compute the rational side square root V
 cpp_int V = 1;

 // 2. Compute the algebraic side square root gamma
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Through the matrix calculation in Phase 4, we obtained a “set of relations $S$ whose product yields even powers for all prime factors”. With this, we can construct a “square” in both the rational side and the algebraic side worlds.

For the rational side, it’s just integer multiplication, so computing the square root $V$ is easy.

$$V^2 = \prod_{S} (a - bm)$$

However, the real hell lies on the “algebraic side”. In the algebraic field world $\mathbb{Z}[\alpha]$, since the uniqueness of prime factorization does not hold, calculations have been performed using ideals. What was guaranteed by the matrix calculation is only that it becomes a “square of an ideal”, and it is not guaranteed that it becomes a “square of an element ($\gamma^2$)”.

Here stands a formidable wall in algebraic number theory: the “obstruction of the ideal class group” and the “obstruction of the unit group”. In GNFS, we use the magic of “Quadratic Characters” to break through this wall. Columns of quadratic residues (Legendre symbols) for several tens of special prime ideals are secretly added in advance to the matrix in Phase 4. As a result, the found set $S$ ignores the obstructions with an overwhelming probability and successfully forms the “true square of an element $\gamma^2$”.

The work of finding $\gamma$ (algebraic square root) is computed using highly complex algorithms such as Montgomery’s method.

And finally, we warp the algebraic side square root $\gamma$ into the real world (by substituting $m$ for $x$) via the ring homomorphism $\phi$, yielding $Y$. If we simply set the rational side $V$ as $X$, the absolute equation we have been pursuing is finally complete.

$$X^2 \equiv Y^2 \pmod N$$

All that is left is to compute $\gcd(X-Y, N)$. Running through the 0.001-second process, the moment a non-trivial factor is printed on the screen, the proudly impregnable RSA cryptography completely collapses.

Conclusion

GNFS is not just a programming technique. It is a crystal of human intellect that has wrestled down the “depths of pure mathematics” like abstract algebra, ring theory, and ideal class groups using “extreme engineering” like supercomputer distributed architectures and cache optimizations.

The chat messages and credit card information we casually transmit are protected upon such astronomical mathematical defense and offense.

Through this C++ framework, I hope you have felt the “romance of mathematics and computers” behind state-of-the-art cryptanalysis algorithms.

The True Mathematical Structure of the General Number Field Sieve (GNFS)

Sat, 05 Sep 2026 02:26:13 +0900

The True Mathematical Structure of the General Number Field Sieve (GNFS)

The ultimate goal of GNFS is to find $X^2 \equiv Y^2 \pmod N$. To achieve this, mathematicians built a bridge between the “world of real integers” and the “world of algebraic number fields”. That bridge is the “homomorphism”.

Stage 1: The “Homomorphism” Connecting Worlds

1. Polynomial Selection and Root Definition

For a massive composite number $N$, select an integer $m$ and a polynomial $f(x)$ such that $f(m) \equiv 0 \pmod N$. (Example: Expand $N$ in base $m$ and create $f(x)$ from its coefficients. Here, assume $f(x)$ is irreducible (cannot be factored further) over the field of rational numbers $\mathbb{Q}$).

Next, let one of the “complex roots” of the equation $f(x) = 0$ be $\alpha$. Naturally, $f(\alpha) = 0$. $\alpha$ is not an integer but a complex number (an algebraic number) that may involve square roots or imaginary numbers.

2. Construction of Rings and Homomorphisms

Now, prepare two mathematical “rings” (worlds where addition and multiplication are defined).

World A: $\mathbb{Z}[\alpha]$ (Ring of algebraic integers containing $\alpha$) A world of numbers represented in the form $a + b\alpha + c\alpha^2 + \dots$.
World B: $\mathbb{Z}/N\mathbb{Z}$ (Ring of residues modulo $N$) A modulo arithmetic world consisting only of integers from $0$ to $N-1$.

Here, we define a mapping $\phi$ from World A to World B as follows: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

This mapping $\phi$ is a magical operation that completely replaces the variable $\alpha$ in World A with the integer $m$ in World B. This $\phi$ possesses an extremely powerful property known as a “Ring Homomorphism”. A homomorphism is the property of “warping to another world without breaking the structure of addition and multiplication”. In other words, the following equations hold:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

What does this mean? If we can create a “square ($\gamma^2$)” of some complex element $\gamma$ in “World A (the world of $\alpha$)”, warping it to “World B (the modulo world)” via $\phi$ will ** perfectly preserve the square form $\phi(\gamma)^2$**.

Stage 2: The Collapse of Prime Factorization and the Birth of the “Ideal”

We want to collect many appropriate elements $(a - b\alpha)$ in World A ($\mathbb{Z}[\alpha]$) and multiply them together to create a “perfect square (square element)”. Normally, we could simply “prime factorize” each collected $(a - b\alpha)$ and combine them (solving via matrices) so that all prime exponents become even, thus creating a square.

However, here a devastating wall of algebra stands in our way. In algebraic number fields like $\mathbb{Z}[\alpha]$, the “uniqueness of prime factorization (any number can be uniquely expressed as a product of primes in exactly one way)”, which we learn in middle school, collapses.

(Example: In a certain algebraic number field, $6 = 2 \times 3$, but at the same time $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, making it impossible to know which are the true primes.)

If prime factorization is not uniquely determined, the puzzle (sieve method) of “counting the number of primes to make them even” becomes fundamentally impossible to execute.

The Salvation by Kummer and Dedekind: The “Ideal”

What saved us from this collapse was the concept of the “Ideal (ideal number)” created by 19th-century mathematicians. By considering not the elements themselves but the “set of multiples (ideals)” generated by those elements, they made prime factorization possible again.

In the ring of integers of an algebraic number field $\mathcal{O}_K$ (a more complete ring containing $\mathbb{Z}[\alpha]$), even if elements cannot be uniquely prime-factorized, it is proven that “an ideal can always be uniquely prime-factorized into a product of ‘prime ideals ($\mathfrak{p}$)’ in exactly one way”.

Therefore, in GNFS, instead of factorizing the element $(a - b\alpha)$ itself, we perform prime ideal factorization on the principal ideal $\langle a - b\alpha \rangle$ that it generates.

Stage 3: Norms and the Two Sieves

So, how do we know which prime ideals the ideal $\langle a - b\alpha \rangle$ factors into? Here, we use a function called the “Norm”. The norm is a function that converts complex elements of an algebraic number field into “ordinary real integers $\mathbb{Z}$”.

The norm of the element $(a - b\alpha)$ can be calculated by a simple polynomial calculation $b^d f(a/b)$ (where $d$ is the degree of $f(x)$).

Due to algebraic theorems, it is known that “if the norm of a certain ideal can be completely factored into small primes (is smooth), then the original ideal can also be completely factored into small prime ideals.”

Thus, GNFS simultaneously calculates the following two values for a massive number of integer pairs $(a, b)$ and collects only the pairs where both values are “smooth numbers”.

Rational Sieve: $a - bm$ (Values in the real world)
Algebraic Sieve: $b^d f(a/b)$ (Norm in the algebraic number field world)

By collecting tens of millions of pairs $(a, b)$ where both are smooth, and solving the prime factorization data of ideals (how many prime ideals are included) as a giant matrix (linear algebra over GF(2)), we find a set $S$ of pairs such that “when multiplied together, the exponents of all prime ideals become even”.

Stage 4: The Two Confronting “Obstructions” and the Ideal Class Group

Through matrix calculations, we found that multiplying all the ideals of $(a - b\alpha)$ belonging to set $S$ results in the square of a certain ideal $I$.

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

However, it doesn’t end here. The deepest and most difficult mathematical wall in GNFS lies here.

What we ultimately want is not the “square of an ideal”, but the “square of an element ($\gamma^2$)” to plug into the mapping $\phi$. Just because the ideal is squared doesn’t necessarily mean the element itself is squared. There exist two formidable mathematical obstructions here.

Obstruction 1: The Wall of the Ideal Class Group

The ideal $I$ is not always an “ideal generated by a single element (principal ideal)”. It is impossible to extract a concrete element $\gamma$ from an ideal that is not principal.

Here, the concept of the “Ideal Class Group ($Cl_K$)” comes into play. The ideal class group is a group that measures “how many non-principal ideals exist in that algebraic number field (how much the uniqueness of prime factorization is broken)”. Even if $\prod \langle a - b\alpha \rangle$ becomes $I^2$, if $I$ is not the identity element (principal ideal) in the ideal class group, it cannot be pulled back to the square of an element.

Obstruction 2: The Wall of the Unit Group

Suppose we get lucky and $I$ is a principal ideal $\langle \gamma \rangle$. Then, $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. You might think, “Great, the element is squared too!”, but that is a huge mistake.

The fact that ideals (sets of multiples) are equal does not mean the elements are completely equal. A deviation by a “Unit (a number whose reciprocal is also an integer, like 1 or -1)” inevitably occurs. In other words, the actual equality of the elements is as follows:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

($u$ is an element of the unit group $U_K$)

Unless this unit $u$ itself is the square of something (a square element), the left side can absolutely never become a “perfect square of an element”.

Stage 5: Adleman’s Magic “Quadratic Characters”

The obstruction of the ideal class group and the obstruction of the unit group. How do we overcome these two? Here, a genius method called “Quadratic Characters”, introduced by cryptographer Leonard Adleman (the “A” in RSA) and others, makes its appearance.

To determine “whether a certain element is a perfect square in the algebraic number field”, we use an algebraic number field version of the Legendre symbol (quadratic residue). To the giant matrix from earlier (the puzzle to make the count of prime ideals even), we secretly append dozens of additional conditions (columns) stating that “the quadratic characters for some special prime ideals $\mathfrak{q}$ also all become $1$ (even)”.

When we find a set $S$ that satisfies even these additional conditions through matrix calculations, deep theorems of algebraic number theory guarantee that “both the obstruction of the ideal class group and the obstruction of the unit group will naturally vanish with overwhelming probability.”

With this, we finally obtain the true equation.

$$\prod_{S} (a - b\alpha) = \gamma^2$$

Final Stage: The Convergence of Worlds and the Fall of Encryption

Finally, all the pieces of the puzzle are in place.

[Element in the Algebraic Number Field World (World A)] $\gamma^2 = \prod (a - b\alpha)$ (We find $\gamma$ from this using a square root algorithm)

[Element in the Real World (World of Rational Numbers)] $V^2 = \prod (a - bm)$ (Since this is just ordinary integer multiplication, the square root $V$ can be found normally)

Now, it’s time for the magical bridge we built at the very beginning, the homomorphism $\phi$, to take the stage. We warp the element $\gamma$ from World A to World B (the world modulo $N$) using $\phi$ (the mapping that substitutes $m$ for $\alpha$).

$$Y = \phi(\gamma) \pmod N$$

Meanwhile, we take the $V$ created in the real world directly to the modulo world and call it $X$.

$$X = V \pmod N$$

Due to the homomorphism’s property of “preserving structure”, the square relationship that held in World A is perfectly preserved in World B (the world modulo $N$) as well. Furthermore, because the original pairs $(a, b)$ were correspondingly created in the forms $a - b\alpha$ and $a - bm$, these $X$ and $Y$ collide in the world modulo $N$ to produce the following absolute equation:

$$X^2 \equiv Y^2 \pmod N$$

All that is left is to pray that these $X$ and $Y$ are not trivial solutions ($X \equiv \pm Y$) and calculate: $\gcd(X - Y, N)$

If it is a non-trivial solution, the Euclidean algorithm will race through in 0.001 seconds, and the secret primes $p$ and $q$, which are the heart of RSA encryption, will be printed on the output screen.

This is the complete form of the “General Number Field Sieve (GNFS)”, gathering the essence of modern mathematics.

What is the "General Number Field Sieve (GNFS)", Humanity's Strongest Math that Breaks Internet Cryptography?

Sat, 05 Sep 2026 02:09:08 +0900

What is the “General Number Field Sieve (GNFS)”, Humanity’s Strongest Math that Breaks Internet Cryptography?

The internet we use every day. LINE messages, YouTube, Amazon shopping—all communications are protected by “cryptography.” Currently, the most widely used cryptography in the world is “RSA cryptography.”

The cornerstone of RSA cryptography’s defense is very simple. It utilizes the mathematical property that “factoring a gigantic number into primes cannot be solved even by computers.” For example, for “15”, we immediately know it’s “3 × 5”, but the moment this becomes a “270-digit number”, even if we bundle all the supercomputers in the world, it would take hundreds of millions of years to solve.

However, mathematicians do not stay silent either. To break this ironclad cryptography, humanity created a magical algorithm (calculation procedure) called the “General Number Field Sieve (GNFS)”.

In this article, without using any specialized jargon, and only with knowledge of junior high school math (prime factorization, algebraic expressions, greatest common divisor), we will completely explain the mechanism step-by-step by which this “humanity’s strongest algorithm” breaks cryptography!

Chapter 1: The Goal of Decryption is a “Junior High School Formula”

The ultimate special move to confront gigantic prime factorizations. It’s this formula learned in junior high school.

$X^2 - Y^2 = (X + Y)(X - Y)$

You might think, “Eh, can such a basic formula break cryptography?” However, this is the master key that unlocks everything.

The ultimate goal for breaking the cryptography is to find, for a gigantic number $N$, “Numbers ($X$ and $Y$) where the remainder of $X^2$ and $Y^2$ divided by $N$ are the same.”

Why does “same remainder” solve the cryptography?

Suppose two numbers, $X^2$ and $Y^2$, have the “same remainder when divided by $N$.” Having the same remainder means there is a rule that the subtracted “$X^2 - Y^2$” will always be perfectly divisible by $N$ (it becomes a multiple of $N$).

Here, let’s say the gigantic number $N$ used for cryptography is made of the multiplication of two secret prime numbers ($p$ and $q$) ($N = p \times q$).

Factoring $X^2 - Y^2$ results in $(X - Y)(X + Y)$. The fact that this is a multiple of $N$ means that somewhere in this multiplication, the secret primes $p$ and $q$ are hidden.

Here a miracle occurs. There is mathematically a 50% (1/2) probability that the two prime numbers $p$ and $q$ will naturally separate into different rooms, with "$p$ going to the $(X - Y)$ room" and "$q$ going to the $(X + Y)$ room".

With only the prime number $p$ in the $(X - Y)$ room, let’s calculate the “Greatest Common Divisor (the largest common part)” of $(X - Y)$ and $N$.

Contents of $(X - Y)$ = $p \times$ some number
Contents of $N$ = $p \times q$ The only common part is "$p$"!

In other words, the moment you calculate the greatest common divisor, the hidden prime number $p$ pops out, and the cryptography is completely decrypted. (*The greatest common divisor can be calculated instantly even on a smartphone using the “Euclidean Algorithm”.)

[A Little Column: Why squared? Why not cubed or doubled?]

If it’s “$2X - 2Y$”, it becomes $2(X - Y)$, and since there’s only one room, you can’t separate the primes. If it’s “$X^3 - Y^3$”, the size of the rooms becomes unbalanced, making the calculations unnecessarily heavy. To separate the primes into two, “squaring”, which beautifully divides into two rooms, is the most cost-effective.

Chapter 2: How to Find X and Y? The “Prime Card Collection Puzzle”

The goal is clear. However, if you blindly search for “$X^2$ and $Y^2$ that yield the same remainder”, you won’t find it until the end of the universe. Therefore, mathematicians came up with a genius method called the “Prime Card Collection Puzzle”.

Step 1: Collect Only Gold Dust (Smooth Numbers) with a Sieve

First, prepare an appropriate number $Z$, square it, and calculate the remainder $W$ when divided by $N$. (The world of remainders where $Z^2 = W$)

Factorize the resulting remainder $W$. Here, only when a "$W$ made only of small prime numbers like 2, 3, 5, 7" appears, you keep that equation as a “winning card”, and throw it away if large primes are mixed in. It’s a task like discarding large stones with a sieve in a river and collecting only gold dust.

Step 2: The Puzzle of Making Everything an “Even Number”

For example, suppose the following three gold dust cards were collected.

Card A: $Z_1^2 = 2^3 \times 3^1$
Card B: $Z_2^2 = 2^1 \times 5^1$
Card C: $Z_3^2 = 3^1 \times 5^1$

Let’s multiply all these together. The right side becomes $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, and when summarized and organized, it becomes "$2^4 \times 3^2 \times 5^2$".

Amazingly, the number of prime numbers became “4, 2, 2”, which are all even numbers! Having all even numbers means that if you halve the count of everything, it becomes the “square of something.” In other words, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

The left side is $(Z_1 \times Z_2 \times Z_3)^2$, so with this, finally, $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$ The long-awaited “$X^2 = Y^2$” pair is completed!

For computers, the puzzle of calculating whether the number of primes is “even or odd (0 or 1)” is something they are very good at, so with this method, they can find $X$ and $Y$ at high speed.

Chapter 3: The Wall of Despair That Stands in the Way

Now any cryptography can be broken!… Or so we thought, but a big problem arises. If the cryptography number $N$ is up to about “100 digits”, it can be solved with this method (called the Quadratic Sieve), but when $N$ becomes “200 digits or 300 digits”, the $W$ that appears during the calculation becomes too huge.

When the numbers get too huge, “numbers made only of small prime numbers (gold dust)” completely stop appearing. It becomes harder than searching for a contact lens in a desert, and you can’t collect the cards to solve the puzzle at all.

Here finally, humanity’s ultimate weapon, the “General Number Field Sieve (GNFS)”, makes its appearance.

Chapter 4: Humanity’s Strongest Idea, Creating “Two Worlds”

The genius idea of GNFS is: “Calculating only in the real world makes the numbers huge. So, let’s create a ‘hidden world’ using polynomials (algebraic expressions) and split the weight of the calculation into two.”

The Magic of Algebraic Expressions

GNFS converts the gigantic number $N$ into an algebraic expression using a base number $m$. For example, if $N=100$, let $m=4$, so $100 = 4^3 + 2(4^2) + 4$. This is turned into the expression (the hidden world) $f(x) = x^3 + 2x^2 + x$ using the letter $x$.

The interesting thing about this expression is that it has the property: “If you substitute $m$ (4 in the example above) for the letter $x$, you can always warp back to the real number $N$.”

Searching for Gold Dust in Two Worlds Simultaneously

GNFS creates many pairs of random integers $(a, b)$ and performs the following two calculations simultaneously.

Real World: $a - b \times m$
World of Algebraic Expressions: The value calculated by the rules of algebraic expressions for $a - b \times x$

By splitting the problem into two worlds, the size of the numbers handled becomes dramatically smaller (lighter). It’s the image of splitting a huge rock into two to make them easy-to-handle stones.

Then, you sift and collect only the miracle pairs $(a, b)$ where “Both in the real world and in the world of algebraic expressions, they are ‘made only of small prime numbers (gold dust)’”. This is the origin of the name “Number Field Sieve.”

The Moment the Cryptography is Finally Broken

Once tens of millions of “gold dust cards” are collected from both worlds, using the giant matrix calculations of supercomputers, you find the “combination where the number of prime numbers all become even”, just as we did in Chapter 2.

Once the combination is found,

Let the squared number made in the real world be $X^2$
Let the squared expression made in the world of algebraic expressions be $Y(x)^2$

Finally, substitute $m$ into $x$ of $Y(x)$ in the world of algebraic expressions to warp to the real world and merge them. Then, just like mathematical magic, a state where “the remainders of $X^2$ and $Y^2$ are the same” is strictly completed!

After that, just like in Chapter 1, if you calculate the greatest common divisor of $X - Y$ and $N$, the impregnable RSA cryptography collapses with a crash, and the secret primes reveal themselves.

Conclusion: Mathematics Never Ends

You might have thought, “Alright, with GNFS, any cryptography can be broken!” However, RSA cryptography is not giving up either. What is currently used on the internet is a monstrously huge number called “RSA-2048 (about 617 digits)”.

Even though GNFS is humanity’s strongest algorithm, it is said that even to solve 270 digits (RSA-270), it would take thousands or tens of thousands of years even if all the computers in the world were connected. For now, our LINE and bank data are safe.

But what if a “magic that instantly finds $X$ and $Y$ for any gigantic number” appears? Actually, the closest thing to that is the “Quantum Computer (Shor’s Algorithm)” currently under development. It has been mathematically proven that by using the wave properties of quantum mechanics, one can ignore the tedious card collecting puzzle and draw the answer in one shot.

The endless battle of wits between the people who make cryptography (defense) and the people who make algorithms to break it (attack). When you learn that the “prime factorization” and “algebraic expressions” learned in junior high school are actually weapons fiercely fighting on the front lines of global security, doesn’t math class seem just a little bit more interesting?

The person to discover the strongest algorithm of the future might just be you reading this article!

(Note: This article conceptualizes the mathematical charm of cryptography decryption for junior high school students. Actual GNFS is strictly calculated using advanced university mathematics such as ideal class groups of algebraic number fields and homomorphisms.)

The Pros and Cons of Anti-Vaccination

Sat, 24 Jan 2026 15:41:23 +0900

The Pros and Cons of Anti-Vaccination - The Futures of 5,000 People Killed by “Good-Intentioned Anxiety” and the Epidemiological Lessons We Must Learn

The “Illusion of Causality” Highlighted by the COVID-19 Pandemic

Since 2021, the vaccination against the novel coronavirus has progressed rapidly in Japan. It was a public health project rare in human history, with nearly 80% of the public getting vaccinated in a short period. During this process, we witnessed countless “screams” through social media and the media. “My family member passed away a few days after getting the vaccine,” “I’ve been experiencing unexplained poor health since the vaccination” — these complaints are earnest, and for those involved, their suffering is an undeniable truth.

However, here exists a cold but extremely important “trap” in epidemiology. Considering the population size of Japan, whether people get vaccinated or not, about 3,000 to 4,000 people die every day from various causes (illness, accidents, old age). If the vast majority of the public gets vaccinated all at once, probabilistically, a certain number of people will inevitably “die the day after vaccination (from causes unrelated to the vaccine).” In technical terms, this is called “Coincidence”.

Humans are equipped with a cognitive bias called the “Post hoc ergo propter hoc” (after this, therefore because of this) fallacy. If “B (death) occurs after A (vaccination),” we intuitively connect that “A is the cause of B.” During the COVID-19 pandemic, this cognitive bias was amplified and spread by the social media amplifier, creating a demographic that established the image of “vaccine = dangerous” without waiting for scientific verification.

Many public health experts watched this spectacle with a sense of déjà vu. This is because Japan is the only developed country that, just a few years ago, voluntarily relinquished the means to prevent a preventable disease due to this “anxiety without science.” That is the issue of the “Cervical Cancer Vaccine (HPV Vaccine)”.

What Happened in Japan in 2013?

Let’s turn the clock back a little. Cervical cancer is a disease that affects about 11,000 women and kills about 2,900 people a year. It is also called the “Mother Killer” because it strikes women in their 20s to 40s, the prime time for child-rearing and work. The cause is infection with the human papillomavirus (HPV), a common virus that 80% of women who have had sexual intercourse will be infected with at least once in their lives. The HPV vaccine, which prevents this viral infection, was introduced worldwide as an “epoch-making vaccine that can prevent cancer,” and in Japan, it became a routine vaccination (strongly recommended by the state and available free of charge) in April 2013.

However, the situation immediately took a dark turn. Symptoms such as general body pain, movement disorders, and memory impairment were reported by some of the vaccinated girls, and the media widely reported this daily as “suspected adverse reactions to the vaccine.” Images of girls having convulsions had a strong impact on viewers, and public opinion quickly tilted toward the “vaccine danger theory.”

In response, the Ministry of Health, Labour and Welfare decided in June 2013, just two months after the start of routine vaccinations, to “withhold proactive recommendation.” This was neither a “prohibition” nor a “cancellation,” but a highly ambiguous political decision to “keep the framework of routine vaccination but stop sending individual notification letters from the government.” However, this was conveyed to the public as a message that “the government admitted it was dangerous and stopped it.” As a result, the vaccination rate, which had exceeded 70%, plummeted to less than 1% in an instant.

This marks the beginning of the “Lost 8 Years (Vaccine Gap)” in Japan.

The “Truth” Exposed by the Nagoya Study

Were the symptoms reported by the media really caused by the vaccine? There is a large-scale study that attempted to answer this question scientifically. It is commonly known as the “Nagoya Study”.

In 2015, the city of Nagoya conducted a large-scale questionnaire survey of about 70,000 young women. This included both those who had “received the vaccine” and those who “had not,” and asked them about the presence or absence of 24 symptoms, such as “irregular menstruation,” “joint pain,” and “decreased concentration.” If the vaccine were the cause, these symptoms should have clearly appeared more in the “vaccinated” group.

The results were shocking. There was no significant difference in the incidence of symptoms between the “vaccinated group” and the “unvaccinated group.”

What does this mean? Adolescent girls are at a time when they are prone to physical ailments such as orthostatic dysregulation and chronic pain due to hormonal balance changes and circumstances unique to their growth period, regardless of whether they have been vaccinated or not. In other words, there were “girls who had not been vaccinated but had the same symptoms” at the same rate as the “girls who developed symptoms after getting the vaccine” reported by the media. However, the poor health of the unvaccinated girls was treated as “adolescent ailments,” while only the poor health of the vaccinated girls was highlighted as “vaccine damage.” The data showed that it is highly likely that this is the true identity of the phenomenon that caused a fuss as a “drug-induced disaster.”

Furthermore, the involvement of the “Nocebo effect” has also been pointed out. The opposite of the “Placebo effect,” it is a phenomenon in which pain and poor health actually occur due to anxiety and fear when ingested with the belief that “this is bad for the body.” It cannot be denied that the daily negative reports may have affected the delicate minds and bodies of the girls.

The “Sin of Omission” Seen in Numbers

“Stopping recommendation just in case.” At first glance, this decision seems like a “cautious and safe choice.” After all, it’s too late once something happens, so when in doubt, stop. However, in public health, “doing nothing (omission)” sometimes causes damage that far exceeds the risk of “doing something.”

A research team at Osaka University published a cruel estimate regarding the impact of this withheld recommendation. They predict that the sharp drop in vaccination rates between 2013 and 2019 will result in an increase of approximately 25,000 future cases of cervical cancer that could have been prevented, and an increase in deaths of approximately 5,000 to 5,700.

Over 5,000 deaths. This is a number comparable to a large-scale natural disaster. As a result of trying to avoid a risk whose causal relationship was scientifically uncertain, “anxiety about adverse reactions,” we burdened the women of the future with a certain and grave risk: “death from cancer.”

If we look around the world, the difference is obvious. In Australia, due to the spread of vaccination among men and women, cervical cancer is predicted to be “eradicated (become a rare cancer)” by around 2028. In the UK, there are reports that the incidence of cervical cancer in the vaccinated generation has dropped to almost zero. While the world moves towards a future that “overcomes cancer,” Japan alone has been left behind in a past where “cancer continues to increase.” In 2015, the World Health Organization (WHO) Global Advisory Committee on Vaccine Safety singled out the situation in Japan for criticism, stating that “policy decisions not based on scientific evidence are causing real harm (death from cancer).”

The Chaining of “Vaccine Hesitancy” Across the Ocean

The tragedy of the HPV vaccine that occurred in Japan is by no means a “special circumstance unique to Japan.” Even now, there are reports from around the world showing that when “intuitive anxiety” and “ideology” are prioritized over science, infectious diseases will bare their fangs anytime, anywhere.

A prominent example of this is the outbreak of “measles” in the United States.

Measles is a highly contagious virus, but it is a disease that can be almost completely prevented by vaccination. In the United States, it was once declared “eliminated” in 2000 through a thorough vaccination program. In other words, the endemic virus was considered to be gone from the country. However, in recent years, measles has begun to spread again.

According to a BBC report (2024), US health authorities point out that the deeply rooted “Vaccine Hesitancy” in some communities is a hotbed for the spread of the infection. Vaccination rates are declining in areas where some groups claim to be “naturalists” for religious reasons, or where anti-vaccine ideology based on misinformation has permeated. When the virus is brought in from overseas, it causes explosive infections among those without immunity.

Measles is not just a disease that ends with a fever and rash. It causes serious complications such as pneumonia and encephalitis, and can be fatal even in developed countries. A disease that humanity once pooled its wisdom to “contain” is exploiting the vulnerability of people’s “doubts” to threaten the lives of children once again. The case of the United States warns us: “The breakwater of a high vaccination rate collapses in an instant if people’s trust is shaken.”

The Defeat of Media, Experts, and Ourselves

Why do these situations keep repeating? Behind it lies the information asymmetry peculiar to modern society and our cognitive biases.

In the HPV vaccine issue in Japan, the media sensationalized “suspected adverse reactions to the vaccine.” The composition of “pitiful victims” versus “coldhearted government/pharmaceutical companies” was very powerful as a narrative and strongly shook the emotions of viewers. On the other hand, the scientific explanations of experts, such as “there is no statistically significant difference” or “the benefits outweigh the risks,” sounded dry and cold, and were completely powerless in the face of the torrent of emotions.

In the world of science, if there is an established theory supported by 99% of scientists and a dissenting opinion from 1%, they are not treated as “equivalent opinions.” However, the media, perhaps placing too much emphasis on “fairness” or seeking to attract attention, reported the data that would save tens of thousands of lives and the emotional appeal of a single victim’s damage as “equals” side-by-side. Politicians, too, fearing public backlash, prioritized reading the “mood of the room” over scientific evidence. As a result, proactive recommendation of the HPV vaccine was suspended in Japan for about nine years, producing many cancer victims who could have been prevented during that time.

History Repeats Itself - The Intelligence to Resist the “Atmosphere”

In 2022, proactive recommendation of the HPV vaccine was finally resumed in Japan. However, the lost time and lives cannot be returned. And now, just as measles is rebounding in the United States, history will repeat itself over and over if we let our guard down.

It is impossible to completely deny the anti-vaccine movement or having concerns about medical care. Being cautious about what you put into your body is a human defense instinct, and drug-induced disasters have actually occurred in the past. Monitoring and doubting power is important in a democracy.

However, what the series of events—the COVID-19 vaccine, the HPV vaccine, and the measles outbreak in the US—confronts us with is the grim fact that “well-intentioned anxiety that ignores science” can claim more lives than the virus itself.

“It might be dangerous, so let’s wait and see.” When we make that decision, have we factored in the “probability of dying from the disease while waiting and seeing”? “Natural things are best.” When we say that, haven’t we forgotten the history that “it is the viruses found in nature that have taken lives most mercilessly”?

New infectious diseases will continue to appear, and new vaccines will be developed. When that happens, will we again be confused by the phenomenon of “coincidence” and swayed by emotional instigation? Or will we be able to calmly decipher the data and weigh the risks against the benefits?

It is said that history repeats itself. However, the only thing that can stop it is our reason. We must look at statistically correct data and possess the intelligence to choose “facts” over the “atmosphere.” That is our responsibility living in the modern age.

References / Data Sources

Ministry of Health, Labour and Welfare: “Human Papillomavirus Infection ~ Cervical Cancer and the HPV Vaccine ~”
National Cancer Center: Cancer Information Service “Cervical Cancer” Statistical Data
BBC News (Japanese): “US CDC Calls for Vaccination Amid Measles Outbreak; Global Infections on the Rise” (2024) and related original articles
Osaka University Research Team (Yagi A, et al. Lancet Public Health. 2020): Research on estimating excess morbidity and mortality due to the suspension of proactive recommendation for routine HPV vaccination
Nagoya Study (Suzuki S, et al. Papillomavirus Res. 2018)

The Illusion and Reality of "Japanese First": The Defense Mechanism Called "Coexistence" Facing Japan in 2026

Fri, 23 Jan 2026 13:43:41 +0900

The Illusion and Reality of “Japanese First”: The Defense Mechanism Called “Coexistence” Facing Japan in 2026

Introduction: Why Does This Phrase Resonate Now?

We now stand at an unprecedented turning point of an era. Prolonged inflation, sluggish real wage growth, and visibly advancing declining birthrates and aging population. Every time the price tags of products on supermarket shelves are rewritten, anxiety about the future casts a shadow over our hearts.

In the midst of this sense of stagnation, a phrase is rapidly gaining support. It is “Japanese First” (Nihonjin First).

The desire to “first enrich the lives of our own citizens” and “protect Japanese culture and public safety as a top priority” is an extremely natural and compelling urge as a sovereign individual, and as a human being living in this country. However, between the “ideal” championed by this phrase and the “reality” shown by statistical data, there exists a large gap that we must face squarely.

In this article, putting aside emotional arguments and labeling, we will close in on the true nature of this issue based on objective data, historical transitions, and facts occurring in various parts of society.

This phrase did not suddenly appear. It has been cultivated through a complex interplay of global trends and circumstances unique to Japan.

1. 2016-2017: Import and Establishment of the Phrase

In 2016, Donald Trump’s “America First” sent shockwaves around the world. Domestically in 2017, the “Tomin First no Kai” (Tokyoites First) led by Tokyo Governor Yuriko Koike attracted attention. At this point, it was largely a rhetorical device to clarify policy priorities, and exclusionary nuances were still limited.

2. 2023-2024: Visualization of Anxiety

The delayed economic recovery after the pandemic and inflation accompanying the rapid depreciation of the yen hit ordinary households directly. Around the same time, dissatisfaction based on fragmented information, such as “Support for foreigners is too generous” and “Japanese taxpayers’ money is flowing to foreigners,” began to erupt on social media.

In the 2025 national elections, forces officially using “Japanese First” as a slogan secured a certain number of seats. Social media algorithms, reacting to people’s anxieties, preferentially displayed extreme posts, accelerating the “echo chamber phenomenon” where only specific values are reinforced.

The latest public opinion poll conducted by various newspaper companies (late 2025) highlighted the reality that public opinion is split right down the middle regarding this slogan: 42% “Agree / somewhat agree” and 38% “Disagree / somewhat disagree”.

One of the pillars of the logic supporting “Japanese First” is the image that “Japanese resources are being usurped by foreigners.” However, primary data from government agencies shows a reality exactly opposite to this intuition.

1. Labor Force: The “Indispensable Blood” Maintaining the Japanese Economy

According to the Ministry of Health, Labour and Welfare’s “Foreigner Employment Situation (as of the end of October 2024)”, the number of foreign workers was **2,048,675 . Current estimates in 2026 show it has already surpassed ** 2.3 million.

Industrial Sector	Ratio/Increase Rate of Foreign Workers	Reality and Role
Construction	Approx. 22.7% increase YoY	Indispensable for infrastructure maintenance and repair of aging bridges and roads.
Medical/Welfare	Approx. 28.1% increase YoY	Serving on the front lines of caregiving, supporting elderly Japanese.
Manufacturing	Accounts for approx. 26% of the total	The backbone supporting the front lines of Japan’s export industry.

Currently, they are filling the “void that Japanese can no longer secure,” rather than jobs that Japanese people want to do but cannot. If we exclude them in the name of “Japanese First,” our caregiving system would immediately collapse, and housing and food prices would jump further from several tens of percent to multiple times.

The most widely spread narrative on social media is that “foreigners are receiving public assistance preferentially.” However, looking at the Ministry of Health, Labour and Welfare’s statistics, the proportion of households with foreign heads among all recipient households is about 2.8-2.9%. Over the past 10-plus years, this figure has remained almost flat.

Conversely, looking at the age composition of foreign residents, the majority are in the working generations in their 20s to 40s. They pay welfare pensions and health insurance premiums, playing the role of “providers” who support the pensions and medical expenses received by “elderly Japanese.” It is none other than them who are prolonging the life of Japan’s social security system by filling the void in the working generation left after the Japanese have departed.

Anxiety about public safety most strongly stimulates the emotions of “Japanese First.” However, a detailed reading of the National Police Agency’s statistics and the Ministry of Justice’s “White Paper on Crime” reveals how much the image of the “vicious foreigner” on the internet is created by cognitive distortion.

1. A Calm Comparison of “Total Numbers” and “Crime Rates”

According to statistics published in 2024, foreigners account for about 5.5% of all arrested persons. The remaining roughly 95% are crimes committed by Japanese.

Comparing the number of arrested persons per 100,000 population (crime rate) reveals the essence even further.

Category	Arrested Persons per 100,000 Population (Estimate)
Japanese (All Ages)	Approx. 142.7 people
Foreign Residents (Settled/Residents)	Approx. 120.0 people

It is a statistical fact that the crime rate of foreigners residing in Japan in the medium to long term is lower than the overall average for Japanese.

2. The Magic of Bias Due to “Generation”

Why does the image that “foreigners are scary” take precedence? The biggest factor is the difference in “age composition” in criminology.

Japanese: About 30% are elderly people with extremely low crime rates. Because this demographic pushes down the “denominator,” the overall figure for Japan appears low.
Foreigners: Because they come to Japan as a labor force, over 80% are in the “young to middle-aged group,” where crimes are statistically more likely to occur.

If we compare the crime rates of Japanese and foreigners under the same condition of “those in their 20s,” no significant difference is seen between the two. In other words, it is not that “public safety has deteriorated because the number of foreigners has increased,” but merely that “the age group prone to committing crimes (the youth) exists in Japan in the form of foreigners.”

Social media algorithms use our “anxiety” as fuel. When one foreign crime occurs, it is intensely spread in association with the “attribute (nationality).” Then, only the memory that “a foreigner caused an incident again” is reinforced in our brains.

This is called “confirmation bias.” Crimes by Japanese, which account for 95% of the total, are overlooked as “everyday life,” and the 5% of foreign crimes are swapped for the image of “all foreigners.”

Chapter 4: Inheritance of Culture — “Destroyers” or “Saviors”?

The concern that “Japanese traditions and culture will be destroyed” also differs from the reality on the ground.

1. The “Last Inheritors” of Traditional Crafts

The number of workers manufacturing Japanese traditional crafts has plummeted from about 300,000 in the 1970s to about 50,000 today. Those saving this crisis of extinction are foreigners who came to Japan with deep respect for Japanese culture.

Sake Breweries and Sword Smiths: Foreigners have become apprentices in workshops where Japanese people have almost given up on inheritance. By incorporating an ability to broadcast overseas and new sensibilities, they are revitalizing cultures on the verge of closure into “sustainable industries.”

2. Maintenance of Local Communities

In local municipalities that have become “cities at risk of disappearance” due to the disappearance of young people, technical interns and specified skilled foreign workers have become the bearers of local festivals and support the foundation of agriculture. Who is tilling the abandoned farmland left behind by departing Japanese and protecting events that have continued for hundreds of years? If we look at that reality, we understand that they are not the “destroyers” of culture, but the “last line of defense.”

Chapter 5: Concerns in the Educational Field and the Chain of “Bullying”

The side effects of bringing the phrase “Japanese First” into the educational field are serious.

The Binary Opposition Dividing “Inside and Outside”: If children internalize the mistaken elitism that “Japanese are a privileged class that should be prioritized,” it easily leads to bullying that excludes “those who are different from us.”
Ranking by Roots: Children who have Japanese nationality but look different or have different names are attacked as “not Japanese.” This is the collapse of education and an act of harming the very human resources who will carry the future of Japan.

Experts in the field of education fear the risk that the exclusivity carried by the word “First” will diminish children’s ability for multicultural coexistence, resulting in Japan isolating itself from the world.

Chapter 6: Global Trends and the Wave of Populism

This phenomenon is not unique to Japan. Even in Western countries, a phenomenon continues where demographics who could not receive the benefits of globalization drift towards populism championing “My Country First.”

However, where Japan differs decisively from the West is that “its population is decreasing at the fastest speed in the world.” While other countries may have the option of “restriction,” in Japan there already exist countless social infrastructures that cannot be maintained without “cooperation.” Continuing to adhere to an emotional “First” means a logical “slow suicide.”

In Conclusion: What is True “Japanese First”?

The desire embedded in the phrase “Japanese First” — the desire to “put the lives of the citizens first” — is in itself the most basic responsibility that a country’s government should have.

However, the means to fulfill that desire must not be the “exclusion of our neighbors.” Because, as objective data shows, the convenience of life, public safety, traditional culture, and the social security system itself that we currently enjoy are already in a phase of “dependence and coexistence” that cannot be established without the presence of foreigners.

Is not the true “Japanese First” to calmly put the following three points into practice?

Discussions Based on Facts: Do not be swayed by rumors or exaggerated information, but grasp reality based on primary statistics from government agencies.
Establishment of Fair Rules: Require foreigners to comply with Japanese rules, while Japanese society treats them as fair partners.
Internal Update: Do not view the acceptance of foreigners as “losing Japan,” but a paradigm shift recognizing that it is to “rebuild and maintain Japan” with their help.

In 2026, we stand at a major crossroads. Will we continue to shout words of division and strangle ourselves? Or will we face reality and take a step towards a “sustainable Japan” where diverse people support each other?

The answer lies within the “intelligence” and “courage” in the heart of each individual.

What to do when you cannot cancel Google One (Gemini)

Sat, 27 Sep 2025 10:02:59 +0900

[Warning] Will you be charged after the Gemini free trial ends? A guide on how to cancel

When you try out Google’s AI service “Gemini”, a 1-month free trial is offered at first. Many people probably register thinking, “If it’s free, I’ll just give it a try for now”, but there is something you need to be aware of here.

What happens when the free trial ends?

When the trial period ends, you will automatically be charged 2,900 yen per month. This is tied to a subscription called “Google One Membership”, and if you don’t do anything in particular, it’s set up to transition to a recurring charge.

You won’t be charged if you cancel, but…

Of course, if you cancel during the trial, you will not be charged. The official explanation page also explains “How to cancel your Google One membership”.

👉 Cancel your Google One membership (Official)

However, when I actually accessed it, I found myself in a situation where “for some reason, I can’t cancel.” I was confused, wondering “Wait, where do I stop it from?”

Here is the correct way to cancel!

After looking into it, the page where I was actually able to cancel was the following:

👉 Google Account – Delete a service

If you select “Google One” from here and delete it, the cancellation is complete.

Summary

The Gemini free trial is 1 month
After it ends, you are automatically charged 2,900 yen per month
You may not be able to cancel from the official explanation page
The place you can actually cancel is the “Delete a service” page

If you think “It’s fine because it’s a free trial”, you might get charged without realizing it, so please be careful!

👉 If you are reading this article, you might be struggling right now wondering “Where do I cancel from?”. Just check it out from the link above for now.

New Year's Card Creation App Development Stream VOL.1 (Script)

Sun, 31 Aug 2025 20:24:49 +0900

🎬 YouTube Stream Script (New Year’s Card Creation App Development - Part 1)

Start of the Stream (Opening 2-3 minutes)

Brief Greeting

“Hello. Starting today, I’ll be streaming the step-by-step development of a New Year’s card creation app in C++.” “I don’t know how many streams it will take to complete, but I’ll proceed little by little as a series.” “I’ll basically be working in silence, so I hope you can watch it as background music for your own work.”

Overview of the Target App

“In this app, I’d like to make it possible to design the back side of a New Year’s card.” “I plan to incorporate photo insertion, font arrangement, image processing and illustration generation using AI, and ultimately upload it to the Microsoft Store.”

Today’s Work Goals

“Today, in the first session, we will set up the environment and build the foundation.” “Specifically, I would like to proceed with:

Creating a GIT repository
Creating the main window
Displaying the version information dialog
Creating menus and implementing the exit command
Direct2D initialization/release processing and displaying HelloWorld”

Regarding the Source Code Release

“The source code is published on GitHub. If you are interested, please take a look.” → https://github.com/kenjinote/NengaCardApp/

Working Part (Silent)

Create GitHub repository → Initial commit

Create the skeleton of the main window

Create version dialog, menus, and implement the exit command

Direct2D initialization and release processing → Confirm HelloWorld display

Push to GitHub as appropriate

Basically silent, add short explanations only when necessary

Before Ending the Stream (Last 1-2 minutes)

Summary of Today’s Progress

“Today, we created the GIT repository and implemented the window, exit button, and version dialog.” “We were able to get to the point of displaying HelloWorld with Direct2D.”

Connection to Next Time

“From next time, I’d like to proceed with organizing the UI part and objectifying strings.”

Guiding to GitHub Link Again

→ https://github.com/kenjinote/NengaCardApp/

Closing

“Thank you for watching. I will continue to work steadily next time, so thank you for your support.”

Installing an MSIX with a Self-Signed Certificate

Sat, 30 Aug 2025 04:18:04 +0900

Installing an MSIX with a Self-Signed Certificate

When distributing apps on Windows, using MSIX packages is convenient because it unifies the installation and update mechanisms. However, MSIX has a restriction that it requires a “must be signed” certificate. There may be situations where you want to test-distribute an app developed for a company or individually, but “purchasing a commercial code signing certificate is too much.”

This is where a Self-Signed Certificate comes in handy. In this article, we will summarize the steps to attach a self-signed certificate to an MSIX and make it installable in a local environment.

1. Create a Self-Signed Certificate

First, launch PowerShell in administrator mode and run the following command.

1
2


// Create a self-signed certificate
New-SelfSignedCertificate -Type CodeSigningCert -Subject "CN=035A9AAC-915B-4CE1-AE39-1A101BED42F5" -CertStoreLocation Cert:\CurrentUser\My -NotAfter (Get-Date).AddYears(10) -KeyUsage DigitalSignature -FriendlyName "kenjinote"

This creates a certificate for “code signing”.

Giving it a descriptive name with -FriendlyName makes it easier to find later.
You can adjust the expiration date with -NotAfter. Here it’s set to 10 years.

2. Export the PFX File

Export the created certificate in PFX format so it can be used with signtool.

1
2
3
4


// Create pfx
$cert = Get-ChildItem Cert:\CurrentUser\My | Where-Object { $_.FriendlyName -eq "kenjinote" }
$password = ConvertTo-SecureString -String "password" -Force -AsPlainText
Export-PfxCertificate -Cert $cert -FilePath "D:\pfx\cert.pfx" -Password $password

The password set here (e.g., password) will be required later for signing operations.

3. Install the Self-Signed Certificate to Trusted Root Certification Authorities

The created certificate won’t be trusted by Windows as is. To install it, you need to import it into [Trusted Root Certification Authorities] -> [Certificates] from certmgr.msc.

If you import the exported certificate (.cer or .pfx), it will be treated as a trusted certificate on the target PC. This prevents the “untrusted certificate” warning when signing an MSIX.

4. Sign the Installer (MSIX)

Finally, use the created PFX certificate to sign the MSIX. signtool is included with Visual Studio and the Windows SDK.

1
2


// Sign the installer
signtool sign /fd SHA256 /f "D:\pfx\cert.pfx" /p "password" "C:\installer\installer.msix"

/fd SHA256 specifies the signature algorithm.
/f specifies the PFX file, and /p passes the password.
Finally, specify the path to the MSIX file.
If signtool is not in your path, specify the full path. In my environment, it was in the following location:

1

"C:\Program Files (x86)\Microsoft Visual Studio\Shared\NuGetPackages\microsoft.windows.sdk.buildtools\10.0.26100.1742\bin\10.0.26100.0\x64\signtool.exe"

This completes the signing, and the installable MSIX for the target PC is ready.

Summary

Create a self-signed certificate with New-SelfSignedCertificate
Export the PFX with Export-PfxCertificate
Install the certificate in Trusted Root Certification Authorities
Sign the MSIX with signtool

By following this flow, you can test operations and distribute locally without buying a commercial certificate. Of course, a certificate issued by a Certificate Authority is essential for actual commercial distribution, but this method is very convenient during the development and verification stages.

👉 In this example, we used installer.msix, but the same procedure applies to your own custom apps.

The Untold Story of LogicPad Development

Wed, 30 Jul 2025 23:51:35 +0900

Tools for those who “have logic but can’t write code.” Why I created LogicPad

Hello, I’m kenji. I’m the creator of the low-code tool “LogicPad”. This time, rather than introducing the product, I’d like to write about the behind-the-scenes of the development—“Why did I decide to make this?"—and my own thoughts from a slightly personal perspective.

To be honest, this was not just another tool development. My past, frustrations at the workplace, skill set, and the smoldering desire to “create my own product someday”— LogicPad was born as a result of all these things overlapping.

In other words, this is my “life’s culmination project.” I’ll write about this background as honestly and passionately as possible.

I wanted a product I could proudly say, “I made this.”

To be frank, this was my very first motivation.

Since a long time ago, I loved writing code for both work and hobbies. I’ve been involved in various developments. But one day, I suddenly realized. “I have no product released into the world under my own name, with my own responsibility.”

Of course, there is value in what you make as a team, and there was plenty of work I could be proud of. But somewhere in my mind, there was a sense of emptiness, wondering, “Am I going to finish my career under someone else’s name like this?”

Just once is enough. I want to leave something behind that I can proudly say, “I made this.” With that thought, I started conceptualizing LogicPad. This was about 6 years ago (around 2019). (The original idea itself came about 10 years ago in 2015 when I learned about Blueprint, the visual programming language of Unreal Engine.)

It’s a waste to hold back just because you can’t write code, isn’t it?

There were many excellent people at my workplace.

They could build logic. They mastered Excel functions freely and could see through to the essence of a problem. But—when it came to the stage of “writing code,” their hands would stop.

“I’m doing this task while looking at a manual every time, but couldn’t it be automated?” “Yeah, it can. But… you’d have to write code for that…”

Conversations like that happened countless times.

Every time, I thought: “It’s such a waste that people who understand the logic get stopped by the wall of code.”

The Choice of a Low-Code Editor

Actually, in my previous job, I was developing a 2D CAD operated by GUI. With CAD, you assemble shapes using a mouse, right? In other words, it’s a world where you “build logic through operations.”

I thought, “This is incredibly compatible with low-code.”

Going back even further, since my student days, I was mass-producing small programs—image processing, numerical processing, Windows tools, automatic SNS posting tools, etc.—by writing code as soon as I thought of them. I think there are over 600 of them. They are still on GitHub today.

Back then, I didn’t think about the meaning. I just “made things because I wanted to make them.” That was it.

But now, while making LogicPad…

I felt like the dots were finally connected into a line.

Easy to Use, Yet Powerful. The Difficulty of Balance

While proceeding with development, what I constantly thought about was “Making a tool that is intuitively usable and genuinely powerful.”

If you add features, you can do more. But it becomes harder to use. If you make it simple, anyone can touch it. But then some people will find it lacking.

So that people won’t say, “Low-code tools are just toys, right?” But also so they won’t say, “You have to write code in the end anyway.”

I fought continuously on that fine line between intuition and expressiveness.

I rebuilt the UI many times, threw it away many times, and when I finally got closer to a form where I thought, “This can work,” I was truly happy.

Saved by the Very First “User’s” Words

The first person I handed LogicPad to was a former colleague. They weren’t good at IT, and code was scary. But they were good at logic.

After I explained a bit and had them try it out… the single phrase they said a few minutes later, I still can’t forget.

“With this, I think even I could do it!”

I almost cried. This was exactly what I wanted to give them.

Not just a working tool, but the feeling of “I made it myself!”. I was convinced that this is the true value of LogicPad.

When More People Can Create, Society Becomes More Interesting

I genuinely believe that the “democratization of technology” is crucial.

Technology has the power to change the world. But the people who can handle it are limited.

What if you could build apps just by “understanding the logic”?

More people will be able to join the “creating side.” And I believe that what gets born from there will exceed our current imagination.

If LogicPad could become that gateway. I want it to be a tool that turns “I want to try making it” into “I can make it.”

That is my wish.

In Conclusion

LogicPad is still in beta and not finished yet. There are a mountain of improvements and things I want to do.

But I’ve poured all the “dots” of my life into this tool. Now, I can say with pride:

“This is a product that I made.”

👇 Bonus: What You Can Do with LogicPad

Build processes with drag-and-drop
Handle conditional branching and variables in the GUI
Features diverse AI integration nodes
Expandable for advanced users by inserting scripts
High-precision mathematical functions and data processing (such as infinite-precision numerical calculations)
Rich shortcut keys for advanced users
Supports over 90 languages

What I Want to Do Moving Forward

Generate logic from natural language in collaboration with AI
A system where users can create custom nodes
Build a platform to share created nodes and logic

✍️ Afterword

Thank you so much for reading this far. This wasn’t just a tool development; it was a challenge into which I poured my own experiences, passion, and fragments of my life.

“I can’t write code, but I have logic.” A future where such people become able to “create” with their own power. I want to continue aiming for that through LogicPad.

If this made you feel even a little bit like “I want to try using it,” that alone makes me very happy. If you’re interested, please definitely try out LogicPad.

And if you have any thoughts or things you noticed after using it, no matter how small, please let me know. Your voice will be a great power in creating the next step for this product.

Thank you for your continued support.

How to Batch Delete Metadata (Personal Information) from Excel, Word, etc. using PowerShell

Wed, 30 Jul 2025 02:42:40 +0900

How to Batch Delete Metadata (Personal Information) from Excel, Word, etc. using PowerShell

Office files like Excel automatically save “metadata (personal information)” such as the author, last modifier, and company name. There are many cases where you want to delete this information, such as when sharing files outside the company.

In this article, we will explain in detail how to delete Excel metadata using PowerShell, focusing on batch processing within a folder ** and ** applying it to other Office files like Word and PowerPoint.

1. Delete metadata of a single Excel file

This is the most basic script to delete personal information of a single Excel file. It calls the Excel COM object, sets the RemovePersonalInformation property to $true, and overwrites the file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Start the Excel application hidden
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

# Open the file (* specify absolute path)
$filePath = "C:\Path\To\Your\File.xlsx"
$wb = $excel.Workbooks.Open($filePath)

# Enable the setting to remove metadata (personal information)
$wb.RemovePersonalInformation = $true

# Overwrite, save, and close
$wb.Save()
$wb.Close($false)

# Quit Excel and release memory
$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

Note: Be sure to specify an ** absolute path (full path)** for the path passed to Workbooks.Open(). Using a relative path may cause an error.

2. Batch process all Excel files in a folder

In practice, there are many cases where you want to “delete the metadata of dozens of Excel files in a specific folder all at once.” This can be achieved by combining Get-ChildItem with a loop process.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


$targetFolder = "C:\Path\To\Your\Folder"

# Get all .xlsx and .xls files in the folder
$excelFiles = Get-ChildItem -Path $targetFolder -Include "*.xlsx", "*.xls" -Recurse

if ($excelFiles.Count -eq 0) {
 Write-Host "No Excel files found."
 exit
}

$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

foreach ($file in $excelFiles) {
 Write-Host "Deleting metadata for $($file.Name)..."

 # Open the file
 $wb = $excel.Workbooks.Open($file.FullName)

 # Delete metadata and overwrite save
 $wb.RemovePersonalInformation = $true
 $wb.Save()
 $wb.Close($false)
}

$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

Write-Host "All processing completed!"

3. Delete metadata of other Office files (Word / PowerPoint)

You can delete metadata not only in Excel but also in Word and PowerPoint using exactly the same logic. Only the name of the COM object called is different, and the fact that the RemovePersonalInformation property is available is common.

For Word

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$word = New-Object -ComObject Word.Application
$word.Visible = $false
$word.DisplayAlerts = 0

$doc = $word.Documents.Open("C:\Path\To\Your\File.docx")
$doc.RemovePersonalInformation = $true
$doc.Save()
$doc.Close()

$word.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($word) | Out-Null

For PowerPoint

For PowerPoint, the setting of the RemovePersonalInformation property is the same, but the behavior of hidden startup is slightly different.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ppt = New-Object -ComObject PowerPoint.Application

# Open by specifying hidden mode (msoFalse) etc. in the 2nd to 4th arguments
$presentation = $ppt.Presentations.Open("C:\Path\To\Your\File.pptx", $false, $false, $false)
$presentation.RemovePersonalInformation = $true
$presentation.Save()
$presentation.Close()

$ppt.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($ppt) | Out-Null

Conclusion

By utilizing PowerShell and COM objects, you can fully automate the deletion of Office file metadata. It is very useful to have a folder batch processing script on hand before delivery to prevent confidential information or personal names from accidentally leaking out.

A Simple Explanation of Kepler's Conjecture

Mon, 21 Jul 2025 22:53:03 +0900

A Simple Explanation of Kepler’s Conjecture! The Best Way to Pack Watermelons Tightly

Hello, this is kenji!

Today, I’d like to explain a mathematical concept with a somewhat difficult-sounding name, “Kepler’s Conjecture,” as simply as possible.

At first glance, it seems like a very niche topic, but it’s actually a quite familiar problem: “How can we pack watermelons as tightly as possible in a box?” It relates to convenience store refrigerators and how cargo is loaded.

And in the world of mathematics, it’s a super romantic story because it could not be proven for over 400 years.

Let’s get started!

Who is Kepler anyway?

First of all, who is the “Kepler” in “Kepler’s Conjecture”?

This is the name of a German astronomer and mathematician, Johannes Kepler.

He was a truly amazing person. For example, he’s the one who discovered that planetary orbits are elliptical. It’s common knowledge now, but back then (around 1600), even the heliocentric theory wasn’t widely believed.

Galileo = The genius of observation
Kepler = The genius who explained the universe with mathematical formulas
Newton = The super genius who compiled those theories into physical laws

In that kind of positioning, Kepler was a pioneer of “explaining the universe with mathematical formulas.”

And then, one day, he brought this up.

What is Kepler’s Conjecture?

Put simply, “Kepler’s Conjecture” is about this:

When packing spheres of the same size (like watermelons or oranges) into a box, which arrangement packs them the tightest?

That’s the problem.

And what Kepler conjectured in the 1600s was:

Isn’t it most efficient to stack them in a triangle-like shape, just like how oranges are displayed at a greengrocer?

That was it.

To say this more mathematically, it’s called the “Sphere Packing Problem,” which is the problem of finding the densest way to pack spheres into space.

Kepler conjectured that an arrangement called “Face-Centered Cubic (FCC)” structure (like stacking watermelons in a triangle) is the most efficient.

And, while everyone thought, “That certainly seems right,” it was incredibly difficult to mathematically prove that “This is absolutely the best!”

400 Years Until It Was Proven!?!

So, when was it actually proven?

Surprisingly, around 1998 to 2005. In other words, no one could prove it for nearly 400 years. That’s crazy.

Moreover, it was proven by an American mathematician named Thomas Hales.

He decided it was impossible to do by hand calculations alone, and proved it using computers. However, the proof was so complex that a problem arose: humans couldn’t properly check it!

This sparked a huge debate in the mathematical world: “So, can we really trust a proof done by a computer?”

In the end, the proof that said, “We have rigorously verified it, including the computer part!” (formally known as a “formal proof”) was completed in 2014.

In other words, it took over 400 years to prove that Kepler’s intuition was right. What a romantic story.

It’s Used a Lot in Real Life Too

You might think that “how to arrange spheres” is just a topic for math nerds, but it’s actually super practical.

Efficiently packing drinks in a convenience store refrigerator
Loading canned goods onto transport pallets
Applied to communications (like digital signal compression)
Used in 3D printers and the design of crystal structures

And so on, it’s a theory that’s actually heavily used behind the scenes in our daily lives.

Summary: Human Intuition is Amazing

So, let’s summarize.

Kepler’s Conjecture = The problem of how to pack spheres as tightly as possible
Mr. Kepler = The mathematician and astronomer who discovered planetary orbits
Conjectured in the 1600s! But proven in the 2000s!
It’s highly applied in real life!

And the most interesting part is that “the way greengrocers intuitively stacked things was mathematically the strongest.”

In short, human intuition is amazing. And the fact that it can take 400 years to prove it is such a romantic story.

If you’re interested, please try searching for things like “Thomas Hales”, “Formal Proof”, and “Sphere Packing”. It’s incredibly fascinating when you dig deeper into it.

See you!

[PR]

Buy Now

The Wall of AI Development

Sun, 20 Jul 2025 21:52:42 +0900

The Wall of AI Development

〜Made it to the 8th station, but from there it was hell〜

Hello, I’m kenji.

Recently, I’ve been hearing a ton of people saying, “I asked AI and it made an app for me!” We’ve moved past the era of no-code and low-code, and are entering a phase of “vibe coding” (writing code by feel).

For example, if you say, “Make an app that processes images and posts them to SNS,” AI will spit out the code and even the UI. It’s amazing, you’d think we don’t need humans anymore, right?

But you know, that’s like landing at the 8th station of Mount Fuji in sandals.

Getting to the 8th station looks “easy”

Development with AI is really easy at first. File I/O? It runs for now. Network? Well, it connects. Database? JSON is fine. UI? ChatGPT spit out React code. Billing? Just copy-paste the Stripe API.

Here, you get the illusion of “Am I an engineer now?”. But the real hell begins from here.

Why you get stuck

The reason is simple: “AI makes it look like it’s done, but leaves the final adjustments entirely to humans.”

Data gets lost in File I/O
DB normalization is weak so searches are slow
UI is not intuitive
Crashes from access concentration because no load testing was done
Rejected by Apple/Google review
(Almost) causes an uproar by violating legal requirements

In other words, **AI is good at creating a prototype that looks like a finished product , but ** finishing it into a product that actually works in the real world is still a human’s job today.

But there’s a paradox

Here you notice one paradox.

What if AI becomes able to truly do everything in the future? In other words, what if “AI can perfectly handle security, billing, and design all by itself”?

At that time, the need for humanity to create apps itself might disappear.

Because if a user directly tells the AI, “I want to do this kind of thing,” the task will be executed immediately without an app.

🌀For example

In the past, we “launched a calculator app to calculate”, but now it’s done just by saying, “Hey Siri, what’s 12 x 32?”.

In the same way, if you say “AI, process this photo and share it”, the process might be completed without going through any app UI or API.

In other words, when the goal of “making apps with AI” is realized, a world where apps themselves are unnecessary might arrive.

In the end, what we can do now

So, what should we do?

Right now, “above the 8th station” is still the human domain, so polish that
Focus on essential user understanding and service design
Think about “what’s valuable” rather than “what can be made”
Rather, explore ways of providing value that are “not bound by the format of an app”

AI is a tool, a lift, and sometimes a competitor. But, “what to make” and “why to make it” remain questions for us humans.

Conclusion:

The wall of AI development is not a paradox of technology, but of structure

An era where anyone can get to the 8th station of Mount Fuji. But the real thing starts from there.

And by the time we reach the summit, a future might be waiting where we ask ourselves, “Did we even need to climb the mountain?”.

How to call Microsoft.Windows.AI from C++

Sat, 19 Jul 2025 10:03:51 +0900

🎯 How to call `Microsoft.Windows.AI` from C++ [With Sample Code]

Since Windows 10, Windows has been equipped with a built-in **runtime capable of executing ONNX format AI models . This is ** Windows ML (Windows.AI.MachineLearning).

In this article, we will specifically explain how to call Microsoft.Windows.AI.MachineLearning from C++ (Win32 app based), along with ** sample code**.

✅ Preparation

◾ System Requirements

Windows 10 (1809+) or Windows 11
Visual Studio 2019 or later (Community edition is fine)
C++/WinRT Support (Microsoft.Windows.CppWinRT)
Windows SDK 10.0.17763.0 or higher

✅ Project Configuration

Create a project in Visual Studio with the following configuration:

Type: C++ Windows Desktop Application (Empty Project)
Subsystem: Windows (WinMain)
Add the following package via NuGet:
1

Microsoft.Windows.CppWinRT

✅ Sample Code

Below is a minimal sample combining the Win32 API and Windows.AI.MachineLearning using WinMain.

Note: Assume the ONNX model to be used is model.onnx, and place it in the same folder as the executable file.

`main.cpp`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <windows.h>
#include <winrt/Windows.AI.MachineLearning.h>
#include <winrt/Windows.Storage.h>

#pragma comment(lib, "windowsapp") // For WinRT linking

using namespace winrt;
using namespace Windows::AI::MachineLearning;
using namespace Windows::Storage;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
 // Initialize WinRT (Either MTA or STA is fine)
 winrt::init_apartment();

 try {
 // Load the model file
 auto modelFile = StorageFile::GetFileFromPathAsync(L"model.onnx").get();
 LearningModel model = LearningModel::LoadFromStorageFileAsync(modelFile).get();

 // Create a session
 LearningModelSession session(model);
 LearningModelBinding binding(session);

 // Model input/output (Here, a temporary empty input)
 // In practice, binding with TensorFloat etc. is required

 // Execute inference
 auto result = session.EvaluateAsync(binding, L"").get();

 MessageBox(nullptr, L"Inference completed", L"Windows ML (C++)", MB_OK);
 }
 catch (winrt::hresult_error const& ex) {
 MessageBox(nullptr, ex.message().c_str(), L"Error", MB_ICONERROR);
 }

 return 0;
}

✅ Supplement: How to Specify Input/Output Tensors

Depending on the model, it is necessary to create and bind Tensors before inference.

Example:

1
2
3
4
5
6
7
8


// Convert a 1D float array to a Tensor
std::vector<float> inputData = {0.5f, 0.3f, 0.2f};
std::vector<int64_t> shape = {1, 3}; // Shape: [1, 3]

auto tensor = TensorFloat::CreateFromArray(shape, inputData);

// Input binding (Match the model's input name)
binding.Bind(L"input_0", tensor);

Outputs can be obtained similarly using result.Outputs().Lookup(L"output_0").

✅ Debugging Tips

A FileNotFoundException will be thrown if the model file is not in the execution folder.
An invalid_argument error will occur if the input/output names do not match.
The exact I/O specifications of the model can be confirmed with tools like Netron.

✅ Summary

Item	Details
API Used	Windows.AI.MachineLearning (WinRT)
Language	C++ (Win32 based)
Recommended Method	Via C++/WinRT headers
Advantages	ONNX models run natively, GPU support available
Caution	Pay attention to model input names and Tensor shapes

✅ Alternatives: For those who do not want to use WinRT

By using Microsoft’s ONNX Runtime, you can handle ONNX models from C++ entirely without WinRT.
It supports cross-platform, allowing common code for Windows/Linux.

📌 Conclusion

Windows ML (Microsoft.Windows.AI) is a powerful AI inference engine that can be robustly used even from C++. If you need native inference on Windows, please give it a try.

For those who want specific examples of creating ONNX models and Tensor binding, we plan to explain them in a follow-up article!

Steps to call TinyLLaMA from C++ (using llama.cpp)

Sat, 19 Jul 2025 09:40:53 +0900

✅ TinyLLaMA × C++ Setup Steps (using `llama.cpp`)

🔧 Step 1: Prepare llama.cpp

1-1. Required Environment (Minimum)

OS: Windows / Linux / macOS
Development Environment: g++ / clang / MSVC
Git / CMake

1-2. Get and Build llama.cpp

1
2
3
4
5
6


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build
cmake ..
cmake --build . --config Release

On Windows, it is easier to use cmake --build . --config Release in the Visual Studio Developer Command Prompt.

📦 Step 2: Download and Convert the TinyLLaMA Model

2-1. Get the Original Model from HuggingFace

Example: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# Download using transformers if necessary
pip install transformers huggingface_hub

python3 -m transformers.models.llama.convert_llama_weights_to_hf \
 --input_dir ./TinyLlama-1.1B-Chat \
 --model_size 1B \
 --output_dir ./hf_model

This is a step to convert into Hugging Face format.

2-2. Convert to GGUF format (for `llama.cpp`)

1
2


cd llama.cpp
python3 convert.py ./hf_model --outfile tinyllama.gguf

2-3. Model Quantization (Size Reduction)

1

./quantize ./tinyllama.gguf ./tinyllama-q4.gguf q4_0

q4_0 is 4-bit quantization. The model size will be reduced to around 350MB.

🧪 Step 3: Call the Model from C++ (Code Example)

3-1. Simple C++ Code (Inference)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include "llama.h"
#include <iostream>

int main() {
 llama_model_params model_params = llama_model_default_params();
 llama_context_params ctx_params = llama_context_default_params();

 llama_model *model = llama_load_model_from_file("tinyllama-q4.gguf", model_params);
 llama_context *ctx = llama_new_context_with_model(model, ctx_params);

 std::string prompt = "The user says they want to read Excel data, filter it, and save it. What is the node configuration?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // Tokenize
 std::vector<llama_token> tokens(prompt.size() + 8);
 int n = llama_tokenize(model, prompt.c_str(), tokens.data(), tokens.size(), true);
 tokens.resize(n);

 for (size_t i = 0; i < tokens.size(); ++i) {
 batch.token[i + 1] = tokens[i];
 }

 batch.n_tokens = tokens.size() + 1;
 llama_decode(ctx, batch);

 // Get Inference Result
 for (int i = 0; i < 50; ++i) {
 llama_token next = llama_sample_token(ctx, nullptr);
 std::cout << llama_token_to_str(model, next);
 llama_batch next_batch = llama_batch_init(1, 0, 1);
 next_batch.token[0] = next;
 next_batch.n_tokens = 1;
 llama_decode(ctx, next_batch);
 }

 llama_free(ctx);
 llama_free_model(model);
 return 0;
}

🧱 Step 4: Compilation Method (Example)

1

g++ -I./llama.cpp main.cpp ./llama.cpp/build/libllama.a -o tiny_infer -pthread -std=c++11

libllama.a will be created in the build/ directory after building.

✅ Example Structure of Output (Organized)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # Quantized model (~350MB)
├── main.cpp # C++ code above
├── llama.cpp/ # llama.cpp core
└── build/
 └── libllama.a # Compiled library

🧠 Additional Notes for Applying to Use Cases

Include code in C++ to match and select node templates based on the output
Example: If “Excel”, “filter”, and “save” are included -> Generate corresponding nodes
A simple structure like if statements + JSON template loading is fine for this part

📌 Summary

Item	Content
Recommended Model	TinyLLaMA-1.1B-Chat v1.0 (GGUF + Quantization)
Size	~350-450MB (4-bit quantization)
C++ Integration	Possible using `llama.cpp`, almost no external dependencies
Processing Capability	Sufficient for basic intent understanding and output generation (Natural Language -> Structure)
Scalability	Can be made into a node generation AI by combining slot filling and template calling

How to post a message to Slack using Slack App + OAuth2

Wed, 16 Jul 2025 23:36:27 +0900

✅ Posting Method Using an Access Token (Slack Web API)

Slack’s “OAuth Token (such as xoxb-…)” is a key used to post using Slack’s Web API. In this case, unlike Webhooks, you POST to the Slack API Endpoint with an Authorization: Bearer header.

🔑 Required Prerequisites

You need to include chat:write in the OAuth Scopes of your Slack app:

Setup Steps

Go to https://api.slack.com/apps
Create an app or select an existing one
Under “OAuth & Permissions” > Scopes → Add chat:write
“Install to Workspace” or “Reinstall” to get the Access Token (e.g., xoxb-xxxxxxxxxx)

💻 C++ Code (Posting to Slack API using WinHTTP)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostSlackMessage(const std::wstring& accessToken, const std::string& channel, const std::string& text) {
 const wchar_t* host = L"slack.com";
 const wchar_t* path = L"/api/chat.postMessage";

 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 if (!hSession) return false;

 HINTERNET hConnect = WinHttpConnect(hSession, host, INTERNET_DEFAULT_HTTPS_PORT, 0);
 if (!hConnect) return false;

 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", path,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 // Authorization header and Content-Type
 std::wstring headers = L"Content-Type: application/json\r\n";
 headers += L"Authorization: Bearer " + accessToken + L"\r\n";

 // JSON body
 std::string body = R"({"channel":")" + channel + R"(","text":")" + text + R"("})";

 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 (DWORD)-1,
 (LPVOID)body.c_str(),
 body.length(),
 body.length(),
 0);

 if (!result || !WinHttpReceiveResponse(hRequest, NULL)) {
 std::cerr << "Send error\n";
 return false;
 }

 // Check status code
 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring token = L"xoxb-your-access-token"; // Access Token
 std::string channel = "channel-ID-or-#general"; // Example: "#general" or "C0123456789"
 std::string message = "I tried posting to Slack from C++!";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "Post successful!\n";
 } else {
 std::cerr << "Post failed.\n";
 }

 return 0;
}

📌 How to Get the Channel ID

Using just the channel name (e.g., #general) may sometimes result in an error. A more reliable method is to use the ID found in the URL of the Slack channel page.

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑ This part is the Channel ID

✅ About Token Types (Supplementary)

Token Format	Purpose	Example Use Case
`xoxb-...`	Bot Token (Recommended)	Post, edit, delete
`xoxp-...`	User Token (Not Recommended)	Non-bot operations
Refresh Token	Long-term token renewal	Usually not used

📝 Summary

To post to Slack from C++, the Slack Web API + Bearer Token method is reliable.
Use the chat.postMessage endpoint with HTTPS POST.
The token must be sent in the Bearer header.
Specifying the channel by ID is recommended.

How to Post Messages to Slack using C++ (Win32 API + WinHTTP) [Webhook Supported]

Wed, 16 Jul 2025 19:42:56 +0900

How to Post Messages to Slack using C++ (Win32 API + WinHTTP) [Webhook Supported]

I want to post messages to Slack from C++. It’s common in Node.js or Python, but doing it with “C++ × Win32 API × WinHTTP” is quite rare, isn’t it?

In this article, I will explain how to send messages from C++ to Slack using a Webhook URL, step-by-step and in an easy-to-understand manner.

✅ Overall Flow

To post to Slack, follow these steps:

Obtain a Slack Webhook URL (API key)
Send a POST request using WinHTTP
Assemble the message body in JSON format
Check the result and you’re done!

🔑 Step 1: How to Obtain a Slack Webhook URL

Slack allows you to easily post messages from external services using a feature called Incoming Webhooks.

Steps to Obtain

Access https://api.slack.com/apps
Click Create New App
Choose From scratch, then select the app name and the workspace to post to
Select “Incoming Webhooks” from the left menu and enable it
Click “Add New Webhook to Workspace” and select a channel
Copy the generated URL (e.g., https://hooks.slack.com/services/xxx/yyy/zzz)

This URL functions like an API key.

💻 Step 2: Send a Message to Slack with C++ Code

Technologies Used

Win32 API
WinHTTP (Standard Library)
JSON formatted messages

Sample Code (Posting to Slack)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostToSlack(const std::wstring& webhookUrl, const std::string& messageJson) {
 // Parse URL
 URL_COMPONENTS urlComp{};
 wchar_t hostName[256];
 wchar_t urlPath[1024];

 urlComp.dwStructSize = sizeof(urlComp);
 urlComp.lpszHostName = hostName;
 urlComp.dwHostNameLength = _countof(hostName);
 urlComp.lpszUrlPath = urlPath;
 urlComp.dwUrlPathLength = _countof(urlPath);

 if (!WinHttpCrackUrl(webhookUrl.c_str(), 0, 0, &urlComp)) {
 std::wcerr << L"Failed to parse URL\n";
 return false;
 }

 // Connect and start HTTP session
 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 HINTERNET hConnect = WinHttpConnect(hSession, hostName, urlComp.nPort, 0);
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", urlPath,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 std::wstring headers = L"Content-Type: application/json\r\n";
 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 -1,
 (LPVOID)messageJson.c_str(),
 messageJson.length(),
 messageJson.length(),
 0);

 if (!result) {
 std::cerr << "Send request failed\n";
 return false;
 }

 WinHttpReceiveResponse(hRequest, NULL);

 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 // Release resources
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring webhookUrl = L"https://hooks.slack.com/services/xxx/yyy/zzz"; // Replace with your Webhook URL

 std::string message = R"({
 "text": "Hello from C++ :rocket:",
 "username": "C++ Bot",
 "icon_emoji": ":robot_face:"
 })";

 if (PostToSlack(webhookUrl, message)) {
 std::cout << "Posted successfully!\n";
 } else {
 std::cerr << "Failed to post.\n";
 }

 return 0;
}

🧪 Customizing JSON Messages

With Slack Webhooks, you can include parameters like the following:

1
2
3
4
5
6


{
 "text": "Notification content",
 "username": "Bot name",
 "icon_emoji": ":rocket:",
 "channel": "#desired_channel_name"
}

📌 Supplementary Notes

Content-Type must be specified as "application/json"
Pass the Webhook URL as a wstring without any changes (URL encoding is unnecessary)
Since it’s HTTPS communication, don’t forget WINHTTP_FLAG_SECURE

🎉 Bonus: Example of Post Confirmation in Slack

It will be displayed in Slack like this:

1
2


[C++ Bot]
Hello from C++ :rocket:

✍️ Summary

Item	Details
Posting Method	Webhook (Incoming Webhooks)
Communication Library	WinHTTP
Data Format	JSON
Usable Parameters	text, username, icon_emoji, channel, etc.

Even if you thought “Integrating C++ with Slack? No way…”, you can start embedding a notification bot today!

🚀 Teaser for Next Time?

If you’re interested, next time:

File attachments
UI with buttons
Flexible API operations with Slack App + OAuth2

I can introduce you to more advanced Slack integrations like these!

Market-In and Product-Out

Tue, 15 Jul 2025 20:18:22 +0900

Market-In vs. Product-Out

Hello, this is kenji.

Sometimes in business books or proposals,

“We use a market-in strategy.” “This is a product-out approach, isn’t it?”

You see people saying things like this, but…

Wait, market-in? Product-out? Which one is better???

Don’t you ever feel that way?

So this time, I want to break down these terms “market-in” and “product-out” as simply as possible, with a slightly critical eye.

Simply put…

Market-in: Listening to the voice of the market and creating products that match it.
Product-out: Creating what you think is good (the product) and putting it out into the world.

That’s it. Simple.

For example, with a ramen shop…

A market-in ramen shop would be like, “Iekei ramen is popular lately. Alright, let’s go with plenty of fat and garlic!”

A product-out ramen shop would be like, “This soy milk basil salt ramen I made is seriously the best, so eat it.”

Which one is the correct answer… Both are.

With market-in, you cater to customer needs, so “the probability of it selling is high,” but it’s hard to produce breakthrough ideas or innovations.

With product-out, you “give shape to the justice you believe in,” so it’s edgy and attractive, but if you miss the mark, it won’t resonate with anyone.

The iPhone is quite product-out

Apple released the iPhone in an era when people were saying “I don’t need a smartphone.”

This is completely a successful example of product-out.

If they had just listened to users, they would have been told “A phone without a keyboard? Impossible,” and that would have been the end of it.

But product-out can easily become “self-satisfaction”

Sometimes there are companies or people who say, “We are a product-out type,” but

Wait, isn’t that just ignoring the user?

I sometimes think that.

“I made it because I wanted to. But it didn’t sell.” That’s not product-out, that’s “self-indulgent-out.”

Market-in has pitfalls too

On the other hand, market-in is not omnipotent either.

If you say, “I’ll do everything because the users want it!”, the core of the product gets blurred, and in the end, it might not resonate with anyone.

It’s like when you keep adding features, and before you know it, it’s become a chaotic tool.

The ones who are truly amazing are “those doing both”

Amazing products perfectly present “something users truly wanted but couldn’t put into words.”

In other words, it means “getting market-in style empathy with a product-out mindset.”

It’s easy to say, but incredibly difficult to do. However, if you can pull this off, it instantly becomes a “god-tier product.”

Conclusion: User reaction is everything, not words

Market-in or product-out. Which is right is a pretty meaningless question.

“Is it properly reaching the users’ hearts?” That’s everything, I think.

I feel like saying “we’re doing this kind of strategy” is fine as long as you can write it in marketing materials later.

So, that was a talk about market-in and product-out!

Without being confused by weird loanwords, thinking about “In the end, what will make people happy?” is the healthiest approach, I think.

See you around~.

Collatz Conjecture

Tue, 15 Jul 2025 18:03:03 +0900

Is it true that “any number eventually becomes 1”? ── Playing with the Collatz Conjecture

Hello! I’m kenji.

Suddenly, but if you hear “a rule where any number eventually becomes 1”, isn’t it a bit mysterious?

For example, 19, or 87, or even 1000000. If you tweak the numbers according to appropriate rules, for some reason it converges to “1” at the end.

Such a dream-like story is the Collatz Conjecture.

What is the Collatz Conjecture anyway?

First, let me introduce the rules.

Start: Choose any positive integer
Operation:
- If it is even → Halve it (n → n / 2)
- If it is odd → Triple it and add 1 (n → 3n + 1)

If you repeat this forever, the conjecture says that any number will eventually reach 1.

For example, starting from 6:

1

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

It properly became “1”. Welcome back!

Let’s do it in code: Collatz in Python

Now, in times like this, it’s faster to try it in code! Let’s output the “Collatz sequence” in Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def collatz(n):
 steps = [n]
 while n != 1:
 if n % 2 == 0:
 n = n // 2
 else:
 n = 3 * n + 1
 steps.append(n)
 return steps

# Example: Starting from 19
print(collatz(19))

When you execute it:

1

[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

It splendidly reaches 1. Even though it takes quite a detour, it firmly reaches the goal at the end!

By the way, even if you start from 29, it reaches 1 in the same way.

1

print(collatz(29))

When you execute it:

1
2
3
4
5
6
7
8


[27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242,
121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350,
175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167,
502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479,
1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911,
2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35,
106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Surprisingly, it takes 111 steps!

Moreover, there are scenes where it balloons to over 9000 along the way. It’s a pattern that takes a huge detour before reaching the goal.

So, what’s amazing about it in the end?

What’s amazing about this conjecture is,

Even though it hasn’t been proven, it seems to become 1 no matter what number you use

That’s the point.

Eh? Then, what about 1 trillion, or 10 quadrillion…?

If you thought that, you are sharp. Actually, it has been verified up to about “2 to the 68th power” using computers, and all have reached 1. Unbelievable…

But, it hasn’t been theoretically proven that “it always happens”. This is what they call an “unsolved problem” in the world of mathematics.

Who is Mr. Collatz?

So, reading this far, you might wonder “who is Collatz anyway?”. Let me introduce him properly!

Name: Lothar Collatz
Nationality: Germany
Year of birth: 1910 - 1990
Title: Mathematician (Active in the fields of functional analysis and number theory)

He proposed this conjecture in 1937, and since then, for over 80 years, no one has been able to prove or disprove it.

By the way, this problem is so simple yet so deep that even Paul Erdős (a super famous mathematician) is said to have said this:

“Mathematics may not be ready for such problems.”

In other words, the theory that human mathematics hasn’t caught up with this mystery yet…

No “complex math formulas” are necessary

The good thing about the Collatz Conjecture is that anyone can play with it.

You can do it if you have paper and pen. If you write code in Python, you can test it automatically. And yet, cutting-edge mathematicians are seriously challenging it.

Doesn’t it make you excited?

Bonus: Code to test it all at once

I’ll also include code to test various numbers all at once.

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps} (Steps: {len(steps)-1})")

This outputs the Collatz sequences from “1 to 20” all at once.

Conclusion: This world is indeed mysterious

So, that’s the Collatz Conjecture.

Even though it’s super simple
No one can prove it
It’s a huge problem in the math community

It’s an existence like a cluster of mysteries.

Even programming beginners can try it, so please definitely play with it~!

How to Post Messages to Microsoft Teams from C++ (WinHTTP + Graph API)

Mon, 14 Jul 2025 23:40:15 +0900

How to Post Messages to Microsoft Teams from C++ (WinHTTP + Graph API)

I want to automatically post to a Microsoft Teams chat –
Microsoft Graph API is exactly what you can use in such cases.
In this article, I will introduce a C++ code example using WinHTTP ** and the ** necessary API authentication steps step by step.

🔧 Necessary Preparations (Microsoft Graph API Authentication Settings)

1. Register App in Azure Portal

First, to use the Microsoft Graph API, you need to register an app in Azure.

Access the Azure Portal
“Microsoft Entra ID ” > “+ Add ” > “ App registrations ” > “ New registration”
Enter any app name and click “Register”

2. Add API Permissions

Go to the “API permissions” left menu
Under “Microsoft Graph ” > “ Add a permission ”, search for the following scopes and click “ Update permissions”

Chat.ReadWrite
User.Read

If you want to post to a channel, ChannelMessage.Send is also required

3. Note Client ID and Tenant ID

Make a note of the following two items displayed on the “Overview” tab:

Application (client) ID
Directory (tenant) ID

4. Create Client Secret

Go to the “Certificates & secrets” tab
“New client secret” > set the expiration date, and click “Add”
Be sure to note ** the displayed value (secret) ** on the spot

🔐 Obtaining an Access Token (OAuth2)

Use the client_credentials flow to obtain it.
Run the following command with curl to obtain an access token.

1
2
3
4
5
6
7


curl -X POST ^
 https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token ^
 -H "Content-Type: application/x-www-form-urlencoded" ^
 -d "client_id={client_id}" ^
 -d "scope=https%3A%2F%2Fgraph.microsoft.com%2F.default" ^
 -d "client_secret={client_secret}" ^
 -d "grant_type=client_credentials"

Example Response

1
2
3
4
5
6


{
 "token_type":"Bearer",
 "expires_in":3599,
 "ext_expires_in":3599,
 "access_token": "eyJ0eXAiOiJKV1QiLCJub... (omitted)"
}

Call the Microsoft Graph API using this access_token.

💬 C++ Sample for Posting to Teams Chat

Here is a C++ example of posting to a chat using WinHTTP.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <windows.h>
#include <winhttp.h>
#include <iostream>
#include <string>

#pragma comment(lib, "winhttp.lib")

void PostToTeamsChat(const std::wstring& accessToken, const std::wstring& chatId, const std::wstring& message) {
 HINTERNET hSession = WinHttpOpen(L"TeamsPoster/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);

 HINTERNET hConnect = WinHttpConnect(hSession, L"graph.microsoft.com", INTERNET_DEFAULT_HTTPS_PORT, 0);

 std::wstring endpoint = L"/v1.0/chats/" + chatId + L"/messages";
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", endpoint.c_str(), NULL,
 WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);

 std::wstring jsonBody = L"{\"body\": {\"content\": \"" + message + L"\"}}";
 std::wstring headers = L"Authorization: Bearer " + accessToken + L"\r\nContent-Type: application/json\r\n";

 BOOL bResult = WinHttpSendRequest(hRequest,
 headers.c_str(), (DWORD)-1L,
 (LPVOID)jsonBody.c_str(), (DWORD)(jsonBody.length() * sizeof(wchar_t)),
 (DWORD)(jsonBody.length() * sizeof(wchar_t)), 0);

 if (bResult)
 WinHttpReceiveResponse(hRequest, NULL);

 DWORD dwSize = 0;
 WinHttpQueryDataAvailable(hRequest, &dwSize);

 if (dwSize > 0) {
 std::wstring response(dwSize / sizeof(wchar_t), 0);
 DWORD dwDownloaded = 0;
 WinHttpReadData(hRequest, &response[0], dwSize, &dwDownloaded);
 std::wcout << L"Response: " << response << std::endl;
 }

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);
}

int main() {
 std::wstring access;
 std::wstring chatId = L"19:";
 std::wstring message = L"Hello from C++!";
 std::wcout << L"Enter your access token: ";
 std::getline(std::wcin, access);
 std::wcout << L"Enter chat ID: ";
 std::getline(std::wcin, chatId);
 PostToTeamsChat(access, chatId, message);
 return 0;
}

🔍 How to Get Chat ID

You can check the Chat ID with GET /v1.0/me/chats.

1
2
3
4


curl -X GET ^
 https://graph.microsoft.com/v1.0/me/chats ^
 -H "Authorization: Bearer {access_token}" ^
 -H "Content-Type: application/json"

Example Response

1
2
3
4
5
6
7
8
9


{
 "value": [
 {
 "id": "19:abc123xyz@thread.v2",
 "topic": null,
 "chatType": "oneOnOne"
 }
 ]
}

📌 Points to Note

This sample is a minimal implementation. In actual operation:
- Token expiration handling
- HTTPS certificate validation
- Enhanced error handling
For channel posting, use teams/{team-id}/channels/{channel-id}/messages.
Sending attachments requires multipart processing or the Graph Drive API.

Summary

📎 Summary

Feature	Overview
Graph API	Official API to interact with Teams
App Registration	Required authentication procedures on Azure
Access Token	Obtained via OAuth2, used for requests
C++ Implementation	Call Graph API using WinHTTP

🚀 Next Steps

As more advanced samples, the following are also possible:

Team channel posting (/teams/{team-id}/channels/...)
Posting with attachments
Switching between bot accounts and user accounts
Full C++ implementation including token acquisition

If you have any requests, please feel free to comment!

About Required Marks in Input Forms

Mon, 14 Jul 2025 13:47:51 +0900

I have summarized information about the “required” mark in overseas screen UI (forms), along with UI guideline materials.

📌 Main Required Marks and Best Practices

Using an Asterisk (*)
- This is generally the most widespread method, adding “*” to required fields.
- However, an explanation such as “* indicates a required field” at the beginning of the form is essential (Nielsen Norman Group, California State University, Northridge).
- There are also examples that use color for emphasis (such as red text).
Clearly Stating “Required” or “(required)” in the Label
- By explicitly adding “Required” in text within the label, it can be clearly communicated to screen readers, improving accessibility (Deque).
Using ARIA Attributes or HTML5 required Attribute in Conjunction
- In addition to visual indication, using aria-required="true" or <input required> allows you to programmatically communicate that a field is required (Deque).
Clearly Stating Optional Fields Using “(optional)”
- There is also a method of explicitly indicating optional fields as “(optional)” instead of required fields, which is effective when both are mixed.
- However, Nielsen-Norman points out that “it is easier to judge if required fields are also explicitly indicated” (TPGi).

✅ Summary of UI Guideline Materials

Source	Content
NN/g: Marking Required Fields in Forms	A combination of an asterisk + explanatory text is recommended, and showing only optional fields is evaluated as unfriendly (Nielsen Norman Group).
Deque (Anatomy of Accessible Forms)	- Use the string “Required” or an image within the label. - Explicitly states that suggesting by color alone is insufficient.
W3C Techniques (H90)	There are examples of including an asterisk or “(required)” in the label and defining the meaning at the beginning of the form.
TPGi (Doing what’s required)	Considering accessibility, evaluated that an asterisk + ARIA attribute + inserting label text is optimal.
Contensis UX Forms Guidelines	Briefly summarizes that consistent marking (* or (optional)) is important.

✅ Recommended Implementation Approach

Add an explanatory text at the beginning of the form:

Fields marked with * are required. (Or collectively “All fields are required”, and if there are optional fields, “unless marked optional”)
Applying Labels:
- Write it like First Name * or Email (required).

ARIA Attributes / HTML5 Attributes:

1
2


<label for="email">Email <abbr title="required">*</abbr></label>
<input id="email" required aria-required="true">

Do not rely on color alone: Support both visual and programmatic indications.

🔗 Reference Links (UI Guideline Materials)

NN/g: Marking Required Fields in Forms (California State University, Northridge, Nielsen Norman Group, Deque)
Deque: Anatomy of Accessible Forms (Deque)
W3C Techniques: H90 Indicating required form controls (W3C)
TPGi: Indicating mandatory fields accessibly (TPGi)
Contensis: UX Forms Guidelines (Contensis)

If necessary, I can also provide specific HTML/CSS code examples, UI component design templates for Sketch/Figma, etc. Please feel free to consult with me!

How to Install Gemini CLI on Windows Environment

Sun, 13 Jul 2025 23:49:56 +0900

[For Beginners] How to Install Gemini CLI on Windows

“Gemini CLI” allows you to use Google’s generative AI “Gemini” from the command line. In this article, we will explain the steps to install Gemini CLI in a Windows environment as easily as possible.

1. Preparation: Install Node.js and npm

First, since Gemini CLI runs on an environment called “Node.js”, you need to have the following installed:

Node.js
npm (Package management tool included with Node.js)
npx (Command execution tool included with npm)

Please download the Windows version of Node.js from the official website below (the LTS version is recommended):

👉 Node.js Official Website

Once the installation is complete, let’s verify if it was installed correctly with the following commands.

1
2


node -v
npm -v

2. Launch PowerShell

To use Gemini CLI on Windows, it is common to operate it using PowerShell. Type “PowerShell” in the Start menu to launch it.

3. Install Gemini CLI

Copy and paste the following command into PowerShell and execute it:

1

npx @google/gemini-cli

This command temporarily executes the Gemini CLI package published by Google. You may be prompted for initial setup or login if necessary.

Note: It may take a few minutes the first time. If you encounter an error, please double-check your Node.js or network environment.

4. Installation Complete! What to do next

Now, Gemini CLI has been installed on Windows. From now on, you will be able to perform various operations using Gemini from the command line, such as text generation and code completion.

If you want to check the official documentation or help, you can also utilize commands like the following.

1

npx @google/gemini-cli --help

Conclusion

Let’s review the steps to introduce Gemini CLI to Windows.

Install Node.js and npm
Launch PowerShell
Execute npx @google/gemini-cli

Now you’re all set! If you want to use generative AI locally, please give it a try using these steps as a reference.

I have been awarded Microsoft MVP (2025-2026) again

Sun, 13 Jul 2025 22:01:15 +0900

I’ve been awarded Microsoft MVP (2025-2026) again!

Hello, I’m kenji.

I have an announcement. I was awarded the Microsoft MVP (Most Valuable Professional) again this year. This is my ** 9th time** receiving the award.

Thank you so much to everyone who always supports me.

What is Microsoft MVP?

When you hear “MVP”, many of you might think of the most valuable player in sports, but the MVP here is a title given to those who contribute to Microsoft’s technical community.

Specifically,

Sharing information on tech blogs and social media
Publishing sample code on GitHub
Speaking at study sessions and conferences
Answering questions on Q&A sites
Technical exchange and collaboration with developers overseas
Participating and posting in communities where engineers connect with each other

It’s a system that evaluates activities like “sharing one’s own knowledge and experiences for others”.

There are awardees all over the world, but the number of people selected each year is limited, and being awarded again is by no means easy. That’s why it is a real honor to be recognized in this way.

What I focused on this past year

This year, I put effort into sharing information with an awareness of making technology “easy to understand” and “accessible”.

Publishing practical sample code on GitHub
Speaking at study sessions and conferences (both domestic and international)
Regular information sharing through tech blogs and social media
Continuous answering activities on Q&A sites
Knowledge sharing on engineer community sites
Communication and joint verification with engineers overseas

Among them, publishing code on GitHub was particularly memorable because I sometimes received feedback like, “I was struggling with the exact same thing, so this helped!” which made me realize that my efforts are helping others with their development.

Also, I received feedback during my event presentations that it was “easy to understand even for beginners”, which served as a good opportunity to think about “what makes an effective technical explanation?”.

Looking towards next year

The evolution of technology is incredibly fast, and just keeping up with it is tough. Even so, I believe there is great value in delivering real knowledge as “primary information”, such as the actual experiences I gained from trying things out and the points where I stumbled.

Next year, I want to take on the challenge of publishing “visually easy-to-understand technical content” incorporating videos and diagrams. I hope to increase the kind of output that can even slightly resolve someone’s “I’m stuck!” moments.

Finally

The title of MVP is ultimately just one milestone.

I will continue at my own pace, without overdoing it. But while making sure to be of help to someone.

“This saved me when I was looking it up” “This sample worked!” “This talk was easy to understand”

I want to continue being the kind of engineer that people say these things about.

Thank you very much for your continued support.

Advantages and Disadvantages of Creating Programs with Win32API + C++

Sat, 12 Jul 2025 12:30:35 +0900

The Appeal and Challenges of Developing with Win32API + C++

For those who want to master Windows application development, Win32API + C++ remains a powerful option today. This combination, which allows for interacting with the OS at the closest distance, combines high speed and flexibility.

On the other hand, since it is vastly different from modern development styles, learning it requires dedication.

On this page, from the perspective of an active Windows app developer, we explain its advantages and disadvantages in an easy-to-understand manner.

Advantages

Ultra-Fast Native Execution

Because C++ and Win32API operate at the layer closest to the OS, there is almost no unnecessary overhead. It boasts overwhelming execution speed and highly efficient use of CPU and memory.

High Flexibility and Freedom

You can minutely control all aspects of an application yourself, such as window control, asynchronous processing, COM integration, and process management. It’s also possible to build purpose-built tools and your own custom frameworks.

Easy to Distribute Without Runtimes

Since external runtimes like .NET or Java are unnecessary, it can be distributed as a single executable file. Troubles during redistribution are less likely to occur, and it’s appealing that it can easily run without an installer.

Capable of Creating Lightweight Apps

Because it requires only a bare-minimum configuration, a major feature is its extremely small memory footprint. It runs comfortably even on low-spec PCs or in virtual machine environments.

Advanced OS-Level Control is Possible

Global hooks for mouse and keyboard, fine-tuning of window styles, manipulation of system menus, and other forms of control that are difficult with standard languages and libraries can be realized.

Disadvantages

Low Development Efficiency

GUI construction must also be done entirely in code, and creating a single button can sometimes require dozens of lines of code. Modifications during design changes are also cumbersome, making productivity lower compared to developing with UI frameworks.

Maintainability Tends to Decrease

The code often has a specialized structure, such as message loops and window procedures, leading to issues with readability and reusability. It also has aspects that make it unsuitable for team development and long-term maintenance.

Difficult to Support Modern UI

Supporting UX expected in recent years, such as high DPI support, touch interfaces, accessibility, and dark mode, is difficult. Each must be handled manually one by one, which requires a lot of effort.

No Cross-Platform Support

Because it is a completely Windows-exclusive API, it cannot be ported to macOS or Linux. If you are planning multi-platform deployment, you will need to select other technologies.

Extremely High Learning Cost

You must understand concepts and mechanisms that are rarely used today, such as handles, GDI, COM, and OLE. Much of the documentation is old, requiring time and perseverance to learn.

Suitable Uses

Lightweight tools such as file launchers and hotkey assistants
System utilities like clipboard manipulation and IME control
Native control applications like global hooks and window captures
Driver auxiliary tools that work closely with hardware

Unsuitable Uses

General consumer apps where modern UI/UX is important
Prototyping and MVP development built with a priority on speed
Large-scale projects intended for long-term operation and team development
Cross-platform products that need to support multiple OSs

Evaluation Summary

Aspect	Evaluation
Execution Speed	◎ Very Fast
Memory Efficiency	◎ Excellent
Development Speed	× Slow
Maintainability	× Low
Cross-Platform Support	× Not Supported
Modern UI Support	× Weak
Freedom of OS Control	◎ Overwhelmingly High

Conclusion

Win32API + C++ is a tool suited for developers who want to “handle everything in the OS themselves.” While its power is immense, learning and operating it requires a corresponding level of dedication.

Whether it’s worth “daring to choose” it depends entirely on the nature of the app you are aiming for.

Diving into the world of #include <windows.h> without relying on GUI frameworks or modern languages―― That choice still remains meaningful today.

[For Beginners] Steps to Install libcurl (with OpenSSL support) in Visual Studio using vcpkg

Mon, 07 Jul 2025 21:46:08 +0900

For using libcurl (with OpenSSL support) in Visual Studio, vcpkg is easy and recommended

When you want to handle HTTP communication in C++, libcurl is often used. However, adjusting builds and dependencies can be unexpectedly troublesome, right?

In such cases, the Microsoft-made C++ library management tool “vcpkg” is very useful. This time, we will introduce the steps from introducing libcurl (with OpenSSL support) using vcpkg to making it smooth to use in Visual Studio.

Installing vcpkg (Only for those who haven’t installed it yet)

First, let’s install vcpkg. Please run the following steps in PowerShell.

1
2
3


git clone https://github.com/microsoft/vcpkg
cd vcpkg
.\bootstrap-vcpkg.bat

If Git is not installed yet, please install it from the Git official website.

Installing libcurl (with OpenSSL support)

Next, we will use vcpkg to install libcurl. To specify the 64bit version with OpenSSL support, run the following command.

1

vcpkg install curl[ssl] --triplet x64-windows

When this command is run, necessary dependencies (such as OpenSSL) are also set up automatically.

Integration settings with Visual Studio

To easily use the library introduced by vcpkg from a Visual Studio project, configure the integration setting with the following command.

1

vcpkg integrate install

By doing this setting, #include <curl/curl.h> can be automatically used in Visual Studio projects, eliminating the need to manually set up library paths and linker settings.

Conclusion

With this, the preparation to introduce libcurl (with OpenSSL support) into Visual Studio is complete.

With vcpkg, troublesome dependencies can be managed all at once.
Easily introduce libcurl with vcpkg install curl[ssl] --triplet x64-windows
Automatic integration with Visual Studio is possible with vcpkg integrate install

After this, just include the header in your project and start developing using the libcurl API. Please utilize the convenient vcpkg and dramatically increase your development efficiency.

What it Takes to Avoid Falling for Conspiracy Theories

Mon, 26 May 2025 22:23:34 +0900

“Mental Security” Needed to Avoid Being Drawn into Conspiracy Theories

When browsing the internet, you may sometimes come across “conspiracy theory”-like stories.

“Isn’t there someone operating behind the scenes of this event?” “Could the real truth be hidden?” Many of you have probably seen such narratives spread in a plausible manner.

To avoid being drawn too deeply into such information, it is very important to develop not only “knowledge” and “thinking skills” but also your state of mind—in other words, your “mental security.”

Here are six effective ways of thinking for this purpose.

Do Not Immediately Connect Anxiety with an “Answer”

A major characteristic of conspiracy theories is that they present a clear and simple “answer” to anxieties and questions.

For example, to questions like:

“Why did such an incident happen?”
“Who is benefiting from this?”

When a plot like “Actually, XX is manipulating things behind the scenes” is shown, it is easy to inadvertently be convinced.

However, especially when you feel anxious, it is important to reserve judgment and not jump to conclusions right away.

The “ability to remain in a state of not knowing” is a sign of intellectual maturity.

Intentionally Broaden Your Information Sources

Many people who fall deep into conspiracy theories tend to intensively view only “information with similar perspectives.”

This is called “confirmation bias,” a psychological bias where one is exposed only to information that reinforces one’s existing beliefs.

In particular, the algorithms of social media and video sites constantly push posts that seem to match your preferences, which can naturally narrow your perspective.

Consciously aiming for a diversification of information sources can help avoid this risk, such as:

Accessing media with different viewpoints
Viewing overseas news and academic sources
Listening to opinions that differ from your own

Do Not Think “I Won’t Be Fooled”

People who are knowledgeable or logical can actually be more susceptible to being drawn into conspiracy theories.

If you assume, “I can notice the truth that others don’t,” that becomes a factor that clouds your judgment.

No matter how careful you are, humans make mistakes. That is exactly why acting on the premise that you too might be fooled can be considered a more rational attitude.

“Doubting, yet not jumping to conclusions” becomes your defense.

Look at the Structure, Without Being Pulled by the Story

Conspiracy theories always come with a “dramatic narrative.”

The conflict between good and evil
Rulers and the ruled
The awakened self vs. the brainwashed others

Such simple dichotomies may be attractive as a story, but they do not necessarily reflect reality correctly.

Real-world events and social movements involve a tangle of many elements, such as complex causal relationships, historical backgrounds, and institutional structures.

It is important to have a perspective that understands structurally “why things are the way they are,” without getting too emotionally pulled into the story.

Do Not Leave Loneliness Unaddressed

Behind the strong attraction to conspiracy theories, there may be hidden “isolation” or a “lack of a place to belong.”

When people feel lonely, they become deeply dependent on individuals or groups that understand them. Conspiracy theory communities can sometimes function as that “place to belong.”

Therefore, making efforts not to become lonely also contributes to your mental security.

For example, actions such as:

Having regular conversations with people
Joining communities where you can share hobbies and interests
Having connections offline, not just online

can lead to mental stability.

Focus on Dialogue Rather Than Denial

Even if someone close to you leans toward conspiracy theories, denying them outright can backfire.

When their beliefs are denied, people tend to psychologically protect them (known as “defensive cognition”).

Instead, taking a dialogue-based approach can create the possibility of naturally broadening the other person’s perspective:

Asking carefully, “What made you think that?”
Gently offering your own perspective, such as “There might be this way of thinking too.”

Conclusion: What You Can Do to Keep Your Distance from Conspiracy Theories

Have the ability to suspend judgment and not immediately connect anxiety with answers
Diversify information sources and be aware of biases
Recognize that your own judgment is not absolute
Look at things through structures and causal relationships, not stories
Avoid loneliness and maintain connections
Face others’ conspiracy theories with dialogue rather than denial

It is said that whether one is attracted to conspiracy theories is influenced more by psychological states and environmental factors than by the amount of knowledge.

Therefore, without assuming “I am fine,” making a gradual effort in your daily life to enhance your mental security will surely become a great support for living flexibly in the future information society.

History of No-Code in Local Environments

Sat, 26 Apr 2025 16:46:11 +0900

History of Low-Code / No-Code Development (1980s - Present)

Low-code / no-code development is a development method that allows you to create applications, websites, and databases without specialized programming knowledge. This concept began in the 1980s and has developed into various platforms along with the spread of PCs, the evolution of the Internet, and the expansion of cloud technology. In this article, we will introduce representative tools and services by decade, along with their features and prices.

1980s: The Early Days

HyperCard (Apple, 1987) An app creation tool for Macintosh. It composed screens in a card format and allowed GUI creation via drag-and-drop. Simple behavior control was also possible with its unique scripting language, “HyperTalk.” It was favored for prototyping purposes. The price at launch was $49.95, and it was later provided free of charge to new Mac purchasers. The final version was released in 1998, with no support for Mac OS X or later.
FileMaker (Claris/Apple, 1985) Graphical database software. In addition to tabular data display, it is a relational DB tool equipped with free layout editing and scripting functions. It is currently provided as “Claris FileMaker Pro,” with a full license version priced at $594 (as of 2024).

1990s: The Rise of GUI Apps and Business Systems Development

Visual Basic (Microsoft, 1991) An IDE specialized for Windows app development. By dragging and dropping GUI components like buttons and labels, event-driven apps could be easily built. With VB6.0 in 1998 being the last, it transitioned to the .NET era.
Microsoft Access (1992) A database development tool for Windows. It enabled relational DB design and form creation via GUI, and was widely used for general business app development. It is currently provided as part of Microsoft 365.
PowerBuilder (PowerSoft/Sybase, 1991) A 4GL development tool for business applications. It supported client/server architecture and had strengths in database integration. It is currently still being provided under the SAP umbrella.
Dreamweaver (Macromedia, 1997) A WYSIWYG tool that allowed visual web page creation. It enabled switching between HTML editing and design views, and also supported ASP and PHP. It is currently provided by Adobe and available via subscription (about $34.49 per month).
Flash (Macromedia, 1996) Originally developed as FutureSplash Animator, a vector animation production tool. It was later utilized for creating interactive content for the Web, but support ended in 2020 due to security concerns.
GameMaker (1999) A 2D game creation tool for beginners. Object placement and event control are possible via drag-and-drop. It later supported scripting (GML) as well, and currently multiple plans are offered for commercial use.

2000s: The Spread of Web-Based and Open Source

WordPress (2003) An open-source CMS using PHP and MySQL. It allows the construction of blogs and corporate sites using themes and plugins without programming knowledge. Distributed for free, it is one of the most widely used CMSs in the world.
Wix (2006) A no-code service that allows you to build websites on a browser. You can choose a template and edit it via drag-and-drop. In addition to the free plan, custom domains and e-commerce features are available in paid plans.
OutSystems (2001) A low-code platform for enterprises. Because it allows rapid development of business systems, its adoption by large corporations and government agencies is progressing. It supports both cloud and on-premises environments.
Scratch (MIT, 2007) A programming learning tool developed for children. By combining colored blocks, you can create games and animations, and it is widely used in educational settings. Provided free of charge.
Airtable (2013) A cloud-based service combining spreadsheets and databases. It looks similar to Excel but enables relations, Kanban views, API integration, and more. It is widely used by everyone from individuals to corporations.

2010s-2020s: The Era of Cloud and Automation

In recent years, cloud-based low-code / no-code tools have evolved rapidly.

Power Platform (Microsoft) An integrated business app development and automation platform including “Power Apps” and “Power Automate.” It allows you to visually construct corporate business processes via drag-and-drop.
Salesforce Lightning Platform An app development platform provided by the CRM Salesforce. Business apps can be created via GUI, and integration with other Salesforce services is easy.
Zapier / IFTTT Automation tools that allow integration between multiple cloud services without coding. For example, workflows like “Notify Slack when Google Forms is submitted” can be easily realized.
Notion (2010s) An all-in-one workspace integrating document management, task management, Wiki, etc. It also has a custom database feature, which is useful for business improvement without coding.
Construct 3 / GameSalad Tools that allow you to make games via drag-and-drop. Construct 3 is HTML5 compatible and works on browsers as well, making it popular in educational settings and among indie developers.

Information Sources and Supplementary Details

This article is composed based on the official websites of each product, Wikipedia, and highly reliable materials and articles (Apple, Microsoft, Adobe, etc.). Price information refers to official information from the time or the latest available, as much as possible (prices listed are mainly in US dollars). Many of the tools since the 2000s are subscription-based, and fees vary by plan.

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

What exactly is FizzBuzz, anyway?

Hello!

Today, I’d like to write about “FizzBuzz”.

Whether you’re thinking, “Ah, I know that one!” or “I’ve heard of it, but don’t really get it,” please stick with me for a bit. It takes just a few minutes to read, and you might just have an “aha” moment.

Is it true that “you’re disqualified as a programmer if you can’t write FizzBuzz”?

Roughly speaking, FizzBuzz looks like this.

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

Yes, this is the famous “FizzBuzz problem.”

You go through the numbers from 1 to 100 in order,
if it’s a multiple of 3, print “Fizz”, if it’s a multiple of 5, print “Buzz”,
and if it’s a multiple of both, print “FizzBuzz.” It’s extremely simple.

And yet, for some reason, it’s often treated like a “minimum test for programmers.” It comes up in interviews, and on social media you’ll occasionally see people flexing with comments like, “If you can’t even write FizzBuzz…”

But wait a minute.

Can we really definitively say, “Couldn’t write FizzBuzz = can’t program”?

It’s not about whether you can do it, but whether you’re in a “state” to do it

It’s true that FizzBuzz requires an understanding of syntax and basic logical thinking. So it makes sense that it’s used to “check the basics.”

But, hear me out.

If the environment is different, the results will be different.

For example,

When you’re nervous in front of an interviewer you’ve just met
When you’re suddenly handed a whiteboard and don’t have an editor at hand
When you suddenly draw a blank and think, “Wait, what’s modulo again?”

…Doesn’t that happen? We’re human, after all. I think it does.

Therefore, rather than “whether you can write FizzBuzz,” I think what’s actually more important is “whether you can get yourself into a state where you can write FizzBuzz.”

The pitfall of the common advice to “just train and you’ll be fine”

When this topic comes up, the advice “so practice every day!” tends to appear.

It’s true that repeated practice will enable you to write it smoothly, and that in itself is a good thing. But if you stand on the premise that “you’re disqualified if you can’t write FizzBuzz,” it can turn into pure fear.

In other words, it tends to create a structure where you feel, “I made a mistake = I’m useless.”

For example, on days when you oversleep, don’t you tend to think, “I’m lazy…”? But it might just be that your body was accidentally tired.

The same goes for FizzBuzz.

That being said, FizzBuzz is still a good question

That being said, there’s nothing wrong with FizzBuzz.

Rather, I think it’s a very well-made question. The rules are simple, and it’s easy to expand. For example, if you change it like this, it deepens your thinking even more.

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

This is an example showing that “you don’t have to use if-elif-else to write it.” It’s a bit smart, isn’t it?

In other words, FizzBuzz doesn’t just show “whether you could do it,” but also serves as an entry point to see “how you write it” and “how deeply you understand it.”

In conclusion

I don’t think you need to attach excessive meaning to whether you can do FizzBuzz or not.

Even if you couldn’t write it, it might simply mean “you were just a little off your game,” and often you can do it if you think about it carefully later.

Let’s not rush and proceed slowly.

Code is written by humans. Because we’re human, there are times when we forget things or get nervous. I think it’s enough if we can accept that and move forward little by little.

Well then, let’s take it easy and write some code today too.

Tower of Hanoi

Thu, 17 Apr 2025 22:23:14 +0900

Tower of Hanoi

Hello!

Today, I would like to explain the “Tower of Hanoi” along with a Python sample program.

What is the Tower of Hanoi?

The Tower of Hanoi is a puzzle using three rods and multiple disks. The disks vary in size and are initially stacked on one rod in decreasing order of size. The rules are as follows:

Only one disk can be moved at a time.
A larger disk cannot be placed on top of a smaller disk.

This puzzle is considered an excellent teaching material for learning recursive thinking. Recursion is a method of solving a problem by breaking it down into smaller problems of the same type. In the Tower of Hanoi, to move n disks, the operation of moving n-1 disks is repeated.

Let’s Solve the Tower of Hanoi in Python

Below is a sample code to solve the Tower of Hanoi in Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def hanoi(n, source, target, auxiliary):
 if n == 1:
 print(f"Move disk 1 from {source} to {target}")
 return
 hanoi(n - 1, source, auxiliary, target)
 print(f"Move disk {n} from {source} to {target}")
 hanoi(n - 1, auxiliary, target, source)

# Example: Move 3 disks from A to C
hanoi(3, 'A', 'C', 'B')

In this code, the hanoi function is called recursively, and the steps to move the disks are printed. For example, in the case of 3 disks, you will get the following output:

1
2
3
4
5
6
7


Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

In this way, by using a recursive approach, even complex problems can be solved simply.

How Long Does It Take to Move 64 Disks?

The minimum number of moves for the Tower of Hanoi is 2^n - 1. This means that to move 64 disks, it requires 2^64 - 1 moves, or approximately 1.84 × 10^19 moves. Even if you could make one move per second, it would take about 584.9 billion years. This is roughly 42 times the age of the universe (about 13.7 billion years).

Thus, as the number of disks increases, the required number of moves increases exponentially. Therefore, it is not realistic to actually move 64 disks.

Conclusion

The Tower of Hanoi is a perfect puzzle for learning recursive thinking. Using Python, you can easily implement its solution. However, care must be taken as the required number of moves increases sharply as the number of disks increases.

By understanding the recursive approach and actually writing the code, you can improve your programming skills. By all means, give the Tower of Hanoi a try.

Number of Lines of Source Code

Thu, 17 Apr 2025 10:33:02 +0900

Number of Lines of Source Code

Hello!

Today, I would like to talk about a slightly unusual theme.

It’s about “How much has the number of lines of source code increased compared to the past?”

For example, the space shuttle’s software consisted of about 420,000 lines of code. This code was developed with very strict processes to meet NASA’s high quality standards. On the other hand, in modern large-scale software projects, it is not uncommon for the number of lines of code to exceed tens of millions. For instance, Google’s codebase is said to reach about 2 billion lines.

In this way, the scale of software has grown along with the times.

But, wait a minute.

An increase in the number of lines of code is not necessarily a bad thing. In order to add new features or meet user needs, it is natural for code to increase. However, as the code increases, the risk of bugs also rises. In fact, a study shows that when open source projects exceed 1 million lines, the incidence of bugs tends to increase.

That being said, not all projects are increasing code in the same way.

For example, the Linux kernel had about 200,000 lines in version 1.0 in 1994, but increased to about 20 million lines in version 4.2 in 2015. This increase is to accommodate the evolution of hardware and the addition of new features.

So, the number of lines of source code varies greatly depending on the scale and purpose of the project, as well as the historical context.

The increase in lines of code itself is not a problem, but appropriate management is necessary to maintain quality and maintainability. It is important to understand the risks associated with the increase in code and take appropriate measures.

Finally, I think it’s important not to get too caught up in the number of lines of code, but to focus on the purpose and quality of the project.

Well then, see you next time!

Kerckhoffs's Principle

Wed, 16 Apr 2025 23:53:08 +0900

Kerckhoffs’s Principle

Hello!

Today, I’d like to talk about something a bit interesting and actually incredibly important called “Kerckhoffs’s Principle”.

Ah, wait, wait. Some of you might be thinking, “I’ve never heard of ‘Kerckhoffs’s Principle,’ and there are already too many katakana words…” Don’t worry. This article is exactly for you.

What does “Secure Cryptography” mean?

For example, imagine someone telling you, “This safe can only be opened by someone who knows the secret way to open it.”

At first glance, that sounds very secure, right? But if you think about it closely, isn’t it a bit unsettling?

Like, “If that secret leaks, isn’t it all over?”

Actually, this is exactly why Kerckhoffs’s Principle comes into play.

What exactly is “Kerckhoffs’s Principle”?

To put it very simply, it’s the idea that:

“A cryptographic system should be secure even if its inner workings become public knowledge.”

In other words, “Security should rely solely on the ‘secret key’, and it’s perfectly fine for the encryption method itself to be public!”

Conversely, “A system that only relies on keeping the cryptographic algorithm (mechanism) a secret is considered to have low reliability.”

“It’s safe because the mechanism is a secret” might be a bit dangerous

A common line of thought goes like this:

“Nobody has seen the inside of this app, so the security is fine.”

I understand the sentiment. But that’s basically the same as saying, “Nobody is looking, so nobody will find any flaws, so it must be fine.”

In reality, the very fact that “nobody is looking” can become a risk in itself.

But why is this principle so important?

The reason is, if someone manages to get their hands on the mechanism and can easily decrypt it, that encryption is compromised.

To use an analogy, it’s like a door lock built with a super complex mechanism, but which can actually be opened with a spare key made at a dollar store.

It’s not “It’s safe because the key is secret”, but rather “Even if you show the entire mechanism, it can’t be opened without the proper key” that is important.

The feeling of “But isn’t that kinda scary?”

This is where many people feel:

“Isn’t it kind of scary to expose the whole mechanism?”

I get it. You can’t help but think, “If I show everything inside, won’t it be copied or misused?”

But that is exactly the core of Kerckhoffs’s Principle. The true security is the “strength that doesn’t collapse even if you show the inside”.

That being said, it takes a little courage at first

Putting yourself in the shoes of a developer, “Making the mechanism public = exposing weaknesses”, so of course, it’s nerve-wracking.

But think about it.

Something that says “Anyone is welcome to verify it” while properly showing the mechanism will ultimately be trusted more.

It’s a lot like human relationships, isn’t it?

“Someone who gets along with you after you’ve shown your true self” is, after all, the most comforting.

So

Kerckhoffs’s Principle might sound a bit theoretical, but its essence is very simple.

It’s just about: “Let’s build a mechanism that won’t break no matter who sees it.”

Proper design over superficial secrets. Code you aren’t ashamed to show, rather than code you want to hide from everyone.

Perhaps this kind of “strength” is what will be increasingly sought after in the coming era.

Thank you for reading!

Security topics can be a bit difficult, but there are parts that connect to “human relationships” and a “sense of everyday security.” Without feeling pressured, learning about it little by little will surely bring something good.

Steps to Execute PowerShell from C++ via C++/CLI DLL

Wed, 16 Apr 2025 01:58:03 +0900

🎯 Steps to Execute PowerShell from C++ via C++/CLI DLL (Visual Studio 2022 / C++)

✅ Overall Structure

🔹 ① CLI Wrapper DLL (C++/CLI)

Provides functionality to execute PowerShell scripts.

🔹 ② Native C++ Caller

Calls the CLI DLL to execute PowerShell scripts.

🔧 Step 1: Create CLI Wrapper DLL Project

1. Create Project

[Create a new project] → [C++] → CLR Class Library (.NET Framework)
Name: PowerShellWrapper

💡 If this template is not displayed, install the “.NET desktop development” workload.

2. Add NuGet Package

Right-click the project → [Manage NuGet Packages]
Search and install System.Management.Automation
(Version 5.x or 7.x)

3. Implement CLI Side Code

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 Step 2: Call from Native C++

1. Create C++ Console App Project

Name: NativeApp

2. Add Reference

Right-click the project → [Add] → [Reference] → [Projects] → Add PowerShellWrapper
[Configuration Properties] → [C/C++] → [Common Language Runtime Support] → Change to /clr

3. Execution Code (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 Note (IDL / TLB / COM Registration)

Since this configuration references the .NET DLL directly instead of using COM, IDL, TLB, and COM registration are not required.

✅ Final Structure

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → Call DLL

Command to check Windows license status

Mon, 14 Apr 2025 00:41:45 +0900

[Windows] How to check license status (just one command)

Have you ever wondered if your Windows license is correctly activated?

A very convenient method is to check your license information with a single command. By following the steps below, you can easily check your current license status.

Command to check license status

You can display license information using a script tool built into Windows. Here is the command to use:

1

slmgr /dli

When you run this command, partial license information will be displayed in a window.

How to run

Type “cmd” in the Start Menu, right-click on Command Prompt, and select “Run as administrator”.
Enter the following into the command prompt and press the Enter key:
1

slmgr /dli
After waiting a few seconds, license information like the following will be displayed.

Main information displayed

Part of the product key
License type (Retail, OEM, etc.)
License status (Licensed, expired, not activated, etc.)

Want to know more detailed information?

There are also commands like the following:

slmgr /dlv: Display more detailed license information
slmgr /xpr: Display the license expiration date (e.g., whether it is permanent)

Summary

You can easily check the Windows license status with a single command.

Simple check: slmgr /dli
Detailed check: slmgr /dlv
Expiration date check: slmgr /xpr

If there is a problem with your license, updates or some functions may be restricted, so it is safe to check regularly.

ffmpeg Parameters for iOS

Sun, 02 Mar 2025 04:16:07 +0900

ffmpeg Conversion Parameters Optimized for iOS

Here is an ffmpeg command to convert videos so they can be played smoothly on iOS devices (iPhone and iPad).

1
2
3
4
5
6


ffmpeg -i input.mp4 \
-c:v libx264 -profile:v high -level 4.1 \
-vf "scale=1920:-2" -r 30 \
-crf 20 -preset slow \
-c:a aac -b:a 128k -ar 48000 \
-movflags +faststart output.mp4

Meaning of Each Option (Brief Explanation)

Option	Description
`-i input.mp4`	Input file (source video to be converted)
`-c:v libx264`	Encode video with H.264 (iOS compatible)
`-profile:v high -level 4.1`	Widely compatible profile and level for iOS
`-vf "scale=1920:-2"`	Resize width to 1920px, auto-adjust height maintaining aspect ratio
`-r 30`	Convert to 30fps frame rate
`-crf 20`	Video quality (lower value means higher quality, recommended 18-23)
`-preset slow`	Balance between encode speed and compression ratio (slow means high compression/high quality)
`-c:a aac`	Encode audio in AAC format
`-b:a 128k`	Set audio bitrate to 128kbps
`-ar 48000`	Set audio sampling rate to 48kHz (recommended for iOS)
`-movflags +faststart`	Places the index at the beginning of the video, speeding up streaming playback on Web and iOS

Videos converted with these settings can be expected to have high compatibility and smooth playback on Apple devices such as iPhones and iPads.

You can adjust file size and image quality by changing the resolution and bitrate as needed. Try setting -crf to around 18 if you need high quality, or 22-25 if you want to reduce the file size.

Android (Google Pixel) Device Software Restoration (Initialization and Repair) Procedure

Fri, 28 Feb 2025 01:20:41 +0900

Android (Google Pixel) Device Restoration Procedure

If your Google Pixel device experiences severe system issues such as “repeatedly restarting (boot loop),” “stuck on the logo screen,” or “extremely unstable operation,” you can safely repair (restore) the device’s software via a browser using the official “Pixel Update and Software Repair” tool provided by Google.

This article details the specific steps and precautions for this process.

1. Access the Restoration Tool

First, from a browser (Google Chrome or Microsoft Edge recommended) on your PC (Windows or Mac), access the official repair tool page below.

🔗 Pixel Update and Software Repair Official Site

※ Note ※ Executing the restoration process may completely erase (initialize) the data on your device (photos, apps, contacts, etc.). If the device is still operable, be sure to back up your data to Google Drive or elsewhere beforehand.

2. Preparations for Restoration

To ensure the process goes smoothly, make the following preparations:

Charge the Battery If the power turns off midway, the device could be bricked (completely broken). Charge it to at least 50%, or preferably fully charged.
Prepare a Genuine USB Cable To ensure stable data transfer, it is strongly recommended to use the genuine USB-C cable included with the device.
Install Drivers (If Necessary) When using a Windows PC, the device may not be recognized correctly. In that case, please install the Google USB Driver.

3. Specific Restoration Steps

Once preparations are complete, follow the on-screen instructions to proceed with the restoration.

Step 1: Select Carrier and Connect the Device

When you open the site, a screen to select your telecommunications carrier will appear. If you have a SIM-free version or are not tied to a carrier, select “Other”. Then, connect your PC and Pixel device using a USB cable.

Step 2: Put the Device into “Rescue Mode (Fastboot Mode)”

Following the on-screen instructions, from a powered-off state, press and hold the “Power button” and “Volume Down button” simultaneously to launch Fastboot mode (a screen with an Android mascot lying down on a black background).

Step 3: Recognize the Device on the PC

Click the “Connect your phone” button on the browser, and a pop-up will open listing the connected Pixel devices. Select the target device and allow the connection.

Step 4: Download and Install Software

Once the device is recognized, the optimal version of the Android OS (firmware) will automatically be selected. When you click “Install”, the software will be downloaded to your PC, and it will begin writing (flashing) to the device.

⚠️ Warning: During this process, ** absolutely do not unplug the USB cable or turn off the PC.**

Step 5: Completion and Initial Setup

The restoration is successful when the progress bar reaches 100% and a completion message is displayed. The device will automatically restart and display the same initial setup screen (“Hello” screen) as when it was purchased.

Summary

The official Google Pixel repair tool is an extremely excellent tool that allows you to safely reflash the firmware with just a few clicks in the browser, without needing to directly run special commands (like adb or fastboot).

Before taking a malfunctioning device to a repair shop, trying this procedure once might easily solve the problem. Please use this as a reference.

Send Gmail from curl

Thu, 27 Feb 2025 02:13:31 +0900

Send Gmail from curl

1. Get an App Password

https://myaccount.google.com/apppasswords Click the link above and enter an app name. Save the generated password.

2. Send an email with the curl command

Run the following command.

In the example below, the email content is written in mail.txt.

1
2
3
4
5
6


From: from@gmail.com
To: to@gmail.com
Subject: Test Email
Content-Type: text/plain; charset="UTF-8"

This is a test email.

Create the above file and run the following command.

1

curl --url "smtps://smtp.gmail.com:465" --ssl-reqd --mail-from "from@gmail.com" --mail-rcpt "to@gmail.com" --user "from@gmail.com:xxxxxxxxxxxxxxxx" --upload-file mail.txt

Replace xxxxxxxxxxxxxxxx with your app password.

Python Code Snippets

Mon, 24 Feb 2025 18:21:14 +0900

Introduction of sample code using standard libraries.

Download and display an image

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


import urllib.request
import tempfile
import os
import webbrowser
import time

url = "https://www.aomori-ringo.or.jp/kids/wp-content/uploads/2021/11/apple.png"

try:
 with urllib.request.urlopen(url) as response:
 img_data = response.read()

 # Save to a temporary file and display
 with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
 tmp.write(img_data)
 print(f"file://{tmp.name}")
 webbrowser.open(f"file://{tmp.name}")
 time.sleep(3)
except Exception as e:
 print(f"An error occurred: {e}")

finally:
 if 'tmp' in locals():
 os.unlink(tmp.name) # Delete temporary file

Call ChatGPT API from curl

Sat, 01 Feb 2025 17:15:34 +0900

Call ChatGPT API from curl

This assumes calling from the Windows Command Prompt.

1
2

curl https://api.openai.com/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer sk-proj-XXXXXXXXXXXXXXXXXXXX" -d "{""model"": ""gpt-3.5-turbo"",""messages"": [{""role"": ""system"", ""content"": ""Please answer in Kansai dialect.""}, {""role"": ""user"", ""content"": ""Insert the message you want to send here""}]}"

High Dividend Yield Stocks Summary

Sun, 22 Dec 2024 00:56:14 +0900

High Dividend Yield Stocks Summary

Mitsubishi UFJ Financial Group (8306)
Sumitomo Mitsui Financial Group (8316)
Mitsubishi Corporation (8058)
Itochu Corporation (8001)
NTT (9432)
KDDI (9433)
Okinawa Cellular Telephone (9436)
Tokio Marine Holdings (8766)
Toyota Motor (7203)
Yamaha Motor (7272)
Asahi Group Holdings (2502)
Kirin Holdings (2503)
JT (2914)
Bridgestone (5108)
Daiwa House Industry (1925)
Sekisui House (1928)
Kyocera (6971)
Shin-Etsu Chemical (4063)
Nitto Denko (6988)
ORIX (8591)
Mitsubishi HC Capital (8593)
Hulic (3003)

Goals

Sun, 08 Dec 2024 03:32:34 +0900

Long-term Goals

1 year from now
- Start a business
- Create a website and release software (free)
2 years from now
- Annual sales of 10 million yen
- Publish a book
- Release software (paid)
3 years from now
- Annual sales of 100 million yen
5 years from now
- Annual sales of 1 billion yen
10 years from now
- Annual sales of 10 billion yen

Short-term Goals

1 month from now
- Create a business plan
3 months from now
- Raise about 5 million yen in funding to start the business
6 months from now
- Start the business
1 year from now
- Get the business on track

Immediate Tasks

Clarification of Goals and Vision
Purpose: Why create the software? Example: Solve a problem, provide new value, target a specific niche market, etc. Vision: What kind of future do you want to realize through the software? Example: Improve business efficiency, make daily life more comfortable, improve the quality of education, etc.
Market Research and Needs Analysis
Target User: Who will use the software? Specify age group, occupation, interests, etc. Competitor Analysis: Are there competitors in the same field? Analyze their strengths and weaknesses. Identifying Needs: Understand the unresolved problems and demands of the target users.
Software Design and Features
Basic Features: List essential features. Example: User authentication, data storage, analysis functions, etc. Differentiation Points: Clarify unique points compared to other companies’ products. Example: Simple UI, utilization of AI, high customizability. Technical Specifications: Programming languages, frameworks, databases to be used, etc.
Development Plan and Resource Allocation
Development Schedule: Set a timeline for each stage of the project. Example: Prototype development, testing, official release. Team Composition: Required personnel and skill sets (programmers, designers, marketing staff, etc.). Budget: Estimate development costs, marketing costs, and operating costs.
Marketing and Revenue Model
Promotion Methods: Utilize SNS, websites, advertisements, etc. to improve awareness. Monetization Strategy: Consider options such as a free version + paid version, monthly subscription, advertising revenue, etc. User Acquisition Strategy: Providing free trials, promoting word of mouth, forming user communities, etc.
Operations and Scaling
Post-release Operations: Collecting feedback from users, fixing bugs, adding features. Growth Strategy: Plan how to increase the number of users, expand to other countries, and develop new features. Risk Management: Prepare countermeasures for legal issues and technical troubles.

About

Sat, 07 Dec 2024 00:00:00 +0000

What is this blog about?

Hello!

Today, I’d like to talk about a somewhat simple but frequently asked question: “What is this blog about?”

As is often the case, blogs are often thought of as “a place to broadcast specialized information”. For example, “If it’s a technical blog, you should just write about technology matter-of-factly,” or “Diaries are diaries, work talk is work talk,” and they should be separated.

But if you draw the line too much like that, doesn’t it feel a bit stifling for both the writer and the reader?

On this blog, technical topics are indeed the main focus. Programming, little discoveries around development, and so on. I think people who like those kinds of topics will enjoy it.

However, that’s not all.

I also occasionally write about little realizations from daily life and my hobbies. For example, things I pondered while taking a walk, or a manga I read recently. Those kinds of things are surprisingly interesting because they might actually be helpful to someone.

Some of you might think, “Is it okay to talk about unrelated things on a tech blog?” But that’s exactly the point.

I believe that work, hobbies, and daily worries are all connected. Therefore, I write this blog within that kind of “connection” and “flow”.

So, if you have any questions or anything on your mind, please feel free to leave a comment. Your thoughts or even just brief impressions are very welcome.

I hope this blog can be a place for such relaxed communication.

Leather Product Maintenance

Wed, 30 Oct 2024 00:31:46 +0900

Recently, I have become interested in leather products and have been purchasing various items. Along with this, I’ve developed an interest in the maintenance of leather products and have gathered some related items, which I would like to introduce.

Recently Purchased Leather Product Maintenance Items

M.MOWBRAY DELICATE CREAM

Price: Around 1,320 yen

This cream provides nourishment, moisture, and flexibility. It doesn’t add gloss, but it is suitable for leather that requires a lot of moisture and hydration. It doesn’t have an unpleasant smell, but it does have a slight scent. Since it’s colorless, I think it’s highly versatile. Because it’s a light and smooth cream, it might be good to use a bit more of it compared to other creams.

Collonil 1909 Supreme Creme de Luxe

Price: Around 1,777 yen

This is a famous, standard, and all-purpose cream that is less likely to cause stains. It is a moisturizing cream that restores the color of the leather. It gives a slight gloss. It is white and seems to also offer water-repellent effects.

M.MOWBRAY SHOE CREAM (Black)

Price: Around 1,000 yen

A cream for shoes. It contains wax, oils, and organic solvents. It restores the color of the leather and adds gloss. Since it’s black, apply it to black leather. I use it for my suit shoes.

M.MOWBRAY STAIN REMOVER

Price: Around 700 yen

This came with a brush I bought. A water-based cleaner for shoes. It removes dirt from leather. Soak a cloth generously with it and gently rub the leather to remove the dirt.

Hanlon's Razor

Tue, 24 Sep 2024 18:14:34 +0900

Hello! Today’s story is about “Hanlon’s Razor”

Today, I’d like to write about a concept with a slightly unusual name: “Hanlon’s Razor.” When you hear the name, you might think, “Sounds kind of scary…?” but it’s actually an idea that’s very relatable and gives us a gentle perspective.

Have you ever thought, “That person might hate me…”?

For example, have you ever experienced something like this?

Slow replies on LINE
Made eye contact but wasn’t greeted
Ignored when you asked for a favor

At times like that, you get anxious and think, “Could they dislike me?” I often feel that way too. And I get depressed all on my own.

What is Hanlon’s Razor?

That’s where “Hanlon’s Razor” comes in.

This phrase is originally “Hanlon’s Razor” in English. The meaning is roughly like this:

“Never attribute to malice that which is adequately explained by stupidity.”

…The wording is a bit harsh, isn’t it? To put it a little more softly:

“Even if someone seems to be acting mean, it might just be carelessness or inattention.”

It’s a way of thinking like this.

Who said it first? Who is Robert J. Hanlon?

This phrase is said to have first appeared in a book published in 1980 called “Murphy’s Law Book Two.”

The idea submitted by Robert J. Hanlon, one of the contributors, was used exactly as is, which is how it got the name “Hanlon’s Razor.”

By the way, the “Razor” part means like a philosophical tool to “shave off the unnecessary and think simply,” and alongside Ockham’s Razor, it’s a phrase used to organize one’s thoughts.

It gets exhausting when you assume “They meant harm”

For example, when your email is ignored at work.

If you think, “Why won’t they reply? Do they hate me?”, you just get more and more negative.

But if you really think about it,

They just happened to overlook it
They wrote a reply but didn’t send it
Their smartphone notifications got buried

Reasons like these are surprisingly common. And we often mess up ourselves.

The weird thing about being forgiving of your own mistakes but strict with others

For example, when you forget to reply to a friend’s LINE.

You might reply with a totally innocent vibe like, “Ah, sorry! I missed the notification~”.

But when someone does the same thing to you, you think, “I was ignored.”

This happens a lot. People are very understanding of their own circumstances, but it’s hard to see other people’s circumstances.

Assuming “malice” is actually a loss

When someone does something to you, if you assume “they meant harm,” you make an enemy out of that person in your heart.

But they might just be clumsy, or maybe they’re just overwhelmed with other things.

Of course, there are truly rude people, and it’s natural to be hurt when treated poorly.

But your heart will feel a little lighter if you don’t jump to the conclusion that “it must be malicious.”

That being said, I’m not saying you should just put up with everything

Please don’t misunderstand here; I don’t mean to say “You’re just worrying too much about everything.”

When something unpleasant is done to you, it’s okay to think, “That was terrible.”

However, rather than deciding “That person has a bad personality” or “They tried to hurt me on purpose,”

I’m suggesting that it might be nice to have the leeway to think, “Maybe they had their own reasons.”

So: Looking at things a little more gently might change your world

I think Hanlon’s Razor is less about “Let’s be kind to people” and more about a “Way to protect your own heart.”

When you sense malice in people’s actions, your own feelings get strained too.

But if you can think, “Maybe it was just a mistake, or they just didn’t have the capacity,” you feel a little more at ease.

It’s a way of thinking you can use for yourself in that way.

Finally: Please tell me about your experiences too

Thank you for reading.

If you have any stories where you felt “I felt frustrated at a time like this~”, please let me know.

Sometimes just putting your own experiences into words can make your heart feel a little clearer.

See you again!

Basic Knowledge of Computers

Thu, 19 Sep 2024 01:10:20 +0900

Basic Knowledge of Computers

This page explains what a computer is.

Definition of a Computer

A computer is a machine that has the following five units:

Input unit
Output unit
Storage unit
Control unit
Arithmetic logic unit

Roughly speaking, a computer is a machine that performs a specific process on a certain input and outputs the result. It can store, calculate, and output the input data. Control has the role of controlling the aforementioned four units.

What is needed to operate a computer

To operate a computer, programs (software) are needed in addition to the devices (hardware).

Programs instruct the computer on what kind of processing to perform. Programs are written in a format that the computer can understand.

An example of a program is as follows. A program that calculates the sum from 1 to an input integer:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
using namespace std;

int main() {
 // Secure necessary storage area
 int n, sum = 0;

 // Output
 cout << "Please enter an integer: ";

 // Input
 cin >> n;

 // Calculation
 for (int i = 1; i <= n; i++) { // Calculation
 sum += i;
 }

 // Output
 cout << "The sum from 1 to " << n << " is " << sum << "." << endl;

 // Exit
 return 0;
}

The program is converted into machine code by a compiler, transforming it into a format that the computer can execute.

Recommended iOS Apps

Wed, 18 Sep 2024 23:31:20 +0900

Recommended iOS Apps

X

Instagram

facebook

youtube

TikTok

Microsoft Edge

Firefox

Google Chrome

ChatGPT

LINE

Microsoft Teams

Notion

Goodnotes 6

TeamViewer

DropBox

GitHub

Amazon

PayPay

WolframAlpha

Mercari

The Story of the Old Couple and the Donkey

Wed, 18 Sep 2024 00:56:59 +0900

The Old Couple, the Donkey, and Our Problem of “Whose Voice to Listen To”

Hello!

Today, I wanted to write about something I thought about from “The Story of the Old Couple and the Donkey.”

I’m sure many of you have heard of it. It’s that famous fable.

What is “The Story of the Old Couple and the Donkey”?

Once upon a time, there was an old couple and a donkey.

At first, the old man rode the donkey, and the old woman walked. Then, a passerby said,

“What a man, letting his old wife walk while he rides!”

Hearing this, the old couple decided that the old woman would ride the donkey instead. Then, another person said,

“It’s outrageous for a woman to ride the donkey and make the man walk!”

Well then, they decided they would both ride the donkey. Then again, someone said,

“Poor donkey, it’s too heavy carrying two people!”

If that’s the case, they both got off the donkey and started walking. Then this time…

“Why is no one riding the donkey when you have one?”

Ultimately, the old couple was at a loss.

“Listen to everyone’s opinion” is certainly a valid argument. But…

This story is often taken as a moral lesson like, “Oh, there’s no end to it if you keep worrying about what others think.”

But reality isn’t that simple, is it?

There are often people who say, “Don’t care about what others think!”

But it’s a bit difficult to ignore everything completely. For example, when posting something on social media. When thinking about what to say at a company drinking party. You inevitably care about someone’s reaction.

Because “other people’s opinions” sometimes affect our safety and evaluation.

That being said, being swayed too much becomes painful

The old couple in this story probably just wondered “What should we do?” at first.

But no matter what, “someone” will complain.

And as you start going in circles saying, “Then let’s do this next,” “Maybe it’s this?”, you lose sight of what you want to do.

This is a common occurrence in our daily lives as well.

The expectations of bosses, the words of parents, the number of “likes” on social media. Have you ever lost track of what you really want to do while adapting to them?

It’s important to choose “whose voice to listen to”

So, what should we do? There is no correct answer.

However, “following everyone’s opinion” is realistically impossible.

That’s why I think it’s important to choose “whose voice to listen to” for yourself.

For example, “Listen only to the advice of people you respect” or “Use whether your past self would agree as a standard.”

Having even just one standard that you “want to believe in” will reduce the noise of the world a little bit.

So, when you are a little tired

It might be good to remember the story of “The Old Couple and the Donkey.”

We tend to worry about what others think, don’t we?

But if you try to respond to everything, you’ll end up getting off the donkey too.

Sometimes, if you can think, “Maybe it’s okay to prioritize my own feelings.” Your heart might feel just a little bit lighter.

Why Making the Blue LED Was Almost Impossible

Sun, 15 Sep 2024 00:43:52 +0900

Why Making the Blue LED Was Almost Impossible

An introduction to an English documentary program. It is very interesting. I have a strong impression that the Japanese who solved such a highly difficult problem were not well-appreciated within Japan at first.

Trying Out the Qt Extension Pack in Visual Studio Code

Fri, 13 Sep 2024 00:53:53 +0900

Getting Started with Qt Development in VSCode: How to Install the Qt Extension Pack

Hello, Kenji here. This time, I’ll introduce “how to set up a Qt development environment in Visual Studio Code (hereafter VSCode)”.

Recently, there has been an increasing demand for developing Qt applications using the lightweight and highly extensible VSCode, in addition to the official Qt Creator. For those people, I recommend the “Qt Extension Pack”. Simply by installing this extension pack, you can get the main Qt-related extensions all at once.

Target Audience

Those who want to start GUI application development using Qt
Those who want to develop in VSCode instead of Qt Creator
Those who find it troublesome to search for extensions one by one

Prerequisites

VSCode must be installed (You can download it for free from the official website)
The main Qt library must be installed (Qt Official Website)

What is the Qt Extension Pack?

The Qt Extension Pack is an extension pack for VSCode. By installing it, the following features are automatically added:

Support for .ui files (Qt Designer)
Syntax highlighting for .pro and .qrc files
C++ code completion, building, and debugging assistance for Qt
Qt Resource Browser

Installation Steps

1. Open VSCode

First, launch VSCode.

2. Open the Extensions View

Click the Activity Bar (square block icon) on the left side to show “Extensions”.

Alternatively, you can press the shortcut Ctrl + Shift + X.

3. Search for “Qt Extension Pack”

Enter the following keyword in the search bar:

1

Qt Extension Pack

4. Click the Install Button

When the target pack is displayed, click the “Install” button. This will install multiple extensions at once, such as the following:

Qt Language Support
QML Support
Qt Designer Integration
CMake Tools (Essential for CMake-based Qt development)

Supplementary Project Settings (CMake + Qt Example)

If you use Qt with CMake, the combination with the following extensions is recommended:

Also, if you put the following description in your CMakeLists.txt, integration with Qt will be smooth:

1
2


find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(MyApp PRIVATE Qt6::Widgets)

Bonus: How to open .ui files?

.ui files can be edited in Qt Designer. In VSCode, you can right-click a .ui file → select Open with Qt Designer (requires Qt Designer to be included in the PATH environment variable).

Summary

Step	Content
1	Launch VSCode
2	Open the Extensions Panel
3	Search for “Qt Extension Pack”
4	Click the Install button

Setting up a Qt environment in VSCode is now much easier than before. It has sufficient features as a substitute for Qt Creator, and is recommended for those who want to work nimbly.

Finally

From now on, I plan to proceed with development utilizing Qt UI tools and QML in this environment. Next time, I plan to explain how to build & run a Qt Hello World app from VSCode.

See you next time!

How to Check if Your iPhone is SIM Locked

Thu, 12 Sep 2024 00:32:11 +0900

How to Check if Your iPhone is SIM Locked

Home Screen > Settings > General > About > Carrier Lock

Check whether it says No SIM restrictions or SIM locked.

P≠NP Conjecture

Wed, 11 Sep 2024 02:22:39 +0900

Overview

1

Class P is the class of problems that are decidable in polynomial time by a deterministic Turing machine. Class NP is the class of problems for which the correctness of a witness (evidence that the answer is Yes) can be verified in polynomial time when given the witness. Since problems decidable in polynomial time are also verifiable in polynomial time, it is obvious that P ⊆ NP. However, it is not clear whether P is a proper subset of NP. Although there is no proof yet, many researchers believe that P ≠ NP. This conjecture that class P and class NP are not equal is known as the "P ≠ NP conjecture".

Reference site : https://daigakudenki.com/np-hard/

Awarded Microsoft MVP (2024-2025) Again

Tue, 03 Sep 2024 21:25:20 +0900

Awarded Microsoft MVP (2024-2025) Again

Hello, this is kenji. I’m pleased to announce that I have been awarded the Microsoft MVP (Most Valuable Professional) again this year. This is my 8th time receiving the award.

Since I have the opportunity, I’d like to write a little bit about what the MVP is.

What is Microsoft MVP?

Even though it says MVP, it is not about the most valuable player in sports (I get asked this occasionally…). Microsoft MVP (Most Valuable Professional) is an award given to individuals who actively share and disseminate their knowledge and experience regarding Microsoft technologies to the community.

Writing technical blogs, answering questions on Q&A sites, publishing sample codes, or speaking at events. “Sharing what you know in a way that helps someone else” – such steady activities are evaluated.

There are awardees all over the world, but the number is limited every year, and it is not easy to be re-awarded. Under such circumstances, I am truly grateful to have been recognized again.

Reasons for the Award

This time, I was re-awarded in the “Developer Technologies” category. Over the past year, I have been doing activities like this:

Writing blog posts about Microsoft-related technologies
Posting answers on technical Q&A sites
Publishing sample codes on GitHub
Speaking at study groups and technical events, etc.

None of these are extraordinary, but I have been conscious of disseminating information by turning “things I tried that worked” or “things I stumbled on but managed to solve” into a form that is even slightly useful.

I am genuinely happy that it has taken shape in this way.

Looking Ahead

The world of technology moves incredibly fast, and just keeping up with it is tough. But precisely because of that, I feel there is meaning in sharing “raw information” like what it was actually like to use it and what was hard to understand.

I hope to continue doing this at my own pace without straining myself. I would be happy if I could deliver information that makes someone think, “Oh, that helped,” in some form or another.

I look forward to your continued support.

How to download YouTube videos with yt-dlp.exe

Tue, 03 Sep 2024 14:09:26 +0900

What is yt-dlp?

yt-dlp is a command-line tool for downloading YouTube videos. Not only can you download videos, but you can also download them as music files in mp3 format.

Download and Install

Download the latest yt-dlp.exe from the yt-dlp releases page.
Place yt-dlp.exe in a folder of your choice.
Add the folder path of yt-dlp.exe to the Path environment variable.

Usage

Run yt-dlp.exe in the command prompt and specify the URL of the YouTube video.

1

yt-dlp.exe "https://www.youtube.com/watch?v=VIDEO_ID"

Passing just the VIDEO_ID part as an argument is also OK.

If you want to download it as an mp3 music file, run the following command.

1

yt-dlp.exe --extract-audio --audio-format mp3 --embed-thumbnail --add-metadata "https://www.youtube.com/watch?v=VIDEO_ID"

The video will be downloaded to the current directory where you executed the command.

That’s it.

Short Video Links

Sun, 25 Aug 2024 16:24:35 +0900

Soccer Ball Boy

@gg211204 『ボールボーイがヒーローになった日』この日チームを救ったボールボーイは後日クラブに招待され、選手達食事を共にした。 #トッテナム #スパーズ #モウリーニョ #ボールボーイ ♬ original sound - じょり

Starbucks

Einstein's Quote

Sat, 24 Aug 2024 18:38:47 +0900

Hello!

Today, I would like to talk about a quote by Albert Einstein.

The World Doesn’t Appreciate Your Good Deeds?

` The world will never appreciate the million good things you do. But it will criticize the one wrong thing you do… But do not be discouraged. “Always rise above all laughter and criticism. Stay strong.”

Albert Einstein `

This is a quote attributed to Einstein. It sharply points out the harshness of society and the bias in people’s evaluations that we feel every day.

Still, Keep Rising

“Always rise above all laughter and criticism. Stay strong.”

This following sentence can be said to be Einstein’s answer to the harsh reality mentioned above. It teaches us the importance of not yielding to criticism or ridicule, and continuing to move forward believing in ourselves.

Applying Einstein’s Teachings in Daily Life

This quote is deeply related to our daily lives. For example, there are times when your efforts at work go unrecognized, and only trivial mistakes stand out. Also, your statements on social media might be taken out of context and criticized.

At such times, try to remember this quote by Einstein. It is important to hold on to your own beliefs rather than being swayed by the evaluations of others.

Summary

This quote by Einstein teaches us the importance of “living believing in yourself without being swayed by the evaluations of others”. Let’s have the courage to pursue the path we believe in, without yielding to criticism or ridicule.

Finally, Einstein’s words once again.

“Always rise above all laughter and criticism. Stay strong.”

I hope this quote resonates with your heart and becomes a catalyst for you to take a positive step forward.

C Language Code to Generate Prime Numbers

Sat, 24 Aug 2024 09:38:10 +0900

Here is a simple C language code that generates prime numbers within a specified range. In this example, it enumerates prime numbers from 1 to n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Please enter the maximum value of the range to generate prime numbers: ");
 scanf("%d", &n);
 printf("The prime numbers from 1 to %d are as follows:\n", n);
 printPrimes(n);
 return 0;
}

This code works as follows:

isPrime function: Determines whether a given number is a prime number. For efficiency, it first checks if it is divisible by 2 or 3, and then proceeds to check using steps of 6.
printPrimes function: Outputs the prime numbers within the specified range. It outputs 2 first, and then checks only odd numbers.
main function: Prompts the user to input the maximum value of the range and outputs the prime numbers within that range.

When you compile and run this code, it will display the prime numbers within the specified range.

Thou Shalt Not Die

Thu, 25 Jul 2024 13:16:47 +0900

Akiko Yosano

“Thou Shalt Not Die”

―― Grieving for my younger brother in the besieging army at Port Arthur

Ah, my brother, I weep for you,
Thou shalt not die,
Being the youngest born,
You received the most of our parents’ love.
Did they place a blade in your hand
And teach you to kill?
Did they raise you to twenty-four
Just to tell you to kill and die?

As the master of an old and proud
Merchant house in the town of Sakai,
Since you are the one to inherit our parents’ name,
Thou shalt not die.
Whether the fortress of Port Arthur falls,
Or whether it does not, what does it matter?
You surely know, such things
Are not the way of a merchant’s house.

Thou shalt not die.
The Emperor himself
Does not go out to battle.
To shed one another’s blood,
To die the death of beasts,
And call such death human glory,
With his great and deep heart,
How could the Emperor possibly desire this?

Ah, my brother, in battle
Thou shalt not die.
Our mother, who lost our father
Last autumn,
In the midst of her sorrow, pitifully
Having her son summoned, she guards our home.
Even in this great reign heard to be peaceful,
Our mother’s white hairs have grown.

Weeping behind the shop curtains
Is your fragile, young bride,
Have you forgotten her, do you think of her?
Parted before being together for even ten months,
Think of the young girl’s heart.
In this world, with only you,
Ah, whom else is she to rely upon?
Thou shalt not die.

About Akiko Yosano

Thu, 25 Jul 2024 13:08:36 +0900

🔹 Person Overview

Akiko Yosano (1878-1942) was a Japanese poet, author, and thinker who was active from the Meiji through the early Showa periods. She is especially known for her passionate and unique tanka poems, and is a figure who opened new horizons for female independence and expressions of romance in modern Japanese literature.

Real Name: Sho Yosano (maiden name: Otori)
Birthplace: Sakai (Sakai City, Osaka Prefecture)
Husband: Tekkan Yosano (tanka poet, poet)
Main Active Period: Late Meiji to Early Showa periods
Characteristics:
- Garnered attention for tanka poems that frankly expressed a woman’s romantic feelings
- Held feminist ideals and promoted female education and independence
- Also demonstrated a pacifist stance criticizing the Russo-Japanese War
- Core member of the literary magazine “Myojo”

🔹 Representative Works, Synopses, and Characteristics

1. “Midaregami” (Tangled Hair) (1901)

Overview: Her debut poetry collection. Published in her early 20s, it delivered a major shock to the Japanese literary world.
Characteristics: Frankly expressed romantic feelings and physical desire from a female perspective.
Famous Poem:

Without even touching the hot blood of my soft skin aren’t you lonely, you who preach the Way?

→ It became a topic of discussion for expressing a view of romance considered bold under the moral values of the time, in a woman’s own words.

2. “Kimi Shinitamou koto nakare” (Thou Shalt Not Die) (1904)

Format: Poem (free verse, not tanka)
Content: An anti-war poem addressed to her younger brother deployed in the Russo-Japanese War.
Excerpt:

Thou shalt not die, As you were born last, Our mother wept bitterly While wringing your sleeves…

Significance: Groundbreaking in that it appealed for anti-war sentiments from the perspective of a woman mourning her brother’s potential death, amidst a strong trend of glorifying war at the time.

🔹 Influence and Evaluation

Conducted socially advanced activities such as women’s liberation, pacifism, and the popularization of education.
Devoted her later years to women’s education and was involved in the establishment of women’s universities (e.g., Bunka Gakuin).
One of the most important female intellectuals and literary figures in pre-war Japan.

🔹 Summary

Item	Content
Name	Akiko Yosano
Fields of Activity	Tanka, poetry, criticism, education
Major Works	“Midaregami”, “Kimi Shinitamou koto nakare”
Characteristics	Expression of romantic freedom, female independence, pacifism
Influence on Modern Times	Pioneer of feminist literature, innovation in modern tanka, anti-war poetry

Introduction to Mathematica

Thu, 25 Jul 2024 01:36:19 +0900

Introduction to Mathematica

Solve an equation

1

Solve[x^2 - 3 x + 2 == 0, x]

Output

1

{{x -> 1}, {x -> 2}}

Solve an equation within integers

1

Solve[x^2 - 3 x + 2 == 0 && 0 <= x <= 2, x, Integers]

Output

1

{{x -> 1}, {x -> 2}}

Solve simultaneous equations

1

Solve[{x + y == 3, x - y == 1}, {x, y}]

Output

1

{{x -> 2, y -> 1}}

Solve an inequality

1

Reduce[x^2 - 3 x + 2 > 0, x]

Output

1

x < 1 || x > 2

Differentiate

1

D[x^2, x]

Output

1

2 x

Integrate

1

Integrate[x^2, x]

Output

1

x^3/3

Find a limit

1

Limit[1/x, x -> 0]

Output

1

Infinity

Find a series

1

Sum[1/n^2, {n, 1, Infinity}]

Output

1

π^2/6

Create a matrix

1

m = {{1, 2}, {3, 4}}

Find the product of matrices

1

m . m

Output

1

{{7, 10}, {15, 22}}

Find the inverse matrix

1

Inverse[m]

Output

1

{{-2, 1}, {1.5, -0.5}}

Find eigenvalues and eigenvectors

1

Eigensystem[m]

Output

1

{{5, 0}, {{1, 1}, {1, -1}}}

Find the inner product of vectors

1

{1, 2} . {3, 4}

Output

1

11

Find the cross product of vectors

1

Cross[{1, 2, 3}, {4, 5, 6}]

Output

1

{-3, 6, -3}

Find the magnitude of a vector

1

Norm[{1, 2, 3}]

Output

1

√14

Find the angle between vectors

1

ArcCos[{1, 2} . {3, 4}/(Norm[{1, 2}] Norm[{3, 4}])]

Output

1

ArcCos[11/(√5 √25)]

Find the projection of a vector

1

{1, 2} . {3, 4}/Norm[{3, 4}] {3, 4}/Norm[{3, 4}]

Output

1

{11/5, 22/5}

Find the rotation of a vector

1

RotationMatrix[π/2].{1, 0}

Output

1

{0, 1}

Find the translation of a vector

1

TranslationTransform[{1, 2}][{3, 4}]

Output

1

{4, 6}

Find the scaling of a vector

1

ScalingTransform[{2, 3}][{1, 1}]

Output

1

{2, 3}

Find the reflection of a vector

1

ReflectionTransform[{1, 1}][{1, 1}]

Output

1

{0, 0}

Generate random numbers

1

RandomReal[]

Output

1

0.123456

Generate random numbers (integers)

1

RandomInteger[]

Output

1

123456

Generate random numbers (range specified)

1

RandomReal[{1, 10}]

Output

1

5.6789

Generate random numbers (integers, range specified)

1

RandomInteger[{1, 10}]

Output

1

5

Generate random numbers (distribution specified)

1

RandomVariate[NormalDistribution[0, 1]]

Output

1

0.123456

Generate random numbers (distribution specified, number specified)

1

RandomVariate[NormalDistribution[0, 1], 10]

Output

1

{0.123456, 0.234567, ..., 0.987654}

Generate random numbers (distribution specified, number specified, seed specified)

1
2


SeedRandom[12345]
RandomVariate[NormalDistribution[0, 1], 10]

Output

1

{0.123456, 0.234567, ..., 0.987654}

Apply a function to array elements

1
2
3


Map[Sqrt, {1, 4, 9}]
Sqrt /@ {1, 4, 9}
Map[#^(1/2)&, {1, 4, 9}]

Output

1

{1, 2, 3}

Define a function using lambda expressions

1
2


f = Function[x, x^2]
f[3]

Output

1

9

Compose functions

1
2
3
4


f = Function[x, x^2]
g = Function[x, x + 1]
h = Function[x, f[g[x]]]
h[3]

Output

1

16

Reference the previous calculation result

1

% + 1

Output

1

17

Pure functions

1

(#+3)&[5]

Output

1

8

Extract from an array

1
2


Select[{1, 2, 3, 4, 5}, EvenQ]
Select[{1, 2, 3, 4, 5}, Mod[#,2]==0&]

Output

1

{2, 4}

Hugo Command List

Fri, 31 May 2024 01:36:00 +0900

What is Hugo?

Hugo is a static site generator. It can convert Markdown files into HTML and create websites. Hugo is written in the Go language and runs very fast.

This blog is also created with Hugo.

Installing the Hugo CLI

To install the Hugo CLI, run the following command.

Example for macOS. For other operating systems, please refer to the official documentation.

1

brew install hugo

You can install it using Homebrew.

Hugo Command List

Hugo provides various commands. Below is a summary of commonly used commands.

Create a new site

1

hugo new site <site-name>

Command to create a new site. Specify the name of the site in <site-name>.

Create a new post

1

hugo new <post-name>.md

Command to create a new post. Specify the name of the post in <post-name>.

Start the server

1

hugo server

Command to start a local server. You can access it at http://localhost:1313.

Build the site

1

hugo

Command to build the site. HTML files will be generated in the public directory.

Deploy the site

1

hugo deploy

Command to deploy the site. Deployment settings are configured in the config.toml file.

List all posts

1

hugo list all

Command to display a list of all posts.

Check configuration

1

hugo config

Command to check the configuration.

Display help

1

hugo help

Command to display help information.

Display version

1

hugo version

Command to display the version.

That concludes the Hugo command list. There are many other commands available, so please refer to the official documentation for more details.

References

Hugo Official Documentation

Recommended Visual Studio Code Extensions

Wed, 29 May 2024 17:20:19 +0900

Visual Studio Code Recommended Extensions List

Category	Name	Publisher	Description
Virtual / Container Management	Remote Development	Microsoft	Supports remote development by connecting to virtual containers / WSL via SSH
Virtual / Container Management	Docker	Microsoft	Supports management of Docker containers
Code Management	GitHub Pull Requests	GitHub	Manage GitHub Pull Requests within VSCode
Code Management	GitHub Copilot	GitHub	Supports AI-based code completion
Code Management	Git Graph	mhutchie	Graphically displays Git branches and commits
Code Management	Git History	Don Jayamanne	Displays Git history
Browser / Web Development	Debugger for Firefox	Firefox DevTools	Use Firefox’s debugger within VSCode
Browser / Web Development	Microsoft Edge Tools for VS Code	Microsoft	Use Edge’s developer tools within VSCode
Browser / Web Development	Vue Language Features (Volar)	Vue	Supports Vue language features
Browser / Web Development	JavaScript (ES6) code snippets	charalampos karypidis	Provides JavaScript snippets
Browser / Web Development	Tailwind CSS IntelliSense	Tailwind Labs	Provides Tailwind CSS snippets
Cloud Development	AWS Toolkit	Amazon Web Services	Supports AWS development
Cloud Development	Azure Tools	Microsoft	Supports Azure development
Cloud Development	Google Cloud Tools	Google Cloud	Supports Google Cloud development
Database	MySQL	Jun Han	Supports MySQL development
Database	SQL Server (mssql)	Microsoft	Supports SQL Server development
Database	PostgreSQL	Chris Kolkman	Supports PostgreSQL development
Embedded	PlatformIO	PlatformIO	Supports PlatformIO development
Embedded	Arduino	Microsoft	Supports Arduino development
Embedded	WorkBench	Particle	Particle’s development environment, supporting IoT development including firmware, libraries, and cloud integration
C/C++	C/C++ Extension Pack	Microsoft	Supports C/C++ development
C/C++	C/C++ Runner	franneck94	Runs C/C++ code (supports gcc, msvc, cuda nvcc compilers)
C/C++	Cortex-Debug	marus25	Supports debugging of Cortex-A/R/M microcontrollers
Python	Python Extension Pack	Microsoft	Supports Python development
Python	Jupyter	Microsoft	Supports Jupyter Notebook development
Utility / UI Extension	Markdown All in One	Yu Zhang	Supports Markdown writing
Utility / UI Extension	Hex Editor	Microsoft	Edits binary files
Utility / UI Extension	vscode-pdf	tomoki1207	Displays PDF files
Utility / UI Extension	Rainbow CSV	mechatroner	Displays CSV files colorfully
Utility / UI Extension	Draw.io Integration	Henning Dieterichs	Use Draw.io within VSCode
Utility / UI Extension	Japanese Language Pack for Visual Studio Code	Microsoft	Japanese localization pack
Utility / UI Extension	Live Share	Microsoft	Supports real-time collaborative work

Trying out mermaid.js

Sat, 25 May 2024 02:18:09 +0900

What is mermaid.js?

mermaid.js is a JavaScript library that allows you to graphically display complex charts and diagrams, such as flowcharts, diagrams, and Gantt charts, using its own text-based syntax (Mermaid syntax). It is also adopted by various services like GitHub, Qiita, and Notion. This time, we will make mermaid.js usable in hugo.

Making mermaid.js usable in hugo

The procedure is as follows:

Add the following to layouts/partials/extend_footer.html.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


{{ if or .Params.mermaid .Site.Params.mermaid }}
<script src="https://cdn.jsdelivr.net/npm/mermaid@10.3.0/dist/mermaid.min.js"></script>
{{- $loadmermaid := resources.Get "js/load-mermaid.js" }}
<script src="{{ $loadmermaid.RelPermalink }}"></script>
<script>
 window.initMermaid();
 if (isDarkTheme()) {
 setPrefTheme('dark');
 } else {
 setPrefTheme('light');
 }
</script>
{{ end }}

mermaid.min.js is loaded only when mermaid: true is set via the if statement. This library is about 3MB and unexpectedly large.

Create assets/js/load-mermaid.js. This process is used for initialization and to redraw when the theme is dynamically switched.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


(function(window){
'use strict'

 const elementCode = '.mermaid'
 const loadMermaid = function(theme) {
 window.mermaid.initialize({theme})
 window.mermaid.init({theme}, document.querySelectorAll(elementCode))
 }
 const saveOriginalData = function(){
 return new Promise((resolve, reject) => {
 try {
 var els = document.querySelectorAll(elementCode),
 count = els.length;
 els.forEach(element => {
 element.setAttribute('data-original-code', element.innerHTML)
 count--
 if(count == 0){
 resolve()
 }
 });
 } catch (error) {
 reject(error)
 }
 })
 }
 const resetProcessed = function(){
 return new Promise((resolve, reject) => {
 try {
 var els = document.querySelectorAll(elementCode),
 count = els.length;
 els.forEach(element => {
 if(element.getAttribute('data-original-code') != null){
 element.removeAttribute('data-processed')
 element.innerHTML = element.getAttribute('data-original-code')
 }
 count--
 if(count == 0){
 resolve()
 }
 });
 } catch (error) {
 reject(error)
 }
 })
 }

 const init = ()=>{
 saveOriginalData()
 .catch( console.error )
 document.body.addEventListener('dark-theme-set', ()=>{
 resetProcessed()
 .then(loadMermaid('dark'))
 .catch(console.error)
 })
 document.body.addEventListener('light-theme-set', ()=>{
 resetProcessed()
 .then(loadMermaid('default'))
 .catch(console.error)
 })
 }
 window.initMermaid = init
})(window);

The base code was referenced from below:

Reinitialize with new theme #1945

Modify the theme switching process in header.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


function switchTheme(theme) {
 switch (theme) {
 case 'light':
{{ if or .Params.mermaid .Site.Params.mermaid }}
 document.body.dispatchEvent(new CustomEvent('light-theme-set'));
{{ end }}
 document.body.classList.remove('dark');
 break;
 case 'dark':
{{ if or .Params.mermaid .Site.Params.mermaid }}
 document.body.dispatchEvent(new CustomEvent('dark-theme-set'));
{{ end }}
 document.body.classList.add('dark');
 break;
 // auto
 default:
 if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
{{ if or .Params.mermaid .Site.Params.mermaid }}
 document.body.dispatchEvent(new CustomEvent('dark-theme-set'));
{{ end }}
 document.body.classList.add('dark');
 }
 }
}

Create layouts/shortcodes/mermaid.html

1
2
3


<div class="mermaid" align="{{ if .Get "align" }}{{ .Get "align" }}{{ else }}center{{ end }}">
 {{ safeHTML .Inner }}
</div>

The preparation to use mermaid.js is now complete.

Trying out mermaid.js

Add the following to the article’s front matter

1

mermaid: true

Add the following to the article body

Flowchart

1
2
3
4
5
6


{{<mermaid align="center">}}
graph TD
 A[Start] -->|Condition 1| B(Condition 2)
 B --> C{Condition 3}
 C -->|Condition 4| D[End]
{{</mermaid>}}

Output Result

graph TD A[Start] -->|Condition 1| B(Condition 2) B --> C{Condition 3} C -->|Condition 4| D[End]

Gantt Chart

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


{{<mermaid align="center">}}
gantt
 section Project
 Requirement Definition :done, a, 2024-05-25, 5d
 Basic Design :done, b, after a, 5d
 Detailed Design :done, c, after b, 5d
 Manufacturing :active, d, after c, 10d
 Unit Testing :crit, e, after d, 5d
 Integration Testing : f, after e, 5d
 System Testing : g, after f, 5d
 Release :milestone, h, after g, 1d
{{</mermaid>}}

Output Result

gantt section Project Requirement Definition :done, a, 2024-05-25, 5d Basic Design :done, b, after a, 5d Detailed Design :done, c, after b, 5d Manufacturing :active, d, after c, 10d Unit Testing :crit, e, after d, 5d Integration Testing : f, after e, 5d System Testing : g, after f, 5d Release :milestone, h, after g, 1d

Sequence Diagram

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


{{<mermaid align="center">}}
sequenceDiagram
 participant user
 participant view
 participant controller
 participant model
 participant database
 user->>view: ID/PW Input
 view->>controller: Authentication Request
 controller->>model: Authentication Request
 model->>database: Authentication Request
 database-->>model: Return Authentication Result
 model-->>controller: Return Authentication Result
 controller-->>view: Return Authentication Result
 view-->>user: Display Authentication Result
{{</mermaid>}}

Output Result

sequenceDiagram participant user participant view participant controller participant model participant database user->>view: ID/PW Input view->>controller: ajax query controller->>model: Authentication Request model->>database: Issue SQL database-->>model: Return SQL Result model-->>controller: Return Authentication Request Result controller-->>view: Return ajax query result view-->>user: Display Authentication Result

That is all.

References

How to undo git reset

Wed, 15 May 2024 23:32:43 +0900

How to undo git reset

If you accidentally run git reset after making a git commit, here is how to undo the git reset (restore the state at the time of the git commit).

Check the commit ID before the reset with git reflog
Revert to the state before the reset with git reset --hard HEAD@{number}

That’s how to undo a git reset.

Open Sourcing of MS-DOS 4.0

Sun, 05 May 2024 16:44:28 +0900

Open Sourcing of MS-DOS 4.0

Microsoft has released the source code for MS-DOS 4.0, which was released approximately 40 years ago. It is written almost entirely in 8086 assembly code.

GitHub Repository

https://github.com/microsoft/MS-DOS

Reference Sites

Open-Sourcing MS-DOS 4.0

Recommended Books for Beginner Engineers

Sun, 05 May 2024 16:03:33 +0900

The Art of Readable Code
Principle of Programming
The Pragmatic Programmer
Technologies Supporting the Web
How to Build Secure Web Applications
How Networks Work
Thorough SQL Guide Learned from Masters
Docker Practical Guide
Kubernetes Complete Guide
Code Complete 2nd Edition
Clean Code: A Handbook of Agile Software Craftsmanship
Clean Architecture: A Craftsman’s Guide to Software Structure and Design
Technologies to Learn Before Becoming a Game Programmer
Being Geek
Why Object-Oriented Programming?

Excel Calendar Template (with Holiday Support)

Wed, 01 May 2024 00:15:57 +0900

I created an Excel calendar template (with holiday support)!

I made an Excel template that automatically displays the holidays for a given month when you enter the year and month.

Please download and use it. Calendar.xlsx

How to fix DPI settings resetting on every startup with multi-monitors

Mon, 29 Apr 2024 19:42:20 +0900

This is the configuration procedure for Windows 11.

Open Control Panel
Select Power Options
Click “Choose what the power buttons do”
Click “Change settings that are currently unavailable”
Uncheck “Turn on fast startup (recommended)”
Click “Save changes”

Reference

[Windows 10] Please tell me how to disable fast startup.

Get only the latest of a git repository

Sat, 27 Apr 2024 02:54:12 +0900

Get only the latest of a git repository

You can get only the latest of a repository with the following command. It is useful when you want to quickly fetch a repository to save disk space.

1

git clone --depth 1 <repository URL>

How to fix GitHub Copilot becoming unusable due to a certificate error

Sun, 21 Apr 2024 18:47:26 +0900

How to fix the following error in GitHub Copilot

GitHub Copilot stopped working around April 19, 2024. The error message is as follows:

[ERROR] [ghostText] [2024-04-21T04:06:46.900Z] Error on ghost text request: (FetchError) unable to verify the first certificate [ERROR] [certificates] [2024-04-21T04:06:46.901Z] Your current Copilot license doesn't support proxy connections with custom certificates. Please visit https://gh.io/copilot-network-errors to learn more. Original cause: {"type":"system","_name":"FetchError","code":"UNABLE_TO_VERIFY_LEAF_SIGNATURE"}

Solution

This seems to be a bug in ESET. Turn off “Enable SSL/TLS” in ESET’s Advanced setup.

References

The same error seems to occur with AWS CDK as well.

AWS CDK bootstrap certificate warning-error

Introduction to Vim

Fri, 19 Apr 2024 22:06:34 +0900

Introduction to Vim

Download and Installation

https://www.vim.org/download.php

From the site above, download and install the appropriate module for your OS.

For Windows, it is recommended to choose gvim_X.X.X_x64_signed.exe.

How to Start

For Windows, you need to register the folder containing vim.exe to the Path environment variable.

How to start:

1

vim

When specifying a file name to start:

1

vim filename.txt

How to Exit

To exit, type : (colon), then q, and press Enter.

1

:q

If you have modified the file, a message saying No write since last change (add ! to override) will be displayed. You can discard the changes and force quit.

1

:q!

To save the file and exit:

1

:wq

The following has the same meaning:

1

:x

You can also exit by pressing z twice while holding down Shift (same as :wq).

Modes

Vim has a Command mode and an Insert mode. When you start Vim, it is in Command mode. Pressing the i key switches to Insert mode.

In Insert mode, you can literally type text. To return from Insert mode to Command mode, press the ESC key.

This switching of input modes is a distinct characteristic of Vim.

Cursor Movement and Scrolling

Here is a summary of cursor movement and scrolling in Command mode.

Key	Description
`h` (or `Ctrl`+`H`, `BackSpace`, `←`)	Move left
`j` (or `Ctrl`+`J`, `Ctrl`+`N`, `↓`)	Move down
`k` (or `Ctrl`+`P`, `↑`)	Move up
`l` (or `Space`, `→`)	Move right
`+` (or `Enter`)	Move to the beginning of the next line
`-`	Move to the beginning of the previous line
`Ctrl`+`B` (or `PageUp`)	Scroll up
`Ctrl`+`F` (or `PageDown`)	Scroll down
`Ctrl`+`U`	Scroll half a screen up
`Ctrl`+`D`	Scroll half a screen down
`Ctrl`+`Y`	Scroll one line up
`Ctrl`+`E`	Scroll one line down
`z` `Enter`	Scroll cursor line to top of screen
`z` `.`	Scroll cursor line to middle of screen
`z` `-`	Scroll cursor line to bottom of screen
`0` (or `\|`)	Move cursor to the beginning of the line
`$`	Move cursor to the end of the line
`^` (or `_`)	Move cursor to the first non-blank character of the line
`G` (or `:$`)	Move cursor to the last line
`:Line Number` `Enter`	Move to specified line

If you type a Number followed by any of the above movement keys, it will move that many times. (For example, typing 3j will move the cursor down 3 lines from the current position.)

Other Commands

Key	Description
`Ctrl`+`L`	Redraw the screen
`Ctrl`+`G`	Show file status, number of lines, cursor position, etc.

LoadIcon Does Not Need to Call DestroyIcon

Fri, 19 Apr 2024 01:55:17 +0900

About the Need to Call DestroyIcon

You need to call DestroyIcon in the following cases:

CreateIconFromResourceEx (when called without the LR_SHARED flag)
CreateIconIndirect
CopyIcon

When created with the above functions.

LoadIcon
LoadImage (when using the LR_SHARED flag)
CopyImage (when using the LR_COPYRETURNORG flag and the hImage parameter is a shared icon)
CreateIconFromResource
CreateIconFromResourceEx (when using the LR_SHARED flag)

You must not call DestroyIcon for icons created and loaded in the above cases.

References

DestroyIcon function (winuser.h)

About Generative AI

Tue, 16 Apr 2024 02:13:56 +0900

Lecture Videos on Generative AI

“Generative AI” (1) Masayuki Nakao, Professor at the University of Tokyo - 2023.9.8

“Generative AI” (2) Kuniyoshi Sakai, Professor at the University of Tokyo - 2023.10.11

“Generative AI” (3) Yutaka Matsuo, Professor at the University of Tokyo - 2024.3.15

Generate QR code with curl

Tue, 16 Apr 2024 00:42:27 +0900

Generate QR code with curl

Note: The method introduced below generates the QR code on the server side and returns it, so logs might be kept. Please be careful when converting confidential information such as personal information into a QR code.

Method 1

This is a method to generate a QR code in the command prompt. qrenco.de returns a text-based response.

1

curl qrenco.de/kenji.blog

Output result

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


█████████████████████████████
█████████████████████████████
████ ▄▄▄▄▄ █ ▄ ▄ █ ▄▄▄▄▄ ████
████ █ █ █ ▀▀▀██ █ █ ████
████ █▄▄▄█ █▀▀█▀▄█ █▄▄▄█ ████
████▄▄▄▄▄▄▄█▄▀ ▀ █▄▄▄▄▄▄▄████
████▄ █▀▄ ▄▀█▄▀ ▀██▄▀ ▄████
████▀▀▀█ ▄▄ ▄█▄█▀█▀▄██ ▀████
████▄▄▄██▄▄█ █▀█ ▄██▀▀█ █████
████ ▄▄▄▄▄ █▀█ ▀ ▄▀▄▄▄ ▀████
████ █ █ █▄▄ ▄▀▄▀▄ ██ ▀████
████ █▄▄▄█ █▀▀█ ▀▄▄▄ ▄▄██████
████▄▄▄▄▄▄▄█▄▄███▄▄█▄███▄████
█████████████████████████████
█████████████████████████████

Reference

qrenco.de

Method 2

api.qrserver.com returns an image.

1

curl -o qr.png "https://api.qrserver.com/v1/create-qr-code/?size=150x150&data=HelloWorld"

Output result

Reference

QR Code Generator

Microsoft Word Shortcuts List

Sun, 07 Apr 2024 14:18:51 +0900

Shortcuts List

Shortcut Key	Description
`Ctrl` + `B`	Make bold
`Ctrl` + `I`	Make italic
`Ctrl` + `U`	Underline
`Ctrl` + `E`	Center align
`Ctrl` + `L`	Left align
`Ctrl` + `R`	Right align
`Ctrl` + `]`	Increase font size
`Ctrl` + `[`	Decrease font size
`Ctrl` + `C`	Copy
`Ctrl` + `V`	Paste
`Ctrl` + `X`	Cut
`Ctrl` + `Z`	Undo
`Ctrl` + `Y`	Redo
`Ctrl` + `A`	Select all
`Shift` + `Arrow keys`	Select text
`Ctrl` + `F`	Find text
`Ctrl` + `H`	Replace text
`Ctrl` + `P`	Print preview
`Ctrl` + `S`	Save document
`F12`	Save as
`Ctrl` + `Home`	Move to start of document
`Ctrl` + `End`	Move to end of document

Reference

Keyboard shortcuts in Word

Auto-refresh Web Page Browser Extension (Edge Add-on)

Sat, 06 Apr 2024 15:36:54 +0900

I would like to introduce “Tab Auto Refresh”, an Edge browser extension that automatically refreshes web pages.

Installing Tab Auto Refresh

Tab Auto Refresh

Access the site above and click Install.

Click Add extension.

How to Use

Once the installation is complete, an icon will be added to the top right of Edge.

Open the web page you want to auto-refresh and click the icon to start auto-refreshing.

The part in the green frame is the auto-refresh interval. Please select the timing to auto-refresh.

To stop auto-refreshing, click the icon and then click Stop reloading this tab.

Visual Studio Shortcut List

Sat, 06 Apr 2024 11:27:37 +0900

Visual Studio Shortcut List

I made a list of Visual Studio shortcuts that I personally use often. By memorizing keyboard operations for Visual Studio shortcuts, you can perform development work efficiently. Please make use of them.

Confirmed in Visual Studio 2022.

Shortcut Key	Description
`F1`	Show help for the selected word
`F2`	Jump to bookmark
`Ctrl` + `F2`	Register bookmark
`Ctrl` + `Shif` + `F2`	Delete all bookmarks
`F5`	Build and run (Debug run)
`Ctrl` + `F5`	Build and run (Run without debugging)
`F7`	Build
`F9`	Toggle breakpoint on the cursor line
`Ctrl` + `F9`	Disable breakpoint on the cursor line
`Shift` + `Ctrl` + `F9`	Delete all breakpoints
`F10`	Step over
`F11`	Step into
`F12`	Go to definition
`Ctrl` + `D`	Duplicate cursor line
`Ctrl` + `X`	Cut the line (if there is no selection)
`Ctrl` + `Shift` + `]`	Select up to the matching brace of the cursor part
`Alt` + `Up/Down Arrow Keys`	Move cursor line up or down
`Alt` + `Shift` + `Arrow Keys`	Multi-cursor / Box selection
`Ctrl` + `Tab`	Switch source code / window display
`Ctrl` + `Shift` + `V`	Show clipboard history
`Ctrl` + `K`, `Ctrl` + `C`	Comment out the cursor line
`Ctrl` + `K`, `Ctrl` + `U`	Uncomment the cursor line
`Ctrl` + `G`	Go to line
`Ctrl` + `F`	Find
`Ctrl` + `Shift` + `F`	Find in files (Global search)
`Ctrl` + `H`	Replace
`Ctrl` + `Shift` + `F`	Replace in files (Global replace)
`Ctrl` + `Tab`	Switch source code / window display
`Ctrl` + `Space`	Word completion
`Ctrl` + `Alt` + `L`	Open Solution Explorer window
`Ctrl` + `Shift` + `E`	Open Resource View window
`Ctrl` + `0`, `Ctrl` + `G`	Open Git Commit window

References

Keyboard shortcuts in Visual Studio

Add Hidemaru Editor Grep to Explorer Right-Click Menu

Wed, 03 Apr 2024 00:00:46 +0900

Here is how to add Hidemaru Editor’s grep to the right-click menu of Explorer in Windows 10/11.

※ The following steps involve modifying the registry, so please proceed at your own risk.

Steps

Open the link below and save it to a folder of your choice.

秀丸レジストリ登録.reg

Double-click the 秀丸レジストリ登録.reg file to add it to the registry.

References

Run Hidemaru grep from the folder’s right-click menu

What is the Birthday Paradox?

Tue, 02 Apr 2024 01:20:50 +0900

Do you know the Birthday Paradox?

Let me tell you a slightly mysterious story. How many people do you think need to gather for the “probability of people having the same birthday” to become high?

For example, a year has 365 days, so when you’re told “if 23 people gather, the probability of someone sharing a birthday is over 50%”… it feels somewhat counterintuitive, right?

But this is actually over 50%.

Why does this happen?

This phenomenon is called the “Birthday Paradox”. Its name contains “paradox”, but there is a proper mathematical reason for it.

When the number of people is “n”, the probability that no one shares a birthday can be calculated with the following formula:

1

P(No one shares) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

By subtracting that from 1, you get the “probability of sharing a birthday with someone”.

Looking at the results…

Number of People	Probability of people having the same birthday
10 people	Approx. 11.7%
20 people	Approx. 41.1%
23 people	Approx. 50.7% (Focus here!)
30 people	Approx. 70.6%
70 people	A whopping approx. 99.9%!

In other words, with just 23 people, there is a more than half chance that someone will share a birthday. It seems like this could apply quite often in a school class or a workplace meeting, right?

Conclusion: The gap between intuition and mathematics is interesting

The “Birthday Paradox” is an interesting example where our intuition and actual mathematical probabilities diverge. Knowing this kind of story might make for lively small talk or a fun quiz!

Reference Links

Birthday problem (Wikipedia)

How to Use Snipping Tool

Mon, 01 Apr 2024 23:19:45 +0900

What is Snipping Tool?

Snipping Tool is a screenshot tool built into Windows as a standard feature. You can cut and save a portion of the screen, capture the entire screen, or record the screen.

How to Launch Snipping Tool

You can mainly launch it in the following 3 ways.

Press the Win key, type Snipping Tool, and press the Enter key.
Press Win + Shift + S.
Press Win + R, type snippingtool, and press the Enter key.

How to Use Snipping Tool

The steps to save a captured image are as follows:

Select the Camera icon.
Click the New button.
Select the area you want to capture.
Click the Save as button.
Enter the destination and file name to save.

The steps to save a captured video are as follows:

Select the Video icon.
Click the New button.
Select the area you want to capture.
Click the Start button.
Record the screen.
Click the Stop button.
Click the Save as button.
Enter the destination and file name to save.

Reference

Use Snipping Tool to capture screenshots

How to Create a Shortcut to Lock Your Computer

Mon, 01 Apr 2024 01:37:49 +0900

Here is how to create a shortcut to lock your computer.

It is convenient because you can lock your computer by simply double-clicking the shortcut created on your desktop.

How to Create

1. Right-click on the desktop and select `New` > `Shortcut`

2. The Create Shortcut screen will appear. Enter `rundll32.exe user32.dll,LockWorkStation` and click `Next`

3. Enter the shortcut name `Lock Computer` and click `Finish`

4. Change the icon of the created shortcut

Right-click the created shortcut and select Properties

Click Change Icon

Select the yellow padlock icon and click OK. Click OK again to close the properties.

That’s it.

Double-clicking the created shortcut will lock your computer.

You can also lock your computer by pressing the Win key + L key.

*Note: No confirmation dialog will be displayed when locking the computer.

Monty Hall problem

Sun, 31 Mar 2024 23:41:51 +0900

What is the Monty Hall problem?

The Monty Hall problem is a brain teaser, in the form of a probability puzzle, loosely based on the American television game show “Let’s Make a Deal” and named after its original host, Monty Hall. The problem is as follows:

Premise: One of the three doors has a prize behind it, and the other two have a dud (goat).

The participant chooses one of the three doors.
The host opens one of the other two doors that the participant did not choose, revealing a dud.
The participant is asked whether they want to change their chosen door.

The problem is to consider whether the participant should change the door or not.

Solution

The solution to the Monty Hall problem is as follows:

If the participant does not change the initially chosen door
- Probability of winning: 1/3
- Probability of losing: 2/3
After the host opens the dud door
- If not changed, probability of winning: 1/3 (Does not change from the winning probability in step 1.)
- If changed, probability of winning: 2/3 (The probability of the remaining options.)

Therefore, the participant has a higher probability of winning by changing the door.

Reference

Wikipedia Monty Hall problem

How to install the text editor micro on Windows

Sun, 31 Mar 2024 21:50:39 +0900

Download micro

https://github.com/zyedidia/micro/releases

Open the link above, click Show all XX assets (where X is a number), and download micro-X.X.XX-win64.zip (where X is a number). Unzip the zip file and place the files in a folder of your choice.

Set Environment Variables

To use micro.exe from the command prompt, you need to set the environment variables.

Press Win key + R key, type sysdm.cpl, and press Enter.
Click System Properties in System Properties.
Click Environment Variables.
Select Path under System variables and click Edit.
Click New and add the path of the folder containing micro.exe.
Click OK to close all dialogs.
Restart the command prompt and type nano to check if it can be executed.

How to use micro

When you type micro in the command prompt and execute it, the following screen is displayed.

The main operations and shortcut keys are as follows.

Shortcut Key	Operation
Ctrl+Q	Close file
Ctrl+S	Save file
Ctrl+O	Open file
Ctrl+A	Select all
Ctrl+X	Cut selection
Ctrl+C	Copy selection
Ctrl+V	Paste
Ctrl+Z	Undo
Ctrl+Y	Redo
Ctrl+E	Execute editor command

Reference

micro

How to install CLI text editor nano on Windows

Sun, 31 Mar 2024 18:09:32 +0900

Download nano.exe

https://sourceforge.net/projects/nano-for-windows/

Open the link above, click Download, and download GNU-Nano_Win32(static).zip. Extract the zip file and place nano.exe in an arbitrary folder.

Note: Japanese input is not supported. (As of 2024/03/31)

Set Environment Variables

In order to use nano.exe from the command prompt, you need to set the environment variables.

Press Win key + R key, type sysdm.cpl, and press Enter key.
In System Properties, click on the Advanced tab.
Click on Environment Variables.
Select Path under System variables and click Edit.
Click New and add the path to nano.exe.
Click OK to close all dialogs.
Restart the command prompt, type nano, and check if it can be executed.

How to use nano

When you type nano and execute it, a screen like the following will be displayed.

Shortcut descriptions are displayed at the bottom of the screen.

The meanings of the symbols are as follows:

^ represents the Ctrl key.
M- represents the Alt key.

To save and close, press Ctrl + S and then Ctrl + X.

Reference

GNU nano

How to Fix "Temporary failure resolving..." Error in WSL

Sun, 31 Mar 2024 16:57:33 +0900

How to Fix “Temporary failure resolving…” Error in WSL

1
2
3
4


kenji@MyComputer:~$ sudo apt update
[sudo] password for kenji:
Err:1 http://archive.ubuntu.com/ubuntu focal InRelease
 Temporary failure resolving 'archive.ubuntu.com'

When the above error appears in WSL, the DNS server settings might be incorrect. In my environment, I solved it with the following steps.

Start WSL.
Run sudo nano /etc/resolv.conf.
Change the nameserver line as follows:

1

nameserver 8.8.8.8

Save with Ctrl + S and exit with Ctrl + X.
Run sudo apt update.
If the error doesn’t appear, it’s solved.

If the above steps do not solve the issue

It seems there are cases where the above steps don’t resolve the issue. Please refer to the following article:

How to resolve ‘Temporary failure resolving ~’ during apt update in WSL

How to exit and restart Explorer

Sat, 30 Mar 2024 15:40:24 +0900

This method is for Windows 10. It seems the menu is not displayed in Windows 11. If you hold down the Shift and Ctrl keys and right-click on the taskbar, Exit Explorer will appear in the menu.

How to exit from Task Manager

Press Ctrl + Shift + Esc to launch Task Manager.
Select Details.

Select explorer.exe, press the Delete key, and when asked Do you want to end explorer.exe?, select End process.

How to exit from Command Prompt

Press Win + R, type cmd, and press Enter.
Type taskkill /f /im explorer.exe and press Enter.

How to start Explorer from Task Manager

Press Ctrl + Shift + Esc to launch Task Manager.
Select Run new task from the File menu.
Type explorer.exe and press Enter.

How to Restore the Classic Right-Click Menu in Windows 11

Sat, 30 Mar 2024 13:13:36 +0900

Here is how to restore the classic right-click menu in Windows 11.

Open the Registry Editor.

Press the Win key + R key, type regedit, and press the Enter key. 　

Navigate to HKEY_CURRENT_USER\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}. Create this key if it does not exist.
Navigate to HKEY_CURRENT_USER\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32. Create this key if it does not exist.
Check that the (Default) value in InprocServer32 is empty.

Restart your computer.
Confirm that the right-click menu has returned to the classic version.

Collection of Fonts Useful for Programming

Sat, 30 Mar 2024 02:21:31 +0900

JetBrains Mono

An open-source programming font provided by JetBrains.

Download: https://www.jetbrains.com/ja-jp/lp/mono/

HackGen

HackGen is a programming font that combines the English programming font Hack with Genjyuu Gothic, a derivative of Source Han Sans.

Download: https://github.com/yuru7/HackGen/releases

Ricty Diminished

Ricty Diminished is a sister font to Ricty. Instead of Inconsolata and Migu 1M, it is synthesized using Inconsolata and Circle M+ 1m with the Ricty generation script. Since it does not include IPA Gothic glyphs, the number of available kanji glyphs is limited, but in exchange, it can be distributed under the SIL Open Font License.

Download: https://rictyfonts.github.io/diminished

Cica

It uses Hack + DejaVu Sans Mono for alphanumeric characters and symbols. For other characters, it uses Rounded Mgen+. It is a programming font designed for coding.

Download: https://github.com/miiton/Cica/releases

References:

Migu

A synthesized font of M+ and IPA.

Download: https://itouhiro.github.io/mixfont-mplus-ipa/migu/

Osaka

A font that allows you to use Osaka, a standard Mac OS font, on Windows.

Download: http://ifs.nog.cc/osakattf.hp.infoseek.co.jp/

PlemolJP

A programming font that combines IBM’s open-source Japanese font IBM Plex Sans JP with IBM Plex Mono, also from IBM’s Plex series.

Download: https://github.com/yuru7/PlemolJP/releases

How to Launch Hidemaru Editor with the "hide" Command

Fri, 29 Mar 2024 23:45:37 +0900

Here is how to launch Hidemaru Editor with the “hide” command.

Note: This method has been verified to work on Windows 10/11.

Open the Registry Editor.
Navigate to HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths.
Create a key named hide.exe under App Paths. The part before .exe in this key name will be the command name.
Set the (Default) value of the hide.exe key to the executable file path of Hidemaru Editor. In my environment, it was "C:\Program Files (x86)\Hidemaru\Hidemaru.exe".
Create a String value named Path in the hide.exe key.
Set the data of Path to the folder path where the Hidemaru Editor executable file is located. In my environment, it was "C:\Program Files (x86)\Hidemaru".
Now you can launch Hidemaru Editor with the hide command in the Run dialog, which can be opened with Win + R. Also, in the Command Prompt, you can launch it with the start hide command.

1
2
3
4
5


Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\hide.exe]
@="\"C:\\Program Files (x86)\\Hidemaru\\Hidemaru.exe\""
"Path"="\"C:\\Program Files (x86)\\Hidemaru\\\""

If you save the above content in a .reg file and execute it, the settings will be added to the registry.

Unsolved Problems in Mathematics

Sat, 02 Mar 2024 22:57:36 +0900

Unsolved Problems in Mathematics

This is an explanation of unsolved problems in mathematics. Although the problems themselves are simple, there are still many that have not been proven.

Are there infinitely many perfect numbers?

A perfect number is a positive integer that is equal to the sum of its positive divisors, excluding the number itself. For example,

6 has divisors 1, 2, and 3, and 1+2+3=6, so it is a perfect number.
28 has divisors 1, 2, 4, 7, and 14, and 1+2+4+7+14=28, so it is a perfect number.

Currently, only 51 perfect numbers have been discovered. It is conjectured that there are infinitely many, but this has not yet been proven.

Goldbach’s Conjecture

Goldbach’s conjecture states that every even integer greater than 2 can be expressed as the sum of two primes. (Here, a prime number is a natural number that has no positive divisors other than 1 and itself.)

For example,

4=2+2
6=3+3
8=3+5
10=3+7=5+5

The problem itself is very simple, but it remains unproven.

Riemann Hypothesis

The Riemann hypothesis is the conjecture that the zeros of the Riemann zeta function are restricted to negative even integers and complex numbers with real part 1 / 2.

The Riemann zeta function is the function $\zeta$ defined by:

$$\zeta(s):=\sum _{n=1}^{\infty }{\frac {1}{n^{s}}}=1+{\frac {1}{2^{s}}}+{\frac {1}{3^{s}}}+{\frac {1}{4^{s}}}+\cdots$$

where $s$ is a complex number and $n$ is a natural number.

I Collected Various Version Information Dialogs

Sat, 02 Mar 2024 21:32:11 +0900

I Collected Various Version Information Dialogs

Windows 11

First, here is the version information for Windows 11 that I am currently using.

IntelliJ IDEA (Community Edition)

This is the environment where I write this blog.

Visual Studio Code

This is another editor I often use. It’s surprisingly simple.

Visual Studio

This is the development environment I use for C++.

LINE(Windows)

This is the Windows version of LINE.

Paint.NET

This is an image editing software.

Sakura Editor

This is a text editor.

Google Chrome

This is Google Chrome. I haven’t used it much since Edge came out.

Firefox

This is Firefox. I haven’t used it much recently.

Microsoft Edge

This is Microsoft Edge. I use this one quite often recently.

OBS Studio

This is OBS Studio. I haven’t used it much recently.

TradingView

This is TradingView. Recently, I’ve been using it to look at the USD/JPY charts.

Spy++

This is Spy++. It’s a tool included in the Windows SDK.

Dependency Walker

This is Dependency Walker. It’s a tool included in the Windows SDK.

Resource Hacker

This is Resource Hacker. It’s a tool to edit and extract resources from executable files.

Microsoft Excel

This is Microsoft Excel.

Bandicam

This is Bandicam. It’s a video capture tool.

WinMerge

This is WinMerge. It’s a tool for viewing file differences.

iTunes

This is iTunes. I haven’t used it much recently.

Hidemaru Editor

This is Hidemaru Editor. It’s a text editor.

Adobe Photoshop CS6

This is Adobe Photoshop CS6.

Adobe Illustrator CS6

This is Adobe Illustrator CS6.

ESET NOD32

This is ESET NOD32.

Notepad++

This is Notepad++. It’s a text editor.

MIFES

This is MIFES. I haven’t used it much recently.

GIF Animation Screen Recording Tool

Thu, 08 Feb 2024 01:23:01 +0900

GIF Animation Screen Recording Tool

I created a tool to record the screen and convert it into a GIF animation. With this tool, you can record screen operations and share them via communication tools like Microsoft Teams.

How to Use

Launch the tool.
Specify the recording area. If not specified, the entire screen will be recorded.
Press the record button.
Press the stop recording button.
The GIF animation will be output to the same location as the executable file.

Download

Open the link above and click the GIFScreenRecorder.exe link to download the executable file.

Source Code

GitHub

PMP Study

Sun, 04 Feb 2024 18:41:31 +0900

PMP Exam Study Summary

A summary of my studies for the PMP exam.

Overview

PMP is a project management certification. It is based on a guidebook called PMBOK (latest 7th edition). The PMP exam is 230 minutes long and consists of 180 questions, but 5 of them are dummy questions, so you pass if you answer 106 or more of the 175 questions correctly. The answers are multiple-choice, mostly with 4 options, but some have 5 options or are multiple-select.

Servant Leadership

A leadership style that supports from the bottom rather than commanding from the top.

10 Principles (Characteristics) of Servant Leadership

Listening
Empathy
Healing
Awareness
Persuasion
Conceptualization
Foresight
Stewardship
Commitment to the Growth of People
Building Community

Agile Manifesto 4 Values

We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on the left, we value the items on the right more.

Agile Manifesto

12 Principles Behind the Agile Manifesto

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
Business people and developers must work together daily throughout the project.
Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
Working software is the primary measure of progress.
Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Continuous attention to technical excellence and good design enhances agility.
Simplicity–the art of maximizing the amount of work not done–is essential.
The best architectures, requirements, and designs emerge from self-organizing teams.
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

Principles behind the Agile Manifesto

Terminology

Epic (Outline)
User Story (Unit to be registered in the product backlog, unit for prioritization)
Task (Technical work item, target for time estimation)
Product Backlog / Product Backlog Item
Product Owner
Stakeholder
Agile Practice Guide (Book)
Lean Development
Kanban
Value Chain
AC (Actual Cost)
EV (Earned Value)
PV (Planned Value)
EVA (Earned Value Analysis)
SPI (Schedule Performance Index = EV / PV)
CPI (Cost Performance Index = EV / AC)
EVM (Earned Value Management)
BAC (Budget at Completion)
ETC (Estimate To Complete)
EAC (Estimate At Completion)
Functional Organization
Matrix Organization
Projectized Organization
Servant Leadership
Tuckman’s Model (Forming, Storming, Norming, Performing, Adjourning)
Team Charter
Planning Poker (Fibonacci sequence)
Retrospective (Looking back activity)
Virtual Team
Project Charter
Conflict (6 Coping methods: Confronting/Problem Solving, Collaborating, Compromising, Smoothing/Accommodating, Forcing, Withdrawing/Avoiding)
Value Stream Mapping
Mentoring
Coaching
Training
Douglas McGregor’s Theory X and Theory Y
SWOT Analysis: Strength, Weakness, Opportunity, Threat
SECI Model (Socialization, Externalization, Combination, Internalization)
PDCA, PDSA
PESTLE (Political, Economic, Social, Technological, Legal, Environmental)
VUCA (Volatility, Uncertainty, Complexity, Ambiguity)
Monte Carlo Method
Decision Tree Analysis
Expected Monetary Value (EMV)
Net Promoter Score
Cost-Benefit Analysis
Sprint Review
Release Management
SOW (Statement of Work) “Document containing a detailed description of the project scope, objectives, deliverables, duration, resources, etc.”
P-SOW (Procurement Statement of Work)
RFI (Request For Information)
RFP (Request For Proposal)
Fixed Price Contract (FP: Fixed Price)
Time and Material Contract (T&M: Time and Material)
Cost Reimbursable Contract (CR: Cost Reimbursable)
Fixed Price Incentive Fee (FPIF)
Scope Creep
Kano Analysis
Funding Limit Reconciliation
100 Points Method
MoSCoW Method (Must, Should, Could, Would)
Traceability Matrix
WBS Dictionary
Velocity (Number of story points achieved in each iteration)
Velocity Chart
Engagement Assessment Matrix (Unaware, Resistant, Neutral, Supportive, Leading)
Phase Gate
Information Radiator
Burndown Chart
Burnup Chart
Cumulative Flow Diagram
QCD (Quality, Cost, Delivery)
Spiral Model
Critical Chain
Feature
Iteration / Sprint
Iterative
Incremental
Increment (Deliverable of an increment)
Resilience / Resiliency
Stewardship: Sincere, trustworthy behavior and responsible actions (decision making)
Escalation
KPT (Keep, Problem, Try)
RACI (Responsible, Accountable, Consulted, Informed)
PMO (Project Management Office): Supportive, Controlling, Directive
Cadence
Tailoring
Neurological Levels (Environment, Behavior, Capabilities, Beliefs/Values, Identity)
Business Case (Document outlining project objectives, benefits, risks, ROI, etc.)
Trend Analysis (Executed using run charts, mathematical techniques to predict future outcomes based on results)
Quality Management Plan (Defines the strategy and approach for project deliverables’ quality)
Governance Process
Product Owner (Product vision, product backlog prioritization, product release)
Project Owner (Project sponsor/client)
Project Manager (Manages the overall project)
Project Leader (Directs on site)
Project Member (Drives the project)
Hybrid Approach
Minimum Viable Product (MVP)
Iteration Review
Workshop
Project Benefits Management Plan (Target benefits of project objectives, strategic means to realize them, and timeframes)
Key Performance Indicator (KPI)
On-site (In the field, locally)
Analogous Estimating
Three-Point Estimating
Parametric Estimating
Project Review
Big Bang Approach
DSDM (Dynamic Systems Development Method)
Brooks’s Law
Big Bang Approach (Introducing everything all at once)
Risk Register (Document used as a risk management tool to identify potential setbacks in a project)
Risk Register
Situational Leadership Theory (SL Theory) (4 behaviors matched to the other party’s situation)
Competence
Commitment

References

Study Materials

Aim for First Try Pass in “PMP® Certification Exam”! Strategy Course for Efficient Exam Preparation (2021) Agile Supported

Disasters in Japan

Sun, 07 Jan 2024 00:50:09 +0900

Overview

Notes on natural disasters that occurred in Japan.

January 1, 2024 Noto Peninsula Earthquake

Nanakusa-gayu Recipe

Sat, 06 Jan 2024 22:22:00 +0900

Seven Herbs (Nanakusa)

Seri (Water dropwort)
Nazuna (Shepherd’s purse)
Gogyo (Cudweed)
Hakobera (Chickweed)
Hotokenoza (Nipplewort)
Suzuna (Turnip)
Suzushiro (Radish)

Favorite Japanese Music

Sat, 06 Jan 2024 04:11:01 +0900

Recommended Japanese Music

Tulip - Seishun no Kage
Iruka - Nagoriyuki
Eigo Kawashima - Sake to Namida to Otoko to Onna
Orangestar - Surges
Mariya Takeuchi - Plastic Love
RADWIMPS - Zenzenzense
BEGIN - Shimanchu nu Takara
The Blue Hearts - Jounetsu no Bara
Yumi Arai - Rouge no Dengon
Begin - Umi no Koe
Yumi Arai - Hikouki Gumo
Love is Over - Ouyang Feifei
Clammbon - Nami Yosete
RADWIMPS - Sparkle
Kariyushi58 - Anmer
Kariyushi58 - Owari Hajimari
Teresa Teng - Toki no Nagare ni Mi wo Makase
Hikaru Utada “One Last Kiss”
Fukashigi/wonderboy - Pellicule (Official Music Video)

Kamen Rider Black RX - Opening Song
Tashika na Koto / Kazumasa Oda - Covered by Pak Yuna
【Japanese healing song】Hana／Kosuke Atari（covered by Leah）
“Mayonaka no Door ~stay with me” / Miki Matsubara Official Lyric Video
Midnight Pretenders
Anri - Last Summer Whisper
1985 - The Blue Hearts
BUMP OF CHICKEN - supernova
Tulip - Kokoro no Tabi 1972
Chiisana Koi no Uta
ASKA - Hajimari wa Itsumo Ame (Official Music Video)
Kirinji - Aliens
Ano Hi no Sora yo - Kosetsu Minami

Favorite Western Music

Fri, 05 Jan 2024 00:14:22 +0900

Recommended Western Music

Keane - Somewhere Only We Know
Ben E. King - Stand By Me
The Beatles - Hey Jude
The Mamas & The Papas - California Dreamin'
Ed Sheeran - Shape of You
Mark Ronson ft. Bruno Mars – Uptown Funk
Sugar - Maroon 5
Bette Midler - The Rose
Green Day - Basket Case
Coldplay - Viva La Vida
Maroon 5 - Memories (Lyrics)
Dido - Thank You (Official Video)
Bob Dylan - Blowin’ in the Wind
Coldplay - Yellow
Eric Clapton - Tears In Heaven
B. J. Thomas - Raindrops Keep Fallin’ on My Head (Stereo / Lyrics)
Take Me Home, Country Roads
Simon & Garfunkel - Mrs. Robinson (Audio)
Taylor Swift - Love Story (Live on Letterman)
Wiz Khalifa - See You Again ft. Charlie Puth [Official Video] Furious 7 Soundtrack
The Top (Extended Mix)
Something Just Like This
Feelings
Yesterday Once More
Carpenters - Top Of The World
I Need To Be In Love - Carpenters
Bob Marley & The Wailers “Three Little Birds”
Alan Walker - All Falls Down (feat. Noah Cyrus with Digital Farm Animals)
Alan Walker - Darkside (feat. Au/Ra and Tomine Harket)
Alan Walker - Alone
Alan Walker - Sing Me To Sleep
Alan Walker - Faded
killing me softly with his song
a-ha - Take On Me (Official Video)

Install PowerToys via Command Prompt

Sat, 30 Sep 2023 21:23:00 +0900

Install PowerToys via Command Prompt

Here is how to install PowerToys via Command Prompt.

1

winget install Microsoft.PowerToys --source winget

Uninstall PowerToys via Command Prompt

1

winget uninstall --name PowerToys

Let us respect people who can do things we cannot

Tue, 01 Aug 2023 23:42:31 +0900

Let’s show respect

Let us respect people who can do things that we cannot.

In society, there are surprisingly many people who rank jobs or positions and are unable to show respect to others.

Let’s pay respect to anyone who accomplishes a job we cannot, regardless of what that job may be.

This is something I want to keep in mind.

Splatoon 2

Tue, 01 Aug 2023 00:26:30 +0900

Splatoon 2

Splatoon 2 is probably the game I’ve played the longest in my life. I’ve barely played the story mode, but the 4v4 online matchmaking is very well done. Being able to play against people around my skill level gives it a captivating appeal that never gets old. Also, it is fun to read the movement patterns of both opponents and teammates and think of strategies to win.

Weapons

The weapons I use most often, in order, are the “Foil Squeezer”, “Splattershot Jr.”, “Splat Roller”, and “Foil Flingza Roller”. The “Splattershot Jr.” is a beginner-friendly weapon, and I used it a lot in the early stages.

The turf inked points for each are as follows:

Weapon	Turf Inked
Flingza Roller	6,636,594p
Splat Roller	6,200,629p
Splattershot Jr.	4,211,759p
Foil Squeezer	744,678p
Splattershot	301,238p

Regarding Level

I’ve been going back and forth between A+ and S+, and I’ve been stuck unable to climb to the upper tiers of S+ for a while now. However, rather than trying to climb to the top, I feel like I’m playing just to enjoy the matches. (If I get too high up, the opponents get stronger and the tension rises, making it less enjoyable.)

Play Time

My playtime has exceeded 2,500 hours.

Future Goals

My goal is to maintain my game level and have fun playing, but I would like to max out my money and gear. Since Splatoon 3 came out, matchmaking has been taking longer and sometimes fails entirely, so I want to keep playing while hoping the player base doesn’t decrease any further.

About Receiving the Microsoft MVP Award (2023-2024)

Mon, 31 Jul 2023 19:15:14 +0900

About Receiving the Microsoft MVP Award (2023-2024)

I have received the Microsoft MVP (2023-2024) award. This is the 7th consecutive year I have received this award since 2017.

The category I was awarded in is Developer Technologies.

Looking back at my past activities, I have been doing the following:

Publishing code on GitHub
Disseminating technical information on my blog and SNS (Twitter, etc.)
Posting on the MSDN Forums
Providing feedback on Microsoft products

I hope to continue writing better articles and sharing information.

Thank you very much.

History of Mathematics

Sat, 22 Jul 2023 15:25:10 +0900

The Three Classic Problems of Ancient Greek Mathematics

Given a circle, construct a square with the same area (Squaring the circle)
Given an arbitrary angle, trisect it (Angle trisection)
Given a cube, construct a cube with twice the volume (Doubling the cube)

Archimedean Spiral

On a plane, let a ray OB rotate around a fixed point O at a uniform speed. Assuming the initial position is OA, when point P starts from O simultaneously as the ray begins moving from OA, and moves along OB at a constant speed, the curve drawn by point P is an Archimedean spiral.

Pappus’s Theorem

Cycloid
Conchoid of Nicomedes
Cissoid of Diocles
Fermat’s tangent method
Descartes’ normal method

Timeline

Year	Event
c. 3400 BC	Sumerians perform calculations using clay tokens
c. 3000 BC	Hieroglyphic mathematics appears in Egypt
c. 2800 BC	Weights and measures based on the decimal system are used in the Indus Valley Civilization
c. 2700 BC	Egyptians use ropes and Pythagorean triples to verify angles
c. 2500 BC	The abacus, a calculating tool, is discovered
c. 2500 BC

Reference

History of Mathematics

Recommendation for the Deft Pro (M-DPT1MRBK) Trackball

Tue, 02 May 2023 23:28:33 +0900

About the Elecom Trackball Deft Pro M-DPT1MRBK

It has been about a week since I purchased the Elecom trackball “Deft Pro M-DPT1MRBK”, so I will review my experience using it.

Main Features

High number of buttons (8 buttons)
Can be connected in 3 ways: wired, wireless receiver, and Bluetooth
Large ball size (medium size, 44mm diameter)
Purchase price on Amazon: ￥7,012 (as of May 2, 2021)

Pros

Unlike a mouse, you don’t need to move your wrist, which reduces wrist strain.
With many buttons, you can assign various functions to them. I currently have them assigned as shown above. You can also change button assignments per application.

Dedicated software installation is required for button assignment.

Since the buttons are large, it is relatively easy to make precise movements for a trackball.

Cons

Dust accumulates around the trackball, so the ball needs to be removed and cleaned regularly (about once every few days).
It takes time to get used to the different feel compared to a mouse, as you use your index and middle fingers to move the cursor and your thumb to operate the mouse wheel.
Although I mentioned above that fine movements are easy, it is still difficult to move the cursor pixel by pixel with a trackball.
You cannot operate the wheel while pressing the left button (e.g., when you want to zoom in or out while selecting an area in Paint).

Overall, I think it is on the expensive side for a trackball, but generally it is quite easy to operate and has improved my work efficiency. I hope this will be helpful for those considering purchasing it.

Sample using wxWidgets

Tue, 18 Apr 2023 00:18:22 +0900

What is wxWidgets

wxWidgets is a C++ GUI library that works on platforms such as Windows, Mac, Linux, Android, and iOS.

Installing wxWidgets

Open https://www.wxwidgets.org/downloads/ and download the Windows Installer.
Run wxMSW-3.2.2.1-Setup.exe to install.
Open “C:\wxWidgets-3.2.2.1\build\msw\wx_vc17.sln” from the installed folder.
After opening wx_vc17.sln, select Build > Batch Build.
Click the Select All button, and then click the Rebuild button.
Once the build is finished, temporarily close Visual Studio.

Creating a Sample Project

Open Visual Studio.
Select File > New > Project.
Select Windows Desktop Application (tabs are C++, Windows, Desktop).
Enter wxWidgetsSample for the Project Name.
Click Create.
Right-click wxWidgetsSample and select Properties.
Under Configuration Properties > C/C++ > Additional Include Directories, add C:\wxWidgets-3.2.2.1\include and C:\wxWidgets-3.2.2.1\include\msvc.
Under Configuration Properties > Linker > Additional Library Directories, add C:\wxWidgets-3.2.2.1\lib\vc_x64_lib.
Open wxWidgetsSample.cpp and replace it with the code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

#include <wx/wxprec.h>

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

class MyApp : public wxApp
{
public:
 virtual bool OnInit();
};

class MyFrame : public wxFrame
{
public:
 MyFrame();
private:
 void OnHello(wxCommandEvent& event);
 void OnExit(wxCommandEvent& event);
 void OnAbout(wxCommandEvent& event);
};

enum
{
 ID_Hello = 1
};

wxIMPLEMENT_APP(MyApp);

bool MyApp::OnInit()
{
 MyFrame* frame = new MyFrame();
 frame->Show(true);
 return true;
}

MyFrame::MyFrame()
 : wxFrame(NULL, wxID_ANY, "Hello World")
{
 wxMenu* menuFile = new wxMenu;
 menuFile->Append(ID_Hello, "&Hello...\tCtrl-H",
 "Help string shown in status bar for this menu item");
 menuFile->AppendSeparator();
 menuFile->Append(wxID_EXIT);
 wxMenu* menuHelp = new wxMenu;
 menuHelp->Append(wxID_ABOUT);
 wxMenuBar* menuBar = new wxMenuBar;
 menuBar->Append(menuFile, "&File");
 menuBar->Append(menuHelp, "&Help");
 SetMenuBar(menuBar);

 wxButton* button1 = new wxButton(this, ID_Hello, _("Hello"), wxPoint(20, 20), wxSize(100, 32));
 Connect(ID_Hello, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnHello));

 wxButton* button2 = new wxButton(this, wxID_ABOUT, _("About"), wxPoint(20, 60), wxSize(100, 32));
 Connect(wxID_ABOUT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnAbout));

 wxButton* button3 = new wxButton(this, wxID_EXIT, _("Exit"), wxPoint(20, 100), wxSize(100, 32));
 Connect(wxID_EXIT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnExit));

 CreateStatusBar();
 SetStatusText("Welcome to wxWidgets!");
 Bind(wxEVT_MENU, &MyFrame::OnHello, this, ID_Hello);
 Bind(wxEVT_MENU, &MyFrame::OnAbout, this, wxID_ABOUT);
 Bind(wxEVT_MENU, &MyFrame::OnExit, this, wxID_EXIT);
}

void MyFrame::OnExit(wxCommandEvent& event)
{
 Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& event)
{
 wxMessageBox("This is a wxWidgets' Hello world sample",
 "About Hello World", wxOK | wxICON_INFORMATION);
}

void MyFrame::OnHello(wxCommandEvent& event)
{
 wxLogMessage("Hello world from wxWidgets!");
}

If you build and run it, a window like the one below will open.

References

The sample project is provided below. wxWidgetsSample

That’s all.

Movie TODO List

Mon, 17 Apr 2023 00:34:13 +0900

Movies to watch (check off as I watch them)

Maquia: When the Promised Flower Blooms
The Professor’s Beloved Equation
Summer Wars
Hidden Figures
Good Will Hunting
A Beautiful Mind
The Theory of Everything
The Man Who Knew Infinity
Hawking (Benedict Cumberbatch)
Tenchi: The Samurai Astronomer
Pi
21
I.Q.
Proof
3 Idiots
Buffalo ‘66
A Clockwork Orange
Backdraft
Asakusa Kid
Top Gun
The Matrix Resurrections
I Am Legend
The Da Vinci Code
The Social Network
Steins;Gate
Planetes
Gravity
Violet Evergarden
Psycho-Pass
Demon Slayer
Princess Mononoke
Winny
Zero Focus
Zootopia
Your Name.
Weathering with You
Back to the Future (1, 2, 3)
Shin Godzilla
Shin Ultraman
Shin Kamen Rider
Suzume
THE FIRST SLAM DUNK

Cool Web Page Templates (html5up)

Mon, 17 Apr 2023 00:26:55 +0900

Cool Web Page Templates

html5up https://html5up.net/

I wanted to try using this, so this is a memo.

How to output the current time in ISO8601 format in C++

Sat, 15 Apr 2023 19:35:27 +0900

Prerequisites

ISO C++ 20 Standard (/std:c++20)

Code

1
2
3
4


#include <chrono>
#include <format>

std::string datetime = std::format("{:%FT%TZ}", system_clock::now());

That’s how to output the current time in ISO8601 format in C++.

References

std::format

How to create a shortcut to shutdown Windows

Tue, 11 Apr 2023 17:03:32 +0900

Here is how to create a shortcut to shut down Windows.

It is convenient because you can shut down by double-clicking the created shortcut placed on your desktop or elsewhere.

How to create

1. Right-click on the desktop, and select `New` > `Shortcut`

2. The shortcut creation screen will appear, enter `shutdown.exe -s -f -t 0` and click `Next`

3. Enter the shortcut name `Shutdown` and click `Finish`

4. Change the icon of the created shortcut

Right-click the created shortcut and select Properties

Click Change Icon...

Select the red square icon and click OK, then click OK again to close the properties window.

That’s it.

Double-clicking the created shortcut will shut down Windows.

*Note: No shutdown confirmation dialog will be displayed.

How to apply a mosaic to specific areas of an image in paint.net

Tue, 11 Apr 2023 16:33:10 +0900

Here is how to apply a mosaic to specific parts of an image using paint.net.

When uploading an image to the internet, there may be times when you want to blur or pixelate a specific area. With paint.net, you can quickly edit your images.

Steps

1. Open the image you want to pixelate in paint.net

2. Use the selection tool to select the area you want to pixelate (multiple selections are possible)

Adjust the coarseness of the mosaic effect with the Cell Size. A larger value provides higher concealment.
[Downsampling] Select Multi-sampled bilinear
[Upsampling] Select Nearest neighbor

Click OK to close the dialog.

4. The mosaic effect will be applied to the image, so you can now save it.

That’s it.

How to add a border to an image using paint.net

Tue, 11 Apr 2023 14:31:59 +0900

Here is how to add a border to an image using paint.net.

Steps

1. Open the image you want to add a border to in paint.net

2. Set the secondary color (this will be the color of the border)

If the color palette is not displayed, press the F8 key on your keyboard.

If you want to set it to black, click on .

Increase the width and height by 2 pixels each. Increasing them by 2 pixels will create a 1-pixel border. If you want a 5-pixel border, increase the width and height by 10 pixels each.

Select “Middle” for the anchor, and click OK.

4. The border will be added to the image, so save the image.

That’s it.

How to Get and Place Popular Page Rankings from Google Analytics

Mon, 10 Apr 2023 20:26:57 +0900

Introduction

By using a service called Ranklet, you can easily get and place popular page rankings from Google Analytics.

In this article, I will show you how to place it on a HUGO blog.

Demo

Preparation

Google Analytics must be set up on your site.

Steps

Access Ranklet.
Click Sign in with Google and log in with your Google account (it must be linked to your Google Analytics account).

Click Allow.

Set up basic information.

I configured it as above.

In Google Analytics View, select the view from which you want to get the ranking.

Set up text replacement.

I configured it as above. This is set to remove | kenji.blog from the page title.

Set up the template.

HTML (Hid the ranking numbers)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


<div class="ranklet ranklet-reset">
 <table class="ranklet-table">
 <tbody class="ranklet-pages">
 {{#context.pages}}
 <tr class="ranklet-page">
 <td class="ranklet-image">
 {{#image}}
 <a href="{{url}}" class="ranklet-link">
 <img class="ranklet-img" src="{{image}}" />
 </a>
 {{/image}}
 </td>
 <td class="ranklet-meta">
 <div class="ranklet-title">
 <a href="{{url}}" class="ranklet-link">
 {{title}}
 </a>
 </div>
 {{#description}}
 <div class="ranklet-description">
 <a href="{{url}}" class="ranklet-link">
 {{description}}
 </a>
 </div>
 {{/description}}
 </td>
 </tr>
 {{/context.pages}}
 </tbody>
 </table>
</div>

CSS (Changed font size and set the description to be displayed in 3 lines)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


#ranklet-{{context.id}} {
 .ranklet-reset { // Reset
 table, tr, td, div, span {
 margin: 0;
 padding: 0;
 border: 0;
 font-size: 100%;
 font: inherit;
 vertical-align: baseline;
 line-height: 1;
 box-sizing: border-box;
 }
 }

 .ranklet-table {
 border-collapse: separate;
 border-spacing: 8px 24px;
 width: 100%;
 word-break: break-all;

 td {
 vertical-align: middle;
 }

 .ranklet-rank {
 text-align: center;
 font-size: 120%;
 }

 .ranklet-image {
 text-align: center;
 img {
 max-width: 128px;
 max-height: 128px;
 }
 }

 .ranklet-meta {
 .ranklet-title {
 font-size: 20px;
 line-height: 125%;
 }

 .ranklet-description {
 font-size: 16px;
 margin-top: 8px;
 line-height: 125%;
 display: -webkit-box;
 overflow: hidden;
 -webkit-box-orient: vertical;
 -webkit-line-clamp: 3; /* Number of lines */
 }
 }
 }
}

JavaScript remains unchanged.

Copy the HTML from “Publish on site”.

Copy the displayed HTML.

Paste it into the HUGO template.

Create layouts/partials/ranklet.html and paste the copied HTML.

1

<div id="ranklet-11958"></div><script src="//widget.ranklet.com/v1/ranklet/s3/widgets/11958/widget.js"></script>

Paste the following code on the line before </footer> in layouts/_default/single.html.

1

{{- partial "ranklet.html" . }}

That’s it. Now the ranking will be displayed as shown at the bottom of this page.

[By Language] Summary of Online Code Execution Environments

Sun, 09 Apr 2023 14:01:00 +0900

Python

Google Colaboratory

Google Colaboratory is an online execution environment for Python.

GPU usage is possible.
With Colab notebooks, you can combine executable code and rich text (images, HTML, LaTeX, etc.) in a single document.

It is based on Jupyter Notebook.

Rust

Rust Playground

JavaScript

Javascript Playground

Java

paiza.IO Online Java compiler

Haskell

Haskell Playground

Swift

Online Swift Playground

C++

C++ 14

Others

AWS Cloud9

An online integrated development environment provided by Amazon AWS. Tools for over 40 programming languages such as Node.js, JavaScript, Python, PHP, Ruby, Go, and C++ are pre-packaged.

Visual Studio Code for the Web

An online development environment provided by Microsoft. However, languages that require compilation cannot be executed or debugged.

paiza.IO

An online execution environment supporting 24 major languages such as C, C++, Java, Ruby, Python, PHP, Perl, etc.

CodePen

An online execution environment for HTML, CSS, and JavaScript.

codeanywhere

An online IDE. Allows code sharing and chatting.

How to Enumerate Prime Numbers Up to 1000 Using the Sieve of Eratosthenes

Sun, 09 Apr 2023 12:54:24 +0900

What is the Sieve of Eratosthenes?

The Sieve of Eratosthenes is an algorithm for finding all prime numbers up to any given limit. The algorithm is simple and can be implemented with the following steps:

Create an array of boolean values with N elements, and initialize all elements to true.
Set the 0th and 1st elements of the array to false (because 0 and 1 are not prime numbers).
If the 2nd element of the array is true, output 2 as a prime number.
Set all multiples of 2 from $2^2$ onwards in the array to false.*
If the 3rd element of the array is true, output 3 as a prime number.
Set all multiples of 3 from $3^2$ onwards in the array to false.
Repeat the same process for the 4th, 5th, …, Nth elements.

*The reason for targeting elements from the square of the number onwards to become false is because the numbers smaller than the square have already been processed (enumeration is complete).

Implementation in Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

Slightly Faster Version

Considering the following points, we implement a slightly faster version:

Instead of initializing the array with true, initialize it with false (this is faster).
Since multiples of 2 are not prime numbers, omit the process of setting the elements of multiples of 2 to false.
There is no need to loop up to n; by enumerating primes up to the square root of n, you can enumerate primes up to n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

References

Sieve of Eratosthenes

How to install CocoaPods on Mac

Sun, 09 Apr 2023 03:25:54 +0900

Install using terminal

Open the terminal
Run sudo gem install cocoapods → For some reason, an error message like the following appeared and the installation failed.

Output

1
2
3


ERROR: Error installing cocoapods:
 The last version of activesupport (>= 5.0, < 8) to support your Ruby & RubyGems was 6.1.7.3. Try installing it with `gem install activesupport -v 6.1.7.3` and then running the current command again
 activesupport requires Ruby version >= 2.7.0. The current ruby version is 2.6.10.210.

So I searched the web for the error message (see “Reference” below) and executed the following command:

1

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Output

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396


==> Checking for `sudo` access (which may request your password)...
==> This script will install:
/usr/local/bin/brew
/usr/local/share/doc/homebrew
/usr/local/share/man/man1/brew.1
/usr/local/share/zsh/site-functions/_brew
/usr/local/etc/bash_completion.d/brew
/usr/local/Homebrew
==> The following new directories will be created:
/usr/local/bin
/usr/local/etc
/usr/local/include
/usr/local/lib
/usr/local/sbin
/usr/local/share
/usr/local/var
/usr/local/opt
/usr/local/share/zsh
/usr/local/share/zsh/site-functions
/usr/local/var/homebrew
/usr/local/var/homebrew/linked
/usr/local/Cellar
/usr/local/Caskroom
/usr/local/Frameworks
==> The Xcode Command Line Tools will be installed.

Press RETURN/ENTER to continue or any other key to abort:
==> /usr/bin/sudo /bin/mkdir -p /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/sbin /usr/local/share /usr/local/var /usr/local/opt /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var/homebrew /usr/local/var/homebrew/linked /usr/local/Cellar /usr/local/Caskroom /usr/local/Frameworks
==> /usr/bin/sudo /bin/chmod ug=rwx /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/sbin /usr/local/share /usr/local/var /usr/local/opt /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var/homebrew /usr/local/var/homebrew/linked /usr/local/Cellar /usr/local/Caskroom /usr/local/Frameworks
==> /usr/bin/sudo /bin/chmod go-w /usr/local/share/zsh /usr/local/share/zsh/site-functions
==> /usr/bin/sudo /usr/sbin/chown kenji /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/sbin /usr/local/share /usr/local/var /usr/local/opt /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var/homebrew /usr/local/var/homebrew/linked /usr/local/Cellar /usr/local/Caskroom /usr/local/Frameworks
==> /usr/bin/sudo /usr/bin/chgrp admin /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/sbin /usr/local/share /usr/local/var /usr/local/opt /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var/homebrew /usr/local/var/homebrew/linked /usr/local/Cellar /usr/local/Caskroom /usr/local/Frameworks
==> /usr/bin/sudo /bin/mkdir -p /usr/local/Homebrew
==> /usr/bin/sudo /usr/sbin/chown -R kenji:admin /usr/local/Homebrew
==> /usr/bin/sudo /bin/mkdir -p /Users/kenji/Library/Caches/Homebrew
==> /usr/bin/sudo /bin/chmod g+rwx /Users/kenji/Library/Caches/Homebrew
==> /usr/bin/sudo /usr/sbin/chown -R kenji /Users/kenji/Library/Caches/Homebrew
==> Searching online for the Command Line Tools
==> /usr/bin/sudo /usr/bin/touch /tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress
==> Installing Command Line Tools for Xcode-14.3
==> /usr/bin/sudo /usr/sbin/softwareupdate -i Command\ Line\ Tools\ for\ Xcode-14.3
Software Update Tool

Finding available software

Downloading Command Line Tools for Xcode
Downloaded Command Line Tools for Xcode
Installing Command Line Tools for Xcode
Done with Command Line Tools for Xcode
Done.
==> /usr/bin/sudo /usr/bin/xcode-select --switch /Library/Developer/CommandLineTools
==> /usr/bin/sudo /bin/rm -f /tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress
==> Downloading and installing Homebrew...
remote: Enumerating objects: 236191, done.
remote: Counting objects: 100% (504/504), done.
remote: Compressing objects: 100% (327/327), done.
remote: Total 236191 (delta 176), reused 468 (delta 158), pack-reused 235687
Receiving objects: 100% (236191/236191), 68.37 MiB | 15.51 MiB/s, done.
Resolving deltas: 100% (173058/173058), done.
From https://github.com/Homebrew/brew
 * [new branch] master -> origin/master
 * [new branch] test-runners -> origin/test-runners
 * [new tag] 0.1 -> 0.1
 * [new tag] 0.2 -> 0.2
 * [new tag] 0.3 -> 0.3
 * [new tag] 0.4 -> 0.4
 * [new tag] 0.5 -> 0.5
 * [new tag] 0.6 -> 0.6
 * [new tag] 0.7 -> 0.7
 * [new tag] 0.7.1 -> 0.7.1
 * [new tag] 0.8 -> 0.8
 * [new tag] 0.8.1 -> 0.8.1
 * [new tag] 0.9 -> 0.9
 * [new tag] 0.9.1 -> 0.9.1
 * [new tag] 0.9.2 -> 0.9.2
 * [new tag] 0.9.3 -> 0.9.3
 * [new tag] 0.9.4 -> 0.9.4
 * [new tag] 0.9.5 -> 0.9.5
 * [new tag] 0.9.8 -> 0.9.8
 * [new tag] 0.9.9 -> 0.9.9
 * [new tag] 1.0.0 -> 1.0.0
 * [new tag] 1.0.1 -> 1.0.1
 * [new tag] 1.0.2 -> 1.0.2
 * [new tag] 1.0.3 -> 1.0.3
 * [new tag] 1.0.4 -> 1.0.4
 * [new tag] 1.0.5 -> 1.0.5
 * [new tag] 1.0.6 -> 1.0.6
 * [new tag] 1.0.7 -> 1.0.7
 * [new tag] 1.0.8 -> 1.0.8
 * [new tag] 1.0.9 -> 1.0.9
 * [new tag] 1.1.0 -> 1.1.0
 * [new tag] 1.1.1 -> 1.1.1
 * [new tag] 1.1.10 -> 1.1.10
 * [new tag] 1.1.11 -> 1.1.11
 * [new tag] 1.1.12 -> 1.1.12
 * [new tag] 1.1.13 -> 1.1.13
 * [new tag] 1.1.2 -> 1.1.2
 * [new tag] 1.1.3 -> 1.1.3
 * [new tag] 1.1.4 -> 1.1.4
 * [new tag] 1.1.5 -> 1.1.5
 * [new tag] 1.1.6 -> 1.1.6
 * [new tag] 1.1.7 -> 1.1.7
 * [new tag] 1.1.8 -> 1.1.8
 * [new tag] 1.1.9 -> 1.1.9
 * [new tag] 1.2.0 -> 1.2.0
 * [new tag] 1.2.1 -> 1.2.1
 * [new tag] 1.2.2 -> 1.2.2
 * [new tag] 1.2.3 -> 1.2.3
 * [new tag] 1.2.4 -> 1.2.4
 * [new tag] 1.2.5 -> 1.2.5
 * [new tag] 1.2.6 -> 1.2.6
 * [new tag] 1.3.0 -> 1.3.0
 * [new tag] 1.3.1 -> 1.3.1
 * [new tag] 1.3.2 -> 1.3.2
 * [new tag] 1.3.3 -> 1.3.3
 * [new tag] 1.3.4 -> 1.3.4
 * [new tag] 1.3.5 -> 1.3.5
 * [new tag] 1.3.6 -> 1.3.6
 * [new tag] 1.3.7 -> 1.3.7
 * [new tag] 1.3.8 -> 1.3.8
 * [new tag] 1.3.9 -> 1.3.9
 * [new tag] 1.4.0 -> 1.4.0
 * [new tag] 1.4.1 -> 1.4.1
 * [new tag] 1.4.2 -> 1.4.2
 * [new tag] 1.4.3 -> 1.4.3
 * [new tag] 1.5.0 -> 1.5.0
 * [new tag] 1.5.1 -> 1.5.1
 * [new tag] 1.5.10 -> 1.5.10
 * [new tag] 1.5.11 -> 1.5.11
 * [new tag] 1.5.12 -> 1.5.12
 * [new tag] 1.5.13 -> 1.5.13
 * [new tag] 1.5.14 -> 1.5.14
 * [new tag] 1.5.2 -> 1.5.2
 * [new tag] 1.5.3 -> 1.5.3
 * [new tag] 1.5.4 -> 1.5.4
 * [new tag] 1.5.5 -> 1.5.5
 * [new tag] 1.5.6 -> 1.5.6
 * [new tag] 1.5.7 -> 1.5.7
 * [new tag] 1.5.8 -> 1.5.8
 * [new tag] 1.5.9 -> 1.5.9
 * [new tag] 1.6.0 -> 1.6.0
 * [new tag] 1.6.1 -> 1.6.1
 * [new tag] 1.6.10 -> 1.6.10
 * [new tag] 1.6.11 -> 1.6.11
 * [new tag] 1.6.12 -> 1.6.12
 * [new tag] 1.6.13 -> 1.6.13
 * [new tag] 1.6.14 -> 1.6.14
 * [new tag] 1.6.15 -> 1.6.15
 * [new tag] 1.6.16 -> 1.6.16
 * [new tag] 1.6.17 -> 1.6.17
 * [new tag] 1.6.2 -> 1.6.2
 * [new tag] 1.6.3 -> 1.6.3
 * [new tag] 1.6.4 -> 1.6.4
 * [new tag] 1.6.5 -> 1.6.5
 * [new tag] 1.6.6 -> 1.6.6
 * [new tag] 1.6.7 -> 1.6.7
 * [new tag] 1.6.8 -> 1.6.8
 * [new tag] 1.6.9 -> 1.6.9
 * [new tag] 1.7.0 -> 1.7.0
 * [new tag] 1.7.1 -> 1.7.1
 * [new tag] 1.7.2 -> 1.7.2
 * [new tag] 1.7.3 -> 1.7.3
 * [new tag] 1.7.4 -> 1.7.4
 * [new tag] 1.7.5 -> 1.7.5
 * [new tag] 1.7.6 -> 1.7.6
 * [new tag] 1.7.7 -> 1.7.7
 * [new tag] 1.8.0 -> 1.8.0
 * [new tag] 1.8.1 -> 1.8.1
 * [new tag] 1.8.2 -> 1.8.2
 * [new tag] 1.8.3 -> 1.8.3
 * [new tag] 1.8.4 -> 1.8.4
 * [new tag] 1.8.5 -> 1.8.5
 * [new tag] 1.8.6 -> 1.8.6
 * [new tag] 1.9.0 -> 1.9.0
 * [new tag] 1.9.1 -> 1.9.1
 * [new tag] 1.9.2 -> 1.9.2
 * [new tag] 1.9.3 -> 1.9.3
 * [new tag] 2.0.0 -> 2.0.0
 * [new tag] 2.0.1 -> 2.0.1
 * [new tag] 2.0.2 -> 2.0.2
 * [new tag] 2.0.3 -> 2.0.3
 * [new tag] 2.0.4 -> 2.0.4
 * [new tag] 2.0.5 -> 2.0.5
 * [new tag] 2.0.6 -> 2.0.6
 * [new tag] 2.1.0 -> 2.1.0
 * [new tag] 2.1.1 -> 2.1.1
 * [new tag] 2.1.10 -> 2.1.10
 * [new tag] 2.1.11 -> 2.1.11
 * [new tag] 2.1.12 -> 2.1.12
 * [new tag] 2.1.13 -> 2.1.13
 * [new tag] 2.1.14 -> 2.1.14
 * [new tag] 2.1.15 -> 2.1.15
 * [new tag] 2.1.16 -> 2.1.16
 * [new tag] 2.1.2 -> 2.1.2
 * [new tag] 2.1.3 -> 2.1.3
 * [new tag] 2.1.4 -> 2.1.4
 * [new tag] 2.1.5 -> 2.1.5
 * [new tag] 2.1.6 -> 2.1.6
 * [new tag] 2.1.7 -> 2.1.7
 * [new tag] 2.1.8 -> 2.1.8
 * [new tag] 2.1.9 -> 2.1.9
 * [new tag] 2.2.0 -> 2.2.0
 * [new tag] 2.2.1 -> 2.2.1
 * [new tag] 2.2.10 -> 2.2.10
 * [new tag] 2.2.11 -> 2.2.11
 * [new tag] 2.2.12 -> 2.2.12
 * [new tag] 2.2.13 -> 2.2.13
 * [new tag] 2.2.14 -> 2.2.14
 * [new tag] 2.2.15 -> 2.2.15
 * [new tag] 2.2.16 -> 2.2.16
 * [new tag] 2.2.17 -> 2.2.17
 * [new tag] 2.2.2 -> 2.2.2
 * [new tag] 2.2.3 -> 2.2.3
 * [new tag] 2.2.4 -> 2.2.4
 * [new tag] 2.2.5 -> 2.2.5
 * [new tag] 2.2.6 -> 2.2.6
 * [new tag] 2.2.7 -> 2.2.7
 * [new tag] 2.2.8 -> 2.2.8
 * [new tag] 2.2.9 -> 2.2.9
 * [new tag] 2.3.0 -> 2.3.0
 * [new tag] 2.4.0 -> 2.4.0
 * [new tag] 2.4.1 -> 2.4.1
 * [new tag] 2.4.10 -> 2.4.10
 * [new tag] 2.4.11 -> 2.4.11
 * [new tag] 2.4.12 -> 2.4.12
 * [new tag] 2.4.13 -> 2.4.13
 * [new tag] 2.4.14 -> 2.4.14
 * [new tag] 2.4.15 -> 2.4.15
 * [new tag] 2.4.16 -> 2.4.16
 * [new tag] 2.4.2 -> 2.4.2
 * [new tag] 2.4.3 -> 2.4.3
 * [new tag] 2.4.4 -> 2.4.4
 * [new tag] 2.4.5 -> 2.4.5
 * [new tag] 2.4.6 -> 2.4.6
 * [new tag] 2.4.7 -> 2.4.7
 * [new tag] 2.4.8 -> 2.4.8
 * [new tag] 2.4.9 -> 2.4.9
 * [new tag] 2.5.0 -> 2.5.0
 * [new tag] 2.5.1 -> 2.5.1
 * [new tag] 2.5.10 -> 2.5.10
 * [new tag] 2.5.11 -> 2.5.11
 * [new tag] 2.5.12 -> 2.5.12
 * [new tag] 2.5.2 -> 2.5.2
 * [new tag] 2.5.3 -> 2.5.3
 * [new tag] 2.5.4 -> 2.5.4
 * [new tag] 2.5.5 -> 2.5.5
 * [new tag] 2.5.6 -> 2.5.6
 * [new tag] 2.5.7 -> 2.5.7
 * [new tag] 2.5.8 -> 2.5.8
 * [new tag] 2.5.9 -> 2.5.9
 * [new tag] 2.6.0 -> 2.6.0
 * [new tag] 2.6.1 -> 2.6.1
 * [new tag] 2.6.2 -> 2.6.2
 * [new tag] 2.7.0 -> 2.7.0
 * [new tag] 2.7.1 -> 2.7.1
 * [new tag] 2.7.2 -> 2.7.2
 * [new tag] 2.7.3 -> 2.7.3
 * [new tag] 2.7.4 -> 2.7.4
 * [new tag] 2.7.5 -> 2.7.5
 * [new tag] 2.7.6 -> 2.7.6
 * [new tag] 2.7.7 -> 2.7.7
 * [new tag] 3.0.0 -> 3.0.0
 * [new tag] 3.0.1 -> 3.0.1
 * [new tag] 3.0.10 -> 3.0.10
 * [new tag] 3.0.11 -> 3.0.11
 * [new tag] 3.0.2 -> 3.0.2
 * [new tag] 3.0.3 -> 3.0.3
 * [new tag] 3.0.4 -> 3.0.4
 * [new tag] 3.0.5 -> 3.0.5
 * [new tag] 3.0.6 -> 3.0.6
 * [new tag] 3.0.7 -> 3.0.7
 * [new tag] 3.0.8 -> 3.0.8
 * [new tag] 3.0.9 -> 3.0.9
 * [new tag] 3.1.0 -> 3.1.0
 * [new tag] 3.1.1 -> 3.1.1
 * [new tag] 3.1.10 -> 3.1.10
 * [new tag] 3.1.11 -> 3.1.11
 * [new tag] 3.1.12 -> 3.1.12
 * [new tag] 3.1.2 -> 3.1.2
 * [new tag] 3.1.3 -> 3.1.3
 * [new tag] 3.1.4 -> 3.1.4
 * [new tag] 3.1.5 -> 3.1.5
 * [new tag] 3.1.6 -> 3.1.6
 * [new tag] 3.1.7 -> 3.1.7
 * [new tag] 3.1.8 -> 3.1.8
 * [new tag] 3.1.9 -> 3.1.9
 * [new tag] 3.2.0 -> 3.2.0
 * [new tag] 3.2.1 -> 3.2.1
 * [new tag] 3.2.10 -> 3.2.10
 * [new tag] 3.2.11 -> 3.2.11
 * [new tag] 3.2.12 -> 3.2.12
 * [new tag] 3.2.13 -> 3.2.13
 * [new tag] 3.2.14 -> 3.2.14
 * [new tag] 3.2.15 -> 3.2.15
 * [new tag] 3.2.16 -> 3.2.16
 * [new tag] 3.2.17 -> 3.2.17
 * [new tag] 3.2.2 -> 3.2.2
 * [new tag] 3.2.3 -> 3.2.3
 * [new tag] 3.2.4 -> 3.2.4
 * [new tag] 3.2.5 -> 3.2.5
 * [new tag] 3.2.6 -> 3.2.6
 * [new tag] 3.2.7 -> 3.2.7
 * [new tag] 3.2.8 -> 3.2.8
 * [new tag] 3.2.9 -> 3.2.9
 * [new tag] 3.3.0 -> 3.3.0
 * [new tag] 3.3.1 -> 3.3.1
 * [new tag] 3.3.10 -> 3.3.10
 * [new tag] 3.3.11 -> 3.3.11
 * [new tag] 3.3.12 -> 3.3.12
 * [new tag] 3.3.13 -> 3.3.13
 * [new tag] 3.3.14 -> 3.3.14
 * [new tag] 3.3.15 -> 3.3.15
 * [new tag] 3.3.16 -> 3.3.16
 * [new tag] 3.3.2 -> 3.3.2
 * [new tag] 3.3.3 -> 3.3.3
 * [new tag] 3.3.4 -> 3.3.4
 * [new tag] 3.3.5 -> 3.3.5
 * [new tag] 3.3.6 -> 3.3.6
 * [new tag] 3.3.7 -> 3.3.7
 * [new tag] 3.3.8 -> 3.3.8
 * [new tag] 3.3.9 -> 3.3.9
 * [new tag] 3.4.0 -> 3.4.0
 * [new tag] 3.4.1 -> 3.4.1
 * [new tag] 3.4.10 -> 3.4.10
 * [new tag] 3.4.11 -> 3.4.11
 * [new tag] 3.4.2 -> 3.4.2
 * [new tag] 3.4.3 -> 3.4.3
 * [new tag] 3.4.4 -> 3.4.4
 * [new tag] 3.4.5 -> 3.4.5
 * [new tag] 3.4.6 -> 3.4.6
 * [new tag] 3.4.7 -> 3.4.7
 * [new tag] 3.4.8 -> 3.4.8
 * [new tag] 3.4.9 -> 3.4.9
 * [new tag] 3.5.0 -> 3.5.0
 * [new tag] 3.5.1 -> 3.5.1
 * [new tag] 3.5.10 -> 3.5.10
 * [new tag] 3.5.2 -> 3.5.2
 * [new tag] 3.5.3 -> 3.5.3
 * [new tag] 3.5.4 -> 3.5.4
 * [new tag] 3.5.5 -> 3.5.5
 * [new tag] 3.5.6 -> 3.5.6
 * [new tag] 3.5.7 -> 3.5.7
 * [new tag] 3.5.8 -> 3.5.8
 * [new tag] 3.5.9 -> 3.5.9
 * [new tag] 3.6.0 -> 3.6.0
 * [new tag] 3.6.1 -> 3.6.1
 * [new tag] 3.6.10 -> 3.6.10
 * [new tag] 3.6.11 -> 3.6.11
 * [new tag] 3.6.12 -> 3.6.12
 * [new tag] 3.6.13 -> 3.6.13
 * [new tag] 3.6.14 -> 3.6.14
 * [new tag] 3.6.15 -> 3.6.15
 * [new tag] 3.6.16 -> 3.6.16
 * [new tag] 3.6.17 -> 3.6.17
 * [new tag] 3.6.18 -> 3.6.18
 * [new tag] 3.6.19 -> 3.6.19
 * [new tag] 3.6.2 -> 3.6.2
 * [new tag] 3.6.20 -> 3.6.20
 * [new tag] 3.6.21 -> 3.6.21
 * [new tag] 3.6.3 -> 3.6.3
 * [new tag] 3.6.4 -> 3.6.4
 * [new tag] 3.6.5 -> 3.6.5
 * [new tag] 3.6.6 -> 3.6.6
 * [new tag] 3.6.7 -> 3.6.7
 * [new tag] 3.6.8 -> 3.6.8
 * [new tag] 3.6.9 -> 3.6.9
 * [new tag] 4.0.0 -> 4.0.0
 * [new tag] 4.0.1 -> 4.0.1
 * [new tag] 4.0.10 -> 4.0.10
 * [new tag] 4.0.11 -> 4.0.11
 * [new tag] 4.0.2 -> 4.0.2
 * [new tag] 4.0.3 -> 4.0.3
 * [new tag] 4.0.4 -> 4.0.4
 * [new tag] 4.0.5 -> 4.0.5
 * [new tag] 4.0.6 -> 4.0.6
 * [new tag] 4.0.7 -> 4.0.7
 * [new tag] 4.0.8 -> 4.0.8
 * [new tag] 4.0.9 -> 4.0.9
HEAD is now at c51687009 Merge pull request #15168 from reitermarkus/api-ruby-source-path
==> Installation successful!

==> Homebrew has enabled anonymous aggregate formulae and cask analytics.
Read the analytics documentation (and how to opt-out) here:
 https://docs.brew.sh/Analytics
No analytics data has been sent yet (nor will any be during this install run).

==> Homebrew is run entirely by unpaid volunteers. Please consider donating:
 https://github.com/Homebrew/brew#donations

==> Next steps:
- Run these two commands in your terminal to add Homebrew to your PATH:
 (echo; echo 'eval "$(/usr/local/bin/brew shellenv)"') >> /Users/kenji/.zprofile
 eval "$(/usr/local/bin/brew shellenv)"
- Run brew help to get started
- Further documentation:
 https://docs.brew.sh

Run brew install cocoapods

Output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


Warning: Treating cocoapods as a formula. For the cask, use homebrew/cask/cocoapods
==> Fetching dependencies for cocoapods: libyaml, ca-certificates, openssl@1.1, readline and ruby
==> Fetching libyaml
==> Downloading https://ghcr.io/v2/homebrew/core/libyaml/manifests/0.2.5
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/libyaml/blobs/sha256:b49e62f014
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sh
######################################################################## 100.0%
==> Fetching ca-certificates
==> Downloading https://ghcr.io/v2/homebrew/core/ca-certificates/manifests/2023-
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/ca-certificates/blobs/sha256:11
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sh
######################################################################## 100.0%
==> Fetching openssl@1.1
==> Downloading https://ghcr.io/v2/homebrew/core/openssl/1.1/manifests/1.1.1t
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/openssl/1.1/blobs/sha256:97676d
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sh
######################################################################## 100.0%
==> Fetching readline
==> Downloading https://ghcr.io/v2/homebrew/core/readline/manifests/8.2.1
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/readline/blobs/sha256:abe9d3f3e
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sh
######################################################################## 100.0%
==> Fetching ruby
==> Downloading https://ghcr.io/v2/homebrew/core/ruby/manifests/3.2.2
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/ruby/blobs/sha256:a4ac080688e87
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sh
######################################################################## 100.0%
==> Fetching cocoapods
==> Downloading https://ghcr.io/v2/homebrew/core/cocoapods/manifests/1.12.0
######################################################################## 100.0%
==> Downloading https://ghcr.io/v2/homebrew/core/cocoapods/blobs/sha256:11226288
==> Downloading from https://pkg-containers.githubusercontent.com/ghcr1/blobs/sh
######################################################################## 100.0%
==> Installing dependencies for cocoapods: libyaml, ca-certificates, openssl@1.1, readline and ruby
==> Installing cocoapods dependency: libyaml
==> Pouring libyaml--0.2.5.ventura.bottle.tar.gz
🍺 /usr/local/Cellar/libyaml/0.2.5: 10 files, 330KB
==> Installing cocoapods dependency: ca-certificates
==> Pouring ca-certificates--2023-01-10.all.bottle.tar.gz
==> Regenerating CA certificate bundle from keychain, this may take a while...
🍺 /usr/local/Cellar/ca-certificates/2023-01-10: 3 files, 216.9KB
==> Installing cocoapods dependency: openssl@1.1
==> Pouring openssl@1.1--1.1.1t.ventura.bottle.tar.gz
🍺 /usr/local/Cellar/openssl@1.1/1.1.1t: 8,101 files, 18.5MB
==> Installing cocoapods dependency: readline
==> Pouring readline--8.2.1.ventura.bottle.tar.gz
🍺 /usr/local/Cellar/readline/8.2.1: 50 files, 1.7MB
==> Installing cocoapods dependency: ruby
==> Pouring ruby--3.2.2.ventura.bottle.tar.gz
🍺 /usr/local/Cellar/ruby/3.2.2: 16,605 files, 46.3MB
==> Installing cocoapods
==> Pouring cocoapods--1.12.0.ventura.bottle.tar.gz
🍺 /usr/local/Cellar/cocoapods/1.12.0: 13,436 files, 27.8MB
==> Running `brew cleanup cocoapods`...
Disable this behaviour by setting HOMEBREW_NO_INSTALL_CLEANUP.
Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`).

Run pod --version

Output

1

1.12.0

It seems to have been installed successfully for now.

Reference

Installing “CocoaPods”

How to Get the Daily Record Creation Count Using SOQL in Salesforce

Sun, 09 Apr 2023 02:50:30 +0900

How to Get the Daily Record Creation Count Using SOQL in Salesforce

Open the Developer Console.
Open the Query Editor tab.
Paste and execute the following SOQL query.

1

select day_only(createdDate), count(createdDate) from account group by day_only(createdDate) order by count(createdDate) desc limit 10

Change account to the name of any object you want to query before executing.

Reference

Is there a way to group by the date portion of a datetime field in SOQL?

How to draw graphs using Python (matplotlib.pyplot)

Sun, 09 Apr 2023 01:02:19 +0900

Requirements

Google Account

Steps

Access https://colab.research.google.com/
Select “File” -> “New notebook”
Paste and run the following code

1
2
3
4
5
6
7


import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 500)
plt.plot(x, np.sin(x), label="sin curve")
plt.plot(x, np.cos(x), label="cos curve")
plt.legend() # Show legend
plt.show()

Execution Result

References

matplotlib.pyplot — Matplotlib 3.5.3 documentation

How to Tweet Using Twitter API and Google Colaboratory

Sat, 08 Apr 2023 18:48:32 +0900

Requirements

Twitter API
Twitter API SECRET
Twitter ACCESS TOKEN
Twitter ACCESS TOKEN SECRET
Google Account

For instructions on how to obtain the Twitter API, please refer to the reference sites.

Steps to Tweet using API

Access https://colab.research.google.com/
Select “File” -> “New notebook”
Paste and run the following code (use your own obtained values)

1
2
3
4


API_KEY = '9Smu2f2RoLqbVQHQq6n79Z2JW'
API_SECRET = 'uGVRIkLL2l8sRyPv2Lr4mXxXppnQF1isMoRnvktcXCtFgAK2R8'
ACCESS_TOKEN = '0367292979164670705-7hSErDoQbO6fkFtnn5UY0vqpvecy0O'
ACCESS_TOKEN_SECRET = 'pUv81U9GVzZirz5g4AxZPHAJ4GpSXnBo8GUcZ1egtjw9q'

Paste and run the following code

1

import tweepy

Paste and run the following code (API v1.1)

1
2
3
4


auth = tweepy.OAuthHandler(API_KEY, API_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = tweepy.API(auth)
api.update_status("hello")

→ A tweet saying hello will be posted

Paste and run the following code (API v2.0)

1
2


client = tweepy.Client(consumer_key=API_KEY, consumer_secret=API_SECRET, access_token=ACCESS_TOKEN, access_token_secret=ACCESS_TOKEN_SECRET)
client.create_tweet(text='hello v2')

→ A tweet saying hello v2 will be posted

That’s all

References

How to build OpenSSL on Windows

Fri, 07 Apr 2023 21:06:32 +0900

What is OpenSSL?

It is an open-source library that provides the processing necessary for encrypted communication.

To use it from a program, since the C language source code is public, you need to build it and create a library.

Below, we will introduce the build procedure.

Preparing the build environment

Perl

Download strawberry-perl-5.32.1.1-64bit.msi from https://strawberryperl.com/. The latest version should be fine.
NASM

Download 2.16.01/nasm-2.16.01-win64.zip from Download at https://www.nasm.us/. The latest non-rc version should be fine. After installation, you need to add the folder where NASM was installed to the environment variable PATH.
Visual Studio 2022 ** or ** Build Tools for Visual Studio 2022

Install Visual Studio 2022 Community or Build Tools for Visual Studio 2022 from https://visualstudio.microsoft.com/ja/downloads/.

OpenSSL build procedure on Windows

Download and extract openssl-3.1.0.tar.gz from https://www.openssl.org/source/. If you cannot extract it, execute tar -xzf openssl-3.1.0.tar.gz in the command prompt.
Launch the command prompt with administrator privileges.
Open the extracted folder.
Execute the following command *Change the Community part according to the version of Visual Studio you installed

1

"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

Execute the following command

1

perl Configure VC-WIN64A

Execute the following command (takes a considerable amount of time)

1

nmake

Execute the following command (takes a considerable amount of time)

1

nmake test

Execute the following command

1

nmake install

If successful, OpenSSL will be installed in C:\Program Files\OpenSSL.

That is all.

Reference

https://ja.wikipedia.org/wiki/OpenSSL

What is i18n?

Fri, 07 Apr 2023 00:42:02 +0900

What is i18n?

i18n is an abbreviation for Internationalization. Since Internationalization is long, it is abbreviated as i18n because there are 18 letters between the first i and the last n.

It is often used in the context of internationalizing software.

The main target items in internationalization include the following: ¹

Character sets (standard character codes, etc.)
Text direction (left to right, right to left, top to bottom towards the left, etc.)
Text / Wording
Fonts
Formatting
- Numbers (decimal point characters, thousands separator characters, number of digits to group by, etc.)
- Date and time (how to format year, month, and day; differences in calendars used such as Islamic/Gregorian/Hebrew/Japanese calendars, etc.)
Time difference in date and time information
Currency information

Internationalization and localization - Wikipedia ↩︎

How to make a presentation with HTML (reveal.js)

Thu, 06 Apr 2023 23:23:46 +0900

How to make a presentation with HTML

reveal.js is a presentation creation tool using HTML and Markdown, with the following features:

A variety of presentation features such as mathematical formulas, animations, and swipe operations
Customizable themes and layouts
Navigation features compatible with multiple devices such as mice, keyboards, and touchpads
Advanced features such as automatic slide playback and video embedding
Can be exported in PDF format

With these features, users can easily create interactive and engaging presentations.

How to install and use reveal.js

The easiest way to use it is to download the entire ZIP from the following page and extract it.

Open https://revealjs.com/installation and download master.zip from the link
Open index.html in the extracted folder in a browser
Rewrite index.html to create your own presentation

You can use demo.html as a reference since it contains HTML code for a demo.

Use Cases

The presentations you create can be published as web pages as is, or exported as PDFs. Also, since the source of the presentation is text, it is easy to manage it with a version control system.

It seems you can also create presentations in Markdown format.

References

How to generate illustration images using AI (Stable Diffusion)

Thu, 06 Apr 2023 00:43:19 +0900

What is Stable Diffusion?

Stable diffusion is an AI developed by a research team at the University of Munich in Germany that generates images from inputted text information. By training on various images, it is possible to generate a wide variety of images, from photorealistic ones to illustrations.

This time, I will introduce how to generate illustration images using the pre-trained data of Stable diffusion.

What you need

Google Account

That’s all.

Generation steps

Open https://colab.research.google.com
Select File on the top left and choose New notebook
Select Edit and choose Notebook settings
Change the Hardware accelerator to GPU
Paste and execute the following code

1

!pip install diffusers==0.8.0 transformers

Paste and execute the following code

1

from diffusers import StableDiffusionPipeline

Paste and execute the following code

1
2


pipe = StableDiffusionPipeline.from_pretrained("gsdf/Counterfeit-V2.5")
pipe.to("cuda")

Paste and execute the following code

1
2
3
4
5


prompt = "((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field"
n_prompt = "EasyNegative, extra fingers,fewer fingers"

image = pipe(prompt, negative_prompt = n_prompt).images[0]
image

The Prompt used here is based on the Prompt at https://huggingface.co/gsdf/Counterfeit-V2.5.

Generation results (some)

References

Tools to Analyze the Contents of Executable Files (exe)

Wed, 05 Apr 2023 23:31:06 +0900

What is an Executable File (exe)

A file that can be executed on Windows. Basically, it is written in a format called PE format. It contains machine code to execute, as well as resources such as icons and images.

Since there are several tools to analyze executable files, I will introduce them here.

7-Zip

EXE files are sometimes compressed because their size tends to be large otherwise. In this case, by using the file compression and decompression software 7-Zip, you can extract the executable file and examine its contents. WinRAR is another tool that can extract them similarly.

Resource Hacker

It allows you to extract resources (icons, bitmaps, dialog boxes, strings, etc.) inside an EXE file. Additionally, since it functions as a binary editor, you can edit and rewrite the contents of an EXE file.

PE Explorer

It can analyze PE files (EXE, DLL, OCX, SYS, drivers) for Windows. PE Explorer provides various analysis features, such as displaying the file structure, file headers, directory entries, and exported functions and symbols.

Dependency Walker

You can investigate the DLL files that an EXE file depends on and verify whether they are loaded correctly. You can also trace the function calls of DLL files.

Ghidra

This is a powerful reverse engineering tool developed by the NSA (National Security Agency) and released for free as open source. It is highly popular because it not only disassembles EXE files (converts them to assembly language) but also has decompilation capabilities to convert them into a form close to C language.

IDA Free / IDA Pro

These are high-performance disassemblers and decompilers that have become a global industry standard in malware analysis and reverse engineering. The Pro version is very expensive, but you can use the functionally restricted version “IDA Free” for free for personal or non-commercial purposes.

x64dbg (x32dbg)

An open source debugger for Windows. It specializes in “dynamic analysis,” which involves analyzing the internal state and memory step-by-step while running the executable file. It is commonly used for solving crackmes (challenge programs for analysis) and investigating malware behavior.

ILSpy / dotPeek

If the target EXE file is created in a .NET language such as C#, using these tools allows you to decompile (reverse compile) it into almost the exact same state as the original source code, completely exposing its contents.

These tools are useful for examining the contents of EXE files, but caution is required. Modifying files or using them for unauthorized purposes can cause copyright and security issues, so please ensure you fully understand this before using them.

How to switch applications like Windows (Alt+Tab) on a Mac

Wed, 05 Apr 2023 02:20:12 +0900

Introduction

I will introduce how to switch applications on a Mac in a Windows-like manner (using Alt+Tab).

Since this is difficult to achieve by changing standard settings, this method involves installing an application.

In action

How to setup (macOS Ventura)

Open https://alt-tab-macos.netlify.app
Click Download the latest release
Open the downloaded application
Follow the instructions to install

Now, you can switch applications using Alt+Tab just like on Windows.

That’s all.

How to Match Mac Copy and Paste Shortcut Keys with Windows

Wed, 05 Apr 2023 00:49:02 +0900

Introduction

When switching between Windows and Mac, the frequently used keyboard shortcuts like copy, paste, and undo are different. This post introduces a method to match them.

Setup Method (macOS Ventura)

Open System Settings
Select Keyboard
Select Keyboard Shortcuts
Select Modifier Keys
Assign the Control(^) key to “⌘ Command”
Assign the Command(⌘) key to “^ Control”
Click Done

That’s all.

How to change the shortcut key for switching between Japanese and English input on Mac

Tue, 04 Apr 2023 23:02:12 +0900

Introduction

I use a US keyboard, and on Windows, I switch Japanese input with Alt + `. I wanted to use the same key to switch on Mac, and when I looked it up, I found that it can be changed in the settings.

How to configure (macOS Ventura)

Open System Settings
Select Keyboard
Select Keyboard Shortcuts
Select Input Sources
Double-click the shortcut notation on the right side of “Select next source in Input menu”
Press Alt + `
Click Done

Now you can switch between English and Japanese with Alt + `. However, by default, Katakana is included in the input switching cycle, so I removed Katakana from the input sources using the steps below.

Open System Settings
Select Keyboard
Click Edit on the right side of Japanese - Romaji in Text Input
Click Japanese - Romaji
Uncheck Katakana in the Input mode
Click Done

That’s all.

How to find the location of an executable in Windows

Mon, 03 Apr 2023 00:02:55 +0900

How to find the location of an executable in Windows

Sometimes when you execute a command by specifying an executable file, you want to know where that executable file is located. In such cases, you can find the location of the executable file using the following command.

1

where <executable_file_name>

For example, if you want to know the location of Paint (mspaint.exe), you can do it as follows.

1

where mspaint.exe

References

How do I find the location of an executable in Windows?

Purchased a mac mini (2018)

Sun, 02 Apr 2023 18:05:30 +0900

Purchased a mac mini (2018)

I bought an older used mac mini (2018) on Mercari. The specs are below.

CPU: 3.2GHz 6-Core Intel Core i7
Memory: 32GB
Storage: 1TB SSD

The price was 77,000 JPY

Reason for purchase

I use a mac mini with almost the same specs at work for smartphone app development, but I wanted to set up a development environment at home as well (especially for running Xcode).
I have a macbook pro, but it’s 9 years old and runs very slowly, so I hardly use it.
I wanted to develop iOS apps personally.

Immediately installed Xcode and IntelliJ IDEA

The Xcode version is 14.3 (14E222b)

The IntelliJ IDEA version is 2023.1

Let’s get to developing!

About the Stock Photo Site "Unsplash" for Blogs

Sun, 02 Apr 2023 14:44:17 +0900

About “Unsplash”

https://unsplash.com/

To summarize, the stock photo site “Unsplash” has the following features:

All images can be used for free
Commercial use is allowed
Image modification is allowed
No permission required
No attribution required

It is very easy to use when writing articles for a blog, so please give it a try.

For information about the license, please refer to the footnote below.¹

I will also be utilizing it on this site.

Unsplash License ↩︎

How to Display Japanese in egui

Sat, 01 Apr 2023 03:17:52 +0900

Get the egui sample

You can run the egui sample using the following commands:

1
2
3


git clone https://github.com/emilk/eframe_template/ egui_test
cd egui_test
cargo run

Load a Japanese-compatible font

To display Japanese, you need to load a Japanese-compatible font.

Add the following lines inside the pub fn new method in src/app.rs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Load a Japanese-compatible font
let mut fonts = egui::FontDefinitions::default();
fonts.font_data.insert(
 "Meiryo".to_owned(),
 egui::FontData::from_static(include_bytes!("C:/Windows/Fonts/Meiryo.ttc")),
);
fonts
 .families
 .entry(egui::FontFamily::Proportional)
 .or_default()
 .insert(0, "Meiryo".to_owned());
cc.egui_ctx.set_fonts(fonts);

Now you can display Japanese.

How to enable KaTeX (LaTeX-style math formulas) in Hugo

Fri, 31 Mar 2023 23:11:26 +0900

What is KaTeX

KaTeX is a JavaScript library for displaying LaTeX-style mathematical formulas in HTML.

Specifically, it can display formulas like the following:

$$f(x) = x^2 + x + 41$$

There seem to be other LaTeX-style math rendering libraries, but KaTeX is known for being simple and fast.

How to introduce it to Hugo

Create a new layouts/partials/math.html in your Hugo folder hierarchy.

Make the contents as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css" integrity="sha384-vKruj+a13U8yHIkAyGgK1J3ArTLzrFGBbBc0tDp4ad/EyewESeXE/Iv67Aj8gKZ0" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js" integrity="sha384-PwRUT/YqbnEjkZO0zZxNqcxACrXe+j766U2amXcgMg5457rve2Y7I6ZJSm2A0mS4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(
 document.body,
 {
 delimiters: [
 {left: "$$", right: "$$", display: true},
 {left: "\\[", right: "\\]", display: true},
 {left: "$", right: "$", display: false},
 {left: "\\(", right: "\\)", display: false}
 ]
 });
 });
</script>

Next, add the following code to the existing file layouts/partials/extend_head.html.

1
2
3


{{ if or .Params.math .Site.Params.math }}
{{ partial "math.html" . }}
{{ end }}

Now you are ready to use KaTeX.

You can enable KaTeX by adding math: true to the front matter of a page.

All you have to do is write formulas in LaTeX style in the body of the page article.

1

$$ e^{i \pi} = -1 $$

If you describe it as above, it will be displayed as follows:

$$ e^{i \pi} = -1 $$

References

Recommended Business Books

Sun, 19 Mar 2023 18:13:14 +0900

How to Win Friends and Influence People

https://amzn.to/3YTv0Dr

The Courage to Be Disliked

https://amzn.to/3n3SVCQ

The 100-Year Life: Living and Working in an Age of Longevity

https://amzn.to/3TtKUDf

The 7 Habits of Highly Effective People

https://amzn.to/3TqfjSO

Recommended Chrome Extensions

Sun, 19 Mar 2023 02:54:30 +0900

Recommended Chrome Extensions

I would like to introduce the Chrome extensions I am currently using. Although they are for Chrome, they can also be used in Microsoft Edge.

1. simpleGestures

An extension that enables the use of mouse gestures. It allows you to control the browser without using the keyboard or aiming for toolbar buttons.

For example, sliding the mouse to the left while holding down the right mouse button goes back, and sliding the mouse to the right while holding down the right mouse button goes forward.

This is also highly reliable because it is open source.

2. uBlock Origin

An extension that blocks advertisements. Highly reliable because it is open source. It also operates comfortably with low CPU and memory usage.

3. DeepL Translation

A Chrome extension that allows you to translate pages using the world-famous translation service DeepL. When you select the text you want to translate on the browser, the DeepL icon appears, and clicking it automatically translates the text.

DeepL Translator

An extension that allows you to use ChatGPT in a sidebar. You can display the sidebar with Ctrl+P and immediately ask the AI questions. If there is a selected text string in the page, it will be copied directly into the question text, so you can ask a question immediately with Ctrl+Enter.

ChatGPT Sidebar

5. Salesforce DevTools

An extension that adds useful features for Salesforce development. I think this is unnecessary for those who do not use Salesforce.

Salesforce DevTools

How to update rustc

Sat, 18 Mar 2023 10:27:02 +0900

How to update rustc

Just execute the following single line command.

1

rustup update

Output Reference

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


rustup update
info: syncing channel updates for 'stable-x86_64-pc-windows-msvc'
warning: Signature verification failed for 'https://static.rust-lang.org/dist/channel-rust-stable.toml'
info: latest update on 2023-03-09, rust version 1.68.0 (2c8cc3432 2023-03-06)
info: downloading component 'rust-src'
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
info: downloading component 'rust-std'
info: downloading component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 37.5 MiB/s in 1s ETA: 0s
info: downloading component 'rustfmt'
info: removing previous version of component 'rust-src'
info: removing previous version of component 'cargo'
info: removing previous version of component 'clippy'
info: removing previous version of component 'rust-docs'
info: removing previous version of component 'rust-std'
info: removing previous version of component 'rustc'
info: removing previous version of component 'rustfmt'
info: installing component 'rust-src'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 19.4 MiB / 19.4 MiB (100 %) 2.4 MiB/s in 6s ETA: 0s
info: installing component 'rust-std'
 27.6 MiB / 27.6 MiB (100 %) 12.7 MiB/s in 2s ETA: 0s
info: installing component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 13.8 MiB/s in 4s ETA: 0s
info: installing component 'rustfmt'
info: checking for self-updates
info: downloading self-update

 stable-x86_64-pc-windows-msvc updated - rustc 1.68.0 (2c8cc3432 2023-03-06) (from rustc 1.64.0 (a55dd71d5 2022-09-19))

info: cleaning up downloads & tmp directories

Trying out egui

Sat, 18 Mar 2023 10:27:02 +0900

What is egui

It is a GUI library that can be used with Rust.

Trying out egui

You can run the egui sample with the following commands.

1
2
3


git clone https://github.com/emilk/eframe_template/ egui_test
cd egui_test
cargo run

After that, you can try various things while tinkering with the sample code.

Reference

Official github

How to Eliminate Noise on YAMAHA AG03

Sat, 18 Mar 2023 01:17:10 +0900

How to Eliminate Noise on YAMAHA AG03

While listening to PC audio through the AG03 monitor, I experienced a crackling noise periodically (about once every 1 to 3 minutes). Upon investigating, I found the following solution for noise issues on the AG03.

https://jp.yamaha.com/support/updates/yamaha_steinberg_usb_driver_for_win.html

Downloading and installing the Yamaha Steinberg USB Driver from the site above resolved the noise.

今すぐ購入

References

https://web.archive.org/web/20201003230738/http://yamaha.custhelp.com/app/answers/detail/a_id/7202

Recommended PC Peripherals

Tue, 28 Feb 2023 00:51:49 +0900

Recommended & Desired PC Peripherals for an Active Engineer

Keyboard

When it comes to keyboards, I highly recommend those with a durable capacitive non-contact (electrostatic) switch. I have owned a RealForce for over 10 years, and it is still working perfectly today. The model I use is the English layout, silent version.

However, recently I’ve also been interested in the Logitech MX Keys keyboard.

Trackball

For pointing devices, I recommend a trackball over a mouse, as it reduces fatigue.

I currently use the Logitech MX Ergo. This is an expensive device costing over 10,000 yen, but I think it is well worth the price.

I am also interested in the DEFT PRO (M-DPT1MRXBK), which has a large ball and is operated with the index and middle fingers.

Display

Any display will do, but I recommend a high-resolution 4K display.

Currently, I use a DELL 4K display.

Right now, I would love to have a wide display like an EIZO display or a DELL display.

About fontplus.jp

Tue, 07 Feb 2023 20:59:01 +0900

fontplus.jp, a service for using paid web fonts

https://fontplus.jp/

For 1,100 yen per month, you can use all fonts, and it supports usage across multiple websites.

Using HTML Tags in HUGO

Tue, 17 Jan 2023 19:20:32 +0900

By default, HUGO does not allow the use of HTML tags in articles, but you can enable them by adding the following to your config.toml.

1
2


[markup.goldmark.renderer]
 unsafe = true

Reference: Configure Markup

Looking for GitHub Sponsors

Tue, 17 Jan 2023 18:13:56 +0900

Looking for GitHub Sponsors

I would be happy if you could become a GitHub sponsor via the button below.

The funds will be used for tool development and related activities.

I will do my best until I can afford to attach a code signing certificate!

About Buttons

Sat, 14 Jan 2023 20:24:00 +0900

What is a Button

A button is one of the GUI controls and can be implemented with the standard Windows API. When the area on the screen is clicked (mouse left button down, mouse left button up), the processing specified in the program can be executed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// Creating a button
CreateWindow(
 TEXT("BUTTON"),
 TEXT("Close"),
 WS_CHILD|WS_VISIBLE,
 10,10,128,30,
 hWnd,
 (HMENU)ID_BUTTON1,
 ((LPCREATESTRUCT)lParam)->hInstance,
 0);

 ...

 // A WM_COMMAND message is sent from the OS to the window when clicked.
 case WM_COMMAND:
 switch(LOWORD(wParam))
 {
 case ID_BUTTON1:
 SendMessage(hWnd,WM_CLOSE,0,0);
 break;
 }
 break;

Sample code is available below. button

Bought a Used ThinkPad

Fri, 13 Jan 2023 19:07:00 +0900

Bought a Used ThinkPad Laptop

Since my work on a laptop mostly involves connecting to other machines via remote desktop, I didn’t need a high-spec PC and a Chromebook would have been fine. However, because I couldn’t find one with a good design and high resolution, I bought a ThinkPad.

The specs are below, and using various points, the price came out to around 55,000 yen.

ThinkPad T470s

CPU: Intel Core i7 7600U
RAM: 24GB
SSD: 512GB
OS: Windows 10 Pro 64bit
Screen: 14.0-inch wide (non-glare panel)
Resolution: WQHD LCD 2560×1440
Weight: Approx. 1.32kg
Notes: English keyboard

Since it’s used, I thought it might have signs of wear or scratches, but there were no problems at all, which is great. The battery is also working fine so far.

Complaints that come to mind so far

There are no Pause and App keys. I used the Pause key as a shortcut to open system settings. Also, I used the App key to open pop-up menus, so it’s inconvenient without it.
The PageUp and PageDown keys are right next to the arrow keys on the keyboard, so I often press them by mistake. This might just take some getting used to.

Other PCs I considered but didn’t buy

ASUS Chromebook Flip C436FA (C436FA-ENG)
HP Laptop HP15s-fq

Reference: ThinkPad T470s

Easy Remote Connection with TeamViewer

Fri, 13 Jan 2023 01:45:00 +0900

Easy Remote Connection with TeamViewer

You can easily establish a remote desktop connection using TeamViewer.

Start TeamViewer on both the remote and local computers, and enter the remote computer’s ID and password on the local computer to connect remotely.

To connect remotely via the command line, do the following:

1

%ProgramFiles%\TeamViewer\TeamViewer.exe -i <ID> -P <Password>

Enter the remote computer’s ID in <ID> and the remote computer’s password in <Password>.

Creating a shortcut file with the above command is convenient because it allows you to skip entering the ID and password.

Reference site: Command line parameters

Quotes Collection

Sat, 15 Oct 2022 17:00:43 +0900

Fools learn from experience, wise men learn from history. (Otto von Bismarck)

Give a man a fish and you feed him for a day; teach a man to fish and you feed him for a lifetime. (Laozi)

Stay hungry, stay foolish. (Steve Jobs)

Done is better than perfect. (Mark Zuckerberg)

Keep it simple. (James Gosling)

I don’t have time to worry about who doesn’t like me. I’m too busy loving the people who love me. (Snoopy)

The greatest happiness for a human being is to find a job in which one can make the most of oneself. (Karl Marx)

If a little knowledge is dangerous, where is the man who has so much as to be out of danger? (Thomas Huxley, 1877)

“Contrariwise,” continued Tweedledee, “if it was so, it might be; and if it were so, it would be; but as it isn’t, it ain’t. That’s logic.” (Lewis Carroll, Through the Looking-Glass, 1872)

It is no exaggeration to say that Claude Shannon is the father of the information age, and that his academic achievements are among the greatest of the 20th century. (Commentary by the American Mathematical Society)

They who are acquainted with the present state of the theory of Symbolical Algebra, are aware, that the validity of the processes of analysis does not depend upon the interpretation of the symbols which are employed, but solely upon the laws of their combination. (George Boole, at the beginning of his book The Mathematical Analysis of Logic, 1847)

Graph Editor

Thu, 13 Oct 2022 23:31:11 +0900

Graph Editor

This is an introduction to a web page where you can easily create simple graphs.

https://csacademy.com/app/graph_editor/

You can create graphs by entering numerical values. You can also move elements around using the mouse.

By clicking Directed, you can create directed graphs as well.

You can save the graphs you create as images using Download as PNG.

Solving the Traveling Salesperson Problem with Mathematica

Wed, 12 Oct 2022 19:05:58 +0900

Solving the Traveling Salesperson Problem with Mathematica

Problem

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

Solution

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

We create a matrix using the SparseArray function. Each element represents the distance between cities at the row and column of that element. For example, the first element {1,2}->10 means the distance between 1 and 2 is 10. The second to last element {9,9} indicates the size of the matrix, and the final element Infinity means the length of paths between unspecified cities is infinite, meaning there is no path.

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

You can easily solve the traveling salesperson problem with the FindShortestTour function. {1,2,3,4,5,6,7,8,9} represents the city numbers. DistanceFunction->(d[[#1,#2]]&) passes the matrix d which represents the distance between cities.

Output

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

The output gives the shortest distance and the tour route for it. The shortest distance is 137, and the route is 1→2→5→9→8→7→6→3→4→1. Converting this to ABC order gives A, B, E, I, H, G, F, C, D.

Check all checkboxes in a web page

Wed, 05 Oct 2022 20:07:06 +0900

To check all checkboxes in a web page, open DevTools with F12, paste the following code into the console, and execute it.

1
2
3
4
5
6


let boxes = document.querySelectorAll('input[type="checkbox"]');
for (let i = 0; i < boxes.length; i++) {
 if (!boxes[i].disabled) {
 boxes[i].checked = true;
 }
}

Alternatively,

Create a new bookmark, and in the address field when registering (where you usually enter https://…), paste the following code and save it. Display the web page where you want to check the boxes, and click the created bookmark to check all checkboxes.

1

javascript:(function(){let boxes=document.querySelectorAll('input[type="checkbox"]');for(let i=0;i<boxes.length;i++){if(!boxes[i].disabled){boxes[i].checked=true;}}})();

If you want to uncheck all, change the boxes[i].checked = true; part of the above script to boxes[i].checked = false;.

Favorite Mathematical Formulas

Wed, 05 Oct 2022 13:24:50 +0900

Wilson’s Theorem

When $p$ is a prime number, $(p−1)!≡−1 \pmod p$ holds.

Euler’s Formula

$e^{iπ}+1=0$

Fermat’s Last Theorem

For any integer $n≥3$, there are no positive integer solutions $x, y, z$ to the equation $x^n+y^n=z^n$.

Basel Problem

$1/1^2+1/2^2+1/3^2+1/4^2+...=π^2/6$

Euler’s Prime-Generating Polynomial

$n^2+n+41$ is a prime number for all integers $n$ from $0$ to $39$.

Installing Apps via Command Line Using WinGet

Wed, 05 Oct 2022 12:15:20 +0900

Prerequisites

Windows 11

Steps

Install App Installer from the Microsoft Store https://www.microsoft.com/store/productId/9NBLGGH4NNS1
Install apps from the command prompt
1

winget install Google.Chrome

Main Apps that Can Be Installed

Google Chrome (command winget install Google.Chrome)
Microsoft Edge (command winget install Microsoft.Edge)
Microsoft Teams (command winget install Microsoft.Teams)
Microsoft Office (command winget install Microsoft.Office)
Visual Studio Code (command winget install vscode)
Slack (command winget install SlackTechnologies.Slack)
Discord (command winget install Discord.Discord)
Docker Desktop (command winget install Docker.DockerDesktop)
Git (command winget install Git)
7zip (command winget install 7zip)
VLC (command winget install VideoLAN.VLC)

References

Use the winget tool to install and manage applications

Aside

I thought I could install Paint.Net too, but I wasn’t able to.

https://forums.getpaint.net/topic/118574-please-add-paintnet-to-the-available-packages-for-windows-package-manager-winget/

Features of Rust

Mon, 03 Oct 2022 22:47:20 +0900

Features of Rust

A relatively new open-source programming language developed by Mozilla.
A fast, systems programming language without garbage collection.
Guarantees memory safety through unique language features called ownership and borrowing.
Operates cross-platform.
Comes with an excellent standard package manager called Cargo.

Dynamically setting variables in Github Actions

Sun, 02 Oct 2022 02:33:35 +0900

To dynamically set variables in Github Actions, you can achieve this by appending to $GITHUB_ENV as shown below.

[For Windows]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


name: Rust

on:
 push:
 branches: [ "master" ]
 pull_request:
 branches: [ "master" ]

env:
 CARGO_TERM_COLOR: always

jobs:
 build:
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v3
 - name: Get Environment
 run: |
 echo 'VERSION=1.0.0' >> $GITHUB_ENV
 echo 'NAME=1.0.0' >> $GITHUB_ENV
 - name: Display Environment
 run: |
 echo $env:VERSION
 echo $env:NAME
 - name: Create Release
 id: create_release
 uses: actions/create-release@v1
 env:
 GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 with:
 tag_name: ${{ env.VERSION }}
 release_name: ${{ env.VERSION }}
 draft: false
 prerelease: false
 - name: Upload Release Asset
 id: upload-release-asset
 uses: actions/upload-release-asset@v1
 env:
 GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 with:
 upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
 asset_path: ./target/release/${{ env.NAME }}.exe
 asset_name: ${{ env.NAME }}.exe
 asset_content_type: application/octet-stream

[For Linux]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


name: Rust

on:
 push:
 branches: [ "main" ]
 pull_request:
 branches: [ "main" ]

env:
 CARGO_TERM_COLOR: always

jobs:
 build:
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v3
 - name: Get Environment
 run: |
 echo 'VERSION=1.0.0' >> $GITHUB_ENV
 echo 'NAME=hello' >> $GITHUB_ENV
 - name: Display Environment
 run: |
 echo ${{ env.VERSION }}
 echo ${{ env.NAME }}

Deleting a tag in git

Sun, 02 Oct 2022 02:18:04 +0900

Delete a local tag

Check existing local tags with git tag.
Delete the tag with git tag -d v0.1.0. (Replace v0.1.0 with the tag you want to delete)

Delete a remote tag

Check existing remote tags with git ls-remote --tags.
Delete the remote tag with git push origin --delete v0.1.0. (Replace v0.1.0 with the tag you want to delete)

Reference

How to delete a tag in git locally and remotely!

Displaying a simple window in Rust

Sat, 01 Oct 2022 19:08:58 +0900

Displaying a simple window in Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "win"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies.winapi]
version = "0.3"
features = ["winuser"]

The source code is as follows

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


#![windows_subsystem = "windows"]
use winapi::{
 um::{
 winuser::{RegisterClassW, WNDCLASSW, CS_HREDRAW, CS_VREDRAW,
 LoadIconW, IDI_APPLICATION, LoadCursorW, IDC_ARROW,
 CreateWindowExW, ShowWindow, SW_NORMAL, UpdateWindow,
 GetMessageW, TranslateMessage, DispatchMessageW, MSG,
 WM_DESTROY, PostQuitMessage, DefWindowProcW, WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT},
 wingdi::{GetStockObject, WHITE_BRUSH},
 },
 shared::{
 windef::{HWND, HBRUSH},
 minwindef::{UINT, WPARAM, LPARAM, LRESULT},
 },
};
use std::ptr;
use std::mem;

fn main() {
 unsafe {
 let class_name = encode("my_window_class_name");
 if !register_wndclass(&class_name) {
 return;
 }
 let hwnd = create_window(&class_name);
 if hwnd.is_null() {
 return;
 }
 ShowWindow(hwnd, SW_NORMAL);
 UpdateWindow(hwnd);
 let mut msg = mem::uninitialized::<MSG>();
 loop {
 if GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
 return;
 }
 TranslateMessage(&mut msg);
 DispatchMessageW(&mut msg);
 }
 }
}

fn encode(source: &str) -> Vec<u16> {
 source.encode_utf16().chain(Some(0)).collect()
}

unsafe fn register_wndclass(class_name: &[u16]) -> bool {
 let mut winc = mem::zeroed::<WNDCLASSW>();
 winc.style = CS_HREDRAW | CS_VREDRAW;
 winc.lpfnWndProc = Some(win_proc);
 winc.hIcon = LoadIconW(ptr::null_mut(), IDI_APPLICATION);
 winc.hCursor = LoadCursorW(ptr::null_mut(), IDC_ARROW);
 winc.hbrBackground = GetStockObject(WHITE_BRUSH as i32) as HBRUSH;
 winc.lpszClassName = class_name.as_ptr();
 RegisterClassW(&winc) > 0
}

unsafe fn create_window(class_name: &[u16]) -> HWND {
 CreateWindowExW(
 0,
 class_name.as_ptr(),
 encode("Hello, World!").as_ptr(),
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 )
}

unsafe extern "system" fn win_proc(hwnd: HWND, msg: UINT, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
 match msg {
 WM_DESTROY => PostQuitMessage(0),
 _ => return DefWindowProcW(hwnd, msg, w_param, l_param),
 };
 0
}

Reference

Windows Programming in Rust - CreateWindow edition

Writing Tests in Rust

Sat, 01 Oct 2022 02:00:59 +0900

To write a test in Rust, create a function and add the #[test] attribute on the line above the test function definition.

1
2
3
4
5
6
7
8


fn plus(a:i32,b:i32)->i32 {
 a+b
}

#[test]
fn plus_test() {
 assert_eq!(plus(1, 1), 2);
}

You can run test codes with cargo test. If the test succeeds, it outputs ok. If it fails, it outputs FAILED.

When successful

1
2
3
4
5
6
7
8
9


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.35s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... ok

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

When failed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.33s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... FAILED

failures:

---- plus_test stdout ----
thread 'plus_test' panicked at 'assertion failed: `(left == right)`
 left: `2`,
 right: `3`', src\main.rs:7:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
 plus_test

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

error: test failed, to rerun pass '--bin test1'

Displaying a MessageBox in Rust

Fri, 30 Sep 2022 23:54:31 +0900

You can display a MessageBox in Rust by following these steps.

Install Rust. See Getting Started with Rust.
Run cargo new --bin MessageBox in the command prompt.
Navigate to the MessageBox directory.
Open Cargo.toml and modify it as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
winapi = "0.2.7"
user32-sys = "0.2.0"

Open src\main.rs and modify it as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


extern crate user32;
extern crate winapi;

use std::ffi::CString;
use user32::MessageBoxA;
use winapi::winuser::{MB_OK, MB_ICONINFORMATION};

fn main() {
 let lp_text = CString::new("Hello, world!").unwrap();
 let lp_caption = CString::new("MessageBox Example").unwrap();

 unsafe {
 MessageBoxA(
 std::ptr::null_mut(),
 lp_text.as_ptr(),
 lp_caption.as_ptr(),
 MB_OK | MB_ICONINFORMATION
 );
 }
}

Run cargo run in the command prompt.
If you want to build a release version, run cargo build --release.

References

Hello World MesssageBox example in Rust

What Does It Mean to Understand?

Sat, 24 Sep 2022 02:38:18 +0900

What Does It Mean to Understand?

Hello!

Today, I would like to talk about the theme, “What does it mean to understand?”

Is “understanding” actually ambiguous?

There are moments in everyday life when you feel, “I get it!” But if you think about it carefully, is that “understanding” really complete comprehension?

For example, driving a car. If you step on the accelerator, it moves forward, and if you step on the brake, it stops. You might say you “understand” this. However, there are probably very few people who can explain in detail what is happening inside the engine.

Is complete understanding necessary?

Actually, even if you don’t understand everything completely, it often doesn’t interfere with daily life. Even if you don’t know the internal structure of a smartphone, you can make phone calls and send messages, right?

But that doesn’t mean you should make light of “understanding.” Deepening your understanding can lead to new discoveries and realizations.

There are also many things we don’t understand

There are many things in the world that have not yet been elucidated. For example, the mechanisms of human emotions and consciousness, the origin of the universe, and so on. These are fields that are still not completely “understood” even as science advances.

Even in the world of mathematics, there are unsolved problems like “Goldbach’s conjecture,” despite being simple problems.

The value of “understanding”

As your “understanding” grows, you can explain things with confidence and communicate effectively with others. Having knowledge also has the advantage of making you less likely to be misled by misinformation.

A humble attitude is important

Recognizing what you “don’t understand” leads to humility. And it is precisely because of this recognition that the desire to keep learning is born.

So, while “understanding” is important, it is difficult to comprehend everything completely. What is truly important is to know the limits of your own understanding and to maintain an attitude of continuous learning.

Why do I like math and computers?

Fri, 23 Sep 2022 01:56:52 +0900

I thought about why I like mathematics and computers

Equal to everyone

Regardless of the person, position, or location, it always returns the same output for the same input.

Clear rules

The rules are clearly defined, and there is no absurdity or injustice.

The answers and theories derived are forever correct

There is no worry that an answer once derived will be rewritten later.

Appropriate level of difficulty

There are always unsolved problems, and you can challenge yourself to solve them at any time.

What a Community Needs

Fri, 23 Sep 2022 01:37:43 +0900

What a Community Needs

I felt that the Scratch Community Guidelines are very refined and excellent. The following points were written:

Treat everyone with respect.

Keep safe: Do not publish personal information or contact details.

Leave helpful comments.

Understand remix culture.

Be honest.

Make the site a comfortable place.

I think these perspectives are applicable to any community.

https://ja.scratch-wiki.info/wiki/%E3%82%B3%E3%83%9F%E3%83%A5%E3%83%8B%E3%83%86%E3%82%A3%E3%83%BC%E3%82%AC%E3%82%A4%E3%83%89%E3%83%A9%E3%82%A4%E3%83%B3

Great Figures in Mathematics

Thu, 22 Sep 2022 23:06:37 +0900

Fermat (P. de Fermat, 1601-1665)

A representative French mathematician of the 17th century. He laid the foundation for analytic geometry, probability theory, and differential calculus. He is also the founder of number theory.

Diophantus (Diophantus, c. 207-c. 291)

A Greek mathematician. Famous for the introduction of symbolic notation and the study of rational solutions. His representative work is “Arithmetica”. The field of finding rational solutions to equations is called Diophantine analysis.

Euler (L. Euler, 1707-1783)

The king of mathematics born in Switzerland. He made achievements in every conceivable area of mathematics. He left behind over 700 papers and 45 books.

Legendre (A. M. Legendre, 1752-1833)

A French mathematician. He left numerous achievements in number theory, elliptic integrals, and the problem of gravitational attraction. The term “number theory” originates from his main work, “Essai sur la théorie des nombres”.

Kummer (E. E. Kummer, 1810-1893)

A German mathematician. He achieved great success by applying the number theory of cyclotomic fields to Fermat’s Last Theorem.

Descartes (R. Descartes, 1596-1650)

A highly original French philosopher. His representative works include “Discourse on the Method”, “Geometry”, and “The World”.

Pascal (B. Pascal, 1623-1662)

A French philosopher known for his research in probability theory and fluids. Later, he joined the Jansenists and engaged in religious activities. “Pensées” is his work from that time.

Bachet (C. G. Bachet, 1581-1638)

A French nobleman who studied number puzzles as a hobby. He published a Latin translation of Diophantus’s “Arithmetica” and included his own research as annotations.

Wallis (J. Wallis, 1616-1703)

An English mathematician. In his main work “Arithmetica Infinitorum”, he gave a mathematical form to the concept of limits, contributing to the foundation of calculus.

Brouncker (W. Brouncker, 1620-1684)

An Irish nobleman. The first President of the Royal Society (British Academy). A mathematics enthusiast who interacted with Wallis and others.

Lagrange (J. L. Lagrange, 1736-1813)

An Italian-born French mathematician. He served as the Director of Mathematics at the Berlin Academy as Euler’s successor. He made major achievements in number theory, analytical mechanics, and more.

Siegel (C. L. Siegel, 1896-1981)

A German number theorist. He made numerous contributions to the analytic theory of numbers.

Fibonacci (L. Fibonacci, c. 1175-c. 1250)

An Italian mathematician. In his main work “Liber Abaci”, he used Hindu-Arabic numerals and worked to popularize them. He also discussed congruent numbers in “Liber Quadratorum”.

Baker (A. Baker, 1939-)

An English number theorist. For his contributions to transcendental number theory, he was awarded the Fields Medal along with Heisuke Hironaka.

Poincaré (J. Poincaré, 1854-1912)

A French mathematician known as the last universal mathematician. He left behind outstanding works in automorphic functions, non-Euclidean geometry, differential equations, celestial mechanics, electrodynamics, and scientific essays.

Mordell (L. J. Mordell, 1888-1972)

An American-born mathematician. His parents were immigrants from Lithuania. He published numerous papers on Diophantine equations, but Mordell’s theorem in the theory of elliptic curves is especially famous. Weil extended this to the case of general algebraic curves, leading to an explosive development in arithmetic algebraic geometry.

Weil (A. Weil, 1906-)

A French mathematician of Jewish descent. In his youth, he took an interest in Fermat’s problem and fundamentally revised algebraic geometry with the aim of applying it to number theory, providing a rigorous foundation. He is also known for his writings on the history of mathematics.

Mersenne (M. Mersenne, 1588-1648)

A French Minim friar. He facilitated correspondence among mathematicians in various places. The numbers known as Mersenne numbers were actually conceived by Fermat.

Roberval (G. P. de Roberval, 1602-1675)

A French mathematician. He was almost the only person at the time who held a professorship as a mathematician, and is known for his research on the cycloid.

Abel (N. H. Abel, 1802-1829)

A Norwegian mathematician. He made outstanding achievements such as proving the insolvability of the general quintic equation, the theory of elliptic functions, and the theory of Abelian integrals, but died at a young age.

Jacobi (K. G. Jacob, 1804-1851)

A German mathematician of Jewish descent. He left major achievements in the theory of elliptic functions, theta functions, differential equations, and the calculus of variations. He introduced Abel’s work to the world. He is also known for stating that the purpose of science is for “the honor of the human spirit,” rejecting utilitarianism.

Gauss (C. F. Gauss, 1777-1855)

The king of mathematics born in Germany. Known for his research in number theory, non-Euclidean geometry, geodesy, hypergeometric series, the theory of surfaces, and geomagnetism. He was a perfectionist who is said to have not published his results unless they were perfected to the point where the scaffolding was invisible. His main work is “Disquisitiones Arithmeticae”.

Lamé (G. Lamé, 1795-1870)

A French mathematician. Contributed to the theory of elasticity, heat conduction, etc.

Liouville (J. Liouville, 1809-1882)

A French mathematician. Contributed to differential equations, transcendental number theory, and complex analysis.

Cauchy (A. L. Cauchy, 1789-1857)

A French mathematician. Highly prolific, with many achievements in theoretical physics and mathematics. In France, he is said to be respected as much as Gauss.

Galois (E. Galois, 1811-1832)

A French mathematician. He elucidated Abel’s theorem that equations of degree 5 or higher generally cannot be solved algebraically by introducing the concept of a group. He died young in a duel, which is now known to have been triggered by a trivial issue involving a woman.

Hensel (K. Hensel, 1861-1941)

A German mathematician. A student of Kronecker. He introduced the theory of p-adic numbers (p-adic analysis) into number theory by applying function-theoretic methods.

Hasse (H. Hasse, 1898-1979)

A German mathematician. A student of Hensel, he contributed to the foundation of p-adic analysis and its applications. His work includes the development of class field theory and research on the L-functions of elliptic curves.

Kronecker (L. Kronecker, 1823-1891)

A German mathematician of Jewish descent. Contributed to the theory of elliptic functions, number theory, etc. Known for advocating the arithmetization of mathematics, but his highly subjective personality led him to unfairly criticize his colleague Weierstrass at the University of Berlin and hinder Cantor’s employment, which has given his life a negative image.

Hilbert (D. Hilbert, 1862-1943)

A German mathematician. Left a massive footprint in every field of mathematics, including invariant theory, algebraic number theory, and the foundations of mathematics. The 23 problems he proposed at the International Congress of Mathematicians in Paris (1900) had a major impact on the development of mathematics.

Riemann (B. Riemann, 1826-1866)

A German mathematician. Made profound contributions to the very foundations of mathematics, such as the concept of Riemann surfaces in complex analysis and Riemannian geometry.

Faltings (G. Faltings, 1954-)

A German mathematician. Resolved the Mordell conjecture in 1983.

Wiles (A. Wiles, 1953-)

An English-born mathematician. A leading figure in this field who made major contributions through his research on Iwasawa’s main conjecture, the Birch and Swinnerton-Dyer conjecture, and famously proving Fermat’s Last Theorem.

References

Fermat’s Last Theorem Solved! From Euler to Wiles’ Proof, Kodansha

Enumerate Window Titles

Tue, 20 Sep 2022 17:03:15 +0900

Enumerate Window Titles

Here is how to enumerate the titles of currently open windows using PowerShell.

1

Get-Process|where{$_.mainWindowTItle}|Select-Object MainWindowTitle

Output Sample

1
2
3
4
5
6
7
8
9


MainWindowTitle
---------------
Windows PowerShell
Internet Explorer
Untitled - Paint
Untitled - Notepad
Task Manager
Windows Input Experience
Document - WordPad

Fast Batch Deletion of Large Folders

Tue, 20 Sep 2022 16:04:02 +0900

Fast Batch Deletion of Large Folders

When deleting a large folder in Explorer, the deletion is executed after all the folder contents are fully searched, which is slow. By deleting with a command as shown below, the search and deletion are executed simultaneously, allowing you to delete large folders at high speed.

Move to the target folder level in the Command Prompt.
Execute DEL /F /Q /S folder_name > NUL.
Execute RMDIR /Q /S folder_name.

Salesforce Chatter Bulk Delete Command

Mon, 19 Sep 2022 21:59:14 +0900

Salesforce Chatter Bulk Delete Command

This is a command to delete all posts and attachments in Salesforce Chatter. Open the Developer Console, select “Open Execute anonymous Window” from the Debug menu, paste the following code, and execute it. I personally use this when the organization’s storage capacity is running low.

1
2
3
4
5
6


delete [select id from FeedItem];
delete [select id from FeedAttachment];
delete [select id from ContentDocument];

// Empty the recycle bin
database.emptyRecycleBin([select id from ContentDocument where IsDeleted = true ALL ROWS]);

Windows Shortcuts and Tips

Sun, 18 Sep 2022 23:49:29 +0900

This is a collection of useful little tips and shortcuts I use regularly on Windows. I hope this will be helpful for beginners just starting to use Windows. This assumes Windows 11, but many of them should work on Windows 10 as well.

Close Window

Alt + F4 while the window is active
Ctrl + W while the window is active. Closes the tab or window (only for supported applications)
Double-click the icon on the left of the window title bar
Click the × on the window title bar

Show Desktop

Win + D. Press it twice to restore the original window state. Very useful when you want to see the desktop for just a moment.
Win + M. Minimize all apps. Pressing it twice does not restore them.

Voice Typing

Win + H. Start voice typing. To end voice typing, press Esc or Win + H again.

Press Shift + F10 or the Application key. The Application key is located at the bottom right of the keyboard.

Capture a Selected Area of the Screen

Win + Shift + S allows you to select an area to capture.
Win + Print Screen or simply Print Screen captures the entire screen. (If you add Win, the captured image is saved to C:\Users\Username\Pictures\Screenshots.)
Alt + Print Screen captures the current window.

Launch Apps Pinned to the Taskbar

Win + Number Key launches apps pinned to the taskbar.
For example, pressing Win + 1 launches the first app on the left of the taskbar.
Win + T moves focus to the taskbar icons. You can then press Win + T multiple times, or use the ← or → keys to move the selection and press Enter to launch the selected app.

Zoom In / Zoom Out

Win + + opens Windows Magnifier. You can further zoom in or out of the screen using Win + + or -.
In apps like Notepad or browsers, you can zoom in/out with Ctrl + + or - (only for supported apps).

Lock Windows

Win + L
Ctrl + Alt + Del -> Space or Enter

Shut Down Windows

When the desktop is shown with Win + M or Win + D, or the taskbar is active with Win + T or Win + B, pressing Alt + F4 will display the dialog below. Make sure “Shut down” is selected and press Enter. Alternatively, you can use Win + R -> Alt + F4 -> Alt + F4.
You can shut down using Win + X -> U -> U.
Entering shutdown /s /t 0 in Command Prompt or the “Run” dialog (Win + R) will shut down the system. Adding /f will force a shutdown.

Restart Windows

When the desktop is shown with Win + M or Win + D, or the taskbar is active with Win + T or Win + B, pressing Alt + F4 will display the dialog below. Press ↓ once to select “Restart” and press Enter. Alternatively, you can use Win + R -> Alt + F4 -> Alt + F4.
You can restart using Win + X -> U -> R.
shutdown /r /t 0 restarts the system. Adding /f will force a restart.

Sleep Windows

When the desktop is shown with Win + M or Win + D, or the taskbar is active with Win + T or Win + B, pressing Alt + F4 will display the dialog below. Press ↑ once to select “Sleep” and press Enter. Alternatively, you can use Win + R -> Alt + F4 -> Alt + F4.
Entering rundll32.exe powrprof.dll,SetSuspendState in Win + R or Command Prompt will put the system into hibernation.

Sign Out (Log Off) Windows

When the desktop is shown with Win + M or Win + D, or the taskbar is active with Win + T or Win + B, pressing Alt + F4 will display the dialog below. Press ↑ twice to select “Sign out” and press Enter. Alternatively, you can use Win + R -> Alt + F4 -> Alt + F4.
Win + X -> U -> I
Ctrl + Alt + Del -> Tab twice or ↓ twice -> Enter or Space
logoff to sign out (log off).

Move Windows with Keyboard

Win + ←: Move left
Win + →: Move right
Win + ↑: Move up / Maximize
Win + ↓: Move down / Minimize
Win + Shift + ← or →: Move between multiple monitors
Win + Alt + ← or → or ↑ or ↓: Move window without maximizing or minimizing
When not minimized, press Alt + Space, then M, and use the arrow keys to move.

Since the window will follow the mouse cursor, you can rescue a window even if it is displayed off-screen.

End Process with Task Manager

Ctrl + Shift + Esc launches Task Manager.
Ctrl + Tab switches tabs.
After pressing Tab on the Details tab, you can search for a process by typing its prefix in alphanumeric mode.
With a process name selected, press the Delete key, followed by the Enter key to end the process.

End Process by Specifying Name in Command

taskkill /f /im process_name ends a process. For example, taskkill /f /im explorer.exe ends File Explorer.

Launch Multiple Instances of the Same Program from Taskbar

While holding Shift, left-click an icon on the taskbar to launch multiple instances of the same program. (Only for apps that support multiple instances)

Launch a Program as Administrator

Hold Ctrl + Shift while launching a program to open it with administrator privileges.

Launch File Explorer

Win + E launches File Explorer.
Win + R to open “Run”, type explorer, and press Enter
Ctrl + Shift + N creates a new folder.

Open Command Prompt in the Current File Explorer Location

In Windows 11, you can launch Command Prompt from the right-click menu by selecting “Open in Terminal”.
Also, typing cmd in the address bar and pressing Enter will launch Command Prompt.

Show Clipboard History

Win + V shows the clipboard history. Selecting previously copied text or images will copy them again.

Run

Win + R opens the “Run” dialog.

Here are a few commands you can execute in “Run” or Command Prompt.

Open Edge

Type msedge and press Enter

Open Internet Explorer 11 (IE11)

Type powershell.exe -Command "(New-Object -ComObject InternetExplorer.Application).Visible = $true" and press Enter

Open Terminal

Type wt and press Enter

Open Control Panel

Type control and press Enter
You can also open it with explorer.exe shell:::{26EE0668-A00A-44D7-9371-BEB064C98683}.

Launch Notepad

Type notepad and press Enter

Launch Calculator

Type calc and press Enter

Launch Paint

Type mspaint and press Enter

Launch PowerShell

Type powershell and press Enter

Launch Visual Studio Code

Type code and press Enter

Launch Excel

Type excel and press Enter

Only if Excel is installed.

Open Word

Type winword and press Enter

Only if Word is installed.

Open PowerPoint

Type powerpnt and press Enter
- Only if PowerPoint is installed.

Open System Configuration

Type msconfig and press Enter

Open System Properties

Type sysdm.cpl and press Enter

Open Windows About (Version Info)

Type winver and press Enter

Open On-Screen Keyboard

Type osk and press Enter

Open WordPad

Type wordpad or write and press Enter

Open Registry Editor

Type regedit and press Enter

Open Programs and Features

Type explorer.exe shell:::{7b81be6a-ce2b-4676-a29e-eb907a5126c5} and press Enter

Open Keyboard Properties

Type explorer.exe shell:::{725BE8F7-668E-4C7B-8F90-46BDB0936430} and press Enter

Open Mouse Properties

Type explorer.exe shell:::{6C8EEC18-8D75-41B2-A177-8831D59D2D50} and press Enter

Open Sound

Type explorer.exe shell:::{F2DDFC82-8F12-4CDD-B7DC-D4FE1425AA4D} and press Enter

Open User Accounts

Type explorer.exe shell:::{60632754-c523-4b62-b45c-4172da012619} and press Enter

Copy String from a Standard Message Box

Ctrl + C allows you to copy the text from a standard message box. Copying the message box above will copy the following to the clipboard:

1
2
3
4
5
6
7


[Window Title]
WordPad

[Main Instruction]
Do you want to save changes to Document?

[Save(S)] [Don't Save(N)] [Cancel]

Store Command Prompt Output to Clipboard

Adding | clip (pipe + clip) after a command, like echo "hello" | clip, allows you to copy the standard output to the clipboard.

Text Output of Folder Hierarchy

In Command Prompt, you can output the folder hierarchy in a tree format using the tree command.

Output Sample

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


C:.
├─.idea
│ └─libraries
├─binaryeditorbz
├─blog
│ ├─archetypes
│ ├─content
│ ├─data
│ ├─layouts
│ ├─static
│ └─themes
│ └─PaperMod
│ ├─.git
│ │ ├─branches
│ │ ├─hooks
│ │ ├─info
│ │ ├─logs
│ │ │ └─refs
│ │ │ ├─heads
│ │ │ └─remotes
│ │ │ └─origin
│ │ ├─objects
│ │ │ ├─info
│ │ │ └─pack
│ │ └─refs
│ │ ├─heads
│ │ ├─remotes
│ │ │ └─origin
│ │ └─tags
│ ├─.github
│ │ ├─ISSUE_TEMPLATE
│ │ └─workflows
│ ├─assets
│ │ ├─css
│ │ │ ├─common
│ │ │ ├─core
│ │ │ ├─extended
│ │ │ ├─hljs
│ │ │ └─includes
│ │ └─js
│ ├─i18n
│ ├─images
│ └─layouts
│ ├─partials
│ │ └─templates
│ ├─shortcodes
│ └─_default
│ └─_markup
(omitted below)

Reference

Keyboard shortcuts in Windows

The Appeal of paint.net

Wed, 14 Sep 2022 19:33:31 +0900

I would like to introduce paint.net, an image editing software that I often use during my development work.

Useful Features Not Found in Standard Windows Paint

Can handle transparency and opacity
Can automatically select complex areas
Can handle layers
Can adjust levels, brightness, contrast, etc.
Can apply various effects (blur, distort, noise, etc.)

Other Features

Free to use
Relatively lightweight and fast
Intuitive to use with few quirks
Supports multiple languages, including Japanese

It is a highly functional yet easy-to-use software. I myself haven’t mastered all of its features yet.

Installation

https://www.getpaint.net/download.html

If you wish to choose the free version, please click the red framed area at the link below.

Installing via the Microsoft Store is paid, but it seems to enable automatic updates. Even with the free version, you will be notified of the latest updates, so updating is relatively smooth.

How to set up a custom domain for a Github repository

Tue, 13 Sep 2022 01:16:40 +0900

To set up a custom domain for a Github repository, you need to change the domain’s DNS settings. Here, we will explain assuming that you manage your domain with Onamae.com . Similar settings can be applied by rewriting the A record with other registrars as well.

Change DNS settings on Onamae.com

To change the DNS settings of your domain, log in to the management screen of Onamae.com . After logging in, go to the domain management screen. Once on the domain management screen, change the DNS settings. To change the DNS settings, configure them as follows:

Access https://www.onamae.com/ and click “Onamae.com Navi Login”
Enter your “Onamae ID (Member ID)” and “Password” and click the login button
Click “Name Server Settings”
Click “Domain DNS Settings”
Select the domain you want to set up and click “Next”
Click “Set up” to the right of “Use DNS record settings”
Select A for TYPE, enter 3600 for TTL, enter “185.199.108.153” for VALUE, and click “Add”
Add “185.199.109.153”, “185.199.110.153”, and “185.199.111.153” in the same way as step 7.
Ensure that the checkbox in “Confirm name server change for DNS record settings” is checked and click “Proceed to setting screen”
If the screen “To prevent unintended DNS setting changes” appears, click “Do not set” (select as necessary)
Confirm the setting details and click “Set up”
This completes the DNS settings. It may take up to 72 hours for the reflection to complete.
If it is not reflected after 72 hours, please try contacting Onamae.com support.

To check if the settings have been reflected in your local environment, try executing the following commands. Please replace the example.com part with the domain you want to check.

For Linux and Mac

1

dig example.com +noall +answer -t A

If the result looks like the following, the settings have been reflected.

1
2
3
4


example.com. 0 IN A 185.199.108.153
example.com. 0 IN A 185.199.109.153
example.com. 0 IN A 185.199.110.153
example.com. 0 IN A 185.199.111.153

For Windows

1

nslookup -q=a example.com 8.8.8.8

If the result looks like the following, the settings have been reflected.

1
2
3
4
5
6
7
8
9


Server: dns.google
Address: 8.8.8.8

Non-authoritative answer:
Name: example.com
Addresses: 185.199.108.153
 185.199.109.153
 185.199.110.153
 185.199.111.153

Set a custom domain in the Github repository

Open the repository page and click Settings
Click Pages
If you want to publish the repository source as is, select “Deploy from a branch” in Source. If you want to build the source using HUGO or similar, select “GitHub Actions”.
Select the branch to publish in Branch and click Save
Enter the acquired domain in Custom domain and click Save.
Check “Enforce HTTPS” as necessary to support HTTPS

[PR]

Generating .gitignore with the dotnet command

Tue, 13 Sep 2022 00:25:12 +0900

Since the dotnet.exe command can even build simple programs, it is useful to know how to use it.

Installing the .NET SDK

dotnet.exe is included in the .NET SDK, so we will install the .NET SDK first. Launch cmd.exe with administrator privileges and run the following command:

1

winget install Microsoft.DotNet.SDK.6

Generating .gitignore

The command to generate a .gitignore using dotnet.exe is as follows:

1

dotnet new gitignore

The generated .gitignore is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454


## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
##
## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore

# User-specific files
*.rsuser
*.suo
*.user
*.userosscache
*.sln.docstates

# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs

# Mono auto generated files
mono_crash.*

# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
[Ww][Ii][Nn]32/
[Aa][Rr][Mm]/
[Aa][Rr][Mm]64/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
[Ll]ogs/

# Visual Studio 2015/2017 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/

# Visual Studio 2017 auto generated files
Generated\ Files/

# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*

# NUnit
*.VisualState.xml
TestResult.xml
nunit-*.xml

# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c

# Benchmark Results
BenchmarkDotNet.Artifacts/

# .NET
project.lock.json
project.fragment.lock.json
artifacts/

# Tye
.tye/

# ASP.NET Scaffolding
ScaffoldingReadMe.txt

# StyleCop
StyleCopReport.xml

# Files built by Visual Studio
*_i.c
*_p.c
*_h.h
*.ilk
*.meta
*.obj
*.iobj
*.pch
*.pdb
*.ipdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*_wpftmp.csproj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc

# Chutzpah Test files
_Chutzpah*

# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb

# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap

# Visual Studio Trace Files
*.e2e

# TFS 2012 Local Workspace
$tf/

# Guidance Automation Toolkit
*.gpState

# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user

# TeamCity is a build add-in
_TeamCity*

# DotCover is a Code Coverage Tool
*.dotCover

# AxoCover is a Code Coverage Tool
.axoCover/*
!.axoCover/settings.json

# Coverlet is a free, cross platform Code Coverage Tool
coverage*.json
coverage*.xml
coverage*.info

# Visual Studio code coverage results
*.coverage
*.coveragexml

# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*

# MightyMoose
*.mm.*
AutoTest.Net/

# Web workbench (sass)
.sass-cache/

# Installshield output folder
[Ee]xpress/

# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html

# Click-Once directory
publish/

# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# Note: Comment the next line if you want to checkin your web deploy settings,
# but database connection strings (with potential passwords) will be unencrypted
*.pubxml
*.publishproj

# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/

# NuGet Packages
*.nupkg
# NuGet Symbol Packages
*.snupkg
# The packages folder can be ignored because of Package Restore
**/[Pp]ackages/*
# except build/, which is used as an MSBuild target.
!**/[Pp]ackages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/[Pp]ackages/repositories.config
# NuGet v3's project.json files produces more ignorable files
*.nuget.props
*.nuget.targets

# Microsoft Azure Build Output
csx/
*.build.csdef

# Microsoft Azure Emulator
ecf/
rcf/

# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
*.appx
*.appxbundle
*.appxupload

# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!?*.[Cc]ache/

# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
orleans.codegen.cs

# Including strong name files can present a security risk
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
#*.snk

# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/

# RIA/Silverlight projects
Generated_Code/

# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
ServiceFabricBackup/
*.rptproj.bak

# SQL Server files
*.mdf
*.ldf
*.ndf

# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
*.rptproj.rsuser
*- [Bb]ackup.rdl
*- [Bb]ackup ([0-9]).rdl
*- [Bb]ackup ([0-9][0-9]).rdl

# Microsoft Fakes
FakesAssemblies/

# GhostDoc plugin setting file
*.GhostDoc.xml

# Node.js Tools for Visual Studio
.ntvs_analysis.dat
node_modules/

# Visual Studio 6 build log
*.plg

# Visual Studio 6 workspace options file
*.opt

# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw

# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions

# Paket dependency manager
.paket/paket.exe
paket-files/

# FAKE - F# Make
.fake/

# CodeRush personal settings
.cr/personal

# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc

# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.config

# Tabs Studio
*.tss

# Telerik's JustMock configuration file
*.jmconfig

# BizTalk build output
*.btp.cs
*.btm.cs
*.odx.cs
*.xsd.cs

# OpenCover UI analysis results
OpenCover/

# Azure Stream Analytics local run output
ASALocalRun/

# MSBuild Binary and Structured Log
*.binlog

# NVidia Nsight GPU debugger configuration file
*.nvuser

# MFractors (Xamarin productivity tool) working folder
.mfractor/

# Local History for Visual Studio
.localhistory/

# BeatPulse healthcheck temp database
healthchecksdb

# Backup folder for Package Reference Convert tool in Visual Studio 2017
MigrationBackup/

# Ionide (cross platform F# VS Code tools) working folder
.ionide/

# Fody - auto-generated XML schema
FodyWeavers.xsd

##
## Visual studio for Mac
##


# globs
Makefile.in
*.userprefs
*.usertasks
config.make
config.status
aclocal.m4
install-sh
autom4te.cache/
*.tar.gz
tarballs/
test-results/

# Mac bundle stuff
*.dmg
*.app

# content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore
# General
.DS_Store
.AppleDouble
.LSOverride

# Icon must end with two \r
Icon


# Thumbnails
._*

# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent

# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk

# content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore
# Windows thumbnail cache files
Thumbs.db
ehthumbs.db
ehthumbs_vista.db

# Dump file
*.stackdump

# Folder config file
[Dd]esktop.ini

# Recycle Bin used on file shares
$RECYCLE.BIN/

# Windows Installer files
*.cab
*.msi
*.msix
*.msm
*.msp

# Windows shortcuts
*.lnk

# JetBrains Rider
.idea/
*.sln.iml

##
## Visual Studio Code
##
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json

Although it contains many files for Visual Studio, it also includes files that generally do not need to be managed on git, such as .DS_Store on Mac.

Reference Sites

Install .NET on Windows

11 Favorite Games

Mon, 12 Sep 2022 19:28:50 +0900

When I thought about my favorite games, they all ended up being hall-of-famers. Since there are many old games, if you haven’t played them yet, please give them a try.

Game Boy

The original Game Boy is a handheld game console released by Nintendo in 1989. Later, successor models such as Game Boy Color and Game Boy Advance were released.

① Sa・Ga2: Hihou Densetsu (Final Fantasy Legend II)

An RPG released by Square (currently Square Enix) in 1990. It’s a story where you earnestly collect treasures known as MAGI across various stages. This was the first RPG I ever played.

② Kirby’s Dream Land

An action game released by Nintendo in 1992. Developed by HAL Laboratory. It’s a game where you progress by inhaling enemies or inhaling air to float in the sky. The music and sound effects are also quite well done, making it a highly rhythmic title.

③ Pokémon Red and Green

An RPG released by Nintendo in 1996. Developed by Nintendo EAD, Game Freak, and Creatures. Afterwards, it was made into an anime and became explosively popular, but I’ve only played this first generation.

Super Famicom

A home video game console released by Nintendo in 1990. Overseas, it is also known as the SNES (Super Nintendo Entertainment System).

④ Super Mario Kart

A Super Famicom software released by Nintendo in 1992. A racing game where you compete for rank while obstructing opponents by throwing items like shells and bananas. I remember playing it together with family and friends.

⑤ Dragon Quest V: Hand of the Heavenly Bride

An RPG released by Enix in 1992. It features elements like choosing a marriage partner and making monsters you defeated into companions. I played it extensively until I recruited multiple Liquid Metal Slimes.

⑥ Final Fantasy V

An RPG released by Square in 1992. It features replayability elements where you choose a job and master its skills. Similar to Dragon Quest, I remember earnestly leveling up in caves.

⑦ Torneko no Daibōken: Fushigi no Dungeon

A roguelike game released by Chunsoft in 1993. The predecessor to the Mystery Dungeon series. Its feature is that the layout of the dungeon randomly changes every time. The catchphrase is “An RPG you can play 1000 times”.

⑧ Fushigi no Dungeon 2: Furai no Shiren (Mystery Dungeon: Shiren the Wanderer)

A roguelike game released by Chunsoft in 1995. The sequel to the Mystery Dungeon series’ “Torneko no Daibōken”. There are shops inside the dungeon where you can buy items. (If you leave the shop without paying, the shopkeeper will chase after you.)

⑨ MOTHER2 (EarthBound)

The second installment of the MOTHER series, released by Nintendo in 1994. Developed by Ape and HAL Laboratory. Later, MOTHER3 was released in 2006. Produced by Shigesato Itoi, the work is studded with a unique worldview and philosophical words.

⑩ The Legend of Zelda: A Link to the Past

An action-adventure game released by Nintendo in 1991. A game where you progress by collecting various items and solving slight puzzles. Various sequels have been released since then. (Reference)

Nintendo Switch

A home video game console released by Nintendo in 2017.

⑪ Splatoon 2

An action shooter game released by Nintendo in 2017. A game where you aim for victory by securing territory using ink or defeating opponents. The sequel, Splatoon 3, was released in 2022.

Command to prevent automatic generation of .DS_Store in macOS

Mon, 12 Sep 2022 16:03:42 +0900

The command to prevent the automatic generation of .DS_Store on macOS is as follows. Please execute it in the terminal.

1

defaults write com.apple.desktopservices DSDontWriteNetworkStores true

After executing the command, restart Finder.

1

killall Finder

To restore the setting, please run the following command.

1

defaults delete com.apple.desktopservices DSDontWriteNetworkStores false

As with the above, restart Finder after changing the setting.

1

killall Finder

Bulk Delete .DS_Store with PowerShell

Mon, 12 Sep 2022 10:11:42 +0900

Move the current directory to the target folder, and execute the following command to bulk delete .DS_Store including subfolders.

1

Get-ChildItem . -include '.DS_Store' -Recurse -Force | Remove-Item -Force

Available Shortcodes in HUGO

Sun, 11 Sep 2022 22:59:52 +0900

Available Shortcodes in HUGO

YouTube

{{<youtube 123456abc>}}

Twitter

{{<twitter 123456abc>}}

Instagram

{{<instagram 123456abc>}}

Flickr

{{<flickr 123456abc>}}

Vimeo

{{<vimeo 123456abc>}}

Others

Shortcodes

Side note

If you want to display {{< foo >}} on the site, you need to write {{</* foo */>}}.

Changing the Image Layout in PaperMod

Sun, 11 Sep 2022 18:50:40 +0900

In the default layout, images are placed in the center with a width of 100%. However, I felt this was a bit too large, so I tried wrapping the image under the title and changing the width to around 150px.

The changes made to the files are as follows.

blank.css

To change the margins, image sizes, and the number of displayed text lines, add the following code to blank.css.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


.entry-content {
 -webkit-line-clamp: 4;
}

.entry-footer {
 text-align: right;
}

.entry-cover {
 margin-bottom: initial;
 text-align: center;
}

.entry-cover img {
 border-radius: 4px;
 display: inline;
 max-width: 100%;
}

.post-meta {
 display: block;
 text-align: right;
}

post-entry.css

Since I couldn’t delete the definition in blank.css, I deleted the following line in post-entry.css.

1
2
3
4
5
6


.entry-cover img {
 border-radius: var(--radius);
 pointer-events: none;
 /* width: 100%; */ <- Delete this line
 height: auto;
}

list.html

To change the image layout, I modified the following section in list.html.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


<article class="{{ $class }}">
 <!-- {{- $isHidden := (site.Params.cover.hidden | default site.Params.cover.hiddenInList) }} --><!-- Moved down -->
 <!-- {{- partial "cover.html" (dict "cxt" . "IsHome" true "isHidden" $isHidden) }} --><!-- Moved down -->
 <header class="entry-header">
 <h2>
 {{- .Title }}
 {{- if .Draft }}<sup><span class="entry-isdraft">&nbsp;&nbsp;[draft]</span></sup>{{- end }}
 </h2>
 </header>
 <div style="display:flex;"><!-- Added -->
 <div style="max-width:150px;margin:11px 15px 0px 0px;"><!-- Added -->
 {{- $isHidden := (site.Params.cover.hidden | default site.Params.cover.hiddenInList) }}<!-- Moved from above -->
 {{- partial "cover.html" (dict "cxt" . "IsHome" true "isHidden" $isHidden) }}<!-- Moved from above -->
 </div><!-- Added -->
 <div style="width:100%;"><!-- Added -->
 {{- if (ne (.Param "hideSummary") true) }}
 <div class="entry-content">
 <p>{{ .Summary | plainify | htmlUnescape }}{{ if .Truncated }}...{{ end }}</p>
 </div>
 {{- end }}
 {{- if not (.Param "hideMeta") }}
 <footer class="entry-footer">
 {{- partial "post_meta.html" . -}}
 </footer>
 {{- end }}
 <a class="entry-link" aria-label="post link to {{ .Title | plainify }}" href="{{ .Permalink }}"></a>
 </div><!-- Added -->
 </div><!-- Added -->
</article>

It seems there are quite a few similar requests.

https://github.com/adityatelange/hugo-PaperMod/discussions/159#discussioncomment-247844

I would be grateful if this was supported in the upstream repository as well.

How to set up Twitter Card in PaperMod

Sat, 10 Sep 2022 18:41:22 +0900

Introduction

The PaperMod theme supports Twitter Cards. However, Twitter Card settings need to be described in config.toml or the header information of each article’s *.md. If set in both each article and config.toml, the header information of each article takes precedence.

How to Configure

config.toml

In config.toml, add an item named images under [params]. In images, describe the path to the image to be displayed on the Twitter Card. If placing the image in the static folder, specifying just the file name is sufficient.

1
2


[params]
 images = ["twitter_card.jpg"]

Folder structure

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


root
│ config.toml (Describe here)
├─content
│ └─posts
│ └─article folder
│ │ index.md (Describe here)
│ └─images
│ cover.png (Place here)
└─static
 twitter_card.jpg (Place here)

Header Information of Each Article

In the header information of each article, add an item named image under cover. If you set relative to true, you can specify it as a relative path from the article’s *.md.

1
2
3


cover:
 image: "images/cover.jpg"
 relative: true

If You Do Not Want to Display It at the Top of the Article

If you do not want to display a cover image at the top of the article, add an item named hidden under cover and set it to true.

1
2
3
4


cover:
 image: "images/cover.jpg"
 relative: true
 hidden: true

About Image Size

Based on the current specifications of PaperMod, it seems that Twitter Card sizes are only supported for summary_large_image. The appropriate size (resolution) for summary_large_image varies according to different sources, but around 800 x 418 (aspect ratio 1.91:1) seems good.

Reference Site 1 Reference Site 2

If possible, it is recommended to resize the image before posting.

How to Check Settings

To check Twitter Card settings, use the Twitter Card Validator. However, in my environment, the preview did not display properly, so if the preview does not appear, it is recommended to check once using a private account or similar before posting.

Using GitHub Copilot in IntelliJ IDEA

Sat, 10 Sep 2022 09:44:55 +0900

Introduction

GitHub Copilot is an AI-based code completion tool developed by GitHub. By installing the GitHub Copilot plugin in the IntelliJ IDEA development environment, you can also use GitHub Copilot in IntelliJ IDEA. A Github account is required for activation.

How to Install

Select Settings from the File menu in IntelliJ IDEA
Select Plugins, and search for “GitHub Copilot”
Install via the Install button
Click the Restart IDE button to restart IntelliJ IDEA The installation is complete once IntelliJ IDEA restarts.

Activation

Click the icon at the bottom right
Click Login to Github
Click the Copy and Open button
A browser will open. If you are not logged into Github, log in, paste the code using Ctrl+V, and click the Continue button
Click the Authorize GitHub Copilot Plugin button Activation is complete when the screen above is displayed.

Try it out

When you type a few characters in the IntelliJ IDEA editor, GitHub Copilot will start suggesting code completions. Enjoy the powerful code completion features provided by AI!

How to Install Go

Sat, 10 Sep 2022 00:48:17 +0900

Introduction

Go is a relatively new programming language released by Google in 2009. The Go compiler, tools, and libraries are released as open source. Also, Go is a statically typed language like C and Java, but it does not use pointers in the same way C does.

How to Install

Install Go

Installers for each platform are available from the site above.

Follow the instructions on the screen to proceed with the installation.

Installation is complete. It’s easy, isn’t it?

First Program

Save the following program as hello.go.

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Printf("Hello World\n")
}

If you execute go run hello.go from the command prompt or terminal, Hello, world! will be output.

If you want to compile, executing go build hello.go will generate hello.exe. Executing hello.exe will output Hello, world!.

You can also execute code on a web page

https://go.dev/play/

Japanese Documentation

http://go.shibu.jp/

The explanations necessary for learning Go are consolidated in the link above (Japanese translated version). Since technologies related to Go are open, the resources are rich enough that you don’t even need to buy a physical textbook.

Enjoy your Go life!

Hegel's Dialectic

Fri, 09 Sep 2022 23:13:19 +0900

What is Hegel’s Dialectic?

Hegel grasped the positive significance of the contradictions that reason falls into, and argued that in general, all finite things produce their opposites driven by inherent contradictions, and through mediation, they are both sublated to a higher stage, establishing this as the principle of all movement in the real world. (From Kotobank)

My interpretation is that all ideologies, assertions, and ideas in the real world are not simply correct in a one-sided manner. They always contain contradictions within them, and in the process of understanding and incorporating these opposing structures, one’s awareness develops to a higher level.

I think this applies not only to human thinking but also to all phenomena in the natural world.

For all matter, every action has a reaction; every movement involves friction; gravity is not just for the sun and earth but mutually affects all matter. The currents of rivers and winds don’t just flow in one direction; they are subjected to various forces, changing their flow moment by moment.

Speaking in technical terms, computer programs also inherently contain bugs, and by resolving them, they evolve into higher-level programs. A program without bugs could be considered an uninteresting, stagnant program. It will eventually become obsolete.

The surrounding environment is constantly changing with the times. Instead of ignoring self-contradictions, strangely justifying them, or rigidly fixing our mindsets, I want us to always review our ways of thinking and perceiving things, flexibly adapting our thoughts.

Kamukura (Ramen) for the First Time in Years

Fri, 09 Sep 2022 21:45:19 +0900

I went to Kamukura (Ramen) for the first time in years.

Green Onion Kimchi Ramen

It was delicious. It’s a flavor that makes you want to eat it every once in a while.

Enumerate Prime Numbers in Rust

Fri, 09 Sep 2022 07:08:49 +0900

I wrote a program to enumerate prime numbers in Rust.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}

Relaxing Jazz

Thu, 08 Sep 2022 17:40:26 +0900

Relaxing Jazz Playlist

Cafe Music

Thu, 08 Sep 2022 08:39:03 +0900

Up-tempo

Electro Swing Collection

Electro Swing Mix 2019 Vol.3

lofi hip hop radio(Live)

LoFi Jazz

This is the motivation to study hard every day | 5 hour lofi hip hop / study / work / chill beats

Videos that Boost Motivation

Thu, 08 Sep 2022 02:22:52 +0900

It’s okay even if your efforts aren’t recognized

45年の人生で手に入れた。ぐずぐずした時、いつも背中を押してくれる言葉たち。 pic.twitter.com/EQgmujOSpg
— いれぶん (@eleven_s_s) September 6, 2022

Values are much more diverse

Yusuke Narita “Of the unhappiness that humans hold”

The actions you take are reflected directly

Hayao Miyazaki’s thoughts

My Current Main PC Specs

Thu, 08 Sep 2022 01:55:00 +0900

Here are the specs for my main PC.

Item Name	Value
Processor	Intel Core i7-8700K CPU @ 3.70GHz 3.70 GHz
Memory	32.0 GB
System Type	64-bit operating system, x64-based processor
OS	Windows 11 Enterprise (Version 21H2, Build 22000.856)
Manufacturer	MouseComputer Co., Ltd.

Simple Icon Collection Sites

Wed, 07 Sep 2022 16:46:56 +0900

Google Material Symbols and Icons

https://fonts.google.com/icons

GitHub Octicons

https://primer.style/octicons/

Sargam Icons

https://sargamicons.com/

Thousands of free icons

https://icon-icons.com/

flaticon

https://www.flaticon.com/

ICONFINDER

https://www.iconfinder.com/

iconfont

https://www.iconfont.cn/

open-iconic

https://github.com/iconic/open-iconic

Changing the Color Scheme of PaperMod

Wed, 07 Sep 2022 15:30:21 +0900

I changed the color scheme of the PaperMod theme. I referred to the following for the method.

https://github.com/adityatelange/hugo-PaperMod/discussions/645

The CSS path is as follows.

themes/PaperMod/assets/css/extended/blank.css

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


:root {
 --entry: #fbf7ef;
 --primary: rgba(113, 103, 91, 1.00);
 --secondary: rgba(113, 103, 91, 0.95);
 --tertiary: rgba(113, 103, 91, 0.50);
 --content: rgba(113, 103, 91, 0.85);
 --hljs-bg: #34231B;
 --code-bg: #ebe4d7;
 --border: #fdfaf5;
 --theme: #fbf7ef;
}
.dark {
}

No changes for dark mode for now.

A Child's Consideration

Wed, 07 Sep 2022 04:40:52 +0900

When Mom was sick and resting in bed, I asked my daughter (2 years old) about preparing dinner or the bath, saying, “Should we ask Mom to do this?” She replied, “No, because she’s sleeping!” and I realized that she was being considerate in her own childish way.

I’m glad she seems to be growing into someone who is considerate of others.

Management Notes

Wed, 07 Sep 2022 02:36:11 +0900

Finding emerging businesses

Ask people inside Hot Pepper or tax accountants about businesses that are starting to trend
Do not enter a business that is already saturated with strong competitors
Only enter businesses where you are confident you can attract customers (do not enter businesses where existing operators are using special, inimitable customer acquisition methods)

Imitate thoroughly

Research the business logic before entering
Copy it thoroughly
Then improve upon it

Systematize

Systematize everything into manuals so anyone can do it effortlessly
Come up with ideas to increase sales (more customers, higher unit price per customer) and reduce expenses (labor costs, advertising costs), and systematize them

Management Philosophy

A business owner’s philosophy is “to maximize corporate profits,” nothing more and nothing less
Making social contribution or being liked by employees your management philosophy is a bad idea (consider that these will naturally follow later)

My Thoughts on Japan

Tue, 06 Sep 2022 02:24:11 +0900

I’d like to organize my thoughts on what I find strange or think about Japanese society.

About Student Loans

Speaking of scholarships in Japan, most of them are interest-bearing student loans that must be repaid. In addition, university tuition fees have been continuously increasing since 1950, and the percentage of students receiving these loans is also on an upward trend.

On the other hand, it seems that the recent average total borrowing amount reaches 3.24 million yen.

For users of the Japan Student Services Organization scholarships, the average total borrowing amount is 3,243,000 yen. Reference

If someone is burdened with a debt of 3 million yen at the age of 22 when graduating from university, naturally, their marriage age will be delayed, and it will obviously become harder to have children. I think this is one of the causes of Japan’s declining birthrate problem.

Pervasive Self-Responsibility Theory

This is somewhat based on my senses, but I feel there is a cold social attitude of “other people’s business is their business.” It might be inevitable that this trend occurs after decades of ongoing economic recession, but Even regarding the aforementioned student loan issue, it is not viewed as a problem for society as a whole, and I feel that the voices of young people and minorities, who have fewer votes in elections, are being ignored. Even though, in the long run, it is actually a very important issue for Japan as a whole.

Instead of heading towards excessive competition, I think a spirit of everyone helping out when there are people, generations, or groups in need is extremely important for a country. (However, I feel a sense of discomfort when the government insists on “self-help and mutual help.” I want them to proactively work on rescuing the vulnerable.)

(This article will be updated as needed.)

Characteristics of Japanese People as Seen by AI

Yes, I will explain the characteristics of Japanese people.

[Good Aspects]

Japanese people have a culture of being polite and paying attention to respect and how they treat others.
Punctuality is strictly enforced, and being on time is highly respected.
A collectivistic mindset is strong, with an emphasis on teamwork and cooperation.
Cleanliness is valued, and there is a tendency to be enthusiastic about manners and cleaning in public spaces.
Gifts and souvenirs are cherished, and a culture of expressing gratitude is widespread.

[Bad Aspects]

They may be poor at asserting their personal opinions and have a tendency to avoid clashes of opinion.
A very strict work culture exists, and overtime work or death from overwork (karoshi) is sometimes seen as a problem.
Issues of discrimination or exclusion towards foreigners remain, and harmony with the international community is sometimes called into question.
There is an authoritarian tendency, and it is sometimes pointed out that they often accept the opinions of bosses or elders unconditionally.
It is a closed society, and it is sometimes criticized for having a tendency to struggle to accept outside cultures and values.

Getting Started with Rust

Tue, 06 Sep 2022 00:12:36 +0900

Introduction

Rust is a relatively new programming language that allows you to write fast and memory-efficient modules using modern syntax. It supports multi-platform and is also used in the world of WebAssembly and embedded systems. Notably, it has been adopted by Firefox, Dropbox, and Cloudflare.

It is also gaining attention as an alternative to C++.

Installation

Install Rust

Installation methods for each platform are published on the site above.

First Program

Save the following program as main.rs.

1
2
3


fn main() {
 println!("Hello, world!");
}

When you run rustc main.rs from the command prompt or terminal, it will be compiled, and running ./main (main.exe on Windows) will output Hello, world!.

Japanese Documentation

The Rust Programming Language Japanese Version

The explanations necessary for learning Rust are gathered in the link above (Japanese translation version). It is so comprehensive that there is no need to purchase a Rust textbook.

If you want to try it on the Web

If you want to try it on the Web without installing a compiler, you can use The Rust Playground. When you enter the code and press the “Run” button, it will be compiled and executed on the Web.

Changed my internet environment from Flets Hikari to J:COM

Mon, 05 Sep 2022 22:48:51 +0900

Changed my home internet environment from Flets Hikari to J:COM

On a friend’s recommendation, I changed my home internet connection from Flets Hikari to J:COM. The reasons are:

The monthly fee will be cheaper. 3,619 yen → 2,180 yen
Internet speed will increase from 100MBps to 320MBps

These points.

Impressions after using it

It’s been about a week since the switch, and so far there are almost no problems. I’ll note a few things I noticed below.

After actually changing, I noticed that the download speed definitely became faster, going from 60MBps to just under 320MBps. However, the upload speed, which was around 40MBps with Flets Hikari, dropped to about 10MBps. This seems to be a specification on J:COM’s side. For now, I won’t be doing any streaming or uploading massive amounts of data, so I’ll wait and see.

Also, recently my family and I are mainly working remotely, and today for the first time the internet went down for a few tens of minutes. It recovered automatically, but it might not be a very good omen. It hasn’t even been a week since the switch, though…

As a side note, J:COM regulates P2P communication, so it seems you won’t get good speeds on P2P apps. Those who use P2P should be careful.

About the service

At the time of signing up, I was told that if I join Netflix or Disney+, I could get 40,000 yen worth of QUO cards, which offsets the respective service contract fees and makes the average monthly fee a bit cheaper, so I signed up for the services at the same time as the contract. It seems Netflix is a 1-year contract and Disney+ is a half-year contract, and I need to complete the cancellation procedures myself.

Since it hasn’t been long since the switch, if I have any additional usability issues or thoughts, I’d like to update the article again. See you,

09/06 It became hard to connect to the internet

2022/09/06 around 13:13 for about 3 to 5 minutes
2022/09/06 around 13:30 for about 3 to 5 minutes
And several times after that…

It seems DNS is the problem, so I configured the DNS server referring to here. We’ll see how this goes… Even with the DNS setting, it fell into a state where it couldn’t connect, so when I inquired with support, they said they were doing emergency maintenance… Right after inquiring, the connection status improved, so I think they took some sort of countermeasure.

[HUGO] Display Preview in Local Environment

Mon, 05 Sep 2022 12:28:01 +0900

Installing HUGO

Download

Download HUGO

From the site above, download and extract the Windows module that matches your environment. In my case, I downloaded “hugo_0.102.3_Windows-64bit.zip”.

Extract

Extract the downloaded zip file and copy the hugo.exe inside it to a folder, for example, C:\bin.

Register to Environment Variables

Register it to the environment variables so that you can run hugo.exe from anywhere. This is the operation on Windows 11, but I think it can be registered with the following steps.

Press Win+Pause to open the About page
Click Advanced system settings
Click Environment Variables
Select Path and click Edit
Click New, enter “C:\bin” on a new line, and click OK to close the dialog

Preview the Blog

In the command prompt, navigate to your HUGO blog folder and run the following command.

hugo server -D

The execution result is as follows. (The -D option is for displaying draft articles.)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


C:\Users\win11\IdeaProjects\kenji.blog>hugo server -D
Start building sites …
hugo v0.102.3-b76146b129d7caa52417f8e914fc5b9271bf56fc windows/amd64 BuildDate=2022-09-01T10:16:19Z VendorInfo=gohugoio

 | JA
-------------------+-----
Pages | 39
Paginator pages | 0
Non-page files | 7
Static files | 0
Processed images | 0
Aliases | 13
Sitemaps | 1
Cleaned | 0

Built in 161 ms
Watching for changes in C:\Users\win11\IdeaProjects\kenji.blog\{archetypes,content,themes}
Watching for config changes in C:\Users\win11\IdeaProjects\kenji.blog\config.toml
Environment: "development"
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
Press Ctrl+C to stop

The address will be output when executed (in the example above, http://localhost:1313/), so copy the address to your browser. The preview will automatically update every time you save a file. To end the preview, press Ctrl+C in the command prompt.

Movies Featuring Mathematicians

Mon, 05 Sep 2022 10:41:00 +0900

Here are my 3 recommended movies featuring mathematician protagonists.

A Beautiful Mind

A film depicting the life of a real-life American genius mathematician. A surprising twist at the end. Russell Crowe’s performance in the lead role is excellent.

Enigma

A 2001 film adaptation of Robert Harris’s novel “Enigma”. — Wikipedia

A story about decrypting the codes generated by the German Enigma cipher machine.

The Imitation Game

Another story about cryptanalysis dealing with the Enigma. I love the atmosphere of that era.

The Man Who Knew Infinity

A film depicting the interaction between Cambridge University mathematician G.H. Hardy and Indian mathematician Srinivasa Ramanujan. You can feel the beauty of mathematics.

The Theory of Everything

A film depicting the life of Dr. Stephen Hawking.

Particle Fever

Today's Work Environment

Sun, 04 Sep 2022 14:29:09 +0900

Children’s Desk

The time when my children are sleeping is when I can focus on my work. Let’s go play at the park after nap time. If I only had a Lightning to HDMI adapter for my iPad, I could work at the desk on the right…

Adding a command to insert a date in IntelliJ IDEA

Sun, 04 Sep 2022 05:59:04 +0900

Introduction

I use IntelliJ IDEA when writing this blog. It works well with Git and is convenient because it shows markdown previews. Since I have to write the date in the md header every time I write a blog post, and there doesn’t seem to be a shortcut for inserting dates, I tried creating a command to insert the date, using the following site as a reference. I hope this helps.

Is there a shortcut for inserting date/time in IntelliJ IDEA?

Setup Procedure

Open “File” > “Settings…” from the menu
Select “Editor” > “Live Template” > “HTML/XML” and click “+”
Select Live Template
Enter “date” in Abbreviation
Enter “Insert date and time” in Description
Enter “$date$” in Template Text
Click Edit Variables button
Enter “date” in Name
Enter date("yyyy-MM-dd'T'HH:mm:ss'+09:00'") in Expression
Click OK to close the dialog
Click Define or Change and check “Everywhere”
Click OK to close the dialog
Type “date” in the code editor and press Enter. If the date “2022-09-04T05:59:04+09:00” is inserted, the setup is complete!

That’s all.

Conclusion

I will continue to share more IntelliJ IDEA tips if I find them!

I Started a Blog

Fri, 02 Sep 2022 07:23:00 +0900

I Started a Blog

Something like fireworks, code is here

Hello everyone. Just on a whim, I decided to start a blog.

I don’t really have a grand purpose like “I want to broadcast this!”, but I thought it would be nice to have a place where I can just write down things about technology, daily life, or whatever comes to mind.

I’m not going to try too hard, and I plan to use it like a notepad.

Made with Hugo

This blog is made with a static site generator called “Hugo”. I found a nice theme, so I decided to use it on a whim. (It’s a secret that it took me about 2 hours to choose a theme)

I’ll casually write down things about code or tools I’m interested in as memos.

Morning Komeda Coffee Story

By the way, this morning, I woke up a bit early and went to Komeda Coffee. I left at 8:30, walking leisurely while breathing the morning air.

I ordered a Mini Shiro-Noir and Cafe Au Lait “A” Morning Set. I think it was about 800 yen? (I don’t remember)

Morning cafes are nice. Having some time to just space out before work makes me feel like the day will go well.

With that said, I’ll be writing casually from now on. I plan to mix in technical talks and daily life stuff.

Nice to meet you!

Recommended Chrome Extensions for Salesforce

Mon, 02 May 2022 10:39:36 +0900

Salesforce DevTools

You can search for custom fields and export the fields of custom objects in bulk.

It’s also convenient to be able to build SOQL on the spot.

Salesforce DevTools

Salesforce advanced Code searcher

This is useful when searching for Salesforce code.

Salesforce advanced Code searcher

[Complete Mathematical Guide] Why the Ultimate Classical 'GNFS' Loses to Quantum Algorithms: The Paradigm Shift in Prime Factorization

Mon, 01 Jan 0001 00:00:00 +0000

Information security in the modern internet society is protected by public-key cryptography, such as RSA cryptography. The basis for the security of RSA relies on the fact that “the prime factorization of huge composite numbers is computationally extremely difficult.”

In this article, we will unravel the mathematical mechanism of the “General Number Field Sieve” (GNFS), which is the most powerful prime factorization algorithm for classical computers. We will also dive deeply into why it is completely defeated by “Shor’s Algorithm,” discovered by Peter Shor, exploring this paradigm shift thoroughly with mathematical formulas and conceptual diagrams.

1. The Approach to Prime Factorization in Classical Computing: Evolution from Fermat’s Factorization Method

The prime factorization problem is the problem of finding prime numbers $p$ and $q$ such that $N = p \times q$ for a given composite number $N$.

The basic idea reduces to finding non-trivial $x$ and $y$ that satisfy the following congruence:

$$ x^2 \equiv y^2 \pmod N $$

By rearranging this, we get:

$$ x^2 - y^2 \equiv 0 \pmod N $$ $$ (x - y)(x + y) \equiv 0 \pmod N $$

Here, if $x \not\equiv \pm y \pmod N$, we can obtain a non-trivial factor of $N$ by calculating $\gcd(x-y, N)$ or $\gcd(x+y, N)$. This fact is the foundation of modern prime factorization algorithms like GNFS.

2. The Ultimate Classical Algorithm: The Depths of the “General Number Field Sieve” (GNFS)

“GNFS” is the fastest known prime factorization algorithm for classical computers today. Its time complexity requires sub-exponential time.

Complexity of GNFS

Letting the number of digits (bits) of the number $N$ be $b = \log_2 N$, the computational complexity of GNFS is expressed as follows:

$$ O\left( \exp \left( \left(\frac{64}{9} b\right)^{1/3} (\log b)^{2/3} \right) \right) $$

As can be seen from this formula, the computational complexity is not polynomial time, but “sub-exponential time,” which is slightly slower than exponential time. Still, as the number of digits increases, the computation time grows astronomically.

Mathematical Mechanism of GNFS

GNFS consists broadly of four steps:

Polynomial Selection
Sieving
Matrix Reduction
Square Root

2.1. Polynomial Selection and Number Fields

First, we select irreducible polynomials $f(x)$ and $g(x)$ with integer coefficients. These are set to have a common root $m$ modulo $N$. That is,

$$ f(m) \equiv 0 \pmod N $$ $$ g(m) \equiv 0 \pmod N $$

Usually, $g(x)$ is chosen as a linear polynomial $g(x) = x - m$. If we let $\alpha$ be a root of $f(x)$, a “Number Field” $\mathbb{Q}(\alpha)$ is constructed. We compare operations in the ring of $\mathbb{Q}(\alpha)$ and operations in the normal integer ring $\mathbb{Z}$ through the homomorphism $\phi: \alpha \mapsto m$.

2.2. Sieving

Next, we search for a massive number of coprime integer pairs $(a, b)$. The goal is to find pairs such that the following two values are both “B-smooth” (composed only of relatively small prime factors):

$a - bm$ (value over the integer ring)
$b^d f(a/b)$ (corresponding to the norm $N(a - b\alpha)$ over the number field)

Here, a high-speed search method called a “Sieve” is used. This efficiently extracts $(a, b)$ pairs that satisfy the conditions from a vast number of candidates.

2.3. Linear Algebra over GF(2) (Matrix Reduction)

From the collected pairs $(a, b)$, we construct exponent vectors and find the left null space of a massive sparse matrix over $\mathbb{F}_2$ (the field with only elements 0 and 1).

We find a vector $v$ as a solution so that the relations $ \prod (a_i - b_i m) $ and $ \prod (a_i - b_i \alpha) $ both become squares. This is nothing but solving a system of linear equations:

$$ M \mathbf{x} \equiv \mathbf{0} \pmod 2 $$

Advanced numerical algorithms such as the Block Lanczos Algorithm and the Block Wiedemann Algorithm are utilized here.

2.4. Square Root

Finally, we take square roots in both the number field and the integer ring to derive the relation $x^2 \equiv y^2 \pmod N$. Then, we calculate $\gcd(x-y, N)$ to obtain the factor.

3. The Breakthrough by Quantum Computing: “Shor’s Algorithm”

While GNFS requires sub-exponential time, “Shor’s Algorithm,” published by Peter Shor in 1994, can solve this problem in “polynomial time” by using a quantum computer.

Complexity of Shor’s Algorithm

When the number of qubits is $O(\log N)$, the time complexity is as follows:

$$ O((\log N)^3) $$

This means it does not cause an exponential explosion with respect to the number of bits. This is an astonishing result: even for huge composite numbers where the complexity of “classical computing” exceeds the lifespan of the universe, they can be cracked in hours to days with “quantum computing.”

Overview of Shor’s Algorithm: Reduction to the Period-Finding Problem

Shor’s algorithm cleverly reduces the prime factorization problem to a “period-finding problem.”

Choose a random integer $a$ coprime to $N$ ($1 < a < N$).
Define the function $f(x) = a^x \bmod N$.
Find the period $r$ of $f(x)$, i.e., the smallest positive integer $r$ such that $a^r \equiv 1 \pmod N$.
If $r$ is even, check if $a^{r/2} \not\equiv -1 \pmod N$, and calculate $\gcd(a^{r/2} \pm 1, N)$ to obtain a prime factor.

“Finding the period $r$” in step 3 is the bottleneck that requires exponential time on classical computers, but quantum computers solve this instantly using “quantum superposition” and the “Quantum Fourier Transform” (QFT).

4. Quantum Fourier Transform (QFT) and Period Extraction

Let’s look in detail with formulas at the manipulation of quantum states, which is the core of Shor’s algorithm.

4.1. Generation of Quantum Superposition

First, we prepare two quantum registers. Register 1 holds a superposition state of inputs $x$, and Register 2 holds the computation result $f(x)$. We apply the Hadamard Transform to the initial state $|0\rangle |0\rangle$ to create a superposition of all possible $x$.

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |0\rangle $$

(Here $Q$ is a power of 2 satisfying $N^2 \le Q < 2N^2$)

Next, we use a quantum oracle $U_f$ to compute $f(x) = a^x \bmod N$ and store it in Register 2.

$$ |\psi_2\rangle = U_f |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |a^x \bmod N\rangle $$

Let’s assume here that we measure Register 2 (in reality, the mathematical structure is the same even without measurement). If a value $y = a^{x_0} \bmod N$ is observed, the state of Register 1 collapses into a superposition of all $x$ such that $f(x) = y$. Letting the period be $r$, such $x$ are $x_0, x_0 + r, x_0 + 2r, \dots$

$$ |\psi_3\rangle = \frac{1}{\sqrt{M}} \sum_{k=0}^{M-1} |x_0 + kr\rangle $$

(Here $M \approx Q/r$ is the number of terms)

This state inherently contains information about the period $r$, but direct measurement will only yield a random $x_0 + kr$, and the period $r$ remains unknown. This is where QFT comes in.

4.2. Application of the Quantum Fourier Transform (QFT)

QFT is an operation that performs a discrete Fourier transform on the amplitudes of quantum states. The action of QFT on state $|x\rangle$ is defined as follows:

$$ \text{QFT} |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} e^{2\pi i \frac{xy}{Q}} |y\rangle $$

When this is applied to $|\psi_3\rangle$, phase interference (quantum interference) occurs.

$$ |\psi_4\rangle = \text{QFT} |\psi_3\rangle = \frac{1}{\sqrt{MQ}} \sum_{y=0}^{Q-1} \sum_{k=0}^{M-1} e^{2\pi i \frac{(x_0 + kr)y}{Q}} |y\rangle $$

Expanding the sum in this equation reveals the part:

$$ \sum_{k=0}^{M-1} e^{2\pi i \frac{kry}{Q}} $$

This sum of a geometric series reinforces each other (Constructive Interference) only when $ry/Q$ is close to an integer, and cancels each other out (Destructive Interference) otherwise.

Therefore, the state $|y\rangle$ measured with high probability will be an integer $y$ that satisfies the condition:

$$ \frac{y}{Q} \approx \frac{c}{r} $$

(where $c$ is some integer).

4.3. Identifying the Period via Continued Fraction Expansion

After obtaining $y$ through measurement, we perform a “Continued Fraction Expansion” of $y/Q$ using a classical computer. This allows us to calculate the convergent fraction $c/r$ of $y/Q$, and extract candidates for the period $r$ from the denominator with high efficiency.

5. Comparison of Conceptual Models and the Paradigm Shift

To intuitively understand the difference between GNFS and Shor’s algorithm, we present a conceptual diagram using Mermaid notation.

Conceptual Diagram of Shor’s Algorithm via Quantum Circuit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


graph TD
 A[Initial State: 0...0] --> B[Superposition of all states via Hadamard Transform]
 B --> C[Modular exponentiation a^x mod N]
 C -->|Quantum Entanglement| D[Collapse to a state with periodicity]
 D --> E[Quantum Fourier Transform QFT]
 E -->|Probability amplification via interference| F[Measurement: Obtain y]
 F --> G[Classical processing: Continued Fraction Expansion]
 G --> H[Discovery of period r]
 H --> I[Calculate prime factors of N]

 style A fill:#f9f,stroke:#333,stroke-width:2px
 style E fill:#bbf,stroke:#333,stroke-width:2px
 style I fill:#bfb,stroke:#333,stroke-width:2px

The Essence of the Paradigm Shift

GNFS takes the approach of “searching for relations within a mathematical space (number field).” However, since the search space expands exponentially with the number of digits, it becomes virtually unsolvable for classical computer capabilities (even including parallelization) when the key length exceeds 2048 bits.

On the other hand, Shor’s algorithm utilizes the “wave nature of quantum interference.” It simultaneously evaluates all computation paths in a superposition state, uses QFT to cancel out (destructively interfere) unnecessary answers, and amplifies (constructively interferes) only the probability amplitude of the period that is the correct answer. Through this, instead of searching space, it realizes a completely different dimensional approach of “making the correct answer itself surface.”

6. Summary

In this article, we deeply compared the mathematical backgrounds and algorithmic structures of “GNFS,” the pinnacle of classical limits, and “Shor’s Algorithm,” which demonstrates the power of quantum computing.

While GNFS drove computational complexity down to sub-exponential time by employing mathematical tricks such as polynomial selection and massive matrix calculations, Shor’s algorithm fused the fundamental principles of quantum mechanics—superposition and interference—with a mathematical tool (QFT), achieving a breakthrough to polynomial time in one stroke.

Currently, Fault-Tolerant Quantum Computers (FTQC) capable of executing Shor’s algorithm at a practical scale (thousands of qubits) do not exist. However, the very existence of this mathematical and theoretical paradigm shift is the primary reason why the transition to Post-Quantum Cryptography (PQC) is urgently being accelerated worldwide today.

Links

Mon, 01 Jan 0001 00:00:00 +0000

Search

Mon, 01 Jan 0001 00:00:00 +0000