Wednesday, December 3, 2008

On EclipseCon Idol...

The submission deadline for EclipseCon 2009 has come and gone, and now the program committee has the unpleasant duty of selecting from among the many excellent submissions. But, like all good reality shows, you, the "viewer", get to provide input on what you think should be selected. Don't let your favorite submissions "get sent home"! Providing feedback will not only make the program committee's job easier, but will help ensure that the talks YOU want to see make it onto the program.

I've submitted several proposals this year (see below), and I'd like your feedback. Please follow the link to the EclipseCon submission system to post any comments you may have.


Representational State Transfer (REST) is a style of software architecture for distributed hypermedia systems such as the World Wide Web. However, it is possible to design any enterprise software system in accordance with the REST architectural style without using the HTTP protocol and without interacting with the World Wide Web. Systems that follow the principles of REST often referred to as RESTful. Proponents of REST argue that the Web enjoyed the scalability and growth that it has had as a direct result of a few key design principles. Among these principles are the notions that application state and functionality are divided into resources and that every resource is uniquely addressable using a universal syntax for use in hypermedia links. Another key principle of REST is that all resources share a uniform interface for the transfer of state between client and resource, consisting of a constrained set of content types and a constrained set of well-defined operations.

The Eclipse Modeling Framework (EMF) provides a Java runtime framework and tools for generative application development and fine-grained data integration based on simple models. Models can be specified directly using EMF's metamodel, Ecore, or imported from other forms, including UML and XML Schema. Given a model specification, EMF can generate a corresponding set of Java interfaces and implementation classes that can easily be mixed with hand-written code for maximum flexibility. When deployed, applications developed with EMF benefit from a powerful and extensible runtime, which, among other features, includes a persistence mechanism which has always supported the principles of REST – perhaps even before the term "REST" became popular.

This tutorial will provide an introduction to EMF, including alternatives for specifying a model, EMF's code generation tools, and key runtime framework concepts. As a practical usage of this knowledge, the presenters will show how EMF can be used to build RESTful applications, exploring some best practices for working with resources and other features of the framework.


The Model Development Tools (MDT) project focuses on big "M" modeling within the Modeling project; its purpose is twofold: 1) to provide an implementation of industry standard metamodels and 2) to provide exemplary tools for developing models based on those metamodels. Since its launch in September of 2006, MDT has undergone two major releases and is now working towards its third release as part of the 2009 Galileo Simultaneous Release. This short talk will provide an overview of the new features and components/projects in MDT and give an update on the status of its Galileo release.


In order to enable the much needed agility demanded by today’s marketplace, business functions and associated processes must be supported by semantically accurate and reusable information, i.e. data and its associated metadata. A data model is an abstract model that describes how data is represented and accessed. Data modeling is the process of creating a data model instance by applying a data model theory, typically to solve some business enterprise requirement.

Data model instances can be categorized into various levels or perspectives, including contextual data models which identify entity classes, conceptual data models which define the meaning of things in the organization, logical data models which describe the logical representation of properties without regard to particular data manipulation technology, physical data models which describe the physical means by which data are stored, data definitions which represent the coding language of the schema on the specific development platform, and data instantiations which hold the values of the properties applied to the data in a schema.In this short talk, we’ll take a look at examples of each of these kinds of data models and explore how they are supported by projects/components at Eclipse.


There is a long standing rift between software modelers and data modelers. You say class, I say entity; you say property, I say attribute; you say association, I say relationship; etc.. This long talk will take a candid look at the differences (and similarities) between UML and E/R modeling, and offer insight into what is being, or could be, done at Eclipse and elsewhere to reconcile the two. You might be surprised to learn that the divide between software modelers and data modelers isn't as great as you thought.


Last year, two symposia were held jointly by Eclipse and the OMG to focus on the synergies between open source and open specifications and to discuss how the joint future of Eclipse and the OMG can be shaped. By all accounts, both were quite successful. So, now what? Well, a lot of really useful feedback was shared, but not much has changed since then. The bottom line is that the status quo will no longer suffice. Design by committee and vendor politics won't get anyone anywhere. Neither will closedness and opaqueness. This long talk will review the feedback from the first two symposia and will compare and contrast the Eclipse and OMG ecosystems to identify concrete measures that can be taken to improve the state of affairs.

Tuesday, December 2, 2008

On Rage...

No, I'm not talking about anger (although, not unlike Ian, I do sometimes feel the need to rant)... I'm talking about CodeRage III, CodeGear's annual virtual developer conference (hosted by Embarcadero Technolgies). It's happening right now. All week. And it's free. Details can be found on the session schedule page. Which sessions have you attended? Which ones do you plan to attend? Did I mention that it's free? ;)

In case you're interested, Ed Merks and I will be delivering Eclipse-related sessions at CodeRage III on Wednesday. My session, entitled "Towards Data Model Interchange and Traceability", is from 5:45 pm to 6:45 pm PST. I know, it's late for those of us on the East coast... but hey, this is a global conference! Ed will be giving his infamous stupid modeling talk ("The Unbearable Stupidity of Modeling") right after mine, from 7:00 pm to 8:00 pm PST. Hope to "see" you there! Rage on!

Monday, December 1, 2008

On December 3...

It's been especially difficult for me to keep my head above water these days. So much is going on, at times it's hard to decide what to focus on and when. Eclipse Summit Europe was already two weeks ago now, the Ottawa DemoCamp was last Thursday, submissions for EclipseCon 2009 were due on Friday, CodeRage III is this week, and there's an OMG Technical Meeting next week. I'll try to blog about each of these if/when I find a spare moment...

And that's just conferences. In terms of my "day job", this is a big week for modeling and design solutions at Embarcadero. Three of my products, ER/Studio, ER/Studio Enterprise Portal, and EA/Studio are all releasing new versions on Wednesday. I've blogged before about how lucky I am to be part of such a great team, but this time around the challenges we persevered were so numerous it was almost laughable. My partner in crime, Jason Tiret, will be hosting a webinar on Wednesday to talk about what's new in database modeling at Embarcadero. You ought to check it out!

Sunday, November 16, 2008

On Ludwigsburg...

Wow, it's hard to believe that the last time I blogged was nearly two weeks ago. Where has the time gone? Seeing as I wrote my last blog entry from my hotel room in Reston, Virginia on the eve of EclipseWorld 2008, is seems rather fitting that I write this, my next blog entry, from my hotel room in Ludwigsburg, Germany, on the eve of Eclipse Summit Europe 2008. As a colleague of mine, who shall remain nameless, might say, "I'm so filled with joy for Eclipse Summit Europe that I cannot contain it!".

Like Ed, it looks as though I may need to clone myself in order to participate in everything I want to here at ESE. I haven't decided yet which talks I'll attend, but I suppose I had better do that soon, before things get really busy. At this point I know I'll be participating in the Eclipse Members' meeting tomorrow (Monday) and the Modeling Symposium on Tuesday.

On Wednesday, I'll be delivering two short talks. The first, entitled "Data Models at Eclipse", will provide an overview of the different kinds, or levels, of data models and explore how they are supported by projects/components at Eclipse. The second, "What's New in MDT?", will provide an overview of the Model Development Tools project and, in particular, some of its noteworthy recent additions. If you're going to be at the Summit, I hope to see you there. Of course, if you can't be there for whatever reason, you can always view the slides from the submission page(s)...

Monday, October 27, 2008

On Separation Anxiety...

You gotta keep 'em separated. Or so says conventional wisdom (and the song). One of the homework items for this week's UML Roadmap working group meeting was to propose a solution to the 'separation of concerns' problem in UML. I would argue that this, like many other problems with UML, is actually a symptom of more fundamental issues with the way specifications are defined/developed at the OMG, and that we ought to address these issues before it’s too late (if it isn’t already).

The bottom line is that the status quo will no longer suffice. Design by committee and vendor politics won't get us anywhere. Neither will closedness and opaqueness. In his webinar on ecosystem development the week before last, Mike suggested that ecosystems could be evaluated on the basis of five key concepts (see below). In order for the ecosystem of specifications (languages) that exists at the OMG to survive, I'd say its health in these areas needs to be measured and improved.

Co-evolved innovation. There's certainly a lot of innovation happening at the OMG, and by a lot of players. But sometimes I wonder how relevant the innovation is (in the absence of reference implementations) and how coordinated the activities are (sometimes chairing a task force seems a lot more like cat-herding than coordinated evolution).

Alignment of Vision. The OMG has a vision - MDA (Model Driven Architecture). But how aligned are the various OMG specifications with this vision? How long will the industry wait for it to be realized?

Degree of openness. The OMG is an open organization, in the sense that its reason for being is to produce open specifications. But its processes are less open than other organizations like Eclipse, and that has garnered it some negative press. To borrow from Bjorn's analogy, I think the OMG would benefit from being an openness bear that's "just right".

Degree of modularity. I think this is at the heart of the 'separation of concerns' problem. Languages like UML and its relatives are in fact designed to be modular - they're structured as sets of packages, or "capabilities" and then merged into various compliance levels... but something went wrong along the way, because subsets of these languages aren't as reusable as they were originally intended to be.

A network of niches. A set of vertices without edges is not a graph - it's just a set of vertices. I think many of the niches (UML, BPMN, IMM) are falling into place at the OMG; now, we just need to connect the dots.

Mike also talked about the importance of an open, extensible platform as the basis for a successful ecosystem. I think that's what's missing in the OMG ecosystem. Yes, it has MOF, but that's not a platform on its own; MOF is to the OMG as OSGi is to Eclipse. The OMG needs a platform (a working version of what the InfrastructureLibrary in UML was intended to be) upon which MOF-based languages can be built.

So, here's what I think should be done to solve the 'separation of concerns' problem in UML. Direct the renewed interest and energy in "fixing" UML toward defining a platform of shared concepts upon which UML (and other specifications like BPMN and IMM) can be based. Implement (yes, implement!) a proof a concept that demonstrates the benefits of refactoring UML based on this platform using mechanisms from the emerging Diagram Definition and Semantic MOF specifications, and extrapolate to infer how the same benefits could be reaped by other specifications like BPMN and IMM. Then, and only then, submit responses to the RFPs for Diagram Definition, Semantic MOF (MOF 3.0?), and UML 3.0.

Some say that making changes like this will only serve to disrupt the industry, to scare away the vendors and users once and for all ("they waited forever for UML 2.0; if we propose UML 3.0, we'll lose them for good!"). That's just FUD, if you ask me and, well, desparate times call for desparate measures. The way to avoid this disruption is to make the changes in a more open and transparent way than before, for example, in a project at Eclipse. Of course, we'd try to maintain backward compatibility if at all possible or, at the very least, provide an explicit migration path for existing tools. But let the (proven) technology speak for itself. If we build it, they will come. The time is now.

Friday, October 24, 2008

On Where I'll Be Next Week...

EclipseWorld 2008, of course! It's shaping up to be a great conference, and three of my colleagues and I have the distinct honor of being on the "expert faculty". We'll be delivering technical classes on a variety of topics important to application developers and database professionals. Our presentations will explore concepts such as software archeology, delve into architectural styles such as REST, and provide how-to guidance for database development, data modeling, and application factories in Java.

Scott Walz, senior director of product management, will deliver a class entitled "Classic Database Development Mistakes Made by Java Developers — and Five Ways to Overcome Them" on Wednesday at 3:15 pm. In this session, Scott will outline the five most common databas development mistakes made by Java developers and offer specific direction on how to overcome them.

Ravi Kumar, principal architect, will deliver a class entitled "How to Implement Application Factories in Java" on Thursday at 8:45 am. In this session, Ravi will utilize real-world examples to demonstrate how to build an end-to-end Web application with core capabilities, from database table all the way to presentation.

Michael Rozlog, JBuilder evangelist and co-author of “Mastering JBuilder", will deliver a class entitled "I’ve Just Inherited 1,000,000 Lines of Java Code — NOW WHAT?" on Thursday at 10:30 am. In this session, Michael will help developers understand the concepts behind software archeology and the tools used to support it, as well as explain how to apply the techniques of static and dynamic analysis in the real world. This session has been selected as one of the nine hottest classes at EclipseWorld.

I will be delivering a class entitled "Data Models for Java Applications" on Thursday at 8:45 am and another entitled "RESTful EMF" at 10:30 am. In the first session, I'll be reviewing the various types of data models and exploring how they are supported by projects at Eclipse. In the second session, I'll be providing an overview of Representational State Transfer (REST) and discussing how Java programs can be developed in accordance with the REST architecture style using the Eclipse Modeling Framework (EMF).

In addition to the two technical classes on Thursday, I'll also be doing a Model Development Tools (MDT) project demo between 8:45 and 9:00 pm at the Eclipse Foundation party on Wednesday. I'll be giving a sneak preview of some of the technology soon to be contributed to Eclipse as part of the newly created Papyrus component and will also offer insights into more new subprojects on the horizon.

Where will you be next week? If your answer is the same as mine, I hope to see you there!

Friday, October 17, 2008

On Beginnings and Ends...

So far, it seems that Microsoft's participation at the OMG is more like the end of the beginning than the beginning of the end. Pariticipants in the UML Roadmap working group met on Tuesday to discuss everybody's top three problems/concerns with UML, and there seems to be a concensus that most of the issues fall under a general theme of separation of concerns. More homework has been issued for the next call (to take place in two weeks); this time, the  assignment is to provide feedback on a proposal to develop an integration architecture that would support a family of related languages (wasn't that what MDA was supposed to be?) and to make alternative proposals for addressing the "Separation of Concerns" problem in UML. Any ideas?

Speaking of beginnings and ends, there have been some bitter-sweet changes in the MDT project recently. Termination reviews for the EODM and OCL Tools components were "successful" as of last Wednesday (since nobody from the community requested a formal review), and so both have been archived. The OCL Tools component was actually never completely provisioned, so all that remains of it is a page in Eclipsepedia. EODM, on the other hand, was a more or less functional component for several years, but unfortunately it no longer had a community of developers to maintain it (despite a small but interested user community). The Eclipsepedia page for EODM also remains, and its newsgroup and mailing list have been archived, as have its downloads. Luckily, a proposal for a new ODM implementation at Eclipse is in the works; stay tuned for details.

On a positive note, there have been a couple of new beginnings in MDT. The Papyrus component has now been successfully created, and provisioning is nearly complete. The initial project team (one of the largest and most diverse that I've seen at Eclipse) has plans to provide a code contribution sometime in November; for more details, see the newsgroup or mailing list. Also, the proposal for a new Metamodel Specification Tools (MST) subproject in MDT has finally been declared. If you're interested, please join in the newgroup discussion or drop me a line!

Thursday, October 9, 2008

On Ducks...

All things in my world seem to be pointing toward ducks lately. I just unlocked the "Quacker" bike in Mario Kart Wii, I got a random sales call from Black Duck Software, and I stumbled upon the concept of duck typing for the first time. All on the same day. I've always been a firm believer, as Red Green often attested, that duct tape is indispensable. But now I'm starting to wonder whether all those years he was saying "duck type". If duct tape is a handyman's secret weapon, should duck typing be a programmer's secret weapon?

So what is duck typing? It's the notion that if something walks (waddles) like a duck and quacks like a duck, then it can be assumed to be a duck. Duck typing, commonly used in languages like Ruby and Python, is a style of typing where an object's current set of methods and properties, rather than its inheritance from a particular class, determines its semantics. Duck typing really isn't all that new - it's really about dynamic versus static typing. Real programming languages like Smalltalk have supported this concept for a long time. ;)

Who decides what the definitive characteristics of a duck are? Does something need to look like, dress like, or weigh as much as, a duck to be a duck (or a witch, as the case may be)? Does it have to feel, smell, and taste like a duck to be a duck? If "beauty" is in the eye of the beholder, does the beholder get to decide what a duck is? Is it a matter of perception?

After reading about duck typing, I got to thinking that it might be one approach to resolving the issue of unintended inheritance in UML. What if, rather than specializing metaclasses from a common infrastructure, or merging them into a hybrid representation using package merge, related languages could simply declare what they assume the definitive set of shared characteristics for each metaclass (duck) is? Should a metamodel perhaps be simply a selection of mixins rather than a complex heirarchy of (base) classes?

Tuesday, October 7, 2008

On What's Wrong with UML...

Sure enough, I had an inevitable encounter with said company the week before last at the OMG technical meeting in Orlando. As Steve Cook said, he was welcomed with mostly open arms. The Analysis and Design Platform Task Force meeting was a little more interesting than usual because Steve had the gumption to point out many of the problems that exist with UML. I'm glad he did. Although many of his observations weren't a surprise to all of us, with any luck his fresh perspective will inspire the UML community to act rather than sit around and pontificate...

One of the things that came out of the Orlando meeting was the formation of a UML Roadmap working group, participation in which is open to any OMG member. As homework for today, participants were asked to come up with the top three things that they feel are wrong with UML. I'm sure many will cite complexity as a major problem with UML, but as I've said before, I think this failure is largely in the tools, not necessarily the metamodel. Rather than been passing the complexity of UML on to the end user, vendors should work smarter (not harder) to find innovative ways to make consumable products.

I don't claim to know everything about UML, but after spending several years developing and maintaining the de facto reference implementation of UML at Eclipse, I have a few opinions about what's wrong with the language. While difficult to choose only three, here's what I think my picks (mostly related to interchange) are.

1. Un-intended inheritance

The hierarchy of metaclasses in UML is deep and wide, and riddled with multiple inheritance. The designers of UML strived for a rich architecture with many reusable levels of abstraction; unfortunately, one of the side-effects of such a design is that concepts which make sense in one context (metaclass) are unintentionally inherited in another (metaclass). This is further exacerbated by package merge, which combines mutltiple flavours of a metaclass, from various contexts, into one overloaded representation.

2. Undefined namespaces for standard stereotypes and primitive types

The UML specification defines standard stereotypes for use in its higher compliance levels, but fails to define a normative URI via which the profiles containing them can be referenced. Similarly, UML defines a set of four standard primitive types, but rather then defining a model library with a normative namespace URI so that they can be reused, it merges them into the langage itself, forcing other related languages to do the same.

3. Inability to create a usable XML schema for UML

Currently, it's not possible to produce a working XML schema for UML because of its extensive use of multiple inheritance. Even with a schema produced using the XML extension mechanism a copy-down inheritance, a given UML instance document couldn't be validated, because UML doesn't make a consistent distinction between base classes and mixin classes.

Here's hoping this new working group will bear some fruit.

Wednesday, October 1, 2008

On Plans...

What's that expression again? Luck is what happens when preparation meets opportunity. I was reminded of this cliche recently while reading The Last Lecture by Randy Pausch (a must read). How lucky are you? To be prepared, I think you need to have a plan.

I've been spending a lot of time planning lately. So much that I've had little time to come up for air. In addition to looking at what I'd like to release in the next versions of ER/Studio, ER/Studio Enterprise Portal, and other Embarcadero products in 2009, I've been looking at what will be part of next year's incarnation of MDT as part of the Galileo simultaneous release in June.

Plans for Eclipse projects were due yesterday, and I'm pleased to say that the MDT component leads were able to pull together plans for the MDT components just in time. There's a new, standard format for plans now, which I think is a good thing. One of the nice aspects of the standard plan format is that much of a plan's content can be populated dynamically using Bugzilla queries. Projects like EMF have been doing this for years; I'm glad that more projects will now be able to take advantage of this time-saving approach to planning.

Unfortunately, one of the not-so-nice aspects of the standard plan format is that much of a plan's content can be populated dynamically using Bugzilla queries. I'm cool with the notion that a plan is a "living document", and that using Bugzilla queries allows plan items to transition from "proposed" to "committed" or "deferred" without having to update the document. But this approach also allows bugs to be added and removed from a plan without an easily consumable record of these changes or why such decisions were made. Where's the accountability? In my mind, a plan is not just a document that you can point to at the end of a release to say what you ended up actually doing - that's what release notes are for.

One of the challenges I encountered early on while trying to put together the plans for my MDT components was the desire to view a plan after a release and have it still accurately reflect what was originally planned. Depending on how the Bugzilla queries in a plan are written, it seems that items (particularly ones with version-agnostic target milestones like "M6") which are on the plan for one release could conceivably disappear from that plan and reappear on the plan for a subsequent release. In the absence of the ability to assign multiple target milestones in Bugzilla (one of the features of JIRA that really like) I realized that I needed a way to tag a bug such that it would always be affiliated with the plan for a given release.

I proposed the introduction of a 'galileo' keyword (for bugs that are part of the plan for the Galileo release), but some folks were concerned about the proliferation of keywords (because they are global elements in Bugzilla). Then Denis suggested an even better idea - a 'galileo' flag that could be made available only for projects that wanted/needed it. As it turns out, it's quite a useful thing. Not only can I now tag bugs as being committed (galileo+) or deferred (galileo-) items on my Galileo plan (in perpetuity), I also have a way of marking bugs that get fixed in the Galileo release but weren't originally on my plan (indicated by the absence of the 'plan' keyword). Thanks, Denis!

Thursday, September 11, 2008

On Neighborhoods...

I was right! This is the beginning of the end (or is that the end of the beginning?). Said company has joined the OMG... I guess it's only a matter of time before they finally join Eclipse. There goes the neighborhood. ;)

Wednesday, September 3, 2008

On The Chrome Effect...

With all the buzz around Google Chrome, I couldn't help but try it out myself. For a beta, this thing already seems fairly complete. To test that theory, I tried to see how hard it is to add a custom search provider to Chrome. The answer? Not hard at all.

First, select the 'Options' item from the customize/control toolbar menu (the one with the wrench on it).




You'll see a dialog like the one below.




Next, click on the 'Manage' button. You'll see another dialog, like the one below.




Now click on the 'Add' button, and enter the specifics for your custom search engine in the dialog that appears. In my case I added "ER/Studio Enterprise Portal" for the name, "ersportal" for the keyword, and "http://webportal.embarcadero.com/ersportal/SimpleSearch?PV=%s" for the URL. The '%s' is a placeholder for the search terms.




That's it! Now, you can make your new search provider the default if you want, but that's not necessary. Chrome has a super-smart URL field that supports both searching and browsing. All you need to do is type the keyword for your search provider ("esrportal" in my case) and you'll be prompted to press the 'Tab' key to search using it ("ER/Studio Enterprise Portal" here).




Press the 'Tab' key, type in your search term (I typed "customer"), and presto!



I'm sure there will be a never-ending debate about whether the world really needed a new browser... but I don't care. So far, I've been impressed by what I've seen.

Saturday, August 30, 2008

On Resources...

As I put the finishing touches on one of my presentations for EclipseWorld 2008 on this, the last day of blaugust, I'm reminded of how far the resource model in EMF, and in the Eclipse platform itself, for that matter, has come over the past few years. Nearly gone are the days where applications assume that everything is on the local file system or that a file extension dictates the content of a resource...

And, after reading Kevin's blog entry about declarative styling, I'm excited about how much farther we may yet be able to go. e4 will indeed change the way we, and the industry as a whole, think about Eclipse; if it doesn't, I believe it will have failed. I'm anxious to start making contributions, particularly in the area of the new platform's resource model. How do you plan on contributing to the future of Eclipse?

Friday, August 29, 2008

On Conferences...

As Ian pointed out recently, it's almost conference season again. Although I'm not sure whether I've recovered from the last one yet (EclipseCon 2008, the Washington and Ottawa OMG technical meetings, and two Eclipse/OMG Symposia), my autumn is shaping up to be a busy one. So far I'm committed to attending OMG technical meetings in Orlando and Santa Clara, and I'll be speaking at EclipseWorld 2008 in October.

I'm also hoping I'll be able to attend Eclipse Summit Europe (in November) for the first time this year. I've submitted a few talk proposals, so with any luck one (or more) of them will be accepted. If you're thinking of submitting a talk, now is the time to do it, as the deadline is on Monday! The Modeling symposium on the day before the summit should also prove to be interesting. It sounds like Ed will be there too, as will many of the usual Modeling suspects. Come join in the festivities!

Thursday, August 28, 2008

On Good Intentions...

They say that the road to you-know-where is paved with good intentions. Unfortunately, good intentions aren't enough to sustain a project at Eclipse. As I've said before, to be successful, an Eclipse project must adequately address its three communities (contributors/committers, users, and adopters). This takes work.

We've had to make some difficult decisions in the Modeling project lately, to deal with some projects/components that didn't quite pan out as they were originally intended. To be clear, Eclipse is not a hosting facility (i.e. dumping ground). It's an ecosystem where like-minded individuals can work together to build extensible frameworks and exemplary tools.

In the Modeling project, we like to think of it being relatively easy to create a project, but hard to keep one. We don't want to stifle innovation, but at the same time we hold our projects to the same high standards that Eclipse had gained a reputation for. The mechanism for creating Modeling projects may change a little now that the new Eclipse development process has been approved, but our attitude will remain the same.

The good news is that, while some projects fade away, new projects are always on the horizon. The Papyrus component of MDT was recently approved for creation (stay tuned for the announcement), and a couple more proposals for new MDT subprojects are in the works. If you're interested in being part of the excitement, let me know!

Wednesday, August 27, 2008

On Schedules...

The Pentaho BI Platform, on which ER/Studio Enterprise Portal is based, makes use of a Quartz database to schedule its jobs. Quartz is a full-featured, open source job scheduling system can can be integrated with virtually any Java application.

Unfortunately, the schedule administration interface provided with Pentaho is somewhat cryptic (and hence difficult to use), in part because it uses cron expressions to specify job schedules. There are several tutorials on cron triggers available on the Internet, so I won't provide a full tutorial here. However, I thought it would be helpful to describe what the format of a cron expression looks like and show a few examples that might be useful to, for example, set up a schedule for the synchronization of the reporting database with the ER/Studio repository database.

A cron expression is a string of six or seven fields separated by white space. Specific values, as well as certain special characters, are allowed for each field, as follows:

  • Seconds : values are 0-59, special characters include , - * /
  • Minutes : values are 0-59, special characters include , - * /
  • Hours : values are 0-23, special characters include , - * /
  • Day of Month : values are 1-31, special characters include , - * / L W
  • Month : values are 1-12 or JAN-DEC, special characters include , - * /
  • Day of Week : values are 1-7 or SUN-SAT, special characters include , - * / L #
  • Year (optional) : values are 1970-2099, special characters include , - * /

I won't go into detail on all of the special characters, but * means "all values" and ? means "no specific value" (useful when you want to specify either day of month or day of week but not the other). Here are some examples:

  • 0 0 0 * * ? = midnight every day (the default schedule in the portal)
  • 0 30 1 L * ? = 1:30 AM on the last day of every month
  • 0 0 2 ? * 0#3 = 2:00 AM on the third Sunday of every month
  • 0 0 * * * ? = every hour

It's important to note that schedules between midnight and 1:00 AM can result in either a skip or a repeat depending on changes due to daylight savings time.

On Changing Tack...

In the world of sailing, the term 'tack' is fairly overloaded. In one sense it refers to the front bottom corner of a sail, in another it refers to the side of the boat on which the main sail is being carried (relative to the wind), and in yet another sense it refers to the action of turning the boat through head to wind (e.g. changing from a port tack to a starboard tack). When on a windward leg in a race, it's important to pay attention to variations in the wind direction that may force you to point the boat closer to the wind ("head up") or further away from the wind ("bear away") in order to stay on a close hauled (i.e. fast) point of sail. In sailing terminology, these are referred to "lifts" and "knocks". Generally, a knock on one tack corresponds to a lift on the other tack, so if you're frequently getting knocked, it's advantageous to tack (see, I told you the term was overloaded).

I've found that the same often applies in software development - a change in the way you are attempting to solve a problem can put you in a better position than you would have been with the original approach. I have been "knocked" for over a week now trying to regenerate the source code for the UML2 component of MDT in a runtime workspace. I've always done it this way because I typically need to use recent changes in UML2 itself to regenerate the UML2 source code. No matter what I tried (clean workspace, more memory, builder settings) I could not get one of the code generation templates to compile. What was most frustrating was that the same template compiled successfully in my development workspace.

So, I decided it was finally time to change my approach and make use of a PDE enhancement that was made as part of the recent Ganymede release. I used the 'dropins' folder as my workspace (e.g. -data "C:\Eclipse 3.4 MDT Galileo\eclipse\dropins") and the settings for my runtime workspace as the development properties (e.g. -dev "file:C:/Eclipse 3.4 MDT Galileo/eclipse/dropins/.metadata/.plugins/org.eclipse.pde.core/MDT/dev.properties") and, voila, I was able to bootstrap UML2 and my template compiled successfully. Not only did this solve my problem, but it also means I have one less workspace to configure and maintain!

Tuesday, August 26, 2008

On Memory...

It's been a week now since ER/Studio Enterprise Portal was released, and so far the response has been overwhelmingly positive. Yesterday I mentioned that, while testing the portal, I find the Tomcat service management utility helpful. One of the things, in particular, that I do is change the amount of memory that the application server's Java virtual machine makes use of.



The portal isn't officially supported on Windows XP, but it will run on it. Depending on how much RAM the machine has, and how many other applications are running, the maximum memory pool needs to be lowered to something like 1024 or 512. There's a way to do this via the command line as well:


"c:\Program Files\Embarcadero\ERStudioEnterprisePortal1.0\tomcat\bin\tomcat5.exe" //US//Tomcat5ERSPortal --JvmMx=1024

Monday, August 25, 2008

On Service Management...

It's hard to believe that blaugust is drawing to a close... where did the summer go? Given that I have a few more blog entries left before I hit my target for blaugustFEST, I'll be spending some time this week covering lesser known aspects of Embarcadero's ER/Studio Enterprise Portal product (launched last week). While somewhat product-specific, I hope that this information will also be of general interest to those of you who may be using Tomcat as an application server or Pentaho as a business intelligence platform...

The Enterprise Portal makes use of Apache Tomcat as its application server, and installs it as a service in Windows. One of the things I've found, while testing and using the portal, is that I often want to know the current status of this service and/or do things like shut it down and start it back up again. Fortunately, Tomcat provides a service management utility to do this and other maintenance tasks related to the service. To launch it, type (something similar to) the following from a command prompt (or in the Run dialog available from the Start > Run... menu item):

"C:\Program Files\Embarcadero\ERStudioEnterprisePortal1.0\tomcat\bin\tomcat5w.exe" //MS//Tomcat5ERSPortal

After doing this, an icon will appear in the system tray (on the right-hand side of the task bar). If you double-click the icon, a window will open which allows you to start/stop/restart the service, change the way it logs on to Windows, set the logging behavior, configure the application server's Java virtual machine, among other things.


Friday, August 22, 2008

On Walk Thrus...

How green are you willing to be? With all the talk these days about global warming, carbon offsets, ecomuseums, and the like, two recent drive thru experiences have got me thinking.

A few weeks ago, my wife and I were at the window of a leading coffee company's drive thru to pick up the drinks we had ordered, and were somewhat surprised when they were handed to us in a tray. We explained that we had no need for a tray since there were only two drinks which could probably be managed just fine with the cupholders in our vehicle, and asked that the tray be taken back. To our dismay, the dutiful employee refused, saying that the tray had been used (despite our argument that it in fact had not). We suggested that perhaps they should ask their customers whether they would need a tray at the time the order is placed, but were told that, due to a new policy that was being enforced, employees were not allowed to ask that kind of question. We asked how, then, environmentally conscious customers could avoid wasting trays that they have no intention of using, and the response was that customers should remember to specify explicitly that they will not need a tray when placing their orders. Upon asking what we were to do with a tray that we clearly had no use for, we were directed to a blue recycling box several feet ahead of us in the drive thru... which, not surprisingly, was overflowing with "used" drink trays. Stupefied, we got out of our vehicle, picked up the trays that were strewn about, added ours to the pile (after stomping on it a few times), and pulled away, questioning whether that coffee company deserved our business in the future.

Just today, I was waiting in the drive thru of another leading coffee company (this time, a Canadian one) with my regular Friday lunch crowd, and was drawn into a recurring argument about minimization of greenhouse gas emissions via idle reduction. One of my friends has always maintained that an anticipated idle of longer than ten seconds justifies turning off the engine and restarting it. Another friend argued that, as he learned recently, the threshold is actually 60 seconds. In the midst of the discussion, they both stopped and asked whether vehicles needed to idle at all in drive thrus. They then proceeded to put the car in neutral, turn the engine off, get out of the car and, I kid you not, push the vehicle along, despite puzzled stares from patrons inside the restaurant and obvious looks of frustration from the drivers of the vehicles behind us.

Both of these are examples of fastidiousness. As with all things, I think it's important to have standards, and it often pays to be fastidious, especially in a role like mine. But sometimes we need to question whether those standards make practical sense...

Thursday, August 21, 2008

On Triads...

Word on the street is that I'm not the best program manager ever. At least, that's what the T-shirts say. Regardless of whether you can believe everything you read, and given that I'm often asked what it is that I do for a living, I thought I'd take a moment to explain what exactly a program manager (PGM) is...

A program manager at Embarcadero is a cross between a product owner (in the agile sense) and a project manager. We "own" the user experience; that is, we determine how requirements get turned into functionality that appears in our products. Organizationally, as a program manager, we're part of two triads.

As part of the external, or customer-facing, triad (the "cone of silence"), a program manager works with a product manager (PM) and a product marketing manager (PMM) to gather requirements, assess the market, validate product roadmaps, and analyze the competition. Being a keelboat racer, I like to think of this triad as as the strategic part of my job. In sailing, strategy is what you'd plan to do to win the race if there were no other boats on the course. For more insight into this side of the business, check out the interview that Greg did recently with my PM (Jason Tiret) and PMM (Josh Howard).

As part of the internal, or engineering-facing, triad, a program manager works with a software development manager (SDM) and a quality assurance manager (QAM) to deliver a product which satisfies its requirements, on time and with quality. I like to think of this triad as the tactical part of my job. In sailing, tactics is how you actually make it around the course when there are lots of other boats out there trying to do the same thing. There are typically two kinds of software projects: time-based (where the product is released on the scheduled date, even if the scope needs to change to do so) and content-based (where the product is released with the planned content, even if the date needs to change to do so). At Embarcadero, our projects are of the former kind, and "he who ships, on time, speaks".

Oh, one more thing. We're always looking for good people, so if this role sounds attractive to you, drop me a line. ;)

Wednesday, August 20, 2008

On Darkness...

Speaking of darkness, I spent some time yesterday producing updated XMI serializations for UML 2.2 and was reminded of some recent banter in the blogosphere about UML's apparent demise. As original author of the de facto reference implementation of the UML 2.x metamodel (i.e. the abstract syntax), I feel the need to offer my perspective on the issue.

In my opinion, tool vendors have failed. MDD is a sham, at least the way it has been employed in tools to date. Rather than contorting the artifacts, interface, and user (!) to meet the needs of the model or modeling language (UML, DSL, or otherwise), tools should be applying MDD (and visualization in general) where it makes sense to bring about real productivity and result in better quality software. I know there’s increased productivity and quality to be gained from modeling because I (and many others I know) have experienced it. But then I tend to be more accepting of the whole “no pain, no gain” mentality than most users. Tools need to evolve to make consumption of this stuff painless.

What's interesting to me, despite reports of UML's decent into darkness, is that a once long-time detractor of UML has recently changed its tune and started incorporating support for it into one of its tools. Maybe this really is the beginning of the end. UML is dead! Long live UML!

Tuesday, August 19, 2008

On People...

At the risk of getting sentimental, I'm going to get sentimental for a moment. Today, Embarcadero Technologies released ER/Studio Enterprise Portal 1.0, the first product I've been directly involved in launching since leaving my previous employer just over a year ago.

Looking back at how we got to this day, I'm reminded of a major reason why I came to Embarcadero in the first place - the people. A lot has been, and will be, said about the many virtues of this product. But when I think about it, I can't help but focus on the people that persevered through many challenges so that this product could see the light of day. This is what the word "team" is all about. w00t!

Friday, August 8, 2008

On Trojan Source...

Like me, Gord's product is also on the eve of its release. Oh, what a feeling! What a rush! The last time I felt like this wasn't all that long ago, actually. At the time, Ed blogged about how it felt like the end was nigh. Well, that end has since come and gone, and now everybody knows what Ed was really talking about. Personally, I think he should have entitled his farewell blog entry "So long, and thanks for all the FOSS".

Or is that FLOSS? The product I'm about to release is based on an open source platform that, believe it or not, isn't Eclipse (gasp). Their approach to open source, dubbed "professional open source", is somewhat... different from that of Eclipse. It seems ironic (at least to me) that a platform which boasts freedom from closed, proprietary software would switch to a more restrictive license mid-stream... it's almost like it was part of the grand plan all along.

So what does 'open source' really mean, then? According to the Open Source Initiative (OSI), which officially owns the definition, the distribution terms of open source software must comply with ten criteria. The OSI maintains a list of the open source licenses which have successfully gone through their approval process and comply with these criteria; both EPL and that other license are on it, as are many others. So what's the big deal? Just ask one of the customers or OEM partners who, if they want to adopt the next major version of said platform, may be forced to decide between releasing some of their software under the new open source license and purchasing a commercial license for the platform...

Wednesday, August 6, 2008

On Search Providers...

I mentioned that I spent a lot of my time recently on a deep dive into one of Embarcadero's products that's about to release in the coming weeks. I had planned on giving a "sneak peak" as to what it's all about, but it turns out that Greg beat me to it (thanks, Greg!).

Rather than repeat everything that Greg said, I'll focus on a lesser known aspect of one of the portal's main features. Despite the incredible value of its shared reports, explore dashboard, ad hoc query interface, and administration console, perhaps the most popular (and most scrutinized!) feature of the portal thus far has been its search capability.

One of the cool things (at least in my mind) about the search capability of the ER/Studio Enterprise Portal is that, like other Web-based search interfaces, it can be integrated into the search bar of your favorite browser. I'll walk through the steps to do this for Internet Explorer as an example.

1. Select the 'Find More Providers...' item from the search bar's drop-down menu.



This will take you to a Web page where can choose from among several exiting providers or create your own.

2. From a different browser window, type 'TEST' into the search box of the ER/Studio Enterprise Portal and hit .


This will take you to the Search Results page.



3. Copy and paste the URL from the Search Results page (the "&x=8&y=6" portion at the end isn't necessary), specify a name for the new search provider, and press the 'Install' button.



This will open a dialog asking you to confirm that you want to add the search provider (click 'Add Provider').



4. Choose the new search provider from the search bar's drop-down menu, type in your text, and away you go!



To avoid having to log into the portal each time you want to search, you can also add your user name and password to the URL before pressing the 'Install' button in step 3 above by appending, for example, the string "&userid=MyUserID&password=MyPassword".

Tuesday, August 5, 2008

On Status Quo...

What the heck is Blaugust, anyway? Well, it's what James has been calling the month of August lately in light of a little challenge we have going within the program management team here at Embarcadero (yes, another fest). blaugustFEST is a contest to see who can reach out to the community by blogging or commenting on a blog entry a minimum of twenty times during the month of August. So, keep your eyes peeled for some creative blogging by James, Gord, Wassim, and others... it could prove to be quite entertaining.

I don't mention Ian above because, alas, Ian has decided to move on to another pasture (I don't say greener since, as Ed often says, the grass on the other side only looks greener because you're looking at it from an angle). So, things aren't exactly status quo around here, for various reasons.

I'm glad. Not about Ian leaving, because we'll really miss him, but about things not being status quo. The problem with status quo is that it tends to stifle innovation. I get frustrated (and did just recently, in fact) when faced with a situation where "our users have come to expect that it works this way, and if we change it, we'll never hear the end of it". I'm sure many of you have been in the same boat. There's no doubt we'll be facing scenarios like that with e4.

There's this old story about a woman who always cut the ends off a roast before putting it into the oven. When asked why by one of her kids, she realized she didn't really know - her mother had always done it that way. The next time she saw her mother, she asked the same question, and her mother explained that she had to because she didn't have a large enough pan to fit a whole roast.

The real challenge, IMHO, is to face opposition in the name of progress. Sometimes we need to consider new, potentially better, ways of doing things. That's what innovation is all about, after all...

Friday, August 1, 2008

On Blaugust...

Not unlike John, it seems as though I dropped off the face of the planet(s) nearly three months ago. James has a great expression for this kind of phenomenon - "going dark". Well, I can assure you that while I have been dark in the blogosphere of late, I've been bright in other spheres.

So where have I been? So much has happened since my last entry, it's hard to remember it all...
  • I participated in the e4 Summit in Ottawa. I know, old news, but now there's an actual proposal for the e4 project. What area will you be contributing to?
  • I had a chance to meet with my CodeGear brethren in Scotts Valley for the first time, and I'm very excited about what we'll be able to accomplish now as a combined company. Stay tuned!
  • I co-hosted the second of two Eclipse/OMG Symposia in Ottawa, and I'd venture to say that it was even more fruitful than the first!
  • I played a part (as lead of the MDT project) in ensuring that Ganymede, in all its glory, was successfully released. w00t!
  • I took a much needed vacation (they're never long enough!) - one week camping in New Brunswick and a second week at a chalet in Charlevoix. Oh, the stories...
  • I helped orchestrate a summit for Embarcadero's Software Consultants in Toronto. What a great team!
  • I did a deep-dive on one of my products that is about to release in the coming weeks.
I'll be taking time to blog about each of these activities (and others) in more detail over the next month because, as of today, it is Blaugust after all!

Friday, May 9, 2008

On Navigable Owned Ends...

OK, it’s time for me to get a little bit technical (and to try out JBuilder 2008) for a change. While working on the E/R metamodel as a member of the IMM submission team, I ran into an “interesting” scenario recently involving associations with one end type. Consider the class diagram below (the names have been changed to protect the innocent).


Can you see what’s wrong with this picture? The intent of the modeler was to express the fact that a bicycle has two wheels, one of which is the ‘front’ wheel (from the perspective of the rear) and one of which is the ‘rear’ wheel (from the perspective of the front). If you think about what an instance of this model might look like if it were mapped directly to classes and fields in a programming language like Java (using EMF, for example), you’ll realize that each instance of the 'BicycleWheel' class would need a reference to the bicycle’s other wheel, but also to itself – in order to satisfy the multiplicities (both association ends are required, i.e. they have a lower bound of 1), each wheel must reference both the front wheel and the rear wheel of the bicycle; obviously not a desirable result. In fact, it’s currently impossible to create a valid instance of this model using Java code generated by EMF, since an attempt to set a reference from the front wheel to itself (to satisfy the multiplicity) would result in its reference to the rear wheel being discarded.


What’s interesting (at least to a modeling geek like me) is that this redundancy could, in theory, be eliminated simply by making the association ends (the 'frontWheel' and 'rearWheel' properties) navigable owned ends. What does that mean? Well, in UML 2.x, it’s possible to designate a navigable association end as being owned either by the end type (as in the diagram above) or by the association itself. In the latter case, a mapping to Java would require a class to represent the association; now, in addition to there being an instance of the 'Bicycle' class and two instances of the 'BicycleWheel' class, there would be (at a minimum) an instance of the class representing the association which, in turn, would only need to reference each of the wheels once to satisfy the multiplicities. Ed and I have been giving some thought as to how owned association ends might be mapped to Java using EMF, but this special case makes me think that we still don’t have it quite right – see below.


I think there would still be an issue here with respect to navigability, because given a bicycle wheel, it's supposed to be possible to navigate to both the front wheel and the rear wheel (according to the model). Would this require redundant entries in the maps? What if a front wheel is passed as an argument to the 'getFrontWheel(BicycleWheel)' method? What if the owner of the bicycle rotates its wheels every season? I’m starting to wonder whether it should be considered valid at all to model a bidirectional association with required member ends and one end type. In the absence of an answer to that question and/or EMF support for mapping navigable owned ends to Java, there are a number of ways the model could be changed and still (or better) express the original intent. The model we ended up going with (or, rather, a reasonable facsimile thereof) is below. What might you have done differently?


Wednesday, May 7, 2008

On Change...

Embarcadero. It ain't just about databases anymore...

Friday, May 2, 2008

On the Efforts of the Few...

Dave has blogged a couple of times recently about his thoughts on standards development. As someone who is actively participating in the submission and revision of several specifications (some of which are standards) at the OMG, these comments certainly hit home. I agree that it’s typically 10% of the contributors that tend to do 90% of the work, and too often it seems that I’m among the “lucky” few...

One of the challenges of developing an OMG specification is the lack of tooling support for CMOF (Complete Meta Object Facility) models. This was one of the many topics that were discussed during the “Mega Modeling Mania” BoF (and again during the Eclipse/OMG Symposium) at EclipseCon in March. Based on those discussions, there does appear to be some demand for tooling that will make it easy to create, serialize (in CMOF-compliant XMI), and document metamodels that form the basis for open specifications. In response, I agreed to coordinate a proposal for a new component in the MDT project (tentatively dubbed “Metamodel Specification Tools”, or MST) to provide this kind of tooling at Eclipse.

The idea would be for the MST component to customize and/or extend the existing (or forthcoming) UML editors (primarily for class and package/profile diagrams) to expose CMOF concepts which are missing in UML (like identifiers, namespace URIs, and XMI tags), leverage the CMOF (de)serialization support that was introduced in the UML2 component as part of the Ganymede release, and provide a mechanism for generating a specification (or at least a decent boiler plate for one) directly from the metamodel using BIRT. Of course, it might also be desirable for the component to automate the mapping between a metamodel and its profile representation (if there is one) and possibly to make use of the Eclipse Process Framework (EPF) to document and coordinate the specification development process. If you’d be interested in contributing to such a component, I’d like to hear from you!

Tuesday, April 29, 2008

On Planetesimals...

Have you ever been asked the question, "What planet are you on?" I know I have... Going forward, I'm afraid I'll have to confirm peoples' suspicions when I respond, because I'm actually on more than one planet now that Embarcadero has launched its new blog aggregator, Planet Embarcadero. It makes me wonder whether I should start calling my blog a "planetesimal" instead of a "pob"...

Monday, April 28, 2008

On Giving a Damus...

And another one gone, and another one gone. Christian Damus is the latest addition to the growing list of prominent Eclipse committers in exile, and he's got a clever new email address to boot! I think the answer to Ian's recent question about the effect of open source participation on career progression should be a resounding "yes". Best of luck, Christian!

Wednesday, April 23, 2008

On a FESTivus for the REST of us...

A number of special occasions recently have reminded me of one of my favorite Seinfeld episodes. Remember Festivus? If only we could really escape commercialization

Speaking of fests, Embarcadero recently launched db FEST, a series of challenges that, in addition to introducing the world to its professional grade database tools, will provide each participant with a free T-shirt. I’ve already got mine, and I have to say that they’re pretty cool. Have you taken the challenge?

Another occasion that’s been on my mind lately is EclipseWorld 2008. Submissions were due on April 16, so I spent some time last week putting together a couple of abstracts for technical classes. One of my submissions, entitled “RESTful EMF”, would highlight the ways in which EMF supports the design principles of REST, and identify some best practices for working with resources using EMF. This is especially pertinent, IMHO, given the many enhancements the EMF team has made as part of the upcoming Ganymede release to support things like URI handlers and content type definitions, among other things.

Friday, April 11, 2008

On Fake Ed Merks...

Evidently, the most popular session at EclipseCon 2008 was the keynote delivered by Dan Lyons, a.k.a. “Fake Steve Jobs”. In case you missed it, Ed provided a nice summary of the session (which I witnessed him write in real time because we happened to be sitting together) on his blog. Speaking of Ed, I’ve been wondering for a couple of weeks now where the real one was on Thursday at EclipseCon. I mean, there was a guy who bore a striking resemblance to Ed, blogging furiously, at the Eclipse/OMG symposium that day, but I never would have expected the real Ed to sit through nearly four hours of discussion about the OMG! Maybe times really are changing...

I personally think the symposium was a success. Admittedly, we didn’t have nearly enough time to discuss the issues that were raised (which, in my mind, is better than having no discussion at all), and the participants might have felt a greater sense of purpose had there been an “official” OMG representative in attendance (the fact that the OMG Technical Meeting took place in Washington the week just before EclipseCon made this infeasible)… but I think the level of participation and the quality of the presentations were a testament to the fact that people are indeed committed to a future that involves more collaboration between Eclipse and the OMG. Of course, this was just the first of two symposia being jointly hosted the two organizations – the second one is scheduled to take place at the OMG Technical Meeting in my home city on Wednesday, June 25. I heard a rumor that there might also be an Eclipse DemoCamp that same week, so there will be more than one reason to join the party in Ottawa. Hopefully I’ll see you there (here)!

Friday, April 4, 2008

On Doing The Right Thing...

Another frequent pain point of mine revolves around shopping carts. More specifically, the things people do (or rather, don’t do) with them. For example, I often find myself reorganizing the corral in the parking lot of at Loblaw’s or Costco just so that vehicles (including mine) can get by. Are people so concerned with their own interests that they can’t exert even a small amount of effort to return their carts in an semi-orderly fashion? Have we as a society become so preoccupied with our busy lives that we’ve forgotten simple things like common courtesy? Why is it that children so often seem to know better than we do? I was on a Family Day walk to Starbucks with my kids few weeks ago when they discovered a couple of abandoned shopping carts at a strip mall. Watching them struggle to push the carts all the way to the other end of the mall so that they could be returned to the corral got me thinking…

What is it that makes a community really successful? Is it not a critical mass of members that are committed to doing The Right Thing? Do the members of a community not get to decide what The Right Thing is? What if those members don't see eye to eye? Are the inevitable conflicts that arise not actually good for the community in the end? Is conflict not a necessary prerequisite to growth?

Projects at Eclipse have a responsibility to build and be responsive to three communities – contributors/committers, users, and adopters. What happens when what’s in the best interest of one of those communities is at odds with what’s in the best interest of another? I had to face a situation like this during the Birds of a Feature session that I moderated recently at EclipseCon 2008. The current leadership of the UML2 Tools component stated that one of their goals, in attempting to address the needs of the adopter community, was to regulate the commoditization of UML tooling at Eclipse. Many of the attendees seemed surprised to learn this, and made it clear that while working towards eventually being able to completely generate tooling using GMF is a noble pursuit, what the user community really needs now is a set of robust, usable editors for UML models. I’m quite happy with outcome of the session – representatives from at least four different parties (so far) have offered to pool their resources (nearly three times as many as the number of committers on the current component) in building a complementary set of exemplary end-user UML tools at Eclipse (most likely as part of a new component of the MDT project). Some may argue that this will only serve to further add to the confusion that already exists within the Modeling project, but I’m not sure I agree. Regardless, I’m encouraged by the prospect of what appears to be a true community-driven initiative to do The Right Thing at Eclipse...