Thursday Nov 28, 2013

Java Mission Control - Production Time Profiling Out of the Box

By Guest blogger: Marcus Hirt

With the release of 7u40, there is a new kid on the JDK tooling block – Java Mission Control. This article will try to explain why it is worthwhile to take a closer look at this technology, as well as provide pointers on how to get started. 

History

Mission Control is a production time profiling and diagnostics tools suite that originated with the tooling available for the JRockit JVM. 

As part of the development effort of the JRockit JVM we started building tooling for analyzing the runtime performance of the JVM. We needed information about how real production systems were utilizing JRockit. Requests to get customers to lend us their latest top secret trading applications for evaluation in-house were usually, quite understandably, met with telling blank stares calling our sanity into question. It probably wouldn’t have done us much good anyways, since we wanted production data from systems under real loads. Thus we built a tool (the JRockit Runtime Analyzer, which later evolved into the JRockit Flight Recorder) with low enough overhead that we could convince customers to actually use it to collect production time data for us.

Eventually we accidentally solved some customer problems using the tools and customers started asking us if they could license them. The idea was born to spend some more resources on the tooling and make it a commercial tool to pay for its development. JRockit Mission Control was born.

Java Mission Control

After Oracle acquired Sun Microsystems, Oracle suddenly had two of the top three most commonly used general purpose JVMs available on the market. One was the open sourced reference JVM, with a lot of people knowing the source and licensees basing their own ports and versions of JVM off of it. The other JVM, whilst being a quick and pretty little thing, was proprietary with a rather small number of people knowing the code base. Instead of having to support two JVMs, Oracle wanted to pool the available resources into building a best of breed JVM. It was decided that the base would be HotSpot and that the most useful features in JRockit would be ported over – one of them being Mission Control.


In JDK 7u40 the functionality available in HotSpot had reached critical mass, and the very first version of Java Mission Control (unfortunately versioned 5.2.0) was released. It mainly contains equivalents of two of the JRockit Mission Control tools – the JMX Console and the Flight Recorder. There is no on-line heap analyzer yet. There is however a set of quite useful (experimental) plug-ins for JMC, extending Mission Control to do heap dump analysis, targeted analysis for various oracle products or simply extending existing functionality in more (or sometimes less – yes, I’m looking at you Twitter Trigger Action) useful ways .

Getting Started

Starting Java Mission Control is quite easy. Download a recent enough Java 7 JDK (7u40 or later), then simply launch %JDK_HOME%/bin/jmc. The alien thing that now starts is not, as I am sometimes asked, a native application. It’s Java, but it’s built upon Eclipse RCP technology. If you would rather run JMC inside of Eclipse, you can install JMC into your Eclipse from the JMC update site. A word of caution here – because of a bug in Eclipse/SWT, Mission Control performance is horrible in Eclipse 4.x. This bug is slated to be be fixed in Eclipse 4.4, but until then I strongly recommend either using the stand-alone version of JMC, or installing it into an Eclipse 3.8.2. 

The JMX Console

The console in Mission Control can be thought of as a JConsole on steroids. It allows you to monitor JMX data in various ways, to take action when attributes attain certain values and to persist the data and later look at what has been recorded. There are various experimental plug-ins for the console, such as a Coherence plug-in, a plug-in for running JConsole plug-ins and a plug-in for tweeting messages when a action triggers. 

To connect the console to a JVM, simply choose the JVM you want to connect to in the browser tree and select Start JMX Console. If the JVM was started locally or with JDP, then it will automatically appear in the JVM browser. If you have a remote JVM without JDP running, just enable the built in JMXRMI agent as you normally would to be able to connect with JMX clients such as JConsole.

The JMX console is typically used to monitor a small set of critical attributes, such as the CPU load and Java Heap usage, sampled at a relatively low frequency. The console can be configured to take action when undesirable values are reached for an attribute, and one of those actions can be to dump Flight Recorder data. The JMX console also contains special tabs for looking at thread information, such as deadlocked threads, per thread allocation information and per thread profiling information. That said, the JMX console is used for monitoring the runtime. When profiling capabilities or better diagnostic information is needed, the one stop shop is really the Flight Recorder.

The Java Flight Recorder

The Java Flight Recorder can be thought of as of the equivalent to the Data Flight Recorder for an airplane, but for the Java runtime. While it is running It records information about the JVM and its environment. When something “interesting” happens, the data in the Flight Recorder can be dumped, and the information analyzed off-line to gain an understanding of why everything suddenly went from good to “interesting”. Having the Flight Recorder running as an almost unnoticeable impact on the performance of the Java Application running in the JVM. The overhead is usually well below a per cent. This is achieved by having a high performance recording engine built directly into the runtime and collecting data already being tracked by the runtime or as part of an activity where the data is reachable. (As opposed to actively having to do additional work to get the data.) There are a lot of interesting things that can be said about the recording engine implementation, but this being an overview article, I’ll just move on to how to use it, not how it does what it does.

Creating Flight Recordings

The most important difference to how the Flight Recorder worked in JRockit is that in HotSpot two JVM start-up flags must be enabled on the JVM for which you want to do flight recordings:

-XX:+UnlockCommercialFeatures -XX:+FlightRecorder

And that was probably the most important line in this article. 

There are two different types of recordings, and you can have multiple recordings (of different types) running simultaneously:

1. Timed recordings 

These recording run for a pre-configured duration. They are automatically stopped when the time is up. If initiated from JMC, they will be automatically downloaded and opened in the user interface when done. 

2. Continuous recordings 

These recordings have no explicit end time and must be dumped by the end user. 

Now there are three different ways you can do actual recordings, once the parameters are in place:

1. From Mission Control. This is probably the easiest way. Just point and click. 

2. From jcmd. This is a very useful way to control the Flight Recorder from the command line. Quite useful when you can’t access the machine that is running the JVM of interest from Mission Control and you only have access to a shell. 

3. Using command line flags. This is handy when you want to always run with a continuous recording, or when you want to record the start up behaviour of the JVM right from the very start. 

If you want to know more about how to create Flight Recordings, this blog entry is probably a good place to start. 


Analyzing Flight Recordings

There is a lot of useful information in the flight recordings, and there are a lot of different things the information can be used for. For example:

Method profiling. The Flight Recorder will quite happily do method profiling in production systems with a very low overhead. As a matter of fact, it’s even enabled in the continuous template, so go ahead and use it. It will tell you where the hotspots are in your application. In other words, if you have a CPU bound problem, the method profiling information will tell you where to optimize to get things to go faster. 

GC profiling. The GC implementations emit useful events at GC related activity. Information that can be used to check on the live set, semi-refs, GC pauses (and their individual sub-phases) etc. Quite useful for GC tuning, finding out if you’re overusing finalizers and more. 

Allocation profiling. If you do notice a lot of garbage collections, but don’t notice anything strange about the individual GC phases, you may want to kick back a bit on the allocation. Allocation profiling will help you see where all that allocation activity is putting it’s toll on the memory system. 

WebLogic Server analysis. WebLogic is producing its own set of events for the Flight Recorder. They are quite useful in their own right, but can also be good for putting all the other information recorded in a context - “What was really happening during this transaction?”. This article on the Operative Set shows some of the capabilities. 

Latency Profiling. The Flight Recorder has a lot of different events for various thread stalling activities that can occur, such as blocking on monitor enter, parking, waiting etc. I can’t believe I haven’t written a blog post on this yet. Shame on me. This is usually the first place to look if you haven’t got a CPU bound problem, but still performance issues. 

OS information. CPU load, JVM CPU load, environment variables, running processes – there is a lot of operating system information. If you still can’t find what you’re looking for, Mission Control has a D-Trace plug-in for retrieving everything you ever wanted to know, but were too afraid to ask. Note that the overhead from using D-Trace, even with very few probes, is usually more than an order of magnitude worse than just using the Flight Recorder – use with caution. 

There is much more information available from the event providers built into the JVM, such as class loading and compiler events. One way to learn more details about what is available is to take a closer look at the metadata from a recording.

Summary

Since JDK 7u40 there is a new tools suite bundled with the JDK – Java Mission Control. The main focus of the suite is on production time profiling and diagnostics. This has the benefit that the data gathered is quite true to the dynamics of the application being profiled, as the observer effect is kept quite low. In other words, instead of profiling the profiler itself, most of the time is actually spent profiling the application and the runtime. Whilst the main focus of Mission Control is production systems, it can be quite useful in development too. It is also free for use in development, as per the standard Oracle Binary Code License (BCL).

This article provided a brief introduction to Java Mission Control.

Further Information

Java Mission Control Homepage

My Blog

@javamissionctrl;  @hirt


Tuesday Nov 12, 2013

Don't Miss Out at Devoxx!!!

Come by IoT Hack Fest which starts with the session: kickstart your Raspberry Pi and/or Leap Motion project, part II on Tuesday from 9:30am to 12:00pm to learn how to start a project with the Raspberry Pi and Leap Motion. In the afternoon, you can still join a project and create your own project with the help of experts on Raspberry Pi, Leap Motion and other boards. 

At the Oracle booth, Java experts will be available  to answer your  questions and demo the new features of the Java Platform, including Java Embedded, JavaFX, Java SE and Java EE. This year, the chess game that was first demoed at JavaOne keynotes last September will be showcased at Devoxx. 

Duke is coming to Devoxx this year. You can get your picture taken with Duke on Tuesday, Wednesday and Thursday (Nov. 12-14) from 12:00 to 18:00

Beer bash will be Tuesday from 17:30-19:30 and Wednesday/Thursday from 18:00 to 20:00 at the booth. Oracle is raffling off five Raspberry Pi's and a number of books every day. Make sure to stop by and get your badge scanned to enter the raffle. Raffles are Tuesday at 19:15 and Wednesday/Thursday at 19:45 at the Oracle booth. 

The main conference sessions from Oracle Java experts are: 
Wednesday 13 November
Beyond Beauty: JavaFX, Parallax, Touch, Raspberry Pi, Gyroscopes, and Much More
Angela Caicedo, Senior Member, Technical Staff, Oracle Room 7, 12:00–13:00
Lambda: A Peek Under the Hood, Brian Goetz, Software Architect, Oracle Room 8, 12:00–13:00
In Full Flow: Java 8 Lambdas in the Stream, Paul Sandoz, Software Developer, Oracle Room 8, 14:00–15:00
The Modular Java Platform and Project Jigsaw, Mark Reinhold, Chief Architect, Java Platform Group, Oracle, Room 8, 15:10–16:10
The Curious Case of JavaScript on the JVM, Attila Szegedi, Principal Member, Technical Staff, Oracle, Room 5, 16:40–17:40
Is It a Car? Is It a Computer? No, It’s a Raspberry Pi JavaFX Informatics System.
Simon Ritter, Principal Technology Evangelist, Oracle Room 7, 16:40–17:40

Thursday 14 November
Java EE 7: What’s New in the Java EE Platform Linda DeMichiel, Consulting Member, Technical Staff, Oracle, Room 8, 10:50–11:50
Java Microbenchmark Harness: The Lesser of the Two Evils, Aleksey Shipilev, Principal Member, Technical Staff, Oracle. Room 6, 14:00–15:00
Practical Restful Persistence, Shaun Smith, Senior Principal Product Manager, Oracle Room 8, 17:50–18:50

Friday 15 November
Avatar.js, Server-Side JavaScript on the Java Platform, Jean-Francois Denise, Software Developer, Oracle Room 8, 11:50–12:50

Tuesday Oct 01, 2013

At the Java Demogrounds: What’s Happening with Java SE?

Over at the Java SE demo booth, Oracle’s Aurelio Garcia-Ribeyro, Senior Group Product Manager, briefly discussed JDK 7 and  JDK 8.

“People may not realize that we’ve recently added new functionality to JDK 7,” he said. “So with JDK 7 u40, we added Mission Control and Flight Recorder to the JDK, something we're very proud of. Flight recorder is a feature that works a little like the flight recorder on a plane; you leave it on and it doesn’t really impact your production. It simply runs, and if you encounter an issue, you can go back and discover what triggered it after the fact. It’s quite useful in debugging horrible problems that occur only in production that you cannot really catch when you’re developing because you need it to be going for 15 days with a slow memory leak, but you don’t want to have to reproduce that because it’s costly and you don’t know when it happens. With flight recorder you just leave it on, set a trigger, and when something goes bad, it helps you figure out what triggered that event.”

I asked him about Java SE 8, which is scheduled for release in March of 2014.

“If you want to play with it, go to https://jdk8.java.net/ and download the developer preview. We’d like you to first try your existing projects, which should work just fine. Then after that, you should start playing with the new features like lambda and JSR 310, the Date and Time API. Lambda is the biggest change to the developer programming model. We are very excited about this.”

Thursday Sep 26, 2013

Session Report: 50 New Features of Java EE 7 in 50 minutes

 by Timothy Beneke

On Tuesday afternoon, noted Java EE authors Arun Gupta and Antonio Goncalves offered a whirlwind tour of new features in “Java EE 7: Fifty New Features of Java EE 7 in 50 Minutes”. Gupta is legendary at Oracle for his hard work and astute grasp of the Java EE platform. His blog offers a wealth of insight into Java EE and other Java matters. He is the author, most recently, of Java EE 7 Essentials published by O’Reilly. Goncalves is one of the most highly regarded writers on EE anywhere and the author of Beginning Java EE 7, published by Apress.

Java EE 7’s new features enhance HTML5 support, increase developer productivity, and further improve how enterprise demands can be met. Developers will write significantly less boilerplate code, have better support for the latest Web applications, and gain access to enhanced scalability and richer, simpler functionality. The session did a stellar job of spelling out the details to a packed house.

With four new components (WebSocket, JSON-P, batch, and concurrency), and three old ones significantly updated (JAX-RS, JMS, and EL), along with other significant changes to the platform, a lot of new functionality has been added.

They divided the new Java EE 7 features into 19 categories and explained an average of two to three features in each category.  Here were the categories:

CDI 1.1 (JSR 346)
Bean Validation 1.1 (JSR 349)
Interceptors 1.2 (JSR 318)
Concurrency utilities 1.0 (JSR 236)
JPA 2.1 (JSR 338)
JTA 1.2 (JSR 907)
EJB 3.2 (JSR 345)
JMS 2.0 (JSR 343)
Servlet 3.1 (JSR 340)
Web Socket 1.0 (JSR 356)
Expression Language 3.0 (JSR 341)
JSF 2.2 (JSR 344)
JAX-RS 2.0 (JSR 339)
JSON-P 1.0 (JSR 353)
Batch 1.0 (JSR 352)
JavaMail 1.5 (JSR 919)
JCA 1.7 (JSR 322)
Java Connector Architecture
Default Resources

Here are just a few of the high points:

CDI 1.1 (JSR 346) enables finer scanning control and the ability to veto the processing of a class or package. Bean Validation 1.1 (JSR 349) allows for method validation and the ability to pre/post conditions on method and constructors. Interceptors 1.2 (JSR 318) focused on the ability to associate an Interceptor associated with a constructor and the ability to prioritize interceptor bindings.

For Concurrency utilities 1.0 (JSR 236), the emphasis was on ManagedExecutor with a focus on:
* User threads in Java EE applications
* The ability to support simple and advance concurrency design patterns
* And to extend Concurrency Utilities API from Java SE (JSR 166y)

Further emphasis in concurrency was on ManagedThreadFactory and DynamicProxy.

Dynamic Proxy:
* Creates dynamic proxy objects, and adds contextual information available for applications running in Java EE environment
* It supports Classloading, JNDI, Security, …

Also covered as part of concurrency: ManagedExecutor
* User threads in Java EE applications
* Support simple and advance concurrency design patterns
* Extend Concurrency Utilities API from Java SE (JSR 166y)
– java.util.concurrent package

In addition: ManagedScheduledExecutor
* Managed version of ScheduledExecutorService
* Submit delayed or periodic tasks

For JPA 2.1 (JSR 338), standardized database schema generation and the ability to define additional indexes in schema generation were emphasized. JTA 1.2 (JSR 907) was praised for its capacity for transaction management on Managed Beans as a CDI interceptor binding; in addition, it offers CDI scope whose lifecycle is scoped to the currently active JTA transaction.

They discussed WebSocket and annotated server endpoint which enables full-duplex bi-directional communication over a single TCP connection.

JSON Builder creates an object model (or an array) in memory by adding elements. JsonParser is an event-based parser that can read JSON data from a stream.

All in all, it was an impressive display of Java SE 7 expertise.

Java EE 7 Essentials by Arun Gupta

Beginning Java EE 7 by Antonio Goncalves

Be sure to check out Parleys.com in early October to listen to the entire session. It's well worth it.

Tuesday Sep 24, 2013

Session Report: JSR 341: Expression Language 3.0

Ed Burns, Consulting Member of Technical Staff, and Kinman Chung, Principle Member of Technical Staff, both at Oracle, presented a session on Monday in which they described new features in JSR 341, Expression Language (EL) 3.0. They discussed the APIs for the use of EL in standalone environments and EL syntax for new operators, plus lambda expressions, and support for collection objects, all the while offering copious code illustrations.

Burns remarked that he was pleased that Java Champion and JavaOne Rock Star Adam Bien had referred to EL 3.0 as “the hidden gem of Java EE”. “I don’t know how hidden it is,” said Burns, “but I think it’s a gem.”

He discussed the origins of EL, which has a long and active history in the Java platform. EL began in 2004 as part of the Java Standard Tag Library (JSTL 1.0), moved to JSP 2.0 in 2006, and became an independent specification with JSR 341 in 2011. It is used in JSF, CDI, and Avatar. Now, 9 years after its inception, it is an independent specification that is heavily used in JSF.   

Burns observed that the presence of EL is the key differentiator between Java server and non-java server stacks. “Java server-based web frameworks are likely to use EL,” said Burns. “When you show someone who is not familiar with EL how easy it is to move things together from disparate parts of your application, it’s very compelling.”

The most important feature that EL 3 brings is lambda expressions – developers do not have to wait until Java SE 8 is released. It all runs on Java EE 7, which requires Java SE 7 -- which means that it is currently available. Burns gave a brief discussion of lambda expressions, which basically behave like an anonymous function -- lambdas in EL are EL expressions. They offer full access to the EL environment within the body of the EL lambda expression, something not available from Java SE lambdas. “You won’t be able to refer to other EL things from a plain old SE lambda expression,” said Burns.

The goal of EL 3 is to provide greater expressive power for applications and to use it outside of Java EE. Burns and Chung provided an overview of collection operations and explained EL’s support for stand-alone environments. EL 3 is easy to use outside of Java EE and provides standard data structures: ELContext; ELResolvers; and local variable and function repositories.

They explained that it enables direct EL operations and has: EL expression evaluation; Bean definition; and Function definition. They emphasized that other key parts of Java EE can also be used standalone, such as: Bean Validation; Persistence (JPA); and Contexts and Dependency Injection (CDI). They encouraged developers to consider the possibilities for cloud deployment in: Defining functions and variables and defining beans.

They spent the rest of the session illustrating their key points with a healthy dose of code.

Links and Downloads:
* JSR 341: http://www.jcp.org/en/jsr/detail?id=341
    Download spec and API javadocs

* Project home: https://java.net/projects/el-spec/
   Report spec bugs or RFE for el.next

* RI: https://java.net/projects/uel/
   Maven artifacts available from Maven Central
   Download source and report RI bugs

* Integrated in Glassfish 4.0: https://glassfish.java.net/

You can listen to this session in early October on Parleys.com.

Tuesday Sep 17, 2013

A Conversation with Java Champion Johan Vos

A new interview is now up on otn/java. In it, Johan Vos, a highly regarded Java Champion whose focus is on combining the strengths of back-end systems and embedded devices, provides his insightful take on what’s happening in the world of Java technology. His favorite technologies are currently Java EE/Glassfish at the backend and JavaFX at the front-end. He is a co-author of Pro JavaFX 2, and will be offering two sessions at JavaOne 2013.  

In the interview, Vos summarizes his sessions:

“In ‘Building Social Software on Top of Java EE 7 with DaliCore,’ I’ll show how you can integrate social software functionality into Java EE 7 applications. Many enterprise applications can benefit from some kinds of integration with e.g., Facebook, LinkedIn, Twitter, etc., without jeopardizing the user’s privacy and without giving up ownership of the data. The DaliCore framework adds the concept of User and OnlineAccount to the Java EE world, and provides the coupling with existing social networks. This saves lots of project-specific boilerplate code. This approach works both in web-applications as well as in desktop applications.

In ‘DataFX: The Best Way to Get Real-World Data into Your JavaFX Application,’ Hendrik Ebbers and I will present DataFX 2, a framework that helps JavaFX developers to populate JavaFX controls with real-world data. Now that JavaFX is beyond the stage of demos and POCs, it becomes important that the fake data used in demos be replaced with real data, often coming from back-end servers and databases. Apart from the regular cases where a JDBC source or a RESTful web service is queried, we will also show how changes in the local data can be propagated to the backend again...”

In discussing his efforts to combine Java EE and JavaFX, Vos remarks: “I am convinced that these two technologies are complementary, and while they are completely decoupled, the combination of them can lead to great end-to-end projects. As a POC, and in order to get more realistic use cases that could benefit both DaliCore and DataFX, I started to write a JavaFX application that offers community functionality. The front-end of that application is written in JavaFX, and the back-end is using DaliCore on top of Java EE 7. In this application, lots of data is sent from and to the back-end.”

In addition, Vos discusses his experiences with Java EE 7 and Java SE 8, the revolution that lambda expressions bring to Java, the client aspect of Java, how JavaFX fits into Java SE 8, and much more.

Check out the interview here.

Friday Sep 13, 2013

Josh Juneau – Learning More at JavaOne

Jython expert Josh Juneau on Java development today.[Read More]

Simon Ritter Prepares to Show off Java SE 8 at JavaOne

Oracle’s Simon Ritter has more tricks up his sleeve with cars and hand-tracking devices.[Read More]

Friday Sep 06, 2013

Java Champion/Rock Star Adam Bien at JavaOne 2013

Java Champions are developers who have made important contributions to the Java community; JavaOne Rock Stars are developers who have given highly rated sessions at JavaOne. Adam Bien is both – and one of the most distinguished Java developers in the community. He is an Expert Group member for the Java EE 6/7, EJB 3.X, JAX-RS and JPA 2.X JSRs and is an architect and developer for Java SE and Java EE projects. He has edited several books about JavaFX, J2EE, and Java EE, and is the author of Real World Java EE Patterns—Rethinking Best Practices, and Real World Java EE Night Hacks.

Bien is a Top Java Ambassador 2012, and JavaOne 2009, 2011, 2012 Rock Star. If all this were not enough, he was, in 2010, named Oracle Magazine’s Java Developer of the Year.

His 2013 sessions include:

CON2196: “Lean and Opinionated Java EE 7 Applications”
CON2229: “Architecting Enterprise JavaFX 8 Applications”
CON2230:  “Unit Tests Don’t Break: Stress-Testing Java EE Applications”
CON2231: “Demystifying Java EE”
UGF10369: “Cool NetBeans Tips and Tricks for Java EE 7 Development”

Q: Tell us about your JavaOne sessions.

Bien: In “Cool NetBeans Tips and Tricks for Java EE 7 Development,” I will introduce my favorite NetBeans features. I think I may surprise some attendees with NetBean's productivity and effectiveness.

In “Architecting Enterprise JavaFX 8 Applications,” I would like to introduce a Model View Presenter Architecture with Dependency Injection based on a "framework," only containing two classes. I would also like to highlight the interaction with SceneBuilder, the JavaFX WYSIWYG editor, without being too heavily dependent on it.

In the session "Demystifying Java EE," I will discuss some recurring misconceptions about the concepts and inner workings of Java EE. There is no magic in Java EE – Java EE 7 is very effective, if you follow some rules.

In “Lean and Opinionated Java EE 7 Applications,” I will introduce opinionated approaches and best practices for the design and implementation of Java EE 7 applications. I'm probably going to shock some architects, but the developers should like this session.

In “Unit Tests Don’t Break: Stress-Testing Java EE Applications,” I plan to stress test a Java EE 7 application and monitor the results in real time. Stress testing is incredibly important and sometimes not even a part of the development cycle.

Q: In addition to your sessions, what do you have planned for JavaOne?

Bien: JavaOne is one of the few conferences where I attend other sessions -- from dawn to dusk. In recent years there was not always time to pick lunch. At NetBeans/GlassFish days before JavaOne I will probably meet some Java friends, while at the actual JavaOne I’ve never managed to do that. The technical content is too good and there is not enough time between the sessions.

Q: Tell us about what’s happening with Enterprise JavaFX 8 apps.

Bien: In the recent edition of airhacks.com I started with HTML 5, but most of the attendees waited for Java FX 8 news. There are a lot of Swing applications out there. Migration from Swing to JavaFX is one of the FAQs. Also JavaFX is "just" Java. You can develop now from the User Interface to the back end using the same language, tools, and environments. You can use the same debugger, profiler or memory analyzer for all of your application tiers and layers. JavaFX suits perfectly enterprise application needs.

Q: What have you been working on lately?

Bien: I’ve helped my customers implement Java EE 7 and JavaFX applications. Also, I ported lightfish.adam-bien.com to Java EE 7 and GlassFish v4 and was even able to simplify the code. I also ported Apache FTP Mina to JavaEE7: http://e2ftp.adam-bien.com

Q: What are your expectations for Java EE 7? For Java SE 8?

Bien: I was already very happy with Java EE 6, so Java EE 7 can only exceed my expectations. I'm using daily builds of JavaFX coming with JDK 1.8 for my "leisure" activities. Here I would expect more stability and even better performance. 

Q: How do you assess the state of Java today?

Bien: Java is more interesting for building apps, than ever. And the interest is huge. This year there is an increased tendency to sell out workshops, sessions and conferences. Java 8 together with Java EE 7 and JavaFX 8 will make it even more interesting.

Java has only one problem: its age. We tend to forget how performant, scalable, ubiquitous, and "cutting edge" the Java ecosystem actually is.

Q: What should Java developers understand about unit testing?

Bien: Don't overdo it. Statistics do not matter. Test complex stuff first -- and there is no difference between writing tests for Java SE and Java EE applications

Q: Tell us about ways NetBeans can be used for Java EE 7 development?

A: With NetBeans I'm still able to surprise seasoned developers with productivity without any magic. As a contractor/freelancer I really don't like to spend any time with IDE maintenance and setup. With NetBeans I'm able to set up my full Java EE environment in about a minute on Linux, Windows or Mac. Without any plugins, configurations or restarts. For that reason, I'm using NetBeans daily builds without any friction. What I like the most: NetBeans supports me with integrated code completion, JavaDoc, hints and occasional helpers on demand (like, e.g., creation of beans.xml or persistence.xml) without excessive code generation or opaque wizards. You can achieve 80% with two shortcuts: ctrl + space and alt + enter.

Adam Bien’s Blog

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

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

Insider News from the Java Team at Oracle!

duke
javeone logo
Links


Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
2
5
6
7
12
13
17
18
19
20
22
24
25
26
27
28
29
30
   
       
Today