Embedded Typesafe Domain Specific Languages for Java

Embedded Typesafe DSLs for Java Jevgeni Kabanov Tech Lead, ZeroTurnaround jevgeni@zeroturnaround.com

ABOUT ME ZeroTurnaround Tech Lead Our flagship product is JavaRebel - a class reloading JVM plugin Double as the R&D lead of Webmedia, Ltd. Largest custom software developer in the Baltics Co-founder of Aranea Web Framework Personal blog at dow.ngra.de

Based on Research a rticle “Embedded Typesafe Domain Specific Languages for Java” by Jevgeni Kabanov & Rein Raudjärv Published at Principles and Practice of Programming in Java ' 08

OUTLINE DSLs and Fluent Interface Case study: Building SQL queries Case study: Java bytecode engineering

Domain Specific Language Small sub-language that has very little overhead when expressing domain specic data and behaviour Can be A fully implemented language A specialised API that looks like a sublanguage but still written using some general-purpose language – embedded DSL

Why bother? Low overhead You need to write less It is easier to understand Domain experts can understand it Type safety You can be sure that certain errors won’t occur You need to write less tests You can use type info to add features

Fluent Interface customer.newOrder() .with(6, "TAL") .with(5, "HPK").skippable() .with(3, "LGV") .priorityRush();

Java 5 features and EDSLs Java 5 has Parametric polymorphism (generics) Static method import Java 5 doesn’t have Closures or first-class functions Operator overloading Variable/parameter type inference

SQL Example (4 errors) StringBuffer sql = new StringBuffer() ; sql.append( "SELECT o.sum,(SELECT first_name,last_name" ); sql.append( " FROM person p" ); sql.append( " WHERE o.person_id=p.id) AS client" ); sql.append( " FROM order o" ); sql.append( "WHERE o.id = " +orderId); sql.append( " AND o.status_code IN (?,?)" ); PreparedStatement stmt = conn.prepareStatement(sql.toString()); stmt.setString(1, "PAID" ); //...

Typesafe SQL Example Person p = new Person() ; List<Tuple3<String, Integer, Date>> rows = new QueryBuilder(datasource) .from(p) .where( gt(p. height , 170)) .select(p. name , p. height , p. birthday ) .list(); for (Tuple3<String, Integer, Date> row : rows) { String name = row. v1 ; Integer height = row. v2 ; Date birthday = row. v3 ; System. out .println( name + " " + height + " " + birthday); }

Tuples R eturn tuples that have precisely the selected data with types known ahead Tuple types are inferred from the select expression (column) types

Tuple2 public class Tuple2<T1, T2> implements Tuple { public final T1 v1 ; public final T2 v2 ; public Tuple2(T1 v1, T2 v2) { this . v1 = v1; this . v2 = v2; } public T1 v1() { return v1 ; } public T2 v2() { return v2 ; } }

Typesafe Metadata Metadata used by your DSL should include compile-time type information. We make use of pregenerated metadata dictionary that contains type information about tables and columns

Metadata dictionary public class Person implements Table { public String getName() { return "person" ; } ; public Column<Person, String> name = new Column<Person, String>( this , "name" , String . class ) ; public Column<Person, Integer> height = new Column<Person, Integer>( this , "height" , Integer. class ) ; public Column<Person, Date> birthday = new Column<Person, Date>( this , "birthday" , Date. class ) ; }

Restricting Syntax At any moment of time the DSL builder should have precisely the methods allowed in the current state. SQL query builders allow from , where and select to be called once and only once only in valid order

QueryBuilder class QueryBuilder extends Builder { ... <T extends Table> FromBuilder<T> from(T table); }

FromBuilder class FromBuilder<T extends Table> extends Builder { ... <C1> SelectBuilder1<T, C1> select(Col<T, C1> c1); <C1, C2> SelectBuilder2<T, C1, C2> select(Col<T, C1> c1, Col<T, C2> c2); ... }

SelectBuilder class SelectBuilder2<T extends Table,C1,C2> extends SelectBuilder<T> { ... List<Tuple2<C1,C2>> list(); ... }

Hierarchical Expressions Use method chaining when you need context static functions when you need hierarchy and extensibility or( eq(p.name, "Peter"), gt(p.height, 170) )

Expression public interface Expression<E> { String getSqlString(); List<Object> getSqlArguments(); Class<E> getType(); }

Expressions class Expressions { Expr<Bool> and(Expr<Bool>... e) <E> Expr<Bool> eq(Expr<E> e1, Expr<E> e2) Expr<Bool> like(Expr<?> e, Expr<String> pattern) <E> Expr<E> constant(E value) Expr<String> concat(Expr... e) ... }

Closures interface Closure { void apply(Builder b); } class SelectBuilderC2<C1,C2> extends SelectBuilder { SelectBuilderC2<C1,C2> closure(Closure closure) { closure.apply( this ); return this ; } } }

Unsafe Assumptions Allow the user to do type unsafe actions, but make sure he has to document his assumptions. Expression<Integer> count = unchecked(Integer. class , "util.countChildren(id)" );

Used Patterns Restricting syntax (builders allow from , where and select to be called only once) Typesafe metadata (data dictionary) Hierarchical Expressions (with method chaining for main syntax) Unsafe assumptions (unchecked expressions declare the expected type) Closures for mixing with the control flow

Case Study 2: Typesafe Bytecode

Java Class Definition Modifiers, name, super class, interfaces Enclosing class reference Annotation* Inner class* Name Field* Modifiers, name, type Annotation* Method* Modifiers, name, return and parameter types Annotation* Compiled code

Java Execution Model Local variables Operand stack Execution stack Frame Calling a method Throwing an exception

Instruction Example opcode argumen ts apply Operands stack when applying the instruction : Instruction :

Bytecode Engineering ASM – Java bytecode engineering library Visitor-based API Tree-based API Completely untyped Produced bytecode is only verified at runtime

Hello, World! public class HelloWorld { public static void main(String[] args) { System. out .println( "Hello, World!" ); } }

Hello, World! in Bytecode public class HelloWorld { public <init>()V ALOAD 0 INVOKESPECIAL Object.<init>()V RETURN public static main([LString;)V GETSTATIC System.out : LPrintStream; LDC "Hello, World!" INVOKEVIRTUAL PrintStream.println(LString;)V RETURN }

Hello, World! in ASM ClassWriter cw = new ClassWriter(0); MethodVisitor mv; cw.visit( V1_6 , ACC_PUBLIC + ACC_SUPER , "HelloWorld" , null , "java/lang/Object" , null ); { mv = cw.visitMethod( ACC_PUBLIC + ACC_STATIC , "main" , "([Ljava/lang/String;)V" , null , null ); mv.visitCode(); mv.visitFieldInsn( GETSTATIC , "java/lang/System" , "out" , "Ljava/io/PrintStream;" ); mv.visitLdcInsn( "Hello, World!" ); mv.visitMethodInsn( INVOKEVIRTUAL , "java/io/PrintStream" , "println" , "(Ljava/lang/String;)V" ); mv.visitInsn( RETURN ); mv.visitMaxs(2, 1); mv.visitEnd(); } cw.visitEnd();

Possible mistakes Not enough stack elements for the instruction Stack elements have the wrong type Local variables have the wrong type Using illegal modifiers or opcodes

Similar Patterns Typesafe metadata (class literals) Closures for mixing with the control flow

Different Patterns Restricting syntax H ide methods that consume more stack slots than available Unsafe assumptions Deprecate methods instead of omitting them Allow assuming stack slot and local variable types

Tracking stack We generate classes MethodBuilderX, where X ranges from 0 to N Each represents a state with X stack slots initialized Stack consuming operations are only available in builders which have enough stack slots initialized

Type History You can accumulate type history as a type list and use it to reject actions that do not ﬁt with that history In addition to tracking the current stack size we track each stack slot type using a list of generic type variables

Unsafe Assumptions Allow the user to do type unsafe actions, but make sure he has to document his assumptions.

Reusable genSayHello() private static void genSayHello(MethodBuilder0 mb) { mb .assumePush(String. class ) .getStatic(System. class , "out" , PrintStream . class ) .swap() .invoke() .param(String. class ) .virtVoid(PrintStream. class , "println" ); }

Embedded Typesafe Domain Specific Languages for Java

More Related Content

What's hot

Similar to Embedded Typesafe Domain Specific Languages for Java

Recently uploaded

Embedded Typesafe Domain Specific Languages for Java