Sessions

Google Web Toolkit (GWT) Internals, Tips and Tricks

Speaker : Allahbaksh Asadullah

This presentation would show how to use GWT compiler to generate JavaScript code that can be used in any non GWT JavaScript applications. Later, the presentation covers usage of JSNI [Java Script Native Interface] of GWT effectively to reduce JavaScript object creation in GWT applications. The session will then look at Dependency Injection by GIN and will show how to use GIN effectively along with some hidden tricks. Finally the talk will dwell on GWT Internals, like how GWT uses JDT and converts Java code into JavaScript etc.

Take Away for Audience: The audience will learn how to use GWT and GIN effectively during development. Also it helps audience to generate JavaScript code from Java for use in any web application. Knowing about internals of GWT will also help the audience to come up with new ideas and contribute to Open source projects.

Implementing Search Functionality With Lucene & Solr

Speaker :Allahbaksh Asadullah

Lucene is open source high performance index and search library. It is useful for all developers who are looking to implement search functionality in their applications. The talk will cover basics of Lucene and then take audience to different kinds of Analyzer, Tokenizer and QueryParser (Cutomization of Query Parser) etc. The talk will next look at the Solr Search server which is another open source robust and failsafe search server built on Lucene and REST api.

Java EE 6 : Paving The Path For The Future

Speaker : Arun Gupta

“The Java EE platform is getting an extreme makeover with the upcoming version ? Java EE 6. It is developed as JSR 316 under the Java Community Process.

The Java EE 6 platform adds more power to the platform and yet make it more flexible so that it can be adopted to different flavors of an application. It breaks the ‘one size fits all’ approach with Profiles and improves on the Java EE 5 developer productivity features. It enables extensibility by embracing open source libraries and frameworks such that they are treated as first class citizens of the platform.

Several new specifications such as Java Server Faces 2.0, Servlet 3.0, Java Persistence API 2.0, and Java Context Dependency Injection 1.0 are included in the platform. All these specifications are implemented in GlassFish v3 that providesa light-weight, modular, and extensible platform for your Web applications.

This session provides an overview of Java EE 6 and GlassFish v3. Using multiple simple-to-understand samples it explains the value proposition provided by Java EE 6. “

Dynamic Languages & Web Frameworks in GlassFish

Speaker : Arun Gupta

“Dynamic languages such as JRuby, Groovy, and Jython are increasingly playing an important role in the web these days. The associated frameworks such as Rails, Grails, and Django are gaining importance because of the agility provided by them.

The GlassFish project provides an easy-to-use and robust development and deployment platform for hosting these web applications. It also enables the various languages to leverage the investment in your existing Java Platform, Enterprise Edition (Java EE platform) infrastructure. This session gives an overview of various Dynamic Languages and associated Web frameworks that can be used on the GlassFish project.

It starts with a brief introduction to JRuby and details on how the GlassFish project provides a robust development and deployment platform for Rails, Merb, Sinatra and other similar applications without pain. As a basis for further discussion, this presentation shows the complete lifycycle for JRuby-on-Rails applications on GlassFish v2 and v3. It discusses the various development options provided by GlassFish v3, demonstrates how popular Rails applications can be easily deployed on GlassFish without any modification, and shows how v3 Gem can be used as an effective alternative to WEBrick and Mongrel. It also demonstrates debugging of Rails applications using NetBeans IDE. For enterprise users, it shows how JMX and other mechanisms can be used to monitor Rails applications.

It also talks in detail about the Groovy/Grails and Python/Django development and deployment models in context of GlassFish v3. By following the simple deployment steps the presentation shows, developers will be able to deploy their existing web applications on the GlassFish project.The session also describes the known limitations and workarounds for each of them.

The talk will show a working sample created in different frameworks and deployed on GlassFish v3. The demo will show how different features of the underlying GlassFish runtime are easily accessible to the frameworks running on top of it.”

Create Appealing Cross-device Applications for Mobile Devices with Java ME and LWUIT

Speaker : Biswajit Sarkar

Java ME allows us to write applications that are, generally speaking, portable across a wide range of small devices that support the platform. While the basic functionalities usually work well on all supported devices, the area that does pose problems for developers is the User Interface. Native implementations of javax.microedition.lcdui — the primary API for UIs in Java ME — differ so widely from one device to another that maintaining a device independent and uniform look-and-feel is virtually impossible. Another problem with the javax.microedition.lcdui package is that it does not support components and capabilities that can fully satisfy present day user expectations. The Lightweight UI Toolkit (LWUIT) is the solution to these problems. LWUIT offers a wide range of components with a device independent look-and-feel for building UIs. While some of these widgets are also available under lcdui, there are a number of new ones too and these additions enable application developers to design UIs that can come very close to their desktop counterparts in terms of visual sophistication. And LWUIT is not just about new components either. The API supports a whole range of new functionalities (like Theming and Transitions) too.

This session takes the audience through the structure of Java ME including the major optional APIs. The session also explores LWUIT describing the main components and functionalities.

This session is for developers who want to create applications that work on a wide range of mobile devices using Java ME and LWUIT. The session has been designed with the assumption that the audience is familiar with Java but not necessarily with Java ME. Some degree of familiarity with Swing would be useful.

Building RESTful applications using Spring MVC

Speaker :Kamal Govindraj

REST is an alternate and simpler approach for implementing WebServices. It is based on the HTTP protocol and hence leverages a lot of existing infrastructures. It uses an uniform interface thus making it easy to build client applications. In this session we will look at the fundamental concepts behind REST (Resource, URI, Stateless Conversation ..) and how to apply it in the context of a real applcation. We will also discuss the pros & cons of RESTful vs Soap based webservices. We will discuss the design of RESTful application and then look at how to implement it using Spring MVC.

Building modular applications

Speaker :Kamal Govindraj

For a moderately complex application to manage complexity it needs to be broken up into smaller modules – which can be developed / tested independently. The modularization should be based on the domain rather than along layers (dao/service etc). This session will focus on some guidelines on how to breakup large applications into modules and how to realize that modularity in an application that uses Spring, Hibernate, Maven. The talk is based on the experience gained implementing (and refining) these techniques in 3-4 large product development that I have been involved in.

Java web services using JAX-WS

Speaker : Lalit Bhatt

JAX-WS is the replacement and next generation to JAX-RPC and makes web services development much easier using annotations and much less configuration. JAX-WS is useful for people building webservices/SOA based infrastructure as JAX-WS makes the web service development much easier and is a big gain for developer productivity.

The session uses a web service for temperature conversion example to build both the client side and Server side artifacts. Also on the server side both Servlet based and EJB3.0 based web service development will be demonstrated. JAXB concepts will be used to demonstrate the examples.

The session uses Eclipse Ganymede and Jboss 5.0. However JAX-WS being the standard, the code will smoothly work on any JavaEE based compliant servers.

Getting started with Scala

Speaker : Mushtaq Ahmed

“Scala is a multi-paradigm programming language that has superb interoperability with Java and runs on the JVM. Scala combines Object Oriented Programming and Functional Programming paradigms rather elegantly. This enables Scala to have extremely concise syntax for both: programming-in-the-small as well as programming-in-the-large. In this session, we will go over fundamentals of Scala with examples to highlight its unique features like case classes and pattern matching, for comprehensions, traits, functions as values and others. We will also have a brief look at Scala’s support for writing internal as well as external DSLs.”

Developing, deploying and monitoring Java applications using Google App Engine

Speaker : Narinder Kumar

Google App Engine has added one more option in the ever growing list of virtualization and cloud computing possibilities available for Software developers. Apart from providing regular benefits of Virtualization and Cloud Computing, it also involves a significant shift in ways we have been used to developing, deploying and monitoring web applications. With Java support enabled, it has become a candidate for consideration while developing .

This session includes a presentation along with some demo applications and code walk-through.

Following is an overview of proposed agenda :

  1. Google App Engine Overview
  2. Deploying Hello World Application on Google App Engine
  3. Data Manipulation
  4. Google App Engine APIs
  5. Java Developers Toolkit
  6. Monitoring Deployed Applications
  7. Quota Policies
  8. Additional Features
  9. Current Limitations

Take Away for the Audience

  1. Awareness about an additional option for deployment and management of Web Applications
  2. Technical overview about Google App Engine and it’s API
  3. Java toolkit and IDE Support while using Google App Engine as platform
Experiences of Fully Distributed Scrum between San Francisco and Gurgaon

Speaker : Narinder Kumar

Scrum in general talks about small and co-located teams where members are all sitting in the same room and can easily participate in various design, development and project related discussions. Because of various reasons, lot of software development is currently being done from different geographical locations and at times the development teams are separated from each other by huge time-difference.

This presentation talks about my experience as a software developer in one of the projects where development was simultaneously being done from San Francisco, USA and Gurgaon, India. It explains about various challenges which came our way, our solutions to them and despite being separated by 12.5 hours time difference, how we were able to achieve close to co-located team’s velocity without adversely affecting team members working style on both sides.

Take-Away for the Audience

  1. How to set up a fully distributed team
  2. How to measure team performance – velocity and quality
  3. How to ensure local velocity is maintained when team distributes across time zones
  4. How to deal with cultural differences
How Android is different from other systems – An exploration of the design decisions in Android

Speaker : Navin Kabra

“Google’s Android is a brand new platform for mobile phones, and has been created from scratch specifically for this purpose. This means that it is a ‘modern’ system that does not suffer from any legacy issues, and has taken the best ideas from various other projects to build a system that is arguably better than any of the other, competing, systems. Thus, for example, it uses the Java language as the development language, but has rejected the rest of the Java ecosystem. Specifically it uses a completely new virtual machine (Dalvik) which is redesigned with mobiles in mind – and has a number of very interesting design decisions that we will discuss. Similarly, the Android application framework represents a departure from the traditional way of doing things, and has a learning curve, but once you get used to it, it is great, especially for allowing different apps to share data, code, and in general co-operate. We will explore and discuss this and various other design decisions in Android. This talk can serve as your introduction to “”What is Android”", and more importantly, “”Why is Android”"

Optimize Performance of I/O-intensive Java applications Using Zero Copy

Speaker : Pramod Nagaraja

This session explains how you can improve performance of I/O-intensive Java™ applications through a technique called zero copy. Zero copy lets you to avoid redundant data copies between intermediate buffers and reduces number of context switches between user and kernel space.

Background: Many applications [Web Servers, FTP-like services] serve a significant amount of static content, which amounts to reading data off of a disk and writing the exact data back to the response socket. Each time data traverses the user-kernel boundary; it must be copied, which consumes CPU cycles and memory bandwidth. Fortunately, we can eliminate these copies through a technique called — zero copy.

The Java class libraries support zero copy on Linux and UNIX systems through the transferTo() method in java.nio.channels.FileChannel.

Session Agenda: The session will initially focus on “Zero Copy” concept and its relevance in Data transfer applications. The traditional approach of transferring data b/w processes using File and Socket I/O will be explained in detail. It will demonstrate the overhead incurred when using traditional copy semantics, and will show how transferTo() achieves better performance. transferTo() API brings down the time 65% compared to traditional approach.

Summary
The Session demonstrates performance advantages of using transferTo() compared to the traditional approach. Intermediate buffer copies — even those hidden in the kernel — can have a measurable cost. In applications that do a great deal of copying of data between channels, zero-copy technique can offer a significant performance improvement.

Concurrency: Best Practices

Speaker : Pramod Nagaraja

Introduction: This session discusses simple guidelines that can help develop reliable and high performing parallelism friendly applications in Java. It introduces some of the best practices that can be adopted in Concurrent programming in Java. The session also briefly explains various techniques used by the Java Virtual Machine to optimize synchronization.

Background: Over the years, there has been significant amount of work to make Java support concurrency with less overhead. With the advent of multi-cores, Parallelism is very essential to increase the Application throughput. Parallelism introduces atomicity and visibility issues. From Java 5 onwards, significant improvements like java.util.concurrency, Latches, Barriers are introduced to support Concurrency.

Considerable improvements have also been done at the Virtual Machine level to optimize synchronizations.

Session Agenda: The Session focuses on the “What?Why?How? of Concurrency” in java. It briefly describes the synchronizing features available in Java. A common set of pitfalls faced in Concurrent programming and methods to over come these pitfalls are also introduced. Usage of concurrent collections, Latches and Barriers is demonstrated. Much attention has been given to optimize lock management and synchronization in Java virtual machine. Features like biased locking, lock coarsening, lock elision by escape analysis and adaptive spin locking aim at this optimization. The Session explains each of these features.

Summary: The session describes some of the best practices in developing bug-free concurrent applications. Common pitfalls encountered in concurrent design and methods to avoid such pitfalls are also described.

Java For Mobile Devices – Building a client application for the Android platform

Speaker : Rohit Nayak

The iPhone revolutionized the world of mobile application development. However the iPhone’s proprietary hardware and software development environments are a roadblock to many.

Google’s Android platform with its promise of open standards for hardware and a free and familiar development environment make it a strong contender for competing with the iPhone platform.

After introducing the Android platform we will discuss the paradigms and constraints in building a mobile application. We then dissect a simple “social” Android application which uses a REST-based webservice to communicate. This will help us understand the core components of an Android application and the Android SDK functionality.

Grails as a modern scripting language for Web applications

Speaker : Rohit Nayak

Dynamic scripting languages are a powerful addition to a software designer’s toolbox. Rails/Ruby and Python have not gained much acceptance in the enterprise. Grails and Groovy are an attempt to bridge the gap between the modern scripting world and the Enterprise Java world.

This talk is an introduction towards building web applications in Grails. First we will go about creating a REST based webservice. We will also show how to replace the default database backend of Grails with MySQL.

We will then build a web application that consumes this webservice. The emphasis will be on the design patterns and idioms in Grails that address the web application development lifecycle.

Overview of The Scala Based Lift Web Framework

Speaker :Vikas Hazrati

All of us having experience with other web frameworks such as Struts,Tapestry, Rails, etc would ask “Why another framework? Does Lift really solve problems any differently or more effectively than the ones we’ve used before? The Lift Web Framework provides an advanced set of tools for quickly and easily building real-time, multi-users, interactive web applications. Lift has a unique advantage that no other web framework currently shares: the Scala programming language. Scala is a relatively new language developed by Martin Odersky and his group at EPFL Switzerland. Scala is a hybrid Object Oriented and Functional language that runs at native speeds on the JVM and fully interoperates with Java code. Lift is a hybrid web framework built on Scala. Lift derives its features and idioms from the best of existing web frameworks as well as the functional and OO features in Scala. It compiles to Java bytecode and runs on the JVM, which means that we can leverage the vast ecosystem of Java libraries just as we would with any other java web framework. This presentation details the advantages of this Scala based Web framework over all the existing frameworks that we have used uptil now and shows a small sample application built with Lift. We will create a basic application with a model that maps to RDBMS, web pages that correspond to back end logic and bind dynamically created content to elements on the webpage.

Automating the JEE deployment process

Speaker :Vikas Hazrati

While the basics of deployment are simple, in reality, deployment is a complicated process. The goal of a deployment is “Making an application available to end users”. This means that for the end user to open the browser and hit “www.xebia.com”, the application must be fully functional behind the scenes to serve the request. Let’s follow the end user’s browser request and see what components it hits; First it hits a firewall, then an http server, another firewall, the application server and finally the application running in the application server which uses a database to retrieve some data. In total there are 5 components involved to get the application successfully available. We need to not only configure all 5 components but also place some data on some of those components and make sure they are (re-)started in the correct order to get the pretty picture to the end-user. Thus in a nutshell the application deployment consists of installing the application, configuring resources, configuring middleware components, starting/stopping components, maintaining the correct order and repeating the same steps with different configurations across DTAP environments. Most of the times we tend to do this process manually. The manual process as the name suggests is usually time consuming, not predictable and un-reliable. This causes frustrations for, and between, developers and deployers, not supporting the business needs and therefore too expensive. This session would explore ways to automate the deployment process in order to make it repeatable, defect free, less taxing and less expensive.

* Speakers and sessions are listed on the site only after confirmation. However please note that the sessions, speakers and schedules are subject to change.

Copyright 2006 - 2009 Rightrix Solutions. All rights reserved. All product names are trademarks of their respective companies.
"Java and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. Rightrix Solutions and IndicThreads.com are independent of Sun Microsystems, Inc."
preload preload preload
Get Adobe Flash player