; x86-64 Linux: Hello Worldの出力
section .data
    msg db 'Hello, World!', 0x0a    ; 文字列データ + 改行
    len equ $ - msg                  ; 文字列長を計算
 
section .text
    global _start
 
_start:
    ; sys_write(fd=1, buf=msg, count=len)
    mov rax, 1          ; システムコール番号: write
    mov rdi, 1          ; ファイルディスクリプタ: stdout
    mov rsi, msg        ; バッファのアドレス
    mov rdx, len        ; 書き込むバイト数
    syscall             ; カーネル呼び出し
 
    ; sys_exit(status=0)
    mov rax, 60         ; システムコール番号: exit
    xor rdi, rdi        ; 終了コード: 0
    syscall

; ARM64 macOS: Hello Worldの出力
.global _start
.align 2
 
_start:
    mov x0, #1              ; stdout
    adrp x1, msg@PAGE       ; 文字列アドレス（ページ）
    add x1, x1, msg@PAGEOFF ; 文字列アドレス（オフセット）
    mov x2, #14             ; 文字列長
    mov x16, #4             ; write システムコール
    svc #0x80               ; カーネル呼び出し
 
    mov x0, #0              ; 終了コード
    mov x16, #1             ; exit システムコール
    svc #0x80
 
msg:
    .ascii "Hello, World!\n"

# Python: 同じ "Hello World" がわずか1行
print("Hello, World!")

// Go: クロスコンパイルにより1つのソースから多数のプラットフォーム向けバイナリを生成
package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}
 
// ビルド例:
// GOOS=linux   GOARCH=amd64 go build -o hello-linux
// GOOS=darwin  GOARCH=arm64 go build -o hello-mac
// GOOS=windows GOARCH=amd64 go build -o hello.exe

# Python: インデントでブロック構造
def greet(name):
    if name:
        print(f"Hello, {name}!")
    else:
        print("Hello, World!")

// Rust: 波括弧でブロック構造
fn greet(name: &str) {
    if !name.is_empty() {
        println!("Hello, {}!", name);
    } else {
        println!("Hello, World!");
    }
}

;; Lisp: S式（全てが括弧）
(defun greet (name)
  (if name
      (format t "Hello, ~a!" name)
      (format t "Hello, World!")))

# Python: "There should be one—and preferably only one—obvious way to do it"
# リストの合計値を求める方法
total = sum(numbers)
 
# Pythonは意図的に構文を制限し、「正しい方法」を1つに絞る

# Perl: "There's more than one way to do it" (TMTOWTDI)
# 同じことを複数の方法で書ける
my $total = 0;
$total += $_ for @numbers;                    # 方法1
my $total2 = List::Util::sum(@numbers);       # 方法2
my $total3 = eval join '+', @numbers;         # 方法3（非推奨だが可能）

# Ruby: "Optimized for programmer happiness"
# メソッドチェーンと複数の同義シンタックス
total = numbers.sum                            # 最も簡潔
total = numbers.reduce(:+)                     # 関数型スタイル
total = numbers.inject(0) { |sum, n| sum + n } # ブロック明示

// JavaScriptの意味論の罠
"5" + 3       // → "53"（文字列結合）
"5" - 3       // → 2（数値演算）
 
[] + []        // → ""
[] + {}        // → "[object Object]"
{} + []        // → 0

# Pythonの意味論
"5" + 3       # → TypeError（型の安全性）

# Python: 正格評価（Strict Evaluation）
# 引数は関数呼び出しの前に全て評価される
def first(a, b):
    return a
 
# division_by_zero は呼ばれなくても評価される
# first(1, 1/0)  # → ZeroDivisionError

-- Haskell: 遅延評価（Lazy Evaluation）
-- 式は必要になるまで評価されない
first a b = a
 
-- 1/0 は使われないので評価されない
-- first 1 (1/0)  -- → 1（エラーにならない）
 
-- 無限リストも定義可能（必要な分だけ評価される）
naturals = [1..]           -- 全自然数のリスト
take 5 naturals            -- → [1, 2, 3, 4, 5]
 
-- フィボナッチ数列を無限リストとして定義
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
take 10 fibs               -- → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Python: ジェネレータによる遅延評価の部分的サポート
def naturals():
    n = 1
    while True:
        yield n
        n += 1
 
import itertools
list(itertools.islice(naturals(), 5))  # → [1, 2, 3, 4, 5]

# Python: レキシカルスコープ（静的スコープ）
x = 10
 
def outer():
    x = 20
    def inner():
        print(x)  # 20（定義時の環境を参照）
    inner()
 
outer()

// JavaScript: レキシカルスコープ + クロージャ
function makeCounter() {
    let count = 0;                    // クロージャに捕捉される
    return {
        increment: () => ++count,
        decrement: () => --count,
        getCount: () => count,
    };
}
 
const counter = makeCounter();
counter.increment(); // 1
counter.increment(); // 2
counter.getCount();  // 2

# Rust: Cargo — 全てを統一
cargo new my-project    # プロジェクト作成
cargo build             # ビルド
cargo test              # テスト実行
cargo bench             # ベンチマーク
cargo doc --open        # ドキュメント生成+表示
cargo publish           # crates.io へ公開
cargo clippy            # リンター実行
cargo fmt               # フォーマッタ実行
cargo audit             # セキュリティ監査
 
# Go: go コマンド — シンプルさを追求
go mod init example.com/myproject
go build ./...
go test ./...
go vet ./...
go fmt ./...
go doc fmt              # 標準ライブラリのドキュメント表示
 
# Node.js: npm — 巨大エコシステム
npm init
npm install express
npm test
npm run build
npm audit               # セキュリティ監査
npx eslint .            # ツールを一時的にインストール＆実行

// C: 手動メモリ管理
#include <stdlib.h>
#include <string.h>
 
char* create_greeting(const char* name) {
    // メモリを手動で確保
    size_t len = strlen("Hello, ") + strlen(name) + 2;
    char* result = (char*)malloc(len);
    if (result == NULL) {
        return NULL;  // メモリ確保失敗
    }
    snprintf(result, len, "Hello, %s!", name);
    return result;  // 呼び出し側がfreeする責任を負う
}
 
int main() {
    char* msg = create_greeting("World");
    if (msg) {
        printf("%s\n", msg);
        free(msg);  // ← これを忘れるとメモリリーク
    }
    return 0;
}

// Rust: 所有権システム
fn create_greeting(name: &str) -> String {
    // Stringは所有権を持つ。スコープを抜けると自動解放
    format!("Hello, {}!", name)
}
 
fn main() {
    let msg = create_greeting("World");
    println!("{}", msg);
    // msg はここでドロップ（自動解放）される
    // free()を呼ぶ必要がない。忘れることもできない
}

// Go: ガベージコレクション
func createGreeting(name string) string {
    // GCが管理するヒープに確保される
    return fmt.Sprintf("Hello, %s!", name)
}
 
func main() {
    msg := createGreeting("World")
    fmt.Println(msg)
    // GCが不要になったメモリを自動回収
    // プログラマはメモリ管理を意識する必要がない
}

// Java: Null参照が可能（NullPointerException）
String name = null;
int len = name.length();  // → NullPointerException（実行時エラー）
 
// Java 8+ : Optional型で安全に扱う
Optional<String> maybeName = Optional.ofNullable(getName());
int len = maybeName.map(String::length).orElse(0);

// Kotlin: Null安全が言語レベルで組み込み
var name: String = "Alice"   // Non-null型：nullを代入できない
// name = null                // コンパイルエラー
 
var name2: String? = null    // Nullable型：nullを許容
val len = name2?.length ?: 0 // 安全呼び出し + エルビス演算子

// Rust: Null自体が存在しない。代わりにOption型
fn find_user(id: u64) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}
 
fn main() {
    // パターンマッチで安全に取り出す
    match find_user(1) {
        Some(name) => println!("Found: {}", name),
        None => println!("User not found"),
    }
 
    // メソッドチェーンでも扱える
    let name = find_user(2).unwrap_or("Unknown".to_string());
}

// Swift: Optional型 + if let / guard let
func findUser(id: Int) -> String? {
    return id == 1 ? "Alice" : nil
}
 
// if let でアンラップ
if let name = findUser(id: 1) {
    print("Found: \(name)")
}
 
// guard let で早期リターン
func processUser(id: Int) {
    guard let name = findUser(id: id) else {
        print("User not found")
        return
    }
    print("Processing: \(name)")
}

# Python: 可読性を重視（"There should be one obvious way to do it"）
result = [x * 2 for x in numbers if x > 0]

# Perl: 表現力を重視（"There's more than one way to do it"）
@result = map { $_ * 2 } grep { $_ > 0 } @numbers;

-- Haskell: 数学的な表現力
result = map (*2) . filter (>0) $ numbers

# Python: 同じ処理の書き方の違い
 
# 方法1: 最も読みやすい（推奨）
active_users = []
for user in users:
    if user.is_active and user.age >= 18:
        active_users.append(user.name.upper())
 
# 方法2: リスト内包表記（中級者向け、Pythonic）
active_users = [
    user.name.upper()
    for user in users
    if user.is_active and user.age >= 18
]
 
# 方法3: 過度に関数型（非推奨 — Pythonの文化に合わない）
active_users = list(map(
    lambda u: u.name.upper(),
    filter(lambda u: u.is_active and u.age >= 18, users)
))

// Rust: イテレータチェーン — 表現力と性能を両立
let active_users: Vec<String> = users
    .iter()
    .filter(|u| u.is_active && u.age >= 18)
    .map(|u| u.name.to_uppercase())
    .collect();
 
// Rustのイテレータは遅延評価 + ゼロコスト抽象化
// コンパイル後はforループと同等の機械語になる

# Python: 型の動作は暗黙的
x = 5           # 型推論（暗黙）
x = "hello"     # 型が変わる（動的型付け）

// Rust: 全てが明示的
let x: i32 = 5;                     // 型を明示
let y = 5;                          // 推論可能な場合は省略可
// let x = "hello";                 // コンパイルエラー（型が異なる）
let x: &str = "hello";             // 再宣言（シャドウイング）

// Go: エラー処理は明示的（例外機構なし）
file, err := os.Open("data.txt")
if err != nil {
    return fmt.Errorf("failed to open file: %w", err)
}
defer file.Close()
 
data, err := io.ReadAll(file)
if err != nil {
    return fmt.Errorf("failed to read file: %w", err)
}

# Python: エラー処理は例外機構（暗黙的にスタックを巻き戻す）
try:
    with open("data.txt") as f:
        data = f.read()
except FileNotFoundError:
    print("ファイルが見つかりません")
except PermissionError:
    print("アクセス権限がありません")

// Rust: Result型 + ? 演算子（明示的だが簡潔）
fn read_file(path: &str) -> Result<String, std::io::Error> {
    let data = std::fs::read_to_string(path)?;  // エラー時は早期リターン
    Ok(data)
}
 
// ? 演算子は以下の糖衣構文
fn read_file_verbose(path: &str) -> Result<String, std::io::Error> {
    let data = match std::fs::read_to_string(path) {
        Ok(content) => content,
        Err(e) => return Err(e),
    };
    Ok(data)
}

// Go: ゴルーチン + チャネル（CSPモデル）
func main() {
    ch := make(chan string)
 
    go func() {
        // 別のゴルーチンで実行
        result := heavyComputation()
        ch <- result  // チャネルに結果を送信
    }()
 
    value := <-ch  // チャネルから受信（ブロッキング）
    fmt.Println(value)
}
 
// 複数のゴルーチンとselect
func fanIn(ch1, ch2 <-chan string) <-chan string {
    merged := make(chan string)
    go func() {
        for {
            select {
            case msg := <-ch1:
                merged <- msg
            case msg := <-ch2:
                merged <- msg
            }
        }
    }()
    return merged
}

// Rust: 所有権による安全な並行処理
use std::thread;
use std::sync::mpsc;
 
fn main() {
    let (tx, rx) = mpsc::channel();
 
    // スレッドに所有権を移動（moveキーワード）
    thread::spawn(move || {
        let result = heavy_computation();
        tx.send(result).unwrap();
    });
 
    let value = rx.recv().unwrap();
    println!("{}", value);
}
 
// データ競合はコンパイル時に防止される
// 以下はコンパイルエラーになる:
// let data = vec![1, 2, 3];
// thread::spawn(move || { data.push(4); });
// println!("{:?}", data);  // dataは既にmoveされている

%% Erlang: アクターモデル
%% 各プロセスは独立したメモリ空間を持つ
-module(example).
-export([start/0, loop/0]).
 
start() ->
    Pid = spawn(fun loop/0),
    Pid ! {self(), "Hello"},
    receive
        {Pid, Response} -> io:format("~s~n", [Response])
    end.
 
loop() ->
    receive
        {From, Message} ->
            From ! {self(), "Got: " ++ Message},
            loop()
    end.

// JavaScript: イベントループ + async/await
async function fetchUserData(userId) {
    try {
        const response = await fetch(`/api/users/${userId}`);
        const user = await response.json();
 
        // 並行してプロフィールと投稿を取得
        const [profile, posts] = await Promise.all([
            fetch(`/api/profiles/${user.profileId}`).then(r => r.json()),
            fetch(`/api/posts?userId=${userId}`).then(r => r.json()),
        ]);
 
        return { user, profile, posts };
    } catch (error) {
        console.error("Failed to fetch user data:", error);
        throw error;
    }
}

// 最適化前のCコード
int sum_array(int* arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total = total + arr[i];
    }
    return total;
}
 
// コンパイラが行う最適化:
 
// 1. ループアンローリング
//    ループ本体を複数回展開して分岐コストを削減
int sum_array_unrolled(int* arr, int n) {
    int total = 0;
    int i = 0;
    for (; i + 3 < n; i += 4) {
        total += arr[i] + arr[i+1] + arr[i+2] + arr[i+3];
    }
    for (; i < n; i++) {
        total += arr[i];
    }
    return total;
}
 
// 2. SIMD化（自動ベクトル化）
//    複数のデータを1命令で処理
//    例: SSE/AVXで4個/8個のintを同時加算
 
// 3. 定数畳み込み
int x = 3 + 4;      // → int x = 7; （コンパイル時に計算）
int y = x * 2;      // → int y = 14;
 
// 4. デッドコード除去
int unused = expensive_function();  // 使われない → 削除

# Python で書く簡易的な電卓インタプリタ
 
from dataclasses import dataclass
from typing import Union
 
# AST ノード定義
@dataclass
class Number:
    value: float
 
@dataclass
class BinaryOp:
    op: str
    left: 'Expr'
    right: 'Expr'
 
Expr = Union[Number, BinaryOp]
 
# パーサ（簡略版: トークン列からASTを生成）
class Parser:
    def __init__(self, tokens: list[str]):
        self.tokens = tokens
        self.pos = 0
 
    def parse(self) -> Expr:
        return self.parse_expression()
 
    def parse_expression(self) -> Expr:
        left = self.parse_term()
        while self.pos < len(self.tokens) and self.tokens[self.pos] in ('+', '-'):
            op = self.tokens[self.pos]
            self.pos += 1
            right = self.parse_term()
            left = BinaryOp(op, left, right)
        return left
 
    def parse_term(self) -> Expr:
        left = self.parse_factor()
        while self.pos < len(self.tokens) and self.tokens[self.pos] in ('*', '/'):
            op = self.tokens[self.pos]
            self.pos += 1
            right = self.parse_factor()
            left = BinaryOp(op, left, right)
        return left
 
    def parse_factor(self) -> Expr:
        token = self.tokens[self.pos]
        if token == '(':
            self.pos += 1
            expr = self.parse_expression()
            self.pos += 1  # skip ')'
            return expr
        else:
            self.pos += 1
            return Number(float(token))
 
# 評価器（ASTを辿って計算）
def evaluate(expr: Expr) -> float:
    match expr:
        case Number(value):
            return value
        case BinaryOp('+', left, right):
            return evaluate(left) + evaluate(right)
        case BinaryOp('-', left, right):
            return evaluate(left) - evaluate(right)
        case BinaryOp('*', left, right):
            return evaluate(left) * evaluate(right)
        case BinaryOp('/', left, right):
            return evaluate(left) / evaluate(right)
 
# 使用例
tokens = ['(', '1', '+', '2', ')', '*', '3']
ast = Parser(tokens).parse()
result = evaluate(ast)
print(f"Result: {result}")  # → Result: 9.0

// Rust: ゼロコスト抽象化の例
// 高水準な抽象を使っても、手書きの低水準コードと同等の性能
 
// 高水準版（イテレータ）
fn sum_of_squares(numbers: &[i32]) -> i32 {
    numbers.iter()
        .filter(|&&x| x > 0)
        .map(|&x| x * x)
        .sum()
}
 
// 低水準版（手動ループ）
fn sum_of_squares_manual(numbers: &[i32]) -> i32 {
    let mut total = 0;
    for i in 0..numbers.len() {
        if numbers[i] > 0 {
            total += numbers[i] * numbers[i];
        }
    }
    total
}
 
// 両者は同じ機械語にコンパイルされる（-O2以上）

// Rust: enum でデータの全パターンを型で表現
enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle { base: f64, height: f64 },
}
 
fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { width, height } => width * height,
        Shape::Triangle { base, height } => 0.5 * base * height,
        // 全パターンを網羅しないとコンパイルエラー
    }
}

// TypeScript: Union型 + 判別フィールド
type Shape =
    | { kind: "circle"; radius: number }
    | { kind: "rectangle"; width: number; height: number }
    | { kind: "triangle"; base: number; height: number };
 
function area(shape: Shape): number {
    switch (shape.kind) {
        case "circle":
            return Math.PI * shape.radius ** 2;
        case "rectangle":
            return shape.width * shape.height;
        case "triangle":
            return 0.5 * shape.base * shape.height;
        // TypeScript の strictNullChecks + noUncheckedIndexedAccess で
        // 網羅チェックが可能
    }
}

-- Haskell: 代数的データ型の本家
data Shape
    = Circle Double
    | Rectangle Double Double
    | Triangle Double Double
 
area :: Shape -> Double
area (Circle r)      = pi * r * r
area (Rectangle w h) = w * h
area (Triangle b h)  = 0.5 * b * h
-- パターンマッチの網羅性をコンパイラが検査

# Python
for i in range(1, 101):
    if i % 15 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

// JavaScript
for (let i = 1; i <= 100; i++) {
    if (i % 15 === 0) {
        console.log("FizzBuzz");
    } else if (i % 3 === 0) {
        console.log("Fizz");
    } else if (i % 5 === 0) {
        console.log("Buzz");
    } else {
        console.log(i);
    }
}

// Rust
fn main() {
    for i in 1..=100 {
        match (i % 3, i % 5) {
            (0, 0) => println!("FizzBuzz"),
            (0, _) => println!("Fizz"),
            (_, 0) => println!("Buzz"),
            _      => println!("{}", i),
        }
    }
}

# Python: 再帰版
import time
 
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)
 
start = time.time()
result = fib(40)
elapsed = time.time() - start
print(f"fib(40) = {result}, time: {elapsed:.3f}s")
# 典型的な結果: 約30-60秒

# Python: メモ化版（動的計画法）
from functools import lru_cache
 
@lru_cache(maxsize=None)
def fib_memo(n):
    if n <= 1:
        return n
    return fib_memo(n - 1) + fib_memo(n - 2)
 
result = fib_memo(100)
# → 354224848179261915075（瞬時に計算）

// Rust: 再帰版
use std::time::Instant;
 
fn fib(n: u64) -> u64 {
    if n <= 1 {
        return n;
    }
    fib(n - 1) + fib(n - 2)
}
 
fn main() {
    let start = Instant::now();
    let result = fib(40);
    let elapsed = start.elapsed();
    println!("fib(40) = {}, time: {:.3?}", result, elapsed);
    // 典型的な結果: 約0.5-1秒
}

// Go: 再帰版
package main
 
import (
    "fmt"
    "time"
)
 
func fib(n int) int {
    if n <= 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}
 
func main() {
    start := time.Now()
    result := fib(40)
    elapsed := time.Since(start)
    fmt.Printf("fib(40) = %d, time: %s\n", result, elapsed)
    // 典型的な結果: 約0.5-1.5秒
}