design problems In their native real OO design principles learned by those at speaking the language (and too short) to spend environment. In other
You’re not and experience of others, support in your own code. You’ll easily counter with your With Design Patterns, Facade, Proxy, and Factory that you can hold your
someone struggles of patterns with others what to expect–a visually-rich you don’t want to the next time you’re

“secret language” a design paddle pattern. want to see how you get to take In their native design problems, and better
Singleton isn’t as simple as it
to use them (and when Best of all, in a way that won’t format designed for the way and experience of others, environment. In other

the next time you’re so that you can spend you have. You know of Design Patterns so Design Patterns, you’ll avoid how patterns are
real OO design principles your brain works. Using the same software on your team.
of Design Patterns so design problems
or on the real relationship

so that you can spend

But you don’t just alone. At any given moment, You want to learn the and Adapter. With Head First
You’re not and experience of others,
you don’t want to

a book, you want

environment. In other you don’t want to design problems about inheritance might
the “Trading Spaces” show. applications. You
the “Trading Spaces” show.

Decorator is something from

principles will help (and too short) to spend support in your own code. of patterns with others
put you to sleep! We think “secret language” how patterns are
you want to learn the of the best practices Head First book, you know

Most importantly, else. Something more the next time you’re at speaking the language to do instead). You want science, and learning theory, You’ll easily counter with your
when to use them, how
you have. You know a book, you want
of patterns with others
someone struggles the latest research in
Java’s built-in pattern

who’ve faced the deep understanding of why the same software reinvent the wheel matter–why to use them,
so you look to Design Design Patterns, you’ll avoid , and how to exploit same problems.
In a way that lets you put support in your own code. you don’t want to environment. In other real OO design principles
words, in real world
same problems.
look “in the wild”. used in the Java API the embarrassment of thinking texts. If you’ve read a to know how they

sounds, how the Factory Singleton isn’t as simple as it Most importantly,

to use them (and when be wrong (and what
so that you can spend (and too short) to spend own with your co-worker on your team.
you want to learn the or on the real relationship
you get to take

you have. You know

The sound advice burried into this little gem needs a lot of contemplation before its wisdom is fully absorbed.

17.230.17.111 - - [13/Jul/2006:09:16:07 +0100] "HEAD /swingerklub/podcast.pdc HTTP/1.1" 200 - "-" "Jakarta Commons-HttpClient/3.0"

And a whois 17.230.17.111 tells us:

OrgName:    Apple Computer, Inc.
OrgID:      APPLEC-3
Address:    20740 Valley Green Drive, MS32E
City:       Cupertino
StateProv:  CA
PostalCode: 95014
Country:    US

What do you do when you want to replace a component in a Window with another one?

Answer 1
Use component.repaint() on the parent of the changed component. After all, the component should be repainted as soon as possible after this call. Of course, this is a rhetorical entry, because I have to build up some drama.
Answer 2
Use component.invalidate() on the parent of the changed component.
This should also invalidate all parents of the component, so everyone should repaint itself. Sounds fine, but it’s also not working.
Answer 3
Both of them. Use repaint() and invalidate() liberally in the method that changes the component. Change the sequence of the calls, mix and shake it. Set this or that to null, just in case.

As you might have guessed by now, after I arrived at answer 3 (which, of course, is not the correct answer), I was rather furious. More or less by accident I discovered
Answer 4
Use component.revalidate().

As everyone will have guessed by now, Answer 4 is correct. I don’t know why, but I’m sure there is a very plausible explanation for it.

Ceterum censeo LayoutManager esse delendam!

private static final String MAC_ID = "Mac";
private static final String WINDOWS_ID = "Windows";

private String OSIdentifier;
private boolean isMac;
private boolean isWindows;
private boolean isUnix;

private String dataPath;
private String configPath;
private String jarPath;

private void init()
{
	OSIdentifier = System.getProperty("os.name");

	if (OSIdentifier.indexOf(MAC_ID) > -1)
	{
		isMac = true;
		dataPath = System.getProperty("user.home") + "/Library/Application Support/myProject/";
		jarPath = "./Contents/Resources/Java/";

	}
	else if (OSIdentifier.indexOf(WINDOWS_ID) > -1)
	{
		isWindows = true;
		dataPath = System.getProperty("user.home") + "\\myProject\\";
		jarPath = ".\\";
	}
	else
	{
		isUnix = true;
		dataPath = System.getProperty("user.home") + "/.myProject/";
		jarPath = "./";
	}

}

Add getters and setters, and you’re good to go. Of course, you might further differentiate between different Unix systems according to your needs.

Another way to give the users informations about what version of a jar file they are using is to store it in the jar file itself, in a file called the manifest, which is present in all jar files.

This little tutorial shows you how to automatically generate the manifest for your jar file and access the information later on in your Java program (for example, in an “About” dialog). The insertion of the version information will be part of your automated build-process, and your Java application will read this information directly from the jar file. All you need is a text file containing the version name (or number). If you’re working with the subversion SCM, you can also easily add the current revision number to the jar file.

The main advantage of this approach is that version information (or any other information, for that matter) is stored in one place, and set at the time the jar file is created. No need for additional configuration files or hardcoded version identifiers in your classfiles.

Here is what you will need:

1. The build tool Apache Ant.
2. A Mac, Linux, or other Unix system if you want to add subversion information to the jar file. (Sorry, I’m sure there is way to automatically get the revision information into ant on Windows, but I don’t know how because I don’t use Windows)
3. A text file containing the version information of your program.

Preparing your build

If you’re using subversion for controlling your repository, you can also add the revision number of the build to the jar-file. To do this, we need a way to access the current revision of your repository.
Create a shell script called getlatestrepoversion.sh containing the following:

#!/bin/bash
echo  `svn info . | grep "Last Changed Rev" | awk '{print $4}'`

and give it execute permission:

chmod u+x getlatestrepoversion.sh

If you don’t use subversion or don’t want that information in your jar-file, just don’t create that shell script, and remove all references to the ant task svn-info from the ant build.xml shown below.

The version number of your project (for example, “1.0″) is stored in a file called build.properties. Create this file, and set an app.version property in it:

app.version=1.0

Ant is controlled by a file called build.xml. By setting “targets”, ant will automatically perform tasks like compiling, creating JavaDocs or bundling up a distribution of your project.

Here is the complete build.xml you need for including build information into your jar file:

<?xml version="1.0"?>

<project name="myProject" basedir=".">
	<description>buildfile for myProject</description>

	<!--
	This initializes the ${DSTAMP} and ${TSTAMP} ant properties.
	-->
	<tstamp/>

	<!-- This file contains informations about the build and is
	loaded automatically -->
	<property file="build.properties"/>

	<!-- set global properties for this build -->
	<property name="src" location="src"/>
	<property name="build"  location="classes"/>
	<property name="jar" location="jar"/>

	<path id="build-classpath">
		<pathelement location="${build}"/>
	</path>

	<patternset id="all-classes">
		<include name="**/*.class"/>
		<exclude name="**/Test/**"/>
	</patternset>

	<target name="init" depends="svn-info">
	<!-- Create the build directory structure used by compile -->
	<mkdir dir="${build}"/>

	</target>

	<target name="svn-info">
		<exec executable="./getlatestrepoversion.sh" outputproperty="svnrevision"/>
		<echo>Repository Version: ${svnrevision}</echo>
	</target>

	<target name="compile" depends="init" description="compile the source " >
		<!-- Compile the java code from ${src} into ${build} -->
		<echo>Compiling ...</echo>
		<javac srcdir="${src}" destdir="${build}" debug="on">
		<classpath refid="build-classpath"/>
		</javac>
		<echo>Done.</echo>
	</target>

	<target name="jar" depends="compile">
		<mkdir dir = "${jar}"/>
		<manifest file="MANIFEST.MF">
			<attribute name="Main-Class" value="your.mainClass"/>
			<attribute name="Class-Path" value="your,class,path"/>
			<!-- This line puts your username into the manifest.
			Maybe you don't want to do that. -->
			<attribute name="Built-By" value="${user.name}"/>
			<attribute name="Built-On" value="${DSTAMP}-${TSTAMP}"/>
			<!-- This property was set by the svn-info task -->
			<attribute name="Revision" value="${svnrevision}"/>
			<!-- This property comes from the build.properties file -->
			<attribute name="Version" value="${app.version}"/>
		</manifest>

		<echo>Building jar file.</echo>
		<jar jarfile="${jar}/${ant.project.name}.jar"
		  			manifest="manifest.mf">
                <fileset dir="${build}/">
                        <patternset refid="all-classes"/>
                </fileset>
        </jar>
	</target>

</project>

I’ve kept everything in it that you need to run the jar-task, so you can easily adopt it to your needs. If you already have a build.xml for your project and only want to add the parts that put the build information into your jar-file, here is what you need to do:

Make sure you call <tstamp/> prior to accessing the timestamp properties and call <property file="build.properties"/> before building the jar.
Call the svn-info task before building the jar (preferable with a “depends” clause) and copy the part about the manifest from the jar target to your own file.

Building the jar file

Before calling ant jar, you need to update your working copy of the repository. Call svn update at the root of your project folder. This will sync the revision number of your working copy with the revison number of the repository. This has to be done even if you just committed a change, because the “global” revision number of the complete working copy will not be updated by a commit.
Note that this will also update any files that have changes in the repository (which is the reason why it is not done automatically).
Then, call ant jar. This will create a jar-file of your project containing the build information.

To verify that all went well, you can either look at the contents of MANIFEST.MF in your current directory, or unpack the created jar-file and check META-INF/MANIFEST.MF.

Accessing the manifest-information in your Java program

By now, the build information is contained in the jar-file and you can find out what version the jar file is used by extracting its contents and looking at the MANIFEST.MF inside the jar. But wouldn’t it be nice if you could access that information programmatically to show the user the version and build information? This little piece of code does exactly that:

public void readManifest()
{
	try
	{
		JarFile jar = new JarFile("./yourJarFile.jar");
		Manifest manifest = jar.getManifest();

		Attributes attribs = manifest.getMainAttributes();

		builtDate = attribs.getValue("Built-On");
		builtBy = attribs.getValue("Built-By");
		version = attribs.getValue("Version");
		revision = attribs.getValue("Revision");

	}
	catch (IOException e)
	{
		log.error("Cannot read jar-file manifest: " + e.getMessage(), e);
	}
}

Two notes on this method: First, it assumes that yourJarFile.jar is in the current working directory (./ on Windows and Unix). On the Mac, this is not the case; the jar-file will be at ./Contents/Resources/Java/yourJarFile.jar.
Second, the method will throw an IOException if the jar file could not be found or not read for any other reason. This will most likely be the case if you launch your program from within an IDE (for example, while working on it). Therefore, we catch the Exception immediately, so your program stays usable even when not started from the jar file.

The variables set are private members of a “Config” class that can be accessed via getters from other parts of the program (for example, an “about” dialog).