Month: January 2015

Sublime Text 3 with Javatar

So we in the Bulgarian Java User Group wanted to build Valhalla, and no IDE (Eclipse, Intellij Idea) supports it. We needed some simple text editor with some java support. And Sublime Text 3 (with Javatar) is the one we chose.

Sublime is a fancy editor written in C and Python. Javatar is a plugin that adds some Java support.

Installing Sublime Text 3 beta is straight forward. Installing Javatar is:

[openjdk@localhost valhalla]$ cd ~/.config/sublime-text-3/Packages/
[openjdk@localhost Packages]$ git clone git://github.com/spywhere/Javatar.git

Setting up the correct java is: Ctrl+Shift+P --> "javatar" --> Javatar Settings - Default

Then change the javac and java locations:

Creating projects is a bit uneasy - create new project is actually called "Project -> Save as".

And then we can run some code (fist compile, then run):

[jug.bg] Valhalla hackaton (29.01.2015)

Today we had a second bgjug hackaton for the month. Its topic was Valhalla.

Project Valhalla will probably be part of Java 10 (expected 2018). Among other things it allows using primitives as generic arguments.

Here's how you can build Valhalla yourself.

Here's a virtual machine with valhalla if you're lazy (virtual box).

This is the valhalla presentation by Ivan. And this is the video of the talk (in Bulgarian).

IMG_3676

Here are some of the code we ran:

Ivan created a simple ArrayList

public class SpecialArrayList {
	private static int INITIAL_SIZE = 10;
 
	private T[] elements = null;
	private int length = 0;
 
	public SpecialArrayList() {
		elements = new T[INITIAL_SIZE];
	}
 
	public T get(int position) {
		if(position >= length) {
			throw new ArrayIndexOutOfBoundsException();
		}
 
		return elements[position];
	}
 
	public void add(T element) {
		// Check whether array is full
		elements[length] = element;
		length++;
	}
}
public class Main {
	public static void main(String[] args) {
		SpecialArrayList intList = new SpecialArrayList<>();
		intList.add(1);intList.add(2);intList.add(3);intList.add(4);
		System.out.println(intList.get(2));
 
		SpecialArrayList stringList = new SpecialArrayList<>();
		stringList.add("1");stringList.add("2");stringList.add("3");stringList.add("4");
		System.out.println(stringList.get(3));
	}
}

Nayden tested a bit of crazy code - which is supposed to fail (IA impl = new IAImpl();):

public class B  {
   protected T t;
   protected T[] ts;
   public B(){}
 
   public B(T t){
     this.t = t;
     this.ts = new T[100];
   //  System.out.println(this.t.getClass());
   }
 
   public T[] getTs(){
     return this.ts;
   }
 
   public T getT(){
     return this.t;
   }
 
   public static void main(String[] args){
       B b = new B<>(100);
       System.out.println(b.getT());
 
       System.out.println(b.getClass());
       System.out.println((new B("dada")).getClass());
       System.out.println(c.getClass());
 
       IAImpl ludnica = new IAImpl();
       ludnica.setT(100);
       System.out.println(ludnica.getT() instanceof Object);
 
       IABase base = new IAChild();
       base.setT("dada");
       System.out.println(base.getT());
       System.out.println(base.getClass());
 
       IA impl = new IAImpl();
 
       impl.setT("dada");
       System.out.println(impl.getT());
       System.out.println(impl.getClass());
   }
}
 
 
interface IA{
 public T getT();
 public void setT(T t);
}
 
 
class IABase{
 private T t;
 public T getT(){
   return this.t;
 }
 public void setT(T t){
   this.t = t;
 }
}
 
class IAChild extends IABase {
 
}
 
class IAImpl implements IA {
 private Object t;
 public Object getT(){
   return this.t;
 }
 public void setT(Object t){
   this.t = t;
 }
}

Building OpenJDK 9 on a OSX (or any linux)

This is a tiny tutorial on how to build your own copy of OpenJDK 9 from the current sources.

Contents

Preparation
├─Install a package system
├─Install ccache
└─Command Line Tools
Download OpenJDK 9
Build OpenJDK 9
JTREG
├─JTREG: The variables
└─Running tests
webrev

Preparation

Install a package system

Install brew or macports. I prefer brew. Both are package systems for OS X.

Install ccache

ccache is a compiler cache - speeds up the build.

$ brew install ccache

Command Line Tools

We need them so we have a C compiler and other tools.

Install Xcode Command Line tools ( you don't need the whole Xcode, only the command line tools)

Download OpenJDK 9

Get the sources, in the console type:

$ mkdir jkd9
$ cd jdk9
$ hg clone http://hg.openjdk.java.net/jdk9/dev jdk9.hg

Takes 10-20 secs. This downloads basically a couple of scripts that we will execute to get the actual sources.

Now we execute the script we downloaded:

$ cd jdk9.hg
$ chmod u+x get_source.sh
$ ./get_source.sh

The last command can can take 10-20 minutes depending on the connection speed.

Build OpenJDK 9

$ chmod u+x configure
$ ./configure
$ make clean images

The second command took a bit less than 20 minutes. The first command is fast.

The result: we have this created:  build/macosx-x86_64-normal-server-release/images/jdk/ - this is the built OpenJDK 9 - SUCCESS.

JTREG

jtreg is a "testing harness" (whatever that means) made specially for OpenJDK. We need it to run the tests written for the OpenJDK

Download from https://adopt-openjdk.ci.cloudbees.com/view/OpenJDK/job/jtreg/ (not the Snapshot version, the other one).

unzip in jdk9, so we have jdk9/jtreg.

JTREG: The variables

The official instructions suggest we edit ~/.bashrc. I don't like changing global (for your user) settings, so we can put these settings in jdk9/.bashrc

$ nano .bashrc

Add the following lines:

export SOURCE_CODE=/Users/steve/jdk9/
export JTREG_INSTALL=$SOURCE_CODE/jtreg/
export JT_HOME=$JTREG_INSTALL
export JTREG_HOME=$JTREG_INSTALL
export JPRT_JTREG_HOME=${JT_HOME}
export JPRT_JAVA_HOME=${PRODUCT_HOME}
export JTREG_TIMEOUT_FACTOR=5
export PRODUCT_HOME=$SOURCE_CODE/jdk9.hg/build/macosx-x86_64-normal-server-release/images/jdk
export PATH=$PATH:$PRODUCT_HOME/bin:$JT_HOME/linux/bin/

NOTE: Change /Users/steve/jdk9/ with your folder on the top line.
NOTE: Check the correctness of PRODUCT_HOME too.

To execute this file, do:

$ source .bashrc

Running tests

$ cd jdk9.hg/test
$ make jdk_util

Webrev

Webrev crawls over your changes to generate a set of web-based views of the differences in your code. The different views allow reviewers to easily look at your proposed changes, selecting the appropriate difference format based on the type of file, the type of change, and their own preferences.

webrev.ksh is a 70kb kshell script. Pretty weird.

Go to jdk9.hg and:

jdk9.hg# wget http://hg.openjdk.java.net/code-tools/webrev/raw-file/tip/webrev.ksh
jdk9.hg# chmod u+x webrev.ksh

To prepare a webrev, make some changes. For example in the jaxp folder. Then we commit locally in the mercurial repo.

jdk9.hg# cd jaxp
jaxp# hg commit -m "BGJUG: Fix compiler warnings in jaxp repository"
jaxp# ../webrev.ksh

It will prepare a webrev/ dir and webrev.zip. The folder is then uploaded somewhere and sent to the appropriate mail list inside openjdk. Example:
http://bgjug.sty.bz/bgjug/~bgjug/fix-warnings-jaxp-part1/webrev.00/

Note: execution times come are measured on a pretty recent Macbook Air.

Source: https://java.net/projects/adoptopenjdk/pages/AdoptOpenJDKBuildInstructions

[jug.bg] Building Valhalla and using primitives as generic arguments

Project Valhalla will probably be part of Java 10 (expected 2018). Among other things it allows using primitives as generic arguments.

Building Valhalla

On a linux/unix/osx box we start with:

hg clone http://hg.openjdk.java.net/valhalla/valhalla
cd valhalla
bash get_source.sh  #this one takes some time
bash configure
make clean images # this one takes some cpu

Box<int>

We can have a class like this:

public class Program  {
	public static void main(String[] args) {
		// this one still doesn't work, List not updated to List
//		List l = new ArrayList();
//		l.add(5);
//		System.out.println(l.get(0));
 
		Box b = new Box(6);
		System.out.println(b.get());
	}
}
 
class Box {
    private final T t;
    public Box(T t) { this.t = t; }
    public T get() { return t; }
}

javap

Running javap gives

$ javap -c Program.class gives:
[openjdk@localhost bin]$ ./javap -c Program.class 
Compiled from "Program.java"
public class Program {
  public Program();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return
 
  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class "Box${0=I}"
       3: dup
       4: bipush        6
       6: invokespecial #3                  // Method "Box${0=I}"."":(I)V
       9: astore_1
      10: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      13: aload_1
      14: invokevirtual #5                  // Method "Box${0=I}".get:()I
      17: invokevirtual #6                  // Method java/io/PrintStream.println:(I)V
      20: return
}

Running our pretty simple app gives:

[openjdk@localhost bin]$ ./java Program
Specializing Box${0=I}; searching for Box.class (not found)
Specializing Box${0=I}; searching for Box.class (found)
6
[openjdk@localhost bin]$

Notes: List is still not parameterized with because ... issues.