I posted a first-draft video walkthrough of Kanachan’s Read the Hiragana to YouTube. A few of the UI elements may still change, but basic app usage won’t. Constructive feedback welcome. =)
Updated Kanachan’s Read the Hiragana screen shots
22
Jul
We’ve made a lot of progress on the Kanachan’s Learn the Hiragana iPhone app, and I think that it looks much better than back when I published the first round of screen shots.
Before:
Current:
Before:
Current:
We are hoping to finish the application in the next few days, and submit to Apple for review within a week. Wish us luck with the review process!
Kanachan’s Kana Reference Table released
22
Jul
In case you missed it from my Twitter feed, our first iPad application, “Kanachan’s Kana Reference Table” is now available on the App store.
This app is actually a spinoff of the iPhone app that we are working on. It’s based on one of the screens in the Kana learning app, and was originally intended to be a quick 2-day learning hack while I waited for some graphics from my partner. It sort of took on a life of its own, however, and since it is a much simpler app than “Kanachan’s Read the Hiragana” ended up being finished first. (It ended up having a lot of features that I didn’t originally intend to include, however…)
We’re coming close to finishing the hiragana application, and hope to submit to Apple for review within the next week or so. I will certainly post again when it becomes available.
Hiragana app progress
17
Jun
After meeting with my design partner, I’ve made some significant updates to the UI. All of the buttons that were placed beneath the card are now added to the toolbar at the top of the screen. The “right” and “wrong” buttons are no longer text, and will become image buttons. I also finally have autorotate pretty much nailed (a much more difficult thing to do than I thought it would be…), with just one last layout bug that needs to be fixed.
I also got in-app purchases working, and am pretty sure that we will implement a try-it-before-you-buy-it model where the first 100 cards are free with all features enabled.
I have a little bit of free time while I’m waiting for graphics, so I’ve started working on the data for the Read the Katakana app. As I do this, I’m starting to doubt my original plans, and wonder if I shouldn’t create a “Read the Kana” app instead of separate “Read the Hiragana” and “Read the Katakana” apps. My original intent was to release separate apps because I want to include a couple of katakana-specific features/design tweaks in the latter, but after looking at the reviews of similar apps in the App Store, I’m pretty sure that such an approach would lead to some 1-star reviews from people who want both in a single app.
I’ll keep mulling over this over the next couple of days and see how much of a mess combining the two would be…
First screenshots
08
Jun
Kana-chan’s Read the Hiragana is functionally almost complete. Most of the work remaining to be done is UI tweaks and lots of graphics work (the program is pretty ugly right now—meeting with my graphic designing partner this weekend to talk about how to purty it up).
The main screen is pretty simple, and just shows the front of the card you’re studying (click to see the full screen):
You can click the microphone icon to record your voice (optionally), and tap the card (or click “Flip”) to see the back of the card:
This shows the word in Romaji (along with the meaning of the word, though translations can be turned off in Prefs, since this is not a vocabulary program). You can tap the “Speak” icon to have the program play the word, and if you recorded yourself saying the word while looking at the front of the card the native speaker’s pronunciation will be followed by your own.
New characters are introduced as you progress, each one with a mnemonic device for remembering the form of the character:
The “Kana” tab shows a table of all of the kana, with buttons enabled for the kana that you have learned so that you can review their mnemonic stories. The table also acts as a visual representation of your progress so far:
The stats screen shows some statistics related to how long you’ve been using the program, how much you’ve been studying every day, etc.:
In the next major release, I hope to have an opt-in program where users can send their usage data so that we can get an idea of how long it takes most people to learn to read the hiragana using this app.
More on app pricing
05
Jun
A couple of interesting articles recently on app pricing.
The first is “Never Charge for a Mobile App (and Other Freemium Lessons From VCs)” on GigaOM, in which several VCs push a recurring revenue model—make the app free, and try to sell content from within it over and over again, they say. The caveat is that only about 3-5% of users can be expected to pay anything, so you need to choose a really big market. Unfortunately, “Japanese learners” is not a big market, relatively speaking. That being said, I’ve pretty much decided to release most of my Japanese apps under a “try it before you buy it” model, using in-app purchases to unlock the full program after an extended period of using it. The hiragana reading app, for example, has about 500 cards. I will probably make the app free for the first 100-200, and ask the user to pay if they like the app and want to continue using it.
The second is “iPad App Pricing” by Matt Legend Gemmell, which discusses some interesting math that I’ve had bouncing about in my head for a while now. Namely, it is interesting that many people are hesitant to shell out cash even when the amount requested equates to a very low value per hour of their own time. For example, say that my hiragana reading app should save the average user 2 hours of study time in learning how to read the hiragana (a pretty conservative estimate, I think). If I charge $3.99 for the app, then anyone who thinks that is too expensive is in essence saying that their time is worth less than $2.00 an hour.
Another way to think about the situation is to imagine this: A skilled Japanese teacher says “Hey, buy me a latte and I’ll teach you the hiragana”. Sounds like a pretty good deal, doesn’t it? Yet many potential app purchasers consider the price of a latte expensive when buying apps. There are of course many other complicating factors, such as the reputation of the developer, perceived quality of the app, the existence of competing apps, etc. The whole thing seems to be a weird combination of economics, human psychology, and voodoo.
Hiragana reading app progress
05
Jun
Over the past couple of days I added a new feature that for some reason I didn’t even think about in the original specs for the program (which is currently titled Kana-chan’s Hiragana Reading, BTW), but has really changed the feel of the program—the ability to record your answers as you are presented with hiragana cards, and then play your recording along with the pronunciation by a native speaker. I was already planning on including sound files for each word so that users could hear their pronunciation (and already have recorded all of the words in the program—over 500 of them!), but being able to hear your pronunciation side-by-side with a native speaker’s is pretty damn cool. I even found a couple of words where I had been putting the emphasis on the wrong syllable! The result is that, depending on how you use it (since self recording is optional), the program can be half hiragana reading practice and half Japanese pronunciation practice.
I’m really happy with the built-in recordings, too. UGA’s Sasaki-sensei was kind enough to do the recordings for me, and they sound pretty good, IMHO, especially using headphones. I can’t wait to finish this app and make a katakana reading version.
Splitting my time
01
Jun
As a compliment to the apps that I am developing, and also to fulfill a long time goal (and requests from my students), I have started working on an online textbook to teach Japanese. I’m still torn about splitting my time between two large projects (while also supporting myself doing freelance translation work and other odd jobs, not to mention hoping to finish my PhD over the next 18 months or so…), but I think that both are important compliments to each other. There’s more about the goals of the textbook on that site, if you are interested.
Sweet Prefix.pch file
04
May
Ooooh, this is niiice…
#ifdef DEBUG
#define DLog(...) NSLog(@"%s %@", __PRETTY_FUNCTION__, [NSString stringWithFormat:__VA_ARGS__])
#define ALog(...) [[NSAssertionHandler currentHandler] handleFailureInFunction:[NSString stringWithCString:__PRETTY_FUNCTION__ encoding:NSUTF8StringEncoding] file:[NSString stringWithCString:__FILE__ encoding:NSUTF8StringEncoding] lineNumber:__LINE__ description:__VA_ARGS__]
#else
#define DLog(...) do { } while (0)
#ifndef NS_BLOCK_ASSERTIONS
#define NS_BLOCK_ASSERTIONS
#endif
#define ALog(...) NSLog(@"%s %@", __PRETTY_FUNCTION__, [NSString stringWithFormat:__VA_ARGS__])
#endif
#define ZAssert(condition, ...) do { if (!(condition)) { ALog(__VA_ARGS__); }} while(0)
Read the description at Cocoa is my Girlfriend.
Review algorithms
04
May
Coming back to the hiragana reading app, I’ve decided to rewrite the scheduling algorithm. Originally I was using a modified version of the SuperMemo 2 algorithm, known and loved through Anki, SuperMemo, and numerous other apps, but after playing around with it a bit I decided that this isn’t the best algorithm to use for the kana, for several reasons:
- The algorithm assumes a target number of items to be learned per day, but I think that many hiragana learners will be able to successfully learn with an “all you can eat” model
- Every learned item is considered as a disassociated entity from other items. That would be true if you were learning the kana individually, but my app teaches the kana in the context of words, not individual characters, so any given kana will be reviewed many times in other cards
- Items are never retired using SuperMemo algorithms, just spaced farther and farther into the future. This doesn’t make sense for the kana, which Japanese learners will be using every day. Review will come about through constant usage, so an up-front focused approach should be better.
Instead I’ve decided to use a slightly modified Leitner Box algorithm, which I think should give much better results than SM2.