Friday Sep 06, 2013

JavaOne 2013 with Markus Eisele: Sins and Security in Java EE

Markus Eisele shares his expertise on Java EE.[Read More]

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.

Details
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 blogs.oracle.com/javaone.


About

Insider News from the Java Team at Oracle!

duke
Links


Search

Archives
« August 2015
SunMonTueWedThuFriSat
      
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
     
Today