I asked an Android guy to explain some things to me about Dalvik, so I could understand the Oracle v. Google situation in more depth.
I'm not a programmer, I told him, but I need to understand the tech behind the lawsuit, so I can understand when the lawyers start arguing about what Google did and didn't do and whether it was entitled to do it or not. What is Dalvik? Why use it? So I asked Mark Murphy, the founder of CommonsWare, and who is the author of three books on Android application development, including Busy Coder’s Guide to Android Development, to explain it. He also trains folks in developing for Android. Also, he doesn't work for Google, so he can speak more freely. Once you are in litigation, most companies are silent as the grave until it's decided. Don't go by SCO. That big-mouth grandstanding to the media was not typical.
If, like me, you never paid much attention before to all the intricacies of Java, it's a chance to get up to speed on all that, as the article walks us through different ways the word Java is used, sometimes a bit loosely, as well as explaining what Dalvik does and the benefits it offers.

What I understand is that there were important technical reasons why Google would want to roll their own code, involving security, memory consumption, and speed, quite aside from any legal or licensing issues.
This article isn't directly about the legal issues, by the way, the question that hovers over this matter in my mind, namely can anyone can write their own Java-like code without getting sued? This is just about the technical side, but as the case goes forward, understanding the technical bits will help us to understand the legal bits.
I've learned a few other things from researching and asking around that helped me to further understand the context for why Google went the way it did. For example, Sun's version of Java for mobile, Java ME, is released under GPLv2 only, but unlike OpenJDK, the open-source version of Java SE, there is no Classpath exception applied to Java ME, so using it might create doubt about whether the system exception applied. Moreover, none of the innovation over the past few years (like JavaFX) is in the open source version. I think then that it would be accurate to discern that Google wanted something better than what was available.
So, with that introduction, here's Mark's article:
**************************

When it comes to the Oracle lawsuit against Google regarding Android, many sites and news outlets say that “Android applications are written in Java”. As usual, this is a bit of shorthand.
To really understand what is going on, and where Oracle’s lawsuit comes into the picture, we need to have a bit more detailed picture of what really goes on when somebody writes an Android application:

1. Developers write Java‐syntax source code, leveraging class libraries published by the Android project, Apache Harmony, and other groups. 2. Developers compile the source code into Java VM bytecode, using the javac compiler that comes with the Java SDK.
3. Developers translate the Java VM bytecode into Dalvik VM bytecode, which is packaged with other files into a ZIP archive with the .apk extension.
4. An Android device or emulator runs the .apk file, causing the bytecode to be executed by an instance of a Dalvik VM.

And for most of you, that description was gibberish. That’s the reason why we use the shorthand “Android applications are written in Java” — spelling out all those details every time would get very tiresome. But, we need to sort out this gibberish to answer questions like:

What is Oracle suing over?
Why does this impact Google, if Java was released under the GPL?
Who else might be at risk due to Oracle’s decision to sue?

This article will try to explain two things, in lay terms:

1. What does all that gibberish mean? 2. What technical reasons are there for all that gibberish, compared to the similar gibberish an ordinary Java developer would use?
3. Where do the Oracle patents and such tie in, generally speaking?

First, a few disclaimers:

• In the interests of making this stuff make sense to more ordinary people, I will wind up using some shorthand of my own from time to time. Purists will probably come up with any number of places where what I say glosses over some details. I am certainly interested in making updates and corrections as needed, where those will materially help ordinary people understand things better.
• I will use “Sun” to refer to the firm that invented Java and created the Java development tools. I will use “Oracle” to refer to the firm that acquired Sun and, therefore, owns patents, copyrights, and trademarks relevant to Java.
• I am an Android advocate, though I do not work for Google. While this article is not strictly intended to steer readers’ opinions one way or another on the merits of Oracle’s lawsuit, I am sure that my biases will leak through.
• This article is written for people who have a smattering of technical knowledge, enough to, say, have made some sense over what was going on in the various lawsuits that SCO was recently a part of.
• I have a somewhat quirky sense of humor. You have been warned.

Explaining the Gibberish Let’s take those four pieces of gibberish and examine them, one scary‐looking phrase at a time.
“Java‐syntax source code”
“Java” itself is a bit of shorthand. There are many things that can legitimately be called “Java”. One of those things is the syntax of the Java programming language.
Software developers write source code, in some programming language. Java offers one such language, but there are a crazy number of other programming languages, from FORTRAN and COBOL of the mid‐20th century to newcomers like Scala and Clojure.
Each programming language has a syntax, just as each human language has its rules of grammar and roster of available words. The Java programming language has a specific syntax.
Most — but not all — Android developers will be creating Android applications by writing Java‐syntax source code, no different than if they were writing Java applets, Java desktop applications, so‐called “Java ME” applications for some mobile phones, or Java‐based Web applications to run on a Web server somewhere.
“Class libraries published by the Android project, Apache Harmony, and other groups”
When you build a bridge, you typically do not start by opening an iron mine. Rather, you build the bridge from a mix of pre‐fabricated and custom parts. Pre‐fabricated parts might include girders and rivets. Somebody else was responsible for creating those girders, somebody else was responsible for mining the iron ore used to create the steel used to create the girders, and so on.
Similar, in software development, applications are rarely created completely from scratch. Instead, developers take advantage of pre‐fabricated software routines. One term for those, used in “object oriented” languages like Java, is a “class library”.
I mentioned earlier that there are many things that are called “Java”. Besides the syntax of the source code, some people refer to certain class libraries as being “Java”. Sun developed three major flavors of these class libraries, one for conventional desktop environments (Java SE), one for a limited mobile environment (Java ME), and one for server‐based Web applications (Java EE).
Android has class libraries. Some of those class libraries were written by the core Android team, made up of Google employees and contributors from other firms. The rest of the class libraries come from other open source projects. Notable among these is Apache Harmony, a project aiming to create a complete replacement implementation of all pieces of Java.
Specifically, Harmony offers a class library that is generally compatible with classes that come from Java itself — they have the same names for classes, for example. Android has included some — but not all — of the Harmony classes in the Android OS. Hence, Android developers can write code that use “Java” classes, despite the fact that those classes did not come from Sun and whose copyrights are not held by Oracle.
Java VM bytecode
Yet another thing that people sometimes refer to as “Java” is the Java virtual machine, or Java VM for short.
Many programming languages are “compiled”, meaning that a tool converts the source code that developers type in into something that a “machine” can execute directly. You can think of this as akin to converting a singer’s voice into the bits and bytes that go into an MP3 file or onto a CD.
Many compiled programming languages are compiled into ”opcodes” that are designed to be run by some specific sort of chip. There are opcode sets for the Intel chip in your notebook, and other opcode sets for the ARM chip in your smartphone, and still other opcode sets for the MIPS chip in your DVD player. If you want your source code to run on all three types of chips, you would need to compile it three times.
Some compiled programming languages, though, target not a real chip, but a fake one — a virtual machine. A virtual machine (VM) is a piece of software that mimics the functionality of a real chip. It runs bytecode (the VM equivalent of opcodes) designed for that specific type of VM. Different versions of the VM software can then be written to run on different types of real chips (Intel, ARM, MIPS, etc.). This way, a compiled VM application can run on a wide range of physical chips, without having to recompile the source code to target each physical chip.
Java is perhaps the most famous language that uses a virtual machine — the JVM. It was not the first and is not the only such language. Other popular languages that use VMs include Perl, Python, and Smalltalk — the latter is the language behind the Squeak app that Apple removed from the App Store for violating its “Apple‐only languages” policy. Similarly, Microsoft’s .NET languages (e.g., VB.Net, C#) run on a virtual machine called the Common Language Runtime (CLR).
The javac compiler that comes with the Java SDK
Still another thing that some people refer to as “Java” is the Java software development kit, or Java SDK (or, occasionally, JDK).
The Java SDK represents the set of tools and files needed by a programmer to write Java applications. Among other things, it includes a compiler tool — javac — that converts Java source code into Java bytecode that can be executed by the Java VM.
Dalvik VM bytecode
The Dalvik VM is a virtual machine, along the lines of the Java VM, the Parrot VM (Perl), Microsoft’s CLR, and so forth. Dalvik was written principally for use with Android, though some have experimented with using it separately.
Each VM has its own bytecode, just as each type of CPU chip has its own opcode. Hence, the Dalvik VM bytecode is not the same as the Java VM bytecode, or the Parrot VM bytecode, etc.
Translate the Java VM bytecode
That being said, Android does come with tools that translate compatible Java VM bytecode into Dalvik VM bytecode. This allows developers to write Java‐syntax source code, compile it with the Java SDK’s compiler, then get Android‐compatible Dalvik VM bytecode in the end.
Note that not all Java VM bytecode is compatible with the translation process, and therefore with Dalvik by extension. Notably, old bytecode (Java 1.4.2 and previous) and bytecode compiled by non‐Sun Java compilers will fail to translate.
An instance of a Dalvik VM
A Java program is run by a Java virtual machine. The VM reads in the Java bytecode, finds the desired entry point (a main method on a designated class), and executes the bytecode instructions. Similarly, an Android program is run by a Dalvik virtual machine.
If you wanted to run two separate Java programs at once, you will usually wind up with two copies of the Java virtual machine running on your computer. Similarly, when you run more than one Android application, each application usually gets its own Dalvik VM instance.
So, Why Dalvik?
OK, so, why did anyone bother to create Dalvik in the first place? Why not just use plain ol’ ordinary Java?
I do not claim to know all of the rationale behind the decision. That being said, here are at least some of the known technical reasons:
Memory Consumption
As noted above, if you want to run more than one Java or Android application, each application gets its own virtual machine instance. However, in Java, that will require a substantial amount of RAM, and on Dalvik it does not.
Why? Sharing.
Much of what is in a VM is read‐only. For example, the class libraries each VM uses do not typically get modified when a program using those libraries is run.
In Java, each application gets its own copy of all the read‐only portions of the VM.
In Dalvik, each application shares one master copy of all the read‐only portions of the VM, using techniques like copy‐on‐write.
As a result, Android, through Dalvik, can run more programs in a tightly‐constrained memory environment, like a smartphone.
Security
Saving memory is good. It allows us to do more with less. However, with Dalvik, there is an extra important benefit: it gives us better security that might otherwise be possible.
Linux has a security model baked into the kernel, one involving users and permissions. Each Linux program is run under a certain user’s account, whether that be a real person or a fictitious account for a particular program (e.g., an apache account that runs a Web server). All files in a proper Linux filesystem are owned by some user. Files that are marked as usable only by the user can be read and written to by that user’s own program, but cannot be read or modified by any other program, since other programs run as other users.
With me so far?
In Android, by default, each application gets its own user account — akin to the apache scenario above. When you run an Android application, it can access its own files, but it cannot access other applications’ files by default, courtesy of it running as a certain user.
This is only possible because of the memory sharing described in the previous section. If Android were limited to a traditional Java VM, each program would take up too much memory. Android applications might all have to share a single Java VM and all run as the same user, meaning one application could access another application’s data. You would have to layer all sorts of security cruft into the Java/Android environment to isolate applications from one another.
But, the memory sharing means each Android application can have its own Dalvik VM and run under its own user account. As a result, we get the tried‐and‐true Linux security model, making it significantly less likely that one application will be able to abscond with another application’s data.
Register‐Based VM
There are two ways to implement a virtual machine, “stack‐based” and “register‐based”. Java VMs tend to be stack‐based. The Dalvik VM is register‐based. This too is an optimization designed for mobile environments, where RAM is limited, as you can get more stuff done in fewer bytes, on average, with a register‐based architecture.

REFERENCES

http://www.groklaw.net/article.php?story=20100915143729255

How do I exclude certain directories while using the find command under UNIX or Linux operating systems?

You can use the find command as follows to find all directories except tmp directory:

find /path/to/dest -type d \( ! -name tmp \) -print

Find all directories except tmp and cache:

find /path/to/dest -type d \( ! -name tmp \) -o \( ! -name cache \) -print

The -prune option make sure that you do not descend into directory:

find /path/to/dest -type d \( ! -name tmp \) -o \( ! -name cache -prune \) -print

You can find all *.pl find except in tmp and root directory, enter:

find /  \( ! -name tmp \) -o \( ! -name root -prune \)  -name "*.pl" -print

Your find command may not support -delete option, so use it as follows:

# find /var/pub/ftp/incoming -type f -print0 | xargs -0 -I file rm -f file

OR

# find  /var/pub/ftp/incoming -type f -exec rm -f {} \;

You can also select file types. In this example, delete all *.exe files, enter:   

# find  /var/pub/ftp/incoming -type f -iname "*.exe" -exec rm -f {} \;

 
To find all symlinks to /etc/resolv.conf, use the find command as follows:

# find /path/to/dir -lname /path/to/file

# find / -lname /etc/resolv.conf

/path/to/file is a symbolic link whose contents match shell pattern 
pattern.  The metacharacters do not treat / or . specially. The -ilname 
FILE options is like  -lname,  but  the  match  is  case insensitive:

# find / -ilname resolv.conf  

Find Command Exclude Directories From Search Pattern

You can use the find command as follows to find all directories except tmp directory:
find /path/to/dest -type d \( ! -name tmp \) -print

Find all directories except tmp and cache:
find /path/to/dest -type d \( ! -name tmp \) -o \( ! -name cache \) -print

The -prune option make sure that you do not descend into directory:
find /path/to/dest -type d \( ! -name tmp \) -o \( ! -name cache -prune \) -print

You can find all *.pl find except in tmp and root directory, enter:
find / \( ! -name tmp \) -o \( ! -name root -prune \) -name "*.pl" -print

REFERENCES

http://www.cyberciti.biz/faq/linux-unix-osx-bsd-find-command-exclude-directories/

http://www.cyberciti.biz/faq/deleting-file-in-many-subdirectories-linux-unix-command/ 

http://www.cyberciti.biz/faq/linux-unix-osx-bsd-find-command-exclude-directories/ 

How do I install memcached cache plugin under UNIX / Linux to speed up my dynamic database-driven wordpress blog by caching data and objects in RAM to reduce the number of times an external data source must be read?

You need to install memcached caching server only if your wordpress based blog get a large numbers of hits. You need to install the following software(s) on server:

1. memcached server : It is a caching daemon designed especially for dynamic web applications to decrease database load by storing objects in memory.
2. php-pecl-memcache: PHP extension to work with the Memcached caching daemon through handy OO and procedural interfaces. Memcache can be used as a PHP session handler too.
3. WordPress memcached object cache plugin : This plugin provides a persistent backend for the WordPress object cache.

Our Sample Setup

Internet
    \\
      \\
  ISP Router             +--------+
     //          +-------| mysql1 | 10.10.1.1
     //          |       +--------+
     //          |
  +-----+        |       +------+
  | lb0 |--------+-------| www1 |  10.10.1.2
  +-----+        |       +------+
vip:202.54.1.1   |
                 |       +------+
                 |-------| www2 | 10.10.1.3
                 |       +------+
                 |
                 |       +------+
  +-----+        |-------| www3 | 10.10.1.4
  | lb1 |--------+       +------+
  +-----+        |
                 |       +-----------+
                 |-------| memcache1 |  10.10.1.5
                         +-----------+
   

Where,

• lb0 : It is a reverse proxy server that is installed on a UNIX / Linux in front of Apache Web servers hosted on www1, www2, www3. You can use nginx or any other reverse proxy server with virtual ip (connection redundancy) managed by Keepalived. This is master load balancer.
• lb1: This is backup load balancer with nginx and keepalived.
• www1, www2, www3 : Apache web server with php. You need install "php-pecl-memcache" and "Memcached Object Cache wordpress plugin" on all three servers.
• mysql1 : This is MySQL server with RAID10 and fast scsi / sas disk. This server in under load and you are going to reduce the load by caching queries in RAM.
• memcache1 : This server runs memcached with lots of RAM and it will cache mysql1 queries to decrease database load by storing objects in memory. You need to install memcached server on memcahce1. You can add memcach2 for redundancy purpose.

All of the following instructions are tested on RHEL and CentOS 5.x 64 bit servers.

Install Memcached Server

Type the following command on memache1 server. First, you need to turn on EPEL repo:
# rpm -Uvh http://download.fedora.redhat.com/pub/epel/5/x86_64/epel-release-5-4.noarch.rpm
Now, install memcached using the yum command, enter:
# yum install memcached

Configure memcached

You need to edit /etc/sysconfig/memcached file, enter:
# vi /etc/sysconfig/memcached
Edit as follows:

 
PORT="11211"
USER="memcached"
MAXCONN="2048"
CACHESIZE="4096"
OPTIONS="-l 10.10.1.5"
 

Where,

• PORT: Listen on TCP port # 11211, the default is port 11211.
• USER: Run memcached server as memcached user.
• MAXCONN: Use 2048 max simultaneous connections; the default is 1024.
• CACHESIZE: Use 4096 MB (4GB) memory max to use for object storage; the default is 64 megabytes.
• OPTIONS="-l 10.10.1.5": Listen on 10.10.1.5. This is an important option to consider as there is no other way to secure the installation. Binding to an internal or firewalled network interface is suggested. In this example, IP address 10.10.1.5 is only accessible using LAN and is behind firewalled host.

Make changes as per your setup and requirements. Save and close the file.

Turn On Service

Type the following chkconfig command to turn memcached service, enter:
# /sbin/chkconfig memcached on
## command to START the server ##
# /sbin/service memcached start
## command to STOP the server ##
# /sbin/service memcached stop
## command to RESTART the server ##
# /sbin/service memcached restart

Install php-pecl-memcache

Type the following commands on www1, www2, and www3 Apache server:
# yum -y install php-pecl-memcache
# /sbin/service httpd restart

Install Memcached Object Cache Plugin

Type the following command on www1, www2, and www3 Apache server (if you are using some sort of cluster aware file system such as GFS2 or OCFS2, than just type it on any one apache web server node):
Visit this url and grab the plugin, enter:
$ cd /tmp/
$ wget http://downloads.wordpress.org/plugin/memcached.2.0.zip
$ unzip memcached.2.0.zip
Edit object-cache.php, enter:
$ vi object-cache.php
Edit memcahe server and port connection information:

 
$buckets = array('10.10.1.5:11211');
 

Save and close the file. Finally, copy object-cache.php into your wp-content directory. In our example /var/www/html/wp-content/ directory:
$ cp object-cache.php /var/www/html/wp-content/

How Do I Verify That It Is Working?

Type the following commands to display memcache slabs (please note that the following output is taken from a small memcached server with just 512MB cache for demonstration purpose only):
# memcached-tool 10.10.1.5:11211 display
Sample outouts:

#  Item_Size  Max_age   Pages   Count   Full?  Evicted Evict_Time OOM
  1      96B     38302s       1      42      no        0        0    0
  2     120B     37571s       1       4      no        0        0    0
  3     152B       335s       1     232      no        0        0    0
  4     192B     37763s       1      40      no        0        0    0
  5     240B     37804s       1      36      no        0        0    0
  6     304B     37595s       1      86      no        0        0    0
  7     384B       829s       4   10401      no        0        0    0
  8     480B       228s       1     972      no        0        0    0
  9     600B       106s       1     387      no        0        0    0
 10     752B     38298s       1     288      no        0        0    0
 11     944B       404s       1     143      no        0        0    0
 12     1.2K     38319s       1     258      no        0        0    0
 13     1.4K     12739s       1     176      no        0        0    0
 14     1.8K     38322s       1     230      no        0        0    0
 15     2.3K      1500s       2     491      no        0        0    0
 16     2.8K      1500s       2     648      no        0        0    0
 17     3.5K       828s       3     600      no        0        0    0
 18     4.4K     37660s       2     322      no        0        0    0
 19     5.5K     38035s       1     171      no        0        0    0
 20     6.9K     38458s       1     102      no        0        0    0
 21     8.7K     39002s       1      39      no        0        0    0
 22    10.8K     42068s       1      35      no        0        0    0
 23    13.6K     24184s       1      15      no        0        0    0
 24    16.9K     41626s       1      11      no        0        0    0
 25    21.2K     43426s       1       1      no        0        0    0
 26    26.5K     43392s       1       1      no        0        0    0
 37   308.5K      1493s       1       3     yes        0        0    0

To shows general stats, enter:
# memcached-tool 10.10.1.5:11211 stats
Sample outputs:

#10.10.1.5:11211   Field       Value
         accepting_conns           1
               auth_cmds           0
             auth_errors           0
                   bytes    14945401
              bytes_read  1320187573
           bytes_written  3180772729
              cas_badval           0
                cas_hits           0
              cas_misses           0
               cmd_flush           0
                 cmd_get     1280549
                 cmd_set     1262345
             conn_yields           0
   connection_structures          73
        curr_connections          72
              curr_items       15724
               decr_hits           0
             decr_misses           0
             delete_hits       11296
           delete_misses       24284
               evictions           0
                get_hits     1156788
              get_misses      123761
               incr_hits           0
             incr_misses           0
          limit_maxbytes   536870912
     listen_disabled_num           0
                     pid       42690
            pointer_size          64
               reclaimed           2
           rusage_system   51.550163
             rusage_user   20.861828
                 threads           4
                    time  1284368953
       total_connections         558
             total_items       75121
                  uptime       43527
                 version       1.4.5

To dumps keys and values, enter:
# memcached-tool 10.10.1.5:11211 dump | less

More Tips: To Increase Your WordPress Based Blog Speed

1. Turn on MySQL query cache.
2. Use xcache opcode cacher to accelerates the performance of PHP on servers.
3. Use CDN (Content Delivery Network) for WordPress to speed up your blog.

Conclusion

The end result was pretty good. The database request are completed faster and loads on database servers are decreased. The above setup can be used with other php or webapps too.

Recommended readings:

• CentOS / Redhat Linux: Install Keepalived To Provide IP Failover For Web Cluster.
• Memcached plugin
• Memcached Object Cache
• PHP extension for interfacing with memcached via libmemcached library

REFERENCES
http://www.cyberciti.biz/faq/linux-unix-bsd-wordpress-memcached-cache-plugin/

Q. How do I setup my Red Hat / CentOS / Fedora Linux system to get IP address and other information via a DHCP server for eth0 interface?

A. You can edit eth0 configuration file to switch between static and dhcp networking configuration under RHEL / Fedora or CentOS Linux. Simply edit /etc/sysconfig/network-scripts/ifcfg-eth0 file.

Backup existing static configuration

First backup existing network configuration file using cp command:
# cp /etc/sysconfig/network-scripts/ifcfg-eth0 /root/ifcfg-eth0.bak

Configuring a DHCP Client

Setting up a Linux for dhcp can be done by editing file using a text editor such as vi:
# vi /etc/sysconfig/network-scripts/ifcfg-eth0
Following is sample static configuration:
DEVICE=eth0
BOOTPROTO=static
HWADDR=00:19:D1:2A:BA:A8
IPADDR=10.10.29.66
NETMASK=255.255.255.192
ONBOOT=yes
Replace static configuration with DHCP:
DEVICE=eth0
BOOTPROTO=dhcp
HWADDR=00:19:D1:2A:BA:A8
ONBOOT=yes
Save and close the file. Just restart network service:
# /etc/init.d/network restart
Please note that you need a configuration file for each device that you want to configure to use DHCP.

REFERENCES
http://www.cyberciti.biz/faq/setting-up-a-linux-for-dhcp/

REFERENCES
http://www.reddit.com/r/programming/comments/ddaak/linux_commands_wallpaper_hires/

/**
 * Concatenates the values of a variable into an easily readable string
 * by Matt Hackett [scriptnode.com]
 * @param {Object} x The variable to debug
 * @param {Number} max The maximum number of recursions allowed (keep low, around 5 for HTML elements to prevent errors) [default: 10]
 * @param {String} sep The separator to use between [default: a single space ' ']
 * @param {Number} l The current level deep (amount of recursion). Do not use this parameter: it's for the function's own use
 */
function print_jc(x, max, sep, l) {

 l = l || 0;
 max = max || 10;
 sep = sep || ' ';

 if (l > max) {
  return "[WARNING: Too much recursion]\n";
 }

 var
  i,
  r = '',
  t = typeof x,
  tab = '\t';

 if (x === null) {
  r += "(null)\n";
 } else if (t == 'object') {

  l++;

  for (i = 0; i < l; i++) {
   tab += sep;
  }

  if (x && x.length) {
   t = 'Array';
  }

  r += '(' + t + ") \n";
  r += '('+"\n";


  for (i in x) {
   try {
    r += tab + '[' + i + '] => ' + print_jc(x[i], max, sep, (l + 1));
   } catch(e) {
    return "[ERROR: " + e + "]\n";
   }
  }
  r += ')';


 } else {

  if (t == 'string') {
   if (x == '') {
    x = '(empty)';
   }
  }

  r += '(' + t + ') ' + x + "\n";

 }

 return r;

}

TEST:

//var colors = new Array("red", "blue", "green");
var colors = ["red", "blue", "green"];
document.write('
');
document.write(print_jc(colors));
document.write('
');

Output:

(Array) 
(
  [0] => (string) red
  [1] => (string) blue
  [2] => (string) green
)

REFERENCES
http://scriptnode.com/article/javascript-print_r-or-var_dump-equivalent/

 The moment I saw the print_r() function of PHP, I fell in love with it. It is a very necessary function and I cannot understand why no other language supports it. JavaScript is one such language. So, I have ported the print_r function to javascript.

/**
 * Function : dump()
 * Arguments: The data - array,hash(associative array),object
 *    The level - OPTIONAL
 * Returns  : The textual representation of the array.
 * This function was inspired by the print_r function of PHP.
 * This will accept some data as the argument and return a
 * text that will be a more readable version of the
 * array/hash/object that is given.
 * Docs: http://www.openjs.com/scripts/others/dump_function_php_print_r.php
 */
function dump(arr,level) {
 var dumped_text = "";
 if(!level) level = 0;
 
 //The padding given at the beginning of the line.
 var level_padding = "";
 for(var j=0;j<level+1;j++) level_padding += "    ";
 
 if(typeof(arr) == 'object') { //Array/Hashes/Objects 
  for(var item in arr) {
   var value = arr[item];
   
   if(typeof(value) == 'object') { //If it is an array,
    dumped_text += level_padding + "'" + item + "' ...\n";
    dumped_text += dump(value,level+1);
   } else {
    dumped_text += level_padding + "'" + item + "' => \"" + value + "\"\n";
   }
  }
 } else { //Stings/Chars/Numbers etc.
  dumped_text = "===>"+arr+"<===("+typeof(arr)+")";
 }
 return dumped_text;
}

This is how the function is called. In this example we will give a complex array as the argument.

//Calling the function...
function init() {
 var arra = new Array("So long",'s',42,42.13,"Hello World");
 var assoc = {
  "val"  : "New",
  "number" : 8,
  "theting" : arra
 };
 
 alert(dump(assoc));
}
window.onload=init;

The result will be returned in the following format...

'val' => "New"
'number' => "8"
'theting' ...
   '0' => "So long"
   '1' => "s"
   '2' => "42"
   '3' => "42.13"
   '4' => "Hello World"

REFERENCES
http://www.openjs.com/scripts/others/dump_function_php_print_r.php