Skip to content

CHANGELOG.md

Latest commit

 

History

History
417 lines (326 loc) · 13.8 KB

CHANGELOG.md

File metadata and controls

417 lines (326 loc) · 13.8 KB

ProXPL Changelog

All notable changes to the ProXPL project are documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[1.3.1] - 2026-04-22

Fixed

  • Memory Management: Resolved a critical memory leak in the Type Checker where symbol names and parameter types were not being deallocated during scope exit.
  • VM Stability: Unified the VM dispatch loop (GNUC Computed Goto and Fallback Switch-Case) to eliminate logic divergence and fix missing opcodes (OP_INTERFACE, OP_IMPLEMENT).
  • GC Rooting: Fixed a race condition in OP_MAKE_TENSOR where newly allocated tensors were rooted after stack pops, preventing premature collection.
  • Error Handling: Refactored VM stack overflow handling to report recoverable runtime errors instead of calling exit(1).

[1.3.0] - 2026-01-27

Added

  • AI-Native Primitives:
    • Introduced tensor primitive type with multidimensional support (e.g., tensor<float, 2x2>).
    • Added AST and Parser support for Tensor declarations and @ matrix multiplication operator.
    • Implemented OP_MAT_MUL and OP_MAKE_TENSOR opcodes for native execution.
    • Optimized 2D matrix multiplication using cache-friendly loop ordering.
    • Support for 1D vector dot products using the same @ operator.
  • Context-Oriented Programming (COP):
    • Implemented context and layer declarations for behavioral grouping.
    • Added activate blocks for dynamic behavioral shifts in the runtime.
    • Developed a LIFO active context stack in the VM for hierarchical method dispatch.
    • Implemented resolveContextualMethod for dynamic interception of global function calls.
    • Added new opcodes: OP_CONTEXT, OP_LAYER, OP_ACTIVATE, and OP_END_ACTIVATE.

[1.2.0] - 2026-01-20

Added

  • The 10 Operational Pillars: Implemented the full frontend stack (Lexer, Parser, AST, Type Checker) for all 10 revolutionary language pillars.
    1. Intent-Oriented Programming: intent, resolver keywords.
    2. Context-Aware Polymorphism: @context decorators and context-conditional functions.
    3. Autonomic Self-Healing (ASR): resilient, recovery, restart, rollback blocks.
    4. Intrinsic Security: tainted, pure types, sanitize() expression, policy blocks.
    5. Chrono-Native Logic: temporal variables with decay after clauses.
    6. Event-Driven Concurrency: (Integrated with ASR/Distributed logic).
    7. AI-Native Integration: model, train, predict, dataset keywords.
    8. Quantum-Ready Syntax: quantum, qubit, superpose, entangle blocks.
    9. Hardware-Accelerated Math: gpu, kernel, tensor, matrix types.
    10. Zero-Trust Security: verify, identity, encrypt, decrypt primitives.

Fixed

  • Security: Fixed "Security Violation" errors in benchmarks by ensuring tainted values are correctly tracked and sanitized (type_checker.c).
  • CI/CD: Fixed dependency synchronization issues between package.json and package-lock.json causing build failures.
  • Build: Resolved multiple build errors including path resolution, esbuild configuration, and parser compilation issues.

Changed

  • Compiler Frontend: Significantly expanded Lexer, AST, Parser, and Type Checker to support complex new syntax.
  • Version: Bumped codebase version to 1.2.0.

[1.1.0] - 2026-01-11

Added

  • Access Control: Implemented pub/priv visibility enforcement for class members and modules.
  • Constructors: Added init constructor method support for object initialization.
  • Exception Handling: Introduced try/catch blocks for robust error management and runtime safety.

Changed

  • Versioning: Synchronized project version to 1.1.0 across the core VM, CLI, VS Code extension, and installer scripts.
  • Roadmap: Marked v1.1.0 features as completed and released in the main documentation.

[1.0.0] - 2026-01-06

Added

  • Object-Oriented Programming: First-class support for Classes, Objects, Single Inheritance (extends), and Interfaces.
  • Keywords: class, new, this, extends, interface, static.
  • Runtime:
    • ObjClass, ObjInstance, ObjBoundMethod structures.
    • Opcodes: OP_CLASS, OP_METHOD, OP_INHERIT, OP_GET_PROPERTY, OP_SET_PROPERTY, OP_GET_SUPER.
  • Stability: Finalized v1.0.0 release.

Fixed

  • Build: Resolved CMake configuration issues and compilation errors.
  • VM: Fixed object instantiation and method binding logic.

[0.8.0] - 2026-01-04

Added

  • Diagnostics: Enhanced error reporting with column tracking and visual caret pointers (^).
  • Standard Library:
    • std.fs: Added copy, is_file, is_dir.
    • std.sys: Added exec for command execution.
  • Tooling:
    • LSP: Added "Go to Definition" support and basic keyword completion.
    • Extension: Enabled Snippets and Hover support.
    • PRM: Enabled remote package installation from GitHub (prm install User/Repo).

[0.7.0] - 2026-01-04

Added

  • FFI System: Initial implementation of the Foreign Function Interface using libffi.
  • Extension:
    • Added icon support for .iss (Inno Setup) files.
    • Added icon support for .internal_ingore and .internal_ignore.
  • Runtime:
    • ffi_bridge.c for handling native function calls.
  • Official release build configuration for version 0.7.0.
  • Updated version strings across the codebase.

Fixed

  • Build: Resolved linker errors on Ubuntu and macOS where libffi was not being linked to test executables (ir_gen_test, llvm_gen_test).
  • Stability: Fixed runtime crashes related to stack management and input function usage.

[0.5.0-pre] - 2026-01-02

Added

  • Pre-release build configuration.
  • Updated version strings to 0.5.0-pre.

[0.5.1] - 2025-12-31

Added

  • Language: Introduced use keyword to replace import for module loading, standardizing the syntax.
  • Extension:
    • Added material icons support with vscode-material-icon-theme integration.
    • Fixed VSIX packaging errors.
  • Runtime:
    • Implemented OP_USE opcode for dynamic module loading.
    • Added std.io and standard library module resolution fixes.
  • Comprehensive documentation suite (400+ pages)
    • Professional README with architecture diagrams
    • Complete ARCHITECTURE.md with compiler pipeline details
    • BUILD_GUIDE.md with platform-specific instructions
    • PYTHON_TO_C.md migration blueprint
    • Tutorial series (4 comprehensive tutorials)
    • API reference documentation
    • Bytecode format specification
  • Code of Conduct for community standards
  • Enhanced CONTRIBUTING.md with coding standards
  • GitHub Actions CI/CD workflows
    • Automated build on push/PR
    • Automated testing
    • Automated linting
  • Test framework structure
    • Unit test templates
    • Integration test templates
    • Test fixture organization
  • Development scripts
    • Cross-platform build scripts
    • Formatting automation
    • Linting automation
  • Professional .gitignore for C/Python hybrid
  • Refactor report documenting all changes

Changed

  • CLI: Updated CLI version to match project version.
  • Build: Fixed CMake finding LLVM and compiler paths on Windows.
  • Reorganized repository structure for clarity and scalability
  • Upgraded CMakeLists.txt to modern best practices
  • Improved Makefile with multiple build targets
  • Removed internal clutter (staff-notes, housekeeping files)
  • Consolidated documentation (single source of truth)
  • Enhanced code style guidelines with examples

Fixed

  • .gitignore now properly covers C, Python, and IDE artifacts
  • CMake configuration now supports all major compilers
  • Build instructions now platform-specific and accurate

Removed

  • docs/staff-notes/ (internal development notes)
  • .internal_ignore (housekeeping file)
  • Redundant documentation files
  • Incomplete security documentation

[0.1.0] - 2024-12-11

Initial C-Based Release

Added

  • Complete Lexer (src/lexer/scanner.c)

    • Tokenization of all language constructs
    • 45 keywords support
    • 42 operators support
    • String and number parsing
    • Position tracking (line, column)

  • Complete Parser (src/parser/parser.c)

    • Recursive descent parsing
    • All statement types
    • All expression types
    • Operator precedence
    • Error recovery

  • Type Checker (src/parser/type_checker.c)

    • Type inference algorithm
    • Scope management
    • Symbol resolution
    • Type compatibility checking

  • Bytecode Compiler (src/runtime/compiler.c)

    • AST to bytecode translation
    • 42+ bytecode instructions
    • Constant pooling
    • Jump instruction handling
    • Optimization passes (constant folding, dead code elimination)

  • Stack-Based Virtual Machine (src/runtime/vm.c)

    • Bytecode execution engine
    • Function call handling
    • Native function dispatch
    • Error handling
    • REPL support

  • Runtime System

    • Value type system (value.c)
    • Object system (object.c)
    • Memory management (memory.c)
    • Debug utilities (debug.c)
    • String interning

  • Standard Library (44 functions)

    • I/O: print, input, open, read, write (5 functions)
    • Math: sqrt, sin, cos, tan, floor, ceil, abs, min, max, pow, log, exp, etc. (15 functions)
    • String: len, substring, toUpper, toLower, split, trim, contains, etc. (9 functions)
    • Conversion: toInt, toFloat, toString, toBool, typeof, etc. (8 functions)
    • System: exit, system, getEnv, setEnv, etc. (7 functions)

  • Language Features

    • Variables (let, const)
    • Functions (parameters, return, closures)
    • Classes and objects
    • Control flow (if/else, while, for, switch)
    • Error handling (try/catch/finally)
    • Collections (lists, dictionaries, sets)
    • First-class functions
    • Type annotations (optional)

  • Build System

    • CMake (3.10+) support
    • Makefile for Unix/Linux/macOS
    • Cross-compiler support (GCC, Clang, MSVC)
    • Debug and Release builds

  • Documentation

    • Language specification
    • Project architecture overview
    • Example programs

  • Example Programs

    • hello.prox
    • fibonacci.prox
    • calculator.prox
    • classes_demo.prox
    • stdlib_usage.prox

Development Roadmap

Phase 2: Optimization (Q1 2025)

  • Constant propagation
  • Dead code elimination
  • Tail call optimization
  • Jump optimization
  • Peephole optimization
  • Performance profiler

Phase 3: Advanced Features (Q2 2025)

  • Async/await implementation
  • Pattern matching
  • Generic types
  • Module system (Initial support in v0.5.0)
  • Debugger integration

Phase 4: Ecosystem (Q3 2025)

  • Package manager (ProXPL PM)
  • Standard library expansion
  • IDE plugins (VS Code, Sublime)
  • Language Server Protocol (LSP)

Phase 5: Production (Q4 2025)

  • Comprehensive error messages
  • Garbage collector (advanced)
  • Memory profiler
  • Security audit
  • Performance benchmarks
  • Stable API

Phase 6: Future (2026+)

  • JIT compiler
  • WebAssembly target
  • Native code generation
  • Cross-platform optimization
  • Advanced runtime features

Known Issues

Current Limitations

  1. Type Checker: Partial implementation, needs refinement for complex types
  2. Object System: Basic inheritance, needs method binding optimization
  3. Memory Management: Mark-and-sweep GC not yet implemented
  4. Module System: Partial implementation (use keyword support added, std lib in progress)
  5. Standard Library: 44/75 functions (58% complete)
  6. Error Messages: Could be more detailed with suggestions
  7. REPL: Basic implementation, no history or autocompletion

Workarounds

  • For GC: Short-lived programs work fine with basic allocation
  • For modules: Use the new use keyword or compile with single-file strategy
  • For missing functions: Implement in ProXPL or use system() calls

Migration Guide

From Python Implementation (if existed)

The C implementation aims to be 100% compatible with any previous Python version. If migrating code:

  1. Syntax is identical
  2. All core features supported
  3. Standard library functions have same signatures
  4. Error behavior is consistent

Performance Notes

Benchmarks (Development Build)

Operation Time Notes
Startup ~5-10ms Cold start
Compilation Fast Bytecode compilation
Fibonacci(20) <100ms Recursive
String operations Native C speed Highly optimized

Optimization Targets (v1.0)

  • Startup time: <5ms
  • Compilation: <100ms for typical files
  • Runtime: Native C performance baseline

Security

Current Status

  • Basic input validation
  • No buffer overflows (C-managed)
  • String bounds checking
  • Type safety through type checker

Audit Status

  • Self-reviewed (developer team)
  • No external audit yet
  • Planned for v1.0 release

Recommendations

  • Run with memory sanitizers in development
  • Use ASLR and DEP (OS-level)
  • Validate user input scripts

Contributors

ProXPL is developed by the ProXPL development team.

Acknowledgments

  • Inspired by Python, JavaScript, Go, Rust, Lua
  • Based on compiler design principles from "Crafting Interpreters"
  • Thanks to the open-source community

License

This project is licensed under the MIT License.

How to Report Issues

Bugs

  1. Check existing issues
  2. Provide minimal reproducible example
  3. Include OS, compiler version
  4. Describe expected vs actual behavior

Features

  1. Describe use case
  2. Explain why it's needed
  3. Provide implementation hints (if possible)
  4. Link related issues/discussions

Version Numbering Scheme

ProXPL uses semantic versioning: MAJOR.MINOR.PATCH

  • MAJOR: Breaking changes
  • MINOR: New features (backward compatible)
  • PATCH: Bug fixes
  • PRE-RELEASE: 0.x.x indicates development

Current Version: 1.3.0 Last Updated: January 27, 2026 Next Release: 1.3.0 (Q1 2026)