I’m switching from self-hosting Redmine to using Pivotal
Tracker for issue tracking on my Open Source projects.

• Rake
• FlexMock
• Builder
• TExp
• Given

All the projects are marked public so you should be able to view
the projects (and subscribe to an RSS feed) without actually signing
up for anything.

Did I miss anything?

All the open tickets should be migrated to Pivotal Tracker. If you
notice anything missing, let me know. Thanks.

String figure books are great resources, but they can be incredibly frustrating, too. Even if you?ve never tried to use one, it?s not hard to imagine having a string looped around your fingers, trying to hold the book open with your knee, and then discovering that the next step wraps onto the next page. You somehow need to turn the page without dropping any strings, and without closing or dropping the book.

This zoomed view also answers another one of the design forces behind Ekawada: ?I don?t understand what this step is telling me to do.? You don?t want to just add verbosity to the instructions, because more verbosity can actually hurt readabilty. (Just try reading these instructions for the ?Apache Door? figure, if you want a concrete example of what I mean.)

Thus, for steps where the instruction itself may be too terse, or ambiguous, I can use the zoomed view to add an illustration, or extra clarification, without bloating the instruction list. When you need more information, you can get at it easily, but for the common case, you can just scan the instruction list.

Tune in next time, when I?ll address another design force behind Ekawada: ?I remember learning this one figure as a kid, but can?t remember how to do it now.?

I?d like to announce a new feature we?re adding to all our hosting plans: integration with SendGrid .

What?
What is Sendgrid? Sendgrid is a service that helps us increase email deliverability, no longer do we, or you the customer need to worry about your outbound email servers being down. On top of that, you also get some really neat statistics, like the ones in the image attached to this post (real stats from our test run). (screenshot)

Why?
Some of our higher traffic websites and their membership systems needed a way to track things like how many of their emails were bouncing, and how often their promotional emails were being opened, this is not a replacement to mailchimp, this is just for inter member communication, and for things like making sure the lost password emails went out and were delivered, opened, clicked etc.

When?
Soon. I?ve started work on a custom plugin that will give you similar stats right within the WordPress admin panel, once it?s out of private beta with the customers who need it the most, it?ll be available to all customers, old and new by default.
It?ll also be available on the WordPress.org plugins directory, and the source code will be on Github as always.

How?
You can find out about the release of this plugin in a few ways.

1. Subscribe to this feed.
2. Subscribe to our newsletter.
3. Become a customer .

In my previous post, I talked a bit about one of the ?forces? that influenced the design of Ekawada, my as-yet-unreleased string figure catalog app for iOS. In this post, I want to talk about another of the forces that affected the app: ?What are some easy figures to do??

It?s not hard to imagine someone with little-to-no string figure experience being curious about the app, especially since it is free, and downloading it just to see what it?s all about. They might want to start with the easiest figure, just to see if it is something they could really learn. How should the application show this to them?

From the UI point of view, I took the easy way out: in the upper-left corner of the index is a toggle that lets you switch between ?ABC? (alphabetical) and ?123? (difficulty) orderings. I?m not best pleased with that solution, though: it?s not very self-explanatory. Expect that to change in a future version of Ekawada, after I have more opportunity to think about how best to present that.

(Ignore for now the blue button at the bottom?that?s there because the view is being filtered to show only the ?starter set? of figures. Tapping that button would return the view to the default of showing all installed figures.)

At any rate, toggling the view to ?123? gives you the figure list, sorted by difficulty (actually complexity?more on that shortly). The first figure in the list is the least complex, and the one at the bottom is the most complex.

Here?s where things get sticky, though. There is no formal, standardized way to evaluate a string figure and say how difficult it is. If you look at the various string figure web sites that try to categorize figures by difficulty, they all do it in a very subjective way. Sure, you may agree that the ?easy? ones are easier than the ?hard? ones, but you may also disagree with specific categorizations.

Anyway.

I wanted a way in Ekawada for people to order figures by difficulty, and thus I needed a way to objectively rate figures. After a bit of experimentation and observation, I came up with a system that considers what types of maneuvers are used in each step, and assigns a number to each type of maneuver. Then, the various maneuvers used in a figure are summed, and the figure is given a rating. ?Opening A?, for instance, is rated a 10, ?An Apache Door? is a 61, and ?Cat?s Cradle? is a whopping 196.

This gets to the point of ?complexity? versus ?difficulty?. Cat?s Cradle is rated at 196, but that?s because it is a complex figure (actually, series of figures), and is not actually very difficult. Thus, the rating still doesn?t necessarily tell you what is easy and what is hard, only what is simple and what is complicated.

Often, that?s good enough. I do plan to tweak the algorithm for computing the complexity after Ekawada is released, based on feedback from users. However, I think it?s good enough for version one as it is.

Next week, I?ll talk about how Ekawada balances another of the design forces on my list: ?I can?t hold a figure on my hands and turn pages at the same time.?

According to the latest java.net poll, the Java community is reacting positively to the news that IBM will be collaborating with Oracle on the OpenJDK project. A total of 267 votes were cast in the poll, which ran for the past week. Here is the actual poll question and the results:

What’s your view of the news that Oracle and IBM will collaborate in the OpenJDK project?

• 18% (48 votes) – It’s the best Java news I’ve heard in a long time
• 30% (81 votes) – It’s definitely positive
• 34% (90 votes) – We’ll see how it works out
• 2% (6 votes) – Makes no difference
• 10% (27 votes) – I consider it a negative development
• 4% (10 votes) – I don’t know
• 2% (5 votes) – Other

Summing the first three options tells us that 82% of the voters think or hope that IBM collaboration in OpenJDK will produce positive results. Only 10% of the voters consider the collaboration to have a downside (unfortunately, no one took the time to post a comment describing the downsides they see).

New poll: Apple’s Java announcement and the future of Java on Mac

The new java.net poll focuses on the Apple announcement that its Java port is being deprecated. This new poll perhaps has a relationship with the previous poll, if one considers the OpenJDK as potentially filling the Java gap that will be left on Mac platforms due to Apple’s decision.

The new poll asks What does the announced deprecation of Java from Mac OS X mean for the future of Java on Mac platforms? Voting will be open for the next week.

Java Today

Dustin Marx provides Ten Tips for Using Java Stack Traces:

Most Java developers are somewhat familiar with Java stack traces and how to read and analyze stack traces. However, for beginning Java developers, there are some areas of stack traces that might be a little confusing. In this post, I look at some tips for reading Java stack traces and responding appropriately based on what the stack trace reports…

Alexis Moussine-Pouchkine introduces A practical guide to configuring and testing GlassFish 3.1 Clustering:

The main theme for GlassFish 3.1 is clustering which really encompasses centralized admin, load-balancing and in-memory state replication (HA). These features are all available in the 2.x family and are now being introduced in the OSGi-based and JavaEE6-compatible GlassFish product. While a lot of engineering time has been spent on making the clustering configuration as easy as possible…

Adam Bien recalls Steve Jobs at JavaOne, Mac OS X and Java, then fast-forwards to today:

Scott McNealy and Steve Jobs at JavaOne. “…One of the big surprises was the presence of the venerable Steve Jobs. Jobs underscored the commitment by Apple Computer to ship the Java 2 Standard Edition (J2SE) with their upcoming MacOS X release later this year. This is great news for Mac users and Java developers alike…”

The JCP Program Office announces the availability of the JCP EC Elections Discussion Board:

The final phase of the 2010 JCP program EC Elections is going on now and ends November 1 at midnight PST (November 2 at 8:00 AM UTC). This is an opportunity to have your thoughts, views, and opinions heard-all while helping shape the future of Java technology. There is a discussion board on jcp.org for community members to post questions to the candidates for the 2010 JCP EC Elections…

Spotlights

Our latest java.net Spotlight is the DEVOXX Supporting JUGs page:

67 Java User Groups have registered as supporting DEVOXX this year. The java.net Java User Groups Community notes that the “official” annual Java User Group leaders networking BOF at DEVOXX is scheduled for November 18 at 20:00.

We’re also highlighting Jim Weaver’s “Eye on Visage: Compiler Preview #1 Available”:

The Visage Programming Language is moving forward, with Compiler Preview #1 available now.  This preview features Default Properties, which create a simplified syntax that makes it easier to read nested data structures.  A logo has also been chosen for the project as well…

Poll

Our current java.net poll asks What does the announced deprecation of Java from Mac OS X mean for the future of Java on Mac platforms? Voting will be open through next Monday.

Subscriptions and Archives: You can subscribe to this blog using the java.net Editor’s Blog Feed. You can also subscribe to the Java Today RSS feed and the java.net blogs feed. You can find historical archives of what has appeared the front page of java.net in the java.net home page archive.

– Kevin Farnham

Twitter: @kevin_farnham

Google maps was a useful hit from the moment it went on line. Since then thousands of web pages have added map capability to their sites, courtesy of Google. Let me illustrate how you can add Google maps to your Java application.

Background
Google furnishes its maps via a simple REST request. Does this mean you need to add some fancy REST framework to your application? Not at all! Java provides all you need right in the standard libraries, and it is very easy to do. (that’s part of the real elegance of REST)

Getting It
To request a map, you start with the following URL:

http://maps.google.com/maps/api/staticmap?

After the question mark, append all of the details you wish to be included in the map, separated by ampersand (&) symbols. For example:

http://maps.google.com/maps/api/staticmap?center=Brooklyn+Bridge,New+York,NY&
zoom=14&size=512x512&maptype=roadmap

This requests a road map centering on the Brooklyn Bridge, in New York City, at zoom level 14, 512×512 pixels in size. There’s a very rich collection of options for specifying and decorating maps, Google has very helpfully made a highly detailed page explaining them all.

As I hope you’ve reasonably guessed; the http request dutifully returns an image of the map requested. That’s all there is to it!

Using It
Happily, Java provides all the resources you need to use this great Google feature right in the Standard Edition. Simply create a java.net.URLConnection, request the content, and generate the map image. If you’ve not done this before, fear not, as Java makes it very easy to do, it looks a bit like this:

URLConnection con = new URL("http://maps...").openConnection();
InputStream is = con.getInputStream();
byte bytes[] = new byte[con.getContentLength()];
is.read(bytes);
is.close();
Toolkit tk = getToolkit();
map = tk.createImage(bytes);
tk.prepareImage(map, -1, -1, null);

The variable map now has the image, ready for presentation! Remarkably easy wasn’t it? That’s all it takes, and you can enjoy the full functionality of Google maps in any Java application.

Want More?
Of course I’m not going to leave you hanging like that! I’ve written a complete free runnable GoogleMap Java component for you, it’s less than one page of code. Try it out and let me know what you think.

Enjoy,

John

 In my last blog entry, I described VideoSharing which is an application that uses Web sockets to remote UI events and enable participants to control HTML5 video players remotely. Today, I’d like to share with you a similar type of collaboration application, but this time one that uses other HTML5 features: namely, 2D canvases and client SQL databases. The name of this application is BoardMirror.

 Rather than sharing a video object, like in VideoSharing, BoardMirror shares a canvas object and lets participants draw figures on it. For the sake of simplicity, only two figures can be drawn on a canvas: rectangles and circles. These figures are drawn in a random location inside the canvas and using a random color. Here is a screenshot of the application:

The mirror or collaboration part of the application is the result of copying these figures in all the other canvases that are connected to the server. And, of course, we use Web sockets for this purpose. A Web socket is nothing more than a socket connection that can be established between a (modern) Web browser and a Web container. It provides a low-latency, bi-directional communication parallel to the HTTP channel. It is Ajax/Comet on steroids.

In addition, the BoardMirror application has the ability to store your work of art in a local SQL database in the browser. This is done using one of the new APIs in HTML5. In fact, HTML5 has two options for storing data on the client side: Web Storage and Web SQL Databases. The former is implemented by most browsers and can store name-value pairs; the latter, as suggested by its name, gives you full SQL storage but it’s only implement in some browsers.

Let me start describing the canvas and 2D APIs first. As in the VideoSharing application, we use a JSF facelet to define our main page:

    <html ...>
      ...
      <h:body>
          <h5:canvas width="600" height="400"/>
          <h:outputScript library="js" name="json2.js" target="head"/>
          <h:outputScript library="js" name="app.js" target="head"/>
          <br/>
          <input type="button" value="Rectangle" onclick="APP.drawRectangle()"/>
          <input type="button" value="Circle" onclick="APP.drawCircle()"/>
          <input type="button" value="Clear" onclick="APP.clearCanvas(true)"/>
          <input type="button" value="Load" onclick="APP.loadCanvas()"/>
          <input type="button" value="Save" onclick="APP.saveCanvas()"/>
      </h:body>
   <html>

where the h5:canvas element is defined in the same way as h5:video in the VideoSharing blog. What follows is a JavaScript method that draws a rectangle, sends the rectangle to be drawn remotely and stores the rectangle in a local data structure so that it can saved in a local database, if so requested by the user.

    drawRectangle: function() {
        // Get access to canvas and draw rectangle
        var canvas = this.getCanvas();
        var ctx = canvas.getContext('2d');
        ctx.fillStyle = this.random.color();
        var width = this.random.number(40, 100);
        var height = this.random.number(40, 100);
        var x = this.random.number(0, canvas.width - width);
        var y = this.random.number(0, canvas.height - height);
        ctx.fillRect(x, y, width, height);

        // Mirror rectangle via web sockets and store in array
        var shape = {type: "rectangle", x: x, y: y, width: width,
            height: height, color: ctx.fillStyle};
        this.network.send(JSON.stringify(shape));
        this.shapes[this.shapes.length] = shape;
    },

The code that draws the rectangle should be self explanatory, yet another 2D API! The last three lines of code are there to: create a shape object, send the shape over the network and store the shape in an array, respectively. The network object is initialized in the same way as in the VideoSharing application; only it’s onmessage handler is different:

    websocket.onmessage = function (evt) {
        var shape = JSON.parse(evt.data);
        if (shape.type == "clear") {
            APP.clearCanvas(false);
        } else {
            APP.mirrorShape(shape, false);
        }
    };

Since a canvas can be remotely cleared, there’s a special clear shape type that triggers such a remote event. For all the other shapes (real shapes, that is), the mirrorShape() method is called. This method simply draws the shape in the local canvas (without resending the shape over the network again!).

As stated above, this application also supports storing your canvas in a local database. This is done by storing all the shapes in JSON format. The database logic is implemented in the object returned by the database function shown next.

    var database = function (db) {
      return {
        error: function (err) {
            alert(err.message);
        },
        initialize: function() {
            if (window.openDatabase) {
                db = openDatabase('shapes', '1.0', 'All Shapes', 64 * 1024);
                db.transaction(
                    function (tx) {
                        tx.executeSql('CREATE TABLE shapes (id UNIQUE, shape STRING)')
                    });
                this.load();
            } else {
                alert("Your browser does not support SQL databases");
            }
        },
        load: function() {
            db.transaction(function (tx) {
                tx.executeSql('SELECT * FROM shapes',
                [],
                function (tx, results) {
                    for (var i = 0; i < results.rows.length; i++) {
                        var shape = JSON.parse(results.rows.item(i).shape);
                        APP.shapes[i] = shape;
                    }
                    APP.refreshCanvas();
                },
                this.error)
            } );
        },
        save: function() {
            db.transaction(function (tx) {
                tx.executeSql("DELETE FROM shapes");
                for (var i = 0; i < APP.shapes.length; i++) {
                    tx.executeSql('INSERT INTO shapes (id, shape) VALUES (?, ?)',
                    [i, JSON.stringify(APP.shapes[i])], this.error);
                }
                alert("Canvas has been saved into a local database");
            });
        }
      }
    };

In the initialize() method, the SQL database is opened and a table is created to store the shapes. If the table exists, an error will be ignored since no error handler is provided in the call to tx.executeSql(). The load() method runs a select query without any parameters (notice the "[]") and provides a results handler that parses and stores the shape in the array. The save() method clears the table and then inserts the shape one by one into the database. Note how parameters are passed to fill in the value placeholders denoted by "?" in the SQL string. This should be familiar to anyone that has written JDBC code before.

One interesting aspect of the SQL API is that, following a pattern that is common in Javascript, all operations are asynchronous. This is why functions are passed to methods like db.transaction() and tx.executeSql(). However, the order in which SQL statements are executed follows the execution order of the calls to tx.executeSql(). That is, statements are always queued and run in order —and this is why methods like save() above work.

The Web sockets code in Glassfish that supports this application is identical to that in the VideoSharing application. For more information, the reader is referred to the VideoSharing screencast or to the attached source code bundle. Please note that Web sockets are not enabled by default in Glassfish. To enable them you must execute the following single-line command on your domain:

asadmin set configs.config.server-config.network-config.protocols.protocol.http-listener-1.http.
websockets-support-enabled=true

A good starting point for thinking about the consequences of the Oracle + IBM deal is in the blog of Gianugo Rabellino:

… I will readily admit there is a positive side in IBM ditching Harmony and joining OpenJDK, as the world is now closer to enjoy a strong Java platform.

The problem is the price tag. With IBM surrendering to the Oracle bully, the Java Community Process is now as credible as Weekly World News, and basically nobody is safe. The spin pros have been busy focusing on a strengthened, renewed Java effort, and they conveniently (or should I say pragmatically?) forgot to mention how dangerous it is to be under the illusion that the JCP is a neutral and cooperative body producing Open Source friendly specs when the truth is Oracle can and do whatever they want, including breaching the JSPA and getting away with it. Or play puppet master even with mighty IBM. I wish all my FSF friends will soon recover from the initial excitement for a GPLed Java and realize how, really, the party is over and we have much less freedom than before. And maybe a better JVM with no competitors – but is it worth the price?

My point. First, I’m sad that Harmony is probably going to die. Having one more independent implementation of Java, under a different license, was a plus for the community. In any case, things haven’t changed with the Oracle management: the no-TCK policy for Harmony was started under Sun and, in my opinion, it was not something unexpected, as they choose the GPL license that guarantees the control of the product by means of the original creator (note that I’m not criticizing Sun’s approach: I understand that from the corporate point of view it could have been a good move, the problem here is harmonizing the corporate’s and the community’s needs). 

I disagree with Gianugo when it says that "Java is not free". "Freedom" to me is a shades-of-gray concept, not black and white. Definitely, we’re less free if Harmony goes; but we’re still free to fork OpenJDK, if we want. While full light hasn’t been shed on the scene yet, my opinion is that forking the GPLv2 OpenJDK would save you from any patent litigation. So, my rephrasing of Gianugo’s point is that we have to understand how much freedom we have and whether we’re free enough with the single choices: OpenJDK or an OpenJDK fork. At the moment, I don’t know, but I suppose this situation gives use some decent protection. We need to think more about that.

Let’s remember that "freedom to fork" is for us a way to protect ourselves from a possible future Java evolution that we don’t like. So, to decide whether Java is free enough or not, we should start with writing down what we’d like to do and protect from. A good starting point are the four freedoms defined by the FSF:

• The freedom to run the program, for any purpose (freedom 0).
• The freedom to study how the program works, and change it to make it do what you wish (freedom 1). Access to the source code is a precondition for this.
• The freedom to redistribute copies so you can help your neighbor (freedom 2).
• The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.

So, in future discussions, I’d really like to see "free" with a quantification, rather than an absolute quality.

A final consideration from me. There’s some discussion about whether Harmony could survive after being abandoned by IBM or not. Stephen Colebourne (who’s supposed to know what he’s talking about) looks pessimistic:

While never solely an IBM project, I would expect this to effectively mean the termination of the Harmony project.

Other commenters disagree and think that Google could step in, given its interest in Harmony as the basis for Android (even though I have still to understand how, in 2010, the two projects are really related). I feel Google is really alone after the IBM move (I suppose that other corporates will jump on the Oracle + IBM wagon), but they have got large shoulders.

Now, my point. Let’s suppose that there’s no Oracle lawsuit against Android (hence, implicitly, against Harmony), or that Oracle loses the lawsuit. Let’s suppose at a certain point the community really breaks with Oracle and moves away from Java, deciding to create a *ava fork that it’s not based on the OpenJDK because, for some reason, it reveals not to be free enough. It would be possible to resume work on Harmony: the fact that you don’t have a TCK for it just means you can’t call it Java™. But the community, by testing its projects on it, would be able to determine whether it’s really Java compatible and a viable escape way. In case of a final break with the Java steward, nobody would be much fond of the Java name, being the effectiveness of the solution the only important point.

Now, reading "never solely an IBM project, I’d expect this to effectively mean the termination", or even optimistic people seeing a future to Harmony but only bound to Google stepping in, reinforces my idea that the community is not able to run a *VM technology alone, without the support of a major corporate. Isn’t this the real problem, indeed, beyond any TCK or legal disputation?

PS As a further food for brain, I’ve learnt that Shark has been finally merged to OpenJDK 7. Shark is an IcedTea contribution, allowing to use the LLVM JIT to run Java bytecode. It has been introduced to extend the supported microprocessor architectures and simplify the porting process. It could be an escape lane in case the community decides to be free to choose a different *VM than the one coming from Oracle or IBM. LLVM is developed in the open (BSD license) by the University of Illinois, but my understanding is that Apple’s funding and contributions are fundamental for this project. This seems to confirm that for a successful *VM technology to exist, you need a large corporate. And the problem remains.

Content available at: http://blogs.sun.com/arungupta/entry/screencast_32_osgi_enabled_java