Skip to main content

What about javascript?

· 3 min read
Hategekimana Fabrice
Hategekimana Fabrice
IT trainer, Programming language designer

When Static Typing Meets Code Generation​

Imagine being able to generate JavaScript with the syntax of R and with all the rigor of static typing? This is exactly what JS Blocks enable.

The Problem with Generated Code​

Programmatically generating code is a common practice: building queries, creating front-end scripts, templating... But this approach suffers from a major flaw: the absence of verification at write-time. You concatenate strings hoping the result will be syntactically correct, and you only discover your errors at runtime.

js_code <- paste0("let a = ", value, ";")  # What if 'value' isn't defined?

The Elegance of JS Blocks​

JS Blocks reverse this logic. You write code that looks like JavaScript, but benefits from the full power of static typing:

let js_code <- JS {
    let a: int <- 5;
    let b: char <- "hello";
    
    let greet <- fn(name: char): char {
        "Hello, " + name
    };
};

This code will generate:

js_code <- "let a = 5;
let b = 'hello';

let greet = (name) => {
	'Hello, ' + name
};
"

This code transpiles to an R string containing valid JavaScript, but the magic happens before: the compiler checks types, detects errors, and guarantees that the generated code will be syntactically correct.

Concrete Advantages​

  • Compile-time safety: Type errors are detected immediately, not when your JavaScript executes in the browser.

  • Autocompletion and IntelliSense: Your editor understands your code's structure, even though it will ultimately be converted to a string.

  • Risk-free refactoring: Rename a variable, and all its occurrences in your JS Blocks are automatically updated.

  • Living documentation: Type annotations serve as built-in documentation about what your generated code is supposed to do.

Compelling Use Cases​

This approach particularly shines in several scenarios:

Generating interactive visualizations: Create complex configurations for D3.js or Plotly with the certainty that your parameters are properly typed.

Building R webapps: In Shiny or other frameworks, generate JavaScript for the front-end with all the rigor of the backend.

Advanced templating: Produce configurable scripts where parameters are statically validated before generation even occurs.

Testing and mocking: Generate JavaScript test code with guarantees of consistency.

Innovation Through Constraint​

What makes JS Blocks particularly interesting is that they transform a constraint (having to generate JavaScript) into an opportunity. Rather than working around the problem with fragile solutions, they tackle it head-on by creating a bridge between two worlds: the rigor of static typing and the flexibility of code generation.

It's a perfect example of how good language design can solve real problems without adding unnecessary complexity. The concept is simple to understand, but its implications are profound.

Conclusion​

JS Blocks represent an elegant approach to a problem every developer has encountered. By bringing static typing to generated code, they eliminate an entire class of errors while preserving the flexibility needed for programmatic generation.

In my opinion, it's the kind of innovation that, once adopted, makes it impossible to imagine working any other way.