Skip to content

Latest commit

 

History

History
717 lines (522 loc) · 19.2 KB

release.md

File metadata and controls

717 lines (522 loc) · 19.2 KB

Release History

Version 1.0.0 (February 2026)

First stable release of Gade (Groovy Analytics Development Environment)

Gade is a modern IDE specifically designed for data analysis, visualization, and machine learning with Groovy. It combines the power of the JVM ecosystem with an intuitive interface optimized for data science workflows.

Overview

This is the first production-ready release of Gade, representing over 2 years of development and refinement. The 1.0.0 release focuses on stability, performance, and comprehensive documentation, making Gade ready for professional data science and analytics work.

Key Highlights:

  • 🚀 Multiple runtime modes (Gade, Gradle, Maven, Custom)
  • 💡 Intelligent code completion (<100ms response time)
  • 📊 Integrated data visualization with Matrix library
  • 🗄️ JDBC database integration with connection management
  • 📦 Automated dependency management via Gradle/Maven
  • 🔧 Built-in Git integration
  • ✅ 285 automated tests (70% code coverage for core components)
  • 📚 Comprehensive user and developer documentation

New Features

Runtime System

Multiple Execution Modes:

  • Gade Runtime - Fast embedded GroovyShell for quick scripts and exploration
  • Gradle Runtime - Full Gradle support with dependency resolution via build.gradle
  • Maven Runtime - Maven-based execution for enterprise workflows with pom.xml
  • Custom Runtime - User-specified Java executable for testing against specific JDK versions

Process Isolation:

  • Gradle and Maven runtimes execute in separate JVM processes
  • Prevents classpath conflicts and UI crashes
  • Isolated memory management (scripts can use up to available system memory)
  • JSON-RPC protocol (v1.0) for inter-process communication

See: ADR 001: Separate Process Runtimes

Code Completion

Intelligent Context-Aware Completion:

  • Groovy method/field completion with reflection
  • SQL keyword and database table/column completion
  • JavaScript API completion (DOM, Node.js)
  • Import suggestions with automatic import addition
  • Member access completion (type . to see available methods)

Performance:

  • Average response time: 42-68ms (well under 100ms target)
  • Cached classpath scanning for fast subsequent completions
  • Context detection skips completion inside strings and comments

Extensible Architecture:

  • Pluggable CompletionEngine interface
  • Easy to add new language support
  • Comprehensive API documentation with examples

See:

Database Integration

JDBC Support:

  • Connect to any JDBC-compatible database (PostgreSQL, MySQL, H2, SQL Server, Oracle)
  • BigQuery support for Google Cloud Platform
  • Connection management (save, edit, delete, test connections)
  • SQL script editor with result viewers
  • Query results export to CSV and other formats

Dynamic Driver Loading:

  • Add JDBC drivers via UI or Gradle dependencies
  • No system classloader pollution
  • Support for multiple driver versions in different projects

Data Visualization

Integrated Charting:

  • Line charts, bar charts, pie charts
  • Scatter plots with regression lines
  • Histograms and distribution analysis
  • Box plots for group comparisons
  • Heatmaps and correlation matrices

Matrix Library Integration:

  • Tabular data manipulation (like R's data.frame)
  • Statistical functions (mean, median, standard deviation, correlation)
  • Data transformation and filtering
  • Export to various formats

Chart Export:

  • PNG, SVG, PDF export formats
  • Customizable sizes and themes
  • Publication-quality output

Git Integration

Built-in Version Control:

  • Clone, init, commit, push, pull
  • Branch management (create, switch, merge, delete)
  • Visual diff viewer
  • Stash operations
  • Tag management for releases
  • JGit-based implementation (no external Git required)

SSH and HTTPS Support:

  • HTTPS with personal access tokens
  • SSH key authentication
  • Comprehensive setup guide in documentation

Dependency Management

Gradle Integration:

  • Automatic classpath resolution from build.gradle
  • Intelligent caching with fingerprinting
  • Cache invalidation on build file changes
  • Helpful error messages with fix suggestions
  • Support for multi-project builds

Maven Integration:

  • Classpath resolution from pom.xml
  • POM inheritance support
  • Maven Central and custom repository support
  • Leverages maven-utils library

Cache Location: ~/.gade/gradle-cache/

Project Management

Workspace Features:

  • File browser with project navigation
  • Multiple editor tabs (Groovy, SQL, JavaScript, Markdown, XML, HTML)
  • Auto-save functionality
  • Syntax highlighting for multiple languages
  • Environment panel showing script variables
  • Console with colored output

Wizards:

  • Groovy application scaffold
  • Groovy library scaffold
  • Quick project setup templates

User Interface

JavaFX-based Modern UI:

  • Clean, intuitive interface
  • Customizable font sizes
  • Hi-DPI display support (scaling configuration)
  • Dark mode compatible themes
  • Keyboard-driven workflow (63 documented shortcuts)

Responsive Design:

  • Non-blocking script execution
  • Progress indicators for long operations
  • Graceful error handling

Performance Improvements

Benchmarked Performance

Code Completion (JMH benchmarks):

  • Simple string completion: 42ms average
  • Complex import completion: 68ms average
  • Member access completion: 51ms average
  • Context building: 0.5ms average
  • Registry lookup: 0.008ms average

All targets (<100ms) achieved.

File Operations:

  • 1KB file read: <1ms
  • 1MB file read: 10-50ms
  • 10MB file read: 100-500ms
  • Buffered vs direct read benchmarked

Gradle Cache:

  • Cache directory access: <10µs
  • File existence check: <50µs
  • Cache file read: <5ms

See: docs/improvements/task-27-performance-benchmarks.md

Startup Time

  • Cold start: 3-4 seconds
  • Warm start: 2 seconds
  • (Measured on 2023 MacBook Pro M2)

Memory Efficiency

  • Minimum: 200MB (empty project)
  • Normal: 500MB-1GB (with Gradle runtime)
  • Recommended: 8GB heap for large datasets (-Xmx8G)

Testing and Quality

Test Coverage

285 Automated Tests:

  • Unit tests (JUnit 5 + Mockito): 278 tests
  • GUI smoke tests (TestFX): 7 tests

Code Coverage (JaCoCo):

  • Overall: 15% (includes infrastructure-heavy code)
  • CompletionEngine: 82% (+23% from baseline)
  • GradleUtils: 51% (+7% from baseline)
  • RuntimeProcessRunner: 66% (+5% from baseline)

Coverage by Component:

  • CompletionContext: 94%
  • CompletionItem: 89%
  • CompletionRegistry: 87%
  • GroovyCompletionEngine: 82%

See: docs/improvements/coverage-analysis.md

Performance Benchmarks

JMH (Java Microbenchmark Harness):

  • 3 benchmark suites created
  • 15 individual benchmarks
  • Covers: Code completion, file operations, Gradle cache
  • Run with: ./gradlew jmh

See: docs/improvements/task-27-performance-benchmarks.md

GUI Testing

TestFX Integration:

  • Headless testing (no popup windows)
  • Automated UI verification after each build
  • 7 smoke tests covering main workflows

Configuration:

  • Default: Headless mode (systemProp.testfx.headless=true)
  • Debug: Show GUI with -Dtestfx.headless=false

See: docs/improvements/testfx-smoke-tests.md

Documentation

User Documentation

README.md:

  • System requirements and compatibility
  • 5 installation methods (Linux, macOS, Windows)
  • Quick start guide with code examples
  • Feature overview with screenshots
  • Configuration guide (env.sh/env.cmd)
  • Troubleshooting (8 categories, 30+ solutions)

User Guide (docs/user-guide.md):

  • 900+ lines, 18,000+ words
  • Runtime selection guide (comparison table)
  • Code completion usage (5 types documented)
  • Database connections (4 databases with examples)
  • Git integration workflow
  • Charts and visualizations (8 chart types)
  • 63 keyboard shortcuts
  • Advanced topics (custom engines, large datasets)

API Documentation (Javadoc):

  • Generated at: build/docs/javadoc/
  • Enhanced CompletionEngine, CompletionItem, CompletionContext
  • Implementation examples for extension authors
  • Clean build (0 errors)

Developer Documentation

ARCHITECTURE.md:

  • System overview with component diagrams
  • Runtime execution models
  • JSON-RPC protocol specification
  • Code completion system architecture
  • 5 extension points documented
  • Data flow diagrams
  • Security considerations

CONTRIBUTING.md:

  • Development setup (IntelliJ, Eclipse, VS Code)
  • Build and test instructions
  • Code style guidelines
  • Pull request process with checklist
  • Testing requirements (coverage targets)
  • Documentation guidelines
  • Release process

Architecture Decision Records (ADRs):

  1. ADR 001: Separate Process Runtimes - Why Gradle/Maven use subprocesses
  2. ADR 002: GroovyShell vs JSR223 - Why we use GroovyShell directly (3.7x faster)
  3. ADR 003: Completion Engine Architecture - Pluggable completion design

Total Documentation:

  • 5,000+ lines of new documentation
  • 100+ code examples
  • 11 diagrams

Refactoring and Code Quality

Sprint 3 Refactorings

Task #10: Component Refactoring

  • ConsoleComponent → ConsoleButtonPanel, ConsoleEnvironmentPane, ConsoleTextArea
  • MainMenu → MenuFile, MenuCode, MenuTools
  • GradleUtils → GradleUtils, GradleCacheManager, GradleErrorDetector

Result: Improved maintainability with focused, single-responsibility classes

Task #11: Cache Consolidation

  • Unified caching implementation across components
  • Consistent cache invalidation strategy

Task #12: ExecutableTab Base Class

  • Extracted common behavior from GroovyTab, SqlTab, JsTab
  • Eliminated code duplication
  • Standardized execute button management

Task #13: Protocol Versioning

  • JSON-RPC protocol now versioned (v1.0)
  • Backward compatibility support
  • Clear protocol documentation

See: docs/improvements/v1.0.0-roadmap.md (Sprint 3 section)

Code Improvements

Removed from Production Code:

  • All System.out.println statements (replaced with Logger)
  • Unnecessary suppressed exception handlers
  • Code comments explaining obvious operations

Added:

  • Comprehensive error handling
  • Logging at appropriate levels
  • Helpful error messages with actionable hints

System Requirements

Minimum Requirements

  • Java: JDK 21 or later (LTS recommended)
  • Memory: 4GB RAM minimum
  • Disk Space: 500MB for application + workspace storage
  • Operating System:
    • Linux (x64, tested on Ubuntu 20.04+)
    • macOS (x64/ARM64, tested on macOS 11+)
    • Windows 10/11 (x64)

Recommended Configuration

  • Java: JDK 21 LTS
  • Memory: 8GB+ RAM (16GB for large datasets)
  • Disk Space: 2GB+ (includes dependencies and cache)
  • Display: 1920x1080 or higher
  • Optional: Git for version control integration

Installation

Platform-Specific Distributions

Pre-built packages available:

  • gade-linux-1.0.0.zip - Linux x64
  • gade-macos-1.0.0.zip - macOS (x64 + ARM64)
  • gade-windows-1.0.0.zip - Windows x64

Each includes:

  • Gade application
  • Minimal JRE (Java 21 + JavaFX)
  • Platform-specific launcher (gade.sh or gade.cmd)
  • Desktop icons

Installation:

  1. Download platform-specific zip from releases page
  2. Extract to desired location
  3. Run gade.sh (Linux/macOS) or gade.cmd (Windows)

See: README.md for detailed installation instructions

Alternative Installation Methods

Option 1: Run via Maven (no installation)

./gadeMavenRunner.sh

Option 2: Run via Groovy

groovy gade.groovy

Option 3: Build from Source

git clone https://github.com/perNyfelt/gade.git
cd gade
./gradlew run

Known Limitations

Runtime Limitations

  1. Script Interruption

    • Cannot interrupt long-running scripts in Gade Runtime
    • Workaround: Use separate process runtimes (Gradle/Maven) which can be killed
    • Planned for v1.1.0

  2. Memory Management

    • Large datasets (>2GB) may require heap size adjustment
    • Configure via JAVA_OPTS=-Xmx16G in env.sh/env.cmd

  3. Gradle Daemon

    • First Gradle execution may take 15-30 seconds (dependency download)
    • Subsequent runs use cached dependencies (fast)

Editor Limitations

  1. Large Files

    • Files >100MB have limited syntax highlighting (performance optimization)
    • Text editing remains functional
    • Recommendation: Use external editor for very large files

  2. Code Completion

    • Groovy dynamic features may not always be completable
    • Meta-programming (categories, mixins) has limited support
    • Works best with statically-typed code

Platform-Specific Issues

macOS:

  • First launch may require "Allow" in System Preferences → Security
  • Notarization pending for future releases

Windows:

  • Windows Defender may flag unsigned executable (future: code signing)
  • Git Bash recommended for bash script execution

Linux:

  • Some distributions require manual desktop file creation
  • Icon provided in base directory

Upgrade Notes

This is the initial 1.0.0 release - no upgrades from previous versions.

For users migrating from Ride (the predecessor):

  • Configuration files not compatible (manual migration required)
  • Most scripts should work without modification
  • Database connections must be recreated
  • Git repositories can be opened directly

Bug Fixes from Pre-Release

Critical Fixes

  1. Fixed: NullPointerException in GradleUtils when build.gradle doesn't exist

    • Now returns empty classpath instead of crashing
    • Helpful error message shown to user

  2. Fixed: GMD PDF export producing 0-byte files

    • Updated Groovy Markdown library to latest version
    • Added test coverage for PDF generation

  3. Fixed: Maven home validation not checking for lib/ directory

    • Now verifies complete Maven installation
    • Provides clear error message if incomplete

  4. Fixed: Resource leak in ConnectionHandler

    • JDBC connections now properly closed in all code paths
    • Added try-with-resources throughout

  5. Fixed: Typo "Unknwn" → "Unknown" in error messages

    • Corrected spelling across codebase

Performance Fixes

  1. Fixed: Slow code completion on large classpaths

    • Implemented ClassGraph caching (10x faster)
    • Added cache invalidation on dependency changes

  2. Fixed: Gradle cache not invalidating on build.gradle changes

    • Implemented fingerprinting based on file hash
    • Automatic cache invalidation on modifications

  3. Fixed: Memory leak in completion registry

    • Completion engines now properly release cached scans
    • invalidateCache() called on classpath changes

UI Fixes

  1. Fixed: TestFX tests popping up windows during build

    • Enabled headless mode by default
    • Can be overridden for debugging

  2. Fixed: Hi-DPI scaling issues on Windows

    • Added glass.win.uiScale configuration option
    • Documented in troubleshooting guide

  3. Fixed: Console output not showing colors on Windows

    • Fixed ANSI color code handling
    • Consistent output across platforms

Breaking Changes

No breaking changes - this is the initial 1.0.0 release.

Dependencies

Major Dependencies

Core:

  • Java 21 (LTS)
  • Groovy 4.0.15
  • JavaFX 21

Build Tools:

  • Gradle Tooling API 8.5
  • maven-utils 1.2.0

UI Libraries:

  • RichTextFX 0.11.x (code editor)
  • ControlsFX (enhanced UI controls)

Utilities:

  • ClassGraph (classpath scanning)
  • JGit (Git integration)
  • Jackson (JSON handling)
  • Apache Tika (file type detection)

Data Science:

  • Matrix library (tabular data)
  • Matrix Charts (visualization)
  • FreeCharts (charting)

See: build.gradle for complete dependency list

License

Gade is released under the MIT License.

Third-party dependencies have their own licenses (Apache 2.0, MIT, BSD, Eclipse).

See: README.md for complete third-party license information

Acknowledgments

Contributors:

  • Per Nyfelt - Lead Developer
  • Claude Sonnet 4.5 - AI Assistant (documentation, testing, refactoring)

Special Thanks:

  • Ride project - Original inspiration
  • Groovy community - Language and libraries
  • Matrix library contributors - Data science foundation

Getting Started

Quick Start (5 Steps)

  1. Download and Install

    wget https://github.com/perNyfelt/gade/releases/download/v1.0.0/gade-linux-1.0.0.zip
unzip gade-linux-1.0.0.zip
cd gade-linux-1.0.0
./gade.sh

  2. Create Your First Script

    • Click File → New Script (Ctrl+N)
    • Enter code:
    import se.alipsa.groovy.matrix.*

def data = Matrix.builder()
  .data([[1, 10], [2, 20], [3, 30]])
  .columnNames('x', 'y')
  .build()

println data
println "Mean of x: ${data.mean('x')}"

  3. Execute the Script

    • Press F5 or click Run button
    • View output in Console tab

  4. Explore Features

    • Try code completion (type data. and press Ctrl+Space)
    • Connect to a database (Connections tab)
    • Create a chart (see docs/user-guide.md)

  5. Learn More

    • User Guide: docs/user-guide.md
    • Examples: examples/ directory
    • Help → User Manual (built-in)

Support and Resources

Documentation

  • README.md - Installation and quick start
  • docs/user-guide.md - Comprehensive user guide
  • docs/cookbook/cookbook.md - Common tasks and recipes
  • ARCHITECTURE.md - System architecture (for developers)
  • CONTRIBUTING.md - Contribution guidelines (for developers)
  • API Documentation - build/docs/javadoc/index.html

Community

Reporting Issues

Found a bug?

  • Check existing issues first
  • Include: Gade version, OS, Java version, steps to reproduce
  • Attach logs from ~/.gade/logs/gade.log

Feature requests welcome!

  • Describe use case and proposed solution
  • Examples from other tools helpful

What's Next

Planned for v1.1.0

High Priority:

  • Script interruption support
  • Improved memory profiling tools
  • Enhanced JDBC metadata introspection for large schemas
  • Additional chart types (violin plots, tree maps)

Medium Priority:

  • Remote script execution (SSH)
  • Collaborative editing (multiple users)
  • Plugin system for extensions
  • Language Server Protocol (LSP) integration

Low Priority:

  • Web-based UI (browser access)
  • Mobile companion app
  • Cloud workspace synchronization

See: todo.md for detailed roadmap

Release Information

Version: 1.0.0 Release Date: February 2026 Codename: Stable Release Build: Release

Download:

Checksums:

  • SHA256 checksums provided in release assets

Changelog

For detailed changes, see individual task documentation:

  • docs/improvements/v1.0.0-roadmap.md - Complete roadmap
  • docs/improvements/task-*.md - Detailed task documentation
  • Sprint summaries in roadmap

Thank you for using Gade!

For questions, issues, or contributions, visit: https://github.com/perNyfelt/gade

Gade 1.0.0 - February 2026 A Groovy Analytics Development Environment for Data Scientists