Posts Tagged ‘software development’


Catching all Runtime Exceptions in Swing

March 30, 2009

[note: see my post about writing a java thick client applications using extjs]

So you got some framework that you are using in your swing application and it throws a runtime exception. The Exception is thrown all the way out and ends up on the system.out – very nasty, not good looking and doesn’t help us determining that there is a problem in our application. We might just go on and do the same task again even though the exception was telling us that something went fatally wrong and that it probably would be a good idea to change the state of the application, go into recovery or terminate gracefully.

What can we do to prevent this? We can use try/catch clauses all over the place whenever we call some third party code but that is neither fun nor good code. And still there can be some exceptions slipping by – or are you really sure your code never throws a null pointer exception? Really?

There is an easier way to deal with this problem: All swing activity originates from the event queue and therefore all events are thrown to the event queue as well.  So in order to catch all runtime exceptions such as a null pointer exception we can just use the event queue.

We just need to extend EventQueue and overwrite the dispatchEvent method.

class EventQueueProxy extends EventQueue {

	protected void dispatchEvent(AWTEvent newEvent) {
		try {
		} catch (Throwable t) {
			String message = t.getMessage();

			if (message == null || message.length() == 0) {
				message = "Fatal: " + t.getClass();

			JOptionPane.showMessageDialog(null, "General Error", message, JOptionPane.ERROR_MESSAGE);

The proxy class still calls it’s parents dispatchEvent method and catches anything throwable. When it does, it pops up a simple dialog.

Only thing remaining, we need to install our new event dispatcher on the event queue.

EventQueue queue = Toolkit.getDefaultToolkit().getSystemEventQueue();
queue.push(new EventQueueProxy());

Using this method one can also use exceptions to handle errors throughout a swing application – dealing with errors and exceptions ends up at one place in the application this way and can be used to transform the exceptions into human readable error messages.

For some other helpful links for building swing applications have a look at helpful-java-swing-articles


Analyzing Open Source Projects as a Computer Science Class

January 25, 2009

Looking back at my time studying computer science I remember I learned a lot from the operating system class. The professor implemented his own variation of Xinu ( and then discussed parts of the implementation with us and left some things as an exercise for us to implement. It was one of the harder classes since there was a lot of lab work to actually complete the assignments but I still think about what we did in that class a lot and it gave me a good insight that I still use today.

Since I graduated a lot happened in our industry – as everybody knows, there are more open source projects than one can count. The lessons I learned from Xinu – looking at an architecture and analyzing an implementation – could also be learned from analyzing multiple open source projects and comparing their architecture and design, judging their quality, elasticity (how easy is it to extend and advance them and in what areas), appearance and complexity (complexity of code compared to functionality and overall learning curve complexity to start work on the project).

Analyzing existing code in such a way can be a good entry point into understanding projects and preventing the ‘can not fix because not written by me/it’s not good we have to redo this’ attitude a lot of developers have and would help giving a developer a better feel when a project can not be saved anymore.

I therefore suggest to add a class to computer science studies where the students take apart a set of open source applications and write a paper on their findings. It would be great if those findings should then also be published and available to everybody on the Internet in some public form.