I have just created a library that makes it easier to work with that: JFileHelpers. It uses the awesomeness of Java annotations to allow you to handle flat files with minimum changed to existing code. It’s a port of the awesome FileHelpers C# library, by Marcos Meli.

We are also looking for developers who would be interested on joining the team. If you’re not available, you can also help by using the library, and giving feedback on features you’d like to see implemented.

Hope you like it, I would really like to hear your opinions on the library.

I quited, long time ago, trying to keep pace with latest tech trends on programming languages. I remember when I started programming, using Clipper, all the news you could get was either by buying a book or a magazine.

Today, when you visit a Digg-like website for programming news, you’ll probably end up finding 3 new and completely revolutionary AJAX toolkits, two articles saying why language x sucks and other three saying it is the best thing since sliced bread, new languages, benchmarks, etc… This scenario obligates you to filter new technology and just investigate whatever you think will be important for your skill set. It’s either that or getting really mad and/or shallow.

Well, some time ago I began to read about Java Closures but never figured out what it was and I really didn’t want to bother about it. Yes, but that was before I found Google Tech Talks, and of more interest, the Advanced Topics on Programming Languages series. I watched a 2-hour talk about Java Closures and finally understood it. Actually it was more than that, I started to like Java Closures.

The principle behind Closures isn’t new. It’s about having code blocks in form of variables. I remember that we had that in Clipper back in 1996. But the new Java Proposal goes beyond, allowing some syntax changes that, in my understanding, makes all the difference. I’ll try to give a brief explanation on what I understood on the topic.

If you ever messed with JDBC or Sockets code, you know there are a lot of boring code to write, something like:

public List getCustomers() {
	List result = new ArrayList();
	Connection conn;
	Statement s;
	ResultSet rs;

	try {
		conn = ConnectionPool.getConnection();
		s = c.createStatement();
		rs = s.executeQuery("SELECT * FROM CUSTOMER");

		while (rs.next()) {
			// ...
		}
	} catch (SQLException e) {
		System.out.println("Error...");
		e.printStackTrace();
	} finally {
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
			}
		}
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
			}
		}
		if (c != null) {
			try {
				c.close();
			} catch (SQLException e) {
			}
		}
	}
}

On this code you notice you have 37 lines but business logic is concentrated on lines 7 to 13, or 16% of the code here is business logic. So, when a friend of mine says he doesn’t like Java because it is a bureaucratic language, I have to give in. Imagine having hundrets of data access methods like this on your code. Isn’t it really a lot of duplicated code? Shouldn’t it have a better way of doing this?

Well… Closures to the rescue! What if we could write something like:

public List getCustomers() {
	Connection conn;
	Statement s;
	ResultSet rs;

	with(conn, s, rs, { =>
		conn = ConnectionPool.getConnection();
		s = c.createStatement();
		rs = s.executeQuery("SELECT * FROM CUSTOMER");

		if (rs.next()) {
			// ...
		}
	});
}

That’s the new java construct that is being planned to be implemented on JDK7 codename Dolphin. But even better than what we have above, there is an additional construct, called control abstraction syntax. Take a look:

public List getCustomers() {
	Connection conn;
	Statement s;
	ResultSet rs;

	with (conn, s, rs) {
		conn = ConnectionPool.getConnection();
		s = c.createStatement();
		rs = s.executeQuery("SELECT * FROM CUSTOMER");

		if (rs.next()) {
			// ...
		}
	}
}

This snippet of code is translated to the exact same thing as before. This new construct states that a method invocation with a trailing code block is automagically translated into a closure in compile time. Look how elegant and straightforward this method now is. When you read it, you don’t get distracted by a lot of statements that has nothing to do with business logic.

What about the with method? How would it look like?

public void with(Connection c, Statement s, ResultSet rs, { => void } block) {
	try {
		block.invoke();
	} catch (SQLException e) {
		System.out.println("Error...");
		e.printStackTrace();
	} finally {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
			}
		}
		if (s != null) {
			try {
				s.close();
			} catch (SQLException e) {
			}
		}
		if (c != null) {
			try {
				c.close();
			} catch (SQLException e) {
			}
		}
	}
}

The last parameter on that method is the new closure construct. Closures can take parameters and have a return value as well as optionally throw exceptions. Here are some sample closure types:

{int => int}

{int, int => int}

{String => int throws NumberFormatException}

{ => void }

{T => U}

And implementations:

{int x => x+1}

{int x, int y => x+y}

{String x => Integer.parseInt(x)}

{=> System.out.println("Hello world");}

{int, int => int} sum = {int x, int y => x+y}; // sums up x and y

This article is intended to get you started on java closures. For more in-depth understanding watch the first class presentation by Neal Gafter, one of the authors of the closures specification. Here is the link.

Related links:

I guess it’s been a long time, right? Yeah, lots of things happened since last post, good things indeed. I have quit my previous job to join the Big Blue. Yeah, you know, IBM… I was a little bit skeptic about changing jobs, mostly because I didn’t know exactly what I was going to find here, what kind of project I would be involved on.

Well, for my surprise the first thing that I received when I started was an excellent trainning on the WebSphere Integration Developer or the WID Tools as IBMers like to call it (yes, they just LOVE letter soups!). And along came the concept of SOA (Services Oriented Architecture), what seems to be the buzzword on the corporate world for the moment. I gotta admit it’s a good concept, but I have been hearing about that for almost 10 years now. SOA mixes WebServices with Workflow tools in a nice way. All you have to do is draw your process and there you go. Well, from a management point of view, that’s kinda true. But behind the scenes, as we all know, there are some hard work. And thanks god there is, imagine if all costumers could build their applications just by pointing and clicking – I would not be hired right now!

Aside of that, I am involved on a great project, with lots of smart people involved and an excellent team. My manager is reasonable, likes to be involved and the other developers are quite open to hear what you have to say.

Well, those are the news from the front so far… In minutes I’ll get back to the action with an article about Java and ActiveX interop. See you all by then.

Cheers!

• Can’t seem to find use for code

• Didn’t have the required insight

• Want to remove some coding, but didn’t got the guts or second guessed

• Find one of those just to have conditions

• Are just mad mad mad

• Are really on the mood to create sample data

Have Fun!!!

The catch is that they offer versions with the most useful plug-ins pre-configured into the distribution. In addition, you also can download self-installing plug-ins from the website.

PROS

• Out-of-the-box configuration
• MacOS, Linux and Win32 automated installation
• Download, click, install plug-ins
• Multiple languages versions, like LAMP, PHP, Ruby on Rail, Python, …

CONS

• Based on rather old 3.1 version

So, that’s it. Let’s just hope they make the migration to 3.2. When they do I will most likely start to use it as my default IDE.

See ya next time!

Update: Cool! EasyEclipse.org’s member Phillip just sent the link to the 3.2 beta preview. Keep up the good job!

Well, back when I was a terrible newbie programmer using Clipper as the main development language, someone convinced me that every function (that was the name for a procedural equivalent of today’s object’s methods) needed one unique return point. I stickied to it but never questioned myself ever again if this is really a good thing to do. Nowadays I got myself doing just the opposite: using multiple return points and when I analyzed it, I found that really better. I’ll explain.

Imagine the following method that searches for a particular object within an ArrayList:

private boolean userExists(String name) {
  boolean found = false;
  for (User u : this.getAllUsers()) {
    if (u != null && name.equals(u.getName())) {
      found = true;
      break;
    }
  }
  return found;
} 

Doesn’t this method seems a lot cleaner and easier to understand than:

private boolean userExists(String name) {
  for (User u : this.getAllUsers()) {
    if (u != null && name.equals(u.getName())) {
      return true;
    }
  }
  return false;
} 

There are other cases where I can see the code begging for an immediate return like:

private void loadUsers() {
  if (usersLoaded) {
    return;
  }

  // do all the lengthy user loading...
  (...)
}

In my opinion, the early return when the users are already loaded are easier to interpret and easy to review by another coder than:

private void loadUsers() {
  if (!usersLoaded) {
    // do all the lengthy user loading...
    (...)
  }
  return;
}

I really don’t think it’s a major problem and using one or the other is pretty acceptable but I’d like to hear from you what you think about it so please leave a comment about it if you can. Thanks.

Update: A friend of mine just e-mailed me an article that addresses the same issue.

I digged all around for an algorithm to do that and found a way to do it.

After reading some codes that did the trick in other languages, I finally figured out how to create a routine to change the colors. The basics behind it is the following:

The MIDP 2.0 API has the ability to extract an array of RBG data from an image by calling the Image‘s getRGB() method. This method takes the following parameters:

getRGB(int[] rgbData, int offset, int scanlength, int x, int y, int width, int height)

Where:

rgbData – an array of integers in which the ARGB pixel data is stored

offset – the index into the array where the first ARGB value is stored

scanlength – the relative offset in the array between corresponding pixels in consecutive rows of the region

x – the x-coordinate of the upper left corner of the region

y – the y-coordinate of the upper left corner of the region

width – the width of the region

height – the height of the region

So, to get all image data you need:

int[] raw = new int[image.getWidth() * image.getHeight()];
image.getRGB(raw, 0, image.getWidth(), 0, 0, image.getWidth(), image.getHeight());

What you have now is an array of integers representing each pixel of the image in the AARRGGBB format where RR is red, GG is green, BB is blue and the leading AA is alpha). The alpha attibute defines the opacity of that particular pixel and 00 means completly transparent and FF (255) means completly opaque (solid).

So, to change colors we need to change all pixels that matches an RGB value regardless of what the alpha byte is. To do that we need to “mask” the pixel value with the “&” operator. The first mask we need is to extract (and later on preserve) the alpha value. This mask is 0xff000000 and, as you probably noticed, the ff matches the AA position on the integer (it is the leftmost byte on the integer).

Once we have the alpha value, we need to mask the integer again to extract the RGB color. The mask to do that is the opposite of the previous mask: 0x00ffffff. This mask drops the leftmost byte and extracts the desired RGB value.

Now that you have the alpha value and the RGB value, all you need to do is iterate throughout the pixels array and match the RGB color with the one you are replacing. This step is illustrated on the following snippet:

        // check each color to replace
        for (int j = 0; j < maskedOldColor.length; j++) {
            if (currentMaskedPixel == maskedOldColor[j]) {
                raw[i] = (currentPixel & alphaOnlyBitmask) | maskedNewColor[j];
                break;
            }
        }

Well, I think you got the idea. Anyway, this is my first post and I’d like to know what you think about it so please: comment it!

Regards,

Felipe.