6 Programming Languages under investigation

6 Programming
Languages
under investigation
C++, C#, Java, Scala, Ruby and JavaScript

Agenda
 A flower from every garden
 A taste of worldwide fruits
 Start your engines!
 The genius inside each of us
March 8, 2013 Presented by Hosam Aly at Egypt's JDC 2013 2

A flower
from every
garden
Ruby
JavaScript

Atasteofworldwidefruits
#include <iostream>
#include <string>
using namespace std;
int main(/* int argc, char* argv[] */)
{
string name;
cout << "Enter your name, please: ";
cin >> name;
cout << "Hello " + name + "n";
// or
cout << "Hello " << name << endl;
return 0;
}
C++

using System;
namespace JDC2013
{
class Program {
static void Main(/* string[] args */) {
Console.Write("Enter your name, please: ");
string name = Console.ReadLine();
Console.WriteLine("Hello " + name);
// or
Console.WriteLine("Hello {0}", name);
}
}
}
C#

package org.egjug.jdc2013;
// import java.lang.*;
public class Program {
public static void main(String[] args) {
System.out.print("Enter your name, please: ");
String name = System.console().readLine();
System.out.println("Hello, " + name);
// or
System.out.printf("Hello, %s", name);
}
}
Java

package org.egjug.jdc2013
// import scala._
object Program extends App {
print("Enter your name, please: ")
val name = readLine
println("Hello " + name)
// or
printf("Hello %s", name)
}
Scala

# require 'a_library'
puts 'Enter your name, please: '
name = STDIN.gets
puts 'Hello ' + name
# or
puts "Hello #{name}"
Ruby

Atasteofworldwidefruits var name = prompt("Enter your name, please:");
alert("Hello " + name);JavaScript

Start your
Engines! Compilation
Intermediate
LanguageC#
Java
Scala
Machine Code
C++
Interpreted
JavaScript
Ruby

Start your
Engines! Linkage
Dynamic
• C++
• C#
• Java
• Scala
• Ruby
Static
• C++

Start your
Engines!
• JavaScript
• Ruby
Interpreter
• C#
• Java
• Scala
Virtual
Machine
• C++
Binary
Executable

There is a
Genius inside
Each ofUs
Personal Impressions
Ruby
JavaScript

Agenda
 Syntactical Overview
 Identifiers, Literals, Symbols and Annotations
 Classes, Templates, Functions and Code Blocks
 Imports,Variables and Parameter Passing
 Embedded Syntax (e.g. LINQ, XML)
 Programming Paradigms
 Procedural, Functional and Object-Oriented
 Meta-programming
 Type Systems
 Static, Dynamic, Strong and Weak
 ValueTypes, Reference Types and Higher Order Types
 Annotations and Generics
 Inheritance Models
 Single and Multiple
 Polymorphism and Prototyping
 Mix-ins: Interfaces, Extensions, Traits and Modules
 Memory Management
 Manual, Automatic and Garbage Collected
 Constructors, Destructors, Initializers and Finalizers
 Dependency System
 JARs, DLLs, Gems and Static Libraries
The real one! 

SyntacticalOverview
Identifiers
Letters Numerals Operators Operator Examples
C++ Unicode? After first letter Predefined set void operator++()
C# Unicode After first letter Predefined set void operator--()
Java Unicode After first letter None
Scala Unicode After first letter All val + = 1
Ruby Unicode? Anywhere? Most def ಠ_ಠ(x, y)
JavaScript Unicode After first letter None

SyntacticalOverview
Literals
Numeric Objects Functions
C++ 123456, 07, 0xFF int x[] = {0}
C# 123456, 07, 0xFF
new { Name = "Ali" }
new Dict<int, int> {
{1,2}, {3,4} }
x => y, () => {}
Java
123_456, 0b101,
123456, 07, 0xFF
int x[] = {0}
Scala 123456, 07, 0xFF
(1, 2)
{ 'age' -> 24 }
x => y, () => {}
Ruby
123_456
123456, 07, 0xFF
[1], {b:2}, 0..5
JavaScript 123456, 07, 0xFF [1], {b:2}

SyntacticalOverview
Symbols &Annotations
Java @Deprecated
class Address {
}
[Obsolete]
class Program
{
}
C#
Scala @cloneable
class Address {
val db_column =
'address_line_1
}
person = {
name: 'Ahmad',
age: 26
}
Ruby

SyntacticalOverview
class MyFirstClass {
public:
// pure virtual function makes a class abstract
virtual void firstMethod() = 0;
};
class MySecondClass {
public:
int secondMethod() { return 7; }
};
class MyParentClass : MyFirstClass {
public:
/* override */
void firstMethod() { }
};
C++ Classes
&Templates

SyntacticalOverview
template<typename T>
class MyClass : MyParentClass, MySecondClass {
T value;
public:
MyClass(T value) { setValue(value); }
T getValue() { return value; }
void setValue(T value) { this->value = value; }
};
// example usage
MyClass<string> obj("");
obj.setValue("Hi");
cout << obj.getValue();
C++ Classes
&Templates

SyntacticalOverview
public interface MyFirstInterface
{
void firstMethod();
}
interface MySecondInterface
{
int secondMethod();
}
abstract class MyParentClass
{
public void firstMethod() { }
public sealed override string ToString()
{
return base.ToString();
}
}
C# Classes,
Interfaces &
Generics

SyntacticalOverview
sealed class MyClass<T> :
MyParentClass, MyFirstInterface, MySecondInterface
{
public MyClass(T value) { Value = value; }
public T Value { get; set; }
public int secondMethod() { return 7; }
}
// example usage
var obj = new MyClass<string>("");
obj.Value = null;
Console.WriteLine(obj.Value);
C# Classes,
Interfaces &
Generics

SyntacticalOverview
Func<int, int, int> f =
(int x, int y) => x * 2;
Action<int> a =
x => { Console.WriteLine(x); };
var v = new { Name = "Mohammad", Age = 24 };
C#
Anonymous
Types and
Functions

SyntacticalOverview
interface MyFirstInterface {
void firstMethod();
}
interface MySecondInterface {
int secondMethod();
}
abstract class MyParentClass
implements MyFirstInterface {
@Override public void firstMethod() {}
@Override public final String toString() {
return super.toString();
}
}
Java Classes,
Interfaces &
Generics

SyntacticalOverview
public final class MyClass<T>
extends MyParentClass implements MySecondInterface {
private T value;
public MyClass(T value) { setValue(value); }
public T getValue() { return value; }
public void setValue(T value) {
this.value = value;
}
@Override public int secondMethod() { return 7; }
}
// example usage
MyClass<String> obj = new MyClass<>("");
obj.setValue(null);
System.out.println(obj.getValue());
Java Classes,
Interfaces &
Generics

SyntacticalOverview Runnable r = new Runnable() {
public void run() { }
};Java
Anonymous
Classes

SyntacticalOverview
trait MyFirstTrait {
def firstMethod()
}
trait MySecondTrait {
def secondMethod = 7
}
abstract class MyParentClass extends MyFirstTrait {
override def firstMethod() {}
final override def toString = super.toString
}
final class MyClass[T](var value: T)
extends MyParentClass with MySecondTrait
object MyClass {
// companion object
def test() {
val obj = new MyClass("")
obj.value = null
println(obj.value)
}
}
Scala Classes,
Traits and
Generics

SyntacticalOverview
val f = (x: Int, y: Int) => x+y
val list = List(-1, 2, 3.0, 5, 7.12)
list.filter(_ < 5)
list.filter(signum(_) != 0)
abstract class Printer {
def print // abstract
}
val p = new Printer {
def print { println("Hi") }
}
Scala
Anonymous
Classes and
Functions

SyntacticalOverview
module MyFirstModule
def first_method
end
end
module MySecondModule
def second_method
7
end
end
class MyParentClass
include MyFirstModule
# override
def to_s
super
end
end
Ruby Classes
and Modules

SyntacticalOverview
class MyClass < MyParentClass
include MySecondModule
def initialize(value)
@value = value
end
def value
@value
end
def value= value
@value = value
end
end
# example usage
obj = MyClass.new('')
obj.value = nil
puts obj.value
puts obj.to_s
Ruby Classes
and Modules

SyntacticalOverview
[1, 2, 3].each { |x| puts x }
[1, 2, 3].each do |x|
puts x
end
c = Class.new
c.send :include, MyFirstModule
obj = c.new
Ruby
Anonymous
Classes and
Functions

SyntacticalOverview
 No Classes
 The following code tries to emulate it
 Warning: the following code is unreliable
JavaScript

SyntacticalOverview
function MyFirstClass() {
this.firstMethod = function () { }
}
function MySecondClass() {
this.secondMethod = function () { return 7; }
}
function MyParentClass() {
// Call the parent constructor
MyFirstClass.call(this);
this.toString = function () {
// take care, this is not exactly super!
return this.prototype.toString();
}
}
MyParentClass.prototype = new MyFirstClass();
MyParentClass.prototype.constructor = MyParentClass;
JavaScript
Function
Prototypes

SyntacticalOverview
function MyClass(value) {
MyParentClass.call(this);
MySecondClass.call(this);
this.value = value;
this.getValue = function () { return this.value; }
this.setValue = function (value) {
this.value = value;
}
}
MyClass.prototype = new MyParentClass();
MyClass.prototype.constructor = MyClass;
// example usage
var obj = new MyClass("");
obj.setValue(null); // or obj.value = null;
alert(obj.getValue()); // or alert(obj.value);
JavaScript
Function
Prototypes

SyntacticalOverview
Imports
C++
• #include <iostream>
C#
• using System.Collections;
• using Con = System.Console;
Java
• import java.util.*;
• import static java.lang.Math.*;
Scala
• import scala.io._
• import java.lang.Math.{IEEEremainder => rem, _}
Ruby
• require 'date/format'
• load 'date/format.rb'
N/AJavaScript

SyntacticalOverview
Variables
C++
• int x; auto y = 0; const int &z = x; char *p;
• vector<int> x; const vector<int> x;
C#
• int x; const int x; readonly int x; var x = 0;
• List<int> x; readonly List<int> x;
Java
• int x; final int x;
• List<Integer> x; final List<Integer> x;
Scala
• var x: Int; val x: Int;
• var x: List[Int]; val x: List[Int];
Ruby
• x = 0; @x = 1; @@x = 2
• Constant = 0; CONSTANT = 0
var x;JavaScript

SyntacticalOverview
Parameters andArguments
All
Languages
except JavaScript
Default
Arguments
(except Java)
Variable
Arguments
Named
Arguments
(except C++)

SyntacticalOverview
Parameters andArguments
void f(int x, const char *p = "abc", ...)C++
• Positional arguments only, with constant default arguments and
un-typed varargs
void f(int x, string s = "ab", params int[] y)C#
• f(1, s: "def"); f(0, null, 1, 2, 3)
• Named, constant default and typed variable arguments supported
void f(int x, String... args)Java
• Positional arguments only, with typed variable arguments
def f(x: Int, y: Int = 0, z: =>Long, s: Int*)Scala
• f(1, z = System.nanoTime())
• Named & expr. default arguments, typed varargs, and call-by-name
def f(x, y = 0, z = @a, tags: [], *names)Ruby
• Named, expression default and variable arguments
function f(x)JavaScript
• Nothing special; variable arguments supported artificially

SyntacticalOverview
EmbeddedSyntax
C# LINQ
var query =
from c in categories
join p in products
on c equals p.Category
into ps
from p in ps.DefaultIfEmpty()
select new {
Category = c,
ProductName = p.ProductName
};
Scala XML
val html =
<html>
<body>
<h1>Hello Scala!</h1>
</body>
</html>

Agenda
Syntactical Overview
Identifiers, Literals, Symbols and Annotations
Classes, Templates, Functions and Code Blocks
Imports,Variables and Parameter Passing
Embedded Syntax (e.g. LINQ, XML)
 Programming Paradigms
 Procedural, Functional and Object-Oriented
 Meta-programming
 Type Systems
 Static, Dynamic, Strong and Weak
 ValueTypes, Reference Types and Higher Order Types
 Annotations and Generics
 Inheritance Models
 Single and Multiple
 Polymorphism and Prototyping
 Mix-ins: Interfaces, Extensions, Traits and Modules
 Memory Management
 Manual, Automatic and Garbage Collected
 Constructors, Destructors, Initializers and Finalizers
 Dependency System
 JARs, DLLs, Gems and Static Libraries
The real one! 

Break!
Ruby
JavaScript

Programming Paradigms

TypeSystems
Static
• C++
• C#
• Java
• Scala
Dynamic
• Ruby
• JavaScript
Strong
• C#
• Scala
Weak
• Ruby
• JavaScript
C#
Scala

TypeSystems
ValueTypes
ReferenceTypes
HigherOrderTypes
C#
Scala
Ruby
JS?
C++?
C++
C#
Java
Scala
Ruby
JS
C++
C#
Scala

TypeSystems
Annotations
• C#
• Java
• Scala
Generics
• C#
• Java
• Scala
Templates
• C++

Memory Management
Manual
C++
Pointers
Automatic
C++
auto_ptr Destructors
Garbage
Collected
C#,
Java,
Scala,
Ruby & JS
Unreliable
Finalizers
(C#: CFO)

Memory
Management
 All languages support constructors.
 Dynamic languages (i.e. Ruby and JavaScript)
provide only one constructor, and rely on the
dynamic nature of their parameters.
 Only C++ has deterministic destructors.
 C#, Java, Scala and Ruby support finalizers, but
they are not guaranteed tor run.
 JavaScript has no finalizers, because all memory is
GC’d.
 The .NET framework provides a
CriticalFinalizerObject parent class,
supporting semi-guaranteed finalization.

MemoryManagement
Class Initializers
C++
class MyClass { static int x; };
MyClass::x = 0;
C#
static class MyClass {
static int x;
static MyClass() { x = 10; } }
Java
class MyClass {
static int x;
static { x = 10; } }
Scala
object MyClass {
var x: Int;
x = 10 }
Ruby
class MyClass
@@x = 10
end
JS
function MyClass() {}
MyClass.x = 10;

Polymorphism
and
Prototyping
 Only statically compiled languages have
polymorphism
 Dynamic languages don’t need polymorphism.

Polymorphism
C++
class C1 {
public:
void nonVirtualM() {}
virtual void virtualM() {}
};
class C2 : C1 {
public:
void nonVirtualM() {}
virtual void virtualM() {}
};
C#
class C1
{
public void nonVirtual() {}
public virtual void @virtual() {}
}
class C2 : C1
{
public new void nonVirtual() { }
public override void @virtual() {}
}

Polymorphism
Java
class C1 {
public void virtual() {}
}
class C2 extends C1 {
@Override
public void virtual() {}
}
Scala
class C1 {
def virtual {}
}
class C2 extends C1 {
override def virtual {}
}

JavaScript
Prototyping
// define the Person Class
function Person() { }
Person.prototype.walk = function() { alert('Walk'); };
Person.prototype.hello = function() { alert('Hi'); };
function Student() { // define the Student class
Person.call(this); // Call the parent constructor
}
// inherit Person
Student.prototype = new Person();
// correct the constructor pointer
// because it points to Person
Student.prototype.constructor = Student;
// replace the hello method
Student.prototype.hello = function() { alert('hey'); }
// add bye method
Student.prototype.bye = function () { alert('Bye'); }

InheritanceCardinality
Single
C#
Java
JavaScript
Mix-in
Scala
Ruby
Multiple
C++

Mix-ins
Interfaces
 Abstract function declarations only
 No data, no implementation
 Can be emulated
 In C++: with pure virtual functions
 In Scala: with traits
interface MyInterface
{
void MyMethod();
}
C#
interface MyInterface {
void myMethod();
}
Java

Mix-ins
Extensions
 The ability to “attach” new methods
to existing classes or objects
 Emulated in Scala using implicit
conversions
static class Extensions {
public static void
Print(this string s) {}
}
// to call it:
"abc".Print();
C#
class String
def print
end
end
# to call it:
'abc'.print
Ruby
String.prototype.print =
function() {};
// to call it:
'abc'.print();
JS

Mix-ins
Traits and Modules
 Evolution of interfaces: allowing
implementations
 Almost like classes, except that they
cannot be instantiated
 Traits cannot have instance
variables, while modules can.
trait T1 {
def print {}
}
class C1
// to use it:
val p = new C1 with T1
p.print
Scala
module Named
def name
@name ||= nil; end
def name=(name)
@name = name; end
end
# to use it:
class Person; include Named;
end
Ruby

DependencySystem
C++
Static Libraries and
Dynamically Loaded Libraries (DLLs) or SOs
C#
Dynamically Loaded Libraries (DLLs)
NuGet
Java
JavaArchives (JARs)
Maven or Ivy
Scala
JavaArchives (JARs)
Simple BuildTool (SBT)
Ruby
Gems
Bundler
JS Node Package Manager (NPM)

Agenda
Syntactical Overview
Identifiers, Literals, Symbols and Annotations
Classes, Templates, Functions and Code Blocks
Imports,Variables and Parameter Passing
Embedded Syntax (e.g. LINQ, XML)
Programming Paradigms
Procedural, Functional and Object-Oriented
Meta-programming
Type Systems
Static, Dynamic, Strong and Weak
ValueTypes, Reference Types and Higher Order Types
Annotations and Generics
Inheritance Models
Single and Multiple
Polymorphism and Prototyping
Mix-ins: Interfaces, Extensions, Traits and Modules
Memory Management
Manual, Automatic and Garbage Collected
Constructors, Destructors, Initializers and Finalizers
Dependency System
JARs, DLLs, Gems and Static Libraries
The real one! 

That’s it.
Thank you!
Ruby
JavaScript

6 Programming Languages under investigation

More Related Content

What's hot (19)

Similar to 6 Programming Languages under investigation (20)

More from Hosam Aly (6)

Recently uploaded (20)

6 Programming Languages under investigation

Editor's Notes