Comparing JVM languages

Comparing JVM languages
José Manuel Ortega Candel | @jmortegac
26-27 June 2015

INDEX
Functional programming and closures2
Language classification1
Java 8 new features3
Scala, Groovy, Kotlin, Clojure and Ceylon4
Advantages and drawbacks5
Comparing features6

Language classification
FUNCTIONAL NOT FUNCTIONAL
STATIC
DYNAMIC

Functional programming
•Data structure persistent and immutable
•Closures
•Higher order functions
•Pass functions to functions as parameter
•Create functions within functions
•Return functions from other functions
•Functions as first class values

Closures
•Reduce amount of “boiler plate” code
•Eliminate the boilerplate code of anonymous
inner classes
•Allow the use of idiomatic functional
programming code
•Allow the creation of custom control structures
•In Java 8 closures are just syntactic sugar for
defining anonymous inner classes

Java 8 new
features
 Lambda expressions
 Closures
 Streams
 Enhaced collections
 Processing data in parallel
 Pattern Filter-Map-Reduce
 Annotations types
 Methods References
(String s)-> System.out.println(s)
System.out::println

Filter-Map-Reduce
Book book=new Book(123455,"Beginning Java 8");
Book book1=new Book(3232332,"Java 8 Advanced");
Book book2=new Book(43434343,"Groovy Advanced");
List<Book> books=Arrays.asList(book,book1,book2);
Predicate<Book> condition=(it) -> it.getTitle().contains("Java");
String jsonFormat=books
.stream()
.filter(condition)
.map(Book::toJSON)
.collect(Collectors.joining(", "));
[{isbn:123455,title:'Beginning Java 8'}, {isbn:3232332,title:'Java 8 Advanced'}]

Parallel Streams
List myList = ..
Stream stream = myList.stream();
Stream parallelStream = myList.parallelStream();
Stream parallel = stream.parallel();
•Streams are sequential by default
•With Parallel you can optimize number of threads
•More efficient with bigger collections

Sequential vs Parallel
books.parallelStream().filter((it) -> it.getTitle().contains("Java")).
forEach((it)->System.out.println(it+" "+Thread.currentThread()));
Book{isbn=3232332, title='Java 8 Advanced'} Thread[main,5,main]
Book{isbn=123455, title='Beginning Java 8'} Thread[main,5,main]
books.stream().filter((it) -> it.getTitle().contains("Java")).
forEach((it)->System.out.println(it+" "+Thread.currentThread()));
Book{isbn=3232332, title='Java 8 Advanced'} Thread[main,5,main]
Book{isbn=123455, title='Beginning Java 8'} Thread[ForkJoinPool.commonPool-
worker-2,5,main]

Scala
Combines the paradigms of functional
programming and object-oriented
Statically typed
No types primitives like Java
Everything is an Object, including functions
Performance equivalent to Java

Scala features
Pattern matching
Closures,lambdas,anonymous functions
Traits and mixins for multiple inheritance
Operator overloading
Support Data Paralell like Java 8
Concurrency models(Akka,actors)
Inmutable and mutable data structures

Scala examples
def factorial(n : Int): Int = n match{
case 0 => 1
case x if x >0 => factorial(n-1) *n
}
val languages = List("Scala", "Groovy", "Clojure", "Kotlin")
val headList = languages.head // Scala
val tailList = languages.tail; //List( "Groovy", "Clojure", "Kotlin")
val empty = languages.isEmpty //false
def orderList(xs: List[String]): List[String] =
if (xs.isEmpty) Nil
else insert(xs.head, isort(xs.tail)
@BeanProperty
Annotation which is read by the Scala
compiler to generate getter and setter
class Bean {
@scala.reflect.BeanProperty
var name: String
}
val someNumbers = List(-11, -10, -5, 0, 5, 10)
someNumbers.filter((x) => x > 0)
someNumbers.filter(_ > 0)
List[Int] = List(5, 10)
scala.collection.immutable

Inmutability in Scala
scala> var languages = Set("Scala", "Kotlin")
languages : scala.collection.immutable.Set[java.lang.String] =
Set(Scala, Kotlin)
scala> languages += "Clojure"
scala> languages
res: scala.collection.immutable.Set[java.lang.String] =
Set(Scala, Kotlin, Clojure)
scala> languages -= " Kotlin "
scala> languages
res: scala.collection.immutable.Set[java.lang.String] =
Set(Scala, Clojure)
• You can add elements in a inmutable collection

Java 8 vs Scala streams
bookList.parallelStream().filter(b -> b.title.equals(”Clojure”))
.collect(Collectors.toList())
bookList.par.filter(_.title == “Clojure”)
bookList.par.filter( b =>b.title == “Clojure”)
val bookFilter = bookList.par.filter(_.title.contains("Groovy"))
.foreach{i=> println(Thread.currentThread) }
Thread[ForkJoinPool-1-worker-3,5,main]
Thread[ForkJoinPool-1-worker-5,5,main]

Kotlin
Object-oriented with functional elements
Developed by JetBrains
Statically typed like Scala
Smarts casts
Elvis operator(?) for checking null like Groovy
Type inference
100 % interoperability with Java

Kotlin syntax & rules
Inmutable/Mutable variables
No new keyword for create objects
No primitive types
No static members
Primary constructors
No fields, just properties
By default, all classes are final

Kotlin
Smart casts Maps
val languages = mapOf("Java" to "Gosling",
"Scala" to "Odersky","Groovy" to "Strachan")
for((language,author) in languages){
println("$author made $language")
}
fun eval(e: Expr): Double = when (e) {
is Num-> e.value.toDouble()
is Sum -> eval(e.left) + eval(e.right)
else ->
throw IllegalArgumentException("Unknown
expression")
}
val mapLanguages = hashMapOf<String, String>()
mapLanguages.put("Java", "Gosling")
mapLanguages.put("Scala", "Odersky")
for ((key, value) in mapLanguages) {
println("key = $key, value = $value")
}
fun patternMatching(x:Any) {
when (x) {
is Int -> print(x)
is List<*> ->{print(x.count())}
is String -> print(x.length())
!is Number -> print("Not even a number")
else -> print("can't do anything")
}
}

Kotlin
Operator overloading Default & name arguments
println(product(2))
println(product(2,3))
println(format(text="kotlin"))
println(format(text="kotlin", upperCase= true))
2
6
kotlin
KOTLIN
fun product(a:Int,b:Int=1):Int{
return a.times(b);
}
fun format(text:String,upperCase:Boolean=
false):String {
return if (upperCase) text.toUpperCase() else text
}

Kotlin
Iterators
fun iterateOverCollection(collection: Collection<Int>) {
for (element in collection) {}
}
fun iterateOverString() {
for (c in "abcd") {}
"abcd".iterator()
}
fun iteratingOverMap(map: Map<Int, String>) {
for ((key, value) in map) {}
}

Kotlin
Data classes
 Data annotation changes behavior of hashCode, equals, toString functions
public class Book (var isbn:Int, var title:String)
fun main(args: Array<String>) {
//Books
val book = Book(123456, "Beginning Kotlin")
val book2 = Book(123456, "Beginning Kotlin")
println(book);
println(book.hashCode());
println(book2.hashCode());
println(book.equals(book2));
if (book == book2)
println("Same Book");
if (book != book2)
println("Diferent Book");
}
books.Book@2a84aee7
713338599
168423058
false
Diferent Book
data public class Book (var isbn:Int, var title:String)
//Books
val book = Book(123456, "Beginning Kotlin")
val book2 = Book(123456, "Beginning Kotlin")
println(book);
println(book.hashCode());
println(book2.hashCode());
println(book.equals(book2));
if (book == book2)
println("Same Book");
if (book != book2)
println("Diferent Book");
Book(isbn=123456,
title=Beginning Kotlin)
1848623012
1848623012
true
Same Book

Kotlin
Classes constructor
• It is not necessary define a constructor like in Java
• You can use the class definition to pass the properties and
default values
data public class Book (var isbn:Int, var title:String="My Default Book")
val book = Book(123456)
println(book.title);
}

Kotlin
Higher order functions
• Lambda expressions
• it implicit parameter
val filter = books filter({ b: Book -> b.title.contains(“Kotlin") })
val book = Book(123455, "Beginning Java 8")
val book1 = Book(3232332, "Java 8 Advanced")
val book2 = Book(43434343, “Kotlin Advanced")
val books = Arrays.asList(book, book1,book2)
Filter[Book(isbn=43434343, title=Kotlin Advanced)]
val filter = books filter({ it.contains(“Kotlin") })

Kotlin collections
val listInmutable
=listOf("Java","Kotlin","Groovy","Scala")
val listMutable=ArrayList<String>()
listMutable.add("Java")
listMutable.add("Kotlin")

Kotlin vs Java list iterate
for ((index,element) in list.withIndex()) {
println(“$index$element”);
}
int index=0
for (String element:list) {
System.out.println(index+””+element);
index++
}

Kotlin smart cast vs Java
if (expr is Number) {
println(expr.getValue());
//expr is automatically cast to Number
}
if (expr instanceof Number) {
System.out.println((Number)expr).getValue());
}

Kotlin vs Java types
inference
val longJavaClassName = LongJavaClassName()
LongJavaClassName longJavaClassName =new LongJavaClassName()

Groovy
 Java supercharged(syntactic sugar)
 Object oriented and dynamic language
 Optional typing like Scala and Kotlin
 All type checking is at run time
 It reduces Java boilerplate code including no
semi colons, no getters/setters, type
inference, null safety, elvis operators

Groovy
 Closures with lambda
or it implicit parameter
def upper = { s-> s.toUpperCase()}
def upper = {it.toUpperCase()}
 Collections
def languages = ["Java":”James
Gosling”, "Scala":”Martin Odersky”,
"Clojure":”Rich Hickey”,
"Ceylon":”Gavin King”,
"Groovy":”James Strachan”]
languages.each { entry -> println}
languages.each { k,v -> println}
 Methods as closures with .& operator
def object
object = 2
object = true
object = [1,2,3]
 Optional typing

Groovy
 @Memoized annotation  @Inmutable annotation
@Memoized
def BigInteger fibRecursiveMemoized(n) {
if (n<2) return 1
else return fibRecursiveMemoized(n-1) +
fibRecursiveMemoized(n-2)
}
TimeIt.code{println(fibonnaci.fibRecursive(40))}
TimeIt.code{println(fibonnaci.fibRecursiveMemoized(40))}
165580141
Time taken 42.083165464 seconds
165580141
Time taken 0.061408655 seconds //with memoize
import groovy.transform.Immutable
@Immutable class Language {
String title;
Long isbn;
}
def l1 = new Language (title:'Beginning Groovy',isbn:100)
def l2 = new Language (title:'Groovy advanced',isbn:200)
l1.title = 'Groovy for dummies'
// Should fail with groovy.lang.ReadOnlyPropertyException

Groovy
 Time execution
class TimeIt {
def static code(codeBlock){
def start = System.nanoTime()
try{
codeBlock()
}finally{
def end = System.nanoTime()
println "Time taken ${(end-start)/1e9} seconds"
}
}
}

Groovy
 Parsing and creating XML

Groovy
Advantages Disadvantages
Java Collections Non-lazy evaluation
Closures
(like Lambda expressions in Java 8)
It's performance isn't great
(but it's improving)
Filter – Map – Reduce in streams
Easy interoperability with Java
Static and dynamic typing
@TypeChecked
@CompileStatic
Metaprogramming

Java Groovy
def languages = ["Java", "Scala", "Clojure",
"Kotlin", "Ceylon","Groovy"]
def filter = languages.stream()
.findAll { it.size()>5 }
.collect { it.toUpperCase()}
.first()
List<String> languages = Arrays.asList("Java",
"Scala", "Clojure", "Kotlin","Ceylon","Groovy");
Optional<String> bookFiltered = languages.stream()
.filter(s -> s.length()>5 )
.map(s -> s.toUpperCase())
.findFirst();

Clojure
Pure functional language
JVM language based in Lisp
Not Object Oriented
Dynamically typed
All data structure including list ,vectors, maps,
sequences, collections, are inmutable and fully
persistent
The main data structure is the list
The key is the use of High Order Functions

Clojure
Alternate implementations in functions
(defn square-or-multiply
"squares a single argument, multiplies two arguments"
([] 0) # without arguments
([x] (* x x)) # one argument
([x y] (* x y))) # two arguments
List operations
(first '(:scala :groovy :clojure))return scala
(rest '(:scala :groovy :clojure))return all elements excepts the first
(cons :kotlin '(:scala :groovy :clojure))add kotlin to head in the list

Clojure
Sequences
(defn count-down [n]
(if (<= n 0)
'(0)
(cons n (lazy-seq (count-down (dec n))))))
Filter – Map - Reduce
(filter integer? [1 2.71 3.14 5 42]) => (1 5 42)
(map (fn [n] (* n n)) [1 2 3 4 5]) => (1 4 9 16 25)
(reduce + [1 2 3 4]) => 10
user=> (count-down 8)
(8 7 6 5 4 3 2 1 0)

Clojure
Records
(defrecord Book [isbn title])
(def bookList [(Book. 432423 "Clojure")(Book. 534243 "Kotlin")
(Book. 432424 "Groovy")])
(println "count bookList "(count bookList))
(dorun (for [item bookList]
(println (:title item)(:isbn item))))
(println (filter #(= "Clojure" (get % :title)) bookList))
count bookList 3
Clojure 432423
Kotlin 534243
Groovy 432424
(#user.Book{:isbn 432423, :title
Clojure})
(defrecord Object [prop1 propn])

Clojure
Recursive functions with trampoline and memoize
(defn factorial ([x] (trampoline (factorial (dec x) x)))
([x a] (if (<= x 1) a #(factorial (dec x) (*' x a)))))
(def fibonaci
(memoize (fn [n]
(if (< n 2)
n
(+ (fibonaci (dec n))
(fibonaci (dec (dec n))))))))
(time(println (factorial 20)))
(time(println (fibonaci 30)))
"Elapsed time: 0.692549 msecs"
832040
832040
2432902008176640000

Clojure
Advantages Disadvantages
Very simple Not Object oriented
The language has little elements
compared with other languages
Difficult to decipher stacktraces and errors
Excellent concurrency support Requires a new way to solve problems
Easy interoperability with java There are no variables
Powerful language features
(macros,protocols)
Thre is no inheritance concept
Clojure programs run very quickly No mecanism for avoid NullPointerException
JVM is highly optimized

Clojure vs Java
Code reducing
(defn blank [str]
(every#? (Character/isWhitespace %)
str))
public class StringUtils {
public static boolean isBlank(String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)))) {
return true;
}}
return false;
}}

Ceylon
Is very similar to Java, reducing verbosity
Object oriented with functional features
Strong static typing with type inference
Explicit module system
 Comparing with Java
 Eliminates static, public, protected, private
 Add new modifiers like variable, shared, local
 Shared is used for make visibility outside in other
modules(like public in Java)
 Arrays are replaced by sequences

Ceylon
Sequence languages = Sequence("Java",
"Groovy","Clojure","Kotlin");
//Check if the sequence is empty
if(nonempty languages){
String? firstElementValue = languages.value(1);
String? firstElement = languages.first;
}
Sequence more =
join(languages,Sequence("Ceylon","Scala"));
Sequences Generics & Union types
Iterable<String|Boolean> list =
{“string”,true,false}
ArrayList<Integer|Float> list =
ArrayList<Integer|Float>
(1, 2, 1.0, 2.0)

Comparing featues
•Reducing verbosity
•Variables definition
•Null-safety
•Optional types
•Lambdas
•Pattern matching
•Traits
•Java interoperability

Reducing Java verbosity
Reducing Boilerplate Code
class MyClass{
private int index;
private String name;
public MyClass(int index, String name){
this.index = index;
this.name = name;
}
}
case class MyClass(index: Int, name: String)
public class MyClass(var index:Integer,var name:String){
}
class MyClass {
int index
String name
}
class MyClass(index,name) {
shared Integer index;
shared String name;
}
(defstruct MyClass :index :name)

Variables definition
• In Kotlin and Scala you can define 2 types
• var myMutableVariable
• val myInmutableVariable
• In Ceylon we have variable modifier for mutable
variable Integer count=0;
count++; //OK
Integer count=0;
count++;//ERROR
val name: Type = initializer // final “variable”
var name: Type = initializer // mutable variable

Null-safety
•Operator ? used in Kotlin,Groovy,Ceylon
•Avoid NullPointerException
var b : String? = "b"
b = null // valid null assignment
val l = b?.length()
Elvis Operator(?:) and Safe navigation (?.)
def displayName = user.name ? user.name : "Anonymous“
def streetName = user?.address?.street
String? argument = process.arguments.first;
if (exists argument) { //checking null values
}

Optional Types
Optional<Object> optional = findObject(id);
//check if Optional object has value
if (optional.isPresent()) {
System.out.println(optional.get());
}
Type safe Option[T] in Scala
New class java.util.Optional

Optional Type in Scala
private val languages = Map(1 -> Language(1, "Java", Some("Gosling")),
2 -> Language(2, "Scala", Some("Odersky")))
def findById(id: Int): Option[Language] = languages.get(id)
def findAll = languages.values
def main(args: Array[String]) {
val language = Optional.findById(1)
if (language.isDefined) {
println(language.get.name)
}
}
val language = Optional.findById(3) None

Optional Type in Scala
val languages =Map("Java"->"Gosling","Scala"->"Odersky")
languages:scala.collection.immutale.Map[java.lang.String,java.lang.String]
languages get "Scala"
Option[java.lang.String] = Some(Odersky)
languages get "Groovy"
Option[java.lang.String] = None

Lambdas in streams
List<Book> books=Arrays.asList(book,book1,book2);
Optional<String> bookFiltered =
books.stream()
.filter(b -> b.getTitle().contains("Groovy"))
.map(b -> b.getTitle().toUpperCase())
.findFirst();
val books = Arrays.asList(book,book1,book2)
val bookFiltered : String? =
books.sequence()
.filter { b->b.title.contains("Groovy")}
.map { b->b.title.toUpperCase() }
.firstOrNull()
def bookfilter= books.
findAll { b->b.title.contains(" Groovy ") }
.sort { b->b.isbn }
.collect { b->b.title.toUpperCase() }
.find()
val bookList = List(book1,book2,book3);
val bookFilter = bookList
.filter(b=>b.title.contains("Groovy"))
.map(book => book.title)

Pattern matching
• Is a generalization of Java switch/case
def generalSize(x: Any) = x match {
case s: String => s.length
case m: Map[_, _] => m.size
case _ => -1
}
scala> generalSize("abc")
res: Int = 3
scala> generalSize(Map(1 -> 'a', 2 -> 'b'))
res: Int = 2
fun fib(n: Int): Int {
return when (n) {
1, 2 -> 1
else -> fib(n - 1) + fib(n - 2)
}
}
fun patternMatching(x:Any) {
when (x) {
is Int -> print(x)
is List<*> ->{print(x.size())}
is String -> print("String")
!is Number -> print("Not even a number")
else -> print("can't do anything")
}
}

Traits vs Java interfaces
Traits allow declare method definitions
A trait is an interface with an
implementation(behavior and/or state)
Traits support “multiple inheritance”
One class can inherit from many traits

Traits.Code in interfaces
trait Publication {
int number
def getNumberPublication(){
return (number)
}
}
trait Location {
String description
def getInfoPublication(){
return (description)
}
}
class MyBook implements Publication,Location{
Integer isbn
String title
def getInfoBook(){
return (isbn+ " "+title)
}
}
trait Publication {
def description() = println(“Description”)
}
class Book(var isbn:Int,var title:String) extends Publication{
def getInfoBook(){
return (isbn+ " "+title)
}
}
trait Publication{
var number:String
fun getNumberPublication(){
println(number)
}
}
class Book:Publication {
}

Java interoperability
object list extends App {
import java.util.ArrayList
var list : ArrayList[String] = new ArrayList[String]()
list.add("hello")
list.add("world")
println(list)
}
import collection.JavaConversions._
java.util.Arrays.asList(1,2,3).
foreach(i =>println(i))
java.util.Arrays.asList(1,2,3).
filter(_ % 2 ==0)
fun list(source: List<Int>):ArrayList<Int> {
val list = ArrayList<Int>()
for (item in source)
list.add(item)
for (i in 0..source.size() - 1)
list[i] = source[i]
return list
}
(ns clojure-http-server.core
(:require [clojure.string])
(:import (java.net ServerSocket SocketException)
(java.util Date)
(java.io PrintWriter BufferedReader
InputStreamReader BufferedOutputStream)))

Java interoperability
import scala.beans.BeanProperty
class Language(
@BeanProperty var name: String,
@BeanProperty var author: String) {
}
public static void main(String[] args) {
Language l1 = new Language(“Java",”Gosling”);
Language l2 = new Language(“Scala",”Odersky”);
ArrayList<Language> list = new ArrayList<>();
list.add(l1);
list.add(l2);
}

List Partitions
• We can use partition over a list for obtain 2 lists
scala> List(1, 2, 3, 4, 5) partition (_ % 2 == 0)
res: (List[Int], List[Int]) = (List(2, 4),List(1, 3, 5))
// partition the values 1 to 10 into a pair of lists of even and odd numbers
assertEquals(Pair(listOf(2, 4, 6, 8, 10), listOf(1, 3, 5, 7, 9)), (1..10)
.partition{ it % 2 == 0 })

Read file and print lines
import scala.io.Source
for (line <- Source.fromFile(“file.txt”).getLines())
println(line.length +" "+ line)
import java.nio.file.*;
import java.util.stream.Stream;
Path dict = Paths.get(“file.txt”);
Stream<String> linesStream = Files.lines(dict);
linesStream.forEach(System.out::println);
val dict = Paths.get(“file.txt")
val linesStream = Files.lines(dict)
val lines = linesStream.forEach{println(it)};

Read file and print lines
(defn read-file [file]
(with-open [rdr (clojure.java.io/reader file)]
(doseq [line (line-seq rdr)]
(println line))))
(read-file (file “file.txt"))
Files.lines(Paths.get(“file.txt")).forEach{println it};

Performance in recursion
(defn factorial ([x] (trampoline (factorial (dec x) x)))
([x a] (if (<= x 1) a #(factorial (dec x) (*' x a)))))
@TailRecursive
def fact(BigInteger n,acumulator = 1G) {
if (n <2){
acumulator
}else{
fact(n-1,n*acumulator)
}
}
@scala.annotation.tailrec
def factorialrec(fact:BigInt,number:BigInt=1):BigInt = {
if (fact<2) return number
else factorialrec(fact-1,fact*number)
}

Comparing features
Higher Order Functions
Mixin/traits
Pattern matching
Implicit casts
Nullables / Optionals
Modules
Promote inmutability
Lambdas

Palindrome
(use 'clojure.java.io)
(defn palindrome? [s]
(let [sl (.toLowerCase s)]
(= sl (apply str (reverse sl)))))
(defn find-palindromes[s]
(filter palindrome? (clojure.string/split s #" ")))
fun isPalindrome(s : String) : Boolean {
return s== s.reverse()
}
fun findPalindrome(s:List<String>): List<String>{
return s.filter {isPalindrome(it)}.map {it}
}
def isPalindrome(x:String) = x==x.reverse
def findPalindrome(s:Seq[String]) = s find isPalindrome
def isPalindrome(s) {
def s1 = s.toLowerCase()
s1 == s1.reverse()
}
def findAllPalindrome(list) {
list.findAll{isPalindrome(it)}
}

Conclusions
Full interoperability with Java
Reducing Java verbosity
These languages allow developer be more
productive comparing with java
Pragmatic Programmer advice: When you
learn a new language, you learn a new way
to think.

Resources
SCALA
• http://www.scala-lang.org
• http://www.scalakoans.org
• http://scala-ide.org
• https://www.coursera.org/course/progfun
KOTLIN
• http://kotlinlang.org
• http://kotlin.jetbrains.org
• http://kotlin-demo.jetbrains.com
• http://github.com/Jetbrains/kotlin

Resources
CLOJURE
• http://www.tryclj.com
• http://clojuredocs.org
• http://www.clojure-toolbox.com
• http://www.clojureatlas.com
CEYLON
• https://modules.ceylon-lang.org

Resources
• http://vschart.com/compare/kotlin/vs/clojure/vs/scala

Book
• Seven Languages in Seven Weeks
• A Pragmatic Guide to Learning Programming Languages
• https://pragprog.com/book/btlang/seven-languages-in-seven-weeks
• Ruby
• Io
• Prolog
• Scala
• Erlang
• Clojure
• Haskell

Thank you!
José Manuel Ortega Candel | @jmortegac

Comparing JVM languages

Recommended

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Comparing JVM languages (20)

More from Jose Manuel Ortega Candel (20)

Recently uploaded (20)

Comparing JVM languages