1. 1 Java/MP Multiparadigm Programming Language by Roshan Naik Advisor: Dr. Timothy Budd Estimated Time: 60 mins

2. 2 Java/MP Introduction What's is Java/MP ? Who designed it ? Is there an implementation ?

3. 3 Paradigms Paradigm: A set of assumptions, concepts, values and practices that constitutes a way of viewing reality. Common Programming Paradigms: –Imperative - C,Pascal,Basic,Fortran –Functional - Lisp, Haskell –Object Oriented - C++, Java –Logic - Prolog –Generic, Constraint, Visual, Access-Oriented, Spreadsheet, Rule-Based etc.

4. 4 Imperative Paradigm Step by step instructions are given to the computer. Instruction sequences continually make incremental changes to areas in memory. Characterized by functions, variables, loops and branch instructions. Examples: C, Pascal, Basic, Fortran.

5. 5 Functional Paradigm Based on Lambda Calculus Only functions and values. No variables. No loops. No side effects. Functions can be treated as values. A list or a sequence is often a built in data type. Mathematical techniques can be used to test the correctness of the program. Examples: Lisp, Scheme, Haskell.

6. 6 Functional Paradigm (contd.) Simple Functions: square(n) = n * n // mathematical version int square(int n) { return n*n; } // in a programming language Composition: cube(n) = square(n) * n int cube(int) = { return square(n) * n; } Recursion: factorial(0) = 1 factorial(n) = factorial(n-1) * n int factorial ( int n = 0 ) { return 1; } int factorial(int n) { return factorial(n-1) * n; }

7. 7 Functional Paradigm (contd.) Treating functions as values: –Functions as arguments: f( g(x), h(x), n ) = g( h(n) ) // mathematical version int f( int(int) g, int(int) h, int n ) { // in a programming language return g(h(n)) ; } –Functions as results: int(int) foo (int x) { return int bar(int y) { return x + y; }; }

8. 8 Object Oriented Paradigm Originated from attempts to simulate real world world objects and their interactions. Objects contain behavior and data. Objects interact with each other by exchanging messages. A group of similar objects is called a Class. Classes can be organized into a hierarchy such that properties and behavior that is common among related classes can be factored into a parent class. Examples: C++, Small Talk, Java.

9. 9 Logic Paradigm Based on Predicate Calculus. Problem solving is done by inferencing new results using well known facts and results from earlier inferences. Facts and Rules of inference are the two key abstractions in this paradigm. The problem instance to be solved is formulated as a Query. Backtracking is used to recover from inferences that do not lead to a solution. Examples: Prolog, Gödel.

10. 10 Facts: –mother(Diana, Henry) :- True. // Diana is Henry’s mother –father(Charles, William) :- True. // Charles is William’s father –father(Charles, Henry) :- True. Logic Paradigm (contd.) Diana WilliamHenry Charles Rules: –spouse(x, y) :- father(x, z) & mother(y, z) || mother(x, z) & father(y, z). Query: –spouse(Diana, Charles) ? // Is Diana a spouse of Charles ? –spouse(Charles, a) ? // All spouses for Charles ? equal

11. 11 Java/MP Multiparadigm language –Imperative, Object Oriented, Functional and Logic paradigms. Really the next generation of Leda. Designed as an extension to Java. Upward compatible superset of Java.

12. 12 Java/MP Motivation A multiparadigm language can provide far greater expressive power than languages confined to a single paradigm. Java is a popular programming language and is easy to learn but it strictly confines programmers to the object oriented paradigm. By building Java/MP on top of Java we reduce the learning curve and bring it to a wider bigger audience.

13. 13 Language Design Goals Extensions should be kept simple. Extensions should look evolutionary. Add as few extensions as possible. Compatible with the Java Virtual Machine. Functional and Logic paradigms are incorporated as extensions to the Object Oriented paradigm. Allow to freely mix and match paradigms and the integration should be seamless.

14. 14 New Features Features for: 1.Functional Paradigm 2.Logic Paradigm

15. 15 Java/MP Features for the functional Paradigm –Global Functions –Functions as Values Variables of function type int i = 34; [boolean (int)] func = foo; // foo can be a global/member function Functions as expressions ( lambda function ) –i = 3+4; –func = [boolean (int val)] { return val > 10; }; Lambda Function Single Statement

16. 16 Features for the functional Paradigm Functions as expressions (contd.) –int foo( [int (int)] func ) { return func(3); } –void bar( ) { int k=1; foo( [ int(int i)]{ return k+i; } ) ; } 1+3 = 4 Executed here !!

17. 17 Features for the Logic Paradigm Operator Overloading –String plus( String x, String y ) { // addition operator + return x.concat(y); } –String z = str1 + str2; // same as: z = plus(str1, str2 ); Pass by Name –void assign4( int @ i ) { i = 4; // change in value is reflected in the calling function } –void bar( ) { int j = 3; assign4( j ); System.out.print( j ); // prints 4 } + plus - minus * multiply / divide < less > greater Operator Names

18. 18 Features for the Logic Paradigm Relation: Can be considered as an extension of boolean. Facts and Rules are represented using functions that return a relation. –relation father ( String @ x, String @ y ) { return eq( x, “Charles” ) && eq( y, “William” ) // father(Charles,William)father(Charles,William) || eq( x, “Charles” ) && eq( y, “Henry” ) ; // father(Charles, Henry) } –if( father( “Charles”, “Henry” ) ) Arrow Operator: Assignment that can be undone i < - 4; equal

19. 19 Features for the Logic Paradigm Relational if and while Statements –String son = null; if ( father(“Charles”, son) ) System.out.println( son ); // print any one son –String son = null; while ( father(“Charles”, son) ) System.out.println( son ); // print all sons –int a = 3; if ( ( a 5) ) System.out.println( a );

20. 20 Implementation Translating Java/MP to Java

21. 21 Java/MP Implementation Java/MP is compiled into Java Compilation Process: Java/MP Source Code Java Source Code Byte Code Java/MP compiler Java compiler

22. 22 Translating to Java Types for functions [boolean(int[ ], double)] fv; An interface created for each function type boolean foo ( int[ ] i, double d ) { //.. } Interface Created : interface boolean_function_int_array_double_ { boolean apply( int[ ] p1, double p2 ); }

23. 23 Translating to Java Function Variables –Declaration: [boolean(int[], double)] fv; // Java/MP boolean_function_int_array_double_ fv ; // Java –Invoking function Variables: fv( intArray, 2.5 ); // Java/MP fv.apply( intArray, 2.5 ); // Java – Assigning functions: fv = foo; // Java/MP fv = new boolean_function_int_array_double_ ( ) // Java { public boolean apply(int[] p1, double p2) { return foo(p1, p2); // forward calls to foo( ) } }; Anonymous Class

24. 24 int_function_int_ func = new int_function_int_ ( ) { // Java public int apply( int i ) { return i+5; } }; Translating to Java Functions as variables and expressions –Assigning lambda functions: [int (int)] func = [int (int i)] { return i+5; } ; // Java/MP ??????

25. 25 class A { // Java/MP public [int(int)] foo (int x) { int y = 4; return [int (int z)] { return x + y + z; }; } int lambda32( int x, int y, int z ) { // member function of A return x + y + z ; } class context32 implements int_function_int_ { // inner class of A } Lambda functions and saving contexts Lambda Function context32( A receiver, int x, int y ) { this.receiver = receiver; this.x=x; this.y=y; // store context } public int apply(int z) { receiver.lambda32(x,y,z) ; // invoke the lambda and pass the stored context } Store context Invoke lambda32 with the context

26. 26 Translating to Java [int(int)] foo (int x) { // Java/MP int y = 4; return [int (int z)] { return x + y + z; }; } int_function_int_ foo(int x) // Java { int y = 4 ; return new context32(x, y); }

27. 27 Global Functions and Operator overloading –Declaring: int plus2( int i ) { // Java/MP return i+2; } –Invoking: plus2( 30 ); // Java/MP Translating to Java class function_plus2 implements int_function_int_ // Java { } public static int plus2(int i) { return i+2; } public int apply ( int p1 ) { // implementing interface return plus2(p1); } function_plus2.plus2(30); // Java

28. 28 Translating to Java Pass By Name 1.Pass by reference mechanism int x=3, y=4; swap(x,y); System.out.print(x); // x is 4, if x and y are passed by name to swap 2.Delay evaluation of expressions until needed void writeOnTrue(boolean b,int @ x) // evaluate x if b is true { if(b = = true) System.out.print(x); } writeOnTrue( true, 3+2+25 ); swap(int @ x, int @ y) { // exchange values of x and y } // evaluate 3+2+25 here !! Thunk

29. 29 Translating to Java Automatic conversion of boolean to relation relation father (…) { return true; } relation father (...) { return new relation ( ) { public boolean apply( relation continuation) { return true; } } ; } Relation : An extension of boolean. But in reality, a interface that defines a function that returns a boolean. interface relation { boolean apply( relation continuation); }

30. 30 Translating to Java Relational if and while statements if ( ( a 10 ) System.out.print( a ); // prints 20 while( ( a 10 ) System.out.print( a ); // prints 20 and 13 String son = null; while( father( “Charles”, son ) ) System.out.print( son ); // prints Henry and William

31. 31 Translating to Java Translating relational if Statement: if( relExpr) { // Java/MP System.out.print(..); } public void lambda29(..context if any..) { // Java System.out.print(..); } Convert to a member function class context29 implements void_function_void { context29(..context if any..) { // store context; } public void apply() { lambda29(..context if any..) ; } Context context29 ctx29 = new context29(..context if any..); // 1. create context if ( relExpr.apply( new trueRelation( ) ) = = true ) // 2. if( relExpr ) ctx29.apply( ); // 3. execute lambda29 Translated if statement

32. 32 Translating to Java Translating relational while Statement: while( relExpr) { // Java/MP System.out.print(..); } class context29 implements void_function_void { context29(..context if any..) { // store context; } public void apply() { lambda29(..context if any..) ; } Context public void lambda29(..context if any..) { // Java System.out.print(..); } final context29 ctx29 = new context29(..context if any..); // 1. create context relExpr.apply( new relation( ) { // 2. while( relExpr ) public boolean apply ( relation continuation ) { ctx29.apply( ); // 3. execute lambda29 when relExpr=true return false; // 4. return false to force backtracking } ); Translated while statement

33. 33 Current Status Working prototype compiler on Unix and Windows. Not yet industrial strength. Needs more testing. No byte-code parser to import existing classes. Future Work –Generate byte code directly. –Performance issues. –Multiparadigm-enabled debugger.

34. 34 Questions ?