anoopelias

ObjMaker = function() {
	this.a = "first";
};

ObjMaker.prototype.b = "second";

var objMaker = new ObjMaker();
ObjMaker.prototype.c = "third";
console.log("objMaker.a " + objMaker.a); // Prints 'first'
console.log("objMaker.b " + objMaker.b); // Prints 'second'

anoopelias

import java.util.WeakHashMap;

import junit.framework.Assert;

import org.junit.Test;

public class MemoryLeakTest {

	@Test
	public void test_stack_memory_leak() {

anoopelias

Closure..

Couple of months back, when I started looking at Scala as a programming language, a key computer programming concept came up - Closure. I couldn't find a page which explains what it is and how to use it, so here it goes,

Definition

A closure is a first-class function with free variables that are bound in the lexical environment. (Source wikipedia)

First-class functions

First-class functions are those that can be assigned to a variable to be carried around and be executed at a later point of time. Subsequently this will enable those functions being passed as arguments, as well as returned back. An example in Scala is shown below.

anoopelias

package concept

object Impicit {
  implicit val i : Int = 1                        //> i  : Int = 1
  
  def add(a:Int)(implicit b:Int) = a + b          //> add: (a: Int)(implicit b: Int)Int
  
  add(10)(15)                                     //> res0: Int = 25
  add(10)                                         //> res1: Int = 11
}

anoopelias

package concept

object ImpicitConversion {

  class Val {
    def value = 10
  }
  
  /* Implicit Conversion begins */

anoopelias

scala> case class Name(name:String)
defined class Name

scala> val a = Name("Anoop")
a: Name = Name(Anoop)

scala> val Name(n) = a
n: String = Anoop

scala>

anoopelias

Typically, you can't use a 'new' operator on a generic type. This is because of type erasure.

scala> def create[T] = new T
<console>:7: error: class type required but T found
   def create[T] = new T
                       ^

Scala gives a way of getting around this problem, with the Manifest class.

scala> def create[T](implicit m:Manifest[T]) = m.erasure.newInstance

anoopelias

Assume you have a couple of classes,

case class Person(name: String, age: Int)
case class Employee(person: Person, salary: Double)

Lets say for some reason,

• You don't want to change this source, but
• You should be able to add features save(person) and save(employee), and
• You need clearly separate implementations for both the types,

anoopelias

public class AppleStock {
 
    public static void main(String[] args) {
        int[] stockPricesYesterday = { 500, 501, 503, 495, 503 };
 
        int buy = -1;
        int sell = -1;
        int lowest = -1;
 
        for (int i = 0; i < stockPricesYesterday.length; i++) {

anoopelias

There are two forms of recursion,

• Tail Recursion : The return value is calculated as a combination of the value of current subroutine and the return value of the next call. Example,

   int factorial(int a) {
       if(a==0)
           return 1;
       else
           return a * factorial( a-1 );
  

}