TOON vs JSON :
La Révolution de la Sérialisation

1. Les Limites de JSON en Production

🐢 Parsing Lent

JSON est un format texte nécessitant parsing caractère par caractère. Sur des payloads volumineux ou une fréquence élevée, le CPU devient bottleneck.

📦 Payload Volumineux

JSON encode tout en texte UTF-8 : nombres (`42` → 2 bytes), floats (`3.14159` → 7 bytes), booleans (`true` → 4 bytes). Coût bandwidth élevé, critique pour IoT/mobile.

⚠️ Typage Faible

JSON ne distingue pas int8/32/64, float32/64, timestamps. Tous les nombres sont `Number`, causant bugs silencieux (overflow, perte précision).

// JSON : perte précision sur grands nombres
{"userId": 9007199254740992}  // int64
// Parsed: 9007199254740992 (OK)
// Incremented: 9007199254740993 (ARRONDI à 9007199254740992)
// Bug silencieux causant collisions userId

2. TOON : Format Binaire Optimisé

🎯 Token-Oriented Design

TOON encode les données en tokens binaires typés :

• Type tokens : 1 byte identifiant le type (int8, int32, float64, string, array, object)
• Length prefix : Taille variable encodée efficacement (1-4 bytes)
• Payload binaire : Données raw (int32 = 4 bytes, float64 = 8 bytes)

// Exemple : Encoder {"userId": 42, "score": 3.14}

JSON (texte) : {"userId":42,"score":3.14}  → 29 bytes

TOON (binaire) :
0x01           // Token: OBJECT_START
0x06           // Length: 6 bytes (key)
"userId"       // Key (6 bytes)
0x12           // Token: INT32
0x0000002A     // Value: 42 (4 bytes)
0x05           // Length: 5 bytes (key)
"score"        // Key (5 bytes)
0x14           // Token: FLOAT64
0x40091EB851EB851F  // Value: 3.14 (8 bytes)
0x02           // Token: OBJECT_END

Total: ~30 bytes (comparable, mais gains sur gros payloads)

⚡ Parsing Incrémental

Contrairement à JSON (parse complet obligatoire), TOON supporte le parsing incrémental : traiter les données au fur et à mesure de la réception (streaming WebSocket, chunked HTTP).

3. Benchmarks : TOON vs JSON vs Alternatives

4. Cas d'Usage Idéaux pour TOON

5. Stratégie de Migration JSON → TOON

📋 Checklist Migration

1. Audit performance

   Identifier bottlenecks : parsing CPU, bandwidth réseau, RAM. TOON pertinent si >10K req/s ou payloads >100KB.

2. Migration progressive (Hybrid Mode)

   APIs internes → TOON, APIs publiques → JSON. Content negotiation via header Accept: application/toon.

3. Monitoring & rollback

   Feature flags pour activer/désactiver TOON par service. Métriques : latence p50/p99, erreurs parsing, throughput.

4. Documentation & debugging

   TOON étant binaire, fournir outils debug (décodeur CLI, logs human-readable). Former équipes aux nouveaux patterns.

6. Implémentation TOON (Node.js)

📦 Installation

npm install @toon/encoder @toon/decoder

✍️ Encoding

import { TOONEncoder } from '@toon/encoder';

const encoder = new TOONEncoder();
const data = {
  userId: 42,
  username: "john_doe",
  score: 3.14159,
  isActive: true,
  tags: ["premium", "verified"]
};

const buffer = encoder.encode(data);
// buffer: Uint8Array (binaire TOON)

// Envoi via HTTP
fetch('/api/users', {
  method: 'POST',
  headers: { 'Content-Type': 'application/toon' },
  body: buffer
});

📖 Decoding

import { TOONDecoder } from '@toon/decoder';

const decoder = new TOONDecoder();

// Réception via HTTP
app.post('/api/users', async (req, res) => {
  const buffer = await req.raw(); // Uint8Array
  const data = decoder.decode(buffer);
  
  console.log(data);
  // { userId: 42, username: "john_doe", score: 3.14159, ... }
  
  res.json({ success: true });
});

🌊 Streaming (WebSocket)

import { TOONStreamDecoder } from '@toon/decoder';

const streamDecoder = new TOONStreamDecoder();

ws.on('message', (chunk) => {
  streamDecoder.push(chunk);
  
  // Traiter objets complets au fur et à mesure
  while (streamDecoder.hasComplete()) {
    const obj = streamDecoder.next();
    processUpdate(obj);
  }
});

Conclusion : TOON, Quand et Pourquoi ?

TOON n'est pas un remplacement universel de JSON, mais une optimisation stratégique pour cas d'usage haute performance : IoT, microservices >10K req/s, temps réel, mobile.