IBM@JavaOne 2012, Part 2: Roundup of the IBM sessions

Find out what happened at the IBM sessions at JavaOne 2012, September 30 - October 4, 2012

IBM was active throughout JavaOne 2012, leading numerous technical talks and birds-of-a-feather (BOF) sessions, participating in panels, and delivering an opening-day keynote. This article summarizes IBM's contributions to the conference. Read synopses of the IBM sessions you missed, and view the video or presentation slides for many of them.

Share:

Will Smith (will.smith@uk.ibm.com), Java Support Engineer, IBM

Will Smith has worked in the IBM Java Technology Center since 2001 and has developed and maintained install code, globalization features, the graphics and font Java libraries, and the Java runtime monitoring and diagnostics tools. For the last two years, he has been a member of the customer support team for Java.



Chris Bailey (baileyc@uk.ibm.com), Java Service Architect, IBM

Chris BaileyChris Bailey is a member of the IBM Java Technology Center team at the Hursley Park Development Lab in the United Kingdom. As the technical architect for the IBM Java service and support organization, he is responsible for enabling users of the IBM SDK for Java to deliver successful application deployments. Chris is also involved in gathering and assessing new requirements, delivering new debugging capabilities and tools, making improvements in documentation, and improving the quality of the IBM SDK for Java.


developerWorks Professional author
        level

18 December 2012

Also available in Chinese

Approximately 3,500 Java™ enthusiasts and stakeholders attended this year's JavaOne conference. Amongst the crowd was a noticeable presence from IBM in the form of 14 speakers presenting 21 sessions, sponsorship of the Taylor Street Buzz Cafe, and a booth at the exhibition centre. This article summarizes the IBM sessions for the benefit of the many Java developers who couldn't make the trip to San Francisco — and for those who did but couldn't attend all sessions of interest.

Sunday, September 30: Opening keynotes

Sunday's opening keynote session — presented jointly by Oracle and IBM — took place at the Masonic Auditorium, a different venue from the rest of the conference. The session included guest speakers, among them Dr. Bob Ballard from National Geographic, who talked about his undersea-exploration remote mission-control system and discovering the wreck of the Titanic.

In addition to roadmaps for the Java ME, SE, and EE releases, the Java technology themes from Oracle were: dynamic languages on the JVM, including Project Nashorn (a JavaScript implementation that runs on the JVM); Java on embedded devices; and Java FX, the latest generation of the Java UI. A number of sessions throughout the entire conference were dedicated to these four topics.

The IBM segment of the keynote was presented by two IBM Distinguished Engineers: Jason McGee, Chief Architect for a number of IBM cloud technologies (including IBM PureApplication™ System, IBM Workload Deployer, and WebSphere® Cloud Computing); and John Duimovich, IBM Chief Technology Officer for Java. McGee, speaking first, tackled Java and cloud challenges, discussing virtualization, high density, and simplicity of deployment. IBM's development efforts are driving high density and multitenancy. McGee gave an introduction to patterns of expertise — the basis that IBM clients use to specify their workload deployments in IBM PureApplication System, IBM Workload Deployer, or IBM Smart Cloud Application Services.

Duimovich then described some of the innovative technologies that are advancing the performance and capability of IBM's Java platforms. Duimovich started with data sharing between JVMs via the shared-class cache for class data and Just-In-Time (JIT) compiled code, then moved on to multitenancy. Multitenancy exploits the growing number of processor cores available in modern servers to run multiple applications, isolated from one another but within a single JVM. This helps to optimise workload deployment, start-up time, and memory footprint in a cloud system. Another way to deploy and start an application more quickly is simply to use less library and middleware infrastructure — the direction taken by WebSphere's Liberty profile (see Resources). Liberty is a lightweight runtime that provides standards-based modularity for the cloud. It supports dynamic behaviour for memory and processor reallocation in virtualized environments.

IBM's efforts to support modern workloads are also demonstrated by our Java and System z (mainframe) integration. Java 7 for System z includes hardware transaction memory (HTM), which enables better concurrency for multithreaded applications. This matters because it can run your Java workload up to 45 percent faster!

As always, competition on performance benchmarks drives innovation at IBM. Duimovich was able to cite IBM's current leadership in industry benchmarks.

At this point, Jason McGee returned to describe IBM hardware innovation for Java. He outlined the need for Java to exploit new hardware whilst abstracting the platform for the developer. This is exactly what IBM Pure Systems' Expert Integrated Systems are designed for. In the software sphere, McGee singled out JVM support for multiple languages as a way Java enhances IT implementers' and designers' capabilities. McGee's closing thought on the future direction for Java was to expect more optimization for the cloud.

Watch the IBM JavaOne Keynote 2012 Highlights. (See Resources for a link to full video of the IBM keynote.)


Monday, October 1

Deploying Java Applications on the IBM PureApplication System (CON13533)

IBM PureApplication System

The IBM PureApplication System is a platform that is optimized for both traditional and cloud environments and utilizes IBM's unique Patterns of Expertise. You can read more about Java and Patterns of Expertise in "Deploying into the cloud with the IBM Application Pattern for Java."

Presenter: Jason McGee, Chief Architect for IBM PureApplication System

This session introduced the IBM PureApplication System, deployment patterns, and the virtual application pattern for J2EE. It covered maintenance and updates for virtual applications and the community that exists for developers to share extensions to existing patterns. Virtual system patterns are used to capture today's environments. The session included a demo of linking a Rational Application Developer pattern with a virtual application pattern. McGee explained how workload placement is intelligent: IBM PureApplication System deals with configuring high-availability nodes, resource balancing, and license management. Use of patterns is common across IBM Workload Deployer, IBM PureApplication System, and IBM Smart Cloud Application Services.

Take an IBM PureSystems™ Family Tour with Jason McGee:

Efficient Memory and Thread Management in Highly Parallel Applications (CON4641)

Presenter: Phillip Koza, Senior Software Engineer, IBM

The presentation discussed strategies for estimating and controlling the memory use of multithreaded Java applications. It presented a quick overview of how the JVM uses memory, followed by techniques for estimating the memory usage of various types of objects during testing. These estimates can be used as the basis for a runtime scheme for estimating and controlling the memory use of multiple threads. The final part of the presentation described how to implement robust handling for unchecked exceptions — especially out-of-memory errors — and how to ensure that threads stop properly when unexpected events occur.

View the presentation slides for this session.

Engaging the Enterprise (CON13535)

Presenter: Jerry Cuomo, IBM Fellow and WebSphere CTO

In this presentation, Jerry Cuomo talked about the Engaging Enterprise design pattern, showing how the enterprise can engage with its users — and be more engaging via the web. The session talked about today's "systems of record" and how the areas of mobile, social, analytics, and cloud can be used to create "systems of engagement" between enterprises and their customers.

Jerry Cuomo discusses the Engaging Enterprise design pattern in this Impact 2012 presentation:

What Is the Best Way to Embed Your Scripting Language in Java? (CON3978)

Presenter: Paul Thwaite, IBM Quality Assurance Engineer

Paul Thwaite discussed two ways to embed a scripting language on the JVM — a JSR 223 (Scripting for the Java Platform) implementation and a language-specific embed API — both of which are available for several popular languages. After the talk, it was interesting to hear that few attendees had used the JSR 223 alternative. Instead, they'd chosen their language and invested resources into adopting the language-specific embed API. The talk showed that the language-specific embed API gives the developer the ability to fine-tune the script engine and harness the power of the language's features. By contrast, a JSR 223 implementation can have limitations that might not be acceptable to developers who want to configure their environments.

View the presentation slides for this session.

JVM Support for Multitenant Applications (CON6465)

Presenter: Graeme Johnson, Cloud JVM Architect, IBM

This session started by introducing the concept of multitenancy, whereby a single instance of software runs on a server serving multiple client applications. It went on to show the advantages of having a multitenant JDK that lets multiple applications run in a single javad daemon JVM. The presentation also covered a number of the challenges facing multitenancy — including isolation and resource usage — and how those are being resolved in the IBM JDK using fine-grained tenant APIs and per-tenant resource quotas based on JSR 284 (Resource Consumption Management API).

View the presentation slides for this session.

OpenJDK Penrose Project (BOF10608)

Presenters: Tim Ellison, Senior Technical Staff Member, IBM; David Bosschaert, Principal Engineer, Red Hat

Project Penrose aims to demonstrate interoperability between two vital modularity systems for Java: Project Jigsaw and OSGi. The session started by going through the motivation for Penrose, describing the issues addressed by modularity, how Jigsaw and OSGi differ, and why interoperability between the two is important. Tim Ellison was joined by David Bosschaert from Red Hat, who spoke about the technical progress of Project Penrose and gave a demo of the technology.

View the presentation slides for this session.

OpenJDK: Java SDKs — Testing, Testing, Testing... (BOF4040)

Presenters: Steve Poole, Software Engineer, IBM; Paul Thwaite, IBM Quality Assurance Engineer; Alexandre Iline, Consulting Member of Technical Staff, Oracle

The quality of OpenJDK runtimes is an important topic for all users of Java. This BOF explored the tools, processes, and general approach used to ensure continuing high-quality products. Participants discussed the practicality of testing JDKs and the opportunities and challenges that face the OpenJDK community in measuring, maintaining, and improving quality. Topics ranged from test infrastructure, reporting, and related frameworks to developing new test suites and updating old ones. The whole Java community can get involved in testing OpenJDK deliveries and can help ensure that existing and future JDKs have the high quality we all expect.

Resource Management in Java: Tips, Traps, and Techniques (BOF6823)

Presenter: Neil Richards, IBM OpenJDK developer

This presentation introduced the types of resources that software needs to manage — for example, native resources such as file descriptors, network sockets, and database connections. It covered various mechanisms for managing those resources — including finalization, phantom references, and close() methods — with their associated traps and pitfalls. Some of these disadvantages can be avoided via the new "try with resources" approach introduced in Java SE 7. Richards then showed how both old and new approaches can be used in combination.

View the presentation slides for this session.


Tuesday, October 2

Rediscovering Your Architecture Through Software Archaeology (CON5134)

Presenter: Chris Bailey, Java Service Architect, IBM

This session started by discussing the software life cycle and legacy applications, setting the scene for why design documents for applications might not be up-to-date — or exist at all. The presentation went on to show how using runtime-analysis techniques can generate an understanding of an application and, potentially, generate design documentation retrospectively.

View the presentation slides for this session.

Real-World Compatibility and the Java Promise (CON5243)

Presenter: Tim Ellison, Senior Technical Staff Member, IBM

This well-attended presentation discussed the write once, run anywhere (WORA) goal of Java, the various aspects of compatibility (functional, source, and binary), and how Java and applications need to consider the impact of changes. The session then covered some examples of each of the compatibility issues and approaches to avoiding them. The talk included a mention of the WebSphere Application Server Migration Toolkit and how it helps identify issues when migrating applications.

View the presentation slides for this session.

Leveraging W3C Linked Data for Loosely Coupled Application Integrations (CON5213)

Presenter: Steve Speicher, Integration Architect, IBM

Speicher introduced the concept of linked data, as defined by Tim Berners-Lee: how applications can use web standards to build scalable applications that span a wide range of diverse technology backgrounds and data sources. He then described how the Open Services for Lifecycle Collaboration (OSLC) effort is defining standard RESTful service definitions for services such as software configuration, build and test automation, and requirements and work-item management services — and the standardization activity at the World Wide Web Consortium (W3C) based on this effort. Finally, the session covered various technologies that help in building linked-data applications with the Java API for RESTful Web Services (JAX-RS), annotations, Resource Description Framework (RDF), and more.

View the presentation slides for this session.

High-Speed Networks: Free Performance or New Bottleneck? (CON5270)

Presenter: Ryan Sciampacone, Senior Software Developer, IBM

This talk aimed to give attendees an understanding of the current state of high-speed networks in the context of Java development and to convey practical approaches to achieving great performance — including how to interpret results that initially don't make sense. The talk started with an overview of network advancements over the last 20 years, expectations moving forward, and why network speeds are approaching a significant tipping point. Considering network speeds and potential application bottlenecks can reveal optimization opportunities that show benefits even on slower networks. This evolved into an examination of InfiniBand (IB) mechanics and how existing protocols such as TCP/IP might not be suitable from a performance point of view. A review of throughput versus latency was also included.

The talk then examined two simple experiments that sought potential bottlenecks in systems at the network layer and the application layer, respectively. The first compared IP over IB (IPoIB), Sockets Direct Protocol (SDP), and Remote Direct Memory Access (RDMA). The comparison included trade-offs to consider when developing against them (familiarity versus new complexities and paradigms), as well as the occasional performance speed bumps that are encountered (such as the zero-copy threshold in SDP that stops copying transmission buffers). The second experiment looked at bottlenecks experienced in an existing application and how this affects network utilization. The issues included incorrectly optimized cache sizes used for data marshalling and transmission, an unbalanced ratio of client-server connections to application threads, and how garbage collection had interesting effects on throughput because of transmission buffer sizes. Although performed on an IB network, the resulting changes demonstrated benefit on Gigabit Ethernet networks as well.

View the presentation slides for this session.

Showdown at the JVM Corral (BOF6308)

Presenters: John Duimovich, Java CTO, IBM; Mikael Vidstedt, JVM Architect, Oracle; David Keenan, Consulting Member of Technical Staff, Oracle; Ryan Sciampacone, Senior Software Engineer, IBM

The "showdown" panel session was a lively and good-natured debate, as it has been in previous years. The panel covered a number of questions from the assembled audience.

The first question was about technologies for Java heaps larger than 100GB. Oracle and IBM have similar technologies in HotSpot's G1GC and J9's "balanced" collector, respectively. Dave Keenan talked about G1GC being supported as of Java 7 update 4, and being tested with heaps up to 3TB, whilst Ryan Sciampacone covered the usage of "balanced" inside IBM products in the 50- to 100GB range, and other IBM customer deployments using 500GB in the field.

The next question was about multitenancy in the JVM. Mikael Vidstedt talked about some research Oracle is doing on a solution with data sharing across virtual machines. John Duimovich responded that IBM already has data sharing of class and JIT data in the production JVMs, and that IBM is working on running multiple isolated applications inside a single JVM.

The session included an interactive discussion with the audience on standardization of command-line options and diagnostics, and how IBM and Oracle can work more closely together on making the same options and diagnostics available.

All Power to OpenJDK: Porting the JDK to PowerPC and AIX (BOF8203)

Presenters: Steve Poole, Software Engineer, IBM; Volker Simonis, OpenJDK Evangelist, SAP AG

This BOF session started with some history on the usage of Java on PowerPC by IBM and SAP. It then discussed how to start a porting project and some of the specific challenges encountered in porting HotSpot to a new architecture. Although the audience was fairly small, the attendees who were present were interested in the subject and indicated that they found it useful and informative.

View the presentation slides for this session.

OpenJDK and the Common VM Interface Project (BOF4034)

Presenters: Neil Richards, IBM OpenJDK developer; Andrew Hughes, Software Engineer, Red Hat; Mikael Vidstedt, JVM Architect, Oracle

This session covered the changes happening in the OpenJDK Common VM Interface (CVMI) project as the community members build on the original work of Andrew Hughes. With the major virtual-machine teams working together to document, clarify, and update the interface between the virtual machine and the class libraries, this BOF was an opportunity for everyone interested to meet some of the main participants and to learn more about the history as well as current and future changes. Extending the reach of this project to encompass more virtual-machine implementations is not a short-term exercise.


Wednesday, October 3

From Java Code to Java Heap: Understanding the Memory Usage of Your Application (CON5135)

Optimizing Java memory usage

Chris Bailey's talk on understanding and optimizing memory usage is based on his popular article "From Java code to Java heap," available right here on developerWorks.

Presenter: Chris Bailey, Java Service Architect, IBM

This session was delivered to a standing-room-only audience keen to gain a better understanding of the memory footprint of their Java applications and the steps they can take to optimize it. The presentation started with an overview of how Java uses memory and how much memory is used when a simple Integer object is created. The discussion then moved on to more-complex objects and in particular the Java collections objects, covering how memory can be wasted if you select the wrong collection, or mis-size it. The session concluded with an overview of how to detect memory inefficiencies using Memory Analyzer and some techniques for optimizing memory usage.

View the presentation slides for this session.

Innovative Testing Techniques with Bytecode Instrumentation (CON3961)

Presenter: Paul Thwaite, IBM Quality Assurance Engineer, IBM

This talk's objective was to show how bytecode instrumentation (BCI) can help developers force execution of hard-to-reach areas of their code. Most of the audience stayed for the post-talk Q&A, clearly excited as they started thinking about how BCI techniques could help them in their environments. They could see the benefit of modifying their code on the fly using BCI and the ASM bytecode-manipulation framework without needing to physically change their code.

View the presentation slides for this session.

Security in the Real World (CON7755)

Presenter: Ryan Sciampacone, Senior Software Developer, IBM

This talk covered some of the attack vectors that have been used recently in Java and the steps taken to address them. The talk began with an overview of the implicit and explicit levels of security that Java provides. Implicit coverage includes the Java sandboxing model (which provides security and restrictions to system resources when untrusted code is running), bytecode verification (which ensures that basic Java language protection mechanisms and bytecode rules are enforced), and class loaders (which provide a namespace mechanism that also prevents class file spoofing). Explicit coverage includes secure socket extensions, cryptography, and authentication and authorization facilities — all of which must be invoked by the application to be put into action.

The talk then looked at four recent attacks and their underlying mechanics to show how security can sometimes be complicated and what types of pitfalls the developers should be aware of when writing their own secure code:

  • The Hashing Denial-of-Service attack (CVE-2011-4858): An algorithmic-complexity attack was exploited. In this scenario, the String hash code specified, combined with worst-case performance of some hashing structures, make it possible for an attacker to reliably build parameter strings with identical hashcodes to pass to an application server. This results in long insertion or lookup times and pushes the server into an unresponsive state.
  • The Gondvv attack (CVE-2012-4681): A foreign Java applet could exploit a security hole in Java 7, which allowed it to execute anything on a client machine. A simple access-protection change (from private to public) caused a cascading effect that meant any applet run could circumvent the Java sandbox.
  • The invokespecial fix (CVE-2012-1725): This is a theoretical attack whereby code could bypass the constructor calls in a hierarchy when creating new objects, potentially ignoring important initialization code.
  • MethodHandle: This powerful and important aspect of JSR 292 (Supporting Dynamically Typed Languages on the Java Platform) provides a "function pointer" type of facility similar to reflection, but with important security implications that are not immediately obvious but differ significantly from reflected equivalents.

View the presentation slides for this session.

Java Batch for Cost-Optimized Business Efficiency (CON4105)

Presenter: Sridhar Sudarsan, Chief Architect, IBM Batch Strategy

Around 100 people interested in current and future work involving batch processing attended this session. The highly interactive Q&A segment reflected interest in JSR 352 (Batch Applications for the Java Platform), using WebSphere Batch in various scenarios, design discussions, and optimized development and performance of Java batch solutions using IBM WebSphere.

View the presentation slides for this session.

JavaEE.Next(): Java EE 7, 8, and Beyond (CON10656)

Presenters: Ian Robinson, IBM Distinguished Engineer; Mark Little, JBoss CTO; Scott Ferguson, Developer, Caucho Technology; Cameron Purdy, VP Development, Oracle

This panel session, moderated by Mike Keith from Oracle, gave the audience the opportunity to quiz representatives of several well-known implementations of the Java EE specification on their views about Java EE's current state and future direction.

The first questions were about HTML5. The panel discussed how it enables the client side to become richer — working with the data model rather than just being the rendering layer for information provided by the server — and how this can enable the server to become thinner.

Next up was a discussion about Java EE in the cloud as a Platform as a Service (PaaS) layer. The conversation started with the subject of cloud items being moved from the Java EE 7 specification to Java EE 8, and how it was felt that this was the right thing to do — both to make the Java EE7 deadline, and because a clear definition of what, if anything, needs to be specified at the EE level doesn't exist yet. Some members of the panel felt that there is a clear need for applications to be portable from one cloud to another, but that the metadata surrounding the application (how it is deployed and what resource and scaling requirements it has) might not need to be. Indeed, the deployment metadata is not really Java EE level application information.

The topic then changed to alternative languages: whether dynamic languages like PHP are more productive for the developer, and whether their rapid rise is leading Java to become a legacy platform. The response was that the JVM can run multiple languages, so there is likely to be a shift to an ecosystem in which Java and other languages will work together in the same applications. Mark Little referred to the need for Java to embrace the new languages.

The final set of questions covered smaller footprints and modularity for Java EE. Mark Little talked about the need for Java EE to be deployable into a larger range of devices, including embedded devices. Ian Robinson spoke about the good work done in JEE 6 to define the web profile but raised the issue that more needs to be done — having the options of a web profile or full Java EE profile is not enough, and that the platform as a whole needs to be more relaxed about dynamic combinations of JSRs dependent on what the application requires. The final part of the footprints discussion debated Jigsaw and whether it was really a requirement for Java EE, given that most application-server vendors are already making their products modular via technologies such as OSGi, and the long roadmap to Jigsaw arriving in Java EE 9 from Java SE 9.


Thursday, October 4

Practical Performance: Understand the Performance of Your Application (CON4012)

Presenter: Chris Bailey, Java Service Architect, IBM

Almost 400 people turned up for the last session on the last day of the conference to hear a practical guide on the steps to take to performance-tune an application deployment and what to expect in terms of performance gains at each stage. Bailey started the session by explaining the need to use a representative, repeatable benchmark when doing performance tuning and analysis. He then showed how to investigate each layer of an application — the hardware and operating system, the Java runtime, and the application itself — and how the benchmark for a sample application changes after a number of problems are fixed. The session in particular noted that gains from tuning the operating system and Java runtime are limited because they are highly tuned "out of the box," and that most gains come from improving the Java application.

View the presentation slides for this session.


IBM around JavaOne

In addition to participating in the keynote, technical, and BOF sessions, IBM was active elsewhere around the conference: sponsoring the Taylor Street Cafe, running IBM developerWorks and Rational Team Concert booths at the Exhibition Hall, talking to developers, and providing some interviews.

The IBM developerWorks booth at the exhibition hall displayed the IBM PureSystems Smart Cloud trial, Mobile zone with Worklight, and the Request For Enhancements (RFE) Community initiatives. Positioned next to them were the Rational Team Concert team, which was promoting its tools for Agile development. Check out Michael Chan's blog for photos and more discussion of IBM at the exhibition hall.

A number of IBM team members also gave video interviews. Chris Bailey and Ryan Sciampacone shared their impressions of the conference and talked about the sessions they were presenting, whilst Devin Bui, Diana Bitleris, and Rob Cuddy gave interviews and demos of the IBM PureSystems trial, IBM Worklight, and DevOps, respectively. You'll find these video interviews at the developerWorks video portal.

Resources

Learn

Get products and technologies

Discuss

  • Get involved in the developerWorks community. Connect with other developerWorks users while exploring the developer-driven blogs, forums, groups, and wikis.

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into Java technology on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Java technology
ArticleID=851499
ArticleTitle=IBM@JavaOne 2012, Part 2: Roundup of the IBM sessions
publish-date=12182012