SCHEDULE: WORKSHOPS *

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.

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.

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.

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.

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.

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.

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.