First caveat - this post is not advice for a production Cassandra cluster, it is just my experience playing around with Cassandra and Amazon EC2 to create a small 3-node cluster to tinker around with for fun. It gives me an opportunity to record my experiences and the traps I fell into and how you might avoid or work around them. Second caveat - just to be clear, Amazon EC2 is not free, it is a paid service and you are responsible for any costs you may incur. You will incur costs if you try to replicate my steps. Third caveat - I am a noob at Cassandra and Hector, so please fact-check the material I'm presenting here. I will give links to point you to authoritative information where ever possible.

Documentation for Cassandra

Since my last post on Cassandra 0.7, new and very helpful documentation has cropped up that you might want to peruse:

• Cassandra documentation at Datastax, formerly Riptano
• Cassandra wiki

Documentation for Amazon EC2

Here are the links to the main documentation for Amazon EC2 that I will reference throughout this article:

• Getting Started with EC2 Guide - a tutorial to get your first EC2 instance up and running
• The Amazon EC2 Guide - a comprehensive guide to EC2 that is loaded with information and easy to use

Basic Steps for an Experimental Amazon EC2 Cassandra Cluster

The basic steps I'll cover in this post are as follows:

1. Set up your Amazon account, get familiar with EC2 and EBS
2. Choose your base AMI
3. Set up your base system
4. Storing your base system as an EBS-backed AMI
5. Configuring and launching instances
6. Testing your Cassandra cluster and some basic interactions with it
7. STOP your instances (you don't want to forget this step)

This is the method I've devised for my own personal investigation of Amazon and EC2, entirely for learning purposes. As I've worked my way through this process, I've discovered that there are many ways to achieve this same result. I link to some of them below, but keep in mind that there are lots of ways to do this, and mine is definitely not the most refined.

Amazon EC2 Setup

If you haven't already, head over to aws.amazon.com to set up your Amazon EC2 account and be sure to check out the pricing. The work your way through the entire Getting Started with EC2 guide, including bringing up your first instance. At the point where you're given a choice between Linux and Windows, this post covers the Linux option, but of course you should choose whatever you prefer.

Now you should be up-to-speed on launching an Amazon EC2 instance from a provided AMI. EBS is Elastic Block Storage and we will be using this storage to store our own AMI to use to launch our Cassandra instances from. You do not need to set up an EBS account or create special keys for EBS.

Through the remainder of this post, you can find more detail on all of the Amazon topics covered by referencing the EC2 guide. It's loaded with information. You should use that guide as your main source of information and anything I write in the remainder of this post should be taken with a grain of salt and fact-checked against the guide.

Choose Your Base AMI

Now that you have an idea of the AMIs available by default from Amazon after running through the tutorial, it's time to see the plethora of AMIs that are public and choose one to start with. From within your management console you can view instances by clicking the "Launch Instance" button and going to the "Community AMIs" tab. From there you can see thousands of AMIs. As a word of caution, you should do research on any AMI you are thinking of launching to be sure it's safe and reliable and not pre-infected with worms, root kits, etc.

For my own use, I like and am familiar with Ubuntu, so I'm using an Ubuntu AMI as my base. I chose my AMI after perusing the Lucid Lynx list, because Lucid is the most recent long-term support release of Ubuntu. You can see the Ubuntu AMI list here. I chose a Small instance from the list since I wanted to keep the costs down while I was just experimenting.

AMIs come in many flavors: Standard, Micro, High-CPU, High-Memory, Cluster Compute and Cluster GPU. Within each flavor, are many specific offerings at varying price levels. I'm using a Standard - Small, but you should note that Small is just barely sufficient for Cassandra and doesn't have a 64-bit option. Standard has these characteristics:

• 1 EC2 Compute Unit (1 virtual core with 1 EC2 Compute Unit)
• Memory: 1.7 GB
• 160 GB instance storage (150 GB plus 10 GB root partition)
• Platform: 32-bit
• Moderate I/O

The Cassandra documentation says this about EC2:

On EC2, the best practice is to use L or XL instances with local storage. I/O performance is proportionately much worse on S and M sizes, and EBS essentially doubles your dependence on the already-overcrowded EC2 network...

For more thoughts on EC2 with Cassandra, I found this slideshare.

Armed with this information, give some thought to what interests you, so out and do a little research, and decide on an AMI to use and take note of it's ID. You will want to choose an EBS-backed AMI rather than an S3-backed AMI, since this post goes down the EBS path. If you prefer S3-backed AMIs, then you'll need to make your own adjustments as you follow along with this post. To simplify matters, rather than hunting down the perfect AMI at this point, you can always base your system off of one of the AMIs in the tutorial you followed in the first step.

Set Up Your Base System

Now that you've chosen an AMI and know it's ID, you can launch it in the EC2 Management Console. Note that it appears it's possible to do everything via command line that you can do in the console, but we'll stick to the console for now. I'm not going to cover the details of launching the instance from the AMI ID, just click the "Launch Instance" button and then follow the wizard. If you have questions, the EC2 guide should be able to answer them.

Alternatively, if you want a more streamlined approach, have a look at this tutorial on the Cassandra wiki (and here's yet another approach, though older). My approach is not nearly as streamlined, but my goal was more in the way of educating myself about each step, whereas the tutorial seems to be more oriented toward getting you up and running as quickly as possible. Choose the approach works best for you. Please note that Debian packages are not always the most recent version of software and Debian has a tendency to store files all over the place (also true for Ubuntu), so you may need to do some hunting to locate your configuration files.

Assuming you're sticking with this guide and not the "quick start", we'll continue on with the experiment. After your instance is launched, then you will want to do the following:

• Log onto your instance and make sure it's what you wanted
• Run any OS updates that might be needed. In Ubuntu you would do this using apt-get.
• Install Java 6
• Download and install Cassandra
• Configure Cassandra - basic, not multi-node
• Start Cassandra to verify it works
• Clean up Cassandra files!

You can log onto a Linux instance using ssh, using a command similar to this:

ssh -i /home/myname/.gnupg/mynameEC2key.pem ubuntu@ec2-123-23-123-123.compute-1.amazonaws.com

Where "ec2-123-23-123-123.compute-1.amazonaws.com" is the host name given to your instance after launch. You can view the hostname and IP address in the management console. "Ubuntu" is the default user for the Ubuntu AMI. The "-i /home/myname/.gnupg/mynameEC2key.pem" specifies the key you chose when launching your instance.

Log on, take a look around, and verify that the instance you've launched is what you were expecting from the AMI you chose.

Next follow whatever procedure you would normally follow to be sure you have an up-to-date system. In Ubuntu and Debian Linux systems, you would run commands such as this:

sudo apt-get upgrade
sudo apt-get update

Next, install Java 6, if it's not already there, using your usual mechanism for installing Java on your chosen system. I would recommend not trying to use OpenJDK or GCJ. In Ubuntu, you would use a command like "sudo apt-get install sun-java6-jdk".

Load the Cassandra release onto your instance, using whatever method you prefer, and choose a location to install it. Be sure to verify your download using the PGP, MD5 or SHA1 key. Then extract the tar.gz file.

The IP addresses you should use will come from the instance info for each instance you will launch later, so for this configuration, set Cassandra up as a single-node cluster. Please refer to Datastax instructions for setting up a single-node Cassandra cluster, making sure to set the token to 0.

• Note that mx4j-tools.jar does not come with your Cassandra download, so download that separately and store it in the Cassandra lib folder. You will want it!

What we are doing is starting Cassandra up and verifying that it works, but then we will clean it up afterward so that we can launch multiple instances in a clean state. This is important because Cassandra stores information about nodes when it first starts up, and since we want to have a clean AMI that we can launch repeatedly, we don't want this data hanging around, see this discussion.

At this point you can use the Cassandra client to try creating a keyspace, to verify that it works. Since you're tailing the Cassandra logs in your first ssh connection, make a new ssh connection to do this.

bin/cassandra-cli -host localhost -port 9160
create keyspace Keyspace1 with replication_factor = 1 and placement_strategy = org.apache.cassandra.locator.RackUnawareStrategy;

View the log messages in your first window to observe that the keyspace is created.

Now, stop Cassandra and clean up the files:

sudo rm -rf /var/lib/cassandra/data/
sudo rm -rf /var/lib/cassandra/commitlog/
sudo rm -rf/var/lib/cassandra/saved_caches/

Now it will once again be as if Cassandra had never been started on your system. This is now your functional base instance.

Store EBS-Backed AMI

Now we're ready to store this baby and then it will be available to launch instances that will be ready to run with a little bit of configuration. Go back to your Amazon EC2 management console and see that below instances there is Elastic Block Store section. My current understanding is that when we create an EBS-backed AMI, it will create a snapshot, and when we launch each instance from that AMI snapshot, then a volume will be created assigned to that instance. I'm new to this, so I recommend reading the guide yourself and following the instructions, see these sections:

• AWS Documentation » Amazon EC2 » User Guide » Using Amazon EC2 » Using AMIs » Creating Your Own AMIs » Creating Amazon EBS-Backed AMIs
• AWS Documentation » Amazon EC2 » User Guide » Using Amazon EC2 » Using Amazon EBS-Backed AMIs and Instances

Configuring and Launching Instances

Now that you have an EBS-backed AMI with Java and Cassandra installed on it, we will launch three instances. The first one will be the seed node.

In the management console, in the Instance interface, click the Launch Instance button. Go to the My AMIs tab and select your new AMI and follow the wizard. Some helpful notes:

• Be sure to give a tag, such as name=Cassandra for each instance, so they will be easily identifiable. For the seed note, you could have name=CassandraSeed to easily find the seed.
• Be sure to configure the same security group to all three instances. After you launch an instance you cannot change which security group it belongs to, but you can change the details of the security group. If you want them to all be able to communicate with each other using the internal IP addresses (cheapest option), then having the same security group is important.
• Be sure to launch then in the same availability zone, such as us-east-1a

Launch 3 nodes, one as the seed and two as non-seed nodes.

Now connect to each node using ssh to configure Cassandra. For configuring Cassandra as a multi-node cluster, I want to point you to the Datastax configuration page for setting up a multi-node Cassandra cluster and add a few extra comments. See also this wiki page.

Configure the IP addresses and seeds as in the Datastax instructions, using the management console to get your internal IP addresses, and being careful to be consistent about which one you chose to be the seed.

The token for the seed should be 0, the token for the other nodes is calculated using this formula: i * (2**127 / N) for i = 0 .. N-1, where i is the node number starting from 0, and N is the total number of nodes (or 3 in this case). Using that formula I have these values calculated:

token node1 (seed) = 0
token node2 = 56713727820156410577229101238628035243
token node3 = 113427455640312821154458202477256070485
the value of 2**127 is 170141183460469231731687303715884105728

You can read more about the tokens at the Cassandra wiki.

Now you're ready to launch your nodes. Launch the seed node first, using the familiar command that allows you to tail the log: bin/cassandra -f

Testing the Cassandra Cluster

Now open a new ssh session to one of the three nodes that you've launched and change directory to your Cassandra install.

You can use the Nodetool to verify that your nodes are all working together (this is where that jmx-tools.jar file starts to come in handy).

ubuntu@domU-123-123-123:/opt/apache-cassandra-0.7.0$ bin/nodetool -host localhose ring
Address         Status State   Load            Owns    Token
113427455640312821154458202477256070485
10.207.6.65     Up     Normal  10.59 KB        33.33%  0
10.207.3.113    Up     Normal  10.43 KB        33.33%  56713727820156410577229101238628035243
10.214.47.207   Up     Normal  10.63 KB        33.33%  113427455640312821154458202477256070485

I've had some problems with nodetool that I'll list here. I don't know is I have a buggy version of it, or am missing some crucial bit of information as to how to use and configure it. I think the problems are in some way connected to the way EC2 instances are configured.

• I've had problems getting nodetool to work using localhost as the hostname and had to resort to an IP address for one of the nodes, and not the node I am ssh'ed into
• I've had problems with the nodetool not working after I shut the instances down and then restarted them later

You can now use the cassandra-cli to create a keyspace and column family and observe the log messages as you do that. The command for the keyspace is above.

Stop Your Instances

Be sure to stop your instances when you are done to stop the clock on charges.

Issues

• When you stop your instances, the next time you start them up again, you will need to reconfigure all of the IP addresses. The workaround for this is to pay for static IPs, which is out of the scope of this article.
• Don't forget to stop your instances, since you pay for the time when they are running.

Conclusion

This was the tedious part - getting the infrastructure ready. In the next post(s), I'll start with Hector and working with the Hector example code to define my schema programatically, and then the real fun will begin. I plan to eventually write a web application and Android app that are going to use this simple Cassandra cluster.

Before you read any further, I want to stress that the Cassandra documentation has very minimal detail and the same goes for Hector, and as of yet, I've found no online tutorials at other web sites for version 0.7. This adventure is not for the faint of heart!

If you've decided to plunge ahead anyway, then you should first study the following documents very carefully, because going forward, I'm assuming you're not a Java noob and you're up-to-speed with at least this much introductory material:

• Cassandra Thrift API for 0.7: http://wiki.apache.org/cassandra/API07
• Cassandra data model: http://arin.me/blog/wtf-is-a-supercolumn-cassandra-data-model
• Hector documentation via Riptano [update Riptano changed to DataStax, so URLs are all updated now]: http://www.datastax.com/sites/default/files/hector-v2-client-doc.pdf [pdf] and also take a look at this blog post: http://prettyprint.me/2010/08/06/hector-api-v2/
• Hector Java Cassandra client code: http://github.com/rantav/hector
• Amazon EC2 for our Cassandra cluster in the cloud: http://aws.amazon.com/ec2/

If you find newer and/or better documents online, please list them in the comments. Thanks!

After you've gotten up to speed with those, then the fun begins!

Download and install Cassandra 0.7 Beta2: apache-cassandra-0.7.0-beta2-bin.tar.gz and run it as a single node on your localhost if possible. The code examples we'll try first make the assumption you're running on localhost and using the default port of 9160.

I recommend spending a little time in the cassandra-cli command line interface tool, experimenting with the commands and becoming a little more familiar with Cassandra. The help command inside the tool is your best bet at the moment for discovering the commands you can try. The cassandra.yaml configuration file gives you the name of the default keyspace, Keyspace1, and the column families to try querying. (When I did this, I found my queries didn't seem to be working as I'd expected, but I stubbornly moved along to the next step anyway.)

After getting Cassandra running, the first thing we can try is to get zznate's Hector example code from github and have a go at making those run. Either download the zip file or "git clone" the repository.

[Note... I use Eclipse and have the Maven 2 m2eclipse plugin installed, and am developing on Ubuntu Lucid Lynx. I have 4 GB of memory with a dual core CPU, running on a notebook computer. You may choose to use whatever hardware, tools and OS you prefer, but my observations are based on this environment. Cassandra wants to use a lot of memory, so please take that into account when configuring your development environment.]

I imported the mavenized project, hector-examples, into Eclipse. Because I'm using Maven and Riptano has graciously provided a maven repository for Hector [update: as of 1/11/2011 Hector is on Maven Central repository and the Riptano repository is deprecated], lots of magic happens at this point. Once Maven finished doing its thing, I immediately found 2 issues that needed to be resolved:

1. I needed to update the hector dependency from 0.7.0-17 to 0.7.0-18 in pom.xml
2. The DeleteBatchMutate class didn't compile due to using org.apache.cassandra.thrift.Clock, which has been removed from Thrift, so I needed to change the code to use long instead of Clock.

Hopefully, by the time you read this, those issues will already be fixed.

Next, I started trying to get all of the examples to run and then spend some time modifying them to learn more about how Cassandra and the client work. I quickly found that the examples did not run due to no keyspace, column families or super column families being configured. How did I determine that? After observing the error messages when running the examples, I found the PID of Cassandra and then ran jconsole and inspected the MBeans and saw I had nothing configured.

[Note: Cassandra does not come with the mx4j-tools.jar already included in the lib folder, and Cassandra happily notifies you of that when you start it up, so you'll have to go and download that jar file yourself and drop it in the lib folder to make use of jconsole.]

My understanding was that everything in the cassandra.yaml configuration file should have been created the very first time my localhost Cassandra node was run, but any changes thereafter would need to be made via Thrift or JMX. [update: that was an incorrect assumption, the default keyspace will not be created as of Cassandra 0.7] So, I thought I should have seen my column families and super column families, but they weren't there. I don't know if I'm just misunderstanding or I missed a step somewhere. One possible explanation is that before Beta2 of Cassandra was released, I had installed a nightly build (post beta1) that matched up with a Hector build, and that nightly build might have had the initialization step broken. I didn't delete everything to start with a clean slate before upgrading to the 0.7 Beta2 version. I don't know if starting from a clean beta2 would have helped or not, but I suspect it would not have made a difference.

Anyway, I viewed this as an opportunity to try my hand at creating my own keyspace, column families and super column families. If you happen to already have these installed, then you're in good shape for running the example code, but sooner or later you're going to need to learn how to create these yourself, so let's walk through that now.

Start up cassandra-cli and configure the keyspace:

create keyspace Keyspace1 with replication_factor = 1

For a single node on your localhost, replication_factor has to be 1.

[Note: the documentation says to include the placement strategy in the command, such as "placement_strategy = org.apache.cassandra.locator.RackUnawareStrategy", but that doesn't work and the cli expects an integer. I haven't yet found a mapping of placement strategies to integers, but am still looking.]

Next configure the 2 column families following the rudimentary instructions given on this page of the Cassandra wiki.

[default@unknown] use Keyspace1
Authenticated to keyspace: Keyspace1
[default@Keyspace1] create column family Standard1 with column_type = 'Standard' and comparator = 'BytesType'
922a9664-bb01-11df-a919-e700f669bcfc
[default@Keyspace1] create column family Standard2 with column_type = 'Standard' and comparator = 'UTF8Type' and rows_cached = 10000
99ed2115-bb01-11df-a919-e700f669bcfc

Please take note of the identifier data that is spewed out after running a successful create command and save those values somewhere (example: 922a9664-bb01-11df-a919-e700f669bcfc). I have not yet found a way to list those values back out, and you may need them in the future.

The "describe keyspace" command now shows the 2 column families:

[default@unknown] use Keyspace1
Authenticated to keyspace: Keyspace1
[default@Keyspace1] describe keyspace Keyspace1
Keyspace: Keyspace1
  Replication Factor: 1
  Column Families:
    Column Family Name: Standard2 {
      Column Family Type: Standard
      Column Sorted By: org.apache.cassandra.db.marshal.UTF8Type
    }
    Column Family Name: Standard1 {
      Column Family Type: Standard
      Column Sorted By: org.apache.cassandra.db.marshal.BytesType
    }

We also need super column families for the example code. After finding no documentation anywhere on how to create a super column family, trial and error lead me to this command:

create column family Super1 with column_type=Super and comparator=BytesType

Now the describe command shows enough to get going on running the examples:

describe keyspace Keyspace1
Keyspace: Keyspace1
  Replication Factor: 1
  Column Families:
    Column Family Name: Super1 {
      Column Family Type: Super
      Column Sorted By: org.apache.cassandra.db.marshal.BytesType
    }
    Column Family Name: Standard2 {
      Column Family Type: Standard
      Column Sorted By: org.apache.cassandra.db.marshal.UTF8Type
    }
    Column Family Name: Standard1 {
      Column Family Type: Standard
      Column Sorted By: org.apache.cassandra.db.marshal.BytesType
    }

I suggest at this point you should run all of the Java examples and spend some time on each one making little modifications until you feel comfortable with them. Also take some time to reference them back with the Thrift API, because that will aid in your overall understanding. The example code closely resembles the examples in the PDF documentation file for Hector, so you can read the descriptions for each operation as you try to run and understand it.

I see that this post is becoming really long, so I'm going to break it up into multiple posts. I think at this point we have enough information to get started and experimenting around with some working code examples. I'll post in the future with the steps I'm going to follow to create a very simple application that uses a small 3-node Cassandra cluster.

• See part 2, bringing up 3 Cassandra nodes on Amazon EC2 here

The discussion focused on efforts to separate Java programming from the nitty gritty details of threads. This separation allows a greater number of developers to successfully program for parallel environment by removing focus on the technical details, and thus reducing the knowledge required to write the code. There's also some coverage of the benefits of the higher level of abstraction of functional programming and how the functional programming style is being incorporated into the Java concurrency model. The text has this:

The future will be functional programming or won't be at all.

Intellectually, I applaud these efforts. Emotionally, I feel some loss.

My first introduction to threads was in a systems programming class, using the C language and Pthreads library. Pthreads blew my mind, or maybe it was lack of quality in the lectures. Either way, determined not to be defeated by Pthreads, I went out and bought a stack of books on Pthreads and threads in general and set out to wrap my mind around threads. It worked, but along the way, I learned that I loved the challenge and so I embraced concurrency and parallelism with much enthusiasm. This knowledge that I've accumulated will always be of great value, but as I move toward programming threads at further and further abstractions, I'll lose that close connection to the internals, and I'm a little saddened by that.

From the announcement email:

Professor Martin Odersky is the director of the LAMP group at EPFL, the creator of the Scala programming language, and author of Programming in Scala.

Josh Suereth hosted the first Scala Lift Off East in Reston, VA and has been involved with lots of Scala projects including scala-tools.org, scala-arm, scala-io, scala-jigsaw, and scala-lolz.

I've read halfway through a book on Erlang , another functional programming language, and am finding many similarities to Scala. (That book, BTW, "Programming Erlang: Software for a Concurrent World", by Joe Armstrong , is an excellent book and I highly recommend it.)

So far, I'm liking Scala a lot. It's comfortable because of it's close ties to Java and the fact that it runs in the JVM. It's also compatible with much of the Java code I've written in my life, so that's a huge plus!

My only complaint at this point is with the documentation I've found. There's a lot of great online documentation, but the quick start articles I've read thus far seem to skip all over the place and leave a lot out, so I find myself flipping from one to the other trying to make sense of what I'm reading. It would be a lot easier if I had a concise reference to glance at.

I decided that what's needed is a cheat sheet (pdf), but then couldn't find one, and because necessity is the mother of invention, I've written my own. [Update, most recent cheat sheet version now available on Github]

Now beware, this cheat sheet was created by a newborn 3-day old Scala programmer, so there may be a lot of corrections needed, and I'm certain it needs more information added to it, but I think this is good enough to start with for a quick start guide.

[Update: I've made several improvements and added a version number that I'll increment every time I update it. (Note: instead the Scala cheat sheet has been added to github)]

Scala Cheat Sheet by Julie Bovee Hill is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License

The Busy Developers' Guide to Scala series:

• “Don't Get Thrown for a Loop”, IBM developerWorks
• “Class action”, IBM developerWorks
• “Functional programming for the object oriented”, IBM developerWorks

Scala Reference Manuals:

• “An Overview of the Scala Programming Language” (2. Edition, 20 pages), scala-lang.org
• A Brief Scala Tutorial, scala-lang.org
• “A Tour of Scala”, scala-lang.org

"Scala for Java programmers", A. Sundararajan's Weblog, blogs.sun.com

I prefer Linux over Windows and have preferred Linux for many years. The notebook computer that I use most of the time is running Ubuntu Linux . Linux has the tools I need. Linux, in particular, has the programming and networking tools that I need. Linux is just simply a superb environment for programming.

Adobe Flex is ActionScript programming. The Adobe Flex Builder, an IDE for building Flex applications, is based on Eclipse. Eclipse is an IDE that runs on many platforms, including Linux. Flash runs just fine on Linux (though Adobe has historically been somewhat slow to keep the Linux version up-to-date). I use Eclipse every day. I use Linux every day. I'm new to Flex, but find it fascinating and want to use Flex Builder.

To sum this up, Linux is an ideal programming platform, the tools required for Flex development (Flash and Eclipse) run happily under Linux independently, so why oh why is the Flex Builder not available for Linux?

I downloaded the trail version of Flex Builder to play around with, but to use it, I'm running VMware and have it installed in a Windows XP VM on my Ubuntu laptop – a painful, excruciating situation. So I ask Adobe to please, please, please let your Flex Builder run on Linux, too.

As soon as Adobe adds Linux support, I promise to be first in line to purchase Flex Builder for Linux.

From the site : "memcached is a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load."

My first software job was for a company that wanted to cache the Intranet for the enterprise, a sort of indirect competitor for Akamai. I loved the concept of what we were trying to do. It was fascinating and exciting. Sadly, we lost focus and spun our wheels and never really found what the potential clients were looking for. I've never stopped wishing we could have succeeded, though. I think if we had been clever enough to have invented memcached, we might have had more success as opposed to spinning our wheels on developing a custom file system. Ironically, just as we were fizzling out, memcached was coming to life.

Reference: Web Caching of Wikipedia

Here's the mission of the group as given on their wiki page: "The Java Women Network promotes collaboration amongst women who develop and use Java technology to increase the visibility of women's contribution, mentoring opportunities and professional networking."