Tools & Techniques

Tools & Techniques takes a look at the proliferation of tools available to design and build high-quality applications. Get tips for building an effective set of tools and using those tools in the most productive manner possible.These sessions help you make choices between different tools and integrating those tools into a comprehensive development and build infrastructure.

Tools & Techniques sessions confirmed:

• Building Enterprise Mashups with iBeans
• Getting Things Done for Programmers
• Hunting Memory Leaks
• Just Tune It
• Performance Anti-patterns in Ajax Applications
• Push the Button – Improving the Current Practice of Continuous Integration
• Software Quality: The Quest for the Holy Grail?

Others you might be interested in:

• A Practical Guide to DSLs for the Java Developer
• GWT fu: Going Places with the Google Web Toolkit
• Streamline Web Application Development with JSF 2.0
• Testing Scripts and DSLs: A Practical Use of JSR-223
• Using Java Parallel Method Invocation to Accelerate Data Analysis on a Distributed Data Grid

---

Building Enterprise Mashups with iBeans

Ross Mason, CTO, MuleSource

Get grounded in Enterprise Mashups and how they apply to the enterprise. MuleSource co-founder, Ross Mason covers key mashup concepts and discusses a number of software patterns in this session.

Mashups break down traditional barriers around data and open up powerful new ways for enterprises to leverage the web as a platform. Mashups allow you to deliver real-time information from databases, desktop and departmental sources, and internal and external web sites. In this session you discover how to make the most of your IT investments and increase users’ speed to knowledge with enterprise mashups.

Max also describes ways in which enterprises can do more with their applications to empower their users. Go to this session for brass-tacks advice on the following:

• What enterprise mashups are (and are not);
• Key mashup patterns to apply;
• How these patterns relate to the enterprise;
• An introduction to iBeans;
• And more.

---

Getting Things Done for Programmers

Kito Mann, Author, JavaServer Faces in Action

If you talk to top developers, whether they’re people within your organization or internationally recognized experts, you’ll find something in common: they’re productive. Usually, it isn’t just dumb luck. More often than not, they’ve focused on becoming more productive.

There are dozens of methodologies that claim to increase productivity, but one stands out from the rest: Getting Things Done (GTD). "Getting Things Done®" is the groundbreaking work-life management system and book by productivity guru, David Allen. His process transforms personal overwhelm and overload problems into an integrated system of stress-free productivity. GTD describes a set of behaviors that reduce stress and help you become more productive at the same time. In this session you learn how to improve the productivity of your team by applying GDT principals.

Attend this session to learn:

• The core principals of Getting Things Done (GTD);
• How programmers, architects, and technical managers can apply GTD principles to improve the productivity of individuals and the group as a whole;
• Tools which can be used to successfully implement the GTD methodology;
• And more.

---

Just Tune it

Kirk Pepperdine, Java Performance Tuning Expert

What’s missing in your performance tuning practices? Find out in this session, as Java Performance Tuning expert Kirk Pepperdine introduces his tried-and-true performance tuning methodology. He demonstrates the process of tuning a Java application to get consistent, reliable and effective application. Discover how to be more methodical when tuning performance, and gain the skills you need to fix the root causes of poor performance in your applications.

Attend to gain a firm understanding of how to:

• Be methodical in performance tuning applications;
• Read key performance indicators;
• Develop more reliable and effective ways of performance tuning;
• And more.

---

Hunting Memory Leaks

Kirk Pepperdine, Java Performance Tuning Expert

In Hunting Memory Leaks, Java performance tuning expert, Kirk Pepperdine shows you how to bring JVM memory management to the next level.

Java has improved memory issues in many ways, but better memory leak detection is still needed. Memory leaks create latency, degrade performance, and put developers in a bad light. Memory leaks have proved to be something of a moving target, and they can become an unwelcome burden for overworked developers ready to push an app out the door. New techniques and new tooling help developers that need to quickly and successfully tune apps.

Kirk's session focuses on proven techniques for finding the source of memory leaks in Java applications. He presents real-life examples that show you how to build distributed, server-based Java applications that perform up to their potential.

He presents a brief overview of Java memory management, causes of memory leaks, and proven solutions for quickly and reliably finding them with the NetBeans Platform profiler and VisualVM.

Attend and discover:

• How memory management works in the JVM;
• Where and when memory management breaks down;
• How to use tools to find and fix the causes of the memory issues;
• And more.

---

Performance Anti-patterns in Ajax Applications

Andreas Grabner, Technology Strategist, dynaTrace Software

Ajax development veteran Andreas Grabner walks you through some real-life examples of Ajax anti-patterns and shows how to solve them in this session.

Leveraging the browser as an application platform has many benefits, including enhanced user experience with Ajax. Yet Ajax applications can run into many performance problems: Heavy and incorrect usage of frameworks, too chatty with the web server via XmlHttpRequests, slow JavaScript implementations that result in bad end-user experience, memory leaks, and more.

Take advantage of Grabner’s years of experience as he points out common mistakes and covers such problematic situations as:

• Too much data requested from the server;
• Too much interactivity options for the end-user;
• Underestimated Network Latency;
• And more.

---

Push the Button – Improving the Current Practice of Continuous Integration

Jason Whaley, Independent Consultant

Jason Whaley shows you what you can be doing today to improve Continuous Integration (CI) in your organization within both the Java ecosystem and beyond.

Continuous Integration (CI) isn’t anything new in the world of software development - you and your team of developers probably already implement some, if not all, of the CI guidelines. In this session, find out if you’re using CI practices effectively and taking full advantage of all available tools to improve processes around building, integrating, and deploying software today.

Whaley discusses how to adjust tools and process strategies as new technologies and methodologies emerge. Then, he shows what development teams should be doing today to improve CI usage and remain competitive.

This session demonstrates:

• What it takes to introduce, and maintain a process around Continuous Integration in your team and organization;
• What to do to improve your existing implementation of Continuous Integration on your team today;
• How Continuous Integration can both improve and benefit from recent trends like Cloud Computing and Polyglot Programming;
• What tools that aid Continuous Integration are at your disposal and how to effectively use these tools.

---

Software Quality: The Quest for the Holy Grail?

Jesper Pedersen, Lead Developer, JBoss Tattletale project

Follow expert Jesper Pedersen as he demonstrates how to list basic requirements for your build, test dependency environments and improve the quality of your projects.

As Java projects evolve they become more complex to manage. Getting a complete overview can be a painful task, especially if proper metadata about dependencies isn't available. This session is packed with real-world examples for being more productive on the job when faced with complex Java projects.

Based on his experience, Pedersen shares tools to use in specific environments and proven tips for keeping track of your dependencies and their dependencies. Gain a solid understanding of the tools available to increase productivity and keep your edge over time.

Topics covered in-depth include:

• Software quality: Friend or Foe?
• Defining the baseline
• Getting it right from the start
  - Build environment
  - Test environment
  - Dependency environment
• Is your project already a mess?
  - What can you do?
• Maintaining the lead.