Working with multiple screens in Java

When you want to set the location of a Java Window, you just call setLocation(int x, int y). But what if your screen isn’t big enough? Or when you want to display the window on a second screen?

The desktop is represented by a virtual device, with physical screens providing a viewport onto that device. The top-left corner of the primary screen is always located at coordicates (0, 0). Other physical screens are located relative to this coordinate. See the api-documentation for java.awt.Frame for more information.

To get all available graphics devices, which represent physical screens, use the following code:

GraphicsDevice[] graphicsDevices = 
    GraphicsEnvironment
        .getLocalGraphicsEnvironment()
        .getScreenDevices();

Then, to get the bounds or the offset and size of each device, use the following code:

Rectangle bounds = 
    device
        .getDefaultConfiguration()
        .getBounds();

This works for all screens _except_ the primary screen. The primary screen also contains a taskbar, and you usually don’t want to place a window over the taskbar.

To get the bounds of the primary screen, without the taskbar, use the following code:

GraphicsEnvironment
    .getLocalGraphicsEnvironment()
    .getMaximumWindowBounds();

Pomodoro 0.2 released

It has been a while since the first version of this pomodoro tracker has been released. Development has continued, and there have been a few changes:

  • Backported to Java 1.7.
  • Added popup dialog when Pomodori are done, to ask whether to register it as a complete one:dialog-0.2
  • Added popup dialog when breaks are done, to ask whether to start a new Pomodoro
  • Added the ability to manually reset the current amount of done pomodori
  • The current amount of done pomodori will can be automatically reset after X amount of minutes (default 60 minutes)
  • Popup dialogs will auto-close after 5 minutes
  • Reduced font size of wait screen so it will display correctly on Linux

The updated version can be downloaded here. Source code can be found here.

WAS Deploy Script

When you’re developing for IBM Websphere, you could update your application using the webinterface. But that is a bit slow, and you risk trashing your Websphere installation. You can also use a script. Below is a Windows batch file to do just that.

@setlocal

set WSADMIN_BIN=C:\was_profile\bin
set APP_NAME={My Web Application}
set EAR_LOC=C:\location\application.ear

cd  /D %WSADMIN_BIN%
call wsadmin -c "$AdminApp update %APP_NAME% app {-operation update -contents %EAR_LOC%}"

Installing and using Citrix under Linux Mint

Installing and using citrix under linux might be a bit more tricky than it may appear on first glance. Here are a few steps to make it work.

1. Remove old installation, if needed.

sudo apt-get remove icaclient

2. Download Receiver for Linux. Look for it here: http://www.citrix.com/go/receiver.html
Make sure you have the correct version. This is probably under “For 64-bit Systems”

3. Open the download, and install through package manager.

4. Link certificates:

sudo ln -s /usr/share/ca-certificates/mozilla/* /opt/Citrix/ICAClient/keystore/cacerts

5. in firefox, set Citrix Receiver for Linux plugin to Always Activate.

Troubleshooting Power-Line Communication

Power-Line Communication, turning the power-grid in your home into a computer network, works great! Until it doesn’t. The problem could be that the adapters can find each other, or that the connection is unstable.

Here are some troubleshooting tips that could help with stabilizing the connection:
– Set the network name to some custom name, using the Utilities software which comes with the adapters. Don’t use the default “HomePlugAV”. Check whether there are unknown network adapters which use the name “HomePlugAV” on your network. This could indicate Neighboring Networks Interference.
– Plug the adapter directly into the wall socket. Extension cords degrade the signal.
– Buy adapters with built-in power sockets, and some form of filter. These help to reduce interference even further.

You should see improved performance with these tips

When an application isn’t visible in WebSphere

Every once in a while, WebSphere doesn’t like you. You try to install or update an application, but it refuses to do so, saying the application already exists, and you need to specify a different name. And when you look at the list of your applications, the one you try to install or update isn’t there anymore!

WAS-deployment_error_detailed

Solving this problem isn’t hard, if you know where to look.

1. Shut down the server

2. On the filesystem, remove the application from the following locations:

  • <profile root>/config/cells/<cellname>/applications/<application name>
  • <profile root>/config/cells/<cellname>/blas/<application name>
  • <profile root>/config/cells/<cellname>/cus/<application name>

3. Delete everything from the profile/temp and profile/wstemp directories

4. If needed, edit the following file:
<profile root>/config/cells/<cellname>/nodes/<nodename>/serverindex.xml
Look for the tag <deployedApplications>, and remove your application from there.

5. start the server

You should be able to install your application again.

Sources:
http://www-01.ibm.com/support/docview.wss?uid=swg21590141
http://www.albeesonline.com/blog/2008/04/15/application-already-exists-in-the-configuration-repository-error/

Java: Remove an element from a List

One of the more common tasks in programming is removing a specific element from a list. Although this seems to be straight-forward in Java, it’s a bit more tricky.

Before we start, we should build our list:

   public ArrayList<String> createList(){
      ArrayList<String> myList = new ArrayList<String>();
      
      myList.add("String 1");
      myList.add("String 2");
      myList.add("String 3");
      myList.add("String 4");
      myList.add("String 5");
      
      
      return myList;
   }

Let’s say we want to remove the String “String 2”. The first thing that comes to mind is to loop through the list, until you find the element “String 2”, and remove that element:

   public List<String> removeFromListUsingForEach(List<String> sourceList){
      for(String s : sourceList){
         if (s.equals("String 2")){
            sourceList.remove(s);
         }
      }
      return sourceList;
   }

Unfortunately, in this case, this will throw a

java.util.ConcurrentModificationException

I said “in this case”, because the exception is not always thrown. The details of this strange behavior is out of scope for this blogpost, but can be found here.

There are several ways to remove an element from a list. Depending on your personal preference, and which version of Java you use, here are some examples.

1. Use a for-loop which loops backwards
You can use a for-loop, which runs from the end of the list to the beginning. The reason you want to loop in this direction is, that when you’ve found the element you want to remove, you remove the element at that index. Every element after this one will shift one position towards the beginning of the list. If you’d run the loop forward, you’d have to compensate for this, which just isn’t worth the effort.

   public List<String> removeFromListUsingReversedForLoop(List<String> sourceList){
      for(int i = sourceList.size()-1; i >= 0; i--){
         String s = sourceList.get(i);
         if (s.equals("String 2")){
            sourceList.remove(i);
         }
      }
      return sourceList;
   }

This works in every Java version since 1.2, although you can’t use generics until Java 1.5.

2. Use an Iterator
Another way to remove an element from a list is to use an Iterator. The Iterator will loop through the list, and, if needed, can remove the current element from that list. This is done by calling

Iterator.remove()
   public List<String> removeFromListUsingIterator(List<String> sourceList){
      Iterator<String> iter = sourceList.iterator();
      while (iter.hasNext()){
         if (iter.next().equals("String 2")){
            iter.remove();
         }
      }
      return sourceList;
   }

This works in every Java version since 1.2, although you can’t use generics until Java 1.5.

3. Use Java 8 Streams
What you’re essentially doing here is make a copy of the list, and filter out the unwanted elements.

   public List<String> removeFromListUsingStream(List<String> sourceList){
      List<String> targetList = sourceList.stream()
            .filter(s -> !s.equals("String 2"))
            .collect(Collectors.toList());
      return targetList;
   }

This works since Java 1.8. More about Java 8 can be found here.

Distributed Websearch

When it comes to searching the web, the first thing that comes to mind is Google. Or Bing. Or Yahoo. Sure, it’s easy, fast, and sort of reliable. However, there are a few problems with these kinds of services.

First of all, there’s the filter bubble. These search engines (and social networks) will present results that are specifically tailored for you. On the one hand, this is a good thing, because you’ll probably find what you’re looking for faster. However, you’ll never find information that COULD be relevant, but is filtered out for you. Your world view is being limited by this filter bubble.

You can work around this by using “anonymous” search engines, such as DuckDuckGo or Startpage. These search engines don’t store your personal data, and therefore can not create a filter bubble for you. As for Startpage, that search engine will act as a proxy between you and Google. You will usually get high quality results to your search query.

Another problem is “The Right To Be Forgotten”. The European court ruled that Google needs to provide the option to delete certain search results from its index. When you’ve had problems, which have been resolved, you shouldn’t be judged on the basis of those past problems. However, once information is on the Internet, it’s very hard to remove. The toothpaste is out of the tube, the genie out of the bottle. You’ll never get it back in. Google provides links to this information, it does not provide the information itself. Removing the links is not the same as removing the information. We have seen the same misunderstanding in the case of The Pirate Bay.

YaCy

Since a couple of years, there is YaCy. YaCy is a distributed search engine, that ensures TRUE anonimity, and is impossible to take down. You need to install a piece of software on your computer, browse to the local webserver (probably http://localhost:8090/), and start searching. At this moment, there are 1.7 billion documents in the public network. In contrast, the web is estimated to contain 15 to 55 billion documents.

There are a couple of other interesting features in YaCy, such as creating a search engine for one specific topic, or a search engine for your local intranet. Give it a try.

Ingress

About one week ago, I started playing Ingress, a mobile game that is basically a hybrid between geocaching and capture the flag. And when I say “mobile game”, I mean that you have to walk around with your phone. That is, outside, in the real world.

The game centers around a newly discovered substance called Exotic Matter, or XM, which is associated with a mysterious alien race called the Shapers. This XM leaks into our world through portals, which are real-world objects such as art, architecture, landmarks, and so on. You need to go out and find these portals, and capture them. Once captured, you can link portals together, and create control fields.

There are two factions in the game: the Enlightened and the Resistance. The Enlightened embrace this new phenomenon, and think it is the next step in human evolution. The Resistance disagree: they think the Shapers are dangerous and need to be stopped. When you start playing the game, you need to chose a side. Be careful, you can only change this once!

Upsides of the game:

  • You need to walk around, outside. The American Heart Association recommends walking 10.000 steps per day, on avarage. With this game, that’s peanuts!
  • You’ll explore the city, finding pieces of art that you never knew were there in the first place.
  • As with every group activity, you’ll meet new people. Whether it is because you are invited to a local Ingress community, or because you’re hacking portals and another player is nearby.

Downsides:

  • Since this game is created by google, it probably is a privacy disaster. It needs to send your location directly to google, in order to update the game correctly. However, most of the time you are at those locations because of the game.
  • The game is very demanding of your phone. The graphics, constant Internet connection, and GPS will drain your battery quickly. An extra batterypack is no luxury.
  • I already mentioned the constant Internet connection. This game uses a lot of data. Make sure your mobile data plan is large enough.

The Pomodoro Technique

One of my favorite time management methods is the Pomodoro Technique. The method is basically as follows:

  1. Pick a task.
  2. Work on it for 25 minutes. This is called a Pomodoro.
  3. Take a 5 minute break. Do something totally unrelated to your work.
  4. Work for another Pomodoro, or 25 minutes. This can be on the same task, or a new one if the previous one is finished.
  5. After 4 Pomodoros, take a longer break of 15 to 30 minutes.

Because of the breaks, your mind gets just enough rest to stay focussed. Also, because you’re supposed to work on one task, and one task only during your Pomodoro, the quality of your work can go up.

Ofcourse, the technique is completely customizable. Do you think 25 minutes is too short (or too long)? Try 45 minutes (or 10 minutes). Do you need a long break sooner? Do it every 3 Pomodoros.

No I’ve made my own Pomodoro tracker. It’s written in Java 8, and it’s open source. You can find the source here . A runnable version can be found here.

This is still work in progress, and I mainly made it as a challenge to myself. If you like it, do whatever you want with it.

The pomodoro is running!
The pomodoro is running!

When the screen and the tray icon are red, a pomodoro is running. Right clicking the tray icon will bring up a menu.

Pomodoro break.
Pomodoro break.

When the screen and the tray icon are green, you are on a break.

Waiting for the next Pomodoro to be started.
Waiting for the next Pomodoro to be started.

When the screen and the tray icon are blue, the program is waiting.

Changing the settings
Changing the settings

The settings allow you to specify the location of the program, the times and the number of Pomodoros between long breaks.