Monthly Archives: May 2015

Devoxx4Kids workshops at Red Hat Summit and DevNation – Register Now!

RedHat Summit LogoDevNation Logo Devoxx4Kids

Red Hat Summit and DevNation are asking to Bring Your Kids to Conference, aka BYKC!

Are you speaking or attending Red Hat Summit or DevNation? Do you live in and around Boston area? Interested in having your kids attend a workshop?

Register here!


What? Two rooms, six workshops
When? Sunday, Jun 21
Where? Hynes Convention Center, Boston, MA
How do I register?


Time  Room 1 Room 2
10am – 12pm App Inventor (8 yrs+) Greenfoot (12 yrs+)
12pm – 1pm Lunch Lunch
1pm – 3pm Minecraft Modding (8 yrs+) Dr Racket (10 yrs+)
3pm – 5pm Scratch (8 yrs+) Flappy Bird (12 ys+)

The age limits are only suggested and you better know the capabilities of your kid! Parents would stay with their kids for the duration of the workshop.


Greenfoot: Lets make some games!

Hey you – yes you – do you like playing video or computer games? Well then how about learning to make your own? Come join us as we hang out for two hours and make some computer games with Greenfoot. Along the way you will learn about computer programming – make your computer do things you want. We will wrap up by showing you some places to go to talk with other people making games and more places to become a more powerful wizard! Be sure to bring a laptop – this will definitely be hands on.

App Inventor

The traditional way to create an application is write code. You type commands, one after another, telling the computer or the smartphone what to do next. When you type commands on a keyboard, it’s easy to make mistakes. What’s more, at a glance, the commands look nothing like the things that you’re getting the computer or smartphone to do. Taken together, the commands are just a bunch of text.

But there’s another way to create an application. With App Inventor, you build instructions by fitting building blocks together with one another on the computer screen. The blocks fit together like jigsaw puzzle pieces. When it’s finished, the whole jigsaw puzzle describes all the commands in your application.

In this workshop, you learn to use App Inventor. You can run your applications on the computers in the lab. You can also install your applications on real Android phones.

Dr. Racket: Don’t dictate, evaluate!

This workshop introduces the basics of functional programming using the Dr. Racket programming environment.

In the first part of the workshop you will learn how to evaluate expressions in the Dr. Racket interpreter, including expressions like <if html were available to display the abstract I’ld show here a racket expression that included an actual devox4 kids image>.

In the second part of the workshop we will work on developing a very simple animation. If time permits we will show how we can make our animations interactive, i.e., have them respond to key presses and mouse clicks.

The workshop is constructed to allow roughly equal amounts of time for experimentation and instruction.

Build your own Flappy Bird

In this workshop you will learn about HTML5, CSS and Javascript by create a game. Together we’re going to build our very own Flappy Bird. We’ll do it step by step and it will be a lot of fun!

Minecraft Modding

Minecraft is a multi-player game about building and placing blocks in a three-dimensional environment. The game allows modifications (known as “mods”) that can change the game from what it was originally written. These mods can add content to the game to alter gameplay. For example, new blocks, mobs, and abilities of player can be added.

Have you always wondered what it takes to write these mods ? This workshop is for you!

In this workshop we’ll teach the kids on how to build Minecraft mods. In the process, they also learn some basic Java concepts as well. No programming experience is required.


Scratch ( makes it easy to create interactive stories, animations, games, music, and art, and share these creations on the web. You will create several fun and interesting Scratch programs. No programming experience or typing skill is required.


Are you living in/around Boston area? Interested in becoming a volunteer?

No programming experience is required, some familiarity with computers would be useful. You’ll be required to listen to the instructor and help the attendees follow along.

Sign up using the form below.

Once again, don’t forget to register if you or your kid would like to attend the workshop!

Gilt and Microservices: Why and How provides instant insider access to top designer labels, at up to 70% off retail. The company went through growing pains when the monolithic application was not able to handle the needs of growing business demand. They looked at microservices for a scalable solution and are one of the live examples of how they are using it effectively to keep up with the velocity and agility of the business.

  • What was the need to refactor monolithic application to microservice?
  • What is the technology stack?
  • Is JVM relevant?
  • Relevance of containers
  • Is DevOps a requirement for microservices?
  • Should the microservices be fully contained or can the data be shared?

Watch the answer to these questions in this interview with Adrian Trenaman (@adrian_trenaman), software engineer at Gilt:

Some other details are at:

  • Scaling Microservices at Gilt with Scala, Docker, and AWS
  • Scaling Gilt: From Monolithic Ruby Application to Distributed Scala Microservices Architecture

Many thanks to Daniel Bryant (@danielbryantuk) for the introduction!

Cloud, Devops, Microservices Track Program Committee at JavaOne 2015


JavaOne 2015 Program Committee wheels are churning to make sure we provide the best content for you this year. There are a total of 9 tracks covering the entire Java landscape and all the track leads and program committee members are reviewing and voting upon the submissions. This is not an easy task especially when there are a lot of submission and the quality of submissions is top notch.

Here is the list of program committee members for Cloud and DevOps track:




 James Turnbull

And I am (@arungupta) leading the track along with @brunoborges!


Complete list of all the program committee members across all the tracks is published here.

Many thanks for all the wonderful submissions, and to all the program committee members for reviewing the proposals!

Just to give you an idea, here is the tag cloud generated from the titles of all submissions for Cloud and DevOps track:


JavaOne 2015 Title Tag Cloud for Cloud/DevOps Track


And a tag cloud from all the abstracts of the same track:

JavaOne 2015 Abstract Tag Cloud for Cloud/DevOps Track


And in case you are wondering, here is the tag cloud of titles from submissions across all the tracks:

JavaOne 2015 Tag Cloud Title


And the same for submissions across all the tracks:

JavaOne 2015 Tag Cloud Abstract


Stay tuned, we are working hard to make sure to provide an excellent content at JavaOne!

Here are a couple of additional links:

  • Register for JavaOne
  • Justify to your boss

And, you can always find all the details at

Java EE, Docker and Maven (Tech Tip #89)

Java EE applications are typically built and packaged using Maven. For example, is a trivial Java EE 7 application and shows the Java EE 7 dependency:

And the two Maven plugins that compiles the source and builds the WAR file:

This application can then be deployed to a Java EE 7 container, such as WildFly, using the wildfly-maven-plugin:

Tests can be invoked using Arquillian, again using Maven. So if you were to package this application as a Docker image and run it inside a Docker container, there should be a mechanism to seamlessly integrate in the Maven workflow.

Docker Maven Plugin

Meet docker-maven-plugin!

This plugin allows you to manage Docker images and containers from your pom.xml. It comes with predefined goals:

Goal Description
docker:start Create and start containers
docker:stop Stop and destroy containers
docker:build Build images
docker:push Push images to a registry
docker:remove Remove images from local docker host
docker:logs Show container logs

Introduction provides a high level introduction to the plugin including building images, running containers and configuration.

Run Java EE 7 Application as Docker Container using Maven


  1. Create and Configure a Docker Machine as explained in Docker Machine to Setup Docker Host
  2. Clone the workspace as: git clone
  3. Build the Docker image as: mvn package -Pdocker
  4. Run the Docker container as: mvn install -Pdocker
  5. Find out IP address of the Docker Machine as: docker-machine ip mydocker
  6. Access your application

Docker Maven Plugin Configuration

Lets look little deeper in our sample application.

pom.xml is updated to include docker-maven-plugin as:

Each image configuration has three parts:

  • Image name and alias
  • <build> that defines how the image is created. Base image, build artifacts and their dependencies, ports to be exposed, etc to be included in the image are specified here.Assembly descriptor format is used to specify the artifacts to be included and is defined in src/main/docker directory. assembly.xml in our case looks like:
  • <run> that defines how the container is run. Ports that need to be exposed are specified here.

In addition, package phase is tied to docker:build goal and install phase is tied to docker:start goal.

There are four docker-maven-plugin and you can read more details in the shootout on what serves your purpose the best.

How are you creating your Docker images from existing applications?



Microservices with JBoss EAP 6 Reference Architecture

Microservices follow the divide-and-conquer methodology for technology and teams to create a software that is easier to develop, understand and maintain. The overall quality of the software is much higher because of the CI/CD practices that are an imperative part of using such an architecture.

A new paper is released by the Red Hat Reference Architecture Team titled “Microservice Architecture: Building Microservices with JBoss EAP 6“.

The purpose of the reference architecture is explained in the summary section:

This reference architecture recites the basic tenets of a microservice architecture and analyzes some of the advantages and disadvantages of this approach. This paper expressly discourages a one size fits all mentality, instead envisioning various levels of modularity for services and deployment units.

Microservice Reference Architecture

The reference architecture also provides a sample application that shows how to build a microservice application using JBoss Developer Studio and JBoss EAP 6:

The sample application provided with this reference architecture demonstrates Business Driven Microservices. The design and development of this system is reviewed at length and the steps to create the environment are documented.

Are you building and deploying microservices using JBoss EAP 6? Share your thoughts with us!

Previously published reference architecture documents are available at

Provide feedback at

Deploying Java EE Application to Docker Swarm Cluster (Tech Tip #88)

What is Docker Swarm?

Docker Swarm provides native clustering to Docker. Clustering using Docker Swarm 0.2.0 provide a basic introduction to Docker Swarm, and how to create a simple three node cluster. As a refresher, the key components of Docker Swarm are shown below:

In short, Swarm Manager is a pre-defined Docker Host, and is a single point for all administration. Additional Docker hosts are identified as Nodes and communicate with the Manager using TCP. By default, Swarm uses hosted Discovery Service, based on Docker Hub, using tokens to discover nodes that are part of a cluster. Each node runs a Node Agent that registers the referenced Docker daemon, monitors it, and updates the Discovery Service with the node’s status. The containers run on a node.

That blog provide complete details, but a quick summary to create the cluster is shown below:

Listing the cluster shows:

It has one master and two nodes.

Deploy a Java EE application to Docker Swarm

All hosts in the cluster are accessible using a single, virtual host. Swarm serves the standard Docker API, so any tool that communicates with a single Docker host communicate can scale to multiple Docker hosts by communicating to this virtual host.

Docker Container Linking Across Multiple Hosts explains how to link containers across multiple Docker hosts. It deploys a Java EE 7 application to WildFly on one Docker host, and connects it with a MySQL container running on a different Docker host. We can deploy both of these containers using the virtual host, and they will then be deployed to the Docker Swarm cluster.

Lets get started!

MySQL on Docker Swarm

  1. Start the MySQL container
  2. Status of the container can be seen as:
    It shows the container is running on swarm-node-01.

    Make sure you are connected to the Docker Swarm cluster using eval $(docker-machine env --swarm swarm-master).

  3. Find IP address of the host where this container is started:

    Note IP address of the node where MySQL server is running. This will be used when starting WildFly application server later.

    ps: Filtering by name seem to not return accurate results (#10897).

WildFly on Docker Swarm

  1. Start WildFly application server by passing the IP address of the host and the port on which MySQL server is running:

  2. Status of the container can be seen as:

    It shows the container is running on swarm-node-02. IP address of the host is also shown in the PORTS column.

    As explained in Tech Tip #69, JDBC URL of the data source uses the specified IP address and port for connecting with the MySQL server. However passing IP address is very brittle as the MySQL server may restart on a different Docker host. This is filed as #773.

  3. Access the application at:

    This is using the IP address of the host where the container is started.



Java EE, DevOps, Microservices at Red Hat Summit and DevNation

RedHat Summit LogoDevNation Logo

Red Hat Summit and DevNation together are the biggest and the best gathering of everybody and everything in Red Hat ecosystem.

Red Hat Summit Banner 2015

This 11th year of Summit will have 170 sessions and labs, 8 keynotes, parties, receptions, and a lot more. DevNation, in its second year, is an open source and polyglot conference will have 60+ sessions and labs and several crossover sessions and BoFs from Summit. There are also late night hacking sessions.

Together, these two events will provide a complete geekgasm for anybody using Red Hat technologies.

When? Jun 21-25, 2015 (DevNation) and Jun 23-26, 2015 (Summit)
Where? Hynes Convention Center, Boston, MA
Agenda: Summit and DevNation
Register: Summit and DevNation

In addition, there are kids workshops, organized by Devoxx4Kids, on Sunday, Jun 21. Stay tuned for registration details for that!

You can always find me in the hallways or attend my sessions:

Title Coordinates
DevOps with Java EE  Monday, June 22, 11:30am
Use OpenShift & PaaS to accelerate DevOps & continuous delivery  Wednesday, June 24, 10:40am
Docker for Java developers (lab)  Thursday, June 25, 10:30am
How DevOps and microservices impact your application architecture and development  Friday, June 26, 11am

Looking forward to see you there!


JDK 9 REPL: Getting Started (Tech Tip #87)

Conferences are a great place to meet Java luminaries. Devoxx France was one such opportunity to meet Java language architect, ex-colleague and an old friend – Brian Goetz (@briangoetz). We talked about JDK 9 and he was all raving about REPL. He mentioned that even though there are a lot of significant features, such as modularity and HTTP2 client, in Java SE 9, but this tool is going to be talked about the most often. The statement makes sense since it will really simplify exploration of Java APIs, prototyping, demos in conferences, and similar tasks a lot simpler. This blog is coming out of our discussion there and his strong vote on REPL!

Read-Evaluate-Print-Loop has been there in Lisp, Python, Ruby, Groovy, Clojure, and other languages for a while. Unix shell is a REPL which can read shell commands, evaluate them, print the output, and goes back in the loop to do the same thing.


You can read all about REPL in JDK 9 in JEP 222. Summary from the JEP is:

Provide an interactive tool which evaluates declarations, statements, and expressions of the Java Programming Language: that is, provide a Read-Evaluate-Print Loop (REPL) for the Java Programming Language. Also, provide an API on which the tool is built, enabling external tools to supply this functionality.

JEP 222

The motivation is also clearly spelt out in the JEP:

Without the ceremony of class Foo { public static void main(String[] args) { … } }, learning and exploration is streamlined.

JEP 222

JEP 222 targets to ship REPL with JDK 9 but does not list it is as “targeted” or “proposed to target”. Seems like a documentation bug 😉


As of JDK 9 build 61, REPL is not integrated, and needs to be built separately. Eventually, at some time before JDK 9 is released, this tool will be integrated in the build.

Lets see what does it require to have it running on OSX. This blog followed Java 9 REPL – Getting Started Guide to build and run REPL. In addition, it provides complete log output from the commands which might be helpful for some.

Lets get started!

Install JDK 9

  1. Download the latest build, 61 at the time of this writing.
  2. Setup JAVA_HOME as:
    More details on setting JAVA_HOME on OSX are here.
  3. Verify the version:

Checkout and Install jline2

jline2 is a Java library for handling console input. Check it out:

And then build it:

Clone and Build JDK 9 REPL

OpenJDK codename for the project is Kulla which means “The God of Builders”. Planned name for the tool is jshell.

  1. Check out the workspace:
  2. Get the sources:
  3. Edit langtools/repl/scripts/compile.shscript such that it looks like:
    Notice, the only edits are #!/bin/sh for OSX and adding JLINE2LIB to the location of your previously compiled jline2 workspace. javac is picked from JAVA_HOME that is referring to JDK 9.
  4. Compile the REPL tool by invoking the script from langtools/repl directory:


  1. Edit langtools/repl/scripts/ script such that it looks like:
    Notice, the only edits are !/bin/sh for OSX and adding JLINE2LIB.
  2. Run REPL as:

JDK 9 REPL Hello World

Unlike the introduction of bouncing ball or dancing Duke that was used to introduce Java, we’ll just use the conventional Hello World for REPL

Run “Hello World” as:


No public static void main, no class creation, no ceremony, just clean and simple Java code. The entered text is called as “snippet”.

The complete Java code can be seen using /list all and looks like:

This snippet can be saved to a file as:

Note this is not a Java file. Saved snippet is exactly what was entered:

And the tool can be exited as:

Or you can just hit Ctrl+C.

Complete list of commands can be easily seen:

JDK 9 REPL Next Steps and Feedback

Follow the REPL Tutorial to learn more about the tool’s capability. Here is a quick overview:

  • Accepts Java statements, variable, method, and class definitions, imports, and expressions
  • Commands for settings and to display information, such as /list to display the list of snippets, /vars to display the list of variables, /save to save your snippets, /open to read them back in.
  • History of snippets is available, snippets can be edited by number, and much more

Here is an RFE that would be useful:

  • Export a snippet as full blown Java class

A subsequent blog will showcase how this could be used for playing with a Java EE application. How would you use REPL?

Discuss the project/issues on kulla-dev.

Keep Calm and REPL


WildFly Swarm: Building Microservices with Java EE

Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away

Antoine de Saint-Exupery

This quote by the French writer Antoine de Saint-Exupery was made to substantiate that often less is more. This is true for architect, artist, designer, writer, running, software developer, or in any other profession. Simplicity, minimalism, cutting down the cruft always goes a long way and has several advantages as opposed to something bloated.

What is WildFly Swarm?

WildFly is a light weight, flexible, feature rich, Java EE 7 compliant application server. WildFly 9 even introduced a 27MB Servlet-only distribution. These are very well suited for your enterprise and web applications.

WildFly Swarm takes the notch a bit higher. From the announcement:

WildFly Swarm is a new sidecar project supporting WildFly 9.x to enable deconstructing the WildFly AS and pasting just enough of it back together with your application to create a self-contained executable jar.

WildFly Swarm

The typical application development model for a Java EE application is to create an EAR or WAR archive and deploy it in an application server. All the dependencies, such as Java EE implementations are packaged in the application server and provide the functionality required by the application classes. Multiple archives can be deployed and they all share the same libraries. This is a well understood model and have been used over the past several years.

WildFly Swarm turns the table where it creates a “fat jar” that has all the dependencies packaged in a JAR file. This includes a minimalist version of WildFly, any required dependencies, and of course, the application code itself. The application can simply be run using java -jar.

Each fat jar could possibly be a microservice which can then independently upgrade, replace, or scale. Each fat jar would typically follow single responsibility principle and thus will have only the required dependencies packaged. Each JAR can use polyglot persistence, and use only the persistence mechanism that is required.

Show me the code!

A Java EE application can be packaged as WildFly Swarm fat jar by adding a Maven dependency and a plugin. Complete source code for a simple JAX-RS sample is available at

WildFly Swarm Maven Dependency

Add the following Maven dependency in pom.xml:

WildFly Swarm Maven Plugin

Add the following Maven plugin in pom.xml:

Create WildFly Swarm Fat Jar

The fat jar can be easily created by invoking the standard Maven target:

This generates a JAR file using the usual Maven conventions, and appends -swarm at the end. The generated WAR file name in our sample is swarm-1.0-SNAPSHOT-swarm.jar.

The generated WAR file is ~30MB, has 134 JARs (all in m2repo directory), and 211 classes. The application code is bundled in app/swarm-1.0-SNAPSHOT.war.

Run WildFly Swarm Fat Jar

This far jar can be run as:

The response can be verified as:

WildFly Swarm Release blog refers to lots of blogs about Servlet, JAX-RS with ShrinkWrap, DataSource via Deployment, Messaging and JAX-RS, and much more.

WildFly Swarm Next Steps

This is only 1.0.0.Alpha1 release so feel free to try out samples and give us feedback by filing an issue.

You have the power of all WildFly subsystems, and can even create embeddable Java EE container as shown in the release blog:

Subsequent blogs will show how a microservice can be easily created using WildFly Swarm.

WildFly Swarm Stay Connected

You can keep up with the project through the WildFly HipChat room, @wildflyswarm on Twitter, or through GitHub Issues.

WildFly 9 on NetBeans, Eclipse, IntelliJ, OpenShift, and Maven (Tech Tip #86)


WildFly 9 CR1 was recently released. Lots of cool features are included:

  • Intelligent load balancing
  • HTTP/2 and SPDY support
  • A new offline CLI mode
  • Graceful single node shutdown
  • A new Servlet-only distribution

And this is above the usual Java EE 7 compliance!

This blog is a quick check to verify that it works in all three major IDEs and OpenShift.

WildFly 9 and NetBeans

Lets start with NetBeans 8.0.x first. The screenshot shows WildFly 9 CR1 configured in NetBeans and started. The log is shown in the console.

WildFly 9 CR1 on NetBeans

Complete instructions to setup WildFly in NetBeans are in NetBeans 8 and WildFly 8.

WildFly 9 and Eclipse

Getting Started with JBoss Tools and WildFly 8 shows how to configure WildFly with JBoss Tools. Here are the series of snapshots that shows configuring WildFly 9 in JBoss Tools with Eclipse Mars M6.

A new experimental runtime …

WildFly 9 CR1 Experimental

Specify the directory …

WildFly 9 CR1 Eclipse New Runtime

Now WildFly 9 is configured as a Server in Eclipse …

WildFly 9 CR1 Eclipse Servers

And finally the server is up and running …

WildFly 9 CR1 Eclipse Console

Complete details, including download and update center coordinates, are explained at JBoss Tools Alpha 2 for Eclipse Mars.

WildFly 9 and IntelliJ

WildFly 8 and IntelliJ IDEA Screencast provide complete details on how to setup IntelliJ with WildFly. The snapshot below shows WildFly 9 configured in IntelliJ 14.1.2.

WildFly 9 CR1 with IntelliJ 14

WildFly 9 and OpenShift

Creating an OpenShift application is pretty straightforward as well:

This creates a new application and uses WildFly 9 as the underlying application server. Complete details about the OpenShift cartridge are at You can find about how to create an OpenShift application with an existing application, how to connect to this WildFly instance using JBoss CLI.

WildFly 8 CR1 on OpenShift also provide more details.

WildFly 9 and Maven

WildFly Maven Plugin  provide the latest information about how to get started with WildFly Maven plugin.

But you just need to fire up a WildFly server as:

And then deploy the Java EE 7 Movieplex application as:

And the plugin definition is very simple:


WildFly 9.0 CR1 is Released – HTTP/2, Intelligent Load Balancing, Graceful shutdown, Offline CLI, more

WildFly 9 Banner

WildFly 9.0 CR1 is now released, download from (zip)!

It builds upon the Java EE 7 compliance already achieved in earlier versions and adds the following features:

  • Intelligent load balancing
  • HTTP/2 and SPDY support
  • A new offline CLI mode
  • Server suspend, resume, and graceful shutdown
  • A new Servlet-only distribution

Release Notes provide complete details. 86 issues were fixed since 9.0.0 Beta 2.

How do you get started?

  • Download zip and unzip
  • Start as:
  • Access the main page as localhost:8080 as shown:WildFly 9 Welcome
  • Shutting down the server now shows the following log:

You can already configure this in JBoss Tools Alpha 2. Its currently not supported in NetBeans and has been filed as #252197.

#102030: Celebrating 20 Years of Java by Running 20 10K in 30 Days

May 23rd, 1995 was a momentous day in the history of technology. It does not seem the industry realized that a language released on that day would completely change the landscape of technology in the coming years. Java will be celebrating 20th birthday on the same date this year.

20 years of Java, wow!

Java 20th Anniversary

Go back 20 years in the memory lane and think about when/how Java was invented. World Wide Web was for elites, 5 1/2″ floppy disks, dial-up modems, bulletin boards, e-commerce was just launched. There were, of course, no smart phones, Netflix, Twitter, Facebook, Uber, or any such technology. Pause for a few seconds, think about all the years in between in terms of how the language and the platform has evolved.

Embracing, rich, powerful, reliable, capable and robust are some of the words that come to mind. All of these technologies are now powered by Java!

Isn’t this LEGEN … wait for it … wait for it … wait for it  … DARY (in Barney Stinson’s style 😉 This is truly legendary!

C was invented ~43 years ago, C++ ~32 years ago, Objective C ~32 years ago, and C# ~15 years ago. And which is the only language, other than C, that has stayed among the top 2 languages in Tiobe Index?

Java, of course!

And it is now the top language, once again, for April 2015.

Tiobe April 2015

I joined Sun Microsystems back in Mar 1999 when JDK 1.2.2 was planned. It was extremely fortunate to be part of the inaugural release of J2EE 1.2 (yeah, that’s what it used to be called back then, not any more though) in Dec 1999. And since then the world has been a very different place in enterprise Java world. So Java community is definitely close to heart!

Learn and watch some really historical artifacts from one of the nighthacking sessions:

Here are some master pieces that I’ve possessed over the years:

Java 20 Badges Java 20 Banners

Java 20 Duke  Java 20 Ring

Enough background! 20th birthday of Java demands a celebration. So what do we do?

How to celebrate?

A trek to Mt Everest Base Camp was planned to celebrate the 20th anniversary of Java. Flight tickets were booked, trekking company was engaged, clothes and gears were purchased, and lots of other interesting conversations were happening. The goal was to reach Mt Everest Base Camp on May 23rd and celebrate the anniversary at one of the highest point in the world. However due to unforeseen and unfortunate circumstances, this trek is now cancelled. Fortunately, there was a guardian angel protecting us!

So how am I going to celebrate 20th anniversary of Java?

As an avid runner, I’d like to run twenty 10ks in 30 days of May. Each 10k will be dedicated to one year of Java. Now the distance can certainly be greater than 10k, but it has to be at least 10k.

My runs can be tracked at or on Strava:

Hopefully it will inspire some other Java community members to pick up a healthy activity during the month of May.

You don’t necessarily have to run. There are other ways to celebrate #102030:

  • 20 days of 10 pushups/pullups/squats for 30 days
  • 10 sets of 20 pushups for next 30 days, or 30 sets of 20 pushups for 10 days
  • Donate $10 to 20 charities of your choice, or $20 to 10 charities, or $20 * 10 to 1 charity of your choice over 30 days (e.g. Devoxx4Kids)
  • Write 20 tips on how Java can be used in 10 topics over 30 days
  • Write 10 blogs with 20 tips over 30 days
  • Take 20 minute power naps every day (suggested by @evanchooly 😉

Pick any combination of 10, 20, 30 and use #102030 to share how you are celebrating the 20th birthday month of Java :)

Whats your #102030?