Independent Dev Log

Reflections on Programming with AI

Wed, 10 Jun 2026 10:52:18 GMT

Since 2022, AI has been part of the everyday programmer's workflow for four years. It has now completely changed how we work: productivity, coding conventions, and even architecture have all been turned upside down. Some approaches we once considered foolish suddenly make a great deal of sense.

Localization is a simple example. Previously, we would look for plugins, or call translation APIs to automate the process. Now I can ask AI to generate the translations and keep one text file per language. It is that straightforward, with no plugin required. Maintaining those files by hand once seemed almost impossible; with AI, it barely feels like a problem.

Game combat systems are another example. We used to dislike implementing every ability as a separate script: maintenance was difficult, development was slow, and bugs were easy to introduce. I implemented all combat logic—abilities, projectiles, and buffs—with behavior trees, in a setup somewhat like visual scripting. I even built a dedicated behavior-tree editor. It worked reasonably well in practice. Looking back, though, if I were writing that combat system again today, I would not choose behavior trees or visual scripting. I would have AI write the scripts directly.

I work on an SLG game. Recently, a designer brought us a particularly demanding requirement. We already had a large SLG world map with very complex business logic. The designer wanted a smaller SLG map mode that reused fundamental systems such as marching and combat, but differed substantially in gameplay. Architecturally, I had three choices:

Reuse the existing code directly and accommodate the differences in the business layer.
Abstract the shared logic out of the existing code and use it for the new mode.
Copy the existing code and modify the copy.

In the past, judged on elegance, I would have ranked option 2 above option 1, with option 3 far behind. Option 3 was an architectural taboo: copying and pasting code was a recipe for a maintenance nightmare. If every new mode meant another copy, how could anyone maintain it?

Today, I would choose option 3 without hesitation. I would maintain the main gameplay implementation, then have AI adapt the derivative implementations to follow changes in that primary codebase.

My takeaway is that many clever techniques I once felt proud of now look far less impressive next to AI.

A Pragmatic Game Programmer’s Approach to Optimization

Thu, 16 Oct 2025 09:24:42 GMT

I recently interviewed several backend programmers and asked about optimization. Many struggled to give a good answer.

First, what makes a programmer pragmatic? On a game project, schedule matters enormously. A pragmatic programmer should solve problems quickly and deliver stable code promptly, while keeping it maintainable enough to accommodate changing design requirements.

One interviewee described optimizing an inventory system. Items had originally been represented as dictionaries, such as {name:"item1", lv:1, num:99}. To save space, the developer changed the representation to an array: ["item1", 1, 99]. This removed redundant keys, with an API wrapped around the representation to access its fields.

But was that optimization necessary? It might have halved the inventory system's memory use. Yet how much of the player's total data did inventory occupy? If it accounted for only 2% of memory, reducing it to 1% saved just one percentage point overall. In exchange, the code became harder to maintain and the project slowed down. That is a poor trade.

Here are a few of my views on optimization:

During game development, optimization has the lowest priority. We should not proactively optimize everything. Development speed and maintainability come first, unless a particular feature has hit a bottleneck.
Understand the different bottlenecks on clients and servers.

In my experience, clients are often constrained by memory. They cache not only logical data but also images, models, fonts, and other assets, while having limited process memory available. Client-side optimization therefore often trades time for space: load data and assets dynamically when needed.

Servers are often constrained by CPU. They serve thousands of clients at once. In frameworks such as Skynet, saturating a single CPU core can make some functionality noticeably stall. On the server, I therefore tend to trade space for time: prepare and cache data at startup. That can simplify the logic as well as reduce runtime computation.
Define the workload before optimizing. Optimization has no natural endpoint. Establish the data scale and call frequency first: the maximum players per server, scene size, maximum objects, and how often players act. Optimize around those constraints rather than creating work with little payoff. If a server holds only 1,000 players and a leaderboard needs only the top 100, insisting on a red-black tree may be overkill. I have made that mistake myself, even modifying the tree algorithm to support rankings.
Code structure deserves optimization too. I prefer to refactor early, making interfaces clear and easy to use. That can delay the arrival of a tangled codebase—even if I suspect every sufficiently long-lived project eventually becomes one.

Know when to stop. Avoid an optimization when it is not needed. Most organizations are held together more loosely than we like to admit, and a one-percent performance gain is unlikely to earn you a special reward.

Disabling Transparent Huge Pages on Ubuntu (Repost)

Tue, 23 Sep 2025 08:22:28 GMT

There are two main ways to disable Transparent Huge Pages (THP) on Ubuntu: temporarily, until the next reboot, or persistently. This repost walks through both methods and the checks to make afterward.

1. Check the current THP setting

Open a terminal and run:

cat /sys/kernel/mm/transparent_hugepage/enabled

The value in square brackets is selected. [always] enables THP generally, while [madvise] permits it for applications that request it. An output of always madvise [never] indicates that THP is disabled.

2. Disable THP temporarily

To turn it off immediately for testing:

echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
echo never | sudo tee /sys/kernel/mm/transparent_hugepage/defrag  # 建议同时也关闭碎片整理

The second command also disables THP defragmentation. These settings apply only to the current session; they do not persist across a reboot.

3. Disable THP persistently

Option A: Edit the GRUB configuration

This guide uses GRUB as the main approach.

Edit the configuration file:

sudo nano /etc/default/grub

Find GRUB_CMDLINE_LINUX_DEFAULT or GRUB_CMDLINE_LINUX. Add transparent_hugepage=never inside the quoted kernel arguments. For example:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash transparent_hugepage=never"
# 或者
GRUB_CMDLINE_LINUX="transparent_hugepage=never"

If your particular database deployment also calls for disabling NUMA, its separate argument is numa=off. Do not treat that as an inherent requirement of disabling THP.

Save the file and update GRUB:

sudo update-grub

Reboot:

sudo reboot

Option B: Use a systemd service or rc.local

The original guide presents this as an alternative for deployments that manage the setting through a startup service, mentioning MongoDB as an example.

Create a unit such as /etc/systemd/system/disable-thp.service:

[Unit]
Description=Disable Transparent Huge Pages (THP)
After=sysinit.target

[Service]
Type=oneshot
ExecStart=/bin/sh -c 'echo never > /sys/kernel/mm/transparent_hugepage/enabled && echo never > /sys/kernel/mm/transparent_hugepage/defrag'

[Install]
WantedBy=basic.target

Alternatively, if your system supports rc.local, edit or create /etc/rc.local and insert the following before exit 0:

if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
    echo never > /sys/kernel/mm/transparent_hugepage/enabled
fi
if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
    echo never > /sys/kernel/mm/transparent_hugepage/defrag
fi

Make sure rc.local is executable.

If you chose the systemd approach, reload the configuration, enable the service, and start it:

sudo systemctl daemon-reload
sudo systemctl enable disable-thp.service
sudo systemctl start disable-thp.service

Reboot to confirm that the configuration persists.

4. Verify the setting

After rebooting, run the check again:

cat /sys/kernel/mm/transparent_hugepage/enabled

The expected result is always madvise [never].

Considerations

Why disable THP? The original repost discusses workloads involving Oracle Database, MongoDB, Redis, and Hadoop where THP can cause unwanted latency, overhead, or performance issues. Requirements depend on the application and version.
Performance is a tradeoff. THP can benefit other workloads. If you have no specific problem or application requirement, disabling it is not automatically an improvement.
Defragmentation is separate. The runtime examples set both enabled and defrag to never.
NUMA is separate too. Follow the requirements for your particular software rather than automatically combining numa=off with the THP change.

Whichever method you choose, reboot and verify the resulting state. If something does not behave as expected, investigate the requirements of the particular application before changing further memory settings.

An Nginx Port-Forwarding Pitfall

Tue, 01 Apr 2025 08:33:20 GMT

I recently made a serious mistake while configuring Nginx port forwarding. Here is what happened.

Our game server used WSS, and Nginx needed to forward many paths to backend WebSocket ports. For example, wss://xxx.com/10000 should reach ws://xxx.com:10000. The requested range was around ports 10000–11000. I did not want to write a thousand separate rules, so I found this configuration online:

location ~* ^/(?<port>\d+)$ {
    proxy_pass http://127.0.0.1:$port;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $host;
}

At first glance, it seemed to work: take the number after / and use it as the backend port.

Then a colleague noticed the problem. Although our security group exposed only the intended game-server ports, this rule allowed a user to reach any local port indirectly through Nginx's public port 80 or 443. A small deployment might appear to work normally, but scanning could expose sensitive internal services as traffic grew.

Restrict the destination port

My first thought was to use if. I had also encountered the Nginx community's “If Is Evil” discussion about unexpected behavior in some configurations, so I decided to restrict the numeric match instead.

These are the two patterns recorded in the original post:

location ~* ^/(?<port>(20[0-9]\{3\}))$ {
    proxy_pass http://127.0.0.1:$port;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $host;
}

Or:

location ~* ^/(?<port>2[0-1]\d\d\d)$ {
    proxy_pass http://127.0.0.1:$port;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $host;
}

The intent was to match only an allowed range and reject other ports, rather than pass arbitrary user-supplied numbers to the upstream.

Translation note: the original post describes a 10000–10999 match, but the two restricted patterns above do not implement that range as written. One also escapes the repetition braces. They are preserved here as historical examples; validate the actual pattern and allowed port range before using the configuration.

Updating Google Play Billing to 6.2.1 in Unity

Tue, 16 Jul 2024 07:48:02 GMT

In July 2024, I needed to update an app to Google Play Billing Library version 6 before the August 31 deadline described in the original post. Updating Unity IAP to 4.12.0 through Package Manager caused the Android build to fail. Other developers reported the same problem in the forum, and a fix was not yet available in that workflow. I rolled back to 4.11.0 and updated the billing library manually.

Roll back Unity IAP to 4.11.0

Select version 4.11.0 in Package Manager.

Download the AAR

Download Billing Library 6.2.1 from Google's Maven repository.

Replace the AAR

Copy billing:6.2.1.aar into the Unity project's Assets directory. Unity generates a matching .meta file.
Search the project for the existing billing:5.2.1.aar. Delete it and its adjacent .meta file. Move billing:6.2.1.aar and billing:6.2.1.aar.meta into that directory.

Update build.gradle

Open build.gradle and replace billing:5.2.1 with billing:6.2.1.

That completed the workaround for this project and its 2024 dependency versions.

Accessing an iOS App’s Documents Directory

Mon, 29 Jan 2024 01:50:51 GMT

On iOS 11 and later, setting LSSupportsOpeningDocumentsInPlace and UIFileSharingEnabled to YES in the app's property list makes its Documents directory accessible through the system Files app.

Open Files → On My iPhone. Apps with this feature enabled expose their folder here. This folder is linked to the app's sandbox; deleting the app also removes its stored documents.

Integrating AdMob into Unity

Fri, 19 Jan 2024 17:56:48 GMT

Reference documentation

Resolve dependencies

In Unity, use the Google Mobile Ads dependency tools:

Android: Assets → Google Mobile Ads → Android → Resolve.
iOS: Assets → Google Mobile Ads → iOS → CocoaPods.

Fix a missing initialization-listener class

I encountered this error:

AndroidJavaException: java.lang.ClassNotFoundException: com.google.android.gms.ads.initialization.OnInitializationCompleteListener

Go to Build Settings → Player Settings → Publishing Settings and enable Custom Proguard File.

Add the following rules to proguard-user.txt:

-keep class com.google.unity.** {
   *;
}
-keep public class com.google.android.gms.ads.**{
   public *;
}
-keep public class com.google.ads.**{
   public *;
}
-keepattributes *Annotation*
-dontobfuscate

Configuring Docker Proxies

Fri, 25 Aug 2023 06:20:46 GMT

Set up Clash on Linux

The original setup used this reference: Using Clash on Linux.

Configure a proxy for dockerd

docker pull is performed by the dockerd daemon. On this system, systemd manages the daemon, so its HTTP and HTTPS proxy settings need to be supplied through systemd.

Create a configuration directory:

sudo mkdir -p /etc/systemd/system/docker.service.d

Create /etc/systemd/system/docker.service.d/http-proxy.conf and add the environment variables:

[Service]
Environment="HTTP_PROXY=http://proxy.example.com:8080/"
Environment="HTTPS_PROXY=http://proxy.example.com:8080/"
Environment="NO_PROXY=localhost,127.0.0.1,.example.com"

Reload the configuration and restart Docker:

sudo systemctl daemon-reload
sudo systemctl restart docker

Configure a proxy for containers

For HTTP and HTTPS traffic during container execution, either configure the Docker client or pass environment variables when starting a container.

Create or edit ~/.docker/config.json:

{
 "proxies":
 {
   "default":
   {
     "httpProxy": "http://proxy.example.com:8080/",
     "httpsProxy": "http://proxy.example.com:8080/",
     "noProxy": "localhost,127.0.0.1,.example.com"
   }
 }
}

Alternatively, specify environment variables with docker run. The original command is reproduced below:

docker run --env HTTP_PROXY="http://proxy.example.com:8080/ --env HTTPS_PROXY="http://proxy.example.com:8080/" --env NO_PROXY="localhost,127.0.0.1,.example.com"

Translation note: this original example has an unmatched quote after the HTTP_PROXY value. Close that value before adding the next --env option; also supply the image and other arguments needed by your own container.

Configure a proxy during docker build

During image builds, supply build arguments or use environment variables in the Dockerfile. Here is the original --build-arg example:

docker build \
    --build-arg "HTTP_PROXY=http://proxy.example.com:8080/" \
    --build-arg "HTTPS_PROXY=http://proxy.example.com:8080/" \
    --build-arg "NO_PROXY=localhost,127.0.0.1,.example.com" .

Exporting an xLights Project from Light Show Creator

Wed, 02 Aug 2023 15:52:41 GMT

Here is a practical guide to exporting an xLights project from Light Show Creator so you can personalize your Tesla light show further. xLights can create impressive custom shows, but editing them can be laborious. I built Light Show Creator to make that process easier with automatic generation.

Some users asked for an xLights-style timeline editor. After considering it, I decided that Light Show Creator should remain playful and simple. A timeline would add complexity, and a phone cannot offer the same precision as a desktop editor. Instead, I added XSQ export so that users who need finer control can continue in xLights.

Export and open the project

Import your music into Light Show Creator and create a show in automatic or manual mode. Export it to obtain three files: lightshow.wav, lightshow.fseq, and lightshow.xsq. Copy all three into the same folder on your computer.
Open xLights. For the workflow described in this 2023 guide, use the matching Tesla project files. The app's XSQ export was adapted to Tesla's April 27, 2023 revision, available here:

https://github.com/teslamotors/light-show/blob/09601c577f838e84320faff8ea3a7266af783f56/xlights/tesla_xlights_show_folder.zip
In xLights, choose File → Open Sequence and select the exported lightshow.fseq, not lightshow.xsq. Choose OldView from the View dropdown. The generated frames should now appear, ready for more detailed editing.

Troubleshooting

Keep all three files—MP3 or WAV, FSEQ, and XSQ—in the same folder.
Use the 2023 Tesla project files referenced by this guide from Tesla's GitHub project. The 2021 files may be incompatible with this export workflow.
Select lightshow.fseq, rather than lightshow.xsq, when opening the sequence. Opening the wrong file can produce warnings and lose data.

I hope this helps you enjoy making your own Tesla light shows. If you run into problems or have ideas for the app, feel free to get in touch. I look forward to seeing what you create!

Light Show Creator User Guide

Sat, 29 Jul 2023 16:32:22 GMT

Custom Light Show is one of Tesla's fun features. Light Show Creator is an app for making your own shows quickly and easily. If that sounds interesting, give it a try:

USB-drive requirements

Include a folder named LightShow at the drive's root. You can extract it from the project's LightShow.zip download.
Format the drive as exFAT, FAT32 on Windows, MS-DOS FAT on Mac, ext3, or ext4. NTFS was not supported in the setup described in this guide.
Do not place a TeslaCam folder at the root of this drive.

Tesla's official guide: https://github.com/teslamotors/light-show

Create a project

Open the Projects page, tap New Project, and enter a project name.

Import music

The app supports MP3 and WAV. I recommend WAV where possible, because some MP3 files can cause problems.

Android

Select an MP3 or WAV file no longer than five minutes directly from the filesystem.

iOS

There are two ways to import music:

Share a music file from another app to Light Show Creator.
Copy the file into the LightShowCreator directory.

To import by copying, use Apple's Files app. Install it from the App Store if it is not already on your device.

Open Files and tap On My iPhone.

Open the LightShowCreator folder.

Inside it, the music directory stores imported audio. Copy your music there.

After sharing a file, iOS switches to Light Show Creator. Open the Music page; the selected track should appear in the list within a few seconds.

Share music from another app

You can use a third-party app that supports file sharing, such as OneDrive, Google Drive, or Dropbox.

Choose Open in another app, then select LightShowCreator.

The track will appear in the list. Tap the track you want to use to complete the import.

Use automatic mode

Turn on the Auto button. The lights will respond automatically to the music.

You can adjust several settings:

Step time: the duration of each frame. Longer frames use less memory.
Rhythm sensitivity: how sensitively the lights respond to the music. Lower sensitivity should generally use less memory.
Beat duration: the maximum duration of each light activation. Longer durations use less memory.
Fog-light switch: turn this off for the Standard Range Model 3 and Model Y configurations without front fog lights described in the original guide.

Use manual mode

Manual mode allows more personal editing, much like playing a piano. Each pair of symmetric lights forms a group. Black keys activate both sides; white keys activate one side.

You can also run automatic mode while recording manually, leaving you to control just a few key lights yourself.

Export a light show

Exporting uses sharing, just like importing music. Send the exported files to another app; OneDrive is used in this example:

The app also exports the files to the filesystem:

iOS: LightShowCreator/export/
Android: Downloads/LightShowExport/

If you want to make shows entirely on your phone, without a computer, I strongly recommend a Lightning-to-USB or USB-C-to-USB adapter like this:

Refine a show in xLights

At the time of this guide, the app did not support fades or window and door controls. For those features, put lightshow.wav or lightshow.mp3, lightshow.fseq, and lightshow.xsq together in one folder on a computer, then open the project in xLights.

Questions and answers

What if the music is too fast to follow in manual mode?

Change the playback speed on the settings page.

Why does the Windows version not support manual mode?

At the time of writing, no Windows update was planned. The Windows version was designed around a different interaction model from the touchscreen-based mobile version.

How can I make coordinated shows for multiple cars?

This was on the roadmap. In the meantime, one suggestion was to split the music into several tracks, create a project for each, and use automatic mode to prepare shows for multiple cars quickly.

Integrating Unity IAP with Google Play

Tue, 11 Apr 2023 15:22:39 GMT

These are my notes from integrating Google Play in-app purchases with Unity in April 2023.

Upload a build with billing permission

Add this permission to AndroidManifest.xml:

<uses-permission android:name="com.android.vending.BILLING" />

After uploading the APK and getting it approved, create the in-app products or subscriptions in Google Play Console.

Install Unity IAP

Open Window → Package Manager → Unity Registry, select In App Purchasing, and install it.

Check Unity Player settings

Go to Edit → Project Settings → Player:

Under Other Settings, use IL2CPP as the scripting backend for this setup.
In the configuration section, set API Compatibility Level to .NET Standard 2.0 or later.
Make sure the package name matches the registered app.
Enable Build App Bundle (Google Play).

Add the Google license key

Find the key on the monetization settings page in Google Play Console. Enter it in the project's In-app purchase (IAP) settings on the Unity Dashboard.

In my setup, the corresponding Unity editor panel could report an error. I configured the key through the Dashboard instead.

Add license-test accounts

In Google Play Console, open License testing → License testers from the home page.

License testers and internal-testing participants are different lists. Configure the relevant accounts in each. In the original test setup, China-region accounts could not complete payments; account region was one of the things I needed to check.

Test the store build

Publish an internal-testing build and download it from Google Play. Testing that installed store build was necessary for this workflow.

Reflections on Game Programming

Tue, 21 Feb 2023 15:18:19 GMT

While taking some time off at home, I looked back on my work over the past few years. Here are a few lessons from that experience.

What makes a strong game programmer?

The ability to argue a case constructively. Persuading someone to change their mind and cooperate is difficult. Pulling rank—“I am your manager” or “my manager said so”—does not count. A stronger approach is to understand the people involved, consider several perspectives, and propose a sound solution.
Foresight. When designing a framework, consider future iterations and anticipate requests designers may eventually make, even if they deny needing them today. Make those requests quick to implement within the existing architecture.
Ownership. Become the person who knows a module inside out. Deliver your own work well, but also help drive requirements forward and suggest solutions to colleagues in other roles.
Efficiency. Use tools well, or write automation for coding and testing. The practical results should be faster delivery, fewer bugs, less rework, and less overtime.
The ability to tackle hard problems, such as a critical algorithm or a fatal bug.
Breadth of knowledge. Do not limit yourself to a single language or technology. Each has strengths; use it where it fits.

What makes a strong lead programmer?

First, be a strong programmer, and then go further.
Judge people well. During a short interview, identify candidates who suit the team. Being a good fit is not the same as reciting interview answers: look for the qualities above, or the potential to develop them.
Assign work thoughtfully rather than treating people as interchangeable tools. Match tasks to strengths or skills that need development, and give people substantial autonomy. Good work should also help them grow.
Keep the schedule under control. Estimate requirements accurately, allow team members some buffer, and show designers a prototype as early as possible.
Understand the game deeply. Know both what designers ultimately want and what matters most to them right now. That helps with iteration and scheduling.
Retain people. Advocate for their interests and give them room to grow. Put plainly: pay them adequately, or at least do not let them feel mistreated.

Thoughts on open source

Code is a programmer's underwear: it is not something you show everyone casually. Publishing it means exposing what is underneath. If you show it, make sure it is worth showing.
Do not open-source something just for the sake of doing so. Build something useful rather than another unnecessary wheel. A project or library should help other people, not merely show off how impressive an old project was. I will leave aside projects that use gimmicks to collect stars.
Open source can improve your overall ability quickly. In a sense, it is a mutual exchange of free work. Communities contain all kinds of people, each with their own needs. Contributors and users can both benefit. Every interface and feature makes you ask: is this useful to most users? Does it add unnecessary bulk? Could it be more general? Is it extensible? We rarely ask those questions as consistently in our own closed-source projects. Over time, that habit leads to better code, with the high cohesion and low coupling we aim for.

Improving feature-development efficiency

This workflow came from a more experienced developer, and it has worked well for me:

Review the requirements with the designer. Before the cross-functional meeting, read the document, record questions, and ask for clarification where possible. In the meeting, go through it line by line and resolve every uncertainty. This step matters.
Agree on configuration-table fields and formats with the designer. Ask for temporary data that covers testing, then implement import validation. This step matters even more: once the configuration is settled, the whole data model is usually clear in your mind.
Agree on the client-server protocol. The backend should also define the persistent database structure. Communication and interaction between the two sides are now established.
Write test cases. Include this step whenever possible, before implementation.
Write the code. By this point, you should understand the system's requirements thoroughly.
Hand it over for testing, then enjoy a well-earned breather.

Thoughts on overtime

Nobody likes overtime, but it can be difficult to avoid in game development. It is often about a shared deadline, such as finishing a particular build, when the whole team needs to be available.
I see overtime as sometimes reflecting insufficient capability or time wasted during normal hours. Working with full concentration from 9 a.m. to 9 p.m. is exhausting.
I can accept overtime when it is not imposed as a blanket company policy. Even when the extra hours are less intense, they can be used productively—for example, to improve something or prepare for a future version.
Game teams need considerable face-to-face communication, so their schedules should overlap. If some people work very late and arrive late the next day, while others keep the opposite schedule, it becomes difficult to find someone for a quick requirements discussion. That can block progress unnecessarily.

Other lessons

A technical expert is a bonus for a team, not an absolute prerequisite. Technical research should ultimately serve delivery.
Code should be simple and easy to understand. Ideally, colleagues outside programming should be able to read it and even spot a bug.
In most game-development work, unless you are pushing the frontier, someone has already solved the problem. Be cautious when a design or implementation departs from established approaches. If you thought of it, others probably did too; there may be a reason they did not choose it.
When you discover a bizarre piece of old code, do not rush to delete it. Code does not lie; an unusual product or design requirement may explain it.
Code itself is often the best documentation. Still, explain special handling and temporary code—at least leave a // TODO, or expect criticism later.
Programmers bridge human intent and computers. Ideally, every line we write reduces repetitive manual work in the future, even if getting there requires considerable thought. A good programmer should be eager to think and reluctant to repeat manual work.
Avoid over-optimization, particularly on the server. Debating whether ++i is faster than i++ misses the bigger picture. Hardware is comparatively inexpensive; project progress matters far more than meaningless micro-optimizations. Optimize when something becomes a real bottleneck, rather than for its own sake.

Troubleshooting C# IntelliSense in VS Code

Tue, 27 Dec 2022 14:46:37 GMT

C# IntelliSense in VS Code kept stopping unexpectedly. In December 2022, I ran into another failure:

System.Composition.Hosting.CompositionFailedException: No export was found for the contract 'ILoggerFactory'

OmniSharp had updated automatically. In settings.json, I changed omnisharp.path from latest to a pinned version:

"omnisharp.path": "1.39.2",

Versions that worked together in this setup

Automatic extension updates were a recurring source of problems in this project. This is the historical combination I found stable:

.NET Framework 4.7.1.
Unity's VS Code package 1.2.0: set "com.unity.ide.vscode": "1.2.0" in manifest.json.
VS Code's C# extension 1.24.0: use the arrow beside the uninstall button and choose Install Another Version.
OmniSharp 1.39.2: pin it with omnisharp.path in settings.json.

Default .NET Framework reference-assembly path

C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.7.1

Why My YouTube App Preview Still Had Ads

Mon, 26 Dec 2022 14:55:41 GMT

I uploaded an app preview to YouTube for use on Google Play, but a few days later Google Play removed it. I suspected advertising: when I opened my own video, an ad would sometimes appear.

The documentation said to turn off monetization. I searched through YouTube's settings but could not find the button. My channel did not even qualify for the YouTube Partner Program, so how could I disable monetization? Where were the ads coming from?

After trying for a long time, I contacted Google Play support. This is an English translation of our exchange in December 2022.

My question to support

My app's video preview is no longer visible. I suspect my YouTube video still contains ads. However, my YouTube account is not in the Partner Program, and I cannot find an option to turn off ads on the monetization page or a monetization option for the selected video. Is there a way to disable YouTube ads, or another way to restore the app preview?

Google's reply

After investigating, we found that the system currently detects monetization on your promotional video. The system determines whether these features are present. If your video contains ads, they must be disabled before the video can appear on the Play Store. We want users browsing the Play Store to see your app in the video, rather than advertising that could confuse them.

Please refer to the Help Center and the following video requirements:

Turn off monetization for the video.

Upload a video without a monetization claim, then update its URL in Google Play Console.

Set the video to public or unlisted, rather than private.

Make sure the video can be embedded in the Play Store Android app and website.

If the video uses copyrighted material, turning off monetization may still not prevent ads. In that case, replace it with a video that contains no such copyrighted material or monetization claim.

On inspection, the background music in my video did indeed have a copyright claim.

That explained why looking for my own monetization switch had not helped. YouTube's handling of music rights was stricter than I had expected from using short-video platforms in China. For a commercial preview, I needed music I was authorized to use, whether through a purchased license or an appropriate Creative Commons license. “Free” music still needs its usage terms checked.

Creative Commons music sources I collected

The Creative Commons collection on Aigei.
The Audio Library in YouTube Studio.

YouTube music channels and playlists I collected

Building Light Show Creator: Part 2

Tue, 20 Dec 2022 03:43:29 GMT

Light Show Creator had been available for a while when users told me that, although automatic mode was convenient, manual mode could suit a phone particularly well. I began planning a new manual mode.

The earliest prototype actually had manual editing. Like xLights, it used a timeline. The result was not satisfactory: fine timeline controls worked better with a mouse than a touchscreen. I removed manual mode from the first public release and kept only automatic generation.

The old version was difficult to use.

A piano app recently gave me another idea. What if controlling the lights worked like playing a keyboard? Press a key to turn a light on; release it to turn it off. A white key could control one side of the vehicle, while a black key could activate both sides together.

Automatic mode can also run during a manual recording, so you only need to play the few lights you want to emphasize yourself.

Changing the Nginx Upload Size Limit

Sun, 27 Nov 2022 08:42:25 GMT

With the default Nginx HTTP proxy configuration, request bodies are limited to 1 MB. A larger request can return 413 Request Entity Too Large.

Adjust client_max_body_size in the Nginx configuration. This example raises the limit to 8 MB:

http {
    ...
    #上传文件的大小限制  默认1m
    client_max_body_size 8m;
    ...
}

Removing ^M Line Endings from Multiple Files

Sat, 19 Nov 2022 03:17:16 GMT

Files copied directly from Windows to Linux or macOS may show ^M at the ends of lines in git diff. Windows line endings use two characters, \r\n.

Install dos2unix

Ubuntu or Debian:

sudo apt-get install dos2unix

CentOS:

sudo yum install dos2unix

macOS:

brew install dos2unix

Convert one file

dos2unix filename

Convert multiple files

The original example finds Lua files and passes them to dos2unix:

find ./ -name *.lua | xargs dos2unix

Changing Ubuntu’s Package Mirror

Wed, 16 Nov 2022 02:45:19 GMT

On a Tencent Cloud Ubuntu instance, installing packages with apt failed because the configured mirror could not be resolved:

Err:1 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 m4 amd64 1.4.18-1
  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
Ign:2 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 autoconf all 2.69-11
Ign:3 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 autotools-dev all 20180224.1
Ign:4 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 automake all 1:1.15.1-3ubuntu2
Err:2 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 autoconf all 2.69-11
  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
Err:3 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 autotools-dev all 20180224.1
  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
Err:4 http://mirrors.tencentyun.com/ubuntu bionic/main amd64 automake all 1:1.15.1-3ubuntu2
  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
E: Failed to fetch http://mirrors.tencentyun.com/ubuntu/pool/main/m/m4/m4_1.4.18-1_amd64.deb  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
E: Failed to fetch http://mirrors.tencentyun.com/ubuntu/pool/main/a/autoconf/autoconf_2.69-11_all.deb  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
E: Failed to fetch http://mirrors.tencentyun.com/ubuntu/pool/main/a/autotools-dev/autotools-dev_20180224.1_all.deb  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
E: Failed to fetch http://mirrors.tencentyun.com/ubuntu/pool/main/a/automake-1.15/automake_1.15.1-3ubuntu2_all.deb  Something wicked happened resolving 'mirrors.tencentyun.com:http' (-5 - No address associated with hostname)
E: Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?

mirrors.tencentyun.com appeared to be unavailable; even a ping failed. Switching the package mirror resolved the problem in this setup.

Back up the source list

sudo cp /etc/apt/sources.list /etc/apt/sources.list.bk

Open sources.list

sudo vi /etc/apt/sources.list

Add the Aliyun mirror entries

I added these entries at the beginning of /etc/apt/sources.list. They are for Ubuntu 18.04 Bionic, the release used in this November 2022 post:

deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse

Refresh the package lists and upgrade

sudo apt-get update
sudo apt-get upgrade

Getting Started with Firebase Authentication in Unity

Mon, 14 Nov 2022 16:21:24 GMT

I was looking for a third-party account SDK for an app aimed at international users. After comparing the options, I chose Firebase.

Integration was initially rough. I tried exporting an AAR from Android Studio into Unity, then exporting an Android Studio project from Unity. Neither attempt worked. I had not yet tried iOS.

The real problem was that I had not read the official documentation carefully. Google supplied a Unity package: importing it and doing a little configuration in the Firebase console was much simpler.

Official Firebase Authentication Unity guide

Register the app in Firebase

Make sure the registered package name matches the app's final package name.

Add the SHA certificate fingerprint

Add the fingerprint in the app settings:

Download google-services.json

In the project described in this November 2022 note, I placed the file in Asset/StreamingAssets in the Unity project.

Enable an authentication provider

Import FirebaseAuth.unitypackage

Import the authentication package into Unity.

Add test code

The following code tests account creation with an email address and password:

auth.CreateUserWithEmailAndPasswordAsync(email, password)
            .ContinueWith(task =>
            {
                if (task.IsCanceled)
                {
                    Debug.LogError("CreateUserWithEmailAndPasswordAsync was canceled.");
                    return;
                }
                if (task.IsFaulted)
                {
                    Debug.LogError(
                        "CreateUserWithEmailAndPasswordAsync encountered an error: "
                            + task.Exception
                    );
                    return;
                }

                // Firebase user has been created.
                FirebaseUser newUser = task.Result;
                Debug.LogFormat(
                    "Firebase user created successfully: {0} ({1})",
                    newUser.DisplayName,
                    newUser.UserId
                );
            });

Fixing the AndroidX Build Error After Adding Firebase to Unity

Sun, 13 Nov 2022 17:46:35 GMT

After importing Firebase into Unity, I encountered the following build error:

Could not determine the dependencies of task ':launcher:lintVitalRelease'.
> This project uses AndroidX dependencies, but the 'android.useAndroidX' property is not enabled. Set this property to true in the gradle.properties file and retry.
  The following AndroidX dependencies are detected: androidx.fragment:fragment:1.0.0, androidx.slidingpanelayout:slidingpanelayout:1.0.0,

The project depended on AndroidX, but android.useAndroidX had not been enabled.

Enable the Gradle properties template

Under Build Settings → Player → Publishing Settings, enable Custom Gradle Properties Template. Unity generates the template at Assets/Plugins/Android/gradleTemplate.properties.

Add these two lines:

android.useAndroidX=true
android.enableJetifier=true

My resulting properties file looked like this:

org.gradle.jvmargs=-Xmx**JVM_HEAP_SIZE**M
org.gradle.parallel=true
android.enableR8=**MINIFY_WITH_R_EIGHT**
unityStreamingAssets=**STREAMING_ASSETS**
android.useAndroidX=true
android.enableJetifier=true
**ADDITIONAL_PROPERTIES**

That resolved the problem in this project.

Wireless Debugging on Android

Sun, 13 Nov 2022 13:43:44 GMT

Android 11 introduced wireless debugging, making it possible to debug without a USB cable.

Prerequisites

A phone running Android 11 or later.
Android SDK tools version 30.0.0 or later on the computer. Check the installed version with adb --version.

Pair with a pairing code

Enable developer mode on the phone, then enable USB debugging and the wireless debugging option.
Open Wireless debugging → Pair device with pairing code. Note the pairing code, IP address, and port.
In a terminal on the computer, run adb pair ipaddr:port, replacing the address and port with the displayed values, and enter the pairing code when prompted.
Run adb devices -l to see the connected device.

Pair with a QR code

Enable developer mode, USB debugging, and wireless debugging on the phone.
Select QR-code pairing. In Android Studio's device menu, choose Pair Devices Using WiFi and scan the displayed code with the phone.

Building Light Show Creator: Part 1

Thu, 27 Oct 2022 15:10:39 GMT

Tesla introduced Light Show across its vehicle lineup in the 2021 holiday update. Besides the built-in show, owners could create custom ones. I tried it immediately, but found editing too difficult. That gave me an idea.

Where the idea came from

Tesla recommended an open-source application called xLights, a professional tool for editing lighting performances. Import Tesla's template and some music, and you can start creating a show.

Editing in xLights felt cumbersome: the show needed to be edited frame by frame, and the exported file then had to be checked with a script. Tesla imposes strict limits on lighting sequences, partly to protect the lights from damage. The process took time and effort. Could it be simpler—ideally, import a song and generate the show with one click? I decided to build an app.

Checking feasibility

The first and most important step was to determine whether I could generate a valid FSEQ sequence file, equivalent to one produced by xLights, that the vehicle would recognize. FSEQ is binary, so I had to examine what its bytes meant.

Tesla's validation script helped me infer the basic format: a header followed by sequence frames describing each light's on/off state or brightness.

To test the idea, I used Tesla's official example, which contained three files:

lightshow.wav: the music file, which I could leave alone.
lightshow.xsq: the xLights project, with sequence information in XML form.
lightshow.fseq: the binary sequence exported by xLights for the vehicle.

I imported sequence data from the XSQ project into my app, exported a new FSEQ file, and compared it byte by byte with the xLights output. I kept going until the two files matched exactly. That showed my app could export the same sequence format as xLights.

Building the core feature

After testing the export on a real vehicle, I moved on to the core feature: automatic generation.

The principle is straightforward. Analyze the music, divide the frequency range into n bands, and assign them to the vehicle's lights. Turn a light on when its band exceeds a threshold, and off otherwise. It resembles the animated spectrum display in a music player.

Supporting controls

Fast rhythms and rapidly changing frequencies can exceed the vehicle's limits, so I added parameters users could adjust:

Step time: the duration of each frame. Longer steps use less memory.
Rhythm sensitivity: sensitivity to changes in the music. In principle, lower sensitivity uses less memory.
Beat duration: the maximum duration of each light activation. Longer durations use less memory.
Fog-light switch: the Standard Range Model 3 and Model Y configurations described here did not have front fog lights, so switching this off made the result more suitable for those vehicles.

To prevent sequences from exceeding the memory limit, I ported Tesla's Python validation logic into the app. It checks usage while recording, displays it in real time, and refuses to export a sequence that exceeds the limit.

App-store release

The app was released on the Apple App Store and Google Play:

Plans for future iterations

At the time of writing, the next items on my list were:

A Mac version.
Manual editing.
Audio recording.

I also uploaded several shows recorded with the app, featuring some fun background music, to GitHub. Feel free to download and try them:

https://github.com/xcoding1024/tesla-light-show