The Java Mint Blog

New Mint Release: r15952

2010-10-20T14:58:00.000-07:00

I made a new release of Mint and DrJava with Mint yesterday: October 19, 2010 (r15952). The latest release is, as always, available from the Mint implementation page:

There were several bug fixes regarding assignment to variables declared as CodeFree, the places where SafeCode is required, treatment of type variables with bounds in escapes, and array types, which were erroneously printed as '[Lfoo/bar;' or '[B'.

The version of DrJava with Mint is based on the current trunk (and therefore is newer than the updated stable release of DrJava that was recently made available).

GPCE'10 Tutorial Slides

2010-10-10T05:35:00.000-07:00

The slides for our GPCE 2010 tutorial presentation "Agile and Efficient Domain-Specific Languages using Multi-Stage Programming in Java Mint" are available now as PowerPoint and PDF file.

The zip file with the source code for our GPCE 2010 tutorial is available too.

The simplest way to experiment with Mint is to download the latest version of DrJava with Mint.

GPCE'10 Tutorial Source

2010-10-10T02:38:00.000-07:00

Here is a zip file with the source code for our GPCE 2010 tutorial.

The simplest way to experiment with Mint is to download the latest version of DrJava with Mint.

New Mint Release: r15858

2010-09-30T20:43:00.000-07:00

I made a new release of Mint and DrJava with Mint yesterday: September 29, 2010 (r15858). The latest release is, as always, available from the Mint implementation page:

We have added the edu.rice.cs.mint.runtime.CodeFree interface and the edu.rice.cs.mint.runtime.CheckedExceptionInCode exception class.

The CodeFree interface provides a different, more transparent way of specifying separable classes that can be used for non-local assignments and CSP. When a class is declared to implement the CodeFree interface, the class is guaranteed to be code-free, provided a number of static checks are passed:

All field types and method return types are code-free, either using the old definition that required the types to be final, or by themselves implementing the CodeFree interface.
The same applies to all subtypes of types implementing the CodeFree interface. It is an error to extend a class declared to be code-free using the CodeFree interface and then to add a field containing or a method returning code.

This new rule makes it simpler to work with non-primitive types since the classes do not have to be final anymore. In the past, lifting had to be done instead of using CSP; that is not necessary anymore. Consider the old code with the required lift method and its application instead of straight-forward CSP:

public abstract class Value {
  public separable int intValue() { throw new WrongTypeException(); }
  public separable boolean booleanValue() { throw new WrongTypeException(); }
  public separable abstract boolean valueEq(Value other);
  public separable abstract Code<Value> lift();
}

public class IntValue extends Value {
  private int _data;
  // ...
  public separable Code<Value> lift() {
    final int lfData = _data; // hack to help the Mint compiler
    return <| (Value) new IntValue(lfData) |>;
  }
}

public class BooleanValue extends Value {
  private boolean _data;
  // ...
  public separable Code<Value> lift() {
    final boolean lfData = _data; // hack to help the Mint compiler
    return <| (Value) new BooleanValue(lfData) |>;
  }
}

// ...

public class Val implements Exp {
  private Code<Value> _value;
  public Val(final Value value) {
    _value = value.lift(); // lifting here
  }
  // ...
}

and the new code that doesn't require the lift method anymore:

public abstract class Value implements CodeFree, Serializable {
  public separable int intValue() { throw new WrongTypeException(); }
  public separable boolean booleanValue() { throw new WrongTypeException(); }
  public separable abstract boolean valueEq(Value other);
}

public class IntValue extends Value {
  private int _data;
  // ...
}

public class BooleanValue extends Value {
  private boolean _data;
  // ...
}

// ...

public class Val implements Exp {
  private Code<Value> _value;
  public Val(final Value value) {
    _value = <| value |>; // straight-forward CSP
  }
  // ...
}

Please note that a class used in CSP still needs to be serializable if the code object it is used in is to be saved using MintSerializer.save. That means that whenever you implement CodeFree, you should consider also implementing the java.io.Serializable interface.

The second change involves the way checked exceptions are thrown inside a code object. In the past, checked exceptions were not allowed, because the Code.run() method did not have a throws Throwable clause.

We still didn't add such a clause, because it would essentially require a try-catch construct around every call to Code.run(). Instead, checked exceptions are caught and rethrown wrapped in a edu.rice.cs.mint.runtime.CheckedExceptionInCode unchecked exception. Here is an example:

public static separable void m() throws IOException {
  new File("/this/is/a/bad/path").createNewFile(); // throws IOException
}

// ...

SafeCode<Void> c = <| { m(); } |>;
try {
  c.run();
}
catch(CheckedExceptionInCode ce) {
  Throwable cause = ce.getCause();
  // ...
}

We also improved error checking for calls to separable methods and fixed a bug that required SafeCode<T> in too many places.

The version of DrJava with Mint is based on the current trunk (and therefore is newer than the updated stable release of DrJava that was recently made available).

New Mint Release: r15772

2010-09-16T13:40:00.000-07:00

We have just made a new release of Mint and DrJava with Mint: September 16, 2010 (r15772). The latest release is, as always, available from the Mint implementation page:

We have added the edu.rice.cs.mint.runtime.MintSerializer class to it that can write code object, including CSP data, to a jar file (or whatever stream you like), and then restore it again. Here is a very simple example:

Code c = <|123|>;
File f = new File(dir, "IntegerCode1.jar");
MintSerializer.save(c, "IntegerCode1", f);
        
Integer s = MintSerializer.load(f);
System.out.println(s);

The version of DrJava with Mint is based on the current trunk (and not on updated stable release of DrJava that was made available this week).

Mint on the Mac

2010-09-01T10:55:00.000-07:00

I guess I'm a bit behind the technology curve. The MacBook that I'm using as one of my development machines is one of the original white Intel MacBooks with a Core Duo CPU (not Core 2 Duo). It's a 32-bit machine, and Apple doesn't offer Java 6 for 32-bit computers.

Mint, however, requires a version of Java 6, which is why we recommended using SoyLatte to run Mint. That comes with all kinds of inconveniences because SoyLatte uses X11 for its GUIs, which means DrJava needs to run under X11.

Yesterday I tested Mint and DrJava with Mint using Apple's Java SE 6.0 Release 1 Developer Preview 6 (file name: javase6release1dp6.dmg), which I still had floating around and which is the last version of Apple's Java 6 that still runs on 32-bit Macs. It works! SoyLatte is only required if you don't have a version of Java 6 (either Apple's official version on 64-bit Macs, or Apple's Java SE 6.0 Release 1 Developer Preview 6 on 32-bit Macs) on your Mac.

I have updated the instructions on how to install Java Mint on the Mac and how to run DrJava with Mint accordingly.

New Mint Release: r15716

2010-08-30T10:34:00.000-07:00

As mentioned before, Eddy and I discovered a problem with type variables in code generated by the Mint compiler. We have now fixed this problem in the new release of Mint and DrJava with Mint: August 30, 2010 (r15716). The latest release is, as always, available from the Mint implementation page:

The problem occurred when the programmer used a type variable inside a bracket. An example of this would be a generic method like this:

public separable <X> Code<X> fun(Code<X> c1, Code<X> c2) {
return <| ( `(lfTest.eval(e,f).booleanCodeValue()) ?
              `c2 : `c1 )  |>;
}

This caused Mint to generate 2nd stage code that contained the type variable X unbound. Unfortunately, the types are erased, and there is no way to find out what type X actually refers to at runtime, e.g. by writing something like X.class (this generates the Java compiler error "cannot select from a type variable").

To get around this problem, we now require a final instance of type Class<X> to be in scope for every type variable X. For example, in the generic method above, there is a type variable X that is being used in the bracket. Therefore, we now have to have a final instance of Class<X>somewhere in scope, for example as a method parameter.

public separable <X> Code<X> fun(Code<X> c1, Code<X> c2,
                                 final Class<X> xc) {
return <| ( `(lfTest.eval(e,f).booleanCodeValue()) ?
              `c2 : `c1 )  |>;
}

That's all that is necessary. The variable xc is not actually used in the code, it just needs to be in scope.

New Mint Release: r15707

2010-08-24T14:52:00.000-07:00

When working on our GPCE tutorial, Eddy and I discovered a small bug in the Mint compiler which I have now fixed in the new release of Mint and DrJava with Mint: August 24, 2010 (r15707). The latest release is, as always, available from the Mint implementation page:

The only change I made was to fix the let expression pretty printer when the expression contained more than one declaration.

The problem never came up before because we only had one declaration per let expression, and it was always possible to rewrite

let int x = 1, y = 2; x+y

let int x = 1; let int y = 2; x+y

We are pushing the Mint compiler more, and we have discovered another problem with generic methods. Currently, Mint generates a class extending Code<X> with X occurring unbound when this method is called:

public separable abstract <X> Code<X> fun(Code<X> c1, Code<X>
c2, Object... param);

We are looking at making another bugfix soon.

New Mint Release: r15700

2010-08-20T22:16:00.001-07:00

On Friday, I created a new release of Mint and DrJava with Mint: August 20, 2010 (r15700). The latest release is, as always, available from the Mint implementation page:

The only changes that we made were a small change to the build process on Mac OS, and the addition of the Range and Lift utility classes.

The Lift class allows the user to manually lift primitive values and strings when the compiler did not do that already, for example when working with arrays.

The Range class provides methods that allow many for loops to be written as foreach loops with a final loop variable that can be used across bracket boundaries immediately. Consider this example of a staged sparse matrix multiplication:

public static separable
Code<Void> smmult(final double[][] a,
                  Code<double[][]> b,
                  Code<double[][]> output,
                  int l, int m, int n) {
  Code<Void> stats = <| { } |>;
  for(final int i: range(0, l)) {
    for(final int j: range(0, m)) {
      Code<Double> c = <| 0.0 |>;
      for(final int k: range(0, n)) {
        if(a[i][k] == 0.0)
          continue;
        else if(a[i][k] == 1.0)
          c = <| `c + (`b)[k][j] |>;
        else
          c = <| `c + (`(lift(a[i][k])) * (`b)[k][j]) |>;
      }
      stats = <| { `stats; (`output)[i][j] = `c; } |>;
    }
  }
  return stats;
}

is a lot cleaner than

public static separable
Code<Void> smmult(final double[][] a,
                  Code<double[][]> b,
                  Code<double[][]> output,
                  int l, int m, int n) {
  Code<Void> stats = <| { } |>;
  for(int i = 0; i < l; i++) {
    for(int j = 0; j < m; j++) {
      final int ii = i;
      final int jj = j;
      Code<Double> c = <| 0.0 |>;
      for(int k = 0; k < n; k++) {
        final int kk = k;
        if(a[i][k] == 0.0)
          continue;
        else if(a[i][k] == 1.0)
          c = <| `c + (`b)[kk][jj] |>;
        else
          c = <| `c + (`(lift(a[ii][kk])) * (`b)[kk][jj]) |>;
      }
      stats = <| { `stats; (`output)[ii][jj] = `c; } |>;
    }
  }
  return stats;
}

The ii, jj, and kk variables aren't necessary anymore.

GPCE'10 Tutorial Lecture: Agile and Efficient Domain-Specific Languages using Multi-stage Programming in Java Mint

2010-08-16T12:37:00.001-07:00

Eddy, Walid, and I proposed a tutorial lecture for GPCE'10, and we're delighted to report that it has been accepted for presentation on Sunday, October 10, 2010.

Agile and Efficient Domain-Specific Languages using Multi-stage Programming in Java Mint

Domain-specific languages (DSLs) are a powerful productivity tool because they allow domain experts, who are not necessarily programming experts, to quickly develop programs. DSL implementations have unique constraints for programming languages because they must be efficient, in order to ensure high productivity, but they must also be agile, in order to meet the rapidly changing demands of their domains. In this tutorial we show how multi-stage programming (MSP) can be used to build staged interpreters, which combine the agility of interpreters with the efficiency of compilers. The tutorial is conducted in Java Mint, an multi-stage Java based on recent work incorporating MSP into imperative object-oriented languages. In the first half of the tutorial, we introduce MSP by demonstrating how to write a staged interpreter for a number of basic language constructs, such as recursive functions, conditionals, and let expressions. In the second half, we extend our staged interpreter to take advantage of several well-known compiler optimizations, including type inference, constant folding, and static parallel loop scheduling. We highlight the opportunities afforded by using MSP with object-oriented design to quickly create efficient DSL implementations.

Brief Outline of Tutorial

This tutorial uses Java Mint to introduce MSP in imperative,
object-oriented languages. We will progress as follows:

Introduction to MSP, the three language constructs "bracket",
"escape" and "run", and their use in Java Mint.
Brief overview of MSP applications other than interpreters.
Development of a staged interpreter for a small DSL. We incrementally add:
1. Arithmetic expressions
2. Conditionals
3. Recursive functions
4. Let expressions
Application of compiler optimizations in the interpreter for our DSL. We discuss:
1. Extending the interpreter with multiple data types
2. Type inference
3. Constant folding
4. Static parallel loop scheduling

Biographies

Mathias Ricken is a doctoral candidate in the Programming Languages Team at Rice University and one of the principal developers of the DrJava integrated development environment. His research interests include concurrent programming, extending the Java language, and computer science education. He is the developer of the Concutest concurrent unit testing framework and has created various experimental extensions of Java to address, for instance, programming with meta-data. Currently, Mathias is contributing to Java Mint, a multi-stage extension of Java that allows safe and expressive statically typed program generation and specialization in an imperative language setting.

Edwin Westbrook is a post-doctoral researcher at Rice University. His primary interests are in developing techniques for implementing and verifying properties of domain-specific languages (DSLs). He has worked on a number of projects in this area, including: Cinic, a type theory for building machine-checked proofs of properties of DSLs using a new approach to higher-order abstract syntax; Java Mint, a multi-stage version of Java used for efficient implementations of DSLs; and Acumen, a DSL for designing cyber-physical systems.

Walid Taha is an professor at Halmstad University. His current interest is in modeling and simulation of cyberphysical systems. He was the principal investigator on a number of research awards and contracts from the National Science Foundation (NSF), Semi-conductor Research Consortium (SRC), and Texas Advanced Technology Program (ATP). He received an NSF CAREER award to develop Java Mint. He is the principle designer Java Mint, Acumen, MetaOCaml, and the Verilog Preprocessor. He founded the ACM Conference on Generative Programming and Component Engineering (GPCE), the IFIP Working Group on Program Generation (WG 2.11), and the Middle Earth Programming Languages Seminar (MEPLS). In 2009, he chaired the IFIP Working Conference on Domain Specific Languages (DSLs).

New Version of DrJava with Mint: drjava-r5366-mint-r15665

2010-08-16T12:23:00.000-07:00

The DrJava team released a new stable version of DrJava today, drjava-stable-20100816-r5366.

I therefore created a new release of DrJava with Mint: August 16, 2010 (drjava-r5366-mint-r15665.jar). The latest release is available from the Mint implementation page:

Nothing has changed on the Mint language side.

New Mint Release: r15665

2010-07-29T13:24:00.000-07:00

I just created a new release of Mint and DrJava with Mint: July 28, 2010 (r15665). It's been over a year since we made the first version of Mint available! The latest release is, as always, available from the Mint implementation page:

Nothing really changed in the Mint language or in the way Mint is implemented; however, we moved our modified javac compiler into subpackages of the edu.rice.cs.mint.comp package, which means that the compiler is now invoked using the edu.rice.cs.mint.comp.com.sun.tools.javac.Main class.

The package and class names got a bit long, but by not using the same class names as Sun/Oracle, we can use our compiler together with other compilers or the original compiler if we want to, and there won't be any class name clashes.

New Mint Release: r15637

2010-07-22T15:55:00.000-07:00

I just created a new release of Mint and DrJava with Mint: July 22, 2010 (r15637). It's been over a year since we made the first version of Mint available! The latest release is, as always, available from the Mint implementation page:

The DrJava team released a third beta version of DrJava almost two weeks ago, drjava-beta-20100711-r5314.

The only thing that changed on the Mint language side is the implementation of the toString() method for brackets.

There have a been plenty of new features and bugfixes for DrJava, and they have been integrated into DrJava with Mint. In fact, DrJava with Mint includes a few bugfixes that are not yet in the latest beta of DrJava.

New Version of DrJava with Mint: drjava-r5246-mint-r15405

2010-07-11T21:06:00.001-07:00

The DrJava team released a third beta version of DrJava today, drjava-beta-20100711-r5314.

I therefore created a new release of DrJava with Mint: May 8, 2010 (r15405). The latest release is available from the Mint implementation page:

Nothing has changed on the Mint language side.

New Mint Release: r15405

2010-04-15T17:15:00.000-07:00

I just created a new release of Mint and DrJava with Mint: May 8, 2010 (r15405). The release is available from the Mint implementation page:

The DrJava team released a second beta version of DrJava yesterday, drjava-beta-20100507-r5246.

Nothing has changed on the Mint language side, but there have been minor changes in the Mint build process, and several examples have been added.

There have been plenty of new features and bugfixes for DrJava, and they have been integrated into DrJava with Mint. Most importantly, DrJava with Mint will now automatically select the Mint compiler on start-up.

Camera-Ready Version of PLDI Paper Submitted

2010-03-24T16:58:00.000-07:00

This afternoon, I submitted the final camera-ready version of our Mint paper that was accepted to PLDI 2010, Mint: Java Multi-stage Programming Using Weak Separability.

Eddy and I incorporated some more suggestions we had received from Julia Lawall and Sam Kamin, who sacrificed their valuable pre-OOPSLA submission time to proof-read our paper again. Thank you so much!

I'm glad that I could sign the copyright release form by myself, and that I didn't need to get the signatures of my five co-authors. That could have been a big headache: Walid is here, but I didn't see him today; Eddy and Jun are in Oxford; Yilong is an undergrad at Rice, and I haven't seen him in months; and Tamer is in Egypt. I enjoy signing other people's rights away.

All of that is done now. I think the paper got better still, and we even managed to stay six lines under the limit of twelve pages!

Camera-ready version: Mint: Java Multi-stage Programming Using Weak Separability (PDF)

Mint Talk at Purdue

2010-03-04T16:14:00.000-08:00

I'm visiting my friend Luke at Purdue after SIGCSE, and we arranged for me to give a talk to the CS department.

If you have the chance, come grill me on Monday, March 15, 2010 at 3:30 PM.

Computer Science Colloquia
Mint: A Multi-stage Extension of Java
Mr. Mathias Ricken
Rice University
LWSN 3102 A/B
Monday, March 15, 2010
3:30 p.m. - 4:30 p.m.

Complete Description:
Abstract:
Multi-stage programming (MSP) provides a safe way of generating code at run-time. In mostly-functional languages like MetaOCaml, this has been used to reduce the performance penalties of abstractions such as loops, recursion or interpretation. The main advantage of MSP compared to other techniques, such as string or LISP quotations, is that MSP guarantees type safety for the generated code statically, at the time the program is compiled.

Unfortunately, MSP is difficult to combine with imperative features found in most mainstream languages like Java. The central problem is "scope extrusion", which may accidentally move variables outside the scopes in which they are bound, leading to run-time errors in the generated code. This problem can be prevented if code in escapes (or "anti-quotes") is "weakly separable", i.e. the computational effects occurring inside an escape that are visible from the outside do not involve code.

We have formalized a type system, based on Lightweight Java, that uses weak separability to prevent scope extrusion, and we have proved that the type system is sound. We have also developed an implementation called Mint to demonstrate the expressivity of the type system and the performance benefits MSP can provide in an imperative setting. Since our implementation extends the Java language, our work is accessible to mainstream programmers.

This talk is based on work will be presented at the Conference on Programming Language Design and Implementation (PLDI 2010). More information is available at http://mint.concutest.org/

Bio:
Mathias Ricken is a doctoral candidate in the Programming Languages Team at Rice University and one of the principal developers of the DrJava integrated development environment. His research interests include concurrent programming, extending the Java language, and computer science education. He is the developer of the Concutest concurrent unit testing framework and has created various experimental extensions of Java to address, for instance, programming with meta-data. Currently, Mathias is contributing to Mint, a multi-stage extension of Java that allows safe and expressive statically typed program generation and specialization in an imperative language setting.

Faculty and students wishing to speak privately with Mr. Ricken should contact Jan Vitek at jv@cs.purdue.edu.

This is going to be exciting!

Mathias' Mint Talk

2010-02-22T19:44:00.000-08:00

On February 8, Mathias gave a talk about Mint in the COMP 600 graduate seminar at Rice. The slides for "Mint: A Multi-stage Extension of Java" and the video recording are available now:

Slides (PDF)
Slides (PowerPoint)
Video Recording (on vimeo, requires Flash)

Abstract:

Multi-stage programming (MSP) provides a safe way of generating code at run-time. In mostly-functional languages like MetaOCaml, this has been used to reduce the performance penalties of abstractions such as loops, recursion or interpretation. The main advantage of MSP compared to other techniques, such as string or LISP quotations, is that MSP guarantees type safety for the generated code statically, at the time the program is compiled.

Unfortunately, MSP is difficult to combine with imperative features found in most mainstream languages like Java. The central problem is "scope extrusion", which may accidentally move variables outside the scopes in which they are bound, leading to run-time errors in the generated code. This problem can be prevented if code in escapes (or "anti-quotes") is "weakly separable", i.e. the computational effects occurring inside an escape that are visible from the outside do not involve code.

We have formalized a type system, based on Lightweight Java, that uses weak separability to prevent scope extrusion, and we have proved that the type system is sound. We have also developed an implementation called Mint to demonstrate the expressivity of the type system and the performance benefits MSP can provide in an imperative setting. Since our implementation extends the Java language, our work is accessible to mainstream programmers.

This talk is based on work done in collaboration with Edwin Westbrook, Jun Inoue, Yilong Yao, Tamer Abdelatif, and Walid Taha. A paper titled Mint: Java Multi-stage Programming Using Weak Separability has been accepted for publication in the Proceedings of the 2010 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2010).

New Mint Release: r15116

2010-02-17T19:22:00.000-08:00

I just created a new release of Mint and DrJava with Mint: February 17, 2010 (r15116). The release is available from the Mint implementation page:

There were some small changes in the approximation of weak separability to make the implementation match improvements in the paper more closely. It also disallows stitching in a Code<?> as a statement, because we can't statically know if we have to discard the result in a statement context or not.

New Mint Release: r15085

2010-02-12T08:27:00.000-08:00

I just created a new release of Mint and DrJava with Mint: February 12, 2010 (r15085). The release is available from the Mint implementation page:

The two changes since the last release involve CSP values and escapes in bracket statements. Instead of storing CSP values in a CSP table, we now store CSP values in individual fields. This reduces the overhead by eliminating an array lookup. The serializer benchmark benefited from this, for example.

We now also allow non-void escapes in bracket statements. For example, the following code is now allowed:

Code<Integer> x = <| 1 |>;
Code<void> c = <| { `x } |>;

In the past, this caused an error because 1 was not a statement. The Mint compiler now accepts this and discards the result of the escape if it is used in statement form, but it does emit a warning.

Great News

2010-02-08T12:29:00.000-08:00

Our paper, "Mint: Java Multi-stage Programming Using Weak Separability" (pre-print PDF), has been accepted to PLDI 2010. We look forward to spreading the word about Mint in Toronto!

Mathias just gave the first presentation about Mint in the COMP 600 graduate seminar at Rice. The slides for "Mint: A Multi-stage Extension of Java" are available (PDF).

Finally, you may already have noticed that the blog has a new URL: www.javamint.org. We currently also have some problems with the implementation URL; for now, you can use http://mint.concutest.org as a resource hub for everything Mint-related.

New Mint Release

2009-11-13T20:40:00.000-08:00

I just created a new release of Mint and DrJava with Mint.

There were some dramatic performance improvements in the Mint compiler thanks to base type lifting instead of performing cross-stage persistence for them. I also fixed a bug that didn't allow escaping into bracket statements. And DrJava with Mint now has a simple logo (mostly so I don't get confused if I'm working with DrJava with Mint or with regular DrJava).

Lifting for Primitive and Boxed Types and Strings

2009-11-04T09:43:00.000-08:00

When we examined the code that was generated for the sparse matrix multiplication benchmark of Mint, we noticed that variables containing loop indices had become cross-stage persistent (CSP) variables, which necessitated an array lookup. This was much more expensive than directly accessing a final local variable.

I have now implemented lifting for primitive and boxed types as well as for strings. For example, the code

final int i = 1;
Code c = <| i |>;

used to generate code that looked like this:

public class $$Code1$$
    implements edu.rice.cs.mint.runtime.Code {
    private Object [] $csp_table;
    public $$Code1$$ (Object [] csp_table) {
        this.$csp_table = csp_table;
    }
    public Integer run() {
        return $csp_table[0];
    }
}

Even though the value of i was final, we retrieved the value from the CSP table. Now we lift this value, i.e. we create a code object for it and escape it into the bracket using a edu.rice.cs.mint.runtime.Lift.liftint helper method:

public class Lift {
  Code liftint(int value) { ... }
}

The compiler internally transforms

Code c = <| i |>;

into an escape-and-lift that looks like

Code c = <| `(edu.rice.cs.mint.runtime.Lift.liftint(i)) |>;

Now the code that is generated looks as expected:

public class $$Code1$$
    implements edu.rice.cs.mint.runtime.Code {
    private Object [] $csp_table;
    public $$Code1$$ (Object [] csp_table) {
        this.$csp_table = csp_table;
    }
    public Integer run() {
        return 1;
    }
}

This has lead to nice performance improvements in the matrix multiplication and loop unrolling benchmarks, and (perhaps more spectacularly) also in the Lint interpreter benchmarks. The staged Lint interpreter benchmarks now run 20 times as fast as the unstaged versions. Matrix multiplication shows a speedup of a factor of 4.8, and loop unrolling has a speedup of 2.3.

There is a new release of the Mint implementation (November 4, 2009) and a new version of DrJava with Mint (drjava-r5128-mint-r14460).

New Version of DrJava with Mint

2009-10-19T22:04:00.000-07:00

I just made a new release of the all-in-one DrJava with Mint:

drjava-r5121-mint-r14186.jar

On the Mint side, there is only one small change: Previously, the Mint compiler only appeared in the "Compiler" drop-down box if the "Display all compiler versions" preference was enabled, which by default was not the case.

Happy experimentation with Mint!

All in One File!

2009-10-05T08:20:00.000-07:00

After integrating Mint into DrJava last week, we have now made it even simpler to experiment with Mint: You can download a copy of DrJava that already includes the Mint compiler, all in one file:

DrJava with Mint (check the implementation page for newer versions)

That means on Windows and Linux, provided you have installed the JDK 6, you can just double-click on the jar file or start it using
java -jar drjava-r5104-mint-r14185.jar

On MacOS, you still need to install Soylatte and X11 as described in the previous post, but you don't need to set up Mint. Just run it with
java -jar drjava-r5104-mint-r14185.jar
using Soylatte under X11.

This DrJava with Mint jar file doesn't give you the mintc and mint command line utilities, but you can edit, compile and run Mint programs in DrJava. This is probably the easiest way to experiment with Mint!

Note: We recommend that you disable DrJava's auto-update feature when using the DrJava with Mint jar file. The auto-update would otherwise download new versions of DrJava without integrated Mint. Please go to Edit -> Preferences, select the Notifications category, and set "Check for new versions?" to "none (disabled)".

DrJava with Mint Released

2009-09-28T22:18:00.000-07:00

The latest releases of DrJava contains a compiler adapter for Mint. That means it is possible to conveniently compile Mint programs in the DrJava IDE.

To experiment with Mint and DrJava, please do the following:

Download DrJava with Mint from the JavaMint implementation page. The file will be named drjava-rxxxx-mint-ryyyyy.jar, where xxxx indicates the version of DrJava and yyyyy the version of Java Mint.

MacOS only: Java Mint requires Java 6. If you have a 32-bit Mac for which Apple does not offer Java 6, you can use Soylatte, but that means DrJava needs to be run under Soylatte as well. Soylatte requires X11 to display graphical user interfaces (GUIs).
1. Change your PATH environment variable so that Soylatte's java and javac commands are found first. Edit your .bash_profile or .bashrc file and add the following line at the end of the file:
  export PATH=/usr/local/soylatte/bin:$PATH
2. Install Apple's X11. You can find it on your MacOS X installation DVD (preferred!). Here are also some links where you may download X11 (not checked by us -- if you try any of these, please let us know!):
  - 2.4.0 for Mac OS 10.5 and newer
  - 1.1.2 for Mac OS 10.4.8 and newer
  - 1.0 for Mac OS 10.3 to 10.3.9
  - You should also be able to install XFree86 using Fink.
3. Start the X11 application. A terminal window should open. Put the cursor in that terminal window -- you will start DrJava from there.

Start DrJava using
java -jar drjava-rxxxx-mint-ryyyyy.jar(in the terminal window on MacOS and Linux; on Windows, you can double-click on the drjava-rxxxx-mint-ryyyyy.jar file)

Look at the right side of the in the "Compiler Output" pane. There is a drop-down box labeled "Compiler": Select "Mint 6.0_16-Mint" (or something similar). If you don't see it in the list, DrJava could not find Mint. Check that you are running DrJava with Java 6.

Open a Mint program ("File/Open" menu or "Open" button)

Compile it ("Tools/Compile All" menu or "Compile" button)

Run it ("Tools/Run Document's Main Method" menu or "Run" button). The output will be displayed in the "Interactions" pane.

Note that the interpreter in the Interactions pane does not understand Mint. It is just a Java interpreter. Brackets and escapes are only recognized in programs in the Definitions pane (source editor).

Installing JavaMint on Linux

2009-09-24T13:09:00.000-07:00

Here are some quick instructions on how to download and install Java Mint.

MacOS

You need Sun's JDK 5 or 6 installed.
Download the "binaries only" Java Mint zip file from the Java Mint implementation page. In this example, I have saved the file in my home directory, i.e. at /home/mgricken.
Open a console.
Change into the /usr/local directory:
cd /usr/local
Unzip it as root. This means you have to type in your password:
sudo unzip /home/mgricken/JavaMint-r13871-binaries.zip
Set the MINT_HOME and PATH environment variables:
export MINT_HOME=/usr/local/JavaMint export PATH=$PATH:$MINT_HOME/langtools/bin
To make this permanent, edit your .bash_profile or .bashrc file and put the two lines from step 6 line at the end of the file.

Now you can compile programs using mintc and run them using mint.

mintc Power.java

mint Power

Higher Order Functions in Java

2009-09-14T10:25:00.001-07:00

In order to understand future examples, we first have to discuss how to use higher-order functions in Java, and how to write anonymous inner classes. This post will have nothing to do with multi-stage programming.

Let's write a program that can print out data tables for different mathematical functions. For example, for a function that multiplies by two, f(x) = 2x, we want to print something like this:

x                      f(x)
       -5.0000000000       -10.0000000000
       -4.0000000000        -8.0000000000
       -3.0000000000        -6.0000000000
       -2.0000000000        -4.0000000000
       -1.0000000000        -2.0000000000
        0.0000000000         0.0000000000
        1.0000000000         2.0000000000
        2.0000000000         4.0000000000
        3.0000000000         6.0000000000
        4.0000000000         8.0000000000
        5.0000000000        10.0000000000

We can write a function like this:

    public static void printTableTimesTwo(double x1,
                                          double x2,
                                          int n) {
        assert n>1;

        double x = x1;
        double delta = (x2-x1)/(double)(n-1);
        System.out.println("x                      f(x)");
        System.out.printf("%20.10f %20.10f\n", x, x*2);
        for(int i=0; i<(n-1); ++i) {
            x += delta;
            System.out.printf("%20.10f %20.10f\n", x, x*2);
        }
    }

The parameter x1 determines the lower end of the interval, x2 the upper end, and n determines how many values should be printed. n needs to be at least 2 to print out the values at x1 and x2. We can generate the table above with this call:

        printTableTimesTwo(-5, 5, 11);

What if we want to print out the values of a different function, for example f(x) = x + 4? We can write a new function:

    public static void printTablePlusFour(double x1,
                                          double x2,
                                          int n) {
        assert n>1;

        double x = x1;
        double delta = (x2-x1)/(double)(n-1);
        System.out.println("x                      f(x)");
        System.out.printf("%20.10f %20.10f\n", x, x+4);
        for(int i=0; i<(n-1); ++i) {
            x += delta;
            System.out.printf("%20.10f %20.10f\n", x, x+4);
        }
    }

This involves a lot of code duplication, though. The only parts that actually differ are the two occurrences of x*2 and x+4. How can we factor that difference out?

Let's write an interface that we can use for any kind of function that takes in one parameter and returns one parameter f(x) = y is an example of such a function.

public interface ILambda<R,P> {
    public R apply(P param);
}

This interface is called ILambda and it has one method, apply. We used Java generics and didn't specify the return type and the type of the parameter; instead, we just called them R and P, respectively. A function that takes in a Double and that returns a Double, like f(x) = y, can be expressed using a ILambda<Double,Double>. A function taking a String and returning an Integer would use ILambda<String,Integer>.

Now we can write our f(x) = 2x and f(x) = x + 4 functions using ILambda:

    public class TimesTwo implements ILambda<Double,Double> {
        public Double apply(Double param) { return param*2; }
    }
    public class PlusFour implements ILambda<Double,Double> {
        public Double apply(Double param) { return param+4; }
    }

Now we can write one printTable method that takes in an ILambda<Double,Double> called f representing the function, in addition to the parameters x1, x2 and n, as before:

    public static void printTable(ILambda<Double,Double> f,
                                  double x1,
                                  double x2,
                                  int n) {
        assert n>1;

        double x = x1;
        double delta = (x2-x1)/(double)(n-1);

        // f.apply(x) just means what f(x) means in math!
        double y = f.apply(x);
        System.out.println("x                      f(x)");
        System.out.printf("%20.10f %20.10f\n", x, y);
        for(int i=0; i<(n-1); ++i) {
            x += delta;
            y = f.apply(x);
            System.out.printf("%20.10f %20.10f\n", x, y);
        }
    }

Note that when we want to print out the y-value, we just write f.apply(x), which looks very similar to f(x) in mathematics. It means exactly the same.

We can print out the tables for our two functions using:

        printTable(new TimesTwo(), -5, 5, 11);
        printTable(new PlusFour(), -5, 5, 11);

We have to create new objects for the functions: The first time we call printTable we pass a new TimesTwo object; the second time, we pass a new PlusFour object.

We can now define as many functions as we like without having to rewrite the printTable function. For example, we can easily write a square root function and use it very easily:

    public class SquareRoot implements ILambda<Double,Double> {
        public Double apply(Double param) {
            return Math.sqrt(param);
        }
    }

// ...

        printTable(new SquareRoot(), -5, 5, 11);

The really neat thing is that we can even define a new function on-the-fly, without having to give it a name. We do that using anonymous inner classes in Java. Here, we call printTable and pass it a new object that implements ILambda<Double,Double>.

        printTable(new ILambda<Double,Double>() {
            public Double apply(Double param) {
                return param*param;
            }
        }, -5, 5, 11);

We define a new ILambda from Double to Double without giving it a name. When we use anonymous inner classes, we need to fill in all the methods that are still abstract. Here, it is just the apply method.

The method printTable is now a "higher order function", because conceptually it is a function that takes another function as input.

Questions:

What does the anonymous ILambda<Double,Double> in the example above compute? What's the mathematical function it represents?

How would you print a table for the function f(x) = x² + 2x?

You can download the complete source code for the examples here:

HigherOrder1.java: Example without ILambda

HigherOrder2.java: Example with ILambda

ILambda.java: ILambda interface for the HigherOrder2.java example

Power Using a for Loop

2009-09-09T05:41:00.000-07:00

Soon it will be possible to compile and run Mint programs in
DrJava. I just haven't had time to finish this. In the meantime, here is a program that you can analyze. It is another program that calculates the power x^n.

import edu.rice.cs.mint.runtime.Code;


public class Power_For {
   public static void main(String[] args) {
       final double x = 2;
       int n = 17;

       Code<Double> c = <| 1.0 |>;
       for(int i=0; i<n; ++i) {
           c = <| `c * x |>;
       }

       System.out.println(c.run());
   }
}

This time it uses a for loop. I don't know if you have seen for loops, but the part

for(int i=0; i<17; ++i) { /* something here */ }

sets a variable i to 0, and repeats the part /* something here */ as long as i<n. Each time the loop is done with /* something here */, it will execute ++i, which will increase i by 1. So eventually i will be 17, and since n is 17, i is not < n anymore, and the loop exits.

We have a Code<Double> c that starts out with the code for 1.0:

Code<Double> c = <| 1.0 |>;

Then we have the aforementioned for loop. The code that gets executed
over and over in the loop body is

c = <| `c * x |>;

We are creating a new code value, and inside the code value, we're splicing in c (initially 1.0) and multiplying it with x. Then we assign the new code value back to c. That means after the first
iteration of the loop, c will be the following:

<| 1.0 * x |>

After the second iteration, c will be

<| 1.0 * x * x |>

And so on. After the 17th iteration, it will contain the code

           <| 1.0 * x * x * x * x * x * x * x * x * x * x * x * x * x
* x * x * x * x |>

When we run c with c.run() and print out the value, we will get 131072.0, which is 2 to the power of 17, as expected.

You can download the complete source code for the example here:

Power_For.java: Multi-stage Power function using a for Loop

Installing JavaMint on Windows

2009-09-04T22:28:00.000-07:00

Here are some quick instructions on how to download and install Java Mint.

Windows

You need Sun's JDK 6 installed.
Download the "binaries only" Java Mint zip file from the Java Mint implementation page. In this example, I have saved the file on my desktop, i.e. at C:\Program Files.
Open an Explorer Window and find the zip file you saved in step 2.
Right-click on the zip file and choose "Extract All..." and unpack all files in C:\Program Files. This will create a C:\Program Files\JavaMint directory. If you don't see an "Extract All..." option in your context menu, you may need to download a program such as WinZip or WinRar first.
Right-click on "My Computer" and select "Properties". Go to the "Advanced" tab and press the "Environment Variables" button.
Click on the “New” button in the “System variables” box.
Enter as variable name: MINT_HOME
and as variable value: C:\Program Files\JavaMint
Find the Path variable in the "System variables" box, select it and click "Edit".
Go to the end of the text entered for "Variable value", and add the following text:
;%MINT_HOME%\langtools\bin
Be sure to enter the semicolon at the beginning of the added text.
Press "OK" three times to close all three opened dialogs. Now you have added JavaMint to your path.

Now you can compile programs using mintc and run them using mint. Open a Command Prompt by clicking on the "Start" button, selecting "Run" and entering cmd and pressing "OK" (or search for the "Command Prompt" program in your Start Menu).

mintc Power.java

mint Power

There are samples in the C:\Program Files\JavaMint\langtools\mintTest directory.

Installing JavaMint on MacOS

2009-09-04T12:22:00.000-07:00

Here are some quick instructions on how to download and install Java Mint.

MacOS

You need to have Java 6 installed.

Note: If you have a 32-bit Mac that does not have an Apple version of Java 6, you can use SoyLatte. Please install it in /usr/local/soylatte, i.e. the Java compiler should be /usr/local/soylatte/bin/javac.

Download the "binaries only" Java Mint zip file from the Java Mint implementation page. In this example, I have saved the file on my desktop, i.e. at /Users/mgricken/Desktop.
Open a console.
Change into the /usr/local directory:
cd /usr/local
Unzip it as root. This means you have to type in your password:
sudo unzip /Users/mgricken/Desktop/JavaMint-r13871-binaries.zip
Set the MINT_HOME and PATH environment variables:
export MINT_HOME=/usr/local/JavaMint export PATH=$PATH:$MINT_HOME/langtools/bin
To make this permanent, edit your .bash_profile or .bashrc file and put the two lines from step 6 line at the end of the file.

Now you can compile programs using mintc and run them using mint.

mintc Power.java

mint Power

There are samples in the /usr/local/JavaMint/langtools/mintTest directory. You cannot compile them there, however, because the directory is read-only unless you are the root user. So unzip the Java Mint implementation zip file somewhere else, e.g. in your Documents directory.

The easiest way to experiment with Mint is to download DrJava with Mint. Here are more instructions on how to run DrJava with Mint.

Note: If you are using SoyLatte as your Java 6, please start DrJava with Mint from inside an X11 terminal window.

Welcome!

2009-09-04T09:41:00.000-07:00

You've found the Java Mint Blog!

Despite all of our efforts not to use the name MetaJava for Java Mint, the domain JavaMint was already taken. So, the name MetaJava will live on! :)

This blog will be used to post announcements and useful materials relating to MetaJava, and to follow up on comments from readers.