<Insert Picture Here> Scripting Languages: Options for the JVM

Transcription

1

2 <Insert Picture Here> Scripting Languages: Options for the JVM Simon Ritter Technology Evangelist

3 Languages, Languages Everywhere Clojure Tcl JavaScript v-language CAL Sather Funnel Mini PLAN Lisp Scheme Basic Logo JHCR TermWare Drools Prolog LLP JESS Eiffel Smalltalk C# G Groovy Nice Anvil Hojo Correlate Ada Bex Script Tea PHP Phobos Sleep FScript JudoScript JRuby ObjectScript Jickle Yoix Simkin BeanShell Dawn WebL iscript Jython Pnuts Yassl Forth Piccola SALSA Processing Zigzag Tiger Tiger Icon Pascal Oberon Modula-2 Luck E Rexx JavaFX Script Scala

4 Objective Survey of Dynamic Languages on the JVM Groovy, Ruby, Scala, Clojure

5 What to (Not) Expect EXPECT Discussion on a small subset of the languages Highlight interesting language features Contrast with Java DON'T EXPECT Hello World Coverage of all features Which is a 'better' language Java bashing

6 Why So Many Languages? Domain specific languages All modern languages are Turing complete How you do things varies wildly Different languages approach problems in different ways Freedom of choice

7 Why On The JVM Many languages require runtime support GC, memory management, etc Every problem in computer science can be solved by adding a layer of indirection Butler Lampson VM is the indirection layer Abstraction from hardware Portability, Security, Performance, Reliability

8 <Insert Picture Here> Groovy groovy.codehaus.o rg/

9 Language Features 1 Object oriented programming language Syntax is very similar to Java feels very much like Java Runs Java sources files Compact and concise syntax Optional semi colon and parenthesis Native syntax for list, maps and regex Seamless bi-directional integration with Java Groovy extending Java class implementing Groovy interfaces Reuse Java's infrastructure classes, security, threads, etc Closure, properties and operator overloading support

10 Language Features 2 Easy integration with Java application via JSR-223 One JAR file embeddable/groovy-all-1.x.y.jar Meta Object Protocol (MOP) provides the meta programming capabilities A runtime layer which any application can participate

11 A Valid Java Program import java.util.*; public class Erase { private List<String> filterlongerthan(list<string> list, int len) { List<String> result = new ArrayList<String>(); for (String n: list) if (n.length() <= len) result.add(n); return (result); public static void main(string... args) { List<String> names = new ArrayList<String>(); names.add( Fred ); names.add( Barney); names.add( Wilma ); names.add( Betty ); System.out.println(names); Erase e = new Erase(); List<String> shortnames = e.filterlongerthan(names, 5); System.out.println(shortNames);

12 A Valid Groovy Program import java.util.*; public class Erase { private List<String> filterlongerthan(list<string> list, int len) { List<String> result = new ArrayList<String>(); for (String n: list) if (n.length() <= len) result.add(n); return (result); public static void main(string... args) { List<String> names = new ArrayList<String>(); names.add( Fred ); names.add( Barney); names.add( Wilma ); names.add( Betty ); System.out.println(names); Erase e = new Erase(); List<String> shortnames = e.filterlongerthan(names, 5); System.out.println(shortNames);

13 Groovy Way Automatically imports java.util.* Native list syntax def names = ["Ted", "Fred", "Jed", "Ned"] println names Creates an ArrayList Closure support def shortnames = names.findall { it.size() <= 3 Operator overloading def diff = names - shortnames print diff

14 Operator Overloading Every operator can be overloaded via corresponding method Eg. plus() for '+', leftshift() for '<<', etc. Special method for switch classification Override is iscase() public class Family { def members = [] def plus(person o) { members += o members def plus(family f) { members += f.members members Person fred = Person wilma = Family flintstones = flintstone += fred + wilma Person barney = Person betty = Family rubble = rubble += barney + betty

15 Category Add temporary methods or behaviour to instances of object code block class StringCalcutation { static def plus(string self, String operand) { try { return (self.tointeger() + operand.tointeger()).tostring() catch (NumberFormatException f) { return (self << operand) println use(stringcalculation) { println Redefine the behaviour of + in code block Example adapted from Groovy in Action by Dierk Konig et al

16 Closure A piece of code that is wrapped in an object Anonymous functions/methods Behaves like data, but can be invoked Takes 2 parameters. Closure has a default value def perform(int times, Closure c = {) { for (i = 0; i < times; i++) c.call(i) perform(3) { x -> println hello: ${x Parameter Code block not executed but passed as a parameter

17 Meta Object Protocol Provides dynamic behaviour to Groovy Intercept method calls, create classes and methods, etc MOP consists of: Formalized behaviour for resolving methods/properties Two major classes: GroovyObject and MetaClass Override methods in MetaClass to redefine behaviour Lots of libraries uses MOP String.metaClass.constructor = { constructor = String.class.getConstructor(String.class) constructor.newinstance((new Date()).toString()) println new String() Sat Nov Replace the default constructor Example adapted from Groovy in Action by Dierk Konig et al

18 <Insert Picture Here> Ruby

19 Language Features Supports multiple programming paradigm Imperative, object oriented, functional and reflective Excellent support for reflective programming / metaprogramming Continuation support Freeze a point in the application and return to it later Supports reuse through inheritance, mixins and open classes Open classes is the ability to modify an existing class including those from the host library Eg. add rot13() method to java.lang.string

20 Objects and Method Calls Everything in Ruby is an object Everything is a method call Message passing masquerading as method calls obj.fred is the same as obj.send(:fred)as Method invocation means sending a message to the object Use respond_to? to inspect if an object supports a particular message Methods can be invoked with our without parenthesis Excellent for readability and DSL x = is equivalent to x = 1.+(2.send(:+, 3)) puts ugly_d.quack if ugly_d.respond_to? :quack

21 Reuse Inheritance (traditional object oriented approach) class KaraokeSong < Song def to_s super + [#{@lyrics] end Inherit from Song This means super.to_s from context

22 Reuse Mixins - Adding a module into a class or object Cannot be intantiated module ClassName def class_name self.class.name end end class Song include ClassName s = Song.new(...).extend(ClassName) Mixin to class or instance

23 Reuse Open classes - adding methods to classes or objects class String def rot13 self.tr( A-Ma-mN-Zn-z, N-Zn-zA-Ma-m ) end end

24 Metaprogramming with Ruby Technique by which a program can manipulate another program or itself as their data Ruby relies on metaprogramming heavily Eg. in declaring properties Introspect into a a class, object or the running environment Eg. ObjectSpace.each_object(String) { x puts x Allows you to trap interesting behaviour and override or enhance them Similiar to AOP Eg. creating a method, instantiating an object, invoking a missing method, querying if a member is defined, etc. Eg. emulate ExpandoMetaClass in Groovy by trapping undefined method names

25 Continuations Abstract representation of the rest of the code to be executed if (i > 10) puts i > 10 else puts i < 10 end The continuation of if (i > 10) is puts i > 10 iff i > 10 puts i < 10 iff i < 10 Uses of continuations Coroutines, escape and reenter loops/recursion, debugger, need to backtrack Eg. Able to return to the point of exception after handling the exception

26 callcc callcc to construct a continuation object in Ruby Encapsulates the state of the application up to callcc Use the continuation object to jump to just after the callcc result = 1 i = 1 callcc { $cont_obj Ruby passes a continuation result *= i object to block i += 1 $cont_obj.call if (i <= 10) Returns to the statement just after the callcc

27 Example - Coroutine def ping puts "PING 1" save_and_resume($ping_cont, nil) pong puts "PING 2" save_and_resume($ping_cont, $pong_cont) puts "PING 3" save_and_resume($ping_cont, $pong_cont) end def pong puts "PONG 1" save_and_resume($pong_cont, $ping_cont) puts "PONG 2" save_and_resume($pong_cont, $ping_cont) puts "PONG 3" save_and_resume($pong_cont, $ping_cont) end ping PING 1 PONG 1 PING 2 PONG 2 PING 3 PONG 3 Example adapted from Call with Current Continuation Patterns by Darrell Ferguson, Dwight Deugo

28 <Insert Picture Here> Scala

29 Language Features 1 A hybrid of object and functional Supports mutable and immutable (functional) structures Defaults to immutable for collections Objects, singletons and traits Singleton is a language concept Very similar to interfaces but with fully implemented methods Cannot be instantiated, can only be mixed into a class or object Pseudo operator overloading Operators are all method calls

30 Language Features 2 Statically typed unique in the world of script language Can infer types from code during declaration Easily implement new types and corresponding operations Supports user define implicit type conversion Statically typed higher order functions More rigorous in what you can pass to a method Supports many high level concurrency abstraction Monitors, atomic variables, semaphores, workers, channels, etc Erlang style actors

31 Statically Typed Must provide type in method definition Elsewhere Scala can infer type from the context var map = Map[Int, String](1 -> Cat, 2 -> Dog ) Method return type, variable declaration Including closure / functions types var myfunc: ((Int, Int) => Complex) = null def sumoffactors(number: Int): Int = { var sum = 0 Method declaration for (i <- 1 to number) if ((sum % i) == 0) Inferring from context sum += i sum

32 Singletons Refer to as companion objects in Scala Use extensively in Scala class libraries Defined in the same file as the class Can access private constructors object Employee { def apply(name: String, id: String) = Curried function new Employee(name, id) def apply(name: String, id: String, salary: Double) (verify: (String, String, Double)=> Option[Employee]) :Option[Employee] = { Singleton if (verify(name, id, salary)) Some(new Employee(name, id, salary)) else None Option indicates we may not be getting any result Closure's signature

33 Traits Similar to interfaces with partial implementations trait Greetings { def sayhello(name: String) = Hello + name Mixed in to classes or selectively to object instances Mixin to class class Employee(override val name: String, val id: String) extends Person(name) with Greetings { Mixin to instance Only applicable if there are no abstract methods val fred = new Employee( Fred, 007 ) with Greetings

34 Selective Mixin Can enforce mixing traits only into certain classes By extending from a class Late binding with super object Resolution of super proceeds from right to left Eg class A extends B with TraitA with TraitB TraitB TraitA A assuming B is a class Excellent for implementing decorator or chain-of-command pattern

35 Example Selective Mixin 1 class Person(val name: String) { def calculatesalary(base: Double) = base class Employee(...) extends Person(...) { def mysalary() = calculatesalary(salary)... trait SpotBonus extends Person { Can only be mixin to classes that extends from Person override def calculatesalary(base: Double) = super.calculatesalary(base + (base * 0.05)) trait ThirteenMonth extends Person { override def calculatesalary(base: Double) = super.calculatesalary(base + base)

36 Operators on Types All method calls, no notion of operators Operator precedence is based on ordering of symbols Eg. all letters,, ^, &, < >, =!,:, + -, * % /, all other special characters Unary operators, prefixed with unary_ class Employee(override name: String... //As before def +(_salary: Double) = this.salary + _salary def -:(_salary: Double) = this.salary - _salary def unary_>>!(): Employee =... //promotion def unary_<<!(): Employee =... //demotion fred.salary = fred //Method call fred.+(1000) fred >>! //promote fred 100 -: fred Instance to follow method

37 Implicit Type Conversion Most language have build in implicit conversion Eg. byte + int byte is converted to int Scala allows you to define implicit conversion Use implicit keyword on method var yesterday = 1 days ago class DateHelper(num: Int) { def days(when: String) = { var date = Calendar.getInstance() when match { case ago => date.add(calendar.day_of_month, -num)... date.gettime() Converter that takes 1 and return???.days( ago ) def implicit convertint2datehelper(num: Int) = new DateHelper(num) * Adapted from Programming Scala by Venkat Subramaniam

38 Concurrency Lots of abstraction to support concurrency and asynchrony Signals, monitors, atomic objects, semaphores, workers, mail boxes, actors etc Actor based model A computation entity that inherently concurrent Communicate by send it messages Can change its state or spawn new actors based on messages Two ways of using actors actor method Extend Actor class Communications! to send a message receive case to select message based on type

39 <Insert Picture Here> Clojure

40 Language Features 1 Functional language Verb (functions) is the central theme, not noun (objects) No side effects only depends on its arguments Most Java method do not qualify as functions Give the same argument, will return the same result EVERYTIME Functions are stateless f(x) = f(y) if x is equals y Higher order functions f(x) g(y) where x and y can be functions Closure is very natural Lambda Parameter Body (defn make-greeter [greetings] (fn [name] (format %s, %s greetings name))) ((make-greeter Bonjour ) Jean ) Bonjour, Jean

41 Language Features 2 All data is immutable no data is ever changed * (def foo '(a b c)) (a b c) Reassigned (concat foo '(x y z)) (a b c x y z) foo (a b c) (def foo (concat foo '(x y z))) (a b c x y z) Everything is a sequence with abstractions List (a b c) Vector [a b c] Set #{a b c Map {:x a, :y b, :z c *except for refs

42 Language Features - 3 Homoiconic the data structure is the language No language syntax just have to know how to write parenthesis Evaluation rules first element is the function name Everything else are parameters

43 Calculate 10! Java public int fac(final int f) { int tot = 1; for (int i = 1; i < f; i++ tot *= i return (tot); Clojure (defn fac [f] (if (zero? f) 1 (* f (fac (dec f))))) Function defintion

44 Concurrency Supports 4 concurrency model Agents actors but pass functions instead of messages Atoms like java.util.concurrent.atomic References database like transaction semantics a.k.a Software Transaction Memory (STM) Vars thread local Agents Atoms References Vars Shared X X X Isolated Synchronous X X Asynchronous Coordinated Autonomous X X X X X

45 Sharing Data via Managed References Thread A foo Thread B bar Data Most programming languages eg. Java, C, etc. Thread A Thread B Data Deference to access immutable data

46 Agents Use to manage independent states Send functions to modify the state of the agent Functions are executed asynchronously Only one function is evaluated at a time Some notion of ordering (def foo (agent 0 is immutable (send foo inc)... after some 1

47 References and STM References (ref) provide database like transaction Software transactional memory All or nothing Data are not visible until you commit All changes happens at constant time You see all the changes at once No inconsistent data during transaction Thanks to Clojure's immutable data All references must occur in a transaction Create references with ref Use either alter or commute to change the ref dosync execute expressions in a transaction alter and commute will only run in dosync

48 Handling Conflicts with alter (dosync (alter foo assoc...)) (assoc...) (assoc...) time foo altered by another transaction Transaction is retried At the start of the transaction Get an in transaction copy of foo's value Value will never be inconsistent data is immutable At the end of the transaction foo is check if it has changed during the transaction If it has, transaction is retried Body of transaction must be side effect free Otherwise transaction commits new value visible to all

49 Handling Conflicts with commute (dosync (commute foo assoc...)) (assoc...) (assoc...) time foo altered by another transaction Function is retried Same semantics as alter Except at the end of the transaction If foo is altered, the function is retried Function must be commutative and without side effects Eg. deposit is a commutative operation You can invoke deposit in any order, the final state of the account will still be consistent Withdrawal is not commutative

50 Conclusions Java Virtual Machine can support many languages Many different syntaxs Many different constructs Procedural, declarative or functional Static or dynamic typing Freedom of choice for developers Consistent security, stability and portability JDK7 will improve support for dynamic languages InvokeDynamic bytecode

51 The preceding is intended to outline our general product direction. It is intended for information purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decisions. The development, release, and timing of any features or functionality described for Oracle s products remains at the sole discretion of Oracle.

52