Building JSONLogic in Rust with Github Copilot: A 5-Hour Journey

Harishankar Narayanan — Wed, 20 Nov 2024 07:01:33 +0000

Hey devs! 👋 I recently took on an interesting challenge: implementing the complete JSONLogic specification in Rust, with Github Copilot as my pair programming buddy. The entire project took less than 5 hours, and I wanted to share my experience of how AI can be effectively leveraged in systems programming.

datalogic-rs

What is JSONLogic?

JSONLogic is a way to write portable logic rules as JSON. It's particularly useful when you need to:

Share business logic between frontend and backend
Store rules in a database
Create dynamic validation rules
Build expression evaluators

The Project Goals

Implement the complete JSONLogic spec in Rust
Ensure type safety and zero-copy parsing
Maintain production-grade code quality
Use AI effectively without compromising code quality

My Approach with Github Copilot

1. Clear Architecture First

Instead of jumping straight into coding, I started by designing the project structure. I explained this structure to Copilot, which helped set a consistent pattern for implementation.

2. Test-Driven Development

JSONLogic comes with an extensive test suite. I:

Imported all test cases
Set up the test infrastructure
Let all tests fail initially

#[test]
fn test_var_operator() {
    let cases = load_test_cases("var");
    for case in cases {
        assert_eq!(
            evaluate(case.logic, case.data),
            case.expected
        );
    }
}

3. Pattern-Based Implementation

Started with implementing one operator as a template.

4. Leveraging Copilot

Once I had the pattern established:

Wrote test cases for each operator
Explained the operator's requirements to Copilot
Let Copilot generate the initial implementation
Reviewed and refined the code
Moved to the next operator

5. Optimization & Polish

Final steps included:

Running Clippy and fixing all warnings
Adding comprehensive error messages
Optimizing performance (reducing allocations)
Adding documentation
Setting up CI/CD

Key Learnings

What Worked Well

Clear Direction: Copilot performs best when given clear patterns to follow
Test-Driven Approach: Having tests upfront made validation seamless
Incremental Development: Building operator by operator kept the scope manageable
Review & Refine: AI-generated code needs human oversight for best practices

Challenges Faced

Edge Cases: Some JSON parsing edge cases needed manual handling
Error Messages: Crafting user-friendly error messages needed human touch
Documentation: Generated docs needed refinement for clarity

The Result

The final library (GitHub Link) is:

Production-ready
Fully tested
Well-documented
Performance optimized
Type-safe

Try It Out!

Add to your Cargo.toml:

[dependencies]
datalogic = "0.1.0"

Basic usage:

use datalogic::evaluate;
use serde_json::json;

fn main() {
    let logic = json!({"==": [1, 1]});
    let data = json!({});
    let result = evaluate(&logic, &data).unwrap();
    assert_eq!(result, json!(true));
}

Conclusion

This project showed me that AI can be an effective pair programming partner when used with proper structure and oversight. It's not about replacing human developers but augmenting our capabilities to build faster while maintaining quality.

Would love to hear your thoughts and experiences with AI-assisted development! Feel free to check out the repository, raise issues, or contribute.

What's Next?

Adding more optimizations
Supporting custom operators
Building a web playground
Your suggestions? 😊

datalogic-rs
Remember to ⭐️ the repository if you found it useful!

DEV Community: Harishankar Narayanan