Primary tab navigation

IBM is a repeating Diamond Sponsor of the JavaOne conference, which brings together Java experts and enthusiasts in an extraordinary week of learning and networking focused entirely on all things Java. IBM is also leading a large number of informative sessions at the conference, including:

Three Key Concepts for Understanding JSR 352: Batch Applications for the Java Platform
9/23/2013 11:30 AM JavaOne Session ID: CON7292

Batch may be the oldest application type in our industry and the most recent to be standardized for Java. Come to this session to learn the essentials of JSR 352: Batch Applications for the Java Platform. Find out the three key concepts every developer should know about. Leave this session equipped with an understanding of when and how to apply the batch application pattern to your business needs.

Secure Engineering Practices in Java
9/23/2013 03:00 PM JavaOne Session ID: CON3615

Developing programs that are inherently immune to attack requires sound software engineering practices. This session looks at the overall software engineering lifecycle and the critical points at which software security is a specific consideration. The presentation shows how using threat models, code pattern analysis tooling, targeted reviews, and more enhances Java security.

Debugging Native Heap OOM: Tools and Techniques
9/23/2013 04:30 PM JavaOne Session ID: BOF3663

Native out-of-memory errors happen when a Java application runs out of memory, not in the Java object heap but outside it. No single tool can give you all the answers, and we need to cross-reference information from multiple sources to isolate a problem. This session works through the tools and data available on the main server platforms to give you a repeatable framework for native out-of-memory error debug.

Bytecode Instrumentation for Beginners
9/23/2013 05:30 PM JavaOne Session ID: BOF5621

The range of tools available for the Java platform is one of its many strengths, and a surprising number of these tools rely on bytecode instrumentation (BCI) and bytecode generation to do their work. But BCI is a black art to most. This session aims to take away the mystery and show you what BCI is, how it is used, and how you can get started on writing your own BCI-based tooling.

Security in the Real World
9/23/2013 06:30 PM JaveOne Session ID: BOF4066

This session goes through the state of security in Java in 2013 and discusses some of the attack vectors. It presents a couple of real-world examples and also addresses the challenges in getting security fixes out quickly. It also touches on hardware cryptography. Come learn more about the reality of security today and take away a better awareness of exactly how Java helps protect you.

Ten Things You Should Know When Writing Good Unit Test Cases in Java
9/23/2013 06:30 PM JavaOne Session ID: BOF4255

In this session, learn 10 fundamental unit test principles of what makes a good unit test case and how to apply these unit test best practices in a testing strategy. Intermittent test case failures are expensive, so this session uncovers the pitfalls the unwary can encounter when designing, coding, and executing test cases.

Lightning-Fast Access to Big Data
9/23/2013 06:30 PM JavaOne Session ID: BOF5957

In-memory computing has eliminated the natural bottleneck of traditional data placed in storage and then, when needed, accessed and acted upon in memory. In this session, you will learn how in-memory data grids mark an inflection point for enterprise applications, especially in dealing with big data. The session covers how large data sets can be made available and can be accessed nearly instantaneously.

The Most Useful Tools for Debugging on Windows
9/23/2013 07:30 PM JavaOne Session ID: BOF4159

This presentation provides an introduction to the (subjectively) most useful tools for debugging on Windows.

Using Java to Build Java: Revealing the Power of Open Java Technologies
9/23/2013 08:30 PM JavaOne BOF4176

Learn how modern Java-based technologies are being harnessed by the OpenJDK community to create an open build and test infrastructure that is being used to build the Java runtime itself. Understand the technical, business, and personal challenges involved in creating a new type of “social” Website where developers from all walks of life can work together on their common passion: helping keep Java great.

Leveraging a W3C Linked Data Platform and OSLC for Loosely Coupled Integrations
9/24/2013 08:30 AM JavaOne Session ID: CON2492

Tim Berners-Lee, credited as the inventor of the internet, defined a concept of linked data (HTTP + RDF) that defines how applications can use Web standards to build scalable applications that span a wide range of technology backgrounds and datasources. This session provides the current state of linked data and an update on standardization activity at the World Wide Web Consortium (W3C).

Securing Java in the Server Room
9/24/2013 08:30 AM JavaOne Session ID: CON3636

You don’t need to worry about running your own code on your own servers, right? In fact, there are several vulnerability patterns that can affect server-side Java applications, and this presentation outlines some of the steps you should take to ensure that your server room is not compromised. It looks at the established techniques for enhancing your security and shows new technology from IBM that addresses several attack vectors.

Concierge: Bringing OSGi (Back) to Embedded Devices
9/24/2013 08:30 AM JavaOne Session ID: CON4576

Concierge strives to be a minimal-footprint implementation of the OSGi core standards targeting resource-constrained embedded devices. In this presentation, hear about the systems issues involved in downsizing and optimizing OSGi for embedded systems and see demonstrations of how Java and OSGi can be effectively used in this realm.

Garbage Collection Unleashed: Demystifying the Wizardry
9/24/2013 01:00 PM JavaOne Session ID: CON3948

Problems with garbage collection? This presentation aims to demystify some of the mechanics of garbage collection technologies by looking at a series of problems, mapping them back to the implementation in simple terms, and understanding what this means about the collection and your application and how to address the issue.

Implement a High-Level Parallel API in JDK
9/24/2013 01:00 PM JavaOne Session ID: CON4073

This session discusses how to implement a high-level parallel API (such as parallel_for, parallel_while, or parallel_scan) and math calculation based on a thread pool and task in OpenJDK that aligns with the development of multicores and parallel computing.

OpenJDK Porting Experiences: The Good, the Bad, and the Downright Ugly
9/24/2013 04:30 PM JavaOne Session ID: Session ID: BOF4132

The work to port OpenJDK to Linux PowerPC and AIX PowerPC is coming to an end. This session discusses the technical aspects of porting OpenJDK to a new architecture as well as the community and process challenges that have been addressed in making the project a success.

JPA Performance Myths
9/24/2013 05:30 PM JavaOne Session ID: BOF4454

Every few months, another Joe (or Jane) Shmoe decides it’s time to write an agenda-driven blog post that shows why a particular flavor of JPA blows all the other competitors out of the water. This session shows that, when properly used/tuned, the JPAs from the major providers (EclipseLink, Hibernate, and OpenJPA) all perform nearly the same.

Improving JMX to Perform Better and Become Cloud-Ready
9/24/2013 07:30 PM JavaOne Session ID: BOF5237

This session discusses what improvements are necessary next for the JMX layer to make it perform better and make it ready for the cloud.

Where Next with OpenJDK Community Build and Test?
9/25/2013 08:30 AM JavaOne Session ID: CON4179

In this panel session, learn about the work done so far to provide an open, community-accessible build and test system for developers who want to contribute to OpenJDK. It’s a hard problem, but progress is being made. Come hear the participants from various organizations talk about what is happening and what else is needed. A lively debate with many opinions: guaranteed!

Effective Foreign Function Interfaces: From JNI to JNR
9/25/2013 04:30 PM JavaOne Session ID: CON4767

What do you do when your application needs access to platform features that aren’t available in the Java platform? You need a foreign function interface (FFI). The Java Native Interface (JNI) is the classic power tool for calling native code from your Java program. This session explains the most common JNI performance and correctness pitfalls and explains how to find and avoid them.

How to Write Memory-Efficient Java Code
9/26/2013 02:00 PM JavaOne Session ID: CON5876

Garbage collection has largely removed the need to think about memory management when you write Java code, but there is still a benefit to understanding and minimizing the memory usage of your applications. This session gives you insight into the memory used as you write Java code and provides you with guidance on steps you can take to minimize your memory usage and write more-memory-efficient code.

Build Your Own Runtime Monitoring for the IBM JDK with the Health Center API
9/26/2013 03:30 PM JavaOne Session ID: CON5946

This session provides an overview of the new API in the recently released Health Center version 2.1 of the IBM JDK. It shows how to use it to create simple alerts based on the occurrence of defined conditions, and explores how it is being used by IBM to integrate the Health Center data into its own products.