Wednesday Aug 07, 2013

Garbage First Garbage Collector Tuning

A new article, now up on otn/java, titled “Garbage First Garbage Collector Tuning,”
by Monica Beckwith, Principal Member of Technical Staff at Oracle, and performance lead for the Java HotSpot VM's Garbage First Garbage Collector (G1 GC), shows how to adapt and tune the G1 GC for evaluation, analysis, and performance.

As Beckwith explains, the Garbage First Garbage Collector is the low-pause, server-style generational garbage collector for Java HotSpot VM. It uses both concurrent and parallel phases to achieve its target pause time and maintain good throughput. A garbage collector is a memory management tool. When G1 GC determines that a garbage collection is necessary, it first collects the regions with the least live data – known as garbage first.

Beckwith describes the collection phases and marking cycles, lists default tuning devices, offers recommendations about how to fine tune and evaluate garbage collection, and shows how to respond to overflow and exhausted log messages.

She concludes her article as follows:

“G1 GC is a regionalized, parallel-concurrent, incremental garbage collector that provides more predictable pauses compared to other HotSpot GCs. The incremental nature lets G1 GC work with larger heaps and still provide reasonable worst-case response times. The adaptive nature of G1 GC just needs a maximum soft-real time pause-time goal along-with the desired maximum and minimum size for the Java heap on the JVM command line.”

Check it out here.

Wednesday Jun 26, 2013

Diving into Scala with Cay Horstmann

A new interview with Java Champion Cay Horstmann, now up on otn/java, titled  "Diving into Scala: A Conversation with Java Champion Cay Horstmann," explores Horstmann's ideas about Scala as reflected in his much lauded new book,  Scala for the Impatient.  None other than Martin Odersky, the inventor of Scala, called it "a joy to read" and the "best introduction to Scala". Odersky was so enthused by the book that he asked Horstmann if the first section could be made available as a free download on the Typesafe Website, something Horstmann graciously assented to.

Horstmann acknowledges that some aspects of Scala are very complex, but he encourages developers to simply stay away from those parts of the language. He points to several ways Java developers can benefit from Scala:

"For example," he says, " you can write classes with less boilerplate, file and XML handling is more concise, and you can replace tedious loops over collections with more elegant constructs. Typically, programmers at this level report that they write about half the number of lines of code in Scala that they would in Java, and that's nothing to sneeze at. Another entry point can be if you want to use a Scala-based framework such as Akka or Play; you can use these with Java, but the Scala API is more enjoyable. "

Horstmann observes that developers can do fine with Scala without grasping the theory behind it. He argues that most of us learn best through examples and not through trying to comprehend abstract theories. He also believes that Scala is the most attractive choice for developers who want to move beyond Java and C++.  When asked about other choices, he comments:

"Clojure is pretty nice, but I found its Lisp syntax a bit off-putting, and it seems very focused on software transactional memory, which isn't all that useful to me. And it's not statically typed. I wanted to like Groovy, but it really bothers me that the semantics seems under-defined and in flux. And it's not statically typed. Yes, there is Groovy++, but that's in even sketchier shape.

There are a couple of contenders such as Kotlin and Ceylon, but so far they aren't real.

So, if you want to do work with a statically typed language on the JVM that exists today, Scala is simply the pragmatic choice. It's a good thing that it's such a nice choice."

Learn more about Scala by going to the interview here.

Thursday Apr 04, 2013

Golo – A Lightweight Dynamic Language for the JVM

Julien Ponge, who, in addition to being a Java developer and a professor, also writes technical articles for both otn/java and Java Magazine, has created Golo, a simple, dynamic, weakly-typed open source language that favors the explicit over the implicit. Developers can pick it up in a manner of hours, not days. Responses to its recent release at Devoxx have been favorable.

Built from day 1 with invokedynamic, and currently in beta, Golo takes advantage of the latest advances of the JVM. It is also a showcase on how to build a language runtime with invokedynamic.

The Golo Programming Guide is located here.

Julien is an Associate Professor (Maître de Conférences) in Computer Science and Engineering at INSA-Lyon in France, plus an R&D Computer Scientist at the CITI / INRIA laboratory. Learn more about him here.

Thursday Feb 21, 2013

Register Now for Devoxx UK and Devoxx France 2013

There's only a little over a month to go before Devoxx UK on March 26 and 27 in London and Devoxx France on March 27 to 29 in Paris. The conference schedules are up and space is tight, so register today before they are sold out!

"Cloud, architecture and security" is a new conference track this year. Other tracks are Java SE, methodologies, Java EE, web & big data, new languages on the JVM, and future Devoxx. Developers will get a shot at peer discussions in Bird-of-a-Feathers, learn tips and tricks during quickies and get in-depth technical information in hour-long talks or in the three hour hands-on-labs.  "You could learn something that will help in your day job. Maybe it's a better use of patterns, technologies or methodologies you're utilizing right now" explains Trisha Gee, one of the Devoxx organizers

The conference also presents great networking opportunities with leaders in the Java community and renowned speakers who wrote popular technical books. Some of those well-known speakers are Kirk Pepperdine, Peter Pilgrim, Stephen Chin, Arun Gupta, and Markus Eisele, just to name a few.

Oracle is a European Platinum Partner of the three Devoxx conferences in the U.K., France and Belgium. Come and join us in London and Paris next month.

Wednesday Jan 30, 2013

Nashorn, the JavaScript Implementation in Java 8

In this Interview, Marcus Lagergren, who works on the dynamic language team at Oracle, discussed the Nashorn project.  "Nashorn is the JavaScript runtime based on InvokeDynamic for the Java Virtual Machine (JVM)" he explains. The Nashorn project is now part of the OpenJDK

The performance is much better than its predecessor Rhino. "We totally blow it out of the water now that we have specific tools to run other things than Java on the JVM." Marcus commented. "The pluggability between JavaScript and Java is another good thing" he added.

His Devoxx talk about Nashorn is now freely accessible at Nashorn - implementing dynamic languages on the JVM
Marcus Lagergren's twitter handle is @lagergren. Nashorn blog has the latest on the project

A Rising VM Lifts All Boats: Bay Area Scala Meeting

Join the Bay Area Scala Enthusiasts Feb. 14th in Santa Clara, California to hear how Scala and the JVM work well together. Ever wonder what goes on below the arrows, double colons, and tildes of Scala's syntax? What changes must be made to the JVM and compiler to allow for higher order functions, Actors, and pattern matching? What low level engineering feats will be required for Scala and Java to truly interoperate? Come hear two speakers very close to the thinking and understanding of what goes in to making powerful functional programming features a reality on the JVM. 

JVM Evolution for Higher-Order Languages
Alex Buckley, Specification Lead, Java Language & VM, Oracle.

A Rising VM Lifts All Boats
Paul Phillips is the most prolific contributor to the Scala compiler and a co-founder of Typesafe.

JVM Evolution for Scala @ Oracle Santa Clara
(You need to go to the Bay Area Scala Enthusiasts page to register!) 

Thursday, February 14, 2013
   6:30 to 9:00 pm
Oracle Santa Clara Campus Auditorium

4030 George Sellon Circle (Building 3)
Santa Clara, CA (map)

Scala Resources
OTN Article: Java Champion Dick Wall on the Virtues of Scala 
OTN Article: Java Champion Jonas Bonér Explains the Akka Platform

Thursday Jan 24, 2013

Coding on Crete with Java Specialist Heinz Kabutz

In a new article, now up on otn/java by yours truly, titled “Coding on Crete: An Interview with Java Specialist Heinz Kabutz,” noted Java commentator and consultant Dr. Heinz Kabutz shares insights about the Java platform and talks about his exotic life working as a developer on the island of Crete. Kabutz is well known as the author of the Java Specialists’ Newsletter which reaches some 70,000 developers worldwide.

In a previous 2007 interview, Kabutz lamented the large number of developers who do not engage in unit testing. He offered an update on this:

“The one place where unit testing is sorely lacking is with concurrent code. There are some tools that help find race conditions and deadlocks, but they typically find about a dozen faults per line of code. With such an amount of false positives, discovering a real problem is impossible.

Did you know that there is not a single—not even one—unit test for the Java Memory Model (JMM)? We have to just accept that it works on the Java Virtual Machine (JVM) we are running on. The theory is that if we write our Java code according to the JMM, the code will run correctly on any certified JVM. Unfortunately, the certification does not test the JMM thoroughly. Apparently, there are some tests for the java.util.concurrent classes, and so they assume that if these work, then the JMM must also be correct for that JVM.”

When asked about the greatest performance issues he remarked:

“The biggest performance issue today is still that we often cannot pinpoint the bottlenecks. Customers usually approach us with problems that they have not been able to solve, no matter how many man-months they've thrown at them. The most recent issue I looked at boiled down to a simple race condition. If two threads insert an entry into a shared HashMap at the same time, and the key's hash code points to the same entry in the table, then the HashMap can be corrupted and you might get two entries pointing to each other. This means that whenever you try to call contains() on the map, you risk getting an infinite loop.”

Check out the article.

Friday Oct 19, 2012

An Interview with JavaOne Rock Star Martijn Verburg

An interview with JavaOne Rock Star Martijn Verburg, by yours truly, titled “Challenging the Diabolical Developer: A Conversation with JavaOne Rock Star Martijn Verburg,” is now up on otn/java. Verburg, one of the leading movers and shakers in the Java community, is well known for his ‘diabolical developer” talks at JavaOne where he uncovers some of the worst practices that Java developers are prone to.

He mentions a few in the interview:

* “A lack of communication: Software development is far more a social activity than a technical one; most projects fail because of communication issues and social dynamics, not because of a bad technical decision. Sadly, many developers never learn this lesson.
* No source control: Some developers simply store code in local file systems and e-mail the code in order to integrate their changes; yes, this still happens.
* Design-driven design: Some developers are inclined to cram every design pattern from the Gang of Four (GoF) book into their projects. Of course, by that stage, they've actually forgotten why they're building the software in the first place.”

He points to a couple of core assumptions and confusions that lead to trouble:

“One is that developers think that the JVM is a magic box that will clean up their memory and make their code run fast, as well as make them cups of coffee. The JVM does help in a lot of cases, but bad code can and will still lead to terrible results!

The other trend is to try to force Java (the language) to do something it's not very good at, such as rapid Web development. So you get a proliferation of overly complex frameworks, libraries, and techniques trying to get around the fact that Java is a monolithic, statically typed, compiled, OO environment. It's not a Golden Hammer!”

Verburg has many insightful things to say about how to keep a Java User Group (JUG) going, about the “Adopt a JSR” program, bugathons, and much more.

Check out the article here.

Sunday Sep 30, 2012

Talking JavaOne with Rock Star Charles Nutter

JavaOne Rock Stars, conceived in 2005, are the top rated speakers from the JavaOne Conference. They are awarded by their peers who through conference surveys recognize them for their outstanding sessions and speaking ability. Over the years many of the world’s leading Java developers have been so recognized.

We spoke with distinguished Rock Star, Charles Nutter.

A JRuby Update from Charles Nutter

Charles Nutter of Red Hat is well known as a lead developer of JRuby, a Ruby implementation of Java that is tightly integrated with Java to allow for the embedding of the interpreter into any Java application with full two-way access between the Java and the Ruby code.

Nutter is giving the following sessions at this year’s JavaOne:

  • CON7257 – “JVM Bytecode for Dummies (and the Rest of Us Too)”
  • CON7284 – “Implementing Ruby: The Long, Hard Road”
  • CON7263 – “JVM JIT for Dummies”
  • BOF6682 – “I’ve Got 99 Languages, but Java Ain’t One”
  • CON6575 – “Polyglot for Dummies” (Both with Thomas Enebo)

I asked Nutter, to give us the latest on JRuby. “JRuby seems to have hit a tipping point this past year,” he explained, “moving from ‘just another Ruby implementation’ to ‘the best Ruby implementation for X,’ where X may be performance, scaling, big data, stability, reliability, security, and a number of other features important for today's applications. We're currently wrapping up JRuby 1.7, which improves support for Ruby 1.9 APIs, solves a number of user issues and concurrency challenges, and utilizes invokedynamic to outperform all other Ruby implementations by a wide margin. JRuby just gets better and better.”

When asked what he thought about the rapid growth of alternative languages for the JVM, he replied, “I'm very intrigued by efforts to bring a high-performance JavaScript runtime to the JVM. There's really no reason the JVM couldn't be the fastest platform for running JavaScript with the right implementation, and I'm excited to see that happen.”

And what is Nutter working on currently? “Aside from JRuby 1.7 wrap-up,” he explained, “I'm helping the Hotspot developers investigate invokedynamic performance issues and test-driving their new invokedynamic code in Java 8. I'm also starting to explore ways to improve the general state of dynamic languages on the JVM using JRuby as a guide, and to help the JVM become a better platform for all kinds of languages.”

Originally published on

Thursday Sep 27, 2012

Talking JavaOne with Rock Star Martijn Verburg

JavaOne Rock Stars, conceived in 2005, are the top-rated speakers at each JavaOne Conference. They are awarded by their peers, who, through conference surveys, recognize them for their outstanding sessions and speaking ability. Over the years many of the world’s leading Java developers have been so recognized.

Martijn Verburg has, in recent years, established himself as an important mover and shaker in the Java community. His “Diabolical Developer” session at the JavaOne 2011 Conference got people’s attention by identifying some of the worst practices Java developers are prone to engage in. Among other things, he is co-leader and organizer of the thriving London Java User Group (JUG) which has more than 2,500 members, co-represents the London JUG on the Executive Committee of the Java Community Process, and leads the global effort for the Java User Group “Adopt a JSR” and “Adopt OpenJDK” programs.

Career highlights include overhauling technology stacks and SDLC practices at Mizuho International, mentoring Oracle on technical community management, and running off shore development teams for AIG. He is currently CTO at jClarity, a start-up focusing on automating optimization for Java/JVM related technologies, and Product Advisor at ZeroTurnaround. He co-authored, with Ben Evans, "The Well-Grounded Java Developer" published by Manning and, as a leading authority on technical team optimization, he is in high demand at major software conferences.

Verburg is participating in five sessions, a busy man indeed. Here they are:

  • CON6152 - Modern Software Development Antipatterns (with Ben Evans)
  • UGF10434 - JCP and OpenJDK: Using the JUGs’ “Adopt” Programs in Your Group (with Csaba Toth)
  • BOF4047 - OpenJDK Building and Testing: Case Study—Java User Group OpenJDK Bugathon (with Ben Evans and Cecilia Borg)
  • BOF6283 - 101 Ways to Improve Java: Why Developer Participation Matters (with Bruno Souza and Heather Vancura-Chilson)
  • HOL6500 - Finding and Solving Java Deadlocks (with Heinz Kabutz, Kirk Pepperdine, Ellen Kraffmiller and Henri Tremblay)
When I asked Verburg about the biggest mistakes Java developers tend to make, he listed three:
  1. A lack of communication -- Software development is far more a social activity than a technical one; most projects fail because of communication issues and social dynamics, not because of a bad technical decision. Sadly, many developers never learn this lesson.
  2. No source control -- Developers simply storing code in local filesystems and emailing code in order to integrate
  3. Design-driven Design -- The need for some developers to cram every design pattern from the Gang of Four (GoF) book into their source code

All of which raises the question: If these practices are so bad, why do developers engage in them? “I've seen a wide gamut of reasons,” said Verburg, who lists them as:

* They were never taught at high school/university that their bad habits were harmful.
* They weren't mentored in their first professional roles.
* They've lost passion for their craft.
* They're being deliberately malicious!
* They think software development is a technical activity and not a social one.
* They think that they'll be able to tidy it up later.

A couple of key confusions and misconceptions beset Java developers, according to Verburg.

“With Java and the JVM in particular I've seen a couple of trends,” he remarked. “One is that developers think that the JVM is a magic box that will clean up their memory, make their code run fast, as well as make them cups of coffee. The JVM does help in a lot of cases, but bad code can and will still lead to terrible results! The other trend is to try and force Java (the language) to do something it's not very good at, such as rapid web development. So you get a proliferation of overly complex frameworks, libraries and techniques trying to get around the fact that Java is a monolithic, statically typed, compiled, OO environment. It's not a Golden Hammer!”

I asked him about the keys to running a good Java User Group. “You need to have a ‘Why,’” he observed. “Many user groups know what they do (typically, events) and how they do it (the logistics), but what really drives users to join your group and to stay is to give them a purpose. For example, within the LJC we constantly talk about the ‘Why,’ which in our case is several whys:

* Re-ignite the passion that developers have for their craft
* Raise the bar of Java developers in London
* We want developers to have a voice in deciding the future of Java
* We want to inspire the next generation of tech leaders
* To bring the disparate tech groups in London together
* So we could learn from each other
* We believe that the Java ecosystem forms a cornerstone of our society today -- we want to protect that for the future

Looking ahead to Java 8 Verburg expressed excitement about Lambdas.

“I cannot wait for Lambdas,” he enthused. “Brian Goetz and his group are doing a great job, especially given some of the backwards compatibility that they have to maintain. It's going to remove a lot of boiler plate and yet maintain readability, plus enable massive scaling.”

Check out Martijn Verburg at JavaOne if you get a chance, and, stay tuned for a longer interview yours truly did with Martijn to be publish on otn/java some time after JavaOne.

Originally published on


Insider News from the Java Team at Oracle!



« March 2015