But not everything is coming up roses for Eclipse. An Eclipse Foundation official has suggested it may be time to pare down the functionality of the Eclipse platform. The IDE itself scored low on several functionality measures in a survey released in September 2007 that gauged the views of 1,500 developers last spring. |
The great thing about Eclipse is that it's so feature rich. If you can't find a feature, then either you just haven't looked hard enough or there's a plug-in that adds it. The worst thing about Eclipse is also that it's so feature rich. The toolbars are crowded, the menus are congested, and the configuration dialogs remind me of the Minotaur's labyrinth (although configuration is much better in version 3.1). Even experienced Eclipse programmers are slow and clumsy users. I've looked over countless colleagues' shoulders and blurted out "Control-Shift-T" (open type) when seeing them struggling to find a class in the Eclipse navigation pane. And with a small conscious time investment, you too can stop fumbling around in Eclipse and become a hotkey showoff. |
Author's note: In part one of a two-part series of excerpts from Eclipse's Chapter 2, we'll get down to the business of developing Java using Eclipse. We're going to take a look at using Eclipse for Java development as well as project management, going from the basics to the fairly serious. Nearly everything in this chapter is essential knowledge for the Java developer using Eclipse, so let's jump in. |
This article is going to introduce you to JUnit, a tool for project testing and debugging. After introducing the theory of test-driven development, we'll move on to a step-by-step explanation of how you can create your JUnit tests with the help of the popular Eclipse IDE. We'll show how something as simple as a Hello World program can be exposed to a JUnit test. |
Editor's note: In the Eclipse Cookbook, Steve Holzner, who also authored O'Reilly's Eclipse, offers practical recipes for more than 800 situations you may encounter while working with Eclipse. Today we sample two recipes from the cookbook, with two more (on connecting Eclipse to a CVS repository and on using Swing and AWT inside SWT for Eclipse 3.0) to follow next week. |
Eclipse is a nice IDE, of course, but it's arguably the best platform for hosting your own applications. Using Eclipse facilities spares you from re-coding, for the 100th time, a framework for dealing with online help, generating wizards, or saving a file to disk. Eclipse ships with many helpful features, such as a Lucene-ready engine for searching your help documentation. Like any object-oriented developer, you don't want to reinvent the wheel. |
Editor's note: In part one of this two-part series of excerpts from Eclipse, author Steve Holzner provided examples of how Eclipse makes it easier to create Java code from scratch. Continuing in that vein, in this week's concluding excerpt Steve covers creating Javadocs, refactoring, adding certain skills to your Eclipse toolbox, and customizing the development environment. |
|
Editor's Note: In last week's excerpt from Ant: The Definitive Guide, 2nd Edition, Steve Holzner showed off the basics of integrating Ant with Eclipse. But if you've ever written a build.xml file for a large project, you know that there's more to Ant than spelling out the targets. Providing a build script that can be customized to the developer's OS, file-system layout, and other preferences is important for keeping a team of developers working consistently. In this excerpt, Steve shows how to use Eclipse to set property values and environment variables that can be picked up by Ant. He also shows how to configure the Ant editor to work on Ant files from within Eclipse, how to use a different version of Ant, and more. |
The latest release of Eclipse (Eclipse 3.2) comes with Callisto, a rich set of optional plugins for Eclipse 3.2. Callisto includes a powerful profiling tool called the Eclipse Test & Performance Tools Platform, or TPTP. TPTP provides a comprehensive suite of open source performance-testing and profiling tools, including integrated application monitoring, testing, tracing and profiling functionalities, and static-code analysis tools. Profiling tools are invaluable aids for localizing and identifying performance issues in all sorts of Java applications. In this article, we will look at how you can use TPTP to guarantee high-quality and high-performance code, even during unit and integration testing. |
In part one of this series, we introduced Eclipse's plugin development environment and developed a simple plugin. In part two, we added a toolbar button, a menu item, and dialogs. The result was a shiny gizmo that didn't do much for us. It simply displayed sample text using a font. Now we need to make it manage actual data. We will massage the plugin so that it does what we need it to do. This article discusses editor documents and shows how to customize a wizard. |
The release of the Eclipse Web Tools Platform (WTP) Version 0.7 in July 2005 marks a significant milestone in open source web and J2EE development. The WTP project, seeded by contributions from the IBM Rational Application Developer for WebSphere and ObjectWeb Lomboz, provides a set of well-rounded and tightly integrated tools that simplify the creation of often complex web and J2EE applications. These tools also form the foundation of an integrated web and J2EE tools platform that offers great flexibility to vendors who want to add their own extensions and customization. |
This new monthly column is about writing plugins in Eclipse. Who is this column for? Many Eclipse users simply use the IDE out of the box without needing customization. Many will be using plugins made by other people. That is not the target audience of this column. Some Eclipse users will want to customize it. Some will develop tools for their company's employees. Some will want to sell tools that connect to their products. Some will want to resell Eclipse under another name with these tools pre-installed. These people constitute the target audience. The prerequisites for starting to write Eclipse plugins are knowing how to use Eclipse and write Java programs, and having a good understanding of the Standard Widget Toolkit (SWT) and Swing. |
Editor's note: If you missed last week's batch of recipes from O'Reilly's Eclipse Cookbook, be sure to check them out. This week, we offer two more sample recipes from the book. Both offer glimpses of Eclipse in action -- the first with CVS, and the second with Swing. Enjoy. |
Editor's Note: Every time we do a survey, we find that fewer and fewer Java developers are using a strictly command-line/text-editor approach. The overwhelming majority are using an IDE, and for most, the IDE of choice is Eclipse. Given that, do you really want to enjoy an IDE for creating your code, only have to go out to the command line to build it? Of course not. In this first of a two-part excerpt from Ant: The Definitive Guide, 2nd Edition, Steve Holzner shows how to integrate Ant with Eclipse, from creating a project to writing an Ant build.xml file in Eclipse, and running the build from inside the IDE. |
The book editors at O'Reilly have provided ONJava with a preview of the chapter "Building Eclipse Projects Using Ant" from Steve Holzner's forthcoming book Eclipse: A Java Developer's Guide. Note that this is a beta release; this chapter has not yet been fully edited, and the final version will not appear in this raw form. The images in the final version will also be of higher quality than those presented in this preview. |
Eclipse version 3.2 forms the cornerstone of the Eclipse Callisto release train: a simultaneous release of ten Eclipse projects on June 30, 2006. This article will focus on the Eclipse IDE, in particular its Java Development Tools (JDT). |
If you provide the toolbar ID without a marker ID, your button will be added in a new toolbar right next to this one. Creating toolbars is as simple as using a new toolbar name. This new toolbar will then be available to add on the Eclipse GUI. You will sometimes see plugins using the toolbar path "Normal." This is the old naming convention. Using this in Eclipse 3 will create a new toolbar named "Normal." If you create a new toolbar ID, your toolbar is added after the File toolbar. |
If you closely follow open source or Java programming, you may have heard some of the buzz surrounding Eclipse. Eclipse is an extensible, open source IDE (integrated development environment). The project was originally launched in November 2001, when IBM donated $40 million worth of source code from Websphere Studio Workbench and formed the Eclipse Consortium to manage the continued development of the tool. |
We shall develop an example servlet application and deploy the application in JBoss. First, the servlet is run without any error; subsequently, an error is introduced into the servlet to demonstrate the remote debugging feature in Eclipse. |
SQLExplorer is an Eclipse IDE database plugin that may be used to connect to a database from Eclipse. The SQLExplorer plugin adds a graphical user interface (GUI) to access a database with SQL. With SQLExplorer, you can display the tables, table structure, and data in the tables, and retrieve, add, update, or delete table data. SQLExplorer can also generate SQL scripts to create and query tables. Thus, using SQLExplorer may be preferable to using a command-line SQL client. In this tutorial, we shall establish a JDBC connection with the open source MySQL database from Eclipse 3.0 with the SQLExplorer plugin. |
Technology has a definite cycle. After a decade of dominance by thin clients, rich-client technology is making a comeback. Numerous organizations are building their applications as rich clients and many of them are basing their applications on the Eclipse Rich Client Platform (RCP). The term "rich client" implies first that the application provides the user with a rich experience; second, it implies that the application is a client for some server. While it is not necessarily the case that a rich client has a corresponding server component, this is often the case. |
In this article, I will discuss how to create a controlled and easy to use reporting environment for your organization using Libraries and Templates in BIRT, the Business Intelligence and Reporting Tools project from Eclipse. |
The explosion in interest in Equinox and OSGi should not have surprised us but it did. Many people in the Java community are struggling with system complexity and management issues. With Eclipse, Equinox and OSGi you too can enjoy the benefits of modular, componentized Java wherever you compute. |
The resulting material is is broken down into a series of three articles. This first article talks about installing Eclipse and working with basic Java projects. The second article talks about using Eclipse not only for managing Java projects, but also the OS environment that usually surrounds your Java projects, such as files and directories on your local drive. The third article extends the ideas of part two to show you how you can manage web applications using the same paradigm. |
Eclipse is more than just an IDE. The official enigmatic description is that "Eclipse is a universal tool platform, an open extensible integrated development environment (IDE) for anything and nothing in particular." These excerpts from Erich Gamma and Kent Beck's book Contributing to Eclipse: Principles, Patterns, and Plug-Ins give you the flavor of creating plug-ins for the Eclipse platform. |
Editor's note: The following was sent by Sun to the Eclipse board and membership on January 29, 2004 and then posted on January 30 as an open letter. We've decided to post this to provide a place to discuss the issues raised in this letter. Please feel free to add constructive and professional comments in the feedback below. |
Brief Overview of new features in the upcoming release of the open source SCM Subversion including enhanced merge tracking and change set management as well as using CollabNet Desktop Edition within Eclipse to facilitate team based task and change management. |
When the Eclipse project began, OTI had a culture that focused on shipping on time which has always put people in the center of the development process. Since then I've been amongst others working with John Wiegand tweaking the way we develop. During the past six years we have continually adapted. We tried out things. The things that didn't work we stopped doing and things that worked we kept on doing. And, our teams made it all work. |
This article takes you step by step through building a thick client interface to connect to the server built in the previous article. You will build the thick client on top of the Eclipse Rich Client Platform and then integrate Eclipse RCP with Spring. |
The popular Spring framework's BeanFactoryPostProcessor interface enables developers to easily create a lightweight plug-in framework. . This article discusses how to do this, and it includes a working code sample that shows lightweight plug-ins in action. |
Eclipse 3.2 has changed all that. The Data Tools Platform (DTP), and to a lesser extent the Web Tools Platform (WTP), both part of the new Callisto product suite released with Eclipse 3.2, provide a range of data-centric tools, including JDBC connectivity, SQL querying, database browsing, and more. |
GUI Programming Takes a Leap Forward Java has historically languished and struggled in the area of GUI development: AWT was not robust enough, and Swing—improvement that it is—is just too bulky and slow for many fat client applications. With the advent of the lightweight and fast SWT library, Java GUI programming has taken a huge leap forward, but developers still are faced with the headaches of reverse-engineering old AWT and Swing applications, maintaining existing code, and creating new apps. WindowBuilder Pro is specifically designed to address these issues (See Table 4: WindowBuilder Pro: Pros and Cons). It excels at translating legacy Java GUI code and supporting rapid application development reminiscent of the old Visual Basic 5-6.0. All of this is implemented in an intuitive and easy-to-use Eclipse interface. Java developers who have been avoiding GUI programming because of the learning curve and its impact to their respective productivity should seriously investigate this powerful tool. |
In an earlier article, you learned about a plugin to the Eclipse environment that lets you configure and deploy to your JBoss application server. The same plugin will invoke the Xdoclet standard to let you automatically generate Java code for enterprise applications. (Please refer to the first article for instructions on how to install the plugin: http://www.devx.com/opensource/Article/20242.) |
Palo Alto, CA, March 18, 2003--The Palo Alto Research Center (PARC) and Eclipse announced the transfer of AspectJTM technology from PARC to Eclipse and through the Eclipse Technology Project, to the entire open-source community. AspectJ has an active following in both the research and industrial communities, and represents a well-researched toolkit for Aspect Oriented Programming (AOP). |
In the early days of open source J2EE Integrated Development Environments (IDEs), I experimented with both NetBeans and Eclipse. Ultimately, I opted for Eclipse. At the time, Eclipse appeared to have a more intuitive UI, faster performance and a deeper library of plug-ins to enhance my development experience. Since then, I have stuck with Eclipse. |
Eclipse.org is an open consortium of software development tool vendors that has formed a community interested in collaborating to create better development environments and product integration. The community shares an interest in creating products that are interoperable in an easy-to-use way based upon plug-in technology. By collaborating and sharing core integration technology, Eclipse Platform-compatible tool vendors can concentrate on their areas of expertise and the creation of new development technologies. |
Most of the articles published so far about JFace and SWT have discussed them from the point of view of using them in the context of the larger Eclipse framework. I am going to take a different approach. I will show how you can use JFace and SWT in a stand-alone Java program. |
Editor's note: An updated version of this article titled "Get started with Eclipse Platform" was published in July 2007. This original version will remain available for reference purposes. Read the new article to understand the latest features in Eclipse. |
Editor's note: The name of the Ruby Development Tools (RDT) plug-in and where to find it have changed since this article was written in 2005, but the basic function and licensing terms remain essentially unchanged. RTD, now called Aptana RadRails V1.0.3, is available at the Aptana Web site. To download a new version or update your Eclipse plug-in, follow Aptana's RadRails instructions, which will be familiar to Eclipse users. Note that if you have not installed an Aptana plug-in into your Eclipse workspace before, you should follow Aptana's instructions for Plugging Aptana into an existing Eclipse configuration. |
The embedded Rich Client Platform (eRCP) came about as a way to bring the advancements of the Eclipse Rich Client Platform (RCP) and apply it to the embedded space. |
If you want to locate some unresolved plug-in dependencies (missing plug-ins or plug-ins Eclipse did not load for some reason), first use the Eclipse PDE Plug-in Dependencies view to list your plug-in's dependencies. In case the Plug-in Dependencies view does not list your plug-in, you may want to use the ready-made tool in this article for a similar automated search covering all the linked plug-in folders. If you are interested in only specific plug-ins, you can also modify the source code to suit your requirements. |
To address these issues, the Eclipse Platform introduces the notion of another reusable component that complements plug-ins: a plug-in fragment. A plug-in fragment provides additional functionality to its target plug-in. At runtime, these plug-in contributions are merged along with all dependent fragments. These contributions can include code contributions and contributions of resources associated with a plug-in, like property and HTML files. In other words, the plug-in has access to the fragment's contents via the plug-in's classloader. |
Erich Gamma is the team lead for Java tools for Eclipse. Gamma was one of the Gang of Four known for creating the book Design Patterns: Elements of Reusable Object Oriented Software. He also created JUnit with Kent Beck (see Resources). Refactoring is recognized as another valuable practice in object oriented programming but, until recently, only few tools had support for it. At OOPSLA 200, Eclipse developers demonstrated the Refactoring support in Eclipse. They stressed that refactoring should not alter a program's behavior. |
Editor's note: An updated version of this article, titled "Create an Eclipse-based application using the Graphical Editing Framework," was published in March 2007. This original version will remain available for reference purposes. Read the new article to understand the latest features in GEF. |
The Eclipse Platform is a fresh start at an open integrated development environment (IDE) system with broad commercial participation. While classic tools like Emacs and others have supported the development needs of developers worldwide, most lacked the advanced features and convenience of GUI based IDEs, as well as an easily extensible nature, available in commercial tools. With over 1200 developers from 63 countries involved in the Eclipse open source community process and with more than 150 leading software tools vendors working with it, Eclipse stands a chance to change that entirely. |
The Eclipse Platform offers the capability to share code and work as a team on a software project. Eclipse supports a wide range of code-management solutions, thanks to its plug-in architecture (however, CVS support comes out of box). The focal point of the Eclipse Platform architecture is the workspace. The workspace maintains everything necessary for building and testing a software project. It contains the objects (source code and resources). It also holds the configuration settings for the project, the IDE, and the plug-ins. The workspace is locally maintained on a developer's machine, and teams collaborate through external repositories that are meeting places for code parts from different developers. Repositories are accessible through the client-server architecture via the Internet. |
Of course, using the Eclipse help system is all well and good if you don't mind distributing the 20-plus MB of code required, but this isn't realistic for smaller projects. Hosting an InfoCenter on a central server allows people to connect remotely. People receive all the benefits of using the Eclipse help system (such as searching), but people without connectivity are left stranded. So, in addition to using a hosted InfoCenter, it's useful to include the plain HTML in a downloadable package. As long as you haven't used any server-side technologies such as JSPs, you can easily generate an HTML table of contents to replace the XML one used by Eclipse. Which is why we have eXtensible Stylesheet Language Transformations (XSLT). |
Eclipse is an open source community whose projects are focused on providing an extensible development platform and application frameworks for building software. This article gives you links to the latest version of Eclipse, information on IBM's involvement with Eclipse, and a guide to some of the most interesting Eclipse IDE projects. Learn what Eclipse is good for, why it is important, how you can get started, and where to learn more about it. |
Increasingly, tools assume that features are fully and smoothly integrated, and Maven and Eclipse (even as a simple IDE) are no exceptions. Thus, at first glance, they seem to overlap from a building point of view, as Figure 1 demonstrates. |
Apple's iPhone platform presents an interesting opportunity to developers. With a small form factor and interactive touchscreen, the iPhone and iPod Touch have won over millions of users in a short period of time. But this novel design and proprietary platform present a new set of challenges for application developers. Until Apple releases its software development kit (SDK) in February 2008, developers wishing to target the platform must create Web applications that mimic the iPhone's native look and feel. |
Once you have completed the UML as shown in Figure 2, the next step is to create an EMF Model. To do this, create a new EMF Project (File > New > Project... > Eclipse Modeling Framework > EMF Project), and use com.ibm.example.forum as the project name (this will become the basis for the plug-in name, so we follow the naming conventions for Eclipse plug-ins). On the next page, select Load from an EMF core model and click Next. Browse your file system to load your ecore file, which should automatically fill in the generator model name. On the last page, click the checkbox beside your package and click Finish. This will create the EMF model: forum.genmodel. To see what this is and how to use it, skip to Using the generated EMF model. |
Subclipse is a project to add Subversion support to the Eclipse IDE. We'll use Eclipse's update manager to add Subclipse to our Eclipse IDE. From the Help menu in Eclipse, choose Software Updates > Find and Install to open the update manager. |
The C and C++ languages are among the most popular and widely used programming languages in the world, so it's not surprising that the Eclipse Platform provides support for C/C++ development. Because the Eclipse Platform is only a framework for developer tools, it doesn't support C/C++ directly; it uses external plug-ins for support. This article shows you how to make use of the CDT -- a set of plug-ins for C/C++ development. The CDT Project (see Resources) is working toward providing a fully functional C/C++ Integrated Development Environment (IDE) for the Eclipse Platform. Although the project focus is on Linux®, it works in all environments where GNU developer tools are available, including Win32 (Windows® 95/98/Me/NT/2000/XP), QNX Neutrino, and Solaris platforms. |
This article presents ways to make views in Eclipse collaborate and respond to the states of other views. It also looks at cases in which one way of linking views may prove to be better than others. |
JMerge is an open source tool delivered with the Eclipse Modeling Framework JMerge enables you to customize the generated models and editors without having your changes battered by regenerating the code. JETEmitter supports JMerge if you provide a description of how to merge the freshly generated code with the existing, customized code. This article walks you through an example to explore some of the different options available. |
It may be starting to look pretty, but it isn't doing much right now. In Part 3 of this three-part "Using the Eclipse GUI outside the Eclipse Workbench" series, we fix that by adding menus and actions. We'll see how to create bar menus, toolbars, and pop-up menus. We develop some examples where those menus use some neat JFace utilities to launch programs and access the system clipboard, and we show how to use listeners to make the menu items context-sensitive. |
Help in Eclipse, like the rest of the environment, is built with a plug-in architecture. This article discusses taking advantage of this helpful architecture to externalize the help contents. It assumes a working knowledge of the Java? programming language, Eclipse, and Web topics. It does not assume that you already know anything about how help is organized in Eclipse or how plug-ins work. The goal of the article is to show you how and why you can host the help for the Eclipse environment on a centralized server (either on an intranet or the Internet) and access it from within the environment. |
After wrapping up my discussion of XI in my previous column, I decided it was time to revisit XM, the simple XML content management and publishing solution with which I kicked off this column. In the last year, I have been using XM for various projects and I have heard from readers as well. Throughout the year, I collected suggestions on what should be improved. In this article, I will show you how to create a user interface for XM. I chose to use Eclipse, an open-source project, to build an adaptable programming environment. I believe this article provides useful information for any would-be Eclipse developers, even if they have no interest in XML. |
The Eclipse SDK -- particularly, the Java? Development Tools (JDT) project -- features a built-in Java debugger that provides all standard debugging functionality, including the ability to perform step execution, to set breakpoints and values, to inspect variables and values, and to suspend and resume threads. Additionally, you can debug applications running on a remote machine. The Eclipse Platform is robust in such a way that other programming languages can use the debug facilities for their respective language runtimes. As you will see below, the same Eclipse Debug view is also available for the C/C++ programming languages. |
This is subtle, from a user's perspective because of the natural way this was introduced into the UI. There is no inkling that these new menu choices weren't part of Eclipse's original Java Development Tools (JDT). In fact, that's why the menu cascade is prefixed with "soln," so you can tell it's an extension. What's more, the developer doesn't have to remember that these choices are only available in a particular view or editor because they will be shown anywhere a method is shown. |
There has been a good deal of cross pollination between the Java language and Python camps over the years. Probably the most prominent example of this is Jython, the pure Java implementation of the Python runtime. In that tradition, you will explore the use of the Eclipse IDE and the Ant build and deployment tool for use in Python development. Eclipse and Ant are extremely popular, feature-rich, extensible, and open source; qualities shared with Python. What makes it possible to use these Java tools for Python development are the PyDev and PyAntTasks extensions to Eclipse and Ant, respectively. This article will start with pointers on downloading and installing the required tools and extensions. I'll use a working example of Python code which reads RSS feeds in order to demonstrate the use of Eclipse and Ant for Python development. |
The techniques described here offer an interim solution that can help you quickly integrate Swing-based tools into the Eclipse Platform. However, whenever possible possible, you should use tightly integrated SWT/JFace components over existing Swing widgets. For instance, instead of using individual preference dialog frames to handle user preferences, an editor should use the Eclipse Platform's Preference Page framework as the central entry point for configuring a plug-in. |
ECF aims to meet this goal by providing a set of high-level abstractions, rather than yet another messaging API. This design choice empowers you to reuse high-level communications components (instant messaging, file sharing, video conferencing, etc.) in varying application contexts and UIs. Imagine developing an application that requires instant messaging, blogging, BitTorrent, file sharing, and voice conferencing. With ECF, development can be expedited over all the communication code for each of those services, allowing you to focus on business logic and UIs. |
This list is compiled from a variety of sources and is intended for anyone who wishes to find centralized reading material about Eclipse. One of the biggest challenges new Eclipse users face is where to find the right information for a task. This article provides a small step in solving that problem. |
As you can tell from this article, I think it's important to have the "big five" measures for code quality: coding standards, code duplication, code coverage, dependency analysis, and complexity monitoring. But what works for you is what matters. Keep in mind that there are many other tools available as Eclipse plugins, such as PMD and FindBugs to name a few, that can help you improve the quality of your code early in the development cycle. Regardless of your desired tool or preferred measure, it's important to take action to improve code actively and make your manual code review process more efficient. I predict that after using these plugins for a time, you'll wonder how you lived without them. |
Eclipse is composed of plug-ins, but there are two other levels of components that are important to consider when developing plug-ins for Eclipse -- plug-in fragments and features. |
Because the Java language is relatively young, no long legacy of coding exists in any particular development environment (at least not yet!). The popularity of each of the various Java IDEs has tended to wax and wane in the race to provide new features, improve performance, and become easier to use. The most interesting new development has been the introduction of two free, extensible open source IDEs: Netbeans and Eclipse. These are rapidly approaching the capabilities of commercial offerings. Most developers won't need more than what these two excellent development platforms provide. |
A multitude of XML plug-ins have been developed, and new ones are created all the time. This article focuses on the plug-in called XMLBuddy, because its feature-rich set contains most of the functions needed for XML document development. We do touch on other plug-ins when they provide a richer set of user options for specific tasks. This article will familiarize you with the basic XML editing features, but bear in mind that Eclipse is a dynamic frameset that puts an endless array of tools and features at your fingertips. |
The problem with debugging a Java program remotely is not in the debugger front end but the remote Java back end. Unfortunately, there is not much information about this in the Eclipse help system. In fact, JDI and JVMTI are implemented by Eclipse and the Java runtime environment, respectively. The only thing we are concerned with is the JDWP, which contains the information to communicate with the JVMTI and JDI. The JDWP contains many arguments that have been added to invoke the application for the remote Java application. Following are some of the arguments used in this article. |
Read through any discussion thread on the relative merits of Eclipse and its competitors, and you'll find mention of various features that might be better, worse, or entirely missing in one or the other. Until recently, the one thing that always seemed to come up regarding Eclipse is its lack of a GUI builder: a graphical tool for building GUIs. Happily, this was remedied by the November 2003 launch of the Eclipse Visual Editor Project and the release soon after of Visual Editor V0.5, which allows you to create AWT/Swing applications with a complete WYSIWYG graphical editor. |
If you're used refactoring in JBuilder, you'll find that it's essentially the same in Eclipse, except for the fact that Eclipse uses a wizard to guide you through the process. Using this wizard, you'll have the opportunity to use Eclipse's powerful comparison dialog box to navigate between the changes that Eclipse proposes to make and you can veto or accept each change. |
I have been developing with Eclipse since its early days, and have found that it is one of the best things that ever happened to me for my Java development. Coming from a background of Java programming on Linux® using nothing but vi and a JDK, Java programming and debugging was a tedious task. Now, thanks to Eclipse, I can throw together quick Java-based prototypes easily. My next thought was why not integrate my JSP development into my Eclipse environment as well? Then I would be able to work more easily with my Java code and JSPs. The goal of this article is to save JSP developers time setting up Eclipse to work with Tomcat. |
Build a Web Services Distributed Management (WSDM) interface for the Apache HTTP server without having to worry about Web services artifacts like Web Services Description Language (WSDL) and schema files, using refreshed tooling for WSDM in the Eclipse open source project. In a previous tutorial, you learned how to accomplish this task by hand coding the artifacts required by the Apache Muse run time and using the command-line utilities in Muse. In this tutorial, you do the same but in a faster, easier way. By the end of this tutorial, you will be accomplished at using the tooling integrated into Eclipse to model, generate, and test WSDM interfaces. |
Eclipse can make working with Apache Ant easier. Discover the Ant integration features in the Eclipse integrated development environment (IDE), and learn how to write, build, and debug code in Eclipse through the Ant editor. |
On November 5, 2001, IBM announced its donation of $40 million worth of tools to the Eclipse project. Eclipse, a fully functional software development environment that is written in Java, and that runs on both Linux and Windows, is intended to solve many of the problems of tool interoperability faced by developers of conventional tools. IBM is handing the tools over to the Eclipse consortium, an independent group that will handle the further development of the code based on contributions by board members and individual developers. The consortium includes roughly 40 members who will manage the code intended to become the basis of IBM's next generation of WebSphere products. |
The World Wind Java SDK is a 3D interactive world viewer written in Java and OpenGL that allows any user to zoom from outer space into any place on Earth. This article gives you the foundation for embedding the WWJ SDK as an Eclipse view to gain a new set of powerful tools for GIS development within Eclipse. |
Part 1 of this series began an example that subclassed the JFace application window and used a tree viewer and a table viewer to display folders and files. In Part 2, we did some tidying and added some icons using the JFace image registry. This time, we look at actions and you can use them in menus and toolbars. We'll see the use of the Program class to launch programs and the Clipboard class to access the system clipboard. We have already used icons to display files and folders in viewers. We'll see how they can be used in menus and toolbars, as well. Finally, we'll make actions listen to events from viewers in order to make them context-sensitive. |
This article, which is a follow-up to "C/C++ development with the Eclipse Platform," is intended for C++ developers who want to learn C++ development using the Eclipse CDT. A simple C++ application is developed in the article. The application makes use of the C++ STL. Readers should be familiar with the STL, as well as with basic object-oriented programming principles such as inheritance and polymorphism. A familiarity with Eclipse will be helpful, but is not required. |
Welcome to the Eclipse ecosystem. Our goal was to get you started with the Eclipse platform quickly. We accomplished this with some introductory text accompanied with a simple hands-on exercise. Take the knowledge gained from reading this article and become an active member of the Eclipse ecosystem. |
The AspectJ Development Tools for Eclipse (AJDT) is an open source Eclipse Technology Project that provides the tooling required to develop and run AspectJ applications. We believe good tools have a key role to play in realizing the full benefits of aspect-oriented programming, and particularly in helping newcomers understand the concepts involved. |
Do you want to get faster access to the Ganymede release? Did you ever want to give back to Eclipse but didn't know how? Well, Eclipse has a new program called "Become a Friend of Eclipse," which allows you to give back to the Eclipse community. By becoming a friend of Eclipse, you help the Eclipse Foundation provide services for the Eclipse community, such as providing more bandwidth for users and committers, purchasing additional servers to host Eclipse projects, and sponsoring Eclipse community events. |
To set up the best development environment for your needs, it's important to understand what the prerequisites are. Because the Voice Tools Project depends on the Web Tools Project (which depends on the Eclipse SDK), several packages at the right version levels must be installed. |
Both Eclipse 3.0 and IntelliJ IDEA 4 are feature-rich, Java IDEs that provide syntax checking, code assistance, and code generation for coding. In addition, they both provide support for refactoring, Ant, unit testing, and CVS. And soon, the Eclipse Visual Editor 1.0 for building GUIs using either AWT/Swing or SWT will be available. But some important differences exist between the two. |
In the search for more portable and lightweight enterprise solutions, Java? 2 Platform, Enterprise Edition (J2EE) developers can leverage both Stripes and Apache Derby for rapid, lightweight, J2EE development. Learn how to develop, package, and deploy a simple Stripes application that performs Create, Retrieve, Update, and Delete (CRUD) operations on a Derby database. |
Developers commonly use tools which generate repetitive code. Eclipse users are familiar with standard tools to generate for(;;) loops, main() methods, and accessor methods for selected attributes. Automating these simple, mechanical tasks speeds up development and makes our lives easier. In some cases, such as generating deploy code for J2EE servers, the code generation may save us time and it may hide implementation-specific complexity which is what makes it possible to deploy to different J2EE servers. Code generation isn't just for large tool vendors, but can be used effectively within many projects. Eclipse's Java Emitter Templates (JET), which is packaged as a part of the Eclipse Modeling Framework (EMF), is a simple and functional way to add code generation to your project. In this article, we will explore how JET can be used in a variety of environments. |
Code generation isn't a new concept. It's been around for a while and has been gaining popularity with the model-driven development (MDD) movement as a way to increase productivity. The Eclipse project has a technology project called JET that is a specialized code generator. JET can generate more than "code," however, and we refer to these noncode things as artifacts in this article. |
The ability to trace your program's execution may prove invaluable when you are trying to hunt down an elusive problem. Although the Eclipse Java Debugger is a powerful tool, there are situations when it just cannot be used effectively. Even during regular program execution, various error conditions can occur, and not necessarily due to bugs in your code. Systematically logging these errors aids in diagnosing the conditions under which a particular error occurred. |
The last menu in your inverse sequence, albeit one that you'll probably frequent the most, is the File menu. Many of its options are resource-oriented. Others, such as Close, Close All, Save, Save As..., Revert, and Print are editor-related (each editor type provides its own implementation of these). New, Import, and Export options bring up their corresponding wizard selection dialogs. The New sub-menu exposes shortcuts to wizards most relevant in the current perspective. (For example, Java perspective will have a new Package, Class, Interface, and the like.) Exactly which New, Import, and Export wizards are available depends on your application and/or the set of installed plug-ins. At a minimum, you can create new Projects, Folders, and plain text Files; import projects from an external location in the filesystem, and import and export preferences and resources to/from archive files or the filesystem. Rounding up the contents of the File menu, Switch Workspace allows you to switch your workspace without having to restart Eclipse, and Exit will let you go home after a good day's work. |
The Eclipse runtime is a dynamic environment composed of numerous plug-ins, or bundles, running in an OSGi-compliant framework (Equinox). The OSGi Alliance aims to provide a sort of "universal middleware" for Java—a service-oriented, component-based environment that provides software vendors with standardized access to a variety of platforms and runtime environments. These properties allow Eclipse to deploy into a number of hardware platforms and operating systems. |
Okay, so now you can identify all the non-externalized String literals to reduce overhead. Of course, in Figure 2 the warnings are displayed for the externalized String literals at their point of declaration. Eclipse provides a notation to add which allows the properly constructed Strings to be ignored as a potential issue. |
This article is the first in a series that will take you on a guided tour of Eclipse. With its recent 3.1 release, Eclipse is solidifying its position as one of the most popular Java development environments and broadening its reach into the rich client space. Its developer community is growing rapidly and the momentum behind Eclipse is strong as ever. In this installment, you will look at Eclipse as a project—what technologies it provides, how it is developed, and who participates in the community around it. This will set up the proper context for subsequent installments, which will focus on more specific topics. |
In the business world, few will question the importance of a good first impression. The initial encounter with someone tends to significantly influence the way you perceive them going forward, be it a new partner, customer, vendor, or employee. As any experienced developer or business user will attest, it is very much the same with software. Although a good marketing image of a product helps attract new customers, it also tends to set up high expectations for the user. |
If you ever tried to build your own Eclipse plug-in, you've seen how the Plug-in Development Environment (PDE) makes the job quite easy. However, PDE won't go too far in helping you create customized user interfaces—you must do that yourself, in Java. Fortunately, Eclipse provides a set of APIs to help you along the way. |
An Install Handler bundled with the Feature that uses it must be treated specially by the Eclipse run-time. While it is possible to contribute an Install Handler through an extension point (org.eclipse.update.core.installHandlers) as an ordinary plug-in, this approach would only make it available for subsequent Feature installs. The other option is to bundle a JAR containing the Install Handler code inside the Feature JAR itself. The Feature JAR is downloaded even before the installation process begins. The platform then provisions a special execution environment for the Install Handler code, one that effectively gives it access to plug-ins org.eclipse.core.runtime, org.eclipse.update.core, and optionally (unless running in the headless mode) org.eclipse.ui. This means that the Install Handler code may interact with the Eclipse UI, but must also be prepared to handle a situation in which this is not available. |
This comprehensive suite of UML design tools is developed by Sparx Systems, an Australian company. The product features full support of the UML2 standard, and is capable of generating and reverse-engineering both Java and .NET code. Support for other languages is also available. The suite provides coverage for all stages of the development process, including requirement management, design, and testing. It comes with plug-ins that allow you to link to your favorite IDE, such as the Visual Studio or Eclipse. Model-driven application development has been around for some time, and although it didn't completely displace smaller, lower-level tools (as some had speculated), it enjoys the support of a number of software development shops. Single-user license fee for the Professional Edition of this product is listed at $199. |
It is important to note that there are now Eclipse pre-configured Workbenches available at the Eclipse download site that have some of these plug-ins features already pre-configured. For pure Java development, I use the "Eclipse Classic" version as the basis of my portable Workbench. At home, I use an older "Europa" version as my baseline because it was pre-configured with PHP plug-ins. |
PMD allows you to check code at any level available in the code view; in other words, at the project, package, or class level. The code check is run by right-clicking on the code level you wish to check and selecting Check Code with PMD from the PMD options: |
The HelloWorld plug-in depends on the org.eclipse.core.resource plug-in and depends on org.eclipse.ui plug-in. To use the import org.eclipse.core.resources.*statement and the org.eclipse.ui.plugin.* in Source 2, you need to define the plug-in IDs of these APIs in the requires tag. |
The readSchemaFile( ) method reads the XML Schema file, one line at a time, replacing the default values for the patterns of the XML version, text, image, data, label, and report tags with the values specified in the XML Schema file. |
I am biased, so I don't get to judge the winner, but I will tell you a bit about each of the nominated products and which product is the winner. One thing all of these tools have in common is that they clearly show that there is a desire to improve the software design and development process and that developers crave larger building blocks and bigger constructs. |
Composite widgets are Scrollable, which means that it is possible to add scrolls to the composite widgets by using the SWT.H_SCROLL and SWT.V_SCROLL constants. |
The Eclipse Foundation's download servers barely cooled off after the Callisto release, and the first milestone build of the next Eclipse version (3.3M1) is already available. As always, the upcoming 3.3 release promises exciting new functionality as well as further improvements to the existing features. With so much on its plate the Eclipse development team requires approximately one full year to complete the release cycle. Does this mean that you, a professional Eclipse plug-in developer, have to wait until June of 2007 to reap all the benefits? No. This tip will show you how to use the latest Eclipse milestone builds to develop applications based on the latest stable release. |
In Eclipse 3.1, the IExtensionTracker interface and a default implementation of it, ExtensionTracker, have been been added to help plug-ins be dynamic-aware without having to repeatedly implement the same extension tracking code. To track UI extensions, a plug-in obtains the appropriate IExtensionTracker from the Platform. For example, a Workbench-wide extension tracker can be obtained through IWorkbench.getExtensionTracker(). Likewise, they also can be obtained for IWorkbenchWindow and IWorkbenchPage. If need be, the plug-in can instantiate and maintain its own ExtensionTracker. |
When Pieter Humphrey, Senior Product Marketing Manager, BEA Systems, was asked why they are joining now they replied that Eclipse has reached critical mass. Eclipse is showing momentum, quality, and independence. BEA wants the ability to influence Eclipse and lead key projects that dovetail with BEA products. |
Starting with version 3.0, Eclipse provides a mechanism to programmatically identify file types based on their actual content. The org. eclipse. core. contenttype. contentTypes extension point can be used to define a content type described by a "describer," which is a class capable of recognizing specific types of content given an input stream. Editors designed to work with a specific content type can be bound to it instead of a file extension. |
The Eclipse Foundation just posted a summary of new IDC research at: http://www.eclipse.org/org/press-release/20071106_cbsurvey.php. The survey was developed to better understand how individuals are using Eclipse and which business models organizations are adopting for software built with Eclipse. More than 1,000 people responded. |
For Java (the only language I will cover here), formatting preferences can be found under Window\Preferences to access the Preferences dialog, and then Java\Code Style\Formatter. Here you will find some common formatting standards pre-installed. |
What makes Eclipse applications most easily recognizable is the Workbench. It is the foundation of applications such as the Eclipse IDE — the main window contains menus, toolbars, and a variety of smaller windows, some tiled, some stacked behind one another. What makes each Workbench application unique is what these windows are and what functionality they provide. |
One of the benefits that Eclipse provides is the ability to run code interactively by using its integrated debugger. Examining variables and expressions while executing code step-by-step is an invaluable tool for investigating problems with your code. This excerpt from Chapter 2 of Eclipse in Action: A guide for Java developers provides an introduction to creating a Java project, running a Java program, and debugging it. |
Eclipse allows the use of multiple versions on the same machine, so you will want to decide if is preferable for you to create new workspaces so that you can continue to use your older version, or simply point to the existing workspaces. Both approaches are accomplished through the Import menu; the difference is whether you select the Copy to New Workspace option. |
The Eclipse Rich Client Platform (RCP) also allows developers to create visually appealing user interfaces. However, most Eclipse UI development today requires an experienced Java developer well-versed in the usage of SWT, JFace, and UI Forms API. Compared to web designers, these are still relatively scarce. |
Even though Eclipse Plug-in projects are essentially set up as specialized Java projects, it is not recommended to modify their Java Build Path settings directly. This is because the Plug-in project configuration is managed by the PDE. Luckily, the Plug-in Manifest Editor provides support for specifying the required Execution Environment for plug-ins. In fact, you can choose more than one. In the Overview page, there is an Execution Environments section that lets you do just that. After you add the desired execution environments to the list, click the Update the classpath and the compiler compliance settings link below it. This will not only update your project's Java Build Path, but also its compiler settings to match the language level corresponding to the selected environment (for example, Java Generics are only supported in J2SE-1.5 and later, the "assert" keyword in 1.4, and so on.) |
You can review and update any of your classpath variables in the Eclipse preferences category Java > Build Path > Classpath Variables. |
As was discussed briefly in Chapter 1, "A First Look at Zend Studio for Eclipse," the concept of perspectives is helpful when you are using Zend Studio for Eclipse in different contexts and different stages of development. You should learn how easily you can define and utilize perspectives, and over time this ability should become second nature to you. |
This chapter discusses the architecture behind the code generated in the previous chapter. Before diving deeper into every aspect of the program, it's time to step back and look at Eclipse as a whole. |
Part I discussed the Eclipse ecosystem: how to run it, how to use it, and how to extend it. In this chapter, we revisit the topic of plug-ins and lay the groundwork for all plug-in development topics to be discussed in later chapters. This chapter answers questions about the core concepts of the Eclipse kernel, including plug-ins, extension points, fragments, and more. All APIs mentioned in this chapter are found in the org.eclipse.core.runtime plug-in. |