Sunday May 01, 2016

Talk on Project Vahalla, Completable Future and Many more - Join Us.

Bangalore Java User Group in the month of May going to talk about (Details :  :-

Project Valhalla (Beyond JDK9)

- Value Types

- Specialized Generics

- Var Handles

Talk by :- Srikanth A 

Completable Future and Micro Services

- A deep look at micro services architectures 

- A view of Java Completable Future.

- Design of low latencymicro-services using Completable Future.

Talk by :- Srinivasan R 

Locale infrastructure in Java

- Understanding the basics of Locale

- Locale Sensitive classes

- Locale Data Provider sources.

- By Rachna G 

Bangalore Java User Group (JUG)- Meeting in April 2016

Presentations can be downloaded from :- 

We have done the following sessions :-

Session Details :-

1. Name: Dinesh Bhatt

Org. : Syncogni Consulting

Talking about : RxJava.

Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM. 

2. Name: Rajesh Thandapani 

Org: Oracle, IOT team

Talking about: JDK Device IO API.

The DIO API is very important for IoT apllications developed using Java SE embedded/Java ME technologies. It is a device independent API that enable Java developes to work with various sensors/devices I2C/SPI/GPIO/UART etc. I think since IoT applications are getting popular, there may be interest among java developers to understand/use this API. 

3. Name: Ranganath S 

Talking about: Java Microservices ,

Advantages of Microservices Architecture, Approaches to implement Microservice Architecture.

Thursday Mar 03, 2016

Bangalore Java User Meetup - Jan 2016

We have 3 sessions on :-

 1. i18n - Why internationalization is important

2. Lambdas internal and in-practice - A session quite inspired from Brian talk of JavaOne.

3. Kotlin - The new VM Language by Jetbrains.

 Presentations can be find out here :

Tuesday Oct 13, 2015

Oct. Sessions in Java User Group, Bangalore

 Oct. Sessions in Java User Group, Bangalore. Do join !!

Session Details


Nashorn - Javascript engine in java.

by Sundarajan - He is the writer of Nashorn and want to deliver this talk over video conference. 

1 hrs around.

2. JDWP Protocol and Java debugging

by T. Rajesh Kumar,  Oracle India

45 minutes.

3. Introducing Oracle NoSQL Database

by Anand Chandak and Ashutosh

45 minutes

Monday Sep 21, 2015

Java User Group Meetup for Sep 2015

We have done 2 presentation this month in Java User Group, Bangalore, INDIA.

1. Simple Demo and Usages of ConcurrentHashMap

2. Project JIGSAW - Presentation Here

Some of the snaps of the event.

Friday Jul 31, 2015

Presentations on JUG

Presentations on Concurrency GC and Completable Future done in last JUG:

Happy reading !! 

Saturday Jul 25, 2015

Bangalore Java User Group (JUG)- July Meet-up

Today, we had very interesting sessions on Concurrent Garbage Collector and Completable Future by Deepak and Srinivasan.

Deepak, while taking about the Azul Garbage Collector covers: 

- The basics of GC

- How we can proceed for a concurrent GC

- What are the challenges to achieve a concurrency in GC

Srinivasan while talking about the Completable Future covers: 

- How the new Completable Future of JDK 8 is better than the old calls

- How the real life applications like Banking, Online booking systems can use this feature.

- What were the old bottleneck which got addressed.

If you are also interesting in joining Bangalore Java User Group, follow us on:

Our meetup page -

Our Facebook page -

 Soon, I will provide the links for the presentation. 

Monday Jul 13, 2015

A fast overview of Just-In-Time(JIT) Compiler

JIT comes in these flavors:
 C1 (Client compiler) -client option
 C2 (Server compiler)-server option
 -XX:+TieredCompilation - Better decision of compilers.

Common Optimizations done by Just-In-Time (JIT) Compiler do:

 1. Eliminate dead codes and Expression optimization.

 int someCalculation(int x1, int x2, int x3) {
         int res1 = x1+x2;
         int res2 = x1-x2;
         int res3 = x1+x3;
         return (res1+res2)/2; 

will be converted to

int someCalculation(int x1, int x2, int x3) {
	return x1; 

 2. Inline Method

- Substitute body of the method (<35 bytes of JVM bytecode) - This provides the best optimization by JIT - A better inline that C++ 

For Example: 

int compute(int var) { int result; if(var > 5) { result = computeFurther(var); } else { result = 100; } return result; } 

If you call myVal = compute(3); it will get converted into myVal = 100;


3. Caching Technique:

Point findMid(Point p1, Point p2) { Point p; p.x = (p1.x + p2.x)/2; p.y = (p1.y + p2.y)/2; return p;

p1.x, p2.x -> It can convert into temp1, temp2 and can be cached.


4. Monomorphic dispatch:

public class Birds { private String color; public String getColor() { return color; } } myColor = birds.getColor(); 

If there is no other override of this method, it will convert into

public class Birds { String color; }

mycolor = birds.color; 


5. Null Checks Removal:

x = point.x; y = point.y; At JVM it is equivalents to: if(point==null) throw new NullPointerException(); else { x = point.x; y = point.y; }  

But if the code will not throw NullPointer for more than threshold reference, it will remove the if check.


6. Threading Optimizations:

- Eliminate locks if monitor is not reachable from other threads - Join adjacent synchronized blocks on the same object

7. Loop Optimizations: 

- Combining loops – Two loops can be combined if taking equivalent time. - Inversion loops – Change while into do-while. (why, just give a javap -c) - Tiling loops – Re-organize loop so that it will fix in cache. 


VM Args:

Xint – Interpreter mode Xcomp – Compiled mode Xmixed – Interpreter + Compiler -server → C2 compiler -client → C1 compiler -XX:+TieredCompilation → C1 + C2 (used by 32/64 bit mode) 


Logging Options:

-XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation -XX:LogFile=<path to file> -XX:MaxInlineSize=<size> -XX:FreqInlineSize=<size> 

(For more see my last blog)



Tuesday Jul 07, 2015

VM Options for C1 and C2

Many Java Developers often ask what are the flag options available for C1 and C2 Compilers or what are the flag options available for JIT compilers. Though most of the time our slides will cover some of the important VM options (-XX) but certainly we can't  provide the list of complete option in slides. This is actually quite a trivial job.

Here it goes:

1. Complete VM global flag option (redirecting it to out file):

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal > out

wc -l < out

764  // Total available options, did on jdk7

2. If you will check without  UnlockDiagnosticVMOptions, the no.s will be bit less.

java  -XX:+PrintFlagsFinal > out

wc -l < out


2. This document comes with the beautiful option of where it is been used like Product, C2 diagnostic, C1 Product and many more. So, just grep the out file with "C2" and see what options are available for you on C2 Compiler and which options are product options and which are diagnostic or logging options.

 cat out | grep "C2" 

A list will come something like:

     intx AliasLevel                                = 3               {C2 product}

     bool AlignVector                               = true            {C2 product}

     intx AutoBoxCacheMax                           = 128             {C2 product}

     bool BlockLayoutByFrequency                    = true            {C2 product}

     intx BlockLayoutMinDiamondPercentage           = 20              {C2 product}

     bool BlockLayoutRotateLoops                    = true            {C2 product}

     bool BranchOnRegister                          = false           {C2 product}

     intx ConditionalMoveLimit                      = 3               {C2 pd product}

     bool DebugInlinedCalls                         = true            {C2 diagnostic}

ccstrlist DisableIntrinsic                          =                 {C2 diagnostic}

     bool DoEscapeAnalysis                          = true            {C2 product}

     intx DominatorSearchLimit                      = 1000            {C2 diagnostic}

     intx EliminateAllocationArraySizeLimit         = 64              {C2 product}

     bool EliminateAllocations                      = true            {C2 product}

     bool EliminateAutoBox                          = false           {C2 diagnostic}

     bool EliminateLocks                            = true            {C2 product}

     bool EliminateNestedLocks                      = true            {C2 product}

     bool IncrementalInline                         = true            {C2 product}

     bool InsertMemBarAfterArraycopy                = true            {C2 product}

     intx InteriorEntryAlignment                    = 16              {C2 pd product}

     intx LiveNodeCountInliningCutoff               = 20000           {C2 product}

 3. Running the same option for C1.

cat out | grep "C1" 

We can see:

     bool C1OptimizeVirtualCallProfiling            = true            {C1 product}

     bool C1ProfileBranches                         = true            {C1 product}

     bool C1ProfileCalls                            = true            {C1 product}

     bool C1ProfileCheckcasts                       = true            {C1 product}

     bool C1ProfileInlinedCalls                     = true            {C1 product}

     bool C1ProfileVirtualCalls                     = true            {C1 product}

     bool C1UpdateMethodData                        = true            {C1 product}

     intx CompilationRepeat                         = 0               {C1 product}

     bool LIRFillDelaySlots                         = false           {C1 pd product}

     intx SafepointPollOffset                       = 256             {C1 pd product}

     bool TimeLinearScan                            = false           {C1 product}

     intx ValueMapInitialSize                       = 11              {C1 product}

     intx ValueMapMaxLoopSize                       = 8               {C1 product}

 Enjoy JIT'ing.

Saturday Jul 04, 2015

20 Years of Java In India

20 years of Java has been celebrated across the globe. Here in India Center (IDC), we had a small celebration. Look at our new "Duke" Shirts :). We have Bernard joining for the celebration (search where !!).

Wednesday Jul 01, 2015

Bangalore Java User Group (JUG)- Meeting in July

Talks in List: 

Concurrent Garbage Collection - Harish Babu -  60 mins

Completable Future - Srinivasan Raghavan -  45 mins

Java 8 new Javascript engine call Nashorn - Shekhar Gupta   45 mins

Friday Mar 26, 2010

Tech Days 2010 @ Hyderabad

2010 Sun Tech days over. Nice time at presentation and in train too. Nothing more to write. James was good. 

Presentation here: 

 G1 presentation  and mixing Lightweight/Heavyweight components.

Tuesday Dec 22, 2009

LiveConnect improvement in JDK6

JDK6 has done lot of changes in LiveConnect. LiveConnect is a feature in the browser for communication between Java Applet and JavaScript. With the new Plugin2, most of the work has been left on browser to do. Initially it was Java which do a good amount of work. So, now the Java Plug-in will operate like any other scriptable Plug-in. ..............
[Read More]

Tuesday Dec 15, 2009

Lightweight and Heavyweight components - Mess it !

So, if you are a Swing Developer, you have heard many stories where someone messed Lightweight component with Heavyweight component. In one line " A heavyweight component is one that is associated with its own  native screen resource (commonly known as a peer). A lightweight component is one that "borrows" the screen resource of an ancestor  (which means it has no native resource of its own -- so it's "lighter")."

 Now many times you have heard "Don't mix lightweight and heavyweight". What will happen ? Alright, here is a small code : ............

[Read More]

Wednesday Nov 25, 2009

Sorting and OpenJDK

If you are looking for sorting algorithms and if you use some sorting algorithm in your code/application/big application, then have a look here. First of all sorting/searching is a classic thing. It take more than 70 percent of your application time.People/Developer/Mathematician do a lot of work on optimizing this work to get Best, best out of best.

Early days, JDK used to use QuickSort which is one of the best sorting algorithm and go for a complexity of O(nlogn). But mind it, QuickSort is a recursive algorithm and consume space. Whereas some of the algorithm which has the complexity like O(n\^2) go for less complex in terms of memory. These days our platform varies from small mobile device to a terabyte storage machine............

[Read More]

Vaibhav Hi, I am Vaibhav Choudhary working in Oracle with JDK team. This blog is all about simple concept of Java, JVM and JavaFX.


« July 2016