SCHEDULE

Interoperability: Opening Up Opportunities in a World of Choice and a Time of Change

In this plenary talk, Ramkumar will talk about the myriad new opportunities that have opened up in this new world of choice. A timely keynote, Ramkumar will set the tone for the summit through this plenary especially in these times of chane.

Graphical Frameworks - GEF and ZEST

The Eclipse Graphical Modeling Framework (GEF) uses an SWT-based lightweight GUI toolkit to provide a feature-rich framework for creating graphical editors in Eclipse. GEF employs an MVC (model-view-controller) architecture that enables simple changes to be applied to the model from the view. Thus, it provides a foundation for building to create client-side rich graphical editors based on existing domain models, which are not easily built using native widgets found in the base Eclipse Platform. GEF is application neutral and provides the groundwork to build almost any application, including, but not limited to, charts and graphs, reports, activity diagrams, GUI builders, UML diagram editors, class diagram editors, state machines, and even WYSIWYG text editors like HTML.

Developed with the goal of making graph based programming easy, Zest is an information visualization toolkit for Eclipse that brings several standard graph viewers to the Eclipse platform as well as a graph layout framework and exemplary layout algorithms. The toolkit was designed to add advanced user interface controls to Standard Widget Toolkit and the JFace framework. Using Zest, Graphs are considered SWT Components that have been wrapped using standard JFace viewers. This allows developers to use Zest the same way they use JFace Tables, Trees and Lists. Since Zest has been modeled after JFace, all the Zest views conform to the same standards and conventions as existing Eclipse views. This means that the providers, actions and listeners used within existing applications can be leveraged within Zest. Many of the Zest views are being developed as part of the Graphical Editing Framework (GEF).

GOALS OF THE WORKSHOP: This workshop at Eclipse India Summit 2009 will provide an in-depth look at GEF and Zest and some hands-on experience by walking you through the steps involved in developing your own graphical editor and visualization graphs using Eclipse. You will also learn of best practices and common pitfalls to avoid.

COVERAGE INCLUDES:

• MVC Architecture behind GEF
• Introduction to Draw 2D API, GEF API
• Drawing APIs – Draw2D, Creation of Node and Connection, and responsibilities of major objects
• Controller APIs using EditPart
• Editing APIs covering all the Edit Policies
• Customisations like PropertyPage, OutlinePage (Tree and OverviewPage)
• Enabling Actions and Context Menu
• Add ons like Zoom, Print, Export
• Usage of graph visualizations using a JFace style API
• Zest layout package, platform independent layout algorithms that can be used with existing GEF or GMF based applications
• Demonstrate the advantages of Zest by creating a a plugin dependency view for the PDE

PRE-REQUISITES: This workshop is intended for project leads, team members and managers with advanced programming knowledge in Java. They should also have a working knowledge of the Eclipse workbench, SWT, plug-in development, but have little or no GEF experience.

Plugin Development - Tips and Tricks

The plug-in extension model of Eclipse provides a powerful and general paradigm for architecting extensible systems based on loosely-coupled components. A plug-in in Eclipse is a component that provides a certain type of service within the context of the Eclipse workbench. The Eclipse runtime provides an infrastructure to support the activation and operation of a set of plug-ins working together to provide a seamless environment for development activities.

The Eclipse Platform is composed of numerous plug-ins besides a plethora of additional plug-ins. And key to the success of Eclipse is the ability of developers to extend its functionality using plug-ins. But producing a commercial-quality plug-in means going above and beyond the minimal requirements needed to integrate with Eclipse. It means attending to all those details that contribute to making it fit the quality of a commercial offering.

GOALS OF THE WORKSHOP: This workshop at Eclipse India Summit 2009 is developed for those who know about plug-ins but want to developer a deep understanding and be able to use the advanced features of the Eclipse platform in plug-ins. The workshop will provide detailed, practical coverage about advanced topics in plug-in development, tips and tricks for plug0in development, and specific solutions for the challenges developers are most likely to encounter, including the extra steps needed to achieve the highest quality results.

COVERAGE INCLUDES:

• Plug-in Philosophy
• Compartimentation
• Lazy loading
• Loose Coupling
• Defining Extension Points
• The flip side of the coin
• Adapters
• Using the extension object pattern the Eclipse way
• Data Binding
• Synchronizing controls and (presentation) model
• Customizing the Look and Feel
• Presentation API
• The Next Generation of provisioning
• Provisioning mechanism
• Update sites
• Stealth updates

PRE-REQUISITES: Workshop participants should have experience with Eclipse, strong knowledge of Java and design patterns, GUI development experience and XML. Java programming experience will be helpful, especially object-oriented use of the language. Previous experience with Unified Modeling Language (UML) is also useful.

EclipseLink: High-Performance Java Persistence

Throughput and scalability are top priorities for enterprise Java applications in which relational and XML persistence account for a significant portion of an application’s performance. The open source EclipseLink project provides high-performance implementations of several persistence standards including JPA and JAXB. This session introduces EclipseLink and its advanced performance features.

Eclipse and Building Data Centric Rich Internet Applications

This session will focus on leveraging Eclipse and its ecosystem to build tools for developers to develop data centric Rich Internet Applications which run on the Flash platform. The session will also focus on Flex Builder which is based on eclipse and how it is using the dtp plug ins available in eclipse to connect to various databases to auto generate code. Also you will learn about Flex Builder’s customization capabilities built on top of eclipse’s extension points architecture and build a plugin which can connect to a backend and participate in Flex Builder work flows to build data centric applications.

Patterns in Eclipse

Eclipse is one of the most successful and commercially adopted Open Source Software in recent times. It has been widely used and tons of applications are built on Eclipse. The flexibility and the reliability provided by Eclipse is not an accident. Right from the beginning, Eclipse has been built with several key design patterns in mind. This session focuses on some of the basic design patterns.

• Screen, CPU and memory belongs to the user
• How to build the UI without loading the plugins
• Decoupling plugins by using Adapters
• Using Services to encapsulate the implementation details
• Separation of concerns to maximize the reuse of functionality
• Ideas behind designing a scalable UI

Modeling Frameworks - EMF

Eclipse Modeling Framework (EMF) is a powerful modeling framework and code generation facility for building tools and other Java applications based on simple model definitions. Designed to make modeling practical and useful to the mainstream Java programmer, EMF unifies three important technologies: Java, XML, and UML. From a model specification described in XML Metadata Interchange (XMI), EMF provides tools and runtime support to produce a set of Java classes for the model, a set of adapter classes that enable viewing and command-based editing of the model, and a basic editor.

The amazing success of EMF can be attributed to the careful attention that has been paid to EMF’s architecture, the completeness of its APIs, its flexibility, and its performance. By enabling developers to rapidly construct robust applications based on surprisingly simple models, EMF is now on the list of key Eclipse technologies being used by startups, enterprises and established software vendors. Further, most modeling products in recent times, including those from IBM and Borland, are based on EMF. In a further ratification of EMF's goodness, the developers of e4 (the next Eclipse platform) are planning to use EMF's capabilities to provide a consistent model-based foundation and runtime.

GOALS OF THE WORKSHOP: With so much technology built upon EMF, understanding its features, is essential to leveraging it successfully. The workshop at Eclipse Indian Summit 2009 will help participants understand how using EMF lets you do more with your models that you might have thought possible. The tutorial will begin by explaining the fundamentals of Model Driven Development (MDD) and code generation techniques. It will explain the use of EMF in MDD for modeling and designing an Eclipse plugin development project. The speaker will also demonstrate extending EMF's core features like Dynamic Modelling, Loading and Serializing and also introduce Java Emitter Templates.

COVERAGE INCLUDES:

• Overview of Model Driven Development
• Introduction to a case study
• How to create a model using Ecore, the model used to represent models in EMF
• Usage of generator model
• Running an EMF generator including generating, analyzing and running an application
• Defining EMF models
• Understanding EMF Model generator patterns
• Understanding EMF Edit and Editor generator patterns
• Loading and serializing mechanisms in EMF
• Introduction to dynamic features of EMF

PRE-REQUISITES: Workshop participants should be familiar with the Java programming language and the Extensible Markup Language (XML). They should have hands-on knowledge in developing Eclipse plugins. Previous exposure to modeling technologies such as UML and design patterns, although helpful, is not required.

Fixing JSE/JEE Performance Problems the Eclipse Way

This session will explore how to identify, track and fix a variety of performance problems in JSE and JEE applications. You will learn how it's possible to determine which layer of a JEE application is consuming the most resources. This session will also identify and resolve common problems such as memory leaks (maintaining unnecessary object references) and thread contention. Additionally, the use of line level code coverage in ensuring code quality will also be covered. This session will extensively use the Eclipse-based tool JOptimizer.

Design Case Study of a Complex Development Tool (SOA Space) Built on GEF

With the growing SOA adoption the need to create complex graphical tooling around it like orchestration flows, diagramming editors, diagram-code views etc. is increasingly gaining significance and also playing a significant role in positioning the product line. This is necessitating the choice and use of efficient graphical frameworks which can be leveraged to meet the timely needs of development and product as a whole. Graphical Editing Framework (GEF) in the Eclipse domain is seemingly a better fit for such “a case for the cause” requirements. The maturity and adoption of GEF is drawing more traction in this development space. The focus would be on the complicated use cases and complex scenarios often hit in the SOA space and how GEF helps in addressing such cases and the built-in flexibility and customization it provides. It is also important to leverage the features provided by GEF in a manner that suits the needs of development.

The following aspects would be covered.

• Diversity of SOA use cases
• Development time use cases – Usability
• Demonstrate the GEF advantage
• Effect and Considerations on models, layouts, shapes etc.

Eclipse 3.5 PDE Target Platform Story

The Plug-in Development Environment is one of the most widely used tooling extension of Eclipse. It has been evolving with the growing needs of developers and in Eclipse 3.5 it comes with a new look target platform story. This session will explore and demonstrate:

• New Target Platform story
• Multiple Target Management
• Software Site Target Provisioner
• Target Editor enhancements
• Target Platform State view
• Introduction and enhancements to API Tooling
• Noteworthy enhancements to PDE in Eclipse 3.5

Java Persistence 2.0 - What's New?

Java Persistence 2.0 (JSR 317) promises to standardize many valuable object-relational features requested by enterprise developers. The reference implementation for JPA 2.0 is EclipseLink, which will be the first to deliver them. In this session attendees will gain insight into how these new features can be used and how they can most effectively leverage the advanced capabilities of EclipseLink.

Oracle Plenary

Information on this plenary keynote is not available.

Enhancing the Productivity of RAD Using Websphere

Rational Application Developer (RAD) v7.5 is tightly integrated with WebSphere Application Server (WAS) to provide seamless development and deployment for complex web, Java EE and SOA applications. This webinar highlights some of the key areas of function in RAD v7.5 that enhance developer productivity, including tools for Java EE 5, annotations, and the built-in WebSphere Test Environment that allows applications to be quickly deployed and tested locally.

Reporting Techniques - BIRT

This workshop introduces and explores BIRT, the Eclipse Foundation open source Business Intelligence and Reporting Tools (BIRT) project. BIRT is a powerful report development and deployment toolset that allows Java developers to quickly and easily incorporate reporting into applications without the need for time-consuming custom code. Using BIRT, developers design reports based on a wide variety of data sources, including SQL, Web Services, XML and Java objects, and tightly integrate those reports into their applications using a rich set of APIs. Reports can range in functionality from the simple to the complex, from listing reports to cross tabulation reports, and are all designed visually using a web-page design metaphor.

This workshop will cover the following:

• An introduction to report design and formatting
• An overview of the dynamic elements of reporting through report parameters, changing elements based on data values through highlighting, mapping, and filtering
• An introduction to the various types of charts capabilities in BIRT, incorporating interaction in charts, and ways in which charting can be extended
• An introduction to the use of scripting code based on custom logic to manipulate report data or to adjust report content conditionally
• Collaboration in BIRT report development via libraries and CSS files
• Speedy BIRT report development using templates
• A discussion of easy-to-use tools, which are based on the Eclipse Web Tools Project (WTP), that make it easy for the developer to deploy the BIRT Runtime and reports in their application
• Details on BIRT features made available in the 2.5 release

This workshop will provide attendees with a good understanding of the powerful capabilities of BIRT thereby enabling them to quickly be productive in creating and integrating reports by means of a highly popular Eclipse project – the BIRT project.

Design Patterns Used In Eclipse

The idea behind design patterns is simple - write down and catalog common interactions between objects that programmers have frequently found useful. But design patterns are not just about the design of objects, but about the communication between objects, so they can also be considered as communication patterns. Therefore, designing simple, yet elegant, methods of communication is what makes design patterns so important.

Further, an understanding of patterns as a whole helps programmers learn object-oriented thinking, such as how to leverage polymorphism, design for composition, delegation, balance responsibilities, and provide pluggable behavior.

The three main categories of design patterns are Creational Patterns, Structural Patterns and Behavioral Patterns. Creational patterns create objects for you, rather than having you instantiate objects directly. Structural patterns help to compose groups of objects into larger structures, such as complex user interfaces or accounting data. Behavioral patterns involve how objects interact with each other; it helps to define the communication between objects in your system and how the flow is controlled in a complex program.

GOALS OF THE WORKSHOP:The Design Patterns workshop at Eclipse India Summit 2009 will present an in-depth view of design patterns, as they exist in Eclipse. The goal is to provide an understanding of design patterns, as of how patterns can be defined and processed. It will enable attendees to start thinking in terms of design patterns, recognize and apply patterns to specific software development problems and use known patterns as a shared vocabulary in designing and discussing solutions.

COVERAGE INCLUDES:

• Core Runtime – IAdaptable
• Use of IAdaptables and Adapter Factories
• Core Workspace – Resources
• Accessing File System – Proxy and Bridge Pattern
• Tracking changes in Resources – Observer Pattern
• Traversing the Tree – Visitor Pattern
• Standard Widget Toolkit – SWT
• Responding to Events – Observer
• Defining Layouts - Strategy
• JFace - User Interface Frameworks
• Viewer – Connecting Widget to Model – Pluggable Adapter
• Actions – Command
• Viewer – Customising a Viewer - Strategy
• Patterns used in UI Workbench
• Persisting UI State – Memento
• Workbench Services

PRE-REQUISITES: Workshop participants should have experience with Eclipse, strong knowledge of Java and design patterns, GUI development experience and XML. Java programming experience will be helpful, especially object-oriented use of the language. Previous experience with Unified Modeling Language (UML) is also useful.

Google AppEngine for Java and Eclipse Developers

Abstract: Google AppEngine is the cloud computing platform from Google. Attend this session to understand the key concepts of Google AppEngine and designing / developing applications using Eclipse for targeting the AppEngine platform. We will take a scenario based approach to demonstrate the nuisances of Cloud Computing. We will be covering the following topics in this session:

• How to get started with Google AppEngine
• Refactoring existing applications for the cloud
• Accessing data on the cloud
• Developing & Deploying applications to AppEngine using Eclipse

Fast track to Developing Online Analytical Applications Using the BIRT Tool

The business intelligence and reporting space is focused on tools and capabilities that extract data from data sources, process that data, and present the processed information to the end users. The information may be needed to enable the users to perform their operational or analytical job functions, or it may be customer-centric information such as a transaction statement. The capabilities can range from application- and production-level reporting, through ad hoc user-driven query tools, to highly interactive multi-dimensional online analytical processing (OLAP) and data mining tools. In this session, Ravi will show you how to develop online analytical applications using the BIRT tool. Topics covered include:

• HPIMS Application Architecture
• Connecting to Data Source (MySQL)
• Building a Simple List Report – List Properties
• Building a Report with Images – List Employees
• Formatting Report Content – All Occupants List
• Using Charts in Report – Projection Report

Lighting up Java Web Apps with Silverlight

Silverlight is the cross-browser, cross-platform plug-in from Microsoft for delivering rich user experiences to the end users. Attend this session to understand how to leverage Silverlight’s capabilities to bring media and RIA features to Java web applications. Explore how to use a variety of tools along with Eclipse to add stunning, rich user experiences to your applications. We will be covering the following concepts in this session:

• Basics of Silverlight development
• Using the Eclipse plug-in for Silverlight
• Integrating Silverlight with Java web applications

Introduction to OSGI/Equinox

Eclipse Equinox is a plug-in system that allows developers to implement an application in a set of 'bundles' using common services and infrastructure. And the OSGi technology provides a service-oriented plug-in-based platform for application development. Since OSGi is a dynamic environment where bundles can be installed, started, stopped and uninstalled at runtime, Equinox-based servers use the OSGi runtime that provides a service abstraction and OSGi services map well to services in a SOA.

Equinox is considered to be a major contributor to the success of Eclipse on the client-side (RCP). But it is not limited to the client-side. It can be applied in a general way to build any kind of application, especially servers. For instance, you can extend the server with additional facility by installing extra bundles, like a log analyzer for your HTTP service.

Both Equinox and OSGi are seeing a surge in interest from a wide range of communities from embedded, the traditional domain of OSGi, to desktop tools and applications to mobile devices and servers.

Application server vendors like IBM, BEA, RedHat JBoss, Oracle and OW2 are enhancing their software with OSGi and Equinox. For example, BEA Event Server is a special purpose server developed using Equinox to address the specialized needs of event driven applications. IBM has adopted a platform strategy based on Equinox and Eclipse RCP for the Lotus Notes, Expeditor, Sametime and Symphony product lines.

GOALS OF THE WORKSHOP: Equinox and OSGi aim to ease the difficulties in programming dynamic, modular, extensible systems by providing substantial infrastructure for defining modules, managing lifecycle and facilitating collaboration between modules. This workshop at Eclipse Indian Summit 2009 will cover fundamentals of OSGi as well as introductory topics and specific features of Eclipse Equinox.

COVERAGE INCLUDES:

• First Steps with OSGi
• Modularization the OSGi Way
• Dynamics
• Services
• Declarative Services
• Selected OSGi Standard Services
• Security in OSGi and Equinox
• Classloading in OSGi and Equinoxe
• JEE Integration (Tomcat, Spring)
• Web applications with Equinox
• Tooling
• OSGi Declarative Services
• Dynamic installation and removal of functionality using p2
• Extensibility
• Testing and simulation strategies
• Graphical and web-based user interfaces
• Common pitfalls

PRE-REQUISITES: Workshop participants should have advanced skills in Java development. The software developers and architects attending the workshop are also expected to know how to use Eclipse SDK as Java IDE. Basic understanding of the Spring framework, XML and OSGi are also useful.

Eclipse Test Automation Tools - Options and Approaches

The test automation of Eclipse based plug-ins pose several challenges including the UI framework used, automation of graphical objects created using GEF, typical IDE features like Content Assistance/Code Completion, Indentation, Complex views etc. The GUI Automation tools available are not 100% efficient in identifying the GUI objects and different tools support different UI framework. This workshop will discuss typical test Automation Requirements for Eclipse based plug-ins, and then look at the test complexities and challenges. It will look at the various automation tools and do a Compare and Contrast of them. The workshop will conclude with a list of Test Automation Best Practices and a presentation of a Case study (Test Automation of Eclipse Based SOA IDE).

Goals of the Workshop: This workshop is intended for users who have worked on UI automation tools and wants to know how to automate Eclipse based UI and the challenges that might arise while automating Eclipse UI and a detailed discussion on various UI automation tools. A thorough analysis will be done on different views that Eclipse offer and the challenges they pose while automating those views using QuickTest Professional.

COVERAGE INCLUDES:

• Eclipse IDE and different views
• Challenges with UI Automation
• Performance and Load testing with UI Automation tools
• Comparison of different UI Automation tools
• Limitations of UI Automation tools
• Test Automation best practices

PRE-REQUISITES: Workshop participants should have basic working knowledge of Eclipse IDE and working knowledge of any UI automation tool like QuickTest Professional, Squish, WindowTester, WinRunner. The attendees should have Eclipse IDE (preferably Eclipse 3.4 and above) and QuickTest Professional (9.1 and above) installed on their laptops prior to attending this workshop.

Looking Beyond Product Component Packaging with OSGi/Equinox

OSGI provides a general-purpose, secure, and managed Java framework that supports the deployment of extensible and downloadable applications known as bundles. Equinox is a fully standalone OSGi implementation. This talk discusses the benefits of building your application upon OSGI to include reduction of development and deployment time complexity, reuse of bundles and the availability of a highly dynamic system where bundles and their services could be installed, uninstalled and reinstalled as often as you please. It talks about how to boost your product’s extensibility by providing and ideal platform for third party application developers to provide add-ons and extensions. The Eclipse platform is a classic example. Equinox’s provisioning platform could be used to implement innovative ways to install and upgrade your product in a hassle free manner.

Eclipse as a Framework of Frameworks

Almost all conventional courses in programming begin by teaching you "Hello World" and then other incrementally complex applications. 'Application' being a software which performs a specific pre-decided task. Thus we become intuitively trained to think applications when we think software. It is usually only after few years of practical experience that one starts to understand how to write extensible and pluggable applications and platforms i.e., software which not only performs some core specific tasks, but also provides the foundation for other software's to build on top of. This talk is intended to take a very simple example to motivate the idea of framework architectures, and how one could easily conceive and build frameworks without much effort. The latter part extrapolates the above concepts to explain the eclipse architecture, and also explains how the eclipse framework is intuitively a "framework of frameworks", and that too a very powerful one.

Integrating BIRT Reporting Into Your Applications

Now that you've created great looking BIRT reports, what do you do with them? This session will discuss the reporting requirements you may encounter as you build your reporting solution and how to satisfy them. We will discuss several deployment options that range from API integration to integrating BIRT Viewers into web applications. We will discuss data integration, security integration, branding, and integrating with report server products that provide report sharing, scheduling, AJAX-based BIRT viewers, and a web-based BIRT designer for end users.