Note: Since Eclipse Neon (4.6) this is a build in feature. By default, you can use Ctrl+”+” or Ctrl + “-” to increase or decrease the font size of your active text editor or view.
Today, I found a simple plugin making life easier and saving time during your everday work. Just checkout the plugin Eclipse Font available on google code: https://code.google.com/p/eclipse-fonts/

Just install the plugin from the according update site: http://eclipse-fonts.googlecode.com/svn/trunk/FontsUpdate/
and use Ctrl+- or Ctrl++ to decrease or increase your font size.

Note: If you manually changed your editors’ font size before, you might need to reset this to make the plugin effect your settings.

Enjoy adapting your font size to your current screen resolution!

For example:

String myString = "Hy my name is bob";
String[] words = myString.split(" ");

If you need to perform the same kind of split frequently, the Java Regular Expressions API provides a good oportunity for a performance improvement.
The API provides a Pattern class to precompile a split pattern and execute it on a string.

The example above would look like:

Pattern p = Pattern.compile(" ");
String myString = "Hy my name is bob";
String[] words = p.split(myString);

Now, why would this lead to performance improvement?

Internally, String.split() is implemented as

public String[] split(String regex, int limit) {
    return Pattern.compile(regex).split(this, limit);
}

As you can see, String.split() instantiates a new Pattern object on the fly. The garbage collector can remove it quickly, but if you perform the same split again and again, this requires a reasonable overhead.
So what you can do is:

1. compile your Pattern in advance.
2. Store it either with an object existing long enough to provide access to the Pattern instance, or in a static manner
3. use the split of the precompiled pattern instead of the convinience String.split()

Further recommendation

Google Guava Splitter
The Google Guava commons library provides a nice Strings API including a Splitter class you should take a look at
Google Guava Splitter

Hidden evils of Java’s String.split()…
Prashant Deva wrote an interesting blog entry about the split() performance and provides some statistics:
Read the blog entry

If possible, I would recommend to add a plugin to your wiki allowing to edit your diagrams directly on the wiki page. This enables remote editing and versioning based on your known wiki infrastructure.

However, adding a plugin to your wiki is not possible in every case. Especially when working with a distributed team of mixed departments or componies, or in open source projects with an open community, you should prepare for people not having a UML tool on their computer and you might not be able to modify your wiki.
In such cases, online uml drawing tools can be very helpful. There are plenty of them with pros and cons and you should select the right one carefully.

I recently tested a couple of tools while writing the documentation for the Palladio Workflow Engine. Below, you will find a short abstract per tool and pros and cons about it. If possible I added a screenshot of the tooling.

creately.com

For all of those already familar with tools such as Microsoft Visio, you will be able to use this online tool immediately. Creately provides a flash application that also allows for collaboration and publishing of a diagram. They allow for a braught set of diagram types such as UML Activity, Classes, and much more. Even some non-uml diagrams are supported.
The tool is a flash application and provides drag&drop of elements from a pallette and the positioning and composition of the diagrams. In the majority, you create your diagram using mouse or touchpad.
Creately allows to download your diagram in several image formats and you can share links for editing or viewing your diagrams to others.
For a small bootstrap and wide acceptance, they provide a free access to a limit account. However, if you want to really use it in your team, you will have to choose one of the commercial options. The free edition allows for a very limited number of interactions / diagram only.

yUML

yUML is an online tool you write your diagram in a specific textual representation, press enter to draw a diagram based on your textual description. Finally, yUML provides you a link to share your diagram with others and to download your diagram in several image formats.
yUML Website

If you run a media wiki, a yUML is available for you: http://wiki.sindri.info/wiki/YUML_MediaWiki_Extension

A dialog opens to edit the properties. Choose “New > Externals”

In the second dialog that opens to edit the externals click on “New …” to configure the new svn:externals settings.

In this dialog, you can specify the name of the subdirectory you would like to place in the external sources (“Zend” in the screenshot) as well as the svn url you would like to checkout the sources from (Zend version 1.11 in the screenshot). As shown in the example, you can choose the head of a branch for a specific version, for example, to get the bug fixes and patches for a specific release.
As soon as you have confirmed all these dialogs by clicking “OK”, you can perform an svn update on the base directory you added the svn:external dependency to and tortoise svn will immediately start to download the external content.

In the example shown in the screenshot, I have included the Zend Framework Release 1.11 as an external dependency in my php application code base.
Zend framework release repository: http://framework.zend.com/svn/framework/standard/branches/release-1.11/library/Zend/

All elements, such as nodes and edges can carry attributes with any literal key you would like to set ( addAttribute(String key, Object… value) ).
If one opens a graph in the included viewers (e.g graph.display()), a predefined attribute named “ui.label” is checked and any value of the attribute is used as a label in the visualization of this element.

If you would like to derive the label from another custom attribute instead of setting the “ui.label” attribute in parallel, this can be achieved by using the proxy concept of the GraphStream API.

When a graph is opened in a viewer, this can not only be done by simply calling the display method of the graph, but by opening a Viewer explicitly and setting a Proxy in between of the Viewer and the graph itself:


Viewer v = new Viewer(new CustomEdgeLabelAttributeProxy(graph, "my.attribute"));
v.enableAutoLayout();
v.addDefaultView(true);
v.setCloseFramePolicy(CloseFramePolicy.HIDE_ONLY);


This ensures that visualizing the graph in the ui will pass the created nodes, edges and attributes through the CustomEdgeLabelAttributeProxy.
This proxy class is derived from the class ThreadProxyPipe and the method to react on a newly set node attribute is overridden.


@Override
public void sendEdgeAttributeAdded(String sourceId, long timeId, String edgeId, String attribute, Object value) {
if (attribute.equals(this.labelKey)) {
super.sendEdgeAttributeAdded(sourceId, timeId, edgeId, "ui.label", value);
attribute = "ui.label";
}
super.sendEdgeAttributeAdded(sourceId, timeId, edgeId, attribute, value);
}


The method registers when the custom label attribute, identified by the attribute’s key, passes by. It passes the submitted parameters twice to the super method. Once with the custom attributes id to set this in the GraphicElement as usual, and a second time to set the attribute’s value also for the ui.label attribute to be presented by the viewer.

To also adapt the edge label when the graph respectively the edges are modified when the graph is already updated, you should also override the method

edgeAttributeAdded(String graphId, long timeId, String edgeId, String attribute, Object value)

The implementation of this method follows the same concept as the sendEdgeAttributeAdded() method above.

The proxy provides methods not only for the edge attributes, but also for node and graph attributes to react on.

The complete code of the CustomEdgeLabelAttributeProxy is provided below:


package org.splevo.vpm.analyzer.graph;

@Override
public void sendEdgeAttributeAdded(String sourceId, long timeId, String edgeId, String attribute, Object value) {
if (attribute.equals(this.labelKey)) {
super.sendEdgeAttributeAdded(sourceId, timeId, edgeId, "ui.label", value);
}
super.sendEdgeAttributeAdded(sourceId, timeId, edgeId, attribute, value);
}
}


If you have produced a graph in your program and would like to visualize this there are two easy and straight forward ways to get a result:

GraphViz DOT Format

JGraphT provides an exporter for the GraphViz DOT format. To generate this format, simply use the following code:


DOTExporter exporter = new DOTExporter();
String targetDirectory = "testresults/graph/";
new File(targetDirectory).mkdirs();
exporter.export(new FileWriter(targetDirectory + "initial-graph.dot"), graph);


To view a .dot graph file in Eclipse, you can install the GraphViz Viewer provided by the TextUML project:
http://sourceforge.net/apps/mediawiki/textuml/index.php?title=TextUML_Toolkit
Their update site includes a separate feature for the GraphViz viewer.

JGraphT / JGraph Integration

JGraphT provides an integration with the JGraph library for graph visualisation (http://jgrapht.org/visualizations.html).

Here you will find some example code how to run a simple visualization of your graph.
Note: This code does not take any layouting into account and simply draws all nodes on top of each other.

import javax.swing.JFrame;

JFrame frame = new JFrame();
frame.setSize(400, 400);
JGraph jgraph = new JGraph(new JGraphModelAdapter(graph));
frame.getContentPane().add(jgraph);
frame.setVisible(true);
while (true) {
Thread.sleep(2000);
}

This code is compatible to the JGraph library shipped with JGraphT only.

There are two really nice blog posts providing examples where companies failed to re-implement their software and disuss the reasons for this:

• http://venturebeat.com/2011/02/02/rewriting-code-can-be-startup-suicide
• http://www.joelonsoftware.com/articles/fog0000000069.html

So re-check if you really want to rewrite your software and better think about a smooth and controlled modernization before throwing away your business.

The long and short of it can be summed up quite simply: this is why your Phoenix business needs custom development software. Trying to use someone else’s tools will soon lead to bumps in the road; it wasn’t custom built for your needs, but theirs after all. You will find that there are things that seem easy at first but that thanks to this tool that specializes in something else it is far more complicated. A custom built piece of software can be constructed from the ground up to suit your needs, and be as effective as them as you require.

In the long run, you’ll find the time and stress saved from using custom software built for your business’s particular needs has added up and proven beneficial at an incalculable level.