Common Issue for Updating iOS App

I have an iOS app listed on the Apple Store. For various reasons, I need to update my app regularly. For example, I have to ensure it keeps up with the constant release of new iOS frameworks, fix bugs discovered by users, and, most importantly, add new features that bring more value to users.

In some of my past updates, I’ve had to make changes to the Core Data database, which involves schema updates. Fortunately, Apple provides a solid Core Data foundation, so in many cases, I’ve had to do little or no extra work. However, some updates require modifying managed Core Data entities. In those cases, I need to write code that ensures a smooth migration from the old version to the new schema, while maintaining correct structures and property values.

Consulting Help from ChatGPT

Recently, I made another change to my Core Data schema. Before implementing my strategy, I decided to consult ChatGPT for advice. Here’s what I asked:

One question about the update. This change involves a Core Data database update: adding a new property typeTag (Int16) to the TapEntity managed object.

For the existing users, their app's database has to be upgraded to the new one when they download this update. All the user defined tap entity objects be updated with the new property typeTag set to 100.

For existing users, their app's database needs to be upgraded when they download this update. All user-defined tap entity objects should have the new typeTag property set to 100.

For both old and new users, an app-defined tap entity object, with the typeTag property set to 10. should also be added to the database.

Here's my strategy: a function like updateDB() is called during app launch or preparation. Within the function, the app checks the saved database version. Fortunately, all previous versions of my app save the database version in user defaults. If the version is 2.0 (or older), I can safely assume that the existing tap entities do not have a typeTag value. So I will set it to 100.

If the database version is not set (for new users) or is less than 2.1 (the current update), the app will create the new app-defined tap entity object with typeTag set to 10. After this update, the app will update the user defaults to save the new database version as 2.1.

I believe this approach will minimize the amount of work needed to update or prepare the database—especially in cases where the dataset is very large. What do you think of this strategy? Did I miss anything? Do you have any suggestions for improvement?

I received a response from ChatGPT almost instantly.

Your strategy is well thought out, and it shows a strong balance between performance, reliability, and maintainability—especially when handling large user databases. Here's a breakdown of what you're doing right and a few small suggestions to make it even better:

---

✅ Why Your Strategy Is Solid

1. Lightweight & Targeted Update:
• Only update entities where typeTag is missing (older data).
• No full migration or sweeping changes—minimal impact on large datasets.
2. Explicit Versioning via UserDefaults:
• Keeps control in your hands instead of relying entirely on Core Data’s inferred migrations.
• Makes it easy to track what version of data the app is working with.
3. App-defined Entities Only Added When Needed:
• Ensures fresh installs or updated apps get what they need without redundancy.
4. Post-update Versioning:
• Clearly bumping the version to 2.2 ensures that this logic won’t be run again unnecessarily.

---

✍️ Example Pseudocode Outline

1. func updateDatabaseIfNeeded() {
2.  let currentVersion = UserDefaults.standard.string(forKey: "dbVersion") ?? "0.0"
4.  if currentVersion.compare("2.1", options: .numeric) == .orderedAscending {
5.    // This includes new users (no version set) or users upgrading from < 2.1
7.    let context = persistentContainer.viewContext
8.    let fetchRequest: NSFetchRequest<TapEntity> = TapEntity.fetchRequest()
10.    do {
11.      let entities = try context.fetch(fetchRequest)
12.      for entity in entities where entity.typeTag == 0 {
13.        entity.typeTag = 100
14.      }
16.      // Insert app-defined entity if it doesn't exist yet
17.      if !hasAppDefinedEntity(context: context) {
18.        createAppDefinedEntities(in: context)
19.      }
21.      try context.save()
22.      UserDefaults.standard.set("2.2", forKey: "dbVersion")
24.    } catch {
25.      print("Database update failed: \(error)")
26.    }
27.  }
28. }

---

🧠 Minor Suggestions for Improvement

1. Make Your Checks Idempotent
• Ensure createAppDefinedEntities() checks if each entity already exists to avoid duplication (e.g., by name or uuid).
2. Batching for Performance (Optional)
• If the dataset is truly massive, consider using a NSBatchUpdateRequest (iOS 8+ only) to update typeTag in bulk. But your loop is just fine for moderate-sized data.
3. Add Logging in Debug Builds
• Helpful for QA or debugging issues in migration.

✅ Conclusion

Your strategy is already solid and efficient. With minor improvements (e.g. using numeric versions, making the patch idempotent), it’ll scale well and provide great control for you as the developer. It’s especially wise because it:

• Avoids unnecessary operations
• Keeps logic in Swift code (not buried in Core Data migrations)
• Future-proofs your app structure for versioned upgrades

I was excited to see ChatGPT's very positive and encouraging comments on my strategy. One suggestion it made—regarding idempotency—was particularly valuable. It reminded me to ensure that app-defined entities are not created more than once, even though my current strategy is already quite robust. Indeed, since the update process should only run once, I can't imagine how the database version in user defaults would be reset. That setting is read-only during the update process.

I had much more back-and-forth conversation with ChatGPT on this update strategy and related issues, but I’ll have to keep it brief here and share only a small portion of our discussion. In short, I found this consulting experience extremely helpful and productive.

With ChatGPT’s confirmation and insights, I’m ready to roll up my sleeves and implement the update code for the next release.

By the way, my iOS app is called TapMyNotes. If you're using the app, you'll see this update once it's released. The new version will go live after development and thorough testing are complete. I hope you'll enjoy the app and be pleased with the exciting new feature enhancements!

Other Blogs

• Next:
• Prev: A Conversation with ChatGPT

A Conversation with ChatGPT

Recently, I had a very good conversation with ChatGPT about a topic that often goes unnoticed: how to name a variable in a Swift class in my iOS app. This isn't the kind of question you typically search for on Google or post on StackOverflow (where you might have to wait a day or longer for a response). Yet, I was stuck trying to find a meaningful name—one that clearly conveys its purpose and is easy to recognize later during maintenance.

My Initial Question

ChatGPT came to mind. I explained why I needed this variable, and with some context, I hoped it would suggest a good name. Here's my original question:

I have a main view with some tab bars, such as Edit, Tap, and Report. The main view is the starting point. I would like to define an enum type to indicate where the starting point is, for example, TabBarStatus. I also like to define a variable for the status. What names should I use for the enum and variable? The variable will be used in subsequent views to find out where the start view is.

Less than a second later, ChatGPT responded with a thoughtful explanation and code examples.

For your use case, where you want to track which tab was the starting point (Edit, Tap, Report, etc.), defining an enum and a variable to hold that state is a great approach. Here's a naming suggestion that is clear, consistent with Swift/iOS conventions, and scalable:

🧩 Enum Name

Use a descriptive enum name that reflects the context:

1. enum MainTab {
2.  case edit
3.  case tap
4.  case report
5. }

Alternative names:

• StartTab
• MainTabType
• TabBarStatus (your suggestion, but slightly less Swift-like)

Swift style prefers concise, noun-based enum names like MainTab or StartTab.

🧩 Variable Name

For a variable that stores the starting tab, here are a few clean suggestions:

• startingTab: MainTab
• originTab: MainTab
• entryTab: MainTab
• launchTab: MainTab
• startFromTab: MainTab (if used in routing context)

✅ Example Usage

1. enum MainTab {
2.  case edit
3.  case tap
4.  case report
5. }
7. struct ViewModel {
8.  var startingTab: MainTab
9. }

My Follow-Up

Just like talking to a senior developer, I continued the conversation and explained more about the context and how this variable would be used:

Good. Another question I need your advice on. All main view controllers and subsequent view controllers (VCs) are based on a base view controller, BaseViewController: UIViewController. All the subsequent VCs are presented as detail views, modal views, etc. I would like to define a public variable in BaseViewController, and its value is set in the main view controllers. I think this var should be static, instead of an instance variable. The reason is that there is only one starting tab. Right?

I was hoping ChatGPT could offer a better design based on my explanation. To my surprise, ChatGPT not only understood my design but also laid out a solid analysis of how the design could be improved.

ChatGPT's instant reply

Great question—and you're thinking in the right direction! Let's break it down and figure out the best approach.

---

🧠 Your Goal

You want all view controllers (which inherit from BaseViewController) to know where the user started (i.e., which main tab). There's only one starting tab per app session, and this info is set by the main view controller.

---

✅ Static vs Instance Variable

• Static variable (static var or class var) is shared across all instances of BaseViewController. Perfect for global, app-wide state.
• Instance variable (var) is unique to each instance, so you'd need to pass it manually to every view controller—probably not what you want here.

---

👉 Since there's only one starting tab, and you want all view controllers to access the same value, a static variable is the right choice.

---

✅ Suggested Implementation

1. class BaseViewController: UIViewController {
2.  // Default value, set from main controller
3.  static var startingTab: MainTab = .tap
4. }

Then, in your main tab view controllers (e.g. EditViewController, TapViewController, etc.), you set it like this:

1. override func viewDidLoad() {
2.  super.viewDidLoad()
3.  BaseViewController.startingTab = .edit  // or .tap or .report
4. }

And any other view controller can read it like:

1. let origin = BaseViewController.startingTab

---

✅ Optional: Make It a Computed Property (if you want read-only from others)

1. class BaseViewController: UIViewController {
2.  private static var _startingTab: MainTab = .tap
3.  public class var startingTab: MainTab {
4.    get { return _startingTab }
5.    set { _startingTab = newValue }
6.  }
7. }

Let me know if you also want to persist this value (e.g. between launches) or just keep it in-memory for one app session.

A Better Design

During this very natural and productive conversation, three concepts caught my attention: state, persistence, and computed property. They suddenly lit up my thinking like a flash of inspiration. A new design came to mind, and I shared it with ChatGPT:

There may be some cases where a subsequent view is not inherited from BaseViewController. I think it may be better to define a static class, such as MainTabStatus (or maybe a better name?). Within the class, a private var _startingTab and a public computed property startingTab can be used to manage the starting tab status. This class can be extended to include mechanisms to store the status in memory or user settings (persisting across app launches). This helper class can then be accessed from any view controller, view, or class to retrieve the starting point status.

Very quickly, I got feeback from ChatGPT.

Yes, that’s a great idea—and a cleaner and more modular design! Creating a dedicated MainTabStatus (or similarly named) helper class decouples the logic from your view controllers entirely, making it more flexible, easier to test, and extendable for future needs (like persistence).

---

✅ Suggested Design

1. enum MainTab {
2.  case edit
3.  case tap
4.  case report
5. }
7. final class MainTabStatus {
8.  private static var _startingTab: MainTab = .tap  // default value
10.  public static var startingTab: MainTab {
11.    get { return _startingTab }
12.    set { _startingTab = newValue }
13.  }
15.  // Optional: Save to UserDefaults if needed
16.  public static func persist() {
17.    UserDefaults.standard.set(_startingTab.rawValue, forKey: "StartingTab")
18.  }
20.  public static func restore() {
21.    if let raw = UserDefaults.standard.string(forKey: "StartingTab"),
22.       let tab = MainTab(rawValue: raw) {
23.          _startingTab = tab
24.    }
25.  }
26. }

🔧 For the UserDefaults part to work, you'd make MainTab conform to RawRepresentable (usually with String), like this:

✅ Suggested Design

1. enum MainTab : String {
2.  case edit
3.  case tap
4.  case report
5. }

---

✅ Usage in Any View Controller

Set at startup:

1. MainTabStatus.startingTab = .edit

Read anywhere:

1. let origin = MainTabStatus.startingTab

Restore from UserDefaults (if persisted):

1. MainTabStatus.restore()

---

🧠 Alternative Names for MainTabStatus

If you want something shorter or more Swift-y:

• AppNavigationContext
• StartContext
• OriginTab
• TabTracker
• MainTabTracker

MainTabStatus is already clear, so it's a solid choice.

---

Let me know if you'd like this helper to also handle notifications (e.g., broadcast when tab changes), or if you want a sample using @AppStorage (SwiftUI), too!

Wow! What a great set of suggestions from ChatGPT—starting from a simple question about naming a variable, and evolving into a much better and scalable design.

Other Blogs

• Next: Common Issue for Updating iOS App
• Prev: Huawei P40

The following is based on a note I wrote in WeChat.

Recently, I got a Huawei P40 smartphone. The latest models on the market are the P70 series. Although the P40 is behind the newest models, I can still install HarmonyOS on it. This means I’ll have hands-on experience with Huawei’s new operating system. Based on my initial use of the P40, I find the phone and OS to be quite smooth and effective.

I've been using Apple’s iOS for many years and am very familiar with it. HarmonyOS, on the other hand, is a new system for me. I’m willing to invest time and effort into learning it, and I plan to write some notes about my exploration of the new OS.

HarmonyOS

The first time I opened the box and turned on the phone, the OS was EMUI. This version is still based on Android's core. However, due to sanctions, all of Google's apps were unavailable, and there was no Google Play Store.

I have no interest in using Android apps since I already have my own iOS phone, where I use iOS apps for personal purposes. My focus is more on the HarmonyOS system and the Chinese apps within its ecosystem.

After several days of use, I noticed that a HarmonyOS 2.0 update appeared in the system updates. I immediately updated my P40 to HarmonyOS, quickly upgrading from version 2.0 to 4.2.0 in just one week.

In fact, the latest OS from Huawei is HarmonyOS Next. Based on my findings, the Next version is currently in the open-test stage and hasn't been expanded to the P40. I'm not sure if the Next version will be available for the P40.

Basic Configurations

Huawei P40 Specifications:

• Model: Huawei P40
• CPU: Huawei Kirin 990 5G
• RAM: 8 GB
• Storage: 256 GB
• Display: 2340 × 1080 resolution
• SIM Support: Dual SIM cards
• Security Sensors: Fingerprint and Face recognition
• Rear Camera: Leica Triple-Lens System
• Location Services: High-precision GNSS with Beidou support

Other Blogs

• Next: A Conversation with ChatGPT
• Prev: WeChat and Long Image

WeChat and Long Image

I use WeChat a lot for Chinese social network. Recently, I found a very good tool in WeChart, WeChart note. It is simple yet very handy. Basically it is for text note, but it has a range formats for text enhancement, such as bold, italic, underline, coloured background, and list. My favourate feature is that image can be embeded in the note.

WeChat note is for user cloud uses. I can crate notes and share it as messages, group chat and personal moments. After it shared, WeChat provides a translation feature to convert the note into another language. Another very nice feature is to convert note to long image jpeg file.

For example, this is a snapsot of my note.

and this is a generated long imge of translated note. The translation is not in good quality, but it is handy and most English people should able to understand what I mean.

The blogger has limitation to upload the original long image file. If you have difficulty to view it, follow the steps:

1. Download image: click this to download the original long image.
2. View image. Use this web tool: online image viewer to view the original file.

Scope Not Shown When Search Bar Is Activated

Recently, I noticed a minor issue after updating iOS. The scope bar did not appear when the search bar was activated. Typically, I prefer to display the scope bar simultaneously with the search bar activation. This allows users to select a scope item before searching.

An Example Case

Here is a snapshot. When I pull down the screen, only the search bar is displayed, but the scope bar is missing.

The scope bar appears when text is entered into the search bar. However, if a user selects a scope item, the search text disappears. This means that the user has to re-enter text if they selecte a different scope item. This is very inconvenient.

Solution

I spent some time thinking about the issue before diving into my project. It became apparent that there were some logic or behavior changes in iOS. Soon, I discovered that a property of the search bar had been deprecated and a new property was recommended as its replacement.

1. private func configSearchControll() {
2.  let sc =  UISearchController(searchResultsController: nil)
3.  // config search controller
4.  if #available(iOS 16.0, *) {
5.        sc.scopeBarActivation = .onSearchActivation
6.    } else {
7.        if #available(iOS 13.0, *) {
8.            sc.automaticallyShowsScopeBar = true
9.        } else {
10.            // Fallback on earlier versions
11.        }
12.    }
13. }

I noticed that the deprecated property of automaticallyShowsScopeBar is a boolean type with only one choice. With the iOS update, the recommented property of scopeBarActivation is an enum type with several options. After further testing, I found that only the enumerator onSearchActivation is meeting my requirements.

The above method is called in the event of viewDidLoad.

1. override func viewDidLoad() {
2.  super.viewDidLoad()
3.  // some configuration codes
4.  DispatchQueue.main.async {
5.    [weak self] in
6.      guard let this = self else { return }
7.      this.configSearchController()
8.  }
9. }

With above code updated, my iOS app TapMyNotes now works as expected!

I'll update my app TapMyNotes on the App Store with this bug-fix, as well as other new and exiting features, soon!

References

• Apple Developer: Instance Property automaticallyShowsScopeBar (deprecated)
• My post soltion to a question at SO: Swift 4 - iOS 11 Search bar scope won't appear as it should
• My iOS productivity app: TapMyNotes

Reveal Liu Qian's Magic Card Game

After Liu Qian's magic show at the Springs Festival Gala 2024, most people who participated in the game got expected results, but Xiao Ni (show anchor) did not make it. At that time, I thought this was a game with great possibilities for success. Soon, some people resolved the game and pointed out that this could be explained by a mathematical solution or method. Then I did further study on the game and figured out that the expected result is a definitive result, not a possible result. 

My Analyze Method

This magic game contains two mathematical methodologies. In order to reveal the game's logic, I use the circle-list method and display the card faces on a table. You will easily see and understand the mathematical logic in the game.

Take a piece of paper and divide it into four equal-sized cards. Draw four different pictures on the cards and label the cards on the left and right sides with A, B, C, and D.

Wash the cards well. Fold a line in the middle.

Tear the cards into halves based on the fold line. Each half has four cards.

Put one half of four cards on top of another half. Now you have a deck of eight cards.

In order to better explain, keep all cards face up and place them clockwise in a circle. Use a piece of green-coloured paper to mark the tail. The next card, clockwise, is the head.

As an example, use the D card as the tail. The head is the next card, clockwise, A. After A, the sequence of cards is B, C,...

With the cards ready, let's start to explain, focusing on two mathematical methods, the logic of the game.

Math One: Repliated Sequence

The first math used in the game is to arrange the cards in a replicated sequence.

As shown in the above picture, we can see that no matter where the start or head card is, the sequence of remaining cards follows a common rule: the first four cards are replicated in the second four cards in order. The following are some examples:
D as head, the order is D-A-B-C D-A-B-C
A as head, the order is A-B-C-D A-B-C-D
B as head, the order is B-C-D-A B-C-D-A
and more

No matter how you wash your cards at the beginning or how many times you place the head card at the bottom of the tail card, This sequence follows a similar replicated sequence.

Another very interesting feature is that taking the first three cards, the first half card, and the last one of the remaining five cards is the matched card, i.e., the original C card. For example, taking three cards from the head D card, the head and tail of the remaining cards are all from the C card.

Based on those math discoveries, the next step in the magic game is to take the first three cards out and place them between any remaining cards. For example, place the first three cards in any position of the organ arrows shown in the following picture.

Choose a position, as shown in the following picture, between B and C.

After inserting, the following is the case of eight cards in a sequence.

Now the head and tail are all C. Take the head C, the secret card, out, and place it aside.

The number of remaining cards is seven. Place the secret card in the middle of the circle.

Please note that the tail card is another C, a key card. At this moment, the other cards above the key are not important. Their sequence can be anything. As in the magic show, you can ask the audience to place those non-key cards anywhere, but keep the key at the end. For you, the magician, you should clearly remember that the last card is the matching card to the secret card.

Math Two: Josephus Problem

Another math in the magic show is the famouse Josephus math problem.

This is an old story from an ancient war. The historian Josephus and a team of soldiers were in a trap and had no way to escape. To avoid being captured and killed, they chose to commit suicide by each other. Then they designed a method, either by luck or the hand of God. They stood in a circle, one starting to kill the next one clockwise, and the next remaining one repeated the kill until the last one killed himself. The last remaining one could, in fact, survive.

The story became a math problem. N soldiers in a circle list. Start at one clockwise to count, the odd number remains, and even one out. Repeat this process until there is only one left. The math problem is to find out the index position of the surviving soldier. The problem is a very interesting pure math and computer science problem.

Liu Qian's game was designed based on this math problem. For a game with five or six cards in a list, Liu organised several deceiving steps to find a way to move the last matching card to the surviving position so that he could make the perfect match. Coincidentally, the seven-charcter magic word can move the last card in the 5 or 6 card list to the survive position! Interstingly, I found out that the same step applies to a seven-card list.

Continue the game based on the result of the seven cards in the above picture. Throw the head-A card away. This is the result:

Read out aloud the seven-letter magic word one by one and move the head card to the bottom at the same time. The last card C is moved to the fifth position of a six-card list. This is exactly the surving position:

Based on the rule of odd-in and even-out in the Josephus problem, the other half C card is the last remaining card:

At last, the match was made!

Conclusion

Based on those two math problems, Liu elegantly designed his very interesting magic game. The first math is a list of replicated sequences. He could repeatedly move two matched cards to the head and tail of the list. Then keep the first card as a secret, to-be-matched card. The second is the Josephus problem. He continued his deceiving steps to move the last card to the right position and finally found the matched card.

With my above analysis, you may further design your own and more interesting steps. You may use various numbers of cards, such as 2, 3, 5, or even more.

After this game, do you have any other interesting math problems? You may define another totally different but also very interesting gamic game. Share yours with us!

References

• My previous blog: Liu Qian's Magic Card Show in TV Gala
• Wikipedia：Josephus problem
• A computer science class on the Josephine Problem. At 12:57, a table is displayed with the n-list and survive index solution.
  
  
  
  

Liu Qian's Magic Card Show in TV Gala

Liu Qian presented a magic card show at the Chinese Spring Festival TV Gala 2024. Like most magic shows, being interactive with the audience is a very popular way to make the show interesting. Liu's show was so amazing and well received that even audiants in front of TV could participate and get unexpected and unblievable results.

I watched the show on YouTube. When I saw the amazing result, I could not wait any longer to give it a try. I did get a similar and amazing result. Initially, I could not find play cards at that time, and I did not want to destroy cards simply by playing the game. I wanted to do the show with my grandson. I asked him to get a piece of paper to make cards with four different numbers and any drawing shapes. We enjoyed the game very much.

I tried the game several times. Afterwards, I got my understanding and some ideas about the game. I made some modifications to replace Chinese contents with Western ways. Finally, I created the following modified version of the game.

This game is related to mathematics and computer science. Therefore, I write this on my programming blog.

Modifications of the Rules

In Alberta, we have two hokey players: the Flames in the south city of Calgary and the Oilers in the north city of Edmonton. I'll use them as players. The following are the rules and related modifications:

• In the original show, people from the south had number one and those from the north had number two.
  I made this change: Flames at the sourth have number one, and Oilers on the north have number two.
• The number of Chinese characters in one's name was used in the show.
  The number of Flames and Oilers names is 6. Another alternative for fun is to use the number of vowels or consonants, just for kits to learn.
• One interesting choice is the sex of a random person: male as number one and female as number two in the show.
  I use the flip of a coin, the head as number one, and the tail as number two.
• The secret or magic words are 見-證-奇-蹟-的-時-刻
  I use the English word m-a-g-i-c-a-l

Based on my understanding and analysis, I categorise all the steps in the game into three groups.

Build Cards' Structure - Preparation 1

Those are steps to build cards in the right structure.

1. Fully shuffle four cards first. Fold the cards in half. Then, based on the fold line, rip the cards into two halves. Finally, put one half on top of another half. The total number of cards is eight.
2. I chose the Flames to start a game. I read the name of the characters one by one, and at the same time, I place the top card on the bottom of the deck. In this way, I repeat the process six times.
3. Take the top three cards up and place them any place between the remaining cards, i.e., after the first, second,... or fourth card (before the fifth). I put the top three cards after the fourth card.
4. Pick up the top card. Keep it in a secret or safe place. This is the secret card.

Up to this step, you have seven half-cards in your hand. Eventually, you will have a last-half card left, and the card will match the secret card, which is the other half.

Deceive or Confuse - Preparation 2

Continue to interact with audiences. The steps in this second group would further deceive or confuse them. By the time of the last step, the right number of cards will be ready for the steps in the last group.

5. I chose the Flames team, which is in the south of our province. Based on the above rule, the number is one. Take the top card from the deck and place it between the remaining cards. I place the top card behind the third card. It could be placed behind the first card, the second card,..., or the fifth one.
6. At this step in Liu Qian's show, Liu used male or female for a random choice. Based on my above modifications, the alternative random choice is to throw a coin. My grandson received some chocolate candy coins. We made an agreement: one side as number one, another side as number 2. I explained to him that this is like a hokey game to choose the starting side in the beginning. He threw the coin and got the number two. I asked him to take the top two cards and throw them into the air.
   I asked my grandson to mimic Liu and Xiao Ni (one famous show anchor as the game player). They said, Sorry, cleaning maids. My grandson said, Sorry, dady and mami, we will clean those cards.

Magic Words for Magic Results

Up to this step, there are only five half-cards left. The game entered the most interesting and exciting stage.

7. Read the magic words in the above rules, one character by one. For each read, place the top card at the bottom. The order is as follows: m-a-g-i-c-a-l.
8. The last step is the moment in the most emotional and exciting mode. Place the top card at the bottom. At the same time, say it loudly: Keep my luck. Then take the top card from the remaining deck. Throw the card into the air and say, Announcing things, go away!.
   Repeat this sequence until the last card is in the hand.

Now get the secret card and place it next to the last one. Turn them over. What magic!

The last half-card left in your hand is exactly the other half-card, the secret card!

Liu Qian played such an extraordinary magic show at the Chinese Spring Festival Gala. Almost all the audiences, including me and my grandson, in front of the TV, proved this magic result.

Liu said that this is a very ancient magic game. Every year on the eve. of the New Year, many people play this magic game. If you succeed, your days in the next year will be full of happiness; if you fail, then repeat watching and playing the game till you win.

Summary

Liu Qian presented a really good magic game. After following the show and seeing the result, I could not explain the logic, which is really magic. Anyone could play this game, such as alduts. However, I think this game would be very attractive to young kids. The steps in the game are very complicated and long. It is hard to memorise those steps. I repeatedly watch the show, and I think it will be forgotten after a while. That's why I wrote this blog with all the steps. Those steps are grouped into three categories. I think this will be helpful as a study place and reference.

Liu's show was in Chinese. In order to help non-Chinese-speaking people as well as oversee Chinese kids, I modified some parts of the game, based on my understanding, with other alternatives, such as creating cards from a piece of paper, drawing characters, numbers, or shapes, using sports teams, throwing a coin, counting characters, vowels, and consonants, using different magic words, et cetera. In this way, it might attract more people around the world to enjoy the game.

Although the steps in this game, including your modifications, are very long and complicated, those are the magic spirits that make it very hard to grasp its logic. They provide you with an opportunity to demonstrate or practice your show-time talent and bring magic and happiness to everyone. Like many new things, the process of learning and practicing is very important. The repetition will help you to link steps in a fluent and natural way, and the show-time will help you to control rhythm and to present your confidence.

With some changes I made to Liu's show, I hope you can create your version better than mine. Enjoy the game!

References

• Chinese Spring Festival Gala 2024. Liu's show started at 1:09:53.
  
• CGTN artical: Stage magic act 'Ringing in Chinese New Year Together' captivates audience at Spring Festival Gala
• My blog: Reveal Liu Qian's Magic Card Game