Groovy Code:

import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.Executors
import java.util.concurrent.Callable

def moveSingleDisk(source, dest) {
	//nothing!
}

def moveTower(number, source, dest, temp) {
	if (number > 0) {
		moveTower(number -1, source, temp, dest)
		moveSingleDisk(source, dest)
		moveTower(number - 1, temp, dest, source)
	}
}

AtomicInteger counter = new AtomicInteger()
counter.set(1)

synchronized out(message) {
	println message
}

def logic = {
	start = System.nanoTime()
	moveTower(it, 'A','B','C')
	stop = System.nanoTime()
	out("${it} took ${(stop-start)/ 10**6} milliseconds")
}

def THREADS=16

pool = Executors.newFixedThreadPool(THREADS)
println "Creating a pool for $THREADS threads"

1.upto(64) {
	def value = it
	//out "Submitting job $value"
	task = {c -> pool.submit( c as Callable)}
	task{logic(value)}
}

pool.shutdown()

Java code:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package hanoi2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *
 * @author brad
 */
public class Main {

	static private ExecutorService exec = Executors.newFixedThreadPool(8);

	static void moveSingleDisk(char src, char dst) {
		// System.out.println(src + " => " + dst);
	}

	static void moveTower(int n, char src, char dst, char tmp) {
		if (n > 0) {
			moveTower(n - 1, src, tmp, dst);
			moveSingleDisk(src, dst);
			moveTower(n - 1, tmp, dst, src);
		}
	}

	public void run() {
	}

	public static void main(String[] args) {

		System.out.println("Starting with a thread pool of 8");

		for (int i = 0; i < = 64; i++) {
//      long start, stop;
			final int blah = i;
			exec.submit(new Runnable() {
				public void run() {
					long start = System.nanoTime();
					moveTower(blah, 'A', 'B', 'C');
					long stop = System.nanoTime();
					System.out.println(blah + " took " + ((stop - start) / 1000000) + "ms");

				}
			});
		}
	}
}

Anyway, there’s also something called grails. It’s groovy’s rails application framework. I’m hoping that it’ll be more useful to me than ruby on rails was. Whilst I was able to get some stuff done in rails, I wasn’t able to do quite what I wanted to do. Things didn’t interoperate the way I wanted them to. Building things to be completely REST-ful was a pain. It may simply be that I don’t know enough to do fully RESTful applications.

Also, testing was a pain in rails. I found several testing frameworks, but none quite fit what I wanted to do. That may have had something to do with my insistence upon using constraints in my database. Rails isn’t built to handle constraints, it wants your database to be dumb. I don’t really think that’s a good thing; having constraints in your database allows the database to make more intelligent optimizations regarding the data. Since rails assumes there aren’t any constraints on the database, it generates tests that break databases that use constraints. There are a few work-arounds, but none that exist well enough to actually run all my tests at once. I can piecemeal them and if I do them in the correct order, everything works just fine.

Regarding ruby itself, I miss the ability to create threads. I’ve finally understood threading in java, and how to efficiently and effectively use threads to handle things. Lacking a similar threading operation in ruby (at least an obvious one) I had a lot of trouble trying to implement some of the things I wanted to do. I love the dynamic-ness of ruby, and I like the ability to just write code and it does mostly what I think it should. There is probably a good way to do threading in ruby, I mean, people have written webservers entirely in ruby, I just haven’t figured it out. I’ll probably still use ruby for things, I’ve got a project or two churning around in the back of my mind to use ruby on, but for now, I think I’ll stick with Java.

This has turned more into a rant about what I don’t like about ruby and rails. I guess I’m hoping that grails will live up to my expectations more than rails did, and that groovy will give me the dynamic fun that I enjoyed with ruby.

Groovy feels like Ruby (the name even sounds like it!) but it’s closer to java than Ruby is. That’s good for me to rapidly do stuff. I’ve found that whilst I do enjoy learning new languages and new frameworks, when I want to get stuff done learning the stuff is somewhat of a hindrance for me. Groovy, and it’s framework Grails, shows promise to be the best of both worlds. I (possibly foolishly) purchased the PDF and the Paper copy of Programming Groovy from the Pragmatic Programmers.

I think that if I were to have a favorite publisher, it’d be them. They’re fairly new, about five years old, and located in Texas. I’ve spent more on books through them than just about anywhere else. And I haven’t been dissappointed yet. I also purchased Pragmatic Thinking and Learning. I’m hoping this will help me become more proficient in learning things. It also is somewhat of an interesting subject to me; mastering the mind to further enhance my ability to learn and become an expert in my field.

If you’re looking for some good programming books, I can highly reccomend The Pragmatic Bookstore.