The lab utilizes the maven-lab-plugin, which can be used to create step-by-step labs using Maven.

During the lab, i wanted to know which step I was at and I figured that there should be a goal for that. To list the available goals for a maven plugin you can use the goal help:describe like this:

  $ maven help:describe -DgroupId=com.jayway.maven.plugins.lab -DartifactId=maven-lab-plugin

This will give you an output like:

Name: maven-lab-plugin Maven Mojo
Description: Maven plugin used to create labs that provide more code once a
  step has been completed. Labs are a useful way to learn new technologies,
  frameworks and tools.
Group Id: com.jayway.maven.plugins.lab
Artifact Id: maven-lab-plugin
Version: 1.0.0.RELEASE
Goal Prefix: lab

This plugin has 7 goals:

lab:create
  Description: Goal to chunkify

lab:currentStep
  Description: Get the current step no

lab:findMax
  Description: Goal to find the max version

lab:init
  Description: Goal to create and initialize a lab.

lab:next
  Description: Change to next step

lab:reset
  Description: Goal to create and initialize a lab.

lab:setStep
  Description: Change version to versionNo

For more information, run 'mvn help:describe [...] -Ddetail'

1. Bugfix for NPE when calling facebookStore.createTestUser(false,"...").
2. Added possibility of using a provided HttpClient instance in HttpClientFacebookTestUserStore.
3. Added unit test that displays the use of json-path when asserting data.

Here's a quick reminder of how to create test users for an application. The creation process is handled by an instance of FacebookTestUserStore, e.g. The HttpClientFacebookTestUserStore which uses Apache HttpClient as communication method. The class needs the application ID and the application secret for the application in order to be able to create the users and this is specified in the constructor:

FacebookTestUserStore facebookStore = new HttpClientFacebookTestUserStore("<appId>", "<appSecret>"));

Now you have a choice when creating a test user: You may say that the test user should accept the privileges that you specify for it, which is done by:

FacebookTestUserAccount aTestUser = facebookStore.createTestUser(true, "read_stream");

If you want to give a choice to the test user whether the privileges should be accepted or not, you do the following:

FacebookTestUserAccount aTestUser = facebookStore.createTestUser(false, "read_stream");

The accept/decline choice takes part in the web browser, hence you need the login URL for the test user to access the page. This URL is accessible from the FacebookTestUserAccount:

aTestUser.loginUrl();

Specifying a HttpClient instance to HttpClientFacebookTestUserStore

There might be occasions where you need a special HttpClient instance for communication, for example one instance with proxy settings configures, or another instance where you have stubbed all the communication that takes place. To provide the instance to HttpClientFacebookTestUserStore, just specify it in the constructor:

HttpClient httpClient = new DefaultHttpClient();
FacebookTestUserStore facebookStore = new HttpClientFacebookTestUserStore("<appId>", "<appSecret>", httpClient));

Using json-assert to verify application behavior

The json-assert project, which uses json-path can be used to make life a little less verbose when asserting on data from the JSON document representations of the Facebook data streams that are available in the FacebookTestUserAccount. For example, the user details of a test user can be accessed like this:

aTestUser.getUserDetails();

The result is a java.lang.String containing a JSON Document. To make it easier to assert that the user details actually contain the expected data, you may use json-assert and Hamcrest matchers:

String userDetails = account.getUserDetails();

JsonAssert.with(userDetails).assertThat("$.first_name", equalTo("Sue"));
JsonAssert.with(userDetails).assertThat("$.last_name", equalTo("Ellen"));

Feel free to test it out, the code is open source an can be found on Maven central or on the
Facebook Test Java API project page.

/Tobias

is:unread label:inbox

This will list all unread mails in the inbox. Unfortunately this query is useless when saved
as a filter, as new mail will not be processed by operators such as in:, has: and so on.

The pom is configured to use two different plugins depending on which operating system that is executing it.
On Windows, a Launch4j project plugin will be used. On OS X the osxappbundle plugin is used, which creates an OS X application directory structure and uses the JavaApplicationStub binary for launching the application.

The <profile> tag is used for deciding which plugin to use depending on operating system.

The pom also points out different application icons for the binaries, OS X requires the icon to be in the icns and windows in the ico format.

The wrapped application has a main class in the file com.jayway.wrappedapplication.Launcher

The pom.xml

  4.0.0
  com.jayway.wrappedapplication
  launcher
jar
  1.0-SNAPSHOT
  launcher
  http://maven.apache.org


      windows-deploy
      
        
          Windows
        
      
      


            org.bluestemsoftware.open.maven.plugin
            launch4j-plugin
            1.5.0.0
            
              
                launch4j
verify
                
                  launch4j
                
                
                  false
gui
                  ${project.build.directory}/relauncher-${project.version}.exe
                  ${project.build.directory}/${project.build.finalName}.jar
                  Launcher
                  
                    1.6.0
                  
                  
                    com.jayway.wrappedapplication.Launcher
                    false
anything
                  
                  ${basedir}/build-resources/win/icons/application.ico
                
              
            
          
        
      
    

      
        
          mac
        
      
      


            org.codehaus.mojo
            osxappbundle-maven-plugin
            1.0-alpha-2
            
              com.jayway.wrappedapplication.Launcher
              ${basedir}/build-resources/osx/icons/application.icns
            
            
              
package
                
                  bundle
                
              
            
          
        
      
    
  

And that's it.

The short story of the workaround it is to disable the advanced attachment features in Gmail.

You can look at the blog post to find out when the problem occur, why it does and why the workaround helps:

[1] http://db.tidbits.com/article/11495

To simulate the behavior using functionality provided by maps v3 API, you'll need to find an element that supports the drag event, such as the Marker object. A marker has a position, a shape and provides events such as click, dragstart, drag and dragend.

The code

First off, we need to load the google maps API and specify which version to use. The code uses some extra goodies to calculate the length of the line, which is provided in the geometry library and it looks like this is available in the v3.3 of the API. Here's how to do specify this:

   <script type="text/javascript" src="http://maps.google.com/maps/api/js?libraries=geometry&sensor=false&v=3.3"></script>

The complete code looks like:

<!DOCTYPE html>
<html>
<head>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no"/>
    <style type="text/css">
        html {
            height: 100%
        }

        body {
            height: 100%;
            margin: 0px;
            padding: 0px
        }

        #map_canvas {
            height: 100%
        }
    </style>
    <script type="text/javascript"
            src="http://maps.google.com/maps/api/js?libraries=geometry&sensor=false&v=3.3">
    </script>
    <script type="text/javascript">
        var g = google.maps;
        function initialize() {
            var latlng = new g.LatLng(62.397, 12.644);
            var myOptions = {
                zoom: 4,
                center: latlng,
                mapTypeId: g.MapTypeId.ROADMAP
            };
            var map = new g.Map(document.getElementById("map_canvas"), myOptions);
            registerMapDragHandler(map);
        }

        function registerMapDragHandler(aMap) {

            var map = aMap;

            g.event.addListener(map, 'click', function(event) {
                createLineBeingDragged(map, event.latLng);
            });

            function createLineBeingDragged(map, pos) {
                var line = new g.Polyline({map: map, path: [pos, pos]});
                g.event.addListener(map, 'mousemove', function(event) {
                    line.getPath().setAt(1, event.latLng);
                });
                g.event.addListener(line, 'click', function(event) {
                    g.event.clearListeners(map, 'mousemove');
                    g.event.clearListeners(line, 'click');
                    createMarkersForLine(map, line);
                });

                function createMarkersForLine(map, line) {
                    var startMarker = createMarker(line, 0);
                    var endMarker = createMarker(line, 1);
                    startMarker.nextMarker = endMarker;
                    endMarker.previousMarker = startMarker;
                }

                function createMarker(line, pathPos) {
                    var position = line.getPath().getAt(pathPos);
                    var marker = new g.Marker({map: map, position: position, visible: true, flat: true, draggable: true, raiseOnDrag: false});

                    // Marker functions
                    marker.getPathIndex = function() {
                        if (this.previousMarker != null) {
                            return this.previousMarker.getPathIndex() + 1;
                        } else {
                            return 0;
                        }
                    }

                    marker.startDrag = function(pos) {
                        if (!marker.previousMarker || !marker.nextMarker) {
                            line.getPath().insertAt(marker.getPathIndex(), pos);
                            var newMarker = createMarker(line, marker.getPathIndex());
                            if (marker.nextMarker) {
                                newMarker.previousMarker = marker;
                                newMarker.nextMarker = marker.nextMarker;
                                newMarker.nextMarker.previousMarker = newMarker;
                                marker.nextMarker = newMarker;
                            } else {
                                newMarker.nextMarker = marker;
                                newMarker.previousMarker = marker.previousMarker;
                                newMarker.previousMarker.nextMarker = newMarker;
                                marker.previousMarker = newMarker;
                            }
                        }
                    }

                    marker.beingDragged = function() {
                        line.getPath().setAt(marker.getPathIndex(), marker.getPosition());
                    }

                    // Listeners
                    g.event.addListener(marker, 'dragstart', function(event) {
                        marker.startDrag(event.latLng);
                    });

                    g.event.addListener(marker, 'drag', function(event) {
                        marker.beingDragged();
                    });

                    g.event.addListener(marker, 'click', function(event) {
                        var length = g.geometry.spherical.computeLength(line.getPath()) / 1000;
                        var infoWindow = new g.InfoWindow(
                        {
                            content: "<ul><li>Line length: " + length.toFixed(2) + " km</li>"+
                                    "<li>Latitude: " + marker.getPosition().lat().toFixed(6) + "</li>"+
                                    "<li>Longitude: " + marker.getPosition().lng().toFixed(6) + "</ul>"
                        });
                        infoWindow.open(map, marker);
                    });

                    return marker;
                }
            }
        }
    </script>
</head>
<body onload="initialize()">
<div id="map_canvas" style="width:100%; height:100%"></div>
</body>
</html>

To start drawing, click on the map to specify the starting point and move the mouse to the end point.

The highlighted function is the most interesting. It creates a marker representing one segment of the path of a PolyLine. The marker knows about the previous and next marker and calculates its position in the MVCArray of the path so that it updates the geo-position of the correct segment. This is done by the getPathIndex() function added to the marker.

The Marker.dragStart() function checks whether the marker is the first or last marker in the path. If it is, a segment is added to the PolyLine at the geo-position where the drag starts, and a new marker is created representing the new segment. This means that the line is extended when dragging the end markers.

The Marker.beingDragged() function updates the position of the segment for the PolyLine to the geo-position for the marker, which makes the segment 'editable'.

When clicking on a marker, the length of the line is computed using the google.maps.geometry.spherical.computeLength() function and an InfoWindow is shown displaying the length and the longitude/latitude for the selected marker.

Conclusion

It is possible to simulate the older Google Maps Javascript V2 functionality for editing shapes but it requires you to write your own editing functionality. The code above is just a proof-of-concept and needs a lot more love and caring to be useful.

Quick access to the Terminal

In order not to be disctracted from your line of thoughts and leave the flow, you need to have a quick way of accessing your Terminal. That goes for other applications, and files, as well. I prefer to use Quicksilver myself, which pops-up a small UI with suggestions of what application, or file, to open. The UI is visible by pressing a hot-key. If you want to open the Terminal, you start writing the application name: ter and the Icon of the application and the name will be shown to you (in my case Terminal). When the right application icon is presented, you press Enter and the application is launched.

QuickSilver UI

Quicksilver can do a whole lot of other things, I mainly use it for launching programs and occasionally to open recently opened files. Opening applications this way takes fractions of a second, compared to finding the application in the launch bar.

Bash completion

To work effectively from the command prompt you want to use completions when writing. For example, to navigate around in the file system with the cd command, you would press Tab to get the path filled in or get suggestions of available resources that matches what you have started to write.

OS X and bash comes with a number of these completions out of the box, but you can get even more support by installing bash_completions. One way of doing this is to install MacPorts, which according to their site is "an open-source community initiative to design an easy-to-use system for compiling, installing, and upgrading either command-line, X11 or Aqua based open-source software on the Mac OS X operating system."

After installing MacPorts, you can install bash completion by issuing:

sudo port install bash-completion

Then it needs to be activated, by pointing out the shell-script file from your .profile (or .bash_profile if you have one of those). Open the file ~/.profile in a text editor and add the lines:

if [ -f /opt/local/etc/bash_completion ]; then
    . /opt/local/etc/bash_completion
fi

These settings are applied when you open up a new Terminal window. Depending on which file you have edited, you may have to logout and login again for the system to re-read the files.

One very nice example of the added completions is the ssh copy command scp that now have remote file completion support, that is if the command can access the server without having to prompt you for username/password. This can be achieved by using passwordless logins.

This means that you can write something like:

scp some.server.com:~/bac

and then press Tab to get completed with

scp some.server.com:~/backup-last-release

on the remote server. Isn't that cool?

You can see a list of other programs that now have gotten bash completion support by listing the files in /opt/local/etc/bash_completion.d directory. Examples of supported programs are: Apache ant, ssh, MacPorts, perl, mysqladmin etc.

Bash completion for subversion

If use command-line subversion, installed using MacPorts, and want to add completions then you write:

sudo port install subversion +tools

And activate it by adding the following lines to your .profile file:

if [ -f /opt/local/share/subversion/tools/client-side/bash_completion ]; then
    . /opt/local/share/subversion/tools/client-side/bash_completion
fi

Bash completion for Git

If you have installed git using MacPorts, you can get additional completions by writing:

sudo port install git-core +bash_completion

and then add the following lines to your .profile file:

if [ -f /opt/local/share/doc/git-core/contrib/completion/git-completion.bash ]; then
    . /opt/local/share/doc/git-core/contrib/completion/git-completion.bash
fi

Reverse history search

If you often find yourself looking for previously written commands in the Terminal history by pressing the Up/Down arrow, you may speed up your search by activating the reverse-interactive-history-search using Ctrl + R. This will give you a prompt looking like:

(reverse-i-search)`':

Here you can find commands in the history by writing the first letters, such as cd which might give you:

(reverse-i-search)`cd': cd dev/myproject/target/classes

If that was the command you were looking for, press Enter to activate, or press Ctrl + R to find the next match. If you want to edit the command before activating it, you press Right arrow. Pressing Escape exits the reverse-i-search and returns to your normal prompt.

History ignore

If you still find yourself using the Up/Down arrows to navigate the history, you can make it more effective by specifying what should not appear in the history. For example, the ls command is probably faster to write than to find. Also the same command appearing three times in a row in the history is just annoying.

All of this can be controlled by setting the $HISTIGNORE variable. It takes a colon-separated list of ignores, where the & sign is a special construct for the previous history line. To ignore the ls command and those pesky duplicates, you write:

export $HISTIGNORE="&:ls"

or better yet, add the line to your .profile file to have it activated all the time.

If you have written a Java application and want to enable Growl notifications for it, you previously had the possibility to use cocoa Java bindings for Growl but they have been deprecated and are no longer supported. However, there is an AppleScript API that together with the AppleScript script engine can give access to Growl from Java. If you use Java 6 that is.

The example

This example code uses the Growl class, defined below, which uses the Growl AppleScript API and Java AppleScript script engine in OS X:

public class GrowlDemo {
    public static void main(String... args) {
        // System and boss messages will be enabled by default, spam must be configured in growl settings
        Growl growl = new Growl("Growl Demo",
                new String[]{"system", "boss", "spam"},
                new String[]{"system", "boss"});
        growl.init();
        growl.registerApplication();
        growl.notify("system", "System message", "This seem to be working");
        growl.notify("boss", "From: Big brother", "Get back to work!");
        growl.notify("spam", "Get a diploma", "By going to university");
    }
}

The output will look something like:

Demo code output

Now on to the Growl AppleScript API implementation.

The Growl code

In order to use the AppleScript engine, an engine and a context has to be retrieved. Here's an example:

ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine appleScriptEngine = scriptEngineManager.getEngineByName("AppleScript");
Script script = "<AppleScript syntax goes here>";
appleScriptEngine.eval(script, appleScriptEngine.getContext());

The rest of the code is just building the AppleScript API syntax for Growl:

package com.jayway.growl;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

/**
 * Notify with Growl using AppleScript and Java Script engine.
 *
 * @author Tobias Södergren, Jayway
 */
public class Growl {
    private static final String GROWL_APPLICATION = "GrowlHelperApp";
    private final String applicationName;
    private String[] availableNotifications;
    private String[] enabledNotifications;
    private ScriptEngine appleScriptEngine;

    public Growl(String applicationName, String[] availableNotifications, String[] enabledNotifications) {
        this.applicationName = applicationName;
        this.availableNotifications = availableNotifications;
        this.enabledNotifications = enabledNotifications;
    }

    public void init() {
        ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
        appleScriptEngine = scriptEngineManager.getEngineByName("AppleScript");
        if (appleScriptEngine == null) {
            throw new RuntimeException("No AppleScriptEngine available");
        }

        if (!isGrowlEnabled()) {
            throw new RuntimeException("No Growl process was found.");
        }
    }

    public void registerApplication() {
        String script = script().add("tell application ")
                .quote(GROWL_APPLICATION)
                .nextRow("set the availableList to ")
                .array(availableNotifications)
                .nextRow("set the enabledList to ")
                .array(enabledNotifications)
                .nextRow("register as application ")
                .quote(applicationName)
                .add(" all notifications availableList default notifications enabledList")
                .nextRow("end tell").get();
        executeScript(script);
    }

    public void notify(String notificationName, String title, String message) {
        String script = script().add("tell application ")
                .quote(GROWL_APPLICATION)
                .nextRow("notify with name ").quote(notificationName)
                .add(" title ").quote(title)
                .add(" description ").quote(message)
                .add(" application name ").quote(applicationName)
                .nextRow("end tell").get();
        executeScript(script);
    }

    private boolean isGrowlEnabled() {
        String script = script().add("tell application ")
                .quote("System Events")
                .nextRow("return count of (every process whose name is ")
                .quote(GROWL_APPLICATION).add(") > 0")
                .nextRow("end tell")
                .get();
        long count = executeScript(script, 0L);
        return count > 0;
    }

    private <T> T executeScript(String script, T defaultValue) {
        try {
            return (T) appleScriptEngine.eval(script, appleScriptEngine.getContext());
        } catch (ScriptException e) {
            return defaultValue;
        }
    }

    private void executeScript(String script) {
        try {
            appleScriptEngine.eval(script, appleScriptEngine.getContext());
        } catch (ScriptException e) {
            // log.error("Problem executing script, e);
        }
    }

    private ScriptBuilder script() {
        return new ScriptBuilder();
    }

    private class ScriptBuilder {
        StringBuilder builder = new StringBuilder();

        public ScriptBuilder add(String text) {
            builder.append(text);
            return this;
        }

        public ScriptBuilder quote(String text) {
            builder.append("\"");
            builder.append(text);
            builder.append("\"");
            return this;
        }

        public ScriptBuilder nextRow(String text) {
            builder.append("\n");
            builder.append(text);
            return this;
        }

        public String get() {
            return builder.toString();
        }

        public ScriptBuilder array(String[] array) {
            builder.append("{");
            for (int i = 0; i < array.length; i++) {
                if (i > 0) {
                    builder.append(", ");
                }
                builder.append("\"");
                builder.append(array[i]);
                builder.append("\"");
            }

            builder.append("}");
            return this;
        }
    }
}

That's it.

Code example

This method copies a test user to another FacebookTestUserStore instance:

   FacebookTestUserStore facebookStore = new HttpClientFacebookTestUserStore("<appId>", "<appSecret>"));
   FacebookTestUserStore facebookStore2 = new HttpClientFacebookTestUserStore("<otherAppId>", "<otherAppSecret>"));
   FacebookTestUserAccount account = facebookStore.createTestUser(true, "<facebook_permissions>");
   account.copyToOtherApplication(facebookStore2, true, "<facebook_permissions>");

This one can be used when you just want to specify the other application information

   FacebookTestUserStore facebookStore = new HttpClientFacebookTestUserStore("<appId>", "<appSecret>"));
   FacebookTestUserAccount account = facebookStore.createTestUser(true, "<facebook_permissions>");
   account.copyToOtherApplication("<otherAppId>", "<otherAppSecret>", true, "<facebook_permissions>");

Note that <appId> and <appSecret> should be replaced with the values from the application to copy from (the one owning the test user), <otherAppId> and <otherAppSecret> should be replaced with the values for the application to which the user should be copied.

How to get it

It is available on Maven central, use the following dependency:

<dependency>
  <groupId>com.jayway.facebooktestjavaapi</groupId>
  <artifactId>facebook-test-java-api</artifactId>
  <version>1.1.4</version>
</dependency>

or have a look at the project page for downloads:
http://code.google.com/p/facebook-test-java-api/

The application I was working on, which integrated with Facebook, needed automated integration tests but I could not find any Java API for managing test users. The end result is facebook-test-java-api, a project aimed at testing Facebook application integration.

Usage

FacebookTestUserStore facebookStore = new HttpClientFacebookTestUserStore("<appId>", "<appSecret>"));
FacebookTestUserAccount account = facebookStore.createTestUser(true, "");

Where <appId> and <appSecret> should be replaced with the values from your application.

From the FacebookTestUserAccount, you have access to the different user objects, such as the wall, friends, events etc.

String friendsAsJsonString = account.getFriends();

Assertions may be made on the JSON strings using your favorite toolkit, such as json-path (Yes Kalle, I'm looking at you. Time to release it!)

You can also let two test users be friends by issuing:

FacebookTestUserStore facebookStore = new HttpClientFacebookTestUserStore("<appId>", "<appSecret>"));

FacebookTestUserAccount account1 = facebookStore.createTestUser(true, "read-stream");
FacebookTestUserAccount account2 = facebookStore.createTestUser(true, "read-stream");

account1.makeFriends(account2);

When creating automated tests you probably want to start with a known state for your application. Use the void deleteAllTestUsers() method on the user store to start with an empty set of users. You can also get a list of available test users from the store by calling the getAllTestUsers() method.

List<FacebookTestUserAccount> users = facebookStore.getAllTestUsers();

facebookStore.deleteAllTestUsers();

For automated tests integrating with Facebook, the application need the access token for the test user to perform operations on its behalf. Here is an example of how a test case could look like.

FacebookTestUserAccount account = facebookStore.createTestUser(true, "email,read-stream");

systemUnderTest.doStuffIntegratingWithFacebook( account.accessToken() );

assertTrue("Wall did not contain expected data", account.getProfileFeed().contains("stuff posted on wall"));

How to get it

It is available on Maven central, use the following dependency:

<dependency>
  <groupId>com.jayway.facebooktestjavaapi</groupId>
  <artifactId>facebook-test-java-api</artifactId>
  <version>1.0</version>
</dependency>

or have a look at the project page for downloads:
http://code.google.com/p/facebook-test-java-api/

Step 1, getting the drivers.

1. Go to the Apple support page, click on the 'Download' button. Be aware that the file is about 350MB.
2. Install the drivers.

Step 2, select the driver

1. Turn on the printer and connect it to the Mac.
2. Open the printer preference page, press the '+' button to add the printer.
3. In the 'add printer' dialog, make sure that the printer is visible. Open the driver list.
4. Select HP Laserjet 1022, but not the gutenberg version.

The steps above should do the trick.

This text is taken from the Asciidoc home page.

Asciidoc is a text document format for writing short documents, articles, books and UNIX man pages. AsciiDoc files can be translated to HTML and DocBook markups using the asciidoc(1) command.

This text is taken from the Dia home page.

Dia is a GTK+ based diagram creation program for GNU/Linux, Unix and Windows released under the GPL license. Dia is roughly inspired by the commercial Windows program 'Visio', though more geared towards informal diagrams for casual use.

Screenshots for the Dia program.

Dia and Asciidoc is available for different linux distributions, I installed them in Ubuntu using

$ sudo aptitude install asciidoc dia

They can also be installed on OS X using, for example, the MacPorts project, in which case you write:

$ sudo port install asciidoc
$ sudo port install dia

And then wait for a while when everything compiles..

The solution

Asciidoc has the possibility to import files when generating the documentation, which is a nice feature when you don't want to duplicate information and have it up-to-date. For example, it can import images, show the content of XML files, generate diagrams using various graphviz syntax and so on.

Dia can export its diagrams to various image formats and this can be done on the command line. Using this feature of Dia it is actually possible to have Asciidoc generating image files from Dia's file format, here is how to do it:

Step one, creating the Asciidoc plugin

As asciidoc cannot read the native Dia's file format, it needs to trigger the export functionality of Dia. It is possible to extend Asciidoc by writing a filter, which is just a shell command reading from standard input and writing to standard output. In this specific case, the parameters to the shell process will be used and the image template functionality existing in Asciidoc will take care of reading from the generated image.

Asciidoc reads filter configuration files from four different locations in the following order:

1. It looks in the user’s $HOME/.asciidoc/filters directory.
2. The global filters directory (usually /etc/asciidoc/filters or /usr/local/etc/asciidoc) directory is searched.
3. It looks in the asciidoc(1) ./filters directory.
4. It relies on the executing shell to search the environment search path ($PATH).

Here I will put the filter in my home directory. Start with creating the document structure:

   $HOME/.asciidoc/filters/dia

In the dia directory, create the file dia-filter.conf with the following content:

#
# AsciiDoc Dia filter configuration file.
#
# Version: 0.1

[blockdef-listing]
dia-style=template="dia-block",subs=(),posattrs=("style","file","target","size"),filter='dia -t png -e "{outdir={indir}}/{imagesdir=}{imagesdir?/}{target}" "{outdir}/{file}" {size?-s {size}} > /dev/null'

[dia-block]
template::[image-blockmacro]

Now Asciidoc has been extended with a filter that takes the parameters file, target and size where the last parameter is optional. The next section describes how to use this filter in Asciidoc.

Step two, Import Dia diagram files in Asciidoc

To use the dia filter in Asciidoc, the following syntax is used:

[dia "infile.dia", "outfile.png", "x480"]
-------------------------------
-------------------------------

The syntax above will trigger the filter and provide 'infile.dia' as source which should be a diagram saved in Dia, 'outfile.png' is the image file to be generated and create a 480 pixels wide image. Writing the size as '480x' will specify the height of the image.
Don't forget the dashes, otherwise the filter will not be triggered.

The Eclipse plug-in MouseFeed, written by Andriy Palamarchuk, will repeatedly nag you with what keyboard shortcuts you can use instead of using the mouse to perform actions. For example, if you constantly left-mouse-click the "step-over" button in the debug perspective, the MouseFeed plug-in will pop-up a notification window telling you to instead press "F6" on your keyboard.

You can also make the plug-in even more annoying by having MouseFeed canceling the mouse operation so that you have to use the keyboard shortcut.

I have installed it and forgotten about it until today, when it gently reminded me that collapsing all nodes in the Package Explorer view could be issued by "Shift-Command Numpad_Divide" on Mac OS X. Unfortunately my laptop does not come with a numeric keyboard so I have better to remap the shortcut if I find myself collapsing nodes often.

The MouseFeed home page can be found at: http://www.mousefeed.com
The SourceForge project page: http://sourceforge.net/projects/mousefeed

One interesting problem was that in some of my tests, I had to mock the org.eclipse.core.resources.IResource interface. Nothing too hard about that, just write the following code, using EasyMock 2.4:

 
@Override
protected void setUp() throws Exception {
   super.setUp();
   resource1 = createMock("resource1", IResource.class);
   resource2 = createMock("resource2", IResource.class);
}
 

Now to my problem. First, I will discuss what the IResource.accept(IResourceVisitor visitor) metod does:
The IResource.accept(...) method traverses the directory structure under the resource. For each resource found, starting with the IResource on which accept() was called, the visitor.visit(IResource resource) method is called. If the visit(...) method returns true, the directory structure under the resource is traversed, otherwise traversing stops for that specific resource. This way parts of the directory structure under an IResource can be visited.

The problem I encountered was that since I have an IResource mock, there is no code for the accept() method. The mock will just register that there has been a call for accept(), but the code in the IResourceVisitor.visit(IResource resource), which I want tested, is never called.

What to do? There are different solutions, one example is to use an implementation of IResource, for example org.eclipse.core.internal.resources.Folder, and create a partially mocked object and keep the code for accept(). Not a nice solution though, my test would depend on internal code in the Eclipse project. What I did instead was to use the org.easymock.EasyMock.expectLastCall().andAnswer(IAnswer answer) functionality. The andAnswer() method takes an IAnswer callback implementation, like this:

 
public void testCollectRefreshStatus() throws CoreException {
   // Normal mock expects
   expect(resource1.getLocation()).andReturn(iPath1);
   expect(iPath1.toOSString()).andReturn(RESOURCE_PATH_1).times(2);
 
   // Provide code for accept(...)
   resource1.accept(isA(IResourceVisitor.class));
   expectLastCall().andAnswer(new IAnswer() {
      public Object answer() throws Throwable { // 1.
        IResourceVisitor visitor = (IResourceVisitor) EasyMock.getCurrentArguments()[0]; // 2.
        visitor.visit(resource2); // 3.
        return null;
      }
   });
   expect(resource2.getName()).andReturn("file.txt"); // 4.
 
   replayMocks();
 
   // Perform test
   myTestTarget.someMethod();
 
   // Verify test
   assertEquals(1, myTestTarget.getNumberOfResources());
   verifyMocks();
}
 

Here are some comments to the marked lines in the code above:

1. The answer() method is dictated by the IAnswer interface.
2. EasyMock provides a method to get access to the objects sent as parameters for the expected call. In this case, the call is resource1.accept(...) and the parameter is the IResourceVisitor implementation defined in myTestTarget, which is the code that should be tested.
3. Here the test code has control of the call to the IResourceVisitor.visit() and a mock IResource is provided as parameter. To make the test even better, the boolean return value from the visit() call should be saved and asserted for the correct value to ensure that the intended traversing works as expected.
4. Here the expectations on the mock IResource, for the visit(IResource ...) call, is defined. In this case myTestTarget calls getName() on IResource for some reason, so expectations for that is defined together with a resulting return value that would steer the logic in some direction.

This way the test has full control of the visitor implementation and it is fairly easy to test all the criterias that makes the IResourceVisitor.visit(...) implementation return true or false. Also, the visit() method often changes state of something else, and here it is also possible to test that the state is changed correctly by simulating multiple visit(...) calls, by adding more calls to visit at 3. in the code above.

/Tobias Södergren

Lots of tutorials

The first day was the tutorial day with 22 simultaneous labs and tutorials. All in
all there were about 80 sessions that you could attend, including “An introduction
to Pax tools for OSGi” hosted by Stuart. Unfortunately we did not have time to
see all of the tutorials, and it was often difficult deciding which ones to attend.

The sessions ranged from “introduction” to “advanced” in both core Eclipse, such as Equinox and the Debugger frameworks, and in the variety of sub-projects such as GMF, eRCP, BIRT etc. One interesting session was about the new debugger service framework, abbreviated as DSF, which supports asynchronous calls to and callbacks from the debug target. Much of the framework is dealing with the issues that stem from working asynchronously.

The framework is created by Windriver, a big player in C/C++ development for embedded devices, because debugging embedded devices in most cases has a different nature than debugging Java code. Embedded devices often have slow communication links and the response often come in data chunks because of optimization issues. These characteristics do not fit well with the standard debugging framework in Eclipse.

The OSGi tutorials were well attended, with the Spring Dynamic Modules tutorial almost standing room only. It was also good to see a lot of interest in the OSGi service registry from plugin developers, who are more used to the Eclipse extension point registry. The overall feeling was that most people knew the basics of OSGi and were now eager to learn best practices and more advanced use.

Fake Steve Jobs

Tuesday was the starting day of the “ordinary” conference. The keynote speaker was Dan Lyon a.k.a Fake Steve Jobs. Dan Lyon has been working as a tech writer for many years, and started his blog called Fake Steve Jobs where he was writing tech articles as he thought Steve Job would have written them. After a while, people started to try and guess who this Fake Steve guy was and ultimately his own boss was discussing it openly, to his surprise. Dan had no choice but to come clean, but the popularity of the blog still remained. Sun, Microsoft, Oracle and even Eclipse get hit by his wild bashes, where the latter was something he was nervous about, being a keynote speaker at EclipseCon. But not everything is fictional and as he put it: - People are returning because I occasionally put some seriousness in my blog entries.

Services vs. Extensions

Among the interesting sessions for the day, was a session by Neil Bartlett regarding how to integrate Eclipse Extensions in OSGi services and vice versa. Eclipse extensions are the base for how plug-ins extend the Eclipse platform, such as adding menu entries, dialogs, wizards etc. to the workbench. OSGi is the platform on which Eclipse plug-ins are implemented, and it provides modularity and dynamic services. By using extensions and OSGi services it is possible to write very modular applications which supports lazy loading, being robust and dynamic in nature.

Services + Extensions using dependency injection

Neil also gave a talk on how dependency injection could bridge the gap between extension points and services. This is a very promising approach because it would free developers from having to decide which one to use in their components, and this decision could then be made at configuration/ deployment time. The prototype work is now being continued in an official Eclipse incubator project.

Automatically repairing pre-OSGi code

Erik Wistrand from Makewave (Knopflerfish framework) had a short talk on using bytecode manipulation at load-time to automatically detect and repair potentially problematic legacy code. This is a popular topic at the moment, as many people are looking at how to migrate their current applications to OSGi so they can start taking advantage of OSGi for new components.

OSGi on Android

In another session, Neil Bartlett and BJ Hargrave, a senior manager at IBM, were
presenting how they got two different open-source OSGi containers running on the Google Android mobile platform. Both Equinox, the OSGi container developed by Eclipse, and Concierge which is a small container and a research project developed at ETH Zurich, were running on the Android emulator.

Other OSGi frameworks able to run on Android are Apache Felix, which was the first container running on it, and mBedded Server, which is a commercial OSGi container developed by ProSyst. Being able to run is not the same as being supported by Google though, but it is interesting to see that there was not that much work involved in introducing OSGi to Android.

Open Source Microsoft

Wednesday started off with a keynote from Sam Ramji, director of the Open Source Software Lab at Microsoft. Knowing that the audience was probably quite skeptical about Microsoft’s relationship with open-source Sam’s first slide was about project “Supernova”, where Microsoft decides to buy Eclipse and use it for Visual Studio because they really love Java! After that ice-breaker, Sam went on to discuss some of the open-source projects his lab works on, such as dynamic languages, and how Microsoft has much more focus on interoperability these days. He already has developers working with Mozilla and Apache, but more relevant for Eclipse, they are looking at helping with SWT (Standard Widget Toolkit) support for WPF (Windows Presentation Foundation).However, during the Q&A session Sam said there’s no plan for Microsoft to join Eclipse, or even have their developers become committers, which made this sound like a token effort.

Eclipse 4.0

The initial work of Eclipse 4.0 was presented by Mike Wilson, Jochen Krause, Jeff McAffer and Steve Northover. The current state is “wild ideas” and the trends getting focus in this release are that Java software development is moving into Rich Web GUI backed by services, and that the IDE will move to be a mix of web and desktop targets. The presenters want to see an effort to take what currently exists and put it “in the web space”.

The community work in Eclipse is quite good today, but people need to be much more involved in the future platform.

They also want to see that work is put into making it easier to create plug-
ins with a more uniform API in Eclipse. There will probably be some kind of dependency injection framework available to make it easier to use services and resources. The platform should be better documented, the API should be reasonably sized, and the API should be RESTful and accessible by JavaScript.

The timeline for e4 (Eclipse 4.0 platform) is that the project will be proposed and started after the Eclipse Summit later this year. Until now, everything is ideas that may or may not be included in the project. There will be regular platform builds of e4, including milestones, and it will be ready within 2 years from start.

It will not be an easy task to create the next version of the Eclipse platform, because of its widespread use and the many wills of the multitude of Eclipse projects. The time when Eclipse was just a Java IDE is now long gone and there are a lot of people that have invested a lot, both in time and money, in their existing projects.

API Tooling

Among the things that make OSGi, and also the plug-in concept of Eclipse, great is the possibility of having different versions of the same functionality available for applications without conflict. One application might need version 1.x of a jar file while another requires an API incompatible version 2.x, and with proper versions on the packages there will be no conflict. Although being a good thing, it can be quite challenging to keep the versions correctly updated. Sometimes the changes you do to a code base might break an API compatibility, sometimes not. To remedythe situation in Eclipse, there is a new toolkit called “API Tooling”. The description, which is taken directly from the developer site, states: “API tooling will assist developers in API maintenance by reporting API defects such as binary incompatibilities, incorrect plug-in version numbers, missing or incorrect @since tags, and usage of non-API code between plug-ins”. An example of functionality in the toolkit is that offending code is marked in eclipse and quick-fix will be provided for changes that can be automated. The tools are scheduled to be included in the Eclipse Ganymede release in June.

Information Economy

Thursday’s keynote was given by Cory Doctorow about the “information economy” where information is a commodity, and you should therefore try to keep the cost of “creating” information low. This was a very entertaining talk where he stressed the importance of collaboration over restricting access. With collaboration you can (hopefully) still maintain a competitive edge - while restricting access to information is a temporary solution that often drives up costs, like old fashioned protectionism. Cory finished by asking everyone to help preserve their existing freedoms, such as the freedom on the Internet.

Some reflections

It was nice to see that that OSGi as a concept has matured among both the speakers and visitors as opposed to last years EclipseCon where it was more in a state of hype and excitement. It was also interesting that OSGi is creeping into mobile phones, Spring revealed their Titan platform for Windows Mobile phones containing an OSGi container besides being MIDP compatible. Another announcement made during the conference was that EclipseLink has been chosen as the JPA 2.0 Reference implementation.

Tobias Södergren and Stuart McCulloch

Originally published in JayView.

In the first part of this article, which can be found in the previous JayView, the monitoring tools of the Sun JDK 1.5 was presented. These monitoring tools can be a good start for looking at the current status, and behavior over time, for an application. While these tools can tell you some parts of the doings of an application, finding a problem is sometimes more effective using the troubleshooting tools. This second part of the article will present some of these tools.

Tools overview

The list below contains all tools presented in this article, where the first four can
be found in part one.

Note: A known issue for OSX require that some of the tools is run as root, which can be accomplished by putting ‘sudo ‘ before each command.

Troubleshooting tools

The troubleshooting tools provided by Sun Microsystems in the JDK bin directory are to be considered experimental. They come with no support and they might harm your system. Although being in an experimental state, the tools can be quite useful when looking for problems.

Some of the tools can connect to a locally or remotely running Java process, others operate on a core dump. This dump can be created by the JVM, by specifying Sun Hotspot specific flags such as -XX:+HeapDumpOnCtrlBreak or
-XX:+HeapDumpOnOutOfMemoryError. These flags should be appended to the java command just like system properties:

> java -XX:+HeapDumpOnOutOfMemoryError -jar application.jar

The core dump can also be created with jmap and the syntax is described below. Be aware that the jmap of JDK 1.5 have some problems creating this core dump, sometimes it creates a corrupted file. This specific issue with jmap is fixed in Java 6.

jinfo

The jinfo tool connects to a running local process, a JVM core dump or a remote
process. The purpose of the tool is to display the VM flags used and the values of
the system properties for the process in question. The process id, or VMID, can be found using the jps command. Here is an example connecting to a running process with process id 1649:

> jinfo -flags 1649
Attaching to process ID 1649, please wait...
Debugger attached successfully.
Client compiler detected.
JVM version is 1.5.0_07-87
-Duser.property=somevalue 

In the example above, you can see that the Java application was started using the flag ‘user.property’. To see the system properties, use the -sysprops flag:

> jinfo -sysprops 1649
Attaching to process ID 1649, please wait...
Debugger attached successfully.
Client compiler detected.
JVM version is 1.5.0_07-87
java.runtime.name = Java(TM) 2 Runtime Environment, Standard Edition
sun.boot.library.path = /System/Library/Frameworks/JavaVM.framework/
Versions/1.5.0/Libraries
java.vm.version = 1.5.0_07-87
java.vm.vendor = ”Apple Computer, Inc.”
java.vendor.url = http://apple.com/
path.separator = :
   ...

The jinfo command can give a quick hint about what a java process can see from its environment.

jstack

The jstack command prints out the execution stack trace for threads for a process in the local JVM, a remote JVM or in a core dump. It also prints out thread deadlocks detected by the Hotspot VM, something that can come in handy for
solving threading issues. The command for connecting to a local process looks like:

> jstack 1649
Attaching to process ID 1649, please wait...
Debugger attached successfully.
Client compiler detected.
JVM version is 1.5.0_07-87 

Thread t@4099: (state = BLOCKED)
 - java.lang.Object.wait(long) @bci=0 (Interpreted frame)
 - java.lang.ref.ReferenceQueue.remove(long) @bci=44, line=116 (Interpreted
frame)
 - java.lang.ref.ReferenceQueue.remove() @bci=2, line=132 (Interpreted
frame)
 - java.lang.ref.Finalizer$FinalizerThread.run() @bci=3, line=159
(Interpreted frame)
...
Thread t@4611: (state = IN_NATIVE)
 - java.io.FileInputStream.readBytes(byte[], int, int) @bci=0
 - java.io.FileInputStream.read(byte[], int, int) @bci=4, line=194
 - java.io.BufferedInputStream.read1(byte[], int, int) @bci=39, line=254
 - java.io.BufferedInputStream.read(byte[], int, int) @bci=49, line=313
 - sun.nio.cs.StreamDecoder$CharsetSD.readBytes() @bci=135, line=411
 - sun.nio.cs.StreamDecoder$CharsetSD.implRead(char[], int, int) @bci=112,
line=453
 - sun.nio.cs.StreamDecoder.read(char[], int, int) @bci=180, line=183
 - java.io.InputStreamReader.read(char[], int, int) @bci=7, line=167
 - java.io.BufferedReader.fill() @bci=145, line=136
 - java.io.BufferedReader.readLine(boolean) @bci=44, line=299
 - java.io.BufferedReader.readLine() @bci=2, line=362
 - se.jayway.jconsole.test.Application.run() @bci=29, line=24
 - se.jayway.jconsole.test.Application.main(java.lang.String[]) @bci=9,
line=14

In the example above, we can see that the Application.main( ) method is spending time in FileInputStream.readBytes( ).

jmap

This versatile command prints out information using the following flags:

• - heap prints out heap information, including the different memory pools
• - heap:format=b dumps the heap in a binary format
• - histo prints class histogram information of the object heap
• - permstat prints information class loader-wise about data in the permanent generation memory pool. The permanent generation memory pool contains class meta data and the String literals.

> jmap -heap 1649
Attaching to process ID 1649, please wait...
...
using thread-local object allocation.
Mark Sweep Compact GC 

Heap Configuration:
MinHeapFreeRatio = 40
MaxHeapFreeRatio = 70
MaxHeapSize      = 67108864 (64.0MB)
NewSize          = 655360 (0.625MB)
...

In the example above only the first part of the heap information is printed, there’s a lot more to see.

> jmap -histo 1649
Object Histogram:
Size    Count   Class description
-------------------------------------------------------
194408  1025    char[]
102840  160     byte[]
16032   668     java.lang.String
13208   297     java.lang.Object[]
8208    27      * ObjArrayKlassKlass
...

Above, the first part of the class histogram is printed for the process with VMID 1649.

> jmap -heap:format=b 1649
Attaching to process ID 1649, please wait...
Debugger attached successfully.
Client compiler detected.
JVM version is 1.5.0_11-b03
Unknown oop at 0x889ec790
Oop’s class is null
heap written to heap.bin 

The heap is dumped for the process with VMID 1649 in the example above, and the result is a file called heap.bin.

The jmap -heap and jstat with a suitable garbage collection flag can help with finding memory issues for object instances. Jmap -histo and jmap -permstat can be used for finding memory leaks in permanent generation memory space, e.g. when there are too many classes loaded by class loaders that never get garbage collected.

The jmap -heap:format=b flag has issues with the heap dump sometimes being corrupted, an issue which is fixed for Java 6. When the command is working the heap dump can be analyzed using tools described above and with a tool called jhat, which is bundled with Java 6 SDK. It is also possible to debug the heap dump using the java debugger, called jdb, which also can be found in the bin directory.

I recommend taking a look at jhat, which is a heap analysis tool that processes heap dumps. When invoking jhat it starts with analyzing all objects found in the heap core dump. After the analysis is finished a web server is launched. Use an ordinary web browser to connect to the web server to get access to the object browsing functions available.

One example of a function is the one that makes it possible to filter out weak
references between objects, so that objects that are not eligible for garbage collection can be found. It is also possible to use OQL (Object Query Language) where you can use an SQL-like syntax to get object set results, such as the number of instances for a specific object type, the value for all String objects etc.

The jhat tool is available in Java 6 but can be downloaded from Sun for Java 1.5.

To conclude this article, the monitoring and troubleshooting tools found in the bin directory for the JDK provided by Sun can be a good start when finding bugs in your java code. Use them, you might already have them on your computer.

Originally published in JayView.

A possible scenario

You have started up an application, let’s say it is a web application which is running in an application server. After a while you notice that the application is behaving oddly. You cannot really put your finger on the problem, but sometimes it looks like the web pages are not served as they should. The application also feels slower than you expect.
First thing could be to check out the log files, but as you all know, the debug level
is set to INFO or WARNING because the application is in production:

10:10:40.542 INFOStarting  application...
10:12:21.650 INFOAll  service started.
10:14:22.145 INFOApplication  booted successfully. 

What conclusion do you draw from this output? The application has started and it
looks like nothing serious has detected in the code that is worth mentioning in the
log. Is it time to start guessing or just ignore the gut feeling you have? Not quite yet,
there are some help to be found not far away, and it will not cost you a dime.

Bring out the tools

In your Java SDK 1.5 (or higher) “bin” directory, there are tools that can be quite us-
able for poking around in the Java processes. There are different number of tools for
different platforms and the number of available functions per tool is also depending
on the distribution. Sun Solaris and Linux Java distributions have been blessed with
the most number of tools and functions, Mac OSX and Windows have the least.
Also, the tools are getting constantly improved for newer releases of Java.

Here is a comprehensive list of the tools mentioned in this article and on which
platforms they exist:

This article consists of two parts, and this first part goes through the available moni-
toring tools in the Sun Java 1.5 SDK bin directory.

Monitoring tools

jps

To see which java processes that are currently running on a machine use the jps
command:

> jps
1649 Application
2533 Jps 

The resulting output lists the VMID (Virtual Machine ID) and the Java process
name. To get extended information, append the -v flag to the jps command:

> jps v
1649  Application
2534 Jps
-Dapplication.home=/System/Library/Frameworks/JavaVM.framework/Versions/1.5.0/
Home
-Xms8m 

jstat

This command gives performance statistic information from the JVM for a Java
process. There are a number of statistic options available, which is displayed using
the -options switch:

> jstat -options
-class
-compiler
-gc
-gccapacity
...

To print the statistics for one of the options above for a process, the VMID has to
be specified after the option. The VMID is the same id as listed with the jps com-
mand:

> jstat -gcutil  1649
S0  S1  E  O  P  YGC  YGCT  FGC  FGCT  GCT
0,00  0,00  78,32  0,00  0,24  0  0,000  0  0,000  0,000

Using the jstat command, it is possible to create scripts that periodically checks the
status for e.g. the number of loaded classes or the garbage collection utilization. In
the example above, the garbage collection has taken place mostly in Eden memory
space. Eden space is Sun Hotspot specific memory space for shortlived objects.
Information about memory pools can be found at http://java.sun.com.

jstatd

This command starts up a jstat daemon on a machine and enables remote monitor-
ing. To startup the daemon on the computer which should be monitored, the port
number where the remote clients can connect to has to be specified:

> jstatd -p  12345

After that, it is possible to use both jps and jstat remotely by specifying the host-
name and port:

> jps example.computer.org:12345
2617 Jps
2611 Jstatd
1649 Application

The above example lists the processes on the ‘example.computer.org’ host using the
port 12345. Presented in the output, you can see the jstatd is also a java process.

> jstat  -gcutil  1649@example.computer.org:12345
S0  S1  E  O  P  YGC  YGCT  FGC  FGCT  GCT
0,00  0,00  78,32 0,00  0,24  0  0,000  0  0,000  0,000

Above we can see the same example for process 1649 as in the previous command,
but this time listed for host ‘example.computer.org’ using port 12345.

jconsole

On client computers, or servers with a graphical interface, it is possible to monitor
the JVM status by using a tool called jconsole. The jconsole tool visualizes services
that exposes a JMX (Java Management Extension) interface, and Java 1.5 and later
contains JMX beans for exposing the data defined in the java.lang.management
package.

To be able to monitor java applications using jconsole in Java 1.5, the application
has to be started with the system property -Dcom.sun.management.jmxremote.
Example:

> java -Dcom. sun.management.jmxremote jar  testapp.jar 

When the application has started, the jconsole can be initiated:

> jconsole 

The connection console displays all java processes that has JMX enabled. After con-
necting to the Java process, jconsole provides the following tabs:

• Summary Tab
• Memory Tab – The different memory pools can be inspected
• Thread Tab – The total, peak and currently live threads are displayed
• Classes Tab – The number of classes are displayed
• Mbeans Tab – Gives access to the JMX beans in the management package
• VM Tab – Displays information for the VM where the application is running in

Below are example screenshots for the memory and thread tab:

The jconsole application can be a tool to start with when looking at application
behavior over time, such as memory leaks or unusual thread behavior.

Using the Java monitoring and management tools you can get a better understanding
of the runtime behavior of your application. Sometimes this information is enough
for finding and fixing a problem.

This concludes the first part of the article. In the next issue of JayView we will look
into the troubleshooting tools.

Originally published in JayView.