Skip to content

v2.0.0.md

Latest commit

 

History

History
304 lines (240 loc) · 8.38 KB

v2.0.0.md

File metadata and controls

304 lines (240 loc) · 8.38 KB

ProXPL v2.0.0: The "New Era" Release

Target Release Date: Q1 2028
Status: Planned
Codename: New Era

🌟 Overview

ProXPL v2.0.0 is the first major stable release, marking the language as production-ready for enterprise, systems, and web applications. This release introduces the Self-Hosting Compiler (the ProXPL compiler written in ProXPL itself), a JIT Compiler for optimized runtime performance, Effect System for side-effect tracking, and significant cleanups that remove deprecated features from the v1.x series.

🏆 Milestone Achievements

Milestone Status
Self-hosting compiler ✅ ProXPL compiles ProXPL
100,000+ lines of ProXPL code in the ecosystem ✅
500+ packages on PRM Registry ✅
10+ production deployments reported ✅
Formal language specification (v2.0) ✅
Zero known critical bugs ✅
Full platform support (Win/Linux/macOS/Wasm/ARM) ✅

✨ New Features

1. Self-Hosting Compiler

The ProXPL compiler is now written in ProXPL.

Architecture:

proxpl-bootstrap (C) → compiles → proxpl-v2 (ProXPL) → compiles itself

Benefits:

  • Compiler is now a ProXPL project — easier to contribute
  • Compiler tests written in std.test
  • Faster iteration on language features
  • Dogfooding — the compiler exercises all language features
  • C bootstrap maintained for initial build only

Compilation Stages:

Stage Implementation Purpose
Stage 0 C bootstrap compiler (v1.9.0) Build the ProXPL compiler from scratch
Stage 1 ProXPL compiler (compiled by Stage 0) First self-compiled compiler
Stage 2 ProXPL compiler (compiled by Stage 1) Verify Stage 1 produces identical output

2. JIT Compiler

Just-In-Time compilation for hot code paths.

// JIT automatically optimizes hot functions
func hot_loop() {
    let sum = 0;
    for (let i in 0..1000000) {
        sum = sum + i * i;
    }
    return sum;
}

// Force JIT compilation
@jit
func matrix_multiply(a, b) {
    // ... performance-critical code
}

JIT Architecture:

Bytecode → Interpreter → Profile Counter → Hot Threshold
                                              ↓
                                    Baseline JIT (fast compile)
                                              ↓
                                    Optimizing JIT (LLVM, slow compile)

Optimization Tiers:

Tier Trigger Optimization Level Compile Time
Tier 0 Default Interpreter (bytecode) 0ms
Tier 1 100 invocations Baseline JIT (simple native code) < 1ms
Tier 2 10,000 invocations Optimizing JIT (LLVM O2) < 100ms

Features:

  • On-stack replacement (OSR) — JIT mid-loop
  • Type specialization based on runtime profiling
  • Inline caching for property access
  • Deoptimization bailout to interpreter on type guards
  • JIT code cache management and eviction

3. Effect System

Track and control side effects at the type level.

// Pure function — no side effects
pure func add(a: int, b: int): int {
    return a + b;
}

// Function with declared effects
func readConfig(): string performs IO {
    return read_file("config.pxcf");
}

func processData(data: string): int performs IO, Throws {
    let parsed = json.parse(data);
    write_file("output.json", json.stringify(parsed));
    return length(parsed);
}

// Effect handlers
handle IO {
    func readFile(path): string => mock_read(path);
    func writeFile(path, data) => { /* no-op */ };
}

// Test with mocked effects
test "processData works" {
    with handle IO {
        let result = processData('{"key": "value"}');
        assert_eq(result, 1);
    }
}

Effect Types:

Effect Description
IO File system, network, console I/O
Throws May throw exceptions
Async Returns a future/promise
Mutates Mutates shared state
Allocates Performs heap allocations
Pure No effects (total function)

4. Module System v2

Workspaces, private modules, and re-exports.

// Workspace project.pxcf
project {
    name: "my-app"
    version: "2.0.0"
}

workspace {
    members: [
        "core",
        "api",
        "cli"
    ]
}

// Re-exports
// lib.prox
pub use internal.parser as parser;
pub use internal.compiler as compiler;

// Private modules (not accessible outside package)
mod internal {
    mod parser { ... }
    mod compiler { ... }
}

5. Algebraic Effects & Handlers

First-class effect handlers for dependency injection and testing.

effect Logger {
    func log(level: string, message: string);
}

effect Database {
    func query(sql: string): List<Dict>;
}

func processOrder(orderId: int) performs Logger, Database {
    Logger.log("INFO", "Processing order " + to_string(orderId));
    let items = Database.query("SELECT * FROM items WHERE order_id = ?");
    Logger.log("INFO", "Found " + to_string(length(items)) + " items");
}

// Production handler
handler ProductionLogger for Logger {
    func log(level, msg) {
        write_file("app.log", "[" + level + "] " + msg + "\n", append: true);
    }
}

// Test handler
handler MockLogger for Logger {
    let logs: List<string> = [];
    func log(level, msg) {
        push(this.logs, "[" + level + "] " + msg);
    }
}

6. Cleaned-Up Language

Removed (previously deprecated):

Removed Replacement Deprecated Since
interface keyword trait v1.5.0
import keyword use v0.5.0
Old TOML-style prox.toml project.pxcf v1.3.0
Implicit any type for untyped params Explicit type annotations required v1.5.0

New Defaults:

  • Strict mode enabled by default (all warnings are errors)
  • Explicit type annotations required for public API functions
  • const by default for function parameters (use mut to modify)

📊 Version 2.0 Language Specification

Complete Keyword Table (v2.0)

Category Keywords
Declarations let, const, func, func*, async, class, trait, enum, type, mod, actor, macro
Control Flow if, else, while, for, in, match, case, return, break, continue, yield, await
Types int, float, bool, string, void, any, null, true, false
OOP new, this, super, extends, static, pub, priv, mut
Effects pure, performs, handle, effect, handler
Advanced use, as, from, extern, comptime, operator, context, layer, activate
Error try, catch, throw, resilient, recovery
Concurrency spawn, receive, channel

Type System Summary

Primitives:    int, float, bool, string, void, null
Collections:   List<T>, Dict<K,V>, Set<T>  
Functions:     func(args): ReturnType
Generics:      T, <T: Trait>, <T, const N: int>
Algebraic:     enum Variants { Case1(T), Case2 }
Result Types:  Result<T, E>, Option<T>
Effects:       performs Effect1, Effect2

📈 Performance Targets

Benchmark Target vs C (Clang -O3)
Fibonacci(35) < 50ms 1.5x slower
Binary Trees < 200ms 2.0x slower
HTTP req/sec > 100K N/A
JSON parse 10MB < 100ms 3.0x slower
Startup time < 2ms N/A
JIT warm-up < 500ms N/A

🔧 Breaking Changes from v1.x

Change Migration
interface removed Replace with trait
import removed Replace with use
Implicit any params Add explicit types to public functions
const params default Add mut keyword where modification needed
Strict mode default Fix all warnings, or add #pragma lenient

Automated Migration Tool:

prox migrate --from 1.9 --to 2.0 .
# Automatically fixes all breaking changes in your codebase

🔒 Stability Promise

Starting with v2.0.0, ProXPL commits to:

  1. No breaking changes within the v2.x series
  2. Minimum 3-year LTS for v2.0
  3. Security patches for at least 5 years
  4. Formal RFC process for all language changes
  5. Backward compatibility — all v2.0 code will compile on v2.x

ProXPL v2.0.0 — The language is complete. The journey begins.