The Visual Editor blog

blog:agile-_stress_testing_a_release_process

2009-08-28T16:54:11-04:00

Sometimes you get on an airplane--or into a release process, and partway through the flight, something exciting happens. You never want this to happen, but sometimes it happens anyway. And it becomes an opportunity to find out just how resilient your processes are.

blog:congratulations_to_eclipse_committers

2010-06-24T17:47:20-04:00

Eclipse Helios is here: Done by 39 project teams, 490 committers, creating/managing more than 33 million lines of code. Congratulations to everyone whose code is in this release and to everyone who helped manage this thing out the door! On time. Again.

blog:creating_a_swt_custom_control_in_scala

2009-04-05T16:49:28-04:00

I recently created a simple custom SWT control entirely in Scala, using some XScalaWT to simplify the UI code, to see how much simpler I could make the code using Scala. Creating a SWT custom control in Java requires quite a bit of boilerplate code. Fortunately, while Scala cannot eliminate all this boilerplate, we will see how it can simplify it some. Of course, suggestions for how to improve it are welcomed in the comments. 8-)

blog:david_orme_hands_eclipse_visual_editor_leadership_to_joe_winchester

2008-04-27T00:01:30-04:00

13 November, 2006, Chicago, Illinois. After three years of successfully leading Eclipse's Visual Editor Project, David Orme is moving on to pursue other activities around Eclipse. In 2003, David founded and led the Visual Editor Project as the first Eclipse project to be started and led by somebody other than IBM. During his tenure, David spoke about Visual Editor at every EclipseCon except for the EclipseCon 2006 where Joe Winchester represented Visual Editor. Most recently, David shepherded V…

blog:declarative_data_binding_using_xscalawt

2009-03-21T22:51:06-04:00

This article builds upon the previous work showing how Scala can simplify SWT user interface development by introducing Declarative Databinding (DDB) for XScalaWT. DDB uses Eclipse / JFace Data Binding under the hood, and was designed with the following features in mind:

blog:duck_typing_helps_automatically_dispose_swt_images

2008-04-26T23:28:58-04:00

Let's look at a really practical example of why Duck Typing is important in Java. This example will use Java reflection to hack duck typing but will provide a basis for future discussion of how to really implement the technique in Java. If you need to make SWT automatically dispose Image objects, here's a simple class that gets the job done quite painlessly:

blog:e4_-_end-to-end_cloud_computing_platform

2009-01-29T18:42:58-04:00

Eclipse and Android have a long history of playing nicely together. So it was only natural that I would buy an Android phone (since ERCP wasn't available when I was looking). I was expecting good things. But I wasn't expecting to be blown away by Android's implementation of cloud computing. In the end, I was blown away and more.

blog:e4_a_first_look

2010-02-05T22:23:34-04:00

I've finally got some cycles to catch up on E4 a bit. The first thing I notice is that in E4, you wind up with a lot of code that looks something like this: (from ) public class View1 { @Inject public View1(Composite parent) { Label label = new Label(parent, SWT.NONE); label.setText("E4 is new"); Text text = new Text(parent, SWT.NONE); text.setText("and different"); } }

blog:e4_and_rcp4_desktop_and_web_from_one_source

2008-06-06T11:45:33-04:00

Back at EclipseCon, one of the big news items had to do with the proposed Eclipse 4, or E4 feature set. But I think that the true story behind E4 isn't just about running Eclipse in a browser, but in something much more interesting than that. The real E4 story E4 isn't just a very cool AJAX framework--it's the ability to write rich client applications that deploy to a desktop or a browser from the same code base.

blog:e4_and_web_2.0_-_is_there_a_better_way

2008-12-24T12:04:44-04:00

In The Web 2.0 - or are we going the wrong way?, Tom accurately compares Web 2.0 with 3270 (and 5250) terminals of yesteryear and wonders aloud if Web 2.0 is really the right way to go technically with E4. This is a good question. What is the right way to go, both politically and technically?

blog:e4_code_bloat_thread

2008-12-24T12:05:11-04:00

The E4 mailing list has recently contained an interesting thread on avoiding and dealing with code bloat. I've archived the complete thread here on my Bliki as Code Bloat Thread from E4 mailing list. If you didn't catch the original thread, it's well worth a read...

blog:e4_sdk_available_-_early_adopter_testers_needed

2010-04-15T12:57:49-04:00

An exciting milestone in the E4 project passed yesterday when John Arthorne posted the following to the E4-dev mailing list: " I have spent the last day or so self-hosting full time using Eclipse 4.0 SDK builds. While there are lots of bugs and errors in the log, I have encountered no impediment that prevented my ability to get work accomplished using these builds as my regular IDE. I strongly encourage the rest of the team, and any bleeding edge adopters in the community, to try use Eclipse …

blog:eclipse_data_binding_ships

2008-05-06T13:30:18-04:00

18 May, 2007 A few minutes ago, Boris Bokowski marked bug 154132 -- “JFace Data Binding” recently renamed “Eclipse Data Binding” as FIXED/VERIFIED. This marks the last step in shipping our initial version of Eclipse Data Binding. I'd like to publicly thank everyone who made this possible: Gili Mendel and the Visual Editor team for helping get this started, Boris Bokowski and Brad Reynolds, the other two committers on the project, and the many other contributors who have helped out on the newsg…

blog:eclipse_editors_for_arbitrary_types

2008-05-06T13:23:14-04:00

Sometimes you can't use an Eclipse view to edit something in an RCP application; there are just times you need to be able to open multiple instances of your editor. Or maybe you need your editable thing to be able to interoperate with Eclipse's resources framework. For example, suppose you're implementing a web browser plug-in for Eclipse. You definitely would like the user to be able to open multiple web browser tabs. But how would you actually code this up?

blog:eclipse_rcp_vs._rcplite_vs._naked_swt

2008-05-06T13:25:06-04:00

When should one code in Eclipse RCP? When should one choose naked SWT? And when should one choose RCPLite, the new middle-ground? I tried to answer some of these questions in the following message I posted to the Eclipse.platform newsgroup. I thought it might help some other folks, so I'm presenting a slightly updated version of it here as well.

blog:eclipse_scala_plugin_progress

2009-05-02T21:50:11-04:00

I just have to say: I've been using a recent build of the Eclipse Scala 2.7.4 plugin and finding it really solid and really productive! * Content assist for the most part Just Works * Ctrl-click to jump to source so far Just Works, regardless of if the source/destination is Java or Scala * And of course, the killer feature: integrating ScalaDoc and JavaDoc seems really stable now

blog:eclipsecon_07_the_community_s_party

2008-05-06T13:26:55-04:00

Why was EclipseCon '07 special? For the first time, EclipseCon was really the Eclipse community's party. * The first EclipseCon was interesting in that the conference itself was successful. * EclipseCon 2 remains the best technical conference I have ever attended and it was really the “Eclipse is Successful” party. Nearly every session blew me away. RCP became more than an acronym; it was real. * Last year's EclipseCon was the first year where EclipseCon wasn't dominated by IBM. But th…

blog:eclipsecon_a_new_and_noteworthy_party

2008-05-06T13:24:26-04:00

I'm sitting in the GMF presentation right now. Last year's EclipseCon was basically an Eclipse RCP party plus a vidication that Eclipse is now really big-time as most important companies in the industry joined as Strategic Developers. This year's EclipseCon has turned into a showcase of just how diverse the Eclipse community has become in just under one year.

blog:emf_as_a_model_description_language

2008-05-06T13:22:35-04:00

As described below, the model used by the Visual Editor Project is based on its own language and widget-set neutral metadata format. As it turns out, this model itself is described using Eclipse's own EMF framework. Advantages to doing it this way include:

blog:emf_as_vep_s_model_description_language_2

2008-05-06T13:23:29-04:00

In a previous entry, I discussed some of the advantages and disadvantages of using EMF as the model-description language in VEP. Here we'll take a quick look at some of the implications of implementing the model this way. The reason why EMF and VEP dovetail so nicely is that visual editors need to be able to describe and access meta-information about the user interface objects that they need to manipulate.

blog:emf_is_social_software

2009-03-31T16:29:15-04:00

What I realized at EclipseCon: EMF is firstmost social software. Fundamentally, it's a better JavaBeans with a performant reflective API. Oh--and unlike java.lang.reflect, they encourage you to use the reflective API. Not surprisingly, the result is that EMF has become the seed out of which a whole lot of really cool meta programming tools have sprung:

blog:gcj_native_java_compilation_and_fully_open-source_java

2008-05-06T13:25:18-04:00

Recently, I have been thinking about the advantages of having native compilation of Java code using GCJ. * Application distribution of native binaries is much easier than worrying about what version of what JVM in how many copies is installed on the target computer. Yet, this could retain Java's “write once run anywhere” capabilities. * The Java open-source community could draw on a larger potential base of co-developers because GNU/Linux developers who insist on a completely free-software…

blog:implementing_login_in_rcp_applications

2008-04-26T21:50:12-04:00

Recently, the eclipsepowered discussion mailing list has been talking about how to implement login in an Eclipse RCP application. In the discussion, I described two major use cases: 1. RCP is a standard framework for deploying corporate applications. Logging into RCP implies logging into all of your corporate applications. 2. RCP is a container for many applications, some of which require a login. Olivier Crameri [olivier.crameri netoxygen.ch] then proposed an elegant soluti…

blog:in_java_5_0_is_not_always_equal_to_0

2008-05-13T11:46:37-04:00

Much to my surprise yesterday, I discovered that Java 5 believes that 0 != 0 in certain situations. Try the following in Java 5: System.out.println(0L == 0); System.out.println(((Long)0L).equals(0)); For me, this prints: true false A little more investigation yields the following implementation in class Long:

blog:java_does_duck_typing

2008-05-06T13:26:08-04:00

As promised, this is the followup to Duck Typing helps automatically dispose SWT Images. Here, we will show how to implement Duck Types in Java. (If you don't know what a Duck Type is to begin with, it would be worthwhile to read the older post and then come back here.)

blog:linux_works._windows_shirks

2008-05-13T11:46:24-04:00

Linux just works. And when it breaks I can fix it. I just got a new Windows machine on Monday. It is already beginning to die the inevitable death of a thousand cuts. I installed Fedora Core 6 on my Sony laptop two weeks ago. I've had two hiccups along the way, but they were both simple to fix, after a brief Google session.

blog:more_xscalawt

2009-02-17T20:53:03-04:00

Here are some more Scala and XScalaWT examples, from recent experiments, for those who prefer simple code examples and don't want to read through the longer tutorial. (As in the previous examples, I'll omit the package statement and imports.) class LoginDialog(display : Display) extends Shell(display, SWT.NO_TRIM) { implicit def unboxText2String(t : Text) = t.getText() var username : Text = null var password : Text = null var ok = false setMaximized(true) // since we're runn…

blog:moved_to_dokuwiki

2008-04-26T17:52:42-04:00

As of April 26, 2008, The Visual Editor is moving to DokuWiki. Old content will be migrated soon.

blog:mylyn_makes_code_presentations_clearer

2009-11-27T18:29:57-04:00

Last week I gave a presentation on refactoring regular Java code toward a Scala DSL to the Chicago Area Scala Enthusiasts (CASE). Along the way, I discovered a really cool way to use the Eclipse Mylyn tool to solve a perennial presenter's problem: how to smoothly switch between various code examples during the presentation.

blog:needed_more_readable_swt_snippets

2008-05-06T13:23:42-04:00

When creating small examples to illustrate a single SWT programming technique, the SWT team has been utilizing what they call snippets, or minimal SWT applications. These are great if you need to see at a glance everything related to the particular application in question.

blog:new_eclipse_does_data_binding

2008-04-27T00:15:22-04:00

In short, you can usually replace pages of SWT event handlers with a single line of code similar to the following: dataBinding.bind(textWidget, new Property(personBean, "name"), null); Many of you have heard that Eclipse's Visual Editor Project and JFace teams have been working together to define a data binding framework for all of Eclipse:

blog:on_collecting_ideas_for_a_simplified_data_binding_api

2008-12-26T09:15:17-04:00

In my previous entry, I referred to Kai's blog where various community members wished for a simpler data binding API and asked for comments. This blog is intended to collect the various proposals I've seen for simplifying data binding into one place so we can discuss their relative merits.

blog:oracle_to_unify_sun_and_eclipse

2009-04-28T22:02:58-04:00

When Oracle joined the Eclipse board nearly seven years ago, it was with the stated intent to unify Sun Microsystems and Eclipse. Assuming that their purchase goes through, they will have the power to actually do this. Will they?

blog:please_pardon_the_dust

2008-05-01T21:27:03-04:00

The Visual Editor is now officially a Bliki, with no apologies to Martin Fowler who also runs a Bliki. :-) For those who track content in an RSS reader, the new URL is

blog:refactoring_to_dsls_slides_posted

2009-11-24T20:34:01-04:00

Slides for last week's Scala meetup presentation in Chicago are posted on SlideShare: The topic was “Refactoring to DSLs (for beginners)” and “Scala LiftOff 2009 Recap”.

blog:review_contributing_to_eclipse

2008-04-26T22:06:32-04:00

With the pending release of the Eclipse Rich Client Platform (RCP), Contributing to Eclipse; Principles, Patterns, and Plug-ins by Erich Gamma and Kent Beck is now more relevant than ever. Most technical books are like road maps, showing you the various ways to get to specific destinations, but offering little in the way of guidance about the best route. Contributing to Eclipse; Principles, Patterns, and Plug-ins by Erich Gamma and Kent Beck, on the other hand, is like taking a tour with a prof…

blog:simplifying_swt_with_scala

2009-02-12T21:08:06-04:00

Previously, I promised to show how to radically simplify SWT user interface development using Scala. In this article, we will examine how to do just that. Our approach will be as follows: * I will present a Java class designed to plug into the Scala RCP application we created previously. * We will translate that Java class into Scala using as close to a 1:1 representation as is reasonable. * We will repeatedly ask, “Can we make the Scala code nicer?” and incrementally improve our examp…

blog:speaking_at_chitown_scala_meeting

2009-11-14T21:23:32-04:00

I'll be speaking at the Chicago Area Scala Enthusiasts (CASE) meeting this coming Thursday. We'll cover the following: * News from the Scala LiftOff East in Reston Virginia two weeks ago * I'll talk about using DSLs written in Scala to improve Java projects

blog:successor_to_cvs_subversion_ain_t_it

2008-12-24T12:05:49-04:00

For the non-Eclipse-committers out there, there's been an interesting conversation proceeding on the committer mailing list. Since it's off-topic for the list, I'm replying on my blog. On the mailing list, the question was: If SVN is a poor substitute for CVS, what should we use instead? The answers ranged from:

blog:suggest_a_simpler_data_binding_api

2008-12-24T12:06:46-04:00

Over on Kai's blog, he describes how to implement data validation decorators using JFace Data Binding. In the comments, a whole lot of people complained that because the data binding API is very general, it does not yield code that is very intentional.

blog:surviving_and_thriving_in_the_software_business

2008-05-06T13:25:30-04:00

LinuxWorld 2005 was my first LinuxWorld. Although I've been running a 100% Linux shop since '98 and first installed Linux on one of my computers in '95, I haven't made it to a LinuxWord before now. The reasons for this are long and varied, but mostly boil down to:

blog:swt_graphical_unit_tests_are_easy

2008-04-27T00:14:41-04:00

11 December, 2007 I can't believe how long it's been since I've posted! Wow. Guess time flies when you're having fun, which I've been having a lot of lately. My new contract is to help make RCP the de facto standard graphical interface platform worldwide at a major Fortune 500 firm...

blog:the_ideal_application_architecture

2008-04-26T22:21:23-04:00

Recent, Ed Burnette of EclipsePowered identified several options for what the application platform of the future might look like and solicited feedback about what the rest of us thought would most likely be the winner. His choices were: * More and more clever use of DHTML in web browsers, e.g., oddmail, outlookwebaccess, bindows * A rejuvinated Browser War that spurs lots of innovation in browser enhancements, e.g., Apple Dashboard, what-wg * Standards group innovation plus better stan…

blog:the_visual_editor

2008-05-06T13:22:01-04:00

The very concept of graphically creating new software excites our imaginations, invoking visions of manipulating pictoral representations of code as effortlessly as we think. We dream of The Matrix, of Cyberspace (from William Gibson's Neuromancer), of floating effortlessly through space and time, commanding reality to do our wishes. Unfortunately, the reality is not quite this romantic.

blog:the_way_forward_for_xswt

2009-03-09T23:17:21-04:00

Given all the discussion around modeled UI in the Eclipse E4 (Eclipse 4.0) space and my recent talk about XScalaWT, I received an email wondering aloud what will happen to XSWT (hosted here). Here's more or less what I wrote in response: XSWT will graduate XSWT is going to morph into something else as its ideas are adopted into E4. The result is that what we know today as XSWT is splitting into two development streams:

blog:using_scala_to_create_eclipse_rcp_applications

2009-02-09T22:55:25-04:00

There have been previous descriptions of how to use Scala to create an OSGI bundle, how to configure the PDE for building Scala-based plugins, and how Scala integrates very cleanly with Java. Here, we will describe a pragmatic approach for developing real-world RCP applications using the current Scala and PDE tooling. We will see that if we follow some common-sense coding guidelines that incorporating Scala code into an RCP application is not very different from creating our plug-ins in Java…

blog:using_the_eclipse_2.1_look_and_feel_in_rcp

2008-04-26T22:09:12-04:00

As illustrated by the following snippet, RCP apps can invoke the Eclipse 2.1 theme programatically via the preference settings: IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore(); IPreferenceStore internalStore = PrefUtil.getInternalPreferenceStore(); apiStore.setValue(IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID, "org.eclipse.ui.internal.r21presentationFactory"); internalStore.setValue(IPreferenceConstants.VIEW_TAB_POSITION, SWT.BOTTOM); apiStore.setValue(…

blog:view_versus_editor_in_rcp

2008-12-24T12:05:30-04:00

At , Prakash describes the following distinctions between views and editors: * Editors contribute to the global action bars, and views to its local action bar. * In the layout, editors have a special place called editorArea where all the editors will go. Views can go anywhere else, including fast views, detachable ones, etc.

blog:what_can_we_learn_from_visual_editor_project

2008-05-06T13:27:05-04:00

April 17, 2007 Several times, folks have blogged (primarily at EclipseZone) about the demise of funding for the Visual Editor Project team and the challenges that leaves us with: * Lack of Eclipse 3.3 compatibility * No support for new SWT and JFace features * No support for Eclipse Data Binding

blog:write_uis_more_easily_with_fp

2009-06-08T10:08:30-04:00

At EclipseCon, I had some amazing conversations with various people about the potential to use EMF and modelling technologies to raise the abstraction level, and therefore programmer productivity, when creating user interfaces. Since then, I've realized that XScalaWT can do all this already, for free, as long as you favor convention over configuration in your code...

blog:xscalawt_stylesheets

2009-03-05T00:38:27-04:00

Tonight I finished a first cut at adding style sheet support to XScalaWT. I'm interested in peoples' thoughts/suggestions on the syntax and so forth. Here's how to define a style sheet in XScalaWT: val WHITE = Display.getDefault.getSystemColor(SWT.COLOR_WHITE) val RED = Display.getDefault.getSystemColor(SWT.COLOR_RED) val INVALID_INPUT="INVALID_INPUT" object loginStyles extends Stylesheet( $[Control] ( // all Controls have a white background _.setBackground(WHITE) ), $cla…