Thinkmap Visual Thesaurus


What is it? The Visual Thesaurus is an interactive dictionary and thesaurus with an innovative display that encourages exploration and learning. You'll understand language in an exciting new way. To understand the power of the Visual Thesaurus, you really need to see it in action. Type in your favorite word and give it a try!

Needs Java Enabled Browser

Source: Thinkmap Visual Thesaurus

Create Your Own Web2.0 Logo

Web2.0 Logo Creator: Nice and Beautiful!

If a Boeing 767 runs out of fuel at 41,000 feet what do you have?

If a Boeing 767 runs out of fuel at 41,000 feet what do you have? Answer: A 132 ton glider with a sink rate of over 2000 feet-per-minute and marginally enough hydraulic pressure to control the ailerons, elevator, and rudder. Put veteran pilots Bob Pearson and cool-as-a-cucumber Maurice Quintal in the in the cockpit and you've got the unbelievable but true story of Air Canada Flight 143, known ever since as the Gimli Glider.

Source: Gimli Track Info

Strange statues around the world


Source: Strange statues around the world | - a lifestyle blogzine

Sightseeing with Google Satellite Maps: India

The List of 116 entries is interesting. Here are the popular ones:

Source: Sightseeing with Google Satellite Maps: India

TOP 300 Freeware software


Source: Link to TOP 300 Freeware software! from

FooPlot: Online graphing calculator and plotter


Link to FooPlot: Online graphing calculator and plotter

Mysterious number 6174


Kaprekar's operation

In 1949 the mathematician D. R. Kaprekar from Devlali, India, devised a process now known as Kaprekar's operation. First choose a four digit number where the digits are not all the same (that is not 1111, 2222,...). Then rearrange the digits to get the largest and smallest numbers these digits can make. Finally, subtract the smallest number from the largest to get a new number, and carry on repeating the operation for each new number.

It is a simple operation, but Kaprekar discovered it led to a surprising result. Let's try it out, starting with the number 2005, the digits of last year. The maximum number we can make with these digits is 5200, and the minimum is 0025 or 25 (if one or more of the digits is zero, embed these in the left hand side of the minimum number). The subtractions are:

5200 - 0025 = 5175
7551 - 1557 = 5994
9954 - 4599 = 5355
5553 - 3555 = 1998
9981 - 1899 = 8082
8820 - 0288 = 8532
8532 - 2358 = 6174
7641 - 1467 = 6174

When we reach 6174 the operation repeats itself, returning 6174 every time. We call the number 6174 a kernel of this operation. So 6174 is a kernel for Kaprekar's operation, but is this as special as 6174 gets? Well not only is 6174 the only kernel for the operation, it also has one more surprise up it's sleeve. Let's try again starting with a different number, say 1789.

9871 - 1789 = 8082
8820 - 0288 = 8532
8532 - 2358 = 6174

We reached 6174 again!

Source: Mysterious number 6174

Unlimited List of Awesome Fonts

TV / Movie-related fonts

  • 007 Goldeneye Font
    James Bond GoldenEye Movie Font
  • 28 Days Later Font
    28 Days Later
  • Addams Family Font
    Addams Family Font
  • Air Wolf Font
  • Alias Font
    Alias Font
  • Alien Font
  • Angel Font
    Angel Font
  • ..and many more. Check the Site below to download the fonts.

    Source: Themed Fonts Download Free Movie and Music Fonts

    C# Source Code for Beginners

    This is the source code written based on the concepts explained in the Code Project C# Beginner's Article by Aisha Ikram Titled "Quick C#". This code should be helpful for the beginners to understand the following C# language features:

    • Program structure
    • Namespaces
    • Modifiers
    • Properties
    • Interfaces
    • Function parameters
    • Arrays
    • Indexers
    • Boxing and unboxing
    • Delegates
    • Inheritance and polymorphism

    For more information about the Code Project article, look into


    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    using usethis;
    //Based on the C# programming concepts explained in the CodeProject Article
    namespace FirstCSharpConsole
    sealed class Program //sealed means no class can be inherited from this class

    static void Main(string[] args)
    helloworld obj = new helloworld();
    obj.myVal = 10; //set property
    int a = 10;
    obj.func(ref a);//Pass a by reference
    Console.WriteLine(a); //a will be multiplied by 10

    int m;
    obj.outSomething(out m);
    Console.WriteLine(m);//m is out returned in the prev method as 100

    obj.varparams(0, 1, 2, 3);
    obj.varparams(new int[] { 1, 2, 3 });


    square obj1 = new square();
    obj1.length = 10; //set
    obj1.breadth = 20; //set
    Console.WriteLine(obj1.length); //get
    Console.WriteLine(obj1.breadth); //get

    myShape obj2 = obj1 as myShape; //"as" returns null if obj1 is NOT myShape. else returns myShape
    Console.WriteLine("square is NOT myShape");
    Console.WriteLine("square is myShape");

    Console.WriteLine("Say Hi or Hello");

    //TODO: lock: Its just like a critical section and will be needed in multi threading code

    //checked and unchecked: If the below block is not in unchecked it would have raised exception
    //unchecked means telling the compiler not to check for any exceptions
    int unch = Int32.MaxValue;
    unch= unch* 2;

    demoDelegates d1 = new demoDelegates();
    d1.perform(10, 20);

    //Virtual Functions
    square s1 = new splSquare();

    int k = 10;
    object ko = k; //boxing: package into object
    int j = (int) ko; //unboxing: unpack from object

    }//end of Main

    private static void objIsSomething(helloworld obj)
    if (obj is object) //all objects derive from "object"
    Console.WriteLine("helloworld is object");
    Console.WriteLine("helloworld is not object");
    }//end of class
    }//end of namespace

    namespace usethis
    class helloworld
    int setandget; //property variable
    const int need2InitHereItself = 10; //direct init
    readonly int canInitHereOrInCtor = 20; //direct init
    readonly int willInitInCtor;

    public helloworld()
    willInitInCtor = 30; //indirect init
    canInitHereOrInCtor = 25; //reinit can be done in ctor only
    canInitHereOrInCtor = 26; //reinit can be done in ctor only

    //property is myVal
    public int myVal
    setandget = value; //note that value is a keyword
    return setandget;

    //normal method
    public void func(ref int temp)
    Console.WriteLine(this.myVal); //get property
    temp = temp * 10;

    //try to set readonly var
    //canInitHereOrInCtor = 6999; //will give a compiler error

    //try to use pointer
    //int* k = new int(); //will give a compiler error

    //use unsafe to write pointer code.
    //Note: Need to add /unsafe in compilng options
    int ki = 10;
    int* k = &ki; //Note: NULL is not recognised in C#

    //Array declarations
    int[] a = new int[5]; //single dimensional array
    a[3] = 10;

    int[,] b = new int[5, 10]; //2D array
    b[0, 3] = 20;

    int[][] arrayofarray = new int[2][]; //*jagged* array
    arrayofarray[0] = new int[4];
    arrayofarray[1] = new int[] {1,12,15};//array whose array elements are inited

    //foreach: can be used to iterate in array or collection
    foreach (int iter in a)

    } //end of func

    //demos usage of out param
    public bool outSomething(out int x)
    x = 100;
    return true;

    //unsafe method. just for illustration, not called anywhere
    public unsafe void danger()
    int ki = 10;
    int* k = &ki;

    public void varparams(params int[] arrs)
    Console.WriteLine("number of elements in array are {0}", arrs.Length);
    } //end of class

    interface myShape
    int length
    int breadth
    void draw(object shape);

    }//end of interface

    //implementation class for the interface
    class square : myShape
    int sqX;
    int sqY;

    //get and set interface vars implemented here
    public int length
    return sqX;
    sqX = value;
    public int breadth
    return sqY;
    sqY = value;

    //implement interface methods
    public virtual void draw(object shape)
    Console.WriteLine("interface method draw implemented here (base class)");

    public virtual void playWithSwitch()
    string s = Console.ReadLine();
    switch (s)//strings are allowed in c# unlike c++
    //not having break will give a compiler error
    case "hi"://this is allowed
    case "hello": Console.WriteLine("Hello how r u? bye"); break;
    case "how r u": Console.WriteLine("I'm good thanks.bye"); break;
    case "bye": Console.WriteLine("bye and have a nice day"); break;

    class splSquare : square
    //override will override the base class method,
    //new will stop overriding the base class method
    //Unlike C++, without specifying override will NOT override the base class method
    //Cannot have both new and override methods for draw
    public override void draw(object shape)
    Console.WriteLine("interface method draw implemented here (derived class)");

    //base keyword calls base class method. method is not called. this is just for demo.
    public override void playWithSwitch()


    //To demonstrate indexers
    class shapes : CollectionBase
    public void add(myShape shp)

    //indexer: Indexer is used to write a method to access an element from a collection,
    //by straight way of using [], like an array.
    //its like overloading []
    public myShape this[int index]
    return (myShape)List[index];
    List[index] = value;

    class demoDelegates
    delegate int Operation(int val1, int val2);
    public int add(int val1, int val2)
    return val1 + val2;
    public int subtract(int val1, int val2)
    return val1 - val2;
    public int perform(int val1, int val2)
    Console.WriteLine("Do you want to + or -?");
    string ch = Console.ReadLine();
    Operation oper;
    //Delegates: Enables to conditionally(and dynamically)select the method to be invoked
    if (ch == "+")
    oper = new Operation(add);
    oper = new Operation(subtract);

    return 0;
    }//end of class

    } //end of namespace