My day started with lunch with Nishida, a Japanese businessman setting up the Philippine subsidiary of MSI Corporation. MSI was my host company during my internship, and I’m greatly obliged to them for the opportunity to see how the Japanese software industry worked. I was nervously thinking of what they might want assistance with, and I was pleasantly surprised to find out that this was a social call. We met at the lobby of Shangri-la Makati and walked to Zen for (unsurprisingly) a Japanese lunch.

I had fun chatting with him in Japanese. He said he must’ve been to
all the Japanese restaurants in the area, and he proceeded to list
them. They were just imitations, he said, but they were much cheaper
than food in Japan so he wasn’t unhappy. He had some problems figuring
out the bento box system at Zen, so I tried to explain how it worked,
and I also asked for the Japanese menu. (Good thing my mom and I
peeked at the Japanese menu a week or two ago!)

We then chatted about life in a foreign country. I told him how I’d
quickly made friends through free conversations with volunteers,
technical conferences, and nomikais (informal get-togethers). He’s
been in the Philippines for over seven months but has been having
problems making Filipino friends. Although he went to a few karaoke
bars (you know the Japanese and their karaoke), he didn’t really get
to know people there. As he said, women there just hit on you because
they want to marry a Japanese guy. I laughed and told him I have a
wonderful boyfriend; he doesn’t need to worry about me. He has a
Filipina assistant who sometimes teaches him about Filipino culture
(what to do and what not to do), but they can’t hang out because they
work together. All the other people he knows are Japanese, so they
chat in Japanese. As a result, he doesn’t really feel comfortable
chatting in English.

Of course, I offered to switch to English so that he could practice.
He declined, saying he was just so relieved to find a Filipino who can
talk to him in Japanese. I told him a lot of people learn Japanese
because of anime, and offered to help him look for friendship circles
and other things like that.

We also chatted about cultural misadventures. Food was, as always, a
source of great humor, from balut (which we both can’t stand) to
chicharon (which he found absolutely horrific—how can anyone eat that
sort of stuff? I just grin). He told me about this morning’s phone
call. When he called up the house to confirm our lunch, of course he
asked for “Chua-san”—I always used my last name in Japan, following
convention. My dad answered the phone, and it took some back-and-forth
and a bit of panicking on Nishida’s end before my dad realized the
call was for me. Heh. That’s also why I tend to call guys by their
first names instead of by their last names, even if that _is_ their
nickname…

(You can ask Ernest about the very first time I called him up. See,
his nickname was not only “Baello” (his last name), but he also had
the same name as his father_, so I couldn’t just ask for “Ernest”…
To be safe, I specified his _full_ name instead. That made his mom laugh.)

Anyway. We’ll take care of introducing Nishida to some other people
and taking him out to see some places; it’s the least I can do to
repay my obligations to the volunteers who helped me so much in Japan.
I wish Dominique was there. They’d probably have gotten along very
well. My mom might have fun chatting with him, too; she’ll know how to
make him feel relaxed. Tita Raquel, definitely. I wonder who else
among our friends can help the poor guy… =)

Looks like I passed level 3 of the Japanese Language Proficiency Test.
Yay.

Kakasi is an external utility for
converting Japanese text between coding systems. It can also add
furigana after kanji or convert a text file to romaji.

Debian users can apt-get install kakasi kakasi-dic.
There’s an Emacs interface,
a Perl module (Text::Kakasi),
and a Ruby library.

Aris and I are both struggling with far too much kanji. I used a
combination of kdrill to gain familiarity with kanji and
../emacs/flashcard.el to drill the meaning into my brain, as
flashcard.el requires me to get a question right 5 times in a row
before considering it solved. Aris searched the Internet for flashcard
programs on Windows and played around with things like Kanji Gold and
King Kanji, but couldn’t figure out how to import our wordlist into
them. Kanji Gold looked promising as it also used EDICT, but I
couldn’t figure out the magic number at the end of the dictionary
entry. With over 200 words in our word list, there was no way we were
going to enter those things one by one!

I told him to download Emacs and grab Jorgen Schaefer’s flashcard.el
from my ../emacs directory. I then grabbed the dictionary file that
Kanji Gold couldn’t recognized, replaced [ with : to get flashcard to
recognize it without problems, then set up a deck for him. I tweaked
the default faces a bit—they’re horrible on light-colored displays. I
copied the suggested feedback config and explained the pigeonhole
method to him. I tweaked the checking function so that it checked for
substrings and treated empty input as a definitely incorrect answer.
He wanted the answers displayed all the time, so I coded that in as
well.

The initial word list was too big, so I copied 9 words and put them
into a file, then imported them into a deck. Later, when he finishes
this deck, I’ll show him how to create another colon file and import it.
I’ll also ask him if he wants to tweak the number of compartments.

He’s asked me if I can get YM working in the text editor as well. I’m
currently tunneled through Richi’s host, but I think I can open a
local tunnel for him as well, if he feels like using ERC. ‘course,
normal YM just might work, and chances are there’s a YM-specific
client somewhere in Emacs.

I’ve made no efforts to hide Emacs’ complexity. I lean over and drop
into Lisp code in front of him because I want him to have a working
environment up and running as soon as possible. Who knows? Maybe he’ll
use Emacs even after the internship. =)

He looks like he’s having fun, and certainly appreciates the fact that
I can hack the editor to fit how he wants to do things. He wants to
match the readings, too, which means I’ll need to figure out how leim
works under Windows. I’ll do that on Monday.

This extracts all kanji in the buffer and converts them to the format
expected by flashcard.el.

(defun sacha/kanji/get-ordered-kanji-list ()
  "Return a list of characters in the buffer."
  (goto-char (point-min))
  (let (kanji-list)
    (while (not (eobp))
      (let ((c (char-after (point))))
        (when (>= c ?亜) (add-to-list 'kanji-list c)))
      (forward-char 1))
    kanji-list))

(defun sacha/kanji/to-flashcard-j2e (&optional list)
  "Return a Japanese-English flashcard set.
If LIST is non-nil, use that instead of the current buffer."
  (interactive (list (sacha/kanji/get-ordered-kanji-list)))
  (unless list (setq list (sacha/kanji/get-ordered-kanji-list)))
  (let ((result
         (with-current-buffer (find-file-noselect "/usr/share/edict/kanjidic")
           (mapconcat
            (lambda (kanji)
              (goto-char (point-min))
              (when (re-search-forward (format "^%c.*?{\\(.*\\)}" kanji) nil t)
                (format "%c : %s\n"
                        kanji
                        (replace-regexp-in-string "}\\s-+{" "," (match-string 1)))))
            list
            ""))))
    (if (interactive-p) (kill-new result) result)))

(defun sacha/flashcard-method-leitner-check-answer (card answer)
  "Check answer for correctness. Allow multiple correct answers and provide feedback."
  (if (member answer (split-string (flashcard-card-answer card) ","))
      (progn
        (flashcard-insert "Correct! Answer is:\n"
                          (propertize (flashcard-card-answer card)
                                      'face 'flashcard-answer-face
                                      'rear-nonsticky t)
                          "\n"
                          "\n")
        t)
    (flashcard-insert "The correct answer is:\n"
                      (propertize (flashcard-card-answer card)
                                  'face 'flashcard-answer-face
                                  'rear-nonsticky t)
                      "\n"
                      "\n")
    (y-or-n-p "Was your answer correct? ")))

(setq flashcard-method-check-answer-function 'sacha/flashcard-method-leitner-check-answer)
(add-to-list 'auto-mode-alist '("\\.deck\\'" . flashcard-mode))
(add-hook 'flashcard-mode-hook 'flashcard-add-scroll-to-bottom)
(add-hook 'flashcard-positive-feedback-functions 'flashcard-feedback-highlight-answer)
(add-hook 'flashcard-positive-feedback-functions 'flashcard-feedback-congratulate)
(add-hook 'flashcard-positive-feedback-functions 'flashcard-method-leitner-positive-feedback)

This is for use with kdrill.

(defun sacha/kanji/get-ordered-kanji-list ()
  (let (kanji-list)
    (while (not (eobp))
      (let ((c (char-after (point))))
        (cond
         ((= c ?\"))
         ((= c ?\n))
         ((= c ?:) (forward-line 1) (forward-char -1))
         (t (add-to-list 'kanji-list c))))
      (forward-char 1))
    kanji-list))

(defun sacha/kanji/ordered-usefile-to-kill ()
  (interactive)
  ;; Look up kanji in kanjidic
  (let ((list (sacha/kanji/get-ordered-kanji-list)))
    (kill-new
     (with-current-buffer (find-file-noselect "/usr/share/edict/kanjidic")
       (mapconcat
        (lambda (kanji)
          (goto-char (point-min))
          (when (search-forward (char-to-string kanji) nil t)
            (skip-syntax-forward " ")
            (buffer-substring-no-properties (point) (and (skip-syntax-forward "^ ") (point)))))
        list
        "\n")))))

MWAHAHAHAHA! I just pulled off a really neat Emacs
hack. <grin> It’s Japanese-related. So I’ve been
translating this document for the past two days. It’s really slow
and boring work because there’s no soft copy, so I have to write
the characters (blurry because this is a photocopy of a
photocopy) using the mouse, and hope I don’t make any mistakes
along the way. In the course of copying down kanji (Chinese
characters) for later translation, I created a spreadsheet with
two columns: the kanji word and the number of the slide it
appears on. Then I exported that to CSV, opened that in Emacs,
and wrote an Emacs Lisp function that split the words up into
individual characters. I passed this through
shell-command-on-region to sort and uniquify the characters. I
then went back to the CSV with words and slide numbers, wrote
another Emacs Lisp function that searched edict (Jim Breen’s
electronic Japanese dictionary) for the words, split the word
into individual characters, and filed the word info under each
character, also marking words that were not found in the
dictionary. After that, I wrote yet another function to add table
markup and individual character definitions to each line, then
copied the result into an HTML file.

This should probably be rewritten as a Perl script.

;; Generate the list of characters
;; Use add-all to add all the words to the list
;; call sacha/kanji/format-kanji-with-references

(defvar sacha/kanji/output-file "~/tmp/kanji")

(defun sacha/kanji/process-csv ()
  (interactive)
  (sacha/kanji/split-dictionary)
  (sacha/kanji/add-all)
  (sacha/kanji/format-kanji-with-references))

(defun sacha/kanji/split-dictionary ()
  (interactive)
  (let ((buffer (current-buffer)))
    (with-current-buffer (find-file-noselect sacha/kanji/output-file)
      (erase-buffer)
      (insert-buffer-substring buffer)
      (goto-char (point-min))
      (while (re-search-forward "^\"\\([^\"]+\\)\":" nil t)
        (delete-region (match-end 1) (line-end-position))
        (goto-char (line-beginning-position))
        (delete-char 1)
        (while (not (eolp))
          (forward-char 1)
          (unless (bolp)
            (insert "\n"))))
      (goto-char (line-beginning-position))
      (delete-matching-lines "^\\s-*$")
      (shell-command-on-region (point-min) (point-max) "sort | uniq"  nil t))))

(defun sacha/kanji/add-all ()
  (interactive)
  (while (not (eobp))
    (sacha/add-word)
    (forward-line 1)))

(defun sacha/kanji/format-kanji-with-references ()
  "Add character meaning and table markup."
  (interactive)
  (find-file sacha/kanji/output-file)
  (goto-char (point-min))
  (while (not (eobp))
    (goto-char (line-beginning-position))
    (unless (= (char-after (point)) ?<)
      (forward-char 1)
      (let* ((kanji (buffer-substring (line-beginning-position) (point)))
             (definition (sacha/kanji/find-definition kanji)))
        (when definition
          (save-excursion
            (forward-char -1)
            (insert ""))
          (insert "")
          (insert definition)
          (goto-char (line-end-position))
          (insert ""))))
    (forward-line)))

(defun sacha/kanji/find-definition (kanji)
  "Look up kanji definition."
  (with-current-buffer
      (find-file-noselect "/usr/share/edict/kanjidic")
    (goto-char (point-min))
    (when (and (search-forward kanji)
               (re-search-forward "\\({[^}]+}\\( {[^}]+}\\)+\\)"))
      (match-string 0))))  ;; kanji definitions

(defun sacha/kanji/lookup-word (key)
  "Return the definition of the current word. Ensure edict is loaded before running this."
  (with-current-buffer edict-buffer
    (goto-char (point-min))
    (when (re-search-forward (concat "^" key " \\[\\([^]]+\\)\\] /\\(.*\\)") nil t)
      (list (match-string 1) (match-string 2)))))

(defun sacha/add-word ()
  "Look up this word's definition and add the word to individual character entries."
  (interactive)
  (when (looking-at "^\"\\([^\"]+\\)\".*?:\\([0-9]+\\)")
    (let ((word (match-string 1))
          (slide (match-string 2))
          definition
          chars)
      (setq definition (sacha/kanji/lookup-word word))
      (setq chars (split-string word "" t))
      (while chars
        (with-current-buffer (find-file-noselect sacha/kanji/output-file)
          (goto-char (point-min))
          (when (re-search-forward (concat "^" (car chars)) nil t)
            (goto-char (line-end-position))
            (insert "
S:" slide " " word "")
            (if definition
                (insert " " (elt definition 0) ""
                        " " (elt definition 1) "")
              (insert "???"))))
        (delete (car chars) chars)
        (setq chars (cdr chars))))))