What is an Open Transpiler and why do we need it?

A transpiler is an Open Transpiler if programmers can open the hood of the transpiler and tune it for their own needs. In this post, I will explain what it means exactly, why we need it, and how it works. I’ll end up showing some specific JSweet v2 examples.
(more…)

JSweet version 2.0.0 has been released

We are pleased to announce that JSweet 2 is now available.

JSweet 2 is the outcome of several months of intense work with several partners that have been using JSweet for different purposes. It brings to you major improvements in the way you can transpile your Java code to JavaScript. Here are the main changes:

• More interoperability with JavaScript. By default the generated code gets rid of Java APIs and uses pure JavaScript objects (for instance Java lists and maps will translate to pure JavaScript arrays/objects). No Java runtime is required anymore (on contrary to other Java to JavaScript transpilers) and your JSweet APIs can be used as is by JavaScript and TypeScript programs. JSweet even translates Javadoc comments to JSDoc for full API support. Try it.
• Support for tuning and extending the transpiler. With JSweet 2, there are several ways to tune/extend the generated code: Java annotations, configuration file, or through the JSweet transpiler extension API. In short, JSweet is now an open transpiler, which means it can be easily extended/adapted, as fully explained here. Also check out the small example right below.
• Much improvements to bridge external JavaScript libraries. With JSweet 2, it becomes really easy to write your own candies (a.k.a. bridges). First, you can write definitions on-the-fly in your program within the def package. With the candy generator tool, you can translate the TypeScript definitions and get a first Java version, which you can modify for your own purpose, and share with the community in the jsweet-candies organization.
• More extensive support for Java (semantics and core APIs). Partial and extensible support for many Java APIs such as java.io, java.lang.reflect, or java.math, is now built-in or easy to plug in with the extension API.

Example

For the sake illustrating new JSweet v2 brand new power, let us say your Java program uses java.util.Date objects. By default, JSweet translates java.util.Date objects to JavaScript dates. However, for your context (and some personal reasons), you may want to translate dates to strings. With JSweet 2, you can simply use the extension API to write an adapter that will map the java.util.Date type to the TypeScript string type. It is as simple as this (see the complete example here):

public class HelloWorldAdapter extends org.jsweet.transpiler.extension.PrinterAdapter {
    public HelloWorldAdapter(PrinterAdapter parent) {
        super(parent);
        addTypeMapping(java.util.Date.class.getName(), "string");
    }
}

Know more / get involved

For more details and secondary features, please read the release notes.

We hope to keep in touch with you soon and plan to post some real-world success stories about using JSweet. Don’t hesitate to contact us in the meantime if you have any questions.

• JSweet discussion forum
• Source code, issues, contributions on Github (please star to show support!)
• Contact Renaud Pawlak

JSweet version 1.2.0 has been released

We are pleased to announce stable release 1.2.0.

This release contains many bug fixes and new features. It takes into account our last-months experience developing real IONIC/Cordova applications with JSweet, but also many excellent feedback from the community (many thanks to the reporters!). Also, it is compatible with Angular 2.

Check the release notes.

JSweet v1.0 is out: 10 reasons to use it

JSweet version 1.0 was released today.

JSweet is a Java to JavaScript transpiler built on the top of TypeScript and it gives access to hundreds of up-to-date and well-typed JavaScript APIs from Java. The following figure shows how JSweet translates from the TSD repository and uses the TypeScript tsc compiler and APIs (d.ts) to transpile Java into JavaScript.

With the release of version 1.0, I would like to explore the main reasons why you, as a programmer, would want to try JSweet out, and ultimately use it to program Web applications in a better and safer way.

Reason 1: Type Safety and Robustness

This is the most obvious reason, of course. JSweet ensures strong typing on JavaScript APIs and programs. JSweet has been designed to match TypeScript typing concepts and a JSweet program can bring the same type safety level as a TypeScript program.  (more…)