Programming on kenji.blog

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.

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.

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

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.

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.

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

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.

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""}]}"

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)

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

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.

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

[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 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

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

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

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.

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

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

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

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!

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);
 }
}

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.

Programming on kenji.blog

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

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

What happens when the free trial ends?

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

Here is the correct way to cancel!

Summary

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

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

1. Delete metadata of a single Excel file

2. Batch process all Excel files in a folder

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

For Word

For PowerPoint

Conclusion

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

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

🔧 Step 1: Prepare llama.cpp

1-1. Required Environment (Minimum)

1-2. Get and Build llama.cpp

📦 Step 2: Download and Convert the TinyLLaMA Model

2-1. Get the Original Model from HuggingFace

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

2-3. Model Quantization (Size Reduction)

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

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

🧱 Step 4: Compilation Method (Example)

✅ Example Structure of Output (Organized)

🧠 Additional Notes for Applying to Use Cases

📌 Summary

Advantages and Disadvantages of Creating Programs with Win32API + C++

The Appeal and Challenges of Developing with Win32API + C++

Advantages

Ultra-Fast Native Execution

High Flexibility and Freedom

Easy to Distribute Without Runtimes

Capable of Creating Lightweight Apps

Advanced OS-Level Control is Possible

Disadvantages

Low Development Efficiency

Maintainability Tends to Decrease

Difficult to Support Modern UI

No Cross-Platform Support

Extremely High Learning Cost

Suitable Uses

Unsuitable Uses

Evaluation Summary

Conclusion

FizzBuzz

What exactly is FizzBuzz, anyway?

Is it true that “you’re disqualified as a programmer if you can’t write FizzBuzz”?

It’s not about whether you can do it, but whether you’re in a “state” to do it

The pitfall of the common advice to “just train and you’ll be fine”

That being said, FizzBuzz is still a good question

In conclusion

Tower of Hanoi

Tower of Hanoi

What is the Tower of Hanoi?

Let’s Solve the Tower of Hanoi in Python

How Long Does It Take to Move 64 Disks?

Conclusion

Steps to Execute PowerShell from C++ via C++/CLI DLL

🎯 Steps to Execute PowerShell from C++ via C++/CLI DLL (Visual Studio 2022 / C++)

✅ Overall Structure

🔹 ① CLI Wrapper DLL (C++/CLI)

🔹 ② Native C++ Caller

🔧 Step 1: Create CLI Wrapper DLL Project

1. Create Project

2. Add NuGet Package

3. Implement CLI Side Code

PowerShellWrapper.h

PowerShellWrapper.cpp

🔧 Step 2: Call from Native C++

1. Create C++ Console App Project

2. Add Reference

3. Execution Code (main.cpp)

💡 Note (IDL / TLB / COM Registration)

✅ Final Structure

Android (Google Pixel) Device Software Restoration (Initialization and Repair) Procedure

Android (Google Pixel) Device Restoration Procedure

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

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