// C: スタック上の変数
void example() {
    int x = 42;           // スタック上に 4 バイト確保
    double y = 3.14;      // スタック上に 8 バイト確保
    char buf[256];        // スタック上に 256 バイト確保
}  // 関数終了時に全て自動解放
 
// 関数呼び出しのスタックフレーム:
// ┌──────────────────┐ ← SP（スタックポインタ）
// │ buf[256]         │
// │ y (3.14)         │
// │ x (42)           │
// │ 戻りアドレス      │
// │ 前のフレームポインタ│
// ├──────────────────┤ ← 呼び出し元のフレーム
 
// 詳細なスタックフレーム（x86_64 System V ABI）
// ┌──────────────────┐ ← RSP（スタックポインタ）
// │ ローカル変数      │
// │ 一時変数          │
// │ 退避レジスタ      │
// │ パディング        │  ← 16バイトアライメント
// ├──────────────────┤ ← RBP（ベースポインタ）
// │ 前の RBP         │
// │ 戻りアドレス      │
// │ 第7引数以降      │  ← レジスタに収まらない引数
// ├──────────────────┤
// │ 呼び出し元の      │
// │ スタックフレーム   │
// └──────────────────┘

// 呼び出し規約の影響を理解する例
struct SmallStruct { int x, y; };        // 16バイト → レジスタで渡せる
struct LargeStruct { int data[100]; };   // 400バイト → ポインタで渡される
 
// 小さい構造体は値渡しでもオーバーヘッドが小さい
void process_small(struct SmallStruct s) {
    // s はレジスタまたは少量のスタックで渡される
}
 
// 大きい構造体はポインタで渡すべき
void process_large(const struct LargeStruct *s) {
    // ポインタ（8バイト）だけがレジスタで渡される
}

// Rust: スタック上のデータ
fn example() {
    let x: i32 = 42;          // スタック（4バイト）
    let point = (3.0_f64, 4.0_f64); // スタック（16バイト）
    let arr = [1, 2, 3, 4, 5]; // スタック（20バイト）
 
    // 構造体もスタック上
    struct Point { x: f64, y: f64 }
    let p = Point { x: 1.0, y: 2.0 }; // スタック（16バイト）
 
    // enum もスタック上
    let opt: Option<i32> = Some(42); // スタック（8バイト: i32 + 判別子）
}  // 全て自動解放
 
// Rust ではスタックに置かれる型のサイズがコンパイル時に分かる
// Sized トレイト: コンパイル時にサイズが決定する型
fn takes_sized<T: Sized>(value: T) {
    // T のサイズはコンパイル時に決定
}
 
// ?Sized: サイズが不定の型も受け入れる
fn takes_unsized<T: ?Sized>(value: &T) {
    // T は [u8] や str のようなサイズ不定の型でもOK
}

// Go: スタックの動的成長
// Go のスタックは初期サイズが小さく（数KB）、必要に応じて自動成長する
// これにより大量の goroutine を効率的に扱える
 
func example() {
    x := 42              // スタック（エスケープ解析の結果による）
    arr := [5]int{1,2,3,4,5} // スタック（固定サイズ配列）
    // スライス自体のヘッダ（ポインタ、長さ、容量）はスタック
    // スライスの背後のデータはヒープ
}
 
// Go のスタックの特徴:
// - 初期サイズ: 2KB〜8KB（バージョンにより異なる）
// - 必要に応じて2倍ずつ成長
// - 成長時はコピー方式（contiguous stack）
// - goroutine ごとに独立したスタック
// - スタックポインタの書き換えが必要（コピー時）

// Java: スタックに置かれるもの
void example() {
    int x = 42;           // スタック（プリミティブ型）
    double y = 3.14;      // スタック（プリミティブ型）
    boolean flag = true;  // スタック（プリミティブ型）
 
    // 参照変数はスタック、オブジェクト本体はヒープ
    String s = "hello";   // 参照（8バイト）はスタック
                          // "hello" オブジェクトはヒープ
 
    int[] arr = new int[10]; // 参照はスタック、配列本体はヒープ
    Object obj = new Object(); // 参照はスタック、オブジェクトはヒープ
}
 
// JIT コンパイラのスカラー置換（Scalar Replacement）
// JIT が脱出解析（Escape Analysis）を行い、
// ヒープ確保を省略してスタックに置くことがある
void optimized() {
    Point p = new Point(1, 2);  // 脱出しない → スカラー置換される可能性
    int sum = p.x + p.y;        // p.x と p.y が直接スタックの変数になる
}

// C++: スタックとスマートポインタ
void example() {
    // スタック上のオブジェクト（RAII）
    std::string s = "hello";     // スタック上の String オブジェクト
                                  // 内部バッファはヒープ
 
    std::vector<int> v = {1, 2, 3}; // スタック上の Vector オブジェクト
                                     // 要素データはヒープ
 
    // SSO (Small String Optimization)
    // 短い文字列（通常15〜22文字以下）はヒープを使わずスタック内に格納
    std::string short_s = "hi"; // ヒープ確保なし（SSO）
 
    // SBO (Small Buffer Optimization) は std::function 等でも使われる
    std::function<int(int)> f =  { return x * 2; };
    // 小さなラムダはヒープ確保なし
}

// C: ヒープの手動管理
void example() {
    // malloc でヒープに確保
    int *arr = (int *)malloc(100 * sizeof(int));
    if (arr == NULL) {
        // メモリ確保失敗
        return;
    }
 
    arr[0] = 42;
 
    // realloc でサイズ変更
    int *new_arr = (int *)realloc(arr, 200 * sizeof(int));
    if (new_arr == NULL) {
        free(arr);  // realloc 失敗時は元のメモリを解放
        return;
    }
    arr = new_arr;
 
    // calloc: ゼロ初期化付き確保
    int *zeroed = (int *)calloc(100, sizeof(int));
 
    // 必ず free で解放（忘れるとメモリリーク）
    free(arr);
    arr = NULL;  // ダングリングポインタ防止
    free(zeroed);
    zeroed = NULL;
}
 
// メモリリークの典型的パターン
void leak_example() {
    char *buf = (char *)malloc(256);
    // ... 処理 ...
    if (error_condition) {
        return;  // free を忘れている → メモリリーク
    }
    free(buf);
}
 
// ダングリングポインタ
void dangling_example() {
    int *p = (int *)malloc(sizeof(int));
    *p = 42;
    free(p);
    // *p = 100;  // 未定義動作! 解放済みメモリへのアクセス
}
 
// バッファオーバーフロー
void overflow_example() {
    char buf[10];
    strcpy(buf, "This string is way too long"); // バッファオーバーフロー
    // スタック上の他のデータ（戻りアドレス等）を上書きする可能性
    // セキュリティ脆弱性の原因
}

// Rust: Box でヒープに確保
fn example() {
    let x = Box::new(42);     // ヒープに i32 を確保
    let s = String::from("hello"); // ヒープに文字列を確保
    let v = vec![1, 2, 3];    // ヒープに配列を確保
 
    // スコープを抜けると自動的に解放（所有権システム）
 
    // String のメモリレイアウト
    // スタック: [ポインタ | 長さ | 容量] = 24バイト
    //            ↓
    // ヒープ:  [h|e|l|l|o|_|_|_]  (容量分確保)
 
    // Vec のメモリレイアウト
    // スタック: [ポインタ | 長さ | 容量] = 24バイト
    //            ↓
    // ヒープ:  [1|2|3|_|_|_|_|_]  (容量分確保)
}
 
// カスタムアロケータ（Rust 1.28+ で安定化）
use std::alloc::{GlobalAlloc, System, Layout};
 
struct CountingAllocator;
 
static ALLOCATED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
 
unsafe impl GlobalAlloc for CountingAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        ALLOCATED.fetch_add(layout.size(), std::sync::atomic::Ordering::SeqCst);
        System.alloc(layout)
    }
 
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        ALLOCATED.fetch_sub(layout.size(), std::sync::atomic::Ordering::SeqCst);
        System.dealloc(ptr, layout)
    }
}
 
#[global_allocator]
static A: CountingAllocator = CountingAllocator;

# Python: ほぼ全てがヒープ
x = 42           # ヒープ上の int オブジェクト
s = "hello"      # ヒープ上の str オブジェクト
lst = [1, 2, 3]  # ヒープ上の list オブジェクト
 
# GC が自動的に解放
# プログラマはメモリ管理を意識しなくてよい
 
# Python オブジェクトのメモリレイアウト（CPython）
import sys
sys.getsizeof(42)       # → 28 バイト（int オブジェクト）
sys.getsizeof("hello")  # → 54 バイト（str オブジェクト）
sys.getsizeof([1,2,3])  # → 120 バイト（list オブジェクト + 参照×3）
 
# 各オブジェクトのヘッダ:
#   参照カウント: 8 バイト
#   型ポインタ:   8 バイト
#   → 最低 16 バイトのオーバーヘッド
 
# メモリプロファイリング
import tracemalloc
tracemalloc.start()
 
# ... 処理 ...
 
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
    print(stat)

// JavaScript: 全てがヒープ（V8 エンジンの場合）
// ただし JIT の最適化でスタックに置かれることもある
 
// V8 のオブジェクトレイアウト
// Hidden Class（Map）ベースの高速プロパティアクセス
const obj = { x: 1, y: 2 };
// Hidden Class: { x: offset 0, y: offset 8 }
// インラインプロパティとして高速アクセス
 
// SMI (Small Integer): 31ビット整数はポインタにインライン化
// → ヒープ確保なし
const x = 42;  // SMI として表現（ヒープ確保なし）
 
// HeapNumber: SMI に収まらない数値はヒープ確保
const y = 1.5;  // HeapNumber としてヒープに確保
 
// ArrayBuffer: TypedArray のバッキングストア
const buffer = new ArrayBuffer(1024);     // 1KB のヒープ確保
const view = new Float64Array(buffer);    // ビューはヒープ確保が小さい

// Go: コンパイラが自動的にスタック/ヒープを決定
func example() *int {
    x := 42       // x は関数外に返されるためヒープに配置
    return &x     // エスケープ解析: x がエスケープする
}
 
func local() {
    x := 42       // x は関数内でのみ使用 → スタックに配置
    fmt.Println(x)
}
 
// go build -gcflags="-m" で確認可能
// ./main.go:3:2: moved to heap: x
 
// エスケープの典型的なパターン
func escapeExamples() {
    // 1. ポインタを返す → エスケープ
    createUser := func() *User {
        u := User{Name: "Gaku"}  // ヒープに配置
        return &u
    }
 
    // 2. インターフェースに代入 → エスケープ（の可能性）
    var w io.Writer
    buf := new(bytes.Buffer)  // ヒープに配置
    w = buf
 
    // 3. クロージャにキャプチャ → エスケープ
    x := 42
    fn := func() int {
        return x  // x がクロージャにキャプチャされる → ヒープ
    }
 
    // 4. スライスの append で容量不足 → ヒープに再確保
    s := make([]int, 0, 4)
    for i := 0; i < 10; i++ {
        s = append(s, i)  // 容量超過時にヒープに再確保
    }
 
    // 5. go ルーチンに渡す → エスケープ
    ch := make(chan *Data)
    go func() {
        d := &Data{}  // ヒープに配置
        ch <- d
    }()
}
 
// エスケープ解析の最適化テクニック
// 1. ポインタの代わりに値を返す（小さい構造体の場合）
func createPoint() Point {  // スタックにコピーで返される
    return Point{X: 1, Y: 2}
}
 
// 2. バッファを引数で受け取る
func readInto(buf []byte) int {  // buf の管理は呼び出し側
    // ...
    return n
}
 
// 3. sync.Pool でヒープ確保を再利用
var bufPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}
 
func processRequest() {
    buf := bufPool.Get().([]byte)
    defer bufPool.Put(buf)
    // buf を使用（ヒープ確保の再利用）
}

// C#: struct（値型）vs class（参照型）
struct PointStruct {  // スタック上に配置
    public double X;
    public double Y;
}
 
class PointClass {    // ヒープ上に配置
    public double X;
    public double Y;
}
 
void Example() {
    PointStruct ps = new PointStruct { X = 1, Y = 2 };  // スタック（16バイト）
    PointClass pc = new PointClass { X = 1, Y = 2 };    // ヒープ（16バイト + ヘッダ）
                                                          // 参照（8バイト）はスタック
 
    // 配列
    PointStruct[] arr1 = new PointStruct[100];  // 連続メモリ（100 × 16バイト）
    PointClass[] arr2 = new PointClass[100];    // 参照の配列 + 個別オブジェクト
 
    // Span<T>: ヒープ確保なしのスライス
    Span<int> span = stackalloc int[10];  // スタック上に確保
    span[0] = 42;
 
    // ReadOnlySpan<T>: 文字列のゼロコピースライシング
    ReadOnlySpan<char> slice = "Hello, World!".AsSpan(0, 5);
}
 
// ref struct: スタック専用の構造体（ヒープに置けない）
ref struct StackOnly {
    public Span<int> Data;
    // Span を含むためヒープに置けない
}

// C: 構造体のパディング
struct Bad {
    char a;     // 1バイト
                // 7バイトのパディング（次の double のアライメントのため）
    double b;   // 8バイト
    char c;     // 1バイト
                // 7バイトのパディング（構造体のアライメントのため）
};
// sizeof(struct Bad) = 24 バイト（実データ 10 バイトなのに！）
 
struct Good {
    double b;   // 8バイト
    char a;     // 1バイト
    char c;     // 1バイト
                // 6バイトのパディング
};
// sizeof(struct Good) = 16 バイト（8バイト節約！）
 
// パディング最適化のルール:
// 大きいフィールドを先に、小さいフィールドを後に配置する

// Rust: コンパイラが自動的に並べ替える（デフォルト）
struct AutoReorder {
    a: u8,     // Rust コンパイラがフィールドの順序を最適化する
    b: f64,
    c: u8,
}
// repr(Rust) がデフォルト → コンパイラが最適な順序に並べ替え可能
 
// C 互換レイアウトを強制する場合
#[repr(C)]
struct CLayout {
    a: u8,     // フィールドの順序が保持される
    b: f64,
    c: u8,
}
 
// サイズの確認
use std::mem;
println!("AutoReorder: {}", mem::size_of::<AutoReorder>()); // 16 (最適化)
println!("CLayout: {}", mem::size_of::<CLayout>());         // 24 (C互換)
 
// パック構造体（パディングなし、ただしアクセスが遅い可能性）
#[repr(packed)]
struct Packed {
    a: u8,
    b: f64,
    c: u8,
}
// size_of::<Packed>() = 10 バイト（パディングなし）

// 配列（連続メモリ）vs リンクリスト（散在メモリ）
// 配列は圧倒的にキャッシュフレンドリー
 
// AoS (Array of Structs) vs SoA (Struct of Arrays)
 
// AoS: 構造体の配列（一般的だがキャッシュ効率が悪い場合がある）
struct Particle {
    x: f32,
    y: f32,
    z: f32,
    vx: f32,
    vy: f32,
    vz: f32,
    mass: f32,
    charge: f32,
}
let particles: Vec<Particle> = vec![/* ... */];
 
// x 座標だけ処理する場合:
// [x,y,z,vx,vy,vz,m,c | x,y,z,vx,vy,vz,m,c | ...]
//  ↑                      ↑
// キャッシュラインに不要なデータも含まれる
 
// SoA: 配列の構造体（特定フィールドのバッチ処理に最適）
struct Particles {
    x: Vec<f32>,
    y: Vec<f32>,
    z: Vec<f32>,
    vx: Vec<f32>,
    vy: Vec<f32>,
    vz: Vec<f32>,
    mass: Vec<f32>,
    charge: Vec<f32>,
}
 
// x 座標だけ処理する場合:
// [x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x...]
// キャッシュラインが全て有効データ → 高速
 
// ベンチマーク例（概念的）
fn update_positions_aos(particles: &mut [Particle], dt: f32) {
    for p in particles.iter_mut() {
        p.x += p.vx * dt;
        p.y += p.vy * dt;
        p.z += p.vz * dt;
    }
}
 
fn update_positions_soa(particles: &mut Particles, dt: f32) {
    for i in 0..particles.x.len() {
        particles.x[i] += particles.vx[i] * dt;
        particles.y[i] += particles.vy[i] * dt;
        particles.z[i] += particles.vz[i] * dt;
    }
}
// SoA 版は SIMD 最適化がかかりやすい

// Go: スライスと map のメモリ特性
func cacheExample() {
    // スライス: 連続メモリ → キャッシュフレンドリー
    numbers := make([]int, 1000000)
    sum := 0
    for _, n := range numbers {
        sum += n  // シーケンシャルアクセス → 高速
    }
 
    // map: ハッシュテーブル → キャッシュ非フレンドリー
    m := make(map[int]int, 1000000)
    sum = 0
    for _, v := range m {
        sum += v  // ランダムアクセス → キャッシュミスが多い
    }
 
    // 構造体のポインタスライス vs 値スライス
    type Point struct {
        X, Y, Z float64
    }
 
    // 値スライス: 連続メモリ（推奨）
    points := make([]Point, 1000)
 
    // ポインタスライス: ポインタは連続だがデータが散在
    ptrs := make([]*Point, 1000)
    for i := range ptrs {
        ptrs[i] = &Point{} // 各 Point は別のヒープ位置
    }
}

// スタックオーバーフローの例
fn infinite_recursion(n: i32) -> i32 {
    infinite_recursion(n + 1)  // 終了条件なし → スタックオーバーフロー
}
 
// 巨大なスタック確保
fn big_stack() {
    let arr = [0u8; 10_000_000];  // 10MB → スタックオーバーフロー
    // 解決: let arr = vec![0u8; 10_000_000]; // ヒープに配置
}
 
// 末尾再帰 vs 通常の再帰
fn factorial_recursive(n: u64) -> u64 {
    if n <= 1 { 1 }
    else { n * factorial_recursive(n - 1) }  // スタックフレームが積み上がる
}
 
fn factorial_tail(n: u64, acc: u64) -> u64 {
    if n <= 1 { acc }
    else { factorial_tail(n - 1, n * acc) }  // 末尾位置の再帰呼び出し
}
// ※ Rust は TCO を保証しない。ループに書き換えるのが安全
 
fn factorial_loop(n: u64) -> u64 {
    let mut result = 1u64;
    for i in 2..=n {
        result *= i;
    }
    result
}

-- Haskell: 末尾再帰と遅延評価の注意点
-- 厳密評価版（効率的）
factorial :: Integer -> Integer
factorial n = go n 1
  where
    go 0 acc = acc
    go n acc = go (n - 1) (acc * n)  -- $! で厳密評価を強制すべき
 
-- foldl vs foldl'
-- foldl はサンクを積み上げる（メモリ消費）
-- foldl' は厳密に評価する（推奨）
sum' :: [Int] -> Int
sum' = foldl' (+) 0  -- Data.List.foldl'

# Valgrind の使用例
valgrind --leak-check=full --show-leak-kinds=all ./my_program
 
# AddressSanitizer
gcc -fsanitize=address -g -o my_program my_program.c
./my_program
 
# Rust Miri
cargo +nightly miri run
 
# Go pprof
go tool pprof http://localhost:6060/debug/pprof/heap

// Arena アロケータ: まとめて確保・まとめて解放
// パーサーやコンパイラで頻繁に使われる
 
// 概念的な実装
struct Arena {
    chunks: Vec<Vec<u8>>,
    current: Vec<u8>,
    offset: usize,
}
 
impl Arena {
    fn new(chunk_size: usize) -> Self {
        Arena {
            chunks: Vec::new(),
            current: vec![0u8; chunk_size],
            offset: 0,
        }
    }
 
    fn alloc<T>(&mut self, value: T) -> &mut T {
        let size = std::mem::size_of::<T>();
        let align = std::mem::align_of::<T>();
 
        // アライメント調整
        let offset = (self.offset + align - 1) & !(align - 1);
 
        if offset + size > self.current.len() {
            // 新しいチャンクを確保
            let old = std::mem::replace(
                &mut self.current,
                vec![0u8; self.current.len()],
            );
            self.chunks.push(old);
            self.offset = 0;
        }
 
        let ptr = &mut self.current[self.offset] as *mut u8 as *mut T;
        unsafe {
            ptr.write(value);
            self.offset += size;
            &mut *ptr
        }
    }
}
// Arena が drop されると全メモリが一括解放
// → 個別の free/drop が不要で高速
 
// 実用例: bumpalo クレート
// use bumpalo::Bump;
// let bump = Bump::new();
// let x = bump.alloc(42);
// let s = bump.alloc_str("hello");
// // bump がスコープを抜けると全て解放

// Go: sync.Pool によるオブジェクト再利用
var nodePool = sync.Pool{
    New: func() interface{} {
        return new(ASTNode)
    },
}
 
func parseExpression(tokens []Token) *ASTNode {
    node := nodePool.Get().(*ASTNode)
    // node を使用
    return node
}
 
func freeNode(node *ASTNode) {
    *node = ASTNode{} // ゼロ値にリセット
    nodePool.Put(node)
}

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# セキュアコーディング例
import hashlib
import secrets
import hmac
from typing import Optional
 
class SecurityUtils:
    """セキュリティユーティリティ"""
 
    @staticmethod
    def generate_token(length: int = 32) -> str:
        """暗号学的に安全なトークン生成"""
        return secrets.token_urlsafe(length)
 
    @staticmethod
    def hash_password(password: str, salt: Optional[str] = None) -> tuple:
        """パスワードのハッシュ化"""
        if salt is None:
            salt = secrets.token_hex(16)
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt.encode('utf-8'),
            iterations=100000
        )
        return hashed.hex(), salt
 
    @staticmethod
    def verify_password(password: str, hashed: str, salt: str) -> bool:
        """パスワードの検証"""
        new_hash, _ = SecurityUtils.hash_password(password, salt)
        return hmac.compare_digest(new_hash, hashed)
 
    @staticmethod
    def sanitize_input(value: str) -> str:
        """入力値のサニタイズ"""
        dangerous_chars = ['<', '>', '"', "'", '&', '\\']
        result = value
        for char in dangerous_chars:
            result = result.replace(char, '')
        return result.strip()
 
# 使用例
token = SecurityUtils.generate_token()
hashed, salt = SecurityUtils.hash_password("my_password")
is_valid = SecurityUtils.verify_password("my_password", hashed, salt)

# マイグレーションスクリプトのテンプレート
import json
import logging
from pathlib import Path
from datetime import datetime
from typing import List, Dict, Callable
 
logger = logging.getLogger(__name__)
 
class MigrationRunner:
    """段階的マイグレーション実行エンジン"""
 
    def __init__(self, migration_dir: str):
        self.migration_dir = Path(migration_dir)
        self.migrations: List[Dict] = []
        self.completed: List[str] = []
 
    def register(self, version: str, description: str,
                 up: Callable, down: Callable):
        """マイグレーションの登録"""
        self.migrations.append({
            'version': version,
            'description': description,
            'up': up,
            'down': down,
            'registered_at': datetime.now().isoformat()
        })
 
    def run_up(self, target_version: str = None):
        """マイグレーションの実行（アップグレード）"""
        for migration in self.migrations:
            if migration['version'] in self.completed:
                continue
            logger.info(f"実行中: {migration['version']} - "
                       f"{migration['description']}")
            try:
                migration['up']()
                self.completed.append(migration['version'])
                logger.info(f"完了: {migration['version']}")
            except Exception as e:
                logger.error(f"失敗: {migration['version']}: {e}")
                raise
            if target_version and migration['version'] == target_version:
                break
 
    def run_down(self, target_version: str):
        """マイグレーションのロールバック"""
        for migration in reversed(self.migrations):
            if migration['version'] not in self.completed:
                continue
            if migration['version'] == target_version:
                break
            logger.info(f"ロールバック: {migration['version']}")
            migration['down']()
            self.completed.remove(migration['version'])
 
    def status(self) -> Dict:
        """マイグレーション状態の確認"""
        return {
            'total': len(self.migrations),
            'completed': len(self.completed),
            'pending': len(self.migrations) - len(self.completed),
            'versions': {
                m['version']: 'completed'
                if m['version'] in self.completed else 'pending'
                for m in self.migrations
            }
        }

// Rust: メモリマップドファイル（memmap2 クレート）
use memmap2::Mmap;
use std::fs::File;
 
fn read_large_file(path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let file = File::open(path)?;
    let mmap = unsafe { Mmap::map(&file)? };
 
    // mmap は &[u8] として扱える
    // ファイル全体をメモリにコピーせずにアクセス
    let first_100 = &mmap[..100];
    println!("First 100 bytes: {:?}", first_100);
 
    // OS がページ単位でオンデマンドにロード
    // 大きなファイルでも効率的
    Ok(())
}

// Go: bytes.Buffer の効率的な使い方
func efficientStringBuilding() string {
    var buf bytes.Buffer
    buf.Grow(1024) // 事前にサイズを予約（再確保を減らす）
 
    for i := 0; i < 100; i++ {
        fmt.Fprintf(&buf, "Line %d\n", i)
    }
    return buf.String()
}
 
// strings.Builder（Go 1.10+）
func efficientStringBuilder() string {
    var sb strings.Builder
    sb.Grow(1024)
 
    for i := 0; i < 100; i++ {
        sb.WriteString("Item ")
        sb.WriteString(strconv.Itoa(i))
        sb.WriteByte('\n')
    }
    return sb.String()
}

// Java: オブジェクトプール
public class ObjectPool<T> {
    private final Queue<T> pool;
    private final Supplier<T> factory;
    private final Consumer<T> reset;
    private final int maxSize;
 
    public ObjectPool(Supplier<T> factory, Consumer<T> reset, int maxSize) {
        this.pool = new ConcurrentLinkedQueue<>();
        this.factory = factory;
        this.reset = reset;
        this.maxSize = maxSize;
    }
 
    public T acquire() {
        T obj = pool.poll();
        return obj != null ? obj : factory.get();
    }
 
    public void release(T obj) {
        if (pool.size() < maxSize) {
            reset.accept(obj);
            pool.offer(obj);
        }
        // maxSize を超えた場合は GC に任せる
    }
}
 
// 使用例: StringBuilder のプール
ObjectPool<StringBuilder> sbPool = new ObjectPool<>(
    StringBuilder::new,
    sb -> sb.setLength(0),
    100
);
 
StringBuilder sb = sbPool.acquire();
try {
    sb.append("Hello");
    sb.append(" World");
    String result = sb.toString();
} finally {
    sbPool.release(sb);
}