As a quick followup to the helpful article on themes posted to the Eclipse Tips blog, I would like to point out that all of the values that are in the currently active theme are also in the JFace registry. Yes, it is possible to get the current ITheme from the workbench IThemeManager, but [...]

I was hoping to post this a little closer to the date but the cat has been let out of the bag.  I’ve decided to leave IBM for a position at RIM.  It wasn’t an easy decision to make but in the end I thought it was best for me.  I feel like I’ve gotten [...]

Today’s entry in the Android multi-touch series is a short one. In it, we set up the matrices that will be used later for moving and resizing the image. All source code can be downloaded from the web site for Hello, Android! (3rd edition).

In case you missed the previous articles, here’s an outline of the series so far:

1. Introducing multi-touch
2. Building the Touch Example
3. Understanding Touch Events

Setting up for Image Transformation

In order to move and zoom the image we’ll use a neat little feature on the ImageView class called matrix transformation. Using a matrix we can represent any kind of translation, rotation, or skew that we want to do to the image. We already turned it on by specifying android:scaleType=”matrix” in the res/layout/main.xml file. In the Touch class, we need to declare two matrices as fields (one for the current value and one for the original value before the transformation). We’ll use them in the onTouch( ) method to transform the image. We also need a mode variable to tell whether we’re in the middle of a drag or zoom gesture:

From Touchv1/src/org/example/touch/Touch.java:

public class Touch extends Activity implements OnTouchListener {
   // These matrices will be used to move and zoom image
   Matrix matrix = new Matrix();
   Matrix savedMatrix = new Matrix();

   // We can be in one of these 3 states
   static final int NONE = 0;
   static final int DRAG = 1;
   static final int ZOOM = 2;
   int mode = NONE;

   @Override
   public boolean onTouch(View v, MotionEvent event) {
      ImageView view = (ImageView) v;

      // Dump touch event to log
      dumpEvent(event);

      // Handle touch events here...
      switch (event.getAction() & MotionEvent.ACTION_MASK) {
      }

      // Perform the transformation
      view.setImageMatrix(matrix);

      return true; // indicate event was handled
   }
}

The matrix variable will be calculated inside the switch statement when we implement the gestures.

To be continued in Part 5, Implementing the Drag Gesture…

Copyright notice:
This is an excerpt from Hello, Android 3rd edition, published by the Pragmatic Bookshelf. For more information or to purchase a paperback or PDF copy, please visit http://www.pragprog.com/titles/eband3.

Copyright © 2010 The Pragmatic Programmers, LLC. All rights reserved.

No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher.

I case you hadn't noticed :-) despite the recent transition, JavaOne is indeed happening. The call for papers went out a while ago, and it's it's about to close, so submit your proposal today!. It promises to be a giant year with JavaOne being just a few blocks from Oracle OpenWorld. That few blocks should provide a gap of sanity (opportunity?) between the Geeks and the BizTypes. San Francisco will be bursting at the seams.

DbWrench, which is database design and synchronization software, is clearly an application created on top of the NetBeans Platform:

And, someone out there is making money on the NetBeans Platform in this case, since purchasing this application will cost you $145, while a trial version is also available.

Quite a lot of work seems to have gone into this application, primarily in the porting from a previous incarnation (shown here):

Must be nice, as a developer of this application, to suddenly have a free docking framework out of the box. :-)

Note: Nowhere on the DbWrench website will you see a reference to the NetBeans Platform. Nothing wrong with that. But it clearly means that it's hard to make an estimate about the actual popularity of the NetBeans Platform. However, from the screenshots page one can safely conclude that the NetBeans Platform is broadly adopted across all sectors developing industrial software applications.

Many thanks to Andrea Cisternino for identifying this application as yet another NetBeans Platform application! Others out there? Let me know!

Yesterday morning the USERS mailing list of GlassFish had a thread asking How to start and run GlassFishV3 without Netbeans... so, Alexis wrote and posted a quick Survival Guide on using GlassFish without an IDE . From question to documentation in a few hours: self-publishing, no webmaster to contact, all links to online documentation... and no lawyer to check with :-)

Indeed.COM shows a spike in the number of GlassFish-related jobs around end of January (snapshot, live); the date roughly coincides with the reassuring noises from Oracle on CiC. The absolute job numbers are still small, but I expect them to continue to grow, specially as we release our detailed Roadmap. In other good adoption indicators: • Mail traffic at USERS@GlassFish ; see MarkMail • Google Trends (snapshot, live).

And, before you ask; the roadmap is very close...

First step to integrating OpenOffice into the NetBeans Platform (yes, trying that again) is to get it working outside of the NetBeans Platform.

I started by downloading NetBeans IDE 6.5, installed the OpenOffice.org API plugin, then moved the OfficeBean sample from the OpenOffice SDK into the OpenOffice Client project type which I then opened in a NetBeans IDE 6.9 development build:

Running it, I see this:

The next step is to open OpenOffice via the OfficeBean into a NetBeans Platform TopComponent. This blog entry will probably be very useful.

In this installment of the Android multi-touch series, we try to understand touch events by writing some sample code that dumps them out and then examines the results. All source code can be downloaded from the web site for Hello, Android! (3rd edition).

Understanding touch events

Whenever I first learn a new API, I like to first put in some code to dump everything out so I can get a feel for what the methods do and in what order events happen. So let’s start with that. First add a call to the dumpEvent() method inside onTouch():

From Touchv1/src/org/example/touch/Touch.java:

@Override
public boolean onTouch(View v, MotionEvent event) {
   // Dump touch event to log
   dumpEvent(event);
   return true; // indicate event was handled
}

Note that we need to return true to indicate to Android that the event has been handled. Next, define the dumpEvent() method. The only parameter is the event that we want to dump.

From Touchv1/src/org/example/touch/Touch.java:

/** Show an event in the LogCat view, for debugging */
private void dumpEvent(MotionEvent event) {
   String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,
      "POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };
   StringBuilder sb = new StringBuilder();
   int action = event.getAction();
   int actionCode = action & MotionEvent.ACTION_MASK;
   sb.append("event ACTION_" ).append(names[actionCode]);
   if (actionCode == MotionEvent.ACTION_POINTER_DOWN
         || actionCode == MotionEvent.ACTION_POINTER_UP) {
      sb.append("(pid " ).append(
      action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
      sb.append(")" );
   }
   sb.append("[" );
   for (int i = 0; i < event.getPointerCount(); i++) {
      sb.append("#" ).append(i);
      sb.append("(pid " ).append(event.getPointerId(i));
      sb.append(")=" ).append((int) event.getX(i));
      sb.append("," ).append((int) event.getY(i));
      if (i + 1 < event.getPointerCount())
         sb.append(";" );
   }
   sb.append("]" );
   Log.d(TAG, sb.toString());
}

Output will go to the Android debug log, which you can see by opening the LogView view (see Section 3.10, Debugging with Log Messages).

The easiest way to understand this code is to run it. Unfortunately you can’t run this program on the Emulator (actually you can, but the Emulator doesn’t support multi-touch so the results won’t be very interesting). So hook up a real phone to your USB port and run the sample there (see Section 1.4, Running on a Real Phone). When I tried it on my phone and performed a few quick gestures, I received the output below:

 1. event ACTION_DOWN[#0(pid 0)=135,179]
 2. event ACTION_MOVE[#0(pid 0)=135,184]
 3. event ACTION_MOVE[#0(pid 0)=144,205]
 4. event ACTION_MOVE[#0(pid 0)=152,227]
 5. event ACTION_POINTER_DOWN(pid 1)[#0(pid 0)=153,230;#1(pid 1)=380,538]
 6. event ACTION_MOVE[#0(pid 0)=153,231;#1(pid 1)=380,538]
 7. event ACTION_MOVE[#0(pid 0)=155,236;#1(pid 1)=364,512]
 8. event ACTION_MOVE[#0(pid 0)=157,240;#1(pid 1)=350,498]
 9. event ACTION_MOVE[#0(pid 0)=158,245;#1(pid 1)=343,494]
10. event ACTION_POINTER_UP(pid 0)[#0(pid 0)=158,247;#1(pid 1)=336,484]
11. event ACTION_MOVE[#0(pid 1)=334,481]
12. event ACTION_MOVE[#0(pid 1)=328,472]
13. event ACTION_UP[#0(pid 1)=327,471]

Here’s how to interpret the events:

• On line 1 we see an ACTION_DOWN event so the user must have pressed one finger on the screen. The finger was positioned at coordinates x=135, y=179, which is near the upper left of the display. You can’t tell yet whether they’re trying to do a tap or a drag.
• Next, starting on line 2 there are some ACTION_MOVE events, indicating the user moved their finger around a bit to those coordinates given in the events. (It’s actually very hard to put your
  finger on the screen and not move it at all, so you’ll get a lot of these.) By the amount moved you can tell the user is doing a drag gesture.
• The next event, ACTION_POINTER_DOWN on line 5, means the user pressed down another finger. “pid 1” means that pointer id 1 (that is, finger number 1) was pressed. Finger number 0 was already down, so we now have two fingers being tracked on the screen. In theory, the Android API can support up to 256 fingers at once, but the first crop of Android 2.x phones is limited to 2. The coordinates for both fingers come back as part of the event. It looks like the user is about to start a pinch zoom gesture.
• Here’s where it gets interesting. The next thing we see is a series of ACTION_MOVE events starting on line 6. Unlike before, now we have two fingers moving around. If you look closely at the coordinates you can see the fingers are moving closer together as part of a pinch zoom.
• Then on line 10 we see an ACTION_POINTER_UP on pid 0. This means that finger number 0 was lifted off the screen. Finger number 1 is still there. Naturally, this ends the pinch zoom gesture.
• We see a couple more ACTION_MOVE events starting on line 11, indicating the remaining finger is still moving around a little. If you compare these to the earlier move events, you’ll notice a different
  pointer id is reported. Unfortunately the touch API is so buggy you can’t always count on that.
• Finally, on line 13 we get an ACTION_UP event as the last finger is removed from the screen.

Now the code for dumpEvent() should make a little more sense. The getAction() method returns the action being performed (up, down, or move). The lowest 8 bits of the action is the action code itself, and the next 8 bits is the pointer (finger) id, so we have to use a bitwise AND (&) and a right shift (>>) to separate them.

Then we call the getPointerCount( ) method to see how many finger positions are included. getX( ) and getY() return the X and Y coordinates, respectively. The fingers can appear in any order, so we have to call the getPointerId() to find out which fingers we’re really talking about.

That covers the raw mouse event data. The trick, as you might imagine, is in interpreting and acting on that data.

To be continued in Part 4, Setting up for image transformation >

Copyright notice:
This is an excerpt from Hello, Android 3rd edition, published by the Pragmatic Bookshelf. For more information or to purchase a paperback or PDF copy, please visit http://www.pragprog.com/titles/eband3.

Copyright © 2010 The Pragmatic Programmers, LLC. All rights reserved.

No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher.

In the New Scientist's "Seven Theories of Everything" article:


Yes, this sounds a lot like the CDT I know (s/pentachorons/plug-ins/g). And I look forward to CDT 5.0 and the explanation for the existence of matter!

In part 2 of the Android multi-touch series, we start building the sample program introduced in part 1. Excerpted with permission from “Hello, Android! (3rd edition)”. All source code can be downloaded from the book’s web site.

Building the Touch example

To demonstrate multi-touch, we’re going to build a simple image viewer application that lets you zoom in and scroll around an image. See Part 1 for a screenshot of the finished product.

Begin by creating a new “Hello, Android” project with the following parameters in the New Android Project dialog box:

Project name: Touch
Build Target: Android 2.1
Application name: Touch
Package name: org.example.touch
Create Activity: Touch

This will create Touch.java to contain your main activity. Let’s edit it to show a sample image, put in a touch listener, and add a few imports we’ll need later:

From Touchv1/src/org/example/touch/Touch.java:

package org.example.touch;
import android.app.Activity;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.os.Bundle;
import android.util.FloatMath;
import android.util.Log;

import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.ImageView;
public class Touch extends Activity implements OnTouchListener {
   private static final String TAG = "Touch" ;
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      ImageView view = (ImageView) findViewById(R.id.imageView);
      view.setOnTouchListener(this);
   }
   @Override
   public boolean onTouch(View v, MotionEvent event) {
      // Handle touch events here...
   }
}

We’ll fill out that onTouch( ) method in a moment. First we need to define
the layout for our activity:

From Touchv1/res/layout/main.xml:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
      xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent" >
   <ImageView android:id="@+id/imageView"
         android:layout_width="fill_parent"
         android:layout_height="fill_parent"
         android:src="@drawable/butterfly"
         android:scaleType="matrix" >
   </ImageView>
</FrameLayout>

The entire interface is a big ImageView control that covers the whole screen. The android:src=”@drawable/butterfly” value refers to the butterfly image used in the example. You can use any JPG or PNG format image you like, just put it in the res/drawables-nodpi directory. The android:scaleType=”matrix” attribute indicates we’re going to use a matrix to control the position and scale of the image. More on that later. The AndroidManifest.xml file is untouched except for the addition of the android:theme= attribute:

From Touchv1/AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="org.example.touch"
      android:versionCode="1"
      android:versionName="1.0" >
   <application android:icon="@drawable/icon"
         android:label="@string/app_name"
         android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
      <activity android:name=".Touch"
            android:label="@string/app_name" >
         <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
      </activity>
   </application>
   <uses-sdk android:minSdkVersion="3" android:targetSdkVersion="7" />
</manifest>

@android:style/Theme.NoTitleBar.Fullscreen, as the name suggests, tells Android to use the entire screen with no title bar or status bar at the top. You can run the application now and it will simply display the picture.

Continued in Part 3, Understanding touch events >

Copyright notice:
This is an excerpt from Hello, Android 3rd edition, published by the Pragmatic Bookshelf. For more information or to purchase a paperback or PDF copy, please visit http://www.pragprog.com/titles/eband3.

Copyright © 2010 The Pragmatic Programmers, LLC. All rights reserved.

No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher.

We are glad to announce the first release of JBoss jBPM plugin with:

Visual designer for jpdl files with DnD, usages search, rename and inplace editing

Completion, navigation, refactorings and highlighting inside jpdl xml editor

Links to processes from class files

I can't resist to link here few new great articles / tutorials dedicated to the Mercurial distributed version control system and HgEclipse plugin for it.

• "VersionControlTools" - nice essay about current VCS tooling (from Martin Fowler)
• "A Maturity Model for Source Control" - important criteria for the mature VCS (from Lucas Ward)
• "Hg Init: a Mercurial tutorial" - a Mercurial tutorial from the (ex-)SVN user (Joel Spolsky)
• "Git + Mercurial" - detailed step by step tutorial for Git/Mercurial Eclipse integration (from Ekkehard Gentz)

I used to believe that this whole patent system was just a cold war. Everyone was patenting everything they thought of, mainly in case they got sued for infringement on something else, in order to counter sue. Then they'd go meet in a bar somewhere, have a few pints and work things out.

Well, unlike the real cold war, where everyone got smart and realized there would be no winner and just gave up, (and, yeah, there was much more to it than that, but humor me :). The software industry seems to be about to implode on itself.

Yes, I'm talking about Apple suing HTC. I am not a lawyer. I am only a humble software designer, but if I was afraid before of getting sued for accidentally borrowing someone's idea in my own design, now I'm terrified. Today I was working on a wizard to import existing code into the CDT. I bet someone patented that already and I'm freakin' scared.

O.K. I'm being over dramatic about this. And I'm sure peace will reign. But something's got to be done about this system. There are way too many common sense ideas getting patented. And it's killing the drive to produce great products. The iPhone was really cool when it first came out. But as we got our hands on it and used it for a while, we realized that is wasn't really anything special, and the user interface ideas they had are easy to implement. So was it worth a patent? Was it really an invention?

The telephone, electricity, the car, those were great inventions worthy of patenting. But patenting to what end. If whoever owns the patent to the automobile sued everyone who figured out how to make one, where would we be today? And isn't that a monopoly? Where's the fine line between protecting the rights of the inventor, and protecting the rights of the consumer?

At any rate, I'm just a humble software designer who's getting very frustrated about having to be a part time legal clerk to do my job. I just want to innovate. And you know what. If someone comes up with the same idea and doesn't use my implementation. Good on them. There are lots of smart people in the world. Does the patent system help them, or does it make them so frustrated they decide to go server hamburgers instead. (Melodrama hat off ;)

Version 5 of the Eclipse Roadmap is ready for community review and feedback. It is currently scheduled to be discussed and approved at the March 22nd board meeting in Santa Clara. Please feel free to send any feedback via email, my first.last at eclipse.org.

- Don

Since the latest IntelliJ IDEA  9.0.2 EAP the IDE contains a bit of new Maven-related pom.xml editor features.

1. Easier Navigation

• You can navigate to “Dependency usages” from “dependencyManagement” of your parent pom.xml:
  and back:
  
• You can navigate through projects tree

2. Smarter Paths
‘Path reference’ notion were added to the editor to enhance the code completion, usages search and rename refactoring of project paths.

3. More intelligent plugins configuration
IntelliJ IDEA analyses plugin parameter types and adds smart value editors for plugin configuration tags.

You feedback is as always highly appreciated.

I've noticed an increase in chatter on the #eclipsecon tag on twitter about people getting prepped and ready. We're experiencing our usual late surge in registrations that come in from sponsors and straggling co-speakers who finally have the chance to complete their registrations and make travel arrangements. Here are a few reminders for those of you just pulling things together:

• EclipseCon is four days. Four *full* days. There is a programming contest kick-off at 8:15am Monday, and the closing plenary goes until 5:45pm on Thursday. If you coast in late Monday and leave Early Thursday, you're going to miss a lot of cool stuff.
  
• There's only a couple dozen rooms available on the peak nights of the conference at the conference hotel (Hyatt Santa Clara). Moreover, the room block is now open to the public, so it will certainly sell out -- act now, we can't help you after it's sold out. If you're looking for a purely economy room and OK with commuting after the long busy days, the Biltmore and Holiday Inn are popular choices.
• There is a Taxi/Ride share wiki set up for those of you looking for a lift.
  
• No matter what Oisin has made you do the night before, get up for the keynotes - lots of coffee will be served, I promise. The future of the Java Community, Eclipse and NASA, and the incredibly popular Uncle Bob teaching us how and when to say "NO" professionally are things you won't want to miss.
  
• Take some time for the activities. We're sure you're going to want to attend every single session - but you'll notice a lot of 25 minute sessions that you can use to take a break if something doesn't catch your fancy. Play some of the conference games (TBA), visit some of our sponsors, and socialize with your peers. For those of you looking for the complete experience, your days will start very early with the EclipseCon Exercise group!

- Don

Try the last EAP of IntelliJ IDEA 9.0.2 to test new ‘Generate’ actions for Maven pom.xml editor.  Type “Alt+Insert” to invoke the “Generate…” popup menu and select an action to run.

IntelliJ IDEA actually runs live template inside to complete the code generation

Let us know what you think about.

With IntelliJ IDEA 9.0.2 you can enjoy editing web.xml with the new initial parameters support. IntelliJ IDEA now collects parameter names and is also aware of parameter values types. This allows the IDE to generate (with Alt-Insert), complete, highlight and validate them appropriately.

Grab the latest EAP of IntelliJ IDEA 9.0.2 to try it today.

If you are a plugin writer, you can provide your specific context parameters through the special com.intellij.javaee.model.xml.converters.ContextParamsProvider extention point.

This is the first in a series of articles on developing multi-touch applications with Android 2.x. It is excerpted from Chapter 11 of the book “Hello, Android! (3rd edition)”, available in beta now at The Pragmatic Programmers.

Introducing multi-touch

Multi-touch is simply an extension of the regular touch-screen user interface, using two or more fingers instead of one. We’ve used single-finger gestures before, although we didn’t call it that. In Chapter 4 we let the user touch a tile in the Sudoku game in order to change it. That’s called a “tap” gesture. Another gesture is called “drag”. That’s where you hold one finger on the screen and move it around, causing the content under your finger to scroll.

Tap, drag, and a few other single-fingered gestures have always been supported in Android. But due to the popularity of the Apple iPhone, early Android users suffered from a kind of gesture envy. The iPhone supported multi-touch, in particular the “pinch zoom” gesture.

Three common touch gestures: a) tap, b) drag, and c) pinch zoom. (Image courtesy of GestureWorks.com)

With pinch zoom, you place two fingers on the screen and squeeze them together to make the item you’re viewing smaller, or pull them apart to make it bigger. Before Android 2.0 you had to use a clunky zoom control with icons that you pressed to zoom in and out (for example the setBuiltInZoomControls() in the MyMap example). But thanks to its new multi-touch support, you can now pinch to zoom on Android too! As long as the application supports it, of course.

Note: If you try to run the example in this chapter on Android 1.5 or 1.6, it will crash because those versions do not support multi-touch. We’ll learn how to work around that in chapter 13, “Write Once, Test Everywhere”.

Warning: Multi-bugs ahead

Multi-touch, as implemented on current Android phones is extremely buggy. In fact it’s so buggy that it borders on the unusable. The API routinely reports invalid or impossible data points, especially during the transition from one finger to two fingers on the screen and vice-versa.

On the developer forums you can find complaints of fingers getting swapped, x and y axes flipping, and multiple fingers sometimes being treated as one. With a lot of trial and error, I was able to get the example in this chapter working because the gesture it implements is so simple. Until Google acknowledges and fixes the problems, thatmay be about all you can do. Luckily, pinch zoom seems to be the only multi-touch gesture most people want.

The Touch example

To demonstrate multi-touch, we’re going to build a simple image viewer application that lets you zoom in and scroll around an image. Here’s a screenshot of the finished product:

The Touch example implements a simple image viewer with drag and pinch zoom.

Continue reading: Part 2: Building the Touch Example >

Copyright notice:
This is an excerpt from Hello, Android 3rd edition, published by the Pragmatic Bookshelf. For more information or to purchase a paperback or PDF copy, please visit http://www.pragprog.com/titles/eband3.

Copyright © 2010 The Pragmatic Programmers, LLC. All rights reserved.

No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher.

The "on the Java road" part of my job@Oracle is starting with a busy time:

• I'll be starting off at TheServerSide Java Symposium in Las Vegas. I'll be doing a keynote and a panel. EE 6 will be front and center. With luck, the Demo Gods will smile ;~)
• Then I'll be at Tech Days in Hyderabad, India. Tasty food, sunshine, and enthusiastic developers are a great combination.
• After a week back home, I'll be at the Tech Days event in St Petersburg, Russia (not Florida: no dolphins swimming by the hotel's beach). More enthusiastic developers, tasty food from a totally different universe, but I'll need a warmer jacket.

Should be a fun time. Come join in if you're in the neighborhood.

With IntelliJ IDEA 9.0.2 you can edit HTML and CSS code really fast using Zen Coding features.

To use it, you have to install Zen Coding plugin for Web IDE/IntelliJ IDEA: go to Zen Coding Project Download Page, download an archive that contains a set of live templates, and extract it to “<Your Home Directory>\.IntelliJIdea90\config\templates” folder (”~/Library/Preferences/IntelliJIDEA90/templates” for Mac OS X).

• Zen Coding plugin involves more than 200 different HTML and CSS live templates. To see all of them, just open Settings (Ctrl+Alt+S), Live Templates, Zen Coding group.

• Native Zen Coding support allows you to generate HTML structures using complex templates. For example, try to type “form.form-comment#comment>fieldset” in an HTML file and then press TAB. In this case, “form” and “fieldset“ are live templates but you can use simple tag names instead.

• You can generate not only HTML but also XML structures. Basic features perfectly work for XML.

• “TAG.CLASS” and “TAG#ID” templates allow you to specify class and id of HTML elements, but you can specify a value of any XML/HTML attribute, i.e. you can write “person[name=Jack]“.

• You can use your own live templates as parts of complex templates. For example, suppose you have a template “entry” with the following template text: To generate a list of entries, you just need to type “entry-list>entry[number=$]*5″ and press TAB. By default, the “number” attribute will be generated before “type”. If you want to customize the position where it’s generated, add ATTRS variable to your template – for example: ATTRS variable must have empty string as a default value and should be skipped:

• Of course, you can disable Zen Coding support if you don’t need it (see Settings (Ctrl+Alt+S), XML Zen Coding).

To learn more about Zen Coding features, you can watch screencasts on Zen Coding project home page.

Note that Zen Coding native support is a part of IDEA Community Edition, and its source code is freely available.

The latest IntelliJ IDEA 9.0.2 EAP contains a big number of Database-related functionality changes:

• Database Console now has its own toolwindow
• New console-like UI that keeps input and output in one place and retains the highlighting for execution history
• Keyboard shortcuts for all Console actions are now configurable
• Per-result Page Up, Page Down and Refresh actions
• Complete support for In-Memory Databases (try running some DDL in Console then click Refresh Tables and all the tables will be loaded in the Data Sources tree)
• Improved support for heavy JDBC drivers that use native libraries to run
• The notion of Database Connection allows IntelliJ IDEA to do some cool stuff such as Quick Table Contents Lookup integrated with Quick Documentation Lookup (Ctrl+Q)

The Hibernate Console has also been improved accordingly (separate toolwindow, console-like UI and per-result paging actions).

Try all this in the latest EAP and let us know what you think.

Since IntelliJ IDEA 9.0.2 Database Diagram supports drag-and-drop for adding more tables to the view. The screenshot below shows the way to access the diagram if you somehow missed the What’s New in 9.0 page.

You can try this right now in the latest EAP.

If you work on large projects with dozens of Flex modules (or facets) you’ll like this new feature of IntelliJ IDEA 9.0.2, which lets shorten project build time by compiling several independent Flex modules (facets) in parallel.

To enable this feature go to Settings (Ctrl+Alt+S), Compiler node and then Flex Compiler page:

Let’s have a closer look at this feature.

Flex Compiler Shell (fcsh) is good for small projects, and may be useful in large projects as well, when you need to compile only some of the modules (facets). Fcsh process is kept in memory between compilations, so it is able to quickly recompile only changed piece of code (that is called incremental compilation), but in case of large projects fcsh runs out of memory, then IntelliJ IDEA restarts it automatically, but incremental compilation data is lost.

Mxmlc/compc processes are not kept in memory between compilations, but simultaneous running of independent compilations gives a good performance gain. IntelliJ IDEA automatically finds independent compilations based on module-on-module dependencies, configured in Project Structure (Ctrl+Alt+Shifl+S), Modules node, Dependencies tab.

Whatever tool you’re using, IntelliJ IDEA keeps track of modules where nothing was changed since previous compilation and skips compilation of up-to-date swf/swc files.

In conclusion, here are different ways of compilation in IntelliJ IDEA (applicable for Flex as well as for other programming languages):

• Make Project (Ctrl+F9): compile all modules incrementally (if possible), do not compile up-to-date modules
• Rebuild Project on the Build menu: force full non-incremental compilation of all modules
• Make Module (in popup menu of module root in Project View): compile selected module and all modules it depends on incrementally (if possible), do not compile up-to-date modules
• Compile Module (Ctrl+Shift+F9) (in popup menu of module root in Project View): force non-incremental compilation of selected module only, it’s dependencies are not compiled

So, yesterday was the 10 year anniversary of the first release of JFreeChart, and it slipped by without me noticing! I knew it was coming up, and even checked the exact date a few weeks back, but then on the day I had so much else to do. Life is like that at the moment. Anyway, tonight as I walked home from work I decided a small celebration was in order, so I bought a bottle of New Zealand sunshine and...cheers! Here's to 10 years, 50+ releases, 984+ bugs, 61,525 forum posts, 1.3 million downloads, and hundreds of millions of charts generated.

I heard some wise words yesterday in a discussion over a new business venture. "If you know more than your customers and you know more than your competitors, you should be fine."

I've really been struggling to come up with a justification on how you can still make money in the tools industry. There is such a rich set of open source freely available tools that developers can easily download and adopt. And no matter how you spin it, those free tools cut into the value proposition of a traditional commercial tools offering.

But that's why it so important to focus your investment on unique knowledge areas that you have or can acquire. Developers still face very difficult problems that free and open source tools won't solve for them. And that's where the money is still to be made.

But the converse is also true. For a complete tools solution, you still need the entire stack. And for those things where knowledge is common place, which have the least value (sorry), working in open source is really the only way to keep the costs down to match.

Engineering is expensive. Having the right open source strategy is critical to ensure your business is successful. And that strategy needs to be continuously updated. What you might think is unique knowledge today could become common knowledge tomorrow and you need to have a transition plan to keep above the line. It's certainly a lot of work, but it needs to be done.

As there are more people that could blog about the JavaFX Composer for Netbeans IDE, we decided to create a new team blog. In the blog you should find information, notes and ideas about and around JavaFX Composer.

As I don't want to loose my visitors and subscribers that hold me in 100 most "Popular Blog" at blogs.sun.com, I'll continue to post some news about JavaFX Composer even in this blog too.

• JavaFX Composer Team Blog

From Lessons Learned by Eric Reis:

Eclipse project diversity:
Only a few projects with any diversity (props to Mylyn, CDT, and Linux tools!); none in the core.

Are you having trouble viewing some Java applets on a Mac? Got next generation Java Plug-in? The next generation Java Plug-in (introduced in Java SE 6 update 10), needs to be enabled in order to view applets that leverage features of this Java Plug-in. The next generation Java Plug-in is not enabled by default on Mac OS systems. So here are a few tips to enable the plug-in. <ul> <li>Upgrade to a 6u17 based Java update. This <a href="http://support.apple.com/kb/DL972">support page from Apple</a> might be helpful. </li> <li>Open the Java Preferences application and toggle setting to "Run applets: in their own process".</li> <li>Restart your browser and try viewing the applet.</li> </ul> When using Firefox 3.5 and above, in some cases the Java Preferences setting does not fully disable the default MRJPlugin and fully enable the next generation Java Plug-in. If after the performing the above steps you still have problems viewing some applets, you will need to go to the guts of the problem. <img src="http://blogs.sun.com/images/smileys/smile.gif" class="smiley" alt=":-)" title=":-)" /> <p>Perform the following steps to disable the default MRJPlugin: </p> <ul> <li>Go to the <code>/Applications/Firefox.app/Contents/MacOS/plugins</code> directory.</li> <li>Move the following files to a temp directory or another location: <ul> <li>JavaEmbeddedPlugin.bundle</li> <li>MRJPlugin.plugin</li> </ul> </li> <li>Restart your browser.</li> <li>To check which plug-in is being used by your browser, view the <code>about:plugins</code> URL. An entry titled "JavaPlugin2_NPAPI.plugin" indicates that the next generation Java Plug-in is enabled in your browser. </li> </ul> <p>You can now enjoy Java applets on MacOS!</p> - Sowmya

You’ve probably heard that Apple does not allow any interpreted or run-time compiled programs on the iPhone. That’s why you don’t see Flash, C#, or Java used on the iPhone. Now, companies like Adobe and Novell are trying to do something about that. In a ZDNet Q&A, Joseph Hill, product manager for Mono at Novell explains their approach with MonoTouch.

The MonoTouch project lets you run Mono programs on the iPhone. Mono is an open source implementation of Microsoft’s .NET platform sponsored by Novell. Normally, .NET code written, for example, in C# runs inside of a virtual machine. The VM takes an intermediate form of the code called bytecode (or in the case of .NET, MSIL) and either interprets it or does a Just-In-Time compilation to native code as needed. Apple doesn’t allow that, so as Joseph Hill explains, Novell had to take a different tack.

Ed: Why does Apple allow .NET development with MonoTouch when they don’t allow Java development on the iPhone/iPad?
Joseph: Java (and other runtimes) are restricted from being deployed to the iPhone because an application cannot execute writable memory. Virtual machines like Java and .NET generate native code from bytecode at runtime, and then execute this code; however, for various reasons, the iPhone kernel will not allow this code to be executed. Mono’s Ahead-Of-Time (AOT) feature avoids this issue by generating all native code that the application could generate at runtime ahead-of-time, so the application deployed to the iPhone is a 100% native application.

Ed: Does Ahead-Of-Time compilation make some features of .NET unavailable?
Joseph: The primary feature that is lost to AOT compilation is Reflection.Emit. (Since this would generate code that could not be executed.) Normal reflection is okay.

Next: Do I still need a Mac? >

We've been hearing about the upcoming Eclipse-like-but-not-really-Eclipse project hosting service for a few months now. It's clear that, like Apple's iPad, this new hosting will be a third way: not "real" Eclipse projects and not just external projects that are Eclipse plug-ins [1], but some new and interesting third way. That's exciting because in order to succeed, this third way (this iEclipse) will need to enable amazing new opportunities and to solve compelling contributor problems. I've hypothesized what those problems and solutions might be [2], but I don't have any insider knowledge, so I wait with everyone else to learn the Foundation's real secret sauce.

I'm confident that the Foundation will not simply duplicate something already available to the open source community, for example, providing an Eclipse skin over an existing free project hosting site [3,4]. ... I had thought that the secret sauce was going to be inclusion in the annual coordinated release and the major distros, but the latest report to the membership [5] indicated that the Foundation is going to reduce the number of projects included, thus restricting access to the official distribution channels. ... Then I thought that the secret sauce might be publicity and visibility, thereby helping these new projects find their user and contributor bases, but the Foundation's official press release guidelines [6] are all about partnering with companies and corporate projects and explicitly say that experimental and incubation projects will not be mentioned.

So what's it going to be? What is the clear and compelling value proposition for this new iEclipse hosting service? How will it contribute to ensuring the continued health of the Eclipse core? ... I admit that I expected an open and transparent community dialog when putting together a new service for the benefit of the community but, hey, perhaps the reason for secrecy is that they have asked the newly unemployed Jonathan Schwartz [7] to join the Foundation as VP of iEclipse, and they want to maximize the press around that :)

P.S. I still like my idea of a selective engagement scheme for Eclipse projects ("badges") [2]: if I'm elected to the Board, I'll be pushing for that idea.

NetBeans 6.9 Milestone 1 is out. Do you want to know why there is NO JavaFX support? Read the New and Noteworthy.






































Ok, I'll tell you. You'll find the same in the New and Noteworthy anyway. The JavaFX plugins in NetBeans 6.9 will support the next JavaFX SDK that haven't been published yet. And as there is no runtime(SDK) available yet it has no sense to publish the tools. Stay tuned for a "public" release.

If you’re a lucky owner of IntelliJ IDEA 9 Ultimate Edition, you’ll be surprised to find a new action in VCS History panel: view all changes made in commit in a single dialog. This feature makes it simpler to understand what a commit author made in his change.

To start using this feature, invoke Show History action for any file, then select revision you’d like to investigate, and then click UML icon (or press Control+Shift+D).

This opens the following diff dialog:

As you can see, 3 changes are made in layout.properties, Rounded interface and RoundedButton class. By default, green color marks what was added, blue is for changed, and gray, guess what — deleted. Well, what else can we see here? RoundedButton class doesn’t extend JComponent and does not implement ButtonModel interface anymore, but instead it extends AbstractButton class and implements MouseListener and KeyListener interfaces. Also, author has changed method paint and removed method isPressed. Interface Rounded was added from scratch and some properties were modified, added and removed in layout.properties file. Double click on a node shows standard diff dialog.

You will be able to enjoy this UML-like Diff Tool in next EAPs and also in the nearest IntelliJ IDEA 9 update.

There are many great programming languages. And today we often pick one that fits best for a particular task. IntelliJ IDEA is a great IDE for polyglot programming offering out-of the box support for many languages plus a variety of language plugins.

Last year we’ve started creating language-specific IDEs such RubyMine for Ruby/Rails and Web IDE for HTML, JavaScript and PHP. Recently we’ve made available public preview of a new specialized IDE built on the IntelliJ platform — JetBrains PyCharm.

PyCharm is the environment for programming using Python and for web-development with Django framework.

Obviously, JetBrains PyCharm inherits all the functionality of the latest IntelliJ IDEA 9.0 for editing HTML, CSS, JavaScript, XML, working with VCS and more.

PyCharm 1.0 will be available later this year.

Download Public preview of PyCharm now to try it.

Read more about JetBrains PyCharm and participate in the Early Access Program.

We are going to continue to develop and release the Python plugin for IntelliJ IDEA. The plugin will remain free for all users of IntelliJ IDEA Ultimate.

Develop with pleasure,
JetBrains Team

I'm a big fan of the Ignite format - very short talks which lead to in-depth secondary conversations - although, much like git, if you haven't actually tried it, you can't really understand what a game changer it is. What's neat is how the O'Reilly folks have provided just enough infrastructure and support to create a global network of Ignite events. Two very simple rules (five minutes, 20 slides) and the rest is left for the community to invent and refine.

In addition to just being an Ignite fan, I bring up Ignite's success because I believe that changing the hard wall of Eclipse rules to a more Aikido-like incrementally increasing process will be all-around good for the long-term health of Eclipse. Is the future more big corporate or more crowd-sourced? (I'm betting on the crowd.)

Hypothetically speaking, if I had received an invite to join the Kindle Development Kit (KDK) for active content limited Beta program, which I didn’t, and had read over the Terms and Conditions for the KDK, which don’t officially exist, I wouldn’t have seen this section:

You will not, without our prior written consent, use our trademarks, trade names or logos in any manner, or issue or contribute to any press release or any other public statement relating to the Program, our relationship with you or the terms or existence of this Agreement.

If such a policy existed, and I’m not saying it does or doesn’t, it might prevent anyone from disclosing that they were even working on any Kindle apps. It’s a good thing I’m not doing that. And I certainly wouldn’t be able to share any source code examples or documentation from the KDK with you because the non-existent policy might say:

We will from time to time provide you access to certain software, documentation and related materials (the “Materials”) in our sole discretion. … You will not use or authorize a third party to use any software in a manner that would in any way cause the Materials to be licensed free of charge, distributed in source code form or modifiable other than as expressly permitted in this Agreement.

It’s really too bad the beta program doesn’t exist because if it did I could tell you about the neat <redacted> feature, the fact that the whole thing is based on <redacted>, or the <redacted> limit of <redacted> KB/month. Wow, I can’t believe nobody has reported on that yet.

So… what could we talk about instead? How bout ‘dem Saints?

Stackoverflow is offering free advertising to open source projects looking for contributors [1], but I don't see any submission from the Eclipse Foundation. Maybe it's still being designed?
Anyway, this is the kind of thing that, if I'm elected as a committer Board rep, I'll be pushing the Foundation to do: outreach to recruit additional contributions of all kinds (code, tests, doc, translations, etc).

For those of us who uses Mercurial distributed version control system (DVCS), I have great news: Intland has released the 1.6.0 snapshot of the MercurialEclipse plugin!

The main changes are dedicated the "enterprise" use case - we've improved scalability, usability and performance of the plugin.

• Very short changelog
• Hg changesets
• Hg repository: http://javaforge.com/hg/hgeclipse
  (you must have free javaforge account to access the repo).
• Eclipse update site: http://hge.javaforge.com/mercurialeclipse-snapshots

P.S. Screenshots are coming soon...

Are you interested in SWT API for the Windows Ribbon Framework? If yes please raise your voice in bug 293637. It looks like the Ribbon can’t be used in the SDK or any other Eclipse project at the moment. However, it’s still unclear if it can be part of the SWT API.

Eclipse is at a cross-roads: it has more users than ever before but also less committer involvement than ever before [1,2]. Thinking about this, I'm struck by the similarity between Eclipse's situation and David Weinberger's "The Opposite of Open is Theirs", specifically he says:

If we allow others to make decisions about what the Net is for — preferring some content and services to others — the Net won’t feel like it’s ours, and we'll lose some of the enthusiasm (= love) that drives our participation, innovation, and collaborative efforts.

or, reworded for Eclipse:

If we allow others to make decisions about what Eclipse is — preferring some plug-ins and projects to others — Eclipse won’t feel like it’s ours, and we'll lose some of the enthusiasm (= love) that drives our participation, innovation, and collaborative efforts.

In other words, as long as the official Eclipse distros are controlled by single companies, the growing body of users will continue to be disenfranchised. I think the Apache Foundation epitomizes what the Eclipse Foundation should strive to emulate:

We consider ourselves not simply a group of projects sharing a server, but rather a community of developers and users.

Required diversity, decisions made by contributors, refusal to allow sponsors to control project direction, ... those are some of Apache's open fundamentals. If elected to the Board, I will work for moving the Foundation in that direction. I'm pro-member-company-profits, but not in a way that is anti-open. I want Eclipse and the Foundation to be viable in the long-term and I believe the only way to accomplish that long-term relevance is through a truly open meritocracy.

It needs to be ours and not theirs.

Here’s a scary thought for you. Every day, hundreds of billions of dollars of financial transactions are driven completely autonomously by computer algorithms. The fate of corporations and nations rests on bits of computer code sent out by their makers to do battle in a high-stakes trading war. And when something goes wrong, it can go spectacularly wrong.

When you think of stock exchanges you probably have a quaint notion of a paper-strewn room full of stressed-out traders yelling to be heard over each other while watching big screen monitors that cover every square inch of the walls. Or maybe you have a more modern picture of an army of white collar workers barricaded in their caves of steel intently staring at computer displays, waiting to pounce on the right news or slightest movement by executing a quick buy or sell order.

In reality, today’s markets are largely driven not by bellicose bombasts or educated elites but by algorithms written by programmers like you and me. Programs that are set free to wreak profit (or havoc) in the innards of the world’s electronic cyber-market. According to the Financial Times, program trading accounts for about 30% of the total daily activity on the New York Stock Exchange, and a whopping 60-70% of the activity on other markets such as the Nasdaq. In 2008, the total world derivatives market was estimated at nearly $800 *trillion* dollars.

Unsatisfied by the decision speeds of mere humans, huge banks have turned over the keys to the vault to programs to do the trading of stocks and derivatives for them. The idea has a certain appeal: Put in a few billion dollars, push a button, and walk away while the computer does all the work. When you come back, if all goes well, you’ve made a nice profit. “Leave the driving to us,” as the slogan goes. Even a monkey could do it. Right?

Well, if you’re not a developer and you’re reading this, please take heed. Computers make mistakes, because they just do what their programs tell them to do, and all programs have mistakes lurking in them. “Bugs,” we call them. Much of the craft of computer programming is concerned with reducing the number of bugs. When a program controls something really important, like say an X-Ray machine, a fighter jet, a space craft, or a nuclear power plant, extreme efforts are put into eliminating as many bugs as humanly possible. But as a number of high profile cases have proven, it’s impossible to detect them all.

Take the case of the NYSE Euronext exchange operator. Recently it fined a trading firm for “failing to control” its trading algorithm. One day, out of the blue, the program decided to send “hundreds of thousands” of messages for faulty orders, clogging up the exchange for everyone for hours. All it takes is a bad “if” statement or a misplaced semicolon, or maybe an array that grows larger than expected or a race condition in multi-threaded code. Let’s not even mention what a malicious hacker with an agenda can do.

So what’s the fix? Acknowledge that bugs happen, and put in checks and balances to catch and contain them. Don’t assume computers are infallible. They’re just as fallible as the humans that build and program them. More, because humans have the advantage of common sense. Let’s use it.

Photo credit: Walt Dabney

You've probably seen the news - the Sun/Oracle transaction has closed. With the passing of that milestone, I can once again speak freely.

Having had nine months to accelerate down the runway, there's not a doubt in my mind Oracle's takeoff and ascent will be fast and dramatic. I wish the combined entity the best of luck, and have enormous confidence in the opportunity.

Greg Papadopoulos, one of the brightest people I've ever known, once made a very interesting statement - all technology ultimately becomes a fashion item. It was true for timekeeping, and it's definitely true of computing and telecommunications. To that law, I'd like to add a simple corollary: the technology industry only gets more interesting. It's been true my entire life.

As for where life takes me next, you should follow me via Twitter at openjonathan to find out. I'll also be rehosting this blog (and again, stay tuned to Twitter by following me here). I expect to do my part to keep things interesting.

Thank you for your support and commitment. I wish you all the best of luck building, taking advantage of (and likely wearing) the future!

Jonathan Schwartz
CEO, Sun Microsystems, Inc.
A Wholly Owned Subsidiary of Oracle Corporation.

Steve Jobs has just announced the iPad, calling it a “magical device at a breakthrough price”. Apple says the iPad runs all applications currently available on the iPhone App Store, plus apps customized for the device.

Here are the official specs direct from Apple:

• Powered by a custom 1GHz “Apple A4″ CPU chip (built by Apple),
• 16, 32, or 64GB of flash storage
• 25Whr built-in li-poly battery, 10 hours battery life, 1 month standby
• 1024×768 9.7″ IPS glossy display (132 pixels per inch)
• 802.11n WiFi and Bluetooth
• Speaker and microphone
• 9.56″ x 7.46″ x 0.5″ (242.8mm x 189.7mm x 13.4mm)
• 1.5 pounds (.68kg) for WiFi Model, 1.5 pounds (.73kg) for 3G+WiFi model.
• (Optional) unlocked 3G capability using GSM micro-SIM.
• Video out: 1024×768 with VGA cable or up to 576p with A/V Cable.
• H.264 video up to 720p, 30fps.
• VoiceOver screen reader

Price: $499 for 16GB, $599 for 32GB, $699 for 64GB. If you want 3G that’s $130 extra up front, plus $14.99 for 250MB/moth, or $29.99/month for unlimited data.

Shipping is expected in March worldwide for the WiFi model, April for the 3G model. Unfortunately you can’t pre-order one right now pending FCC approval.

The iPhone 3.3 beta SDK with support for the iPad is available now from the Apple Developer’s web site. It includes an iPad simulator so you can begin testing right away. Similar to Android, you write one iPhone/iPod Touch/iPad app that runs on any device but adapts its user interface to the user’s resolution.

If you try to run an unmodified iPhone app on the big screen, it will either display in a small window in the middle of the screen or the user can zoom it up to 2x size. Zoomed apps won’t appear as crisp as apps adapted for the iPad, of course. That’s because original iPhone apps were designed for a resolution of 480×320 pixels. If you blow that up to 2x the size, you have 960×640 but every dot is 4 times bigger (and blockier) than it was originally.

See also: Live coverage of the announcement.

Like Zaphod Beeblebrox, I'm the candidate you want to vote for. You've (probably) read my blog and you know that I believe the Foundation should be doing a lot more for the committers, especially the independent and small company committers. I want the Eclipse Foundation to provide value for the long-term and I, and others, believe that to do that, the Foundation has to change. I want to be your voice in that change.

I'm sure there will be many solid candidates running for the three open committer rep positions (the list won't be announced until Feb 3 and I have no inside information), but here's why I think you vote for me Feb 22-Mar 12:

1. I've been on the Board before and I know how it operates. Even Mike said that I was one of the most effective Board members during my previous term. I'm confident that I will be one of the most effective members again. You want an effective representative.
   
2. I've been on the inside of the Foundation and I know how it operates. I know the right questions to ask to make sure that the committers are getting the straight dope and the appropriate resources. If you've seen any board at work, you'll know that management tailors its presentations to present the best picture and thus without deep knowledge of the inner workings, board members are handicapped in their inquiry and oversight. My inside knowledge will eliminate that problem for, you, the committers.
   
3. I've proposed specific reforms that will dramatically improve the situation for committers and contributors, e.g., moving the IP burden from the producers to the consumers (April 2009), and a less constrained "what it means to be an Eclipse project" (January 2010), and many others. I will push for significant reforms for the committers and contributors: especially you smaller, independent and non-corporate committers.
   
4. I will advocate for a larger percentage of the Foundation budget providing direct value for the contributors. There are many ways that the Foundation could help the projects without directly hiring developers. For example, the Foundation should have someone actively helping each project enable and encourage community contributions (setting up processes, writing "quick start" guides, recruiting up bug triage volunteers, etc). And the Foundation should have a wiki-editor to curate the Eclipsepedia and make it into something we can be proud of (Ward himself explains that wikis are best when curated) ... The ideas are endless, but they need someone forceful to advocate them at the Board.
   
5. I will communicate with you. You deserve to know what's going on. Neither rain nor sleet nor verbal attacks will silence me. I will keep the committer rep blog up to date by posting after each monthly Board meeting (instead of e.g. just twice a year). I will not repeat just the party line. I will hold weekly office hours on IRC with rotating times optimized for the Americas, Europe, India, and East Asia (noon EST one week, 3pm CET the next week, 9am IST, 9am JST, and then repeat).

I'm a small-time committer, but I'm independent. The big company committers are represented by their Strategic board members, but the independent and non-corporate committers also need someone at the table. I will be your representative at that table.

P.S. If you are an independent committer but you have not yet signed a membership agreement, you'll need to do that in order to be eligible to vote. Just being an active committer isn't enough: you also need to be a Committer Member.

JLibs: I18N made easier, SAX-Java Binding Enhancements

I18N made easier

It’s “T-Day” for Apple as the company is set to announce the long awaited Apple Tablet. I blogged about the event as it happened, and now that it’s all over I’ve re-arranged the comments a bit for easier reading. Enjoy!

[ See also: $499 gets you a powerful tablet for browsing, books, and apps ]

7:57am (Pacific time): The media mob is already assembling at the Yerba Buena Center for the Arts. If you’re like me and you can’t be there in person, I’ll try to make you feel like you are. The temperature is a little nippy, 50 degrees, so bundle up, folks.

8:02am: It’s not too late to try your luck at the Apple Tablet polls. Scroll down to the very end of this post to see them. Polls close at 10am Pacific time.

8:11am: Interesting article at The Gawker about all the Apple Tablet anticipation. They call speculating about the tablet “one of the great modern pastimes”.

8:22am: Crowdsource prediction from the polls below: iSlate, available in March, for Book reading, $700-799, programmed in Objective C. My predictions: iPad, in June, for Games, $900-999, in Objective C.

8:26am: Apple Tablet, #Apple, iSlate, and iTablet are all trending on Twitter. No surprise there, but the one I can’t explain is “Frantic Steve Jobs”.

8:29am: Comments are open! Add your voice to the Trackback area below. We did away with that nasty registration form, so jump in.

8:33am: Is this the outside of the Apple Tablet? Looks pretty bland but plausible.

8:38am: Quite a mix of people in the crowd. Young and old, sweatpants and power suits, not to mention “black clad Apple security types” guarding the entrances. Not many women. Maybe they’re smart enough to avoid standing out in the cold for 3 hours.

8:43am: Lots of iPhone developers in the crowd. Everybody is wondering how compatible the tablet will be with the iPhone/iPod touch. Will it start with zero apps or 100,000?

8:50am: Apple shares down $3.38 this morning to $202.56. Is this a case of Buy on the rumor, sell on the news?

9:05am: Wireless networking is becoming a problem. WiFi is prohibited in the center, and 3G is iffy. Ars writes “We use Sprint [on EVDO] actually, at any big event, AT&T dies because there are 1000’s of iPhones around”. Even people with wireless mice are having a hard time.

9:07am: If the Apple Tablet allows background processing, and is available on carriers other than AT&T (or no carrier at all), I wonder what that will do to the momentum behind Android? Comments welcome.

9:20am: Some people are getting inside the building now (the glass part), others are still standing in the long registration line.

9:22am: Overheard on gizmodo: “I hope Apple announces a tablet that’s really just 6 iPod touches glued together, bezels and all.”

9:28am: Doors are about to open; mood is jovial but some crowding.

9:36am: No, there is no live video feed available. That’s what you have us for! You know, everybody disses Apple for this but I think it just builds on the whole anticipation/insider/secret knowledge thing they have going. Is that why Google events are so boring in comparison? Yeah, that’s it.

9:38am: Another good one: “I hope Apple announces a tablet that makes us all understand why we inexplicably crave a tablet.” Only 20 minutes left before the polls close!

9:42am: Doors are open and the crowd streams in. Looks like Steve Jobs will be in attendance after all. How can we tell? Because Dylan is playing.

9:45am: What kind of company would Apple be without Steve Jobs? He certainly makes it more fun.

9:46am: This just in: Leaked pictures of the Tablet! Er, not really, but funny.

9:48am: Everybody is commenting on the chair on stage. Is Steve J not feeling up to standing? Please God don’t let this turn into Dick Clark’s New Years Rockin’ Eve.

9:56am: People are taking their seats (in the audience I mean). Al Gore is here. How come he gets all the good invites?

9:59am: Looks like TechCrunch has crashed under the load. Or maybe the server died in shame over what CrunchPad could have been.

10:01am: Steve is out on stage! Big applause. Big grin on his face. “We want to kick off 2010 by introducing a truly magical and revolutionary new product”. But first, a few updates.

10:08am: (AppleInsider feed falls by the wayside too… zdnet.com and cnet.com showing strain but still up. No update from Ars in like 20 minutes).

10:08am: 250M iPods sold, 140K apps in the App Store, 3 billion apps downloaded.

10:09am: Jobs: Is there room for something in the middle of a laptop and a smartphone? Not the netbook - too slow, low quality display, and PC software. [snicker] It should be better at things like browsing the web. Email. Photos. Videos. Music. Games. eBooks.

10:11am: Jobs holds up the tablet… and the crowd goes wild. It looks just like a big iPhone.

10:14am: It’s called the iPad. Desktop is customizable, looks like a cross between Mac OS X (dock at bottom)and iPhone OS (icons, strip at top). Steve is emphasizing the web browsing right now.

10:14am: Display is not wide screen - looks closer to 4:3. “Much more intimate” than a laptop. Ah, now I see what the chair is for, that intimate, fire-side chat feeling. Steve runs through the demos.

10:18am: On-screen keyboard is *huge*. Looks like full size.

10:20am: Apps are not just scaled up versions of iPhone apps. For example the Calendar is 2 pages wide. Mail shows iPhone-like summary on left, reading pane on right.

10:23am: Interestingly, the demo unit is connected via WiFi. There is no 3G/phone icon visible anywhere.

10:23am: iTunes runs natively on the iPad. Album covers and all. No need to have a computer to sync up with it.

10:25am: Now showing Google Maps with Street View. Graphics are super smooth. I wonder if this has one of those dual-core ARMs? Or is it Intel Atom? Or Snapdragon? It has to be something pretty darned fast.

10:28am: Here come the specs. 0.5″ thick, 1.5 lbs.

10:30am: Custom 1GHz Apple A4 chip.

10:35am: 16-64GB Flash storage. Full capacitive multi-touch. WiFi 802.11n.

10:40am: Existing iPhone apps will run unmodified. They can run in 1x mode, unscaled, in the middle of the screen, or in 2x (full screen mode). The iPhone SDK has been enhanced to support the iPad. Using the new APIs you can write an app that works on *both* devices, and takes advantage of the bigger screen on the iPad if the user has that.

10:42am: Demo of Nova, a first person shooter. Looks nice. Ships “later this year”.

10:45am: Newspaper reading demonstrated with the New York Times. Multiple columns, inline video.

10:46am: Now showing the Brushes demo. Painting on the screen. Like the iPhone app only bigger.

10:48am: Next up: EA games. Given 3 weeks with the device to make a demo. Need for Speed Shift - touch and accelerator enabled. Touch mirror to see behind you. (Sorry for zdnet/cnet slowdown folks, server is getting hammered!)

10:50am: No word on multi-tasking or camera yet, looks doubtful.

10:53am: MLB.com app looks awesome. Live-game experience, navigate through games, pitch-tracker, trajectory of each pitch from the player’s perspective. And oh yeah, real video from the game if you want that.

10:55am: New app: iBook Store. Browse, buy, and read books online. All 5 major publishers (Penguin, Harper Collins, Simon and Schuster, MacMillan and Hachette) are on board. “Stands on the shoulders” of Kindle and goes a bit further. Bookstore opens this afternoon.

10:59am: iBook store uses the standard EPUB format (unlike the Kindle). You can change the font, size, etc..

11:00am: Also new: iWork on the iPad. New Keynote presentations designed specifically for the iPad. New version of Pages (word processor) and Numbers (spreadsheet). [I wonder if it can video out to a projector?]

11:11am: Keyboard changes based on the application. For example there are custom keyboards in the spreadsheet application for entering formulae.

11:12am: iWork apps are $9.99 each (not bundled together).

11:13am: Steve’s back. The iPad supports USB synching, but
also there are models with built-in 3G. There are 2 plans. $14.99 for 250MB/mo, or $29.99 for unlimited data. Wow.

11:15am: 3G is provided by AT&T in the US. International available in June. There is no contract - cancel any time.

11:16am: All models are unlocked and use GSM micro-SIMS.

11:19am: Price: $499 for 16GB, $599 for 32GB, $699 for 64GB. If you want 3G that’s $130 extra. Shipping in 60 days worldwide.

11:22am: Accessories include a nice case, and a dock with a built-in keyboard.

11:30am: Cue video espousing how great the iPad is.

11:34am: “This is a magical device at a breakthrough price”. That’s it folks, thanks for joining us.

Just for fun I’ve created a few polls in the days running up to the event. The polls are closed now, but check it out and see how well you scored.

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll. Note: There is a poll embedded within this post, please visit the site to participate in this post's poll. Note: There is a poll embedded within this post, please visit the site to participate in this post's poll. Note: There is a poll embedded within this post, please visit the site to participate in this post's poll. Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Enjoy!

The assertion by Doug and Boris (and others) that soon we'll be able to create Eclipse projects in less than 15 minutes led me to the interesting discussion of "what does it mean to be an Eclipse project?" In the past, being an Eclipse project meant six things:

1. Source repository at eclipse.org (CVS or SVN)
2. Mailing lists, newsgroups and forums at eclipse.org
3. Following the Eclipse Development Process (committer elections, release reviews, etc)
   
4. Clearing all code through the Eclipse IP Process
5. An opportunity to be part of the annual coordinated release
6. A select few projects can be part of the standard distro

With the advent (soon) of the non-eclipse.org-hosted Eclipse projects, I assume that at least four of these will no longer be required:

1. Source repository at eclipse.org (CVS or SVN) Can host a project anywhere; can use any repository technology
   
2. Mailing lists, newsgroups and forums at eclipse.org Can host the community anywhere
   
3. Following the Eclipse Development Process (committer elections, release reviews, etc) Can follow any reasonable open source process (I'm assuming this because the current EDP requires at least a one month pre-creation review period which is contra-indicated for 15 minute project creations.)
   
4. Clearing all code through the Eclipse IP Process IP Process is optional. (again, because the IP process is slow, if one will be able to create a project in 15 minutes, clearly the current IP process will not be involved)
   
5. An opportunity to be part of the annual coordinated release
6. A select few projects can be part of the standard distro

This seems like an excellent expansion of what it means to be an Eclipse project: basically, it appears that what it will mean is "if your project is Eclipse related and open source, you can be an Eclipse project".¹ At the same time, however, in certain contexts, there is value to items 1-4, so I imagine this new scheme as "Foundation as a Service", in other words, Eclipse projects will be able to subscribe to whichever of the Foundation processes and infrastructure is best suited to that project.

Perhaps you want to use the portal for committer elections: your project could do that; or your project could choose to use a mailing list for elections. Perhaps your employer requires that all the code pass through the Eclipse IP Process: your project could sign up to be one of the "certified IP clean" projects; or if you didn't feel that need at this time, your project could opt-out of that service. And so on... I imagine that each project will have badges on its project page showing which of the various services and characteristics it has, e.g., "active", "diverse", "ip clean", "well documented", etc. Some badges would be algorithmically determined (active), some by the Foundation (ip clean), and some by the community (well documented).

I think this Foundation as a Service scheme is a great way to expand and extend the Eclipse ecosystem. It allows the Foundation to do that which the Foundation is good at while at the same time broadening the definition of what it means to be an Eclipse project.

¹ I have no visibility into the details and thus I'm probably wrong in one or more or all aspects of this idea.

JLibs: SAX-Java Binding, JLaunch etc

Find details about updates here

We have just pushed an updated version of the Java Tutorial to the web to coincide with the release of Java 6 Update 18.

This update to the tutorial features some additions and an update to the Deployment trail:

• Developing Draggable Applets – a new topic describing how to create an applet that can be dragged outside of a browser and dynamically converted into a Java Web Start application.
• Sending Messages to Other Applets has been rewritten.
• Deploying Without the Codebase Attribute – a new section describing how to use functions in the Deployment Toolkit script to develop and test Java Web Start applications without specifying the codebase attribute in the application's Java Network Launch Protocol (JNLP) file. The ability to deploy and launch Java Web Start applications without specifying the codebase attribute is introduced in the Java SE 6 Update 18 release.

Also, we previously reported that some of the Swing examples would not open under NetBeans 6.5 or later, unless the project.xml file was patched. This problem is fixed.

Thanks, as always, for your feedback.

- Sharon Zakhour

One week after releasing the Android Nexus One phone to the public, Google has released the software development kit (SDK) that allows third-party developers to write applications for the phone. Android 2.1 has several new features including:

• Live Wallpapers
• Support for HTML5 video, geolocation, and web storage in WebViews
• New APIs for determining cellular signal strength
• New methods for Android views such as automatic view flippers and opaque views
• Support for a voice recognition audio source and camera-facing microphone
• New features that an app can optionally require before installing, including a multi-touch screen

Version 2.1 is also referred to as Eclair Maintenance Release 1 (MR1), or API level 7 to programmers. In all, 2.1 has 118 API changes, which is approximately a 0.48% difference compared to the previous version.

Availability

Android 2.1 is currently shipping on the HTC Nexus One. The Motorola Droid (Sholes) sold by Verizon is currently at 2.0.1 but users should expect an over the air update “soon” (which could mean anything from 2 weeks to 2 months). As of this writing, all other Android devices (about 80% of the market, according to Google) are running version 1.5 or 1.6:

Source: Google market data collected during the two weeks ending on 1/4/2010

Eventually 2.0.1 will go away, replaced by 2.1 just as 2.0 was replaced by 2.0.1. If current trends continue, we predict that 2.0.1/2.1 will achieve a 25% market share by February, and 50% by the end of the year.

Note that all programs written using the 1.5/1.6 APIs should work on newer devices, but you should test your apps on all targeted versions and screen sizes just to make sure. Programs written to require the 2.0.1/2.1 APIs will not work on older devices.

JFreeChart is off to a great start in 2010 with two exciting new developments that I'm desperately trying to find the time to integrate into the JFreeChart sources. First, Gerrit Grunwald has been doing some stunning work on (amongst other things) a gauge component for Swing:



Check out Gerrit's presentation on Swing user interfaces, grab the sources for the gauge component, or follow his developments on Twitter (hansolo_).

The second, equally stunning, development is a 3D charting library, Jzy3D, developed by Martin Pernollet, based on JOGL and released under the New BSD License. Here's a sample:



Martin kindly approached me about integrating this library within JFreeChart, and I have started sifting through the code. But you don't have to wait, the code is available now...so try it out!

Tim Bray writes:

"The community of developers whose work you see on the Web, who probably don’t know what ADO or UML or JPA even stand for, deploy better systems at less cost in less time at lower risk than we see in the Enterprise. ... More important is the culture: [with] development cycles [no] longer than a single-digit number of weeks."

The Foundation needs to both enable, but also to actively lead, the community toward this kind of development... It should take no more than 15 minutes to start a new project (or new projects will go to github). It should take no more than 15 minutes for a newbie to get started contributing to a project (or people won't join). It should take no more than a week to finalize a release (or we'll be left behind). Etc... There's a lot of good technology at Eclipse and a lot of good people in the community, but the software world is going through one of its regular massive waves of change, and the Foundation processes are contra-indicated for being part of that wave. I want to see those processes changed so that the greatness that is Eclipse can participate in the change that is occurring.

GemStone Smalltalk is awesome.
And now GemDev: Eclipse for Gemstone/S.

As a follow-up to "It's a Trade Association", I thought I'd explain why I conclude that the Foundation is not an open source entity.

I start by asking if you consider Microsoft an open source entity?

Probably not, in spite of Microsoft providing open source project hosting at codeplex.com. Similarly, although Google is very open source friendly and provides open source project hosting at code.google.com, it too is not an open source company¹. The Linux Foundation is clearly an open source organization. Red Hat is widely acknowledged to be an open source company even though it doesn't host the Linux project. And so on... Thus clearly "X hosts open source projects" is not sufficient to qualify X as an open source entity, but what is sufficient? It seems that:

An open source organization or company is one that contributes a significant number of developer-person-hours to open source projects.²

Microsoft does not contribute significantly to open source projects; Red Hat does. The Eclipse Foundation does not; whereas the Eclipse-centric companies do (IBM being the star contributor). Thus the Foundation itself is not an open source organization: it's a trade association of open source companies, and as a trade association it undertakes activities to support those companies (such as mailing lists and source code repositories).

An identical relationship can be seen between, for example, the Seattle Public Library and the Friends of the Seattle Public Library. The Seattle Public Library does all the real library work: it has the books, the buildings and the librarians; the Friends "support library programs, ... promote community awareness of libraries, advocate for robust city funding of The Library, ...". Nobody mistakes the Friends for the actual library, but everyone acknowledges that the Friends play an essential role in maintaining the community around the library. The Eclipse Foundation is the "Friends of the Eclipse projects": it doesn't do the actual project work, but it plays a role in maintaining the community around the projects.

¹ Some people claim that Google is an open source company because it is the world's largest contributor to open source projects, and I'm fine with that position as well: it simply reinforces my point that what makes a company or organization an open source entity is the contribution of developers, not the hosting of projects.

² One could also apply other criteria, such as "primary business success depends on open source" but "supplies developers" seems to be the primary characteristic from which all others derive.

To provide some numbers behind my concerns about the lack of continuing investment in the Eclipse core, I spent some time analyzing the commit log data. At the recent member presentation, Donald said that there are 935 committers at Eclipse (slide 7). That's a good number because it demonstrates a broad set of interests at Eclipse, but I'm primarily concerned about the Eclipse core (the Java IDE plus Equinox) - what are the committer numbers for that essential-to-all-of-us core?

• There have been a total of 1,159 unique committers to all Eclipse projects since 2001.
• Of those, only 227 (19%) have ever worked on the Eclipse core.
• Of those, only 48 (4%) are active today.
• And that 48 represents an almost 20% decline from the high in 2004.¹

So, the Eclipse core is the base of everything that we users use, and the base of everything that the ecosystem sells, and that core has less than 5% of the total committers - that's not a good situation by itself. And then that less than 5% has been declining for years - that's doubly not a good situation.

The Eclipse user base and ecosystem are expanding, but the all-essential core is not. The unsung heros working on the core are not getting the help that they need to continue doing the fantastic things they've been doing for all us. The Foundation needs to lead the way in convincing all the strategic members to put full-time resources into the core [1]. And it needs to lead the way in lowering the barriers for casual contributions to the core [2]. That is what I'm agitating for... That and world peace.

¹ If you consider the core to be just the Java IDE, then the number-still-active is lower and the decline is larger: 25+%.

In "Seven Harsh Truths About Running Online Communities", Paul Boag says "an anti-social [situation] is your fault" and so I wondered what my fault was in causing the reaction to my trade association post. As far as I can tell, it was my use of the word "leadership" in reference to "the Foundation is not providing leadership to solve the Tragedy of the Commons". In reflection, I can see how it could have been misinterpreted as a personal attack rather than a professional disagreement, so let me explain my use of that word. I'll start with what appears to be an unrelated story:

During a recent visit to the Wikimedia Foundation, I had a very interesting discussion about community and change with Sue Gardner (Executive Director) and Erik Möller (Deputy Director). One of the topics we touched on was the video format the Wikimedia Foundation has chosen: the open format Ogg Theora. They spent a lot of time and energy on the format decision because it was a difficult tradeoff: on one hand, choosing a proprietary format (WMF, Quicktime, Flash, etc) would provide immediate access for everyone, but conflict with their goal of "freely available information everywhere for everyone". On the other hand, choosing an open format would limit availability but would ensure the information remains unfettered by a single company. So what should they do?

Instead they chose a third route: they chose an open format but at the same time, used their leadership position in information to convince the major browser vendors to include Ogg in HTML5. This is huge. This is leverage. This is change for the better.

The Eclipse Foundation could play the same leadership role in solving the Tragedy of the Commons. Mike is the charismatic, forceful leader that member companies would follow - in fact, I think he's the only person in the Eclipse ecosystem who could create the kind of corporate investment that is needed - that's why I was a key vote in hiring him at the beginning¹. I believe that no single company is willing to step into the resource vacuum because nobody (not even IBM) has the deep pockets that IBM had from 2000-2004 — our only hope of corporate investment to solve the tragedy is a central leadership bringing the major strategic players to the table to staff the core team.

That's the "leadership" I was talking about. That's my critique; that's one area where, in my professional opinion, the Foundation could be doing better.

The Foundation is doing lots of good things:

• Ralph continues to create a fantastic European community and the repeated success of Eclipse Summit Europe is entirely to his credit
• Donald has taken over EclipseCon and does a fantastic job supporting the member companies
  
• Ian continues to expand the Eclipse DemoCamps and Eclipse Days - an absolutely vital part of the growth of the Eclipse community
• Denis and his team provide solid IT infrastructure
• and more
  

I'm pro-Foundation. Perhaps I don't make that clear enough in my posts, but I am pro-Foundation. Because I believe in the power behind the Foundation, I can be pro-Foundation at the same time I believe there is more it could be doing.

¹ John Weigand and I were the elected Committer reps on the Board. I resigned from the Board when Mike hired me into the Foundation a year later.

Sometimes you may want to quickly generate graphs programmatically and view/analyze those. Examples include, inheritance/type relation diagrams of an object oriented program, function call graphs and any other domain specific graphs (reporting chain of your organization chart for example). I find GXL very useful for this. GXL stands for Graph eXchange Language. It is a simple XML format to specify graphs. A simple graph stating that "JavaFX" language is related to "Java" language is as follows:

File: Test.gxl

<gxl>

<!-- edgemode tells this is directed or undirected graph -->
<graph id="langs" edgemode="directed">

<!-- write your nodes -->
<node id="java"/>
<node id="javafx"/>

<-- now write your edges -->
<edge from="java" to="javafx"/>

</graph>
</gxl>

You can also add number of "attributes" to nodes and edges - like color of the edge, style of the edge and so on. For example, "red" color can be specified for an edge as follows:

<edge from="java" to="javafx">
  <attr name="color"><string>red</string></attr>
</edge>

Now that we have written a simple graph with two nodes and a single edge between them, we may want to view it. There are number of tools/libraries to view GXL documents -- I've used Graphviz. Graphviz displays it's own native format called ".dot". Graphviz comes with a set of command line tools. One such tool is "gxl2dot", which as you'd have guessed, can be used to convert a .gxl file to a .dot file.

    gxl2dot Test.gxl > Test.dot

Once converted the .dot file can be opened in Graphviz GUI and we can export it to .pdf/.jpg/.png and so on. This way you can email the graphs to others and/or publish in your blogs/webpages easily.

The converted .pdf file for the above simple graph is here: test.pdf

I've used GXL graphs in a recent debugging tool related to JavaFX compiler. More on that later...

I believe Eclipse needs to be more welcoming to contributors. I've written about this in the past [1,2,3,4,5] and even suggested some ideas about how Eclipse could improve [6,7,8,9]. So far there's been no major change: it's still just as difficult to contribute. There's no easy way to get started, no easy way to get the code and build it yourself, etc:

1. The IntelliJ home page gives equals time to "Download" and "Contribute". The Eclipse home page strongly emphasizes "Download" but doesn't have the word "contribute".
   
2. The IntelliJ contribution page (1 click from the home page) lists all sorts of ways that you can contribute to the community from the easiest all the way through becoming a committer.
3. That page even has a prominent How to Check Out and Build page, and the process is two simple steps: (a) git, (b) ant. Period. (With Eclipse even the documentation I could find admits that the "documentation [falls] short on some specifics".)

Which IDE is more inviting to contributions?

This post has been revised based on feedback. Some comments may refer to a previous version.

I've been believing and promoting that the Eclipse Foundation is new combination of open source and commercial interests. But I've recently concluded that I was wrong and that the Foundation is an industry trade association.

... an organization founded and funded by businesses that operate in a specific industry. An industry trade association participates in public relations activities such as advertising, education, political donations, lobbying and publishing, but its main focus is collaboration between companies (see "Membership benefits"), or standardization (see "Eclipse industry working groups").

It's ok that the Foundation is an industry trade association, but it means that the open source side of Eclipse (including me) must stop wishing for the Foundation to solve the Tragedy of the Commons and find some other way to make it happen. The Foundation will continue to provide benefits to the corporate members, that's fine - I've always been pro-profit. And the Foundation will continue to do marketing around the open source projects - nobody ever complained about too much PR help!

There will still be a symbiotic relationship between the Foundation and the open source projects, but if the Foundation is not going to provide the leadership and resources to maintain the core, how can we do it ourselves? What are the mechanisms and rewards we need to put in place?
One thing that a number of people have concluded is that we need a repository that is not constrained by the IP process. That should be easy to do (google code or github). What else?

This post has been slightly revised based on feedback. Some comments may refer to a previous version.