Metalanguage

Teaching Japanese Through Japanese

Just as a programming language needs its own syntax to describe itself, we need a core set of Japanese patterns to teach Japanese. This document establishes our teaching metalanguage - the patterns we use to explain patterns.

Core Teaching Patterns (基本的な教え方)

Pattern 1: Introduction of Concepts (概念の紹介)

When introducing new concepts, we follow this progression:

1. Basic Introduction:
これは[概念]です。
This is [concept].

2. Purpose Statement:
[概念]を使います。
We use [concept].

3. Example Setup:
例を見てください。
Please look at an example.

4. Example Demonstration:
例：[基本例]
Example: [basic example]

This maps to our type system introduction pattern:

interface ConceptIntroduction {
  concept: string;        // What we're teaching
  purpose: string;        // Why we use it
  example: string;        // How it works
  validation: string[];   // How to verify correct usage
}

Pattern 2: Practice Guidance (練習の導き方)

For practice sessions, we use these patterns:

1. Practice Invitation:
練習しましょう。
Let's practice.

2. Pattern Template:
[＿＿＿]は[＿＿＿]です。
[___] is [___].

3. Attempt Request:
言ってみてください。
Please try saying it.

4. Feedback Response:
そうですね。/ もう一度。
That's right. / One more time.

This implements our practice loop structure:

interface PracticeLoop {
  invitation: string;     // Start practice
  template: string;      // Pattern to follow
  attempt: string;       // Student tries
  feedback: string;      // Guide improvement
}

Pattern 3: Error Correction (間違いの直し方)

When correcting mistakes, we use these patterns:

1. Gentle Redirection:
もう一度聞いてください。
Please listen again.

2. Correct Form:
正しい形は[＿＿＿]です。
The correct form is [___].

3. Practice Request:
もう一度言ってください。
Please say it again.

4. Encouragement:
はい、よくできました。
Yes, well done.

This implements our error handling system:

interface ErrorCorrection {
  detection: string;     // Notice error
  correction: string;    // Show correct form
  practice: string;      // Try again
  reinforcement: string; // Confirm improvement
}

Pattern 4: Concept Connection (概念の繋がり)

When connecting concepts, we use:

1. Previous Reference:
前の文型を覚えていますか。
Do you remember the previous pattern?

2. Connection:
新しい文型は似ています。
The new pattern is similar.

3. Difference Highlight:
違いは[＿＿＿]です。
The difference is [___].

4. Integration:
二つの文型を使ってみましょう。
Let's try using both patterns.

This implements our pattern integration system:

interface PatternIntegration {
  recall: string;        // Previous pattern
  connection: string;    // Relationship
  distinction: string;   // Key differences
  combination: string;   // Using together
}

Progressive Vocabulary Building (語彙の積み重ね)

We build our teaching vocabulary progressively:

Week 1 Core Vocabulary:

これ/それ/あれ - this/that/that over there
です - is
使います - use
見てください - please look
聞いてください - please listen
そうですね - that's right
もう一度 - one more time

Week 2 Additions:

覚えていますか - do you remember
似ています - is similar
違います - is different
試してみましょう - let's try

Week 3 Expansions:

説明します - will explain
理由は〜です - the reason is
結果は〜です - the result is
確認しましょう - let's confirm

Daily Learning Cycle (日々の学習サイクル)

Each learning session follows this pattern:

1. Review (復習):
前の文型を見てください。
Please look at the previous pattern.

2. Introduction (導入):
新しい文型です。
This is a new pattern.

3. Practice (練習):
一緒に練習しましょう。
Let's practice together.

4. Integration (統合):
組み合わせてみましょう。
Let's try combining them.

This implements our learning loop:

interface LearningCycle {
  review: string;        // Reinforce previous
  introduction: string;  // Present new
  practice: string;      // Build familiarity
  integration: string;   // Combine patterns
}

Success Patterns (上達のパターン)

You’re successfully using the metalanguage when:

1. You can understand instructions in Japanese
2. You can identify pattern components
3. You can correct your own mistakes
4. You can explain patterns to others

This maps to our competency validation:

interface Competency {
  comprehension: boolean;  // Understand instructions
  recognition: boolean;    // See patterns
  correction: boolean;     // Fix errors
  explanation: boolean;    // Teach others
}

Using This System (システムの使い方)

This metalanguage serves as both:

1. The medium through which we teach
2. The content that we’re learning

Just as a programming language must be able to describe itself, our teaching patterns demonstrate the very concepts they’re teaching. Each explanation reinforces both the specific content and the general patterns of Japanese communication.

Remember: The goal is to think in Japanese patterns rather than translating from English. These teaching patterns help build that natural understanding by making Japanese self-describing.

Continue to Calendar Structure →