an IRC Bot written using BGGA

I was curious how hard it'd be to write an IRC Bot using BGGA closures; now to compile this you'll need to grab the prototype and the jerklib jar. So here's the code:

import jerklib.ConnectionManager;
import jerklib.ProfileImpl;
import jerklib.Session;
import jerklib.events.IRCEvent;
import jerklib.events.JoinCompleteEvent;

/**
 * Created: Apr 6, 2008 9:19:13 PM
 *
 * @author Robert O'Connor
 */
public class BGGAIRCBot {
    ConnectionManager manager = new ConnectionManager(new ProfileImpl("bggabot","bggabot","bggabot2","bggabot3"));
    Session s = manager.requestConnection("irc.freenode.org");

    public BGGAIRCBot() {
        s.addIRCEventListener({IRCEvent e =>
            if(e.getType() == IRCEvent.Type.CONNECT_COMPLETE) {
                e.getSession().join("#jerklib");
            } else if(e.getType() == IRCEvent.Type.JOIN_COMPLETE) {
                JoinCompleteEvent jce = (JoinCompleteEvent)e;  
                jce.getSession().sayChannel(jce.getChannel(),"Hi from BGGA!!!");
              }
        });


        
    }

    public static void main(String[] args) {
        new BGGAIRCBot();

    }
    

}

Now, what would it look like without BGGA? It would like something like this:

import jerklib.ConnectionManager;
import jerklib.ProfileImpl;
import jerklib.Session;
import jerklib.events.IRCEvent;
import jerklib.events.JoinCompleteEvent;
import jerklib.events.listeners.IRCEventListener;

/**
 * Created: Apr 6, 2008 10:05:09 PM
 *
 * @author Robert O'Connor
 */
public class JavaBot {
        ConnectionManager manager = new ConnectionManager(new ProfileImpl("javabot", "javabot", "javabot2", "javabot3"));
        Session s = manager.requestConnection("irc.freenode.org");

        public JavaBot() {
            s.addIRCEventListener(new IRCEventListener() {
                public void receiveEvent(IRCEvent e) {
                    if (e.getType() == IRCEvent.Type.CONNECT_COMPLETE) {
                        e.getSession().join("#jerklib");
                    } else if (e.getType() == IRCEvent.Type.JOIN_COMPLETE) {
                        JoinCompleteEvent jce = (JoinCompleteEvent) e;
                        jce.getSession().sayChannel(jce.getChannel(), "Hi from Java!!!");
                    }

                }


            });
        }

        public static void main(String[] args) {
            new JavaBot();
        }

}

Swinging: BGGA style.

So, to continue on with my playing w/ java closures, I now present Swing event handling: BGGA Style. Again, to compile this you will need the BGGA prototype. You can run it using your installed jre.

First, i'll show you the java version:

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.SwingUtilities;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

/**
 * Created: Mar 19, 2008 5:48:43 PM
 *
 * @author Robert O'Connor
 */
public class UsualJavaGui {
    JFrame frame = new JFrame("Usual Java Example");
    JButton button = new JButton("Press me");

    public UsualJavaGui() {
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button pressed");
            }
        });
        frame.add(button);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new UsualJavaGui();
            }
        });

    }
}

I think you get the gist of what it does. Now the BGGA version.

import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.SwingUtilities;
import java.awt.event.ActionEvent;

/**
 * Created: Mar 19, 2008 7:35:15 PM
 *
 * @author Robert O'Connor
 */
public class BGGAGui {
    JFrame frame = new JFrame("BGGA Frame");
    JButton button = new JButton("Press me");

    public BGGAGui() {
        button.addActionListener({ActionEvent evt => System.out.println("Button pressed");});
        frame.add(button);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        // thanks to neil gafter!
        SwingUtilities.invokeLater({ => new BGGAGui(); }); 

    }
}

What occurs within the the addActionListener() is that when you click the button, that closure is invoked; it does the same thing the java one does (print "Button pressed" to the screen). I'm not sure how to write the invokeLater() method using BGGA to reduce its verbosity. If anybody knows, could you tell me? When the code is executed; the closure is executed and a frame is displayed; yadda yadda.

Closures in java: Fibonacci gets some closure

So, in my previous post I promised an example; it's a simple example. In order to compile it you will need to download the BGGA prototype. You can run it using your installed jre. I'll fiddle with it some more but i wanted to put this one up, so here we go:

public class FibonacciSequenceWithClosures {
    public static void main(String[] args) {
        int fib = {int n => fib(n)}.invoke(Integer.parseInt(args[0]));
        System.out.println(fib);        
    }

    /**
     * Helper method to recursively calculate the 
     * n-th number in the fibonacci seqeunce. 
     * @param n
     * @return the n-th number
     * @throws IllegalArgumentException if you pass in a negative number 
     */
    public static int fib(int n) {
        if(n < 0) {
            throw new IllegalArgumentException("Must be Postive!");
        } else if(n == 1 || n==2) {
            return 1;
        } else {
            return fib(n-1) + fib(n-2);
        }
    }
}

What's going on here? Let's examine it line by line. First you've got your familiar standard class definition; I declare a variable named fib, I'm sure you're asking the what the heck is

 int fib = {int n => fib(n)}.invoke(Integer.parseInt(args[0]));

Answer: it's a closure! We'll examine that line closer.

int fib = { int n => fib(n)}.invoke(Integer.parseInt(args[0]));

First, we have the parameters that we're passing into the closures, then you see

int fib = { int n => fib(n)}.invoke(Integer.parseInt(args[0]));

and you're probably wondering what in god's name that operator is, it's the closure operator! Now, the final piece:

int fib = { int n => fib(n)}.invoke(Integer.parseInt(args[0]));

What i'm doing here, is calling the invoke method on the closure itself, and passing in the first argument passed to the program via a command-line argument. Finally, After all this is done, I print the value returned from the closure that i stored in the variable fib and we're done. You'll get a StackOverFlowException if you pass too large a number. I could probably fix this, but this is sufficient for a simplistic example.

Closures in java

I have the tendency to come off as a real idiot sometimes; and I tend to evangelize anything that looks remotely cool; and that's true, but BGGA closures, looks interesting to me. However, after I watched Josh Bloch's The Closures Controversy [slides] a few weeks ago, I got very turned off. The latest prototype looks a little bit better. I'll fiddle with it and post the code I wrote up here. Once again, I've yet to play with it, but perhaps it's better? All I know is that the groovy-like syntax for the closure operator piques my interest.