Skip to content

Interactive Development Environment Roadmap

Current Status

Epsilon provides basic REPL functionality through SBCL but lacks modern interactive development features. This roadmap outlines the development of a rich, web-based development environment.

Phase 1: Quick Wins (2-3 weeks)

Low Difficulty Items

  • Symbol aliases: Short aliases for common operations
  • (m ...) for (map:make-map ...)
  • (s seq fn) for (seq:map fn seq)
  • Context-specific abbreviations for frequent operations
  • Pretty printers: Better PRINT-OBJECT methods for all data structures
  • Maps print as {:key value, ...}
  • Sets print as #{element ...}
  • Sequences with truncation for large collections
  • Nested structure formatting with proper indentation
  • REPL commands: Common operations as REPL shortcuts
  • :i object - inspect object with expandable views
  • :t function - trace function execution
  • :p expression - profile expression performance
  • :h symbol - help/documentation lookup

Phase 2: Smart REPL Package (3-4 weeks)

Medium Difficulty Implementation

  • Context-aware symbol completion: Intelligent suggestions based on current scope
  • Auto-import based on current working module: Automatic package resolution
  • Symbol search across all loaded packages: Global symbol discovery
  • Recent symbol history and favorites: Persistent user preferences
  • Package alias management: Avoid long prefixes with smart aliasing

Technical Requirements

  • Integration with epsilon.lsp for symbol information
  • Persistent configuration using epsilon.lib.yaml
  • Fast symbol indexing with epsilon.lib.map
  • Command history with epsilon.sys.fs

Phase 3: Inspector Framework (4-6 weeks)

Core Inspector Features

  • Hierarchical object inspection: Tree-based object navigation
  • Expandable/collapsible views: Lazy loading for large objects
  • Type-specific inspectors: Custom views for maps, sequences, functions
  • Edit-in-place for mutable slots: Direct object modification
  • Navigation history: Back/forward through inspection sessions
  • Export capabilities: JSON, EDN, and other format exports

Advanced Inspector Features

  • Visual data structure representation: Graphical tree and graph views
  • Search within inspected objects: Find values and keys in complex structures
  • Comparison mode: Diff view between different objects or states
  • Memory usage analysis: Object size and reference tracking

Phase 4: Notebook Interface (6-8 weeks)

Notebook-Style REPL Features

  • Cell-based evaluation: Persistent results with execution order tracking
  • Markdown cells: Rich documentation with code examples
  • Inline visualizations: Tables, graphs, trees directly in notebook
  • Cell dependencies: Automatic re-execution of dependent cells
  • Export capabilities: HTML/PDF reports for sharing and documentation
  • WebSocket-based interface: Remote access and collaborative editing

Technical Implementation

  • Web-based UI using epsilon.net.http
  • Real-time updates via WebSocket connections
  • Client-side rendering with modern JavaScript
  • Server-side state management for notebook persistence

Phase 5: Live System Browser (8-10 weeks)

High Difficulty Advanced Features

  • Real-time module dependency visualization: Interactive dependency graphs
  • Thread activity monitor: Live stack traces and execution monitoring
  • Memory allocation heatmaps: Visual memory usage patterns
  • Network connection status: Live monitoring of network activity
  • Interactive debugging: Breakpoints with live variable inspection
  • Performance profiling overlay: Real-time performance metrics

Browser Architecture

  • D3.js-based visualizations for complex data
  • Real-time data streaming for live updates
  • Efficient diff algorithms for incremental updates
  • Plugin architecture for custom views and metrics

Phase 6: Time-Travel Debugging (10-12 weeks)

Revolutionary Debugging Features

  • Record all state changes: Comprehensive execution history
  • Step backwards through execution: Reverse debugging capabilities
  • Replay with modifications: "What if" debugging scenarios
  • Diff view between states: Visual comparison of program states
  • Persistent history: Post-mortem analysis of crashes and issues
  • Test integration: Replay failed tests with full context

Technical Challenges

  • Efficient state snapshot algorithms
  • Incremental change tracking
  • Large history storage and retrieval
  • Integration with garbage collector
  • Performance impact minimization

Implementation Roadmap

Timeline Overview

  1. Phase 1 (2-3 weeks): Smart REPL with context management
  2. Phase 2 (3-4 weeks): Inspector framework with rich visualizations
  3. Phase 3 (4-6 weeks): Notebook interface using epsilon.http
  4. Phase 4 (6-8 weeks): System browser with D3.js visualizations
  5. Phase 5 (8-10 weeks): History system with efficient snapshots

Technical Requirements

  • WebSocket support: Real-time communication for live updates
  • Browser-based UI: Modern web interface using epsilon.http
  • Efficient serialization: Handle large objects and rapid updates
  • Incremental updates: Avoid full redraws for performance
  • Extensible architecture: Plugin system for custom inspectors

Success Metrics

Phase 1 Success Criteria

  • REPL commands work reliably with good documentation
  • Pretty printers improve readability significantly
  • Symbol aliases reduce typing and improve workflow

Phase 2 Success Criteria

  • Symbol completion provides relevant suggestions under 100ms
  • Auto-import resolves 90%+ of common symbol usage
  • Package management eliminates most manual prefixing

Phase 3 Success Criteria

  • Inspector handles complex objects with good performance
  • Navigation and search work smoothly for large data structures
  • Export functionality produces clean, usable output

Phase 4 Success Criteria

  • Notebook interface supports collaborative development
  • Cell dependencies work reliably with minimal user intervention
  • Export produces publication-quality documentation

Phase 5 Success Criteria

  • System browser provides actionable insights into program behavior
  • Performance profiling identifies bottlenecks effectively
  • Debugging interface reduces time-to-resolution for issues

Phase 6 Success Criteria

  • Time-travel debugging enables rapid issue reproduction
  • History system has minimal performance impact during normal operation
  • Integration with testing provides comprehensive failure analysis

Architecture Integration

Core Dependencies

  • epsilon.lsp: Symbol information and project understanding
  • epsilon.net.http: Web interface and WebSocket communication
  • epsilon.lib.json: Data serialization for web interface
  • epsilon.tool.test: Integration for test-driven development
  • epsilon.sys.thread: Parallel execution and monitoring
  • epsilon.lib.map: Efficient data structures for caching and indexing

Extension Points

  • Custom inspectors: Plugin system for domain-specific views
  • Visualization plugins: Extensible chart and graph types
  • Debug adapters: Integration with external debugging tools
  • Export formats: Pluggable output formats for different use cases