You and Your Tools

Bjorn Freeman-Benson, Eric Johnson, Jan Wloka, Gaetan Morice (Sierra Wireless)

Eclipse IDE And Languages - Tools · Long - curated
Tuesday, 11:10, 50 minutes | Great America 1


Two talks about your relationship with your tools: not quite Dr. Phil for tools, but still interesting topics.

Is your metadata lying to you? Our experience building features and products

I like to think of it as the "StringBuffer" problem. With Java 1.4, the String class gained "append(StringBuffer buf)". Old code that appended a StringBuffer to a String now had a more efficient implementation just by recompiling! However, it also meant that even if a JAR could build against both Java 1.4 and Java 1.3, if you built against the later Java, it might not run on the earlier one, because it wouldn't have the new optimized function. In a componentized world, we potentially have this problem in spades, and not just with a single platform, but every feature we ship.

With Eclipse, fortunately, we have a very rich infrastructure for specifying metadata on individual JAR files, and on features. This metadata holds out the promise of huge advantages. We might, for example be able to determine whether or not we can deploy a feature - if we just get our metadata right.

Yet, if we don't use that same metadata in the build process, there's a small chance that the metadata itself will be a lie, all because of the StringBuffer problem. We could, perhaps, sidestep the problem by always building against a fixed platform. To maintain our development agility, though, we want our build environment to be much more dynamic. This talk discusses the steps that we have taken to dynamically provision a target environment for use in building our software.

What if your tools knew when you have done a good job?

You are working in a team changing the code base with other members in parallel. Every change you deliver to the team's repository, is not only affecting the system quality, but also may interfere with changes of other team members. While the development process is chosen very carefully by the team to prevent introduction of bugs and improve system quality, current tools are very limited in dealing with a developer's contribution. They can record code changes, recover deleted resources, and detect textual merge conflicts, but effects of changes on the code base remain unpredictable. Resulting problems are, e.g., (undetected) merge conflicts, ineffective testing, and a high likeliness of introducing bugs.

Change models represent textual edits at the level of program elements, i.e., AST nodes. Every node of a change model, an atomic change, reflects the semantics of the underlying programming language, e.g., add method, change field, and delete class. Change-aware tools can leverage the model to compute structural and behavioral effects of changes. For example, a change-aware unit testing tool can not just provide test results, but also guide the development of new unit tests aiming for a full coverage of change effects.

In this talk fundamental concepts of change impact analysis will be summarized and illustrated with examples from the implementation of a change-aware unit testing tool. Useful change classifications and their application will be presented, and interesting implementation aspects discussed. Two concrete application scenarios from software testing and process-aware change delivery will be used to present the potential of change-aware tools.

Using Clojure language to improve Eclipse plugin development

Clojure is a dynamic and functional programming language that targets the Java Virtual Machine and has many other interesting features. Three of these features offer real advantages for Eclipse plugins development:

Clojure could be used in two ways to help Eclipse plugins developers:

This talk will give a short presentation of Clojure and the advantages that make it a real alternative to Java. Then the talk will focus on the first works we made at Anyware Technologies to use Clojure in Eclipse plugins development. And then the potential of a more advanced use of Clojure in Eclipse will be discussed.

Eric Johnson has been doing professional software development since the late 80's, and Java development since 2000. He has been working at TIBCO Software Inc. since 2001, and is now a principal architect. Eric's role at TIBCO includes looking broadly at strategic engineering questions. Eric's specific areas of focus include governance, XML, OSGi, Eclipse, open source software, and build infrastructure.

Jan Wloka is currently a postdoctoral researcher in the PROLANGS research group at Rutgers University. He works with IBM Research on change-aware development tools and advanced refactoring techniques. This work particularly aims for practical applications of change impact analysis for tool-supporting software quality management. Jan spent several years in developing tool support and IDE extensions for various development activities. He has built refactoring support for advanced programming models, such as role-based and aspect-oriented programs, and worked on IDE extensions for test development and process-awareness guiding developers in agile methods. Jan received his Ph.D. from Technical University of Berlin in 2007, and worked several years in technology adoption projects at Fraunhofer FIRST in Berlin. He has been a speaker at international conferences, like ICSE, AOSD and FSE.

Gaetan Morice is head of the Eclipse Products Team at Anyware Technologies. He leads Eclipse based IDE projects for embedded software tooling that involve lots of cool Eclipse technologies such as EMF, CDT, TM and DLTK. He also leads research efforts on alternative JVM languages use in Eclipse plugins development.

Gold sponsors

IBM Corporation

Windriver logo


Sun Microsystems



BIRT Exchange by Actuate

Silver sponsors

Innovations Software Technology






Innovent Solutions

SAP Business Objects

Hardware Sponsor


Lanyard Sponsor

Intel logo

report a problem with this page