;; hello.wat - WebAssembly Text Format
(module
  (func $add (param $a i32) (param $b i32) (result i32)
    local.get $a
    local.get $b
    i32.add)
  
  (func $multiply (param $a i32) (param $b i32) (result i32)
    local.get $a
    local.get $b
    i32.mul)
  
  (export "add" (func $add))
  (export "multiply" (func $multiply))
)

// Rust code for WebAssembly
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[no_mangle]
pub extern "C" fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

// Compile with: wasm-pack build --target web

// Load and use WebAssembly module
async function loadWasm() {
    const wasmModule = await WebAssembly.instantiateStreaming(
        fetch('module.wasm')
    );
    
    const { add, multiply } = wasmModule.instance.exports;
    
    console.log('Add:', add(5, 3));        // 8
    console.log('Multiply:', multiply(4, 6)); // 24
}

loadWasm();

;; Memory management
(module
  (memory (export "memory") 1)
  
  (func $allocate (param $size i32) (result i32)
    (global.get $heap_ptr)
    (global.set $heap_ptr 
      (i32.add (global.get $heap_ptr) (local.get $size)))
    (global.get $heap_ptr))
  
  (global $heap_ptr (mut i32) (i32.const 0))
  
  (export "allocate" (func $allocate))
)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedData;
    
    event DataStored(uint256 indexed value, address indexed sender);
    
    function set(uint256 x) public {
        storedData = x;
        emit DataStored(x, msg.sender);
    }
    
    function get() public view returns (uint256) {
        return storedData;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Token {
    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;
    
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    
    address public owner;
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }
    
    constructor(uint256 _totalSupply) {
        totalSupply = _totalSupply;
        balances[msg.sender] = _totalSupply;
        owner = msg.sender;
    }
    
    function transfer(address to, uint256 amount) public returns (bool) {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        balances[msg.sender] -= amount;
        balances[to] += amount;
        
        emit Transfer(msg.sender, to, amount);
        return true;
    }
    
    function approve(address spender, uint256 amount) public returns (bool) {
        allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }
    
    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
        require(balances[from] >= amount, "Insufficient balance");
        require(allowances[from][msg.sender] >= amount, "Insufficient allowance");
        
        balances[from] -= amount;
        balances[to] += amount;
        allowances[from][msg.sender] -= amount;
        
        emit Transfer(from, to, amount);
        return true;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DEX {
    mapping(address => mapping(address => uint256)) public liquidity;
    mapping(address => uint256) public totalLiquidity;
    
    event LiquidityAdded(address indexed tokenA, address indexed tokenB, uint256 amountA, uint256 amountB);
    event Swap(address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
    
    function addLiquidity(address tokenA, address tokenB, uint256 amountA, uint256 amountB) external {
        require(amountA > 0 && amountB > 0, "Amounts must be positive");
        
        liquidity[tokenA][tokenB] += amountA;
        liquidity[tokenB][tokenA] += amountB;
        totalLiquidity[tokenA] += amountA;
        totalLiquidity[tokenB] += amountB;
        
        emit LiquidityAdded(tokenA, tokenB, amountA, amountB);
    }
    
    function swap(address tokenIn, address tokenOut, uint256 amountIn) external returns (uint256 amountOut) {
        require(amountIn > 0, "Amount must be positive");
        require(liquidity[tokenIn][tokenOut] > 0, "No liquidity");
        
        // Simple constant product formula: x * y = k
        uint256 reserveIn = liquidity[tokenIn][tokenOut];
        uint256 reserveOut = liquidity[tokenOut][tokenIn];
        
        amountOut = (reserveOut * amountIn) / (reserveIn + amountIn);
        
        liquidity[tokenIn][tokenOut] += amountIn;
        liquidity[tokenOut][tokenIn] -= amountOut;
        
        emit Swap(tokenIn, tokenOut, amountIn, amountOut);
    }
}

# Basic Julia syntax
function fibonacci(n::Int)::Int
    if n <= 1
        return n
    else
        return fibonacci(n-1) + fibonacci(n-2)
    end
end

# Multiple dispatch
abstract type Shape end

struct Circle <: Shape
    radius::Float64
end

struct Rectangle <: Shape
    width::Float64
    height::Float64
end

function area(shape::Circle)::Float64
    return π * shape.radius^2
end

function area(shape::Rectangle)::Float64
    return shape.width * shape.height
end

# Usage
circle = Circle(5.0)
rectangle = Rectangle(3.0, 4.0)

println("Circle area: ", area(circle))
println("Rectangle area: ", area(rectangle))

using LinearAlgebra
using Plots
using DifferentialEquations

# Linear algebra
A = [1 2 3; 4 5 6; 7 8 9]
b = [1, 2, 3]
x = A \ b  # Solve Ax = b

# Eigenvalue decomposition
eigenvals, eigenvecs = eigen(A)

# Differential equations
function lotka_volterra!(du, u, p, t)
    x, y = u
    α, β, γ, δ = p
    du[1] = α*x - β*x*y
    du[2] = δ*x*y - γ*y
end

u0 = [1.0, 1.0]
tspan = (0.0, 10.0)
p = [1.5, 1.0, 3.0, 1.0]

prob = ODEProblem(lotka_volterra!, u0, tspan, p)
sol = solve(prob)

# Plotting
plot(sol, xlabel="Time", ylabel="Population", title="Lotka-Volterra Model")

using Flux
using MLDatasets

# Load data
train_x, train_y = MLDatasets.MNIST.traindata()
train_x = Float32.(train_x) ./ 255.0f0
train_y = Flux.onehotbatch(train_y, 0:9)

# Define model
model = Chain(
    Dense(784, 128, relu),
    Dropout(0.2),
    Dense(128, 64, relu),
    Dropout(0.2),
    Dense(64, 10),
    softmax
)

# Define loss function
loss(x, y) = crossentropy(model(x), y)

# Training
optimizer = ADAM(0.001)
data = DataLoader((train_x, train_y), batchsize=32, shuffle=true)

for epoch in 1:10
    for (x, y) in data
        gs = gradient(() -> loss(x, y), Flux.params(model))
        Flux.update!(optimizer, Flux.params(model), gs)
    end
    println("Epoch $epoch completed")
end

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  comments: [Comment!]!
}

type Comment {
  id: ID!
  content: String!
  author: User!
  post: Post!
}

type Query {
  user(id: ID!): User
  users: [User!]!
  post(id: ID!): Post
  posts: [Post!]!
}

type Mutation {
  createUser(input: CreateUserInput!): User!
  updateUser(id: ID!, input: UpdateUserInput!): User!
  deleteUser(id: ID!): Boolean!
}

input CreateUserInput {
  name: String!
  email: String!
}

input UpdateUserInput {
  name: String
  email: String
}

// Node.js with Apollo Server
const { ApolloServer, gql } = require('apollo-server');
const { GraphQLScalarType } = require('graphql');

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
    posts: [Post!]!
  }
  
  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
  }
  
  type Query {
    user(id: ID!): User
    users: [User!]!
  }
`;

const resolvers = {
  Query: {
    user: (parent, { id }, context) => {
      return context.dataSources.users.getById(id);
    },
    users: (parent, args, context) => {
      return context.dataSources.users.getAll();
    }
  },
  
  User: {
    posts: (parent, args, context) => {
      return context.dataSources.posts.getByUserId(parent.id);
    }
  },
  
  Post: {
    author: (parent, args, context) => {
      return context.dataSources.users.getById(parent.authorId);
    }
  }
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
  dataSources: () => ({
    users: new UserAPI(),
    posts: new PostAPI()
  })
});

server.listen().then(({ url }) => {
  console.log(`Server ready at ${url}`);
});

-- Window functions
SELECT 
    employee_id,
    name,
    salary,
    department,
    ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) as rank_in_dept,
    AVG(salary) OVER (PARTITION BY department) as dept_avg_salary,
    salary - AVG(salary) OVER (PARTITION BY department) as salary_diff
FROM employees;

-- Common Table Expressions (CTEs)
WITH RECURSIVE employee_hierarchy AS (
    -- Base case: top-level employees
    SELECT employee_id, name, manager_id, 1 as level
    FROM employees 
    WHERE manager_id IS NULL
    
    UNION ALL
    
    -- Recursive case: subordinates
    SELECT e.employee_id, e.name, e.manager_id, eh.level + 1
    FROM employees e
    JOIN employee_hierarchy eh ON e.manager_id = eh.employee_id
)
SELECT * FROM employee_hierarchy ORDER BY level, name;

-- Advanced joins and aggregations
SELECT 
    d.department_name,
    COUNT(e.employee_id) as employee_count,
    AVG(e.salary) as avg_salary,
    MAX(e.salary) as max_salary,
    MIN(e.salary) as min_salary
FROM departments d
LEFT JOIN employees e ON d.department_id = e.department_id
WHERE e.hire_date >= '2020-01-01'
GROUP BY d.department_id, d.department_name
HAVING COUNT(e.employee_id) > 5
ORDER BY avg_salary DESC;

-- Stored procedure
DELIMITER //
CREATE PROCEDURE GetEmployeeStats(IN dept_id INT)
BEGIN
    SELECT 
        COUNT(*) as total_employees,
        AVG(salary) as average_salary,
        MAX(salary) as highest_salary,
        MIN(salary) as lowest_salary
    FROM employees 
    WHERE department_id = dept_id;
END //
DELIMITER ;

-- Function
DELIMITER //
CREATE FUNCTION CalculateBonus(salary DECIMAL(10,2), performance_rating INT)
RETURNS DECIMAL(10,2)
READS SQL DATA
DETERMINISTIC
BEGIN
    DECLARE bonus DECIMAL(10,2);
    
    CASE performance_rating
        WHEN 5 THEN SET bonus = salary * 0.15;
        WHEN 4 THEN SET bonus = salary * 0.10;
        WHEN 3 THEN SET bonus = salary * 0.05;
        ELSE SET bonus = 0;
    END CASE;
    
    RETURN bonus;
END //
DELIMITER ;

# Kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
    version: v1.0.0
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
        version: v1.0.0
    spec:
      containers:
      - name: web-app
        image: myregistry/web-app:v1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        - name: REDIS_URL
          value: "redis://redis-service:6379"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

# Good DSL design principles
design_principles:
  clarity: "Use clear, domain-specific terminology"
  consistency: "Maintain consistent syntax and semantics"
  composability: "Allow combining simple constructs into complex ones"
  extensibility: "Support adding new features without breaking existing code"
  tooling: "Provide good development tools and IDE support"
  documentation: "Comprehensive documentation and examples"
  testing: "Easy to test and validate"
  performance: "Optimized for the target use case"

# Internal DSL example in Python
class QueryBuilder:
    def __init__(self):
        self._select = []
        self._from_table = None
        self._where_conditions = []
        self._joins = []
    
    def select(self, *columns):
        self._select.extend(columns)
        return self
    
    def from_table(self, table):
        self._from_table = table
        return self
    
    def where(self, condition):
        self._where_conditions.append(condition)
        return self
    
    def join(self, table, condition):
        self._joins.append(f"JOIN {table} ON {condition}")
        return self
    
    def build(self):
        query = f"SELECT {', '.join(self._select)} FROM {self._from_table}"
        if self._joins:
            query += " " + " ".join(self._joins)
        if self._where_conditions:
            query += " WHERE " + " AND ".join(self._where_conditions)
        return query

# Usage
query = (QueryBuilder()
    .select("name", "email", "created_at")
    .from_table("users")
    .where("active = 1")
    .join("profiles", "users.id = profiles.user_id")
    .build())

print(query)