I wrote this episode twice. I had missed something very simple. After finishing the piece, another topic came to mind, so I pressed Control and N to create a new document. A new file opened. After I finished that piece too and opened the menu, nothing appeared in the preview of the previous piece. I had a bad feeling, but I thought surely not and opened the file. There really was nothing in it. It had disappeared.
In truth, preventing writing from disappearing was something I had cared about a great deal from the beginning. That is why the text file I saved as a test, back when I first made a firmware with Gemini that supported only Korean and English, is still on the SD card. Later, when I revised the code for power shutdown, I made sure that whether the device turned off automatically because of the sleep timer or whether I turned it off by pressing Control L, it would always save the current file before shutting down. If the device’s power was forcibly cut, nothing could be done, but otherwise it was made to save no matter what. I thought that was enough, but now I saw that two more things were needed: autosave at fixed intervals, and saving the current file before opening a new file. It sounds obvious, but in the case of a standalone program that operates without relying on an operating system, those obvious things have to be planted one by one. That was a lesson I had already learned long ago while making the keyboard layouts, but I never dreamed I would rediscover it after completing the firmware and using it well. Right now I am working on a separate solo project and pushed myself a little too hard, so my weekly Codex credits have run out and I am waiting. Once the limit resets, I will update the firmware first. Recently, someone posted in a ZeroWriter-related Discord that my firmware was good for writing Polish, so I had been in an elevated state. That person too will probably run an online update for the first time once I release the new firmware version.
In any case, after the previous post, the last remaining task was synchronizing the writing list. At the time, I did not actually think it would be the last. I had been improving, one by one, the things that felt inconvenient to me while using it, so in some ways it may have looked like a haphazard patchwork program with no roadmap at all. Fortunately, though, it is only a tool for writing. It is not software installed on a machine that has to do something creative or active on its own, so I think that much can be tolerated. So I thought writing synchronization was simply the problem or task that had to be solved at that moment, and that once it was done, I would create and attach yet another task.
But once the direction was decided, synchronizing the writing list was not that difficult. Deciding the direction was the hard part. The best option would have been to make a homepage and connect the device to it. If I were the only one using it, there would have been no problem. But because this was a public project, users would also have to be able to make a similar space. And if they were really just people who write, people who simply wanted a writing tool, I thought they might not want to spend their time on something like that. Or if they had never done it before, they might get scared and simply give up. But if I made an easy-to-connect website for them, that seemed like something the manufacturer should be doing. If I made my firmware, added a function that connected to that page, and then said, “Buy the machine, sign up for this website, and use this firmware to write conveniently,” it could be taken, in one sense, as a sign that I wanted to pick a fight with the manufacturer. More than anything, it would be over the moment the manufacturer provided a similar service. Then, finally, a good idea came to me. I could use the very fact that I was releasing this firmware on GitHub in reverse. To use this firmware meant that the user at least knew how to access GitHub.
“Codex, when we made the GitHub repository before, I saw that it could be made private too. If I make a private repository, could I use that as my writing storage?”
“Yes. If you provide a token, pull and push functionality can be implemented without much difficulty.”
“Do it.”
Codex told me how to create a private repository and issue a token. After I followed those steps, Codex revised the existing device-access webpage file, and I put it onto the SD card. A little later, Codex said the firmware revision was complete and asked whether I wanted to build and upload it.
“Let’s upload twice. I need to make one more revision first. Do not raise the version for this revision.”
I thought that if the webpage code was also modified, it would be convenient to have the webpage file downloaded to the SD card together with it. If the firmware could change automatically, there seemed to be no reason to manually put in the auxiliary file every time. First, I proceeded by uploading the update directly through the webpage. From now on, when a new version comes out, this firmware will also download other files uploaded to the release. I built the same file again with only the version changed. I uploaded it to the GitHub release and uploaded the webpage file with it. Commit. A new release was created, and when I connected the device to Wi-Fi and opened the webpage, an update mark appeared. I ran the update. Good.
Now it was time for synchronization. Originally I had planned to run writing synchronization from the webpage, but it felt cumbersome. I thought it would be better to make this possible directly from the device. I considered trying it once and, if it was too slow, doing it that way, but it felt ironic that a device would connect to an external website over the internet to synchronize, yet require another device to access it as well. So I decided it would be better to revise the menu.
“Codex. Let’s make just one more change. Add a Sync menu at the very top of the device menu. When I select it, make it synchronize automatically.”
Something like this is made quickly. I modified the GitHub release, but because the release version was the same, automatic updating was not possible, so I updated by uploading the file manually.
After the device rebooted automatically, I selected the Sync menu and pressed Enter. Wi-Fi connection… failed.
“Why can’t it catch Wi-Fi? It just did a moment ago.”
“I had made it call Wi-Fi data only when it was in the Network menu. I will fix it.”
I updated it again, selected the Sync menu, and pressed Enter. Wi-Fi connection… success.
20 files updated.
1/20 2/20 3/20… 20/20 success…
Oh, this is fascinating. I slightly edited one piece of writing.
One different part detected.
1/20 2/20 3/20… 20/20 success…
“Codex, Codex, this is strange.”
“It was set to overwrite everything on GitHub unconditionally. I will correct it.”
Again… Wi-Fi connection success, one different part detected, one push, 1/1 success.
Success. From that point on, after writing, I began synchronizing immediately and then accessing GitHub on my phone to copy the writing. I had no idea it could be this convenient. I had already been satisfied with simply not having to remove and reinsert the SD card…
Now I thought this firmware was not perfect, but at least no longer needed to be revised. That was before I lost today’s writing. So, planning to post more actively on Reddit, I visited the homepage made with GitHub again.
I had done quite a lot with GitHub. First, I had made the ZeroWriter firmware public on GitHub. GitHub also had a service that could make it look like a website, so I set up the code page and the website separately. On Reddit, I link to the website, and on the website, there is a link to the code page. Second, there is a private repository used for synchronizing writing through the firmware. Third, there is a webpage unrelated to ZeroWriter. It is a space where I post English translations of pieces uploaded to my blog or Brunch. ChatGPT translates them, and when I put the translated files into a specific folder of another private repository, Codex made code that publishes them like a blog on a public webpage. The homepage I said I visited was the first one: the space attached to the repository where the firmware was made public, configured to look like a website.
Ize Compose. That was the name of this firmware. Gemini had said that it meant “wisdom” in an ancient Eastern European language, so I had placed it at the front. Before promoting it in earnest, I remembered something Claude had said early in the project.
“With the data I currently have, I cannot find any language in which the word Ize carries a meaning like wisdom, intelligence, or knowledge. If you can provide the source, I can look further.”
But I was in the middle of working on something else, and I did not think it was urgent, so I had let it pass. This time I asked ChatGPT again.
“The name is Ize Compose. I put Ize at the front because I was told it means wisdom.”
“I cannot find any example in Eastern European or Slavic languages where Ize is used with that meaning. I do not think this is a matter of me searching poorly. Where did the source come from?”
This time, Gemini had caused the accident.
Korean original: 쓸 만한 기계가 됐다