Martijn Verburg

Hi all,

My London based start-up has been building machine learning SaaS tools for application performance analysis. Here's a post on why we spent almost 2 years building Illuminate and what we think is the future of APM :-) -

http://www.jclarity.com/2015/02/24/why-we-built-illuminate-where-apm-is-going-next/

Hi all,

We regularly post about Java/JVM performance tuning matters, here's the latest!

http://www.jclarity.com/2014/01/09/why-didnt-my-app-throw-an-outofmemoryerror/

Campbell Ritchie wrote:Sorry to wake the thread again, but what do you call the new operator. It's -> isn't it? Do youj call it “arrow”?

I don't think there's an idiomatic name for it yet, I've been calling it the arrow as well :-)

Hi all,

Garbage collection a mysterious black hole of frustration? My new start-up jClarity has just released it's first product called Censum. It has powerful analytics that will give a busy developer / operations person the answers they need to solve those OOME and high pause time problems.

Hi all,

FYI - I'm blogging at Are we there yet?. My most recent post is a GC analysis on PCGen, the open source role playing character generator.

Hi all,

It was an absolute pleasure, there were a lot of great, well-thought out questions, thanks again!

C# has actually had the lead on Java for the last few years in terms of its feature set. .NET developers will find things like try-with-resources to be very familiar as they already having the using clause in C#. We don't anticipate any problems for our .NET friends coming across to the light side ;-)

Hi Arulk,

We like to think that the book goes further in depth with the Java 7 features than most blog posts etc. We always like to explain why language features are designed a particular way :-). That said, Polyglot probably makes up about 1/3 of the book, with Groovy, Scala and Clojure covered as well as blended into other chapters such as rapid web development and the TDD chapter.

For me it's invokedynamic, Diamond Operator, try-with-resources, NIO.2 API and multi-catch. I was pretty happy with the scope of Java 7, invokedynamic will prove to be its most important feature going forwards....

Jitendra Chittoda wrote:Hi Martin & Benjamin,

I was going through the contents of the book and had a couple of questions related to the performance tuning.
Does this book put some light on-

G1 GC that has been introduced in java 7, and how much performance benefit we can get using G1 GC.

How to tune GC, how much should be the Heap, PermGenSpace, OldGen ratio for max performance.

Does java has tools like JProfiler, to identify the bottleneck?

* It does discuss G1 in some detail and the sorts of performance characteristics you'll get out of it. But as Ben and I always say "Measure, don't guess!". You always need to look at GC collectors in the context of your application and how that application is driven by its users.
* It talks a little bit about tuning GC yes. However, this is a very large topic which takes up at least 1-2 days of our 4-day performance tuning course :-). Again, it always depends on what type of performance you're wanting, lots of small pauses? Or larger more infrequent pauses?
* Java has VisualVM which you can use for some performance analysis, including GC. However it is fairly basic and will only give you so many insights. Our start-up is actually working on more sophisticated tooling (that still gives simple answers).

Jitendra Chittoda wrote:
Few other questions

As java has been taken over by the Oracle, will they continue to support java as opensource? What you guys think on the future of Java?

Can we expect the same kind of innovations with Oracle as Sun did? It seems Oracle is looking at Java in business terms.

* Absolutely - we're very confident that Oracle will continue to support Java as a fully open source project. We actually work closely with them on this and various other community initiatives such as Adopt OpenJDK and Adopt a JSR.
* Sun actually stopped innovating with Java (the language) towards the end as Java had become the defacto language for what we call the stable layer. This means that millions of developers rely on Java (the language) to not break or change too rapidly. Therefore we're not going to see Java getting the latest language features quickly. However, you have lots of choice with many other languages on the JVM that do have the latest features, who all interoperate with Java nicely.

If you're dealing with web apps, that's correct.

This is a very common pattern is software. Good ideas become design patterns, design patterns are bult into frameworks (like Spring) and then into a language itself (the JSR-330 std for Java). Spring 3.x simply implements the common JSR-330 std + some extras.

John Jai wrote:Hello Authors ,

I have two quick questions after seeing the summary of the book..

1. What might be the purpose of including JVM-based languages Groovy, Scala, and Clojure in the book.

Several otehr rcent threads have covered this but in short: The Well-Grounded Java Developer is actually a Well-Grounded JVM Language Developer, using the right language for the right problem domain. For example Clojure and Scala have more inbuilt support for concurrency, Groovy/Grails is very strong for rapid web development etc. Java the language isn't the Golden Hammer for everything but you can mix and match languages in your project as they all run on the JVM!

John Jai wrote:
2. It's noted modern approaches to testing, build, and CI are discussed. Does testing denotes JUnit testing and build discusses regarding build tools like Ant?

It does discuss some JUnit testing, but more about the TDD approach (using JUnit as the testing framework). It discusses Maven over Ant (but covers why Ant is no longer as popular as it once was).

Hope that helps!

It depends what you intend to use it for :-). For me it's an important enough release to migrate to and since Oracle is no longer supporting Java 6 after November 2012, I'd be looking to move regardless :-)

Palak has covered much of this, but in short, it's faster out of the box, more secure out of the box and has several new features that ensure developers write safer code with less boiler-plate. So lots of reasons to upgrade :-)