In the last post we discussed about method & getter/setter, we will continue our discussion on other aspects of Dart classes in this post, as well.

Operators can be thought of as functions with special notation ,like other OO languages Dart also supports operator overloading. You have to use the operator keyword to redefine an operator as shown below:

class Complex
{
  int real,imaginary;
  Complex(this.real,this.imaginary){}

  Complex operator +(Complex c){
    return new Complex(this.real+c.real,this.imaginary+c.imaginary);
  }
  Complex operator -(Complex c){
    return new Complex(this.real-c.real,this.imaginary-c.imaginary);
  }
  String toString(){
    var retval;
    if(imaginary<0) {
      retval = real.toString() + " -i" + imaginary.abs().toString();
    }
    else{
      retval = real.toString() + " +i" + imaginary.toString();
    }
    return retval;
  }
}

Last but not the least, is inheritance.Dart allows us to create subclasses from a base class using the extends keyword like Java.The following snippet demonstrates inheritance and method overriding.

class A{
  void M1(){
    print("A::M1()");
  }
}
class B extends A{
  void M1(){
    print("B::M1()");
  }
}

void main() {
 var a = new B();
 a.M1();
}

//Prints:B::M1()

We will add an instance variable and try to override the same.

class A{
  var x = 10;
  void M1(){
    print("A::M1()");
  }
}
class B extends A{
  var x = 1;
}

There is an exception:

‘D:\Dart\DartFunctionsDemo.dart’: Error: line 24 pos 7: field ‘x’ of class ‘B’ conflicts with instance member ‘x’ of super class ‘A’.

Apparently it seems that Dart does not support overriding instance variables. But to my surprise the code compiles in http://try.dartlang.org/s/i20r. Not sure if I am landing up in any version issues or what exactly is going on.

Similar to get the methods the getter/setters can also be overridden as shown below:

class A{
  var x = 10;
  int get X() {
    print("A::X()");
    return x;
  }
  void M1(){
    print("A::M1()");
  }
}
class B extends A{
  var x_ = 1;
  int get X() => x_;
  void M1(){
    print("B::M1()");
  }
}
void main() {
 var a = new B();
 a.M1();
 print(a.X);
}
//Prints:10

We can invoke the base class functions using super keyword as in Java.

class B extends A{
  var x_ = 1;
  int get X() => x_;
  void M1(){
    super.M1();
    print("B::M1()");
  }
}

Let’s add constructors in the class A and B as shown below:

void main() {

 var a = new B();

}

class A{
  var x = 10;
  int get X() {
    print("A::X()");
    return x;
  }
  A(){

    print("A constructor");

  }
  void M1(){
    print("A::M1()");
  }
}
class B extends A{
  var x_ = 1;
  int get X() => x_;
  B() {
    print("B constructor");
  }
  void M1(){
    super.M1();
    print("B::M1()");
  }
}

The program prints:

A constructor
B constructor

This clearly shows that the base constructor is invoked followed by the derived class.

Let’s tweak the code in A by adding a parameter in the constructor.

class A{
  var x = 10;
  int get X() {
    print("A::X()");
    return x;
  }
  A(this.x){

    print("A constructor");

  }
  void M1(){
    print("A::M1()");
  }
}

After running the program we will get the following error.

‘D:\Dart\DartFunctionsDemo.dart’: Error: line 26 pos 7: unresolved implicit call to super constructor ‘A()’
  B() {
      ^

This is because there is no call made to the constructor A(this.x) while instantiating B. Changing the constructor definition in B and explicitly invoking the super class constructor solves the problem.

B(a):super(a) {
  print("B constructor");
}

This is all about classes in the next post we will discuss about interfaces.

In the last post we have discussed about classes and object instantiation/initialization in Dart.In this post we will take a look methods and getter/setters.

Methods in Dart are two types : instance methods and class level static methods like any other OO language. The code below shows the definition & invocation of a typical instance method.

class Customer
{
  int id;
  String fn;
  String ln; 

  String getFullName(){
    return fn + " " + ln;
  }
}

void main() { 

  var a = new Customer();
  a.fn ="Sankarsan";
  a.ln ="Bose";
  print(a.getFullName());
}
//Prints: Sankarsan Bose

The following example shows the definition & invocation of a typical class level static method.

class Logger
{
  static void LogToConsole(String msg)
  {
    print(msg);
  }
}

void main() { 

  Logger.LogToConsole("Hello World !!");
}

Dart also let you define getter/setter using get and set keywords as shown below:

class Customer
{
  int id;
  String fn;
  String ln; 

  String get firstName() => fn;
  set firstName(String value) => fn = value; 

  String get lastName() => ln;
  set lastName(String value) => ln = value; 

  String get fullName() => firstName + " " + lastName;
}

void main() { 

  var c = new Customer();
  c.firstName ="Sankarsan";
  c.lastName = "Bose"; 

  print(c.fullName);
}

The getter/setter are defined as methods and accessed as fields/properties.Since these are defined as methods you can provide additional validations here as shown below:

set firstName(String value) {
  if(value != null && value.trim().length>0) fn = value;
}

But if I compare to a language like C# where there is support for properties, the major difference is that Dart does not let you define access modifier (private) at class level and the whole purpose from encapsulation standpoint seems to be lost.

However the Dart designers feel differently – http://www.dartlang.org/articles/idiomatic-dart/#fields-getters-setters

This blurring the line between fields and getters/setters is fundamental to the language. The clearest way to think of it is that fields are just getters and setters with magical implementations. This means that you can do fun stuff like override an inherited getter with a field and vice versa. If an interface defines a getter, you can implement it by simply having a field with the same name and type. If the field is mutable (not final) it can implement a setter that an interface requires.

In practice, what this means is that you don’t have to insulate your fields by defensively hiding them behind boilerplate getters and setters like you would in Java or C#. If you have some exposed property, feel free to make it a public field. If you don’t want it to be modified, just make it final.

Dart is an object oriented language and supports classes and inheritance. A typical Dart class definition is shown below.

class Customer
{
  int id;
  String firstName;
  String lastName; 

  String toString() {
    return firstName + " " + lastName;
  }
}

The object of this class is created using the new operator as shown below.

void main() {
  var c = new Customer();
  c.id = 1;
  c.firstName = "Sankarsan";
  c.lastName  = "Bose";
  print(c);
}

One notable difference with most of the typical OO languages we work with is, the access modifier. Here everything is public by default and privacy level is controlled at the package level rather than the class level. You can find an interesting discussion in the thread below on such a design decision:

http://groups.google.com/a/dartlang.org/group/misc/browse_thread/thread/5a5951ae0d334dde

Each class has a default constructor. The above example makes use of the same.We can also define constructor with parameters as shown below:

class Customer
{
  int id;
  String firstName;
  String lastName; 

  Customer(id,firstName,lastName){
    this.id = id;
    this.firstName = firstName;
    this.lastName = lastName;
  }
  String toString() {
    return firstName + " " + lastName;
  }
}

This needs to be instantiated as

var c = new Customer(1,"Sankarsan","Bose");

We can shorten the constructor as

Customer(this.id,this.firstName,this.lastName){}

If we try to define another constructor as

Customer(id,firstName){
  this.id = id;
  this.firstName = firstName;
  this.lastName ="";
}

We get the error

‘D:\Dart\DartFunctionsDemo.dart’: Error: line 33 pos 3: field or method ‘Customer.’ already defined
  Customer(id,firstName){

This is because overloading is not supported.

However we can have multiple constructors using named constructor. Some best examples of named constructors are there in the library class Date.

/**
  * Constructs a new [Date] instance with current date time value.
  * The [timeZone] of this instance is set to the local time-zone.
  */
Date.now();

We can create a Date instance as,

Date d = new Date.now();

Now let’s add two final variables to our class definition.

class Customer
{
  final int x,y;
  int id;
  String firstName;
  String lastName; 

  Customer(this.id,this.firstName,this.lastName){}

  String toString() {
    return firstName + " " + lastName;
  }
}

The final variables needs to be initialized before object creation and it will lead to the following error:

‘D:\Dart\DartFunctionsDemo.dart’: Error: line 32 pos 49: final field ‘x’ not initialized
  Customer(this.id,this.firstName,this.lastName){}

This can be achieved through Initializer List as shown below:

Customer(this.id,this.firstName,this.lastName):x=0,y=0{}

There is another type of constructor called Factory Constructor. This constructor does not create a new instance of the class but returns an instance based on logic like Singleton or from a cache.

The code below shows a Singleton implementation. The _internal is basically like a private constructor used from the factory constructor to internally create an instance.

class Config
{
  static Config cfg ;
  int x;
  factory Config(){
    if(cfg==null)
      {
       cfg = new Config._internal();
      }
    return cfg;
  }
  Config._internal(){}
}

The snippet shown below will print 10 proving that factory constructor is returning the same instance every time it is invoked.

void main() {
  Config c = new Config();
  c.x =10;

  c = new Config();
  print(c.x);

}

There is another type of constructor called Constant Constructors used to create compile time constant or immutable object using const keyword as shown below:

class Test{
  final int x,y;
  const Test (this.x,this.y);
}

Constant object with identical properties are basically the same object instance. So the code below will print true.

void main() {
  var a = const Test(10,20);
  var b = const Test(10,20);
  print(a==b);
}

So far we have discussed only about constructor, more to follow on classes.

In the Dart world functions are first class citizens, they can be treated as objects, passed as parameters to other functions and returned from functions.To start with let’s look at the simplest notation.

void main() {

  print(m1(10,20));
}

m1(a,b)
{
  return a+b;
}
//prints 30

The definition of m1 is quite same as a function definition in javascript apart from the fact that here even the function keyword is also not required.However it is advised to use the types in the function definition. With types the function definition will change to:

int m1(int a,int b)
{
  return a+b;
}

The following variation is also supported:

m1(int a,int b)
{
  return a+b;
}

Here the return type is not specified and hence it is dynamic.But,in this case obviously the return type will be expected to be an “int”. So the following call will give an error in checked execution mode.

String s =m1(10,20);

Unhandled exception:
‘D:\Dart\DartFunctionsDemo.dart’: Failed type check: line 3 pos 15: type ‘Smi’ is not assignable to type ‘String’ of ‘s’.
0. Function: ‘::main’ url: ‘D:\Dart\DartFunctionsDemo.dart’ line:3 col:15

Don’t get confused by the word Smi that stands for small int. VM internally treats it as small int. I think error message  is not that user friendly as “int” is the type available for programmers.

The other two possible variations can be:

m1(int a,b)
{
  return a+b;
}

m1(a,int b)
{
  return a+b;
}

The following call to the above function definition returns 1020.

String s =m1("10",20);

Okay. So the dynamic type is determined to be of type String. Good. As expected. Let’s change the function a little bit by reversing parameters a and b in the addition expression:

 m1( a,int b)
 {
  return b+a;
 }

This leads to an error quite obviously adding string to an int.

Failed type check: line 1468 pos 22: type ‘OneByteString’ is not assignable to type ‘num’ of ‘other’.

Dart also supports optional arguments and named parameters.

 m1( int a,int b,[int c])
 {
   return (b+a)*c;
 }

Here c is the optional argument.

The following code leads to a NullPointerException as the default value of optional argument is null.

print(m1(10,20));

We can also provide default values as shown below:

m1( int a,int b,[int c=1])
{
  return (b+a)*c;
}

In case there are multiple optional arguments we can also specify their names during function call.

void main() {

  print(m1(10,20,c:10));
}

m1( int a,int b,[int c=1,int d=1])
{
  return (b+a)*(c+d);
}

As mentioned in the beginning here functions are first class citizens. The following code shows how we can pass function as arguments.Here m1 is passed as  argument to m2.

void main() {
  print(m2(m1,20,30));
}

m1( int a,int b,[int c=1,int d=1])
{
  return (b+a)*(c+d);
}

m2(f,a,b)
{
  return f(a,b);
}
//prints 100

Here we can further simplify the function definition as [Quite similar to Lambda expressions for those who are familiar with C#]

 var m = (a,b) => a+b;

And then calling,

print(m2(m,20,30));

Similarly a function can also return a function. In the code below we are returning a function to add/multiply based on an input flag.

m1(flag)
{
  var r;
  if(flag==1) r = (x,y) => x+y;
  if(flag==2) r = (x,y) => x*y;
  return r;
}

Then we can invoke the same as,

print(m2(m1(1),20,30));

This is all about functions in brief. In the next post we will move into Classes.

Dart is inherently a dynamically typed language like Javascript. The variables can be declared using the “var” keyword as shown below:

void main() {

  var i=10;
  i=10;
  print(++i);
}

This program quite obviously prints out 11 as expected.

Let’s modify it further by assigning a String value as shown below:

void main() {

  var i=10;
  i=10;
  print(++i);
  i="A";
  print(++i);
}

The program will print 11 and A1. So this is a typical behavior same as any dynamic language e.g. javascript.

Dart also support optional static typing.I can change the declaration of i to a Built-In type int.

void main() {

  int i=10;
  i=10;
  print(++i);
  i="A";
  print(++i);
}

But to my surprise the program still runs in Dart Editor without any error.This is because Dart support two execution modes:

1. Checked Mode – If optional static types are provided while defining the variables then the type checks are performed at runtime.
2. Production Mode – No type checkings are performed. This is the default mode.

I can switch the execution mode in Dart Editor as shown below:

As expected I get an error at runtime:

Unhandled exception:
‘D:\Dart\DartFunctionsDemo.dart’: Failed type check: line 8 pos 5: type ‘OneByteString’ is not assignable to type ‘int’ of ‘i’.
0. Function: ‘::main’ url: ‘D:\Dart\DartFunctionsDemo.dart’ line:8 col:5

This in short is all about variables in Dart.. Next we will look into functions.

Prologue

Today, web is all about being near real-time.We all expect to see the updates we are supposed to see e.g.what my friends are doing on Facebook, we expect our messages & news will be refreshed instantly in our web pages. With advent of technologies like AJAX , Comet etc. gone are the days where we will have to refresh our web pages (using browser refresh button) every now and then, to see updated data.But all this partial page refreshes are happening using XmlHttpRequest , iframes or long polling. There was no standardized protocol to handle this and each of these techniques landed up initiating multiple HTTP connections to the server.So here comes WebSocket – a new protocol specification from W3C as part of HTML5.

WebSocket

WebSocket is a protocol for two-way communication between client (in most cases you can assume it will be the browser) and server (a TCP/HTTP server supporting WebSocket) using a single TCP connection.This will take away the overhead of

• Multiple TCP connections
• Same/similar header data being transferred each time over the wire
• Customized ways to tracking or correlating requests and responses.

The WebSocket specification has two parts one, the WebSocket protocol specification and another the WebSocket API specification which is the spec for client API used for communicating to the server.As of now,

• Google Chrome natively supports WebSocket API
• Mozilla Firefox supports the same with a different interface called MozWebSocket instead of WebSocket
• IE 9 does not support WebSocket API at all

The webservers supporting WebSockets are

• Jetty
• Node.js with Socket.IO
• IIS 8 on Windows 8 ( This is still in a developer preview and not commercially released)
• Tornado

In this post we will focus on how we can work with WebSocket with Node.js and Socket.IO

Node.js

Node.JS is a javascript based event driven highly scalable server framework running on Google’s V8 Javascript Engine.

Node now has a windows installer which can be downloaded from http://nodejs.org/dist/v0.6.6/node-v0.6.6.msi

Once you have installed node you need a good javascript editor (Sublime Text is my choice) to develop your first HTTP Server as shown below:

//Import module http
var http = require('http');
http.createServer(function(request,response){
    //Set response header
    response.writeHead(200,{'Content-Type':'text/html'});
    //Write response html
    response.end("<h1>Hello World !!!! I am running on Node.js</h1>");
}).listen(8124); // HTTP Server listens at port 8124, default host is localhost
console.log('Server started at http://localhost:8124')

There are many objects in Node which generates or emits events. These are called the event emitters.e.g. the http.Server object is an event emitter. The event emitter expose a generic function named on, this function takes in event name and callback as arguments.
Using this function we can add call back to the server which will get fired when any new user gets connected as shown in the snippet below:

//Import module http
var http = require('http');

var server = http.createServer(function(request,response){
    //Set response header
    response.writeHead(200,{'Content-Type':'text/html'});
    //Write response html
    response.end("<h1>Hello World !!!! I am running on Node.js</h1>");
}).listen(8124); // HTTP Server listens at port 8124, default host is localhost

server.on('connection', function (stream) {
  console.log('Connection !!!!');
});

console.log('Server started at http://localhost:8124')

Now let’s take a quick look into what socket.io is about.

Socket.io

Socket.io is a module for for node.js which enables socket like near real-time communication over browser. In reality it supports the following transport along with web sockets:

• xhr-polling
• xhr-multipart
• htmlfile
• websocket
• flashsocket
• jsonp-polling

So it support communication even with browsers where WebSocket is not supported.But we will restrict this discussion primarily to WebSockets.

The code for a simple socket server is shown in the code below:

//Import Socket.io module
var io = require('socket.io');
//Creates a HTTP Server
var socket = io.listen(8124);
//Bind the Connection Event
//This will be fired every time when a new connection is made
socket.sockets.on('connection',function(socket){

        //This will be fired when data is received from client over a single socket
        socket.on('message', function(msg){
            console.log('Received message from client ',msg);
        });
        //Emit a message to client
        socket.emit('greet',{hello: 'world'});
        //This will fire when the client has disconnected
        socket.on('disconnect', function(){
            console.log('Server has disconnected');
        });
});

Now let’s look at the following client code.We need to do the following to build a simple HTML client.

• We need to add a reference socket.io.js. In this case I have referenced it from my node server itself.If the HTML is also rendered from the node server we can use relative path for the same.
• Create a socket and then bind the appropriate event listeners.

<html>
    <title>WebSocket Client Demo</title>
    script src="http://localhost:8124/socket.io/socket.io.js"></script
   script>
        //Create a socket and connect to the server
        var socket = io.connect('http://localhost:8124/');
        //This event will be emitted once connection is made to the server
        socket.on("connect",function(){
            alert("Client has connected to the server");
        });
        //This event will be client receives a "greet" message from server
        socket.on('greet', function (data) {
            alert(data.hello);
            }
        );
    </script
</html>

Now with all these code (server and client) we will run the same and analyze the network calls to understand how the interaction is happening.

The code shows two alerts once when it’s connected to the server and then when it receives the greet message from the server.

The general URL scheme followed by socket.io is

[scheme] ‘://’ [host] ‘/’ [namespace] ‘/’ [protocol version] ‘/’ [transport id] ‘/’ [session id] ‘/’ ( ‘?’ [query] )

Here ,

• Scheme http/https
• Host is the hostname of the socket server
• Namespace is the Socket.IO namespace default is socket.io
• Protocol Version client support default is 1
• Transport ID is for different supported transports like WebSockets, xhr-polling etc.
• Session ID , the web socket session unique session id for the client.

First a http request is issued as shown below with a timestamp parameter.

Due to the absence of transport and session id server identifies this to be a new connection request and returns the following response containing session id and transport options.

Here I am using Google Chrome which supports websocket so another request (HTTP 101 – Protocol Switching request) is issued switching the protocol to websocket as shown below.

Akka is a framework providing Erlang like Actor based concurrency.It runs on the JVM, and has both Scala and Java APIs available.In this post we will take a look into the actors in Akka and how we can perform some basic tasks like starting, stopping the actors and passing messages.

We first need to define an actor by extending akka.actor.Actor class and overriding the receive method as shown below.This is a simple actor just echoes on the console whatever input is fed to it.

class EchoActor extends Actor {
  def receive = {
    case s: String => println(s)
  }
}

To create an instance of the Actor we need to use the static member Actor.actorOf as shown below:

val echo = Actor.actorOf[EchoActor]

It can also be instantiated as

val echo = Actor.actorOf(new EchoActor())

The actorOf method return reference of an actor as instance of akka.actor.ActorRef class.

Next step is to start the actor as shown below:

echo.start()

We can pass a message to the actor using ! symbol as:

echo ! "Hello World"

The complete program looks something like.

package main
import akka.actor.Actor

case object Start

object Main {
  def main(args: Array[String]): Unit = {
    println("Start");
    val echo = Actor.actorOf[EchoActor]
    echo.start()
    echo ! "Hello World"
    echo.stop()
  }
}
class EchoActor extends Actor {
  def receive = {
    case s: String => println(s)
  }
}

This is simple…really very very simple. With this much of knowledge about the Akka API let us try to address the problem of creating a circular ring of N nodes, where each node will pass the message received to it’s next node and so on. M no of messages will be passed through the ring so that there are total N*M message exchange.

The steps followed in creating this is

• Create a list of N nodes
• Link them together using message passing
• Send M messages to the first node which will relay it through the ring.

package main
import akka.actor.Actor
import akka.actor.Actor._
import akka.actor.ActorRef
import scala.collection.mutable.ListBuffer

case class Link (node:ActorRef)
object Ring {

  def main(args: Array[String]): Unit = {
    start(2,2)
  }
  def create(N:Int): IndexedSeq[ActorRef] = {
    for(i<-1 to N) yield actorOf(new RingNode("NODE"+i)).start()
  }
  def link(nodes:IndexedSeq[ActorRef]){
    for(i<-0 to nodes.length-1){
      if(i!=nodes.length-1) nodes(i) ! Link(nodes(i+1))
      else nodes(i) ! Link(nodes(0))
    }
  }
  def message(M:Int,node:ActorRef){
    for(i<-1 to M) node ! "Message"+i
  }
  def start(N: Int, M:Int)  {
    val nodes = create(N)
    link(nodes)
    message(M,nodes(0))
  }
}
class RingNode(name: String) extends Actor{
  var  next:ActorRef = null;
  var buffer: ListBuffer[String] = new ListBuffer()
  def receive = {
    case Link(node:ActorRef) => next = node
    case s:String => process(s,next)
  }
  private def process(msg:String,next:ActorRef){
    if(!buffer.contains(msg)){
        println("Node:::"+name)
        println("Received message: %s".format(msg))
        buffer.append(msg)
        next ! msg
    }

  }
}

The output will be,

Node:::NODE1
Received message: Message1
Node:::NODE1
Received message: Message2
Node:::NODE2
Received message: Message1
Node:::NODE2
Received message: Message2

Since last two weeks, I am trying to play around with Go language from Google as and when I am getting some time.But till now I am stuck in the basics only.The variable declaration part seemed very interesting to me.

var i = 10

var i =10
var j=20
var s = "Hello World"

var{
     i= 10
     j=20
     s = "Hello World"
}

Learning new programming languages always has been a fun.To me, it is a way to learn about solving problems in a different ways.Sometimes efficient and sometimes inefficient compared to languages you already know, obviously that depends upon the problem you are trying to solve.Recently I have started learning Clojure – A primarily JVM based (also has it’s CLR version) dynamic language, designed as dialect of LISP.In recent years Clojure has gained popularity quite fast.I first got interested to learn this language after the watching the video( though it’s a two year old one) embedded below.

To get started with Clojure I used the Clojure REPL (Read-Eval-Print-Loop) where we can type in our program and see the output immediately.The actions of the REPL steps are shown in the figure below:

The above steps are quite straightforward to understand but the term marked in red “Clojure Form”.In strict technical terms Clojure is a homoiconic language i.e here code is data. In the evaluation step code is parsed as blocks (FORMS) and converted to data structures. These data structures are then compiled and executed. So we can day Clojure programs are composed of FORMS. Different types of Clojure Forms is shown in the figure below:

We will explore each of these in the upcoming posts but to have an initial understanding let us consider the following examples.

In the next post we will talk a little bit about available IDEs and tools before we jump on actual programming stuff.