Development for the masses

Moving into narkisr.com

2010-04-04T05:26:00.000-07:00

This blog has served me well for the past three years still iv decided to give it a new home that iv developed, eating my own dog food.

Since Iv developed the entire thing I believe that the reading experience will be better & more interesting to you all, all the old content has been migrated, ill redirect to the new one.

Looking forward to meet you there!

Cool Groovy techniques

2010-01-09T08:13:00.000-08:00

Groovy is a versatile & very powerful language to code with, as a Java super set it enables a Java programmer to write its code with all the known Java idioms & progress into Groovy land in small steps, in this post ill present two techniques that I find to be very powerful.

The first is closure initialization, in Java land its common that when we have an object A which uses another object B with non trivial construction code (which depends on A's input) than we write all the initialization code of B inside A constructor:


class ComplexInit { // our B
  // ... some state that need to be initialized by users of this class
}

class UsesComplex {// our A
  private ComplexInit v
  def UsesComplex(){
     v = new ComplexInit()
     //..  some complex initialization logic which depends on UsesComplex 
  }
}

Another common practice is to create a factory that will encapsulate the initialization of ComplexInit class taking A as input:


class ComplexInitFactory {
  def createComplexWith(UsesComplex u){
    // initialization code which depends on 
  }
}

Groovy offers another way which I named "closure initialization":


class UsesComplex{
  private ComplexInit val = {
     def result = new ComplexInit()
     // more logic here
  }()
  
  def UsesComplex(){
    // ComplexInit is initialized above   
  }
}

Note that we are embedding a closure within the UsesComplex class & call it immediately after it has been defined, this resembles static initializer code blocks in Java except that it not static at all, the anonymous closure has access to its surrounding scope & can access other data members during its run:


class UsesComplex{
  def today = new Date()

  private ComplexInit val = {
     def result = new ComplexInit()
     result.a = today
     result
  }()
}

By separating our constructors into initialization blocks we modularize the construction of our object, making our code more readable & DRY (no separation between deceleration & initialization).
Another interesting technique is dynamic method dispatch, in Groovy we can dispatch methods like so:


class Target{
  def methodA(){ println 'hey'}
}

new Target().methodA()
new Target()."methodA"()// this works too!

This means that we can dispatch methods according to run time logic:


class Target{
  def calcA(){'a'}
  def calcB(){'b'}
  def calcC(){'c'} 
  def notCalc(){'d'}
}

def t = new Target()
def calcs = t.metaClass.methods.findAll{it.name.startsWith('calc')}.collect{it.name}
calcs.each{println t."$it"()}// will print a b c

Its true that Java reflection has similar capabilities however the Java API is very verbose & not as elegant, use this technique with care since it may result with hard to read code!

Thats about it for this post, let me know if you find these techniques useful in your code.

Synching your enviroment around

2009-10-31T11:34:00.000-07:00

Ubuntu 9.10 has just came out & iv rushed to upgrade, upgrading my 9.04 to 9.10 via the upgrade manager is a working option but usually id rather do a clean install & get a fresh system to poke around.
The main issue that clean install brings is restoring your old environment which includes installed programs, settings files (.bashrc, .vimrc etc..), non packaged applications (usually the latest & greatest versions of Clojure, Groovy etc..).
Another issue is the need to restore these settings on multiple machines while keeping it all consistent between them, there must a better way than working it all manually!

Well the solution that iv come with involve two tools, Dropbox & AutomateIt, Dropbox is no more than a fancy folder to the cloud synchronizer which enables me to access all my settings file from any machine, lsym-ing my .bashrc, .vimrc & any other file that id like to share across machines into the Dropbox folder is all that is required.

The second part involves AutomateIt, which is a configuration management framework written in Ruby, an easy way of re-creating symlinks from my Dropbox folder onto a new system is using the following AutomateIt script:


HOME = ENV['HOME']
DROP = "#{HOME}/Private/Dropbox"

def link(src,dst)
   ln_s("#{DROP}/#{src}","#{HOME}/#{dst}")
end

# Vim
link "vim/.vimrc",".vimrc"
link "vim/.vim",".vim"
link "vim/.vimclojure-2.1.2",".vimclojure"
# Bash
link "BashEnv/.bashrc",".bashrc"
link "BashEnv/.inputrc",".inputrc"
# Languages
link "prog-langs/.clojure",".clojure"
link "prog-langs/.groovy",".groovy"
link "prog-langs/.jruby",".jruby"

The nice thing about it is that it hides all the nitty gritty details that id have to figure out when using plain Ruby (or any other environment for that matter), AutomateIt wraps common tasks with a bash like DSL, unlike bash this DSL is portable across multiple unix systems & it hides many of the complexities that follow.
AutomateIt performs actions only when they are required, this solves annoying cases that rise when scripts run more than once on a system (e.g. appending text to files).

Another cool feature is package management, AutomateIt is capable of interacting with multiple packaging systems (yum, apt, gem etc..) in a transparent way, its easy to replicate installed packages onto multiple systems:


# bash
%w(terminator rlwrap).each{ |p| package_manager.install p}

# programming
%w(vim git-core).each{ |p| package_manager.install p}

# communication
%w(deluge openssh-server).each{ |p| package_manager.install p}

# misc
%w(gpodder gnome-do).each{ |p| package_manager.install p}

# installing dropbox
download_manager.download 'http://www.getdropbox.com/download?dl=packages/nautilus-dropbox_0.6.1_i386_ubuntu_9.10.deb' , :to => '/tmp/nautilus-dropbox_0.6.1_i386_ubuntu_9.10.deb'
package_manager.install ({'nautilus-dropbox' => '/tmp/nautilus-dropbox_0.6.1_i386_ubuntu_9.10.deb'} , :with => :dpkg)

Using these tools has made configuration nirvana a bit closer to me & hopefully to you :)

The easiest singleton around

2009-07-25T06:50:00.000-07:00

Iv just finished watching stuart-clojure-presentation where the issue of singletons is mentioned (global & thread local ones), a note from the audience mentions delay as a solution, REPL-ing a bit shows how this works:


user=> (defn singleton-factory []
         (println "creating object")
         (+ 1 2))
#'user/singleton-factory
user=> (def singleton (delay (singleton-factory)))
#'user/singleton
user=> (defn usage []
         (force singleton))
#'user/usage
user=> (usage)
creating object
3
user=> (usage)
3

Stuart does mention contrib singleton which has also per-thread-singleton.


user=> (use 'clojure.contrib.singleton)
nil
user=> (def t-singleton (per-thread-singleton singleton-factory)) 
#'user/t-singleton
user=> (defn use-twice [] (+ 1 (t-singleton)) (+ 1 (t-singleton)))
#'user/use-twice
user=> (defn use-twice-no-singleton [] (+ 1 (singleton-factory)) (+ 1 (singleton-factory)))
#'user/use-twice-no-singleton
user=> (. (Thread. use-twice) start) ; each Clojure Fn implements Runnable
nil
user=> creating object ; REPL prints on the wrong line

user=> (. (Thread. use-twice-no-singleton) start)
user=> creating object ; same thing
creating object

user=>

This should come useful when working with all those Java mutable objects.

Dont overflow yourself!

2009-07-23T15:57:00.000-07:00

Clojure has many nice less highlighted features, one of these is overflow protection, this can be a true life saver:


user=> (unchecked-add 1 2); not safe but might be faster
3
user=> (unchecked-add (. Integer MAX_VALUE) 2); oops
-2147483647
user=> (+ (. Integer MAX_VALUE) 2) ; using safe arithmetic again
2147483649
user=> (+ (. Integer MAX_VALUE) 23)
2147483670
user=> (class (+ (. Integer MAX_VALUE) 23)); Clojure does the right thing for us
java.lang.Long

It does pack more than just concurrency up its sleeve.

Genericsfaction, getting some generics satisfaction

2009-06-29T14:26:00.000-07:00

Java generics have a lot of short shortcoming, most of which are the result of the religious backward compatibility that Java is known for.
One of the most annoying "features" of generics is type erasure in which the compiler removes (almost) any trace of generic types meta data.

Iv been pondering about this issue & had a simple idea, what if we could add back in the meta data that the erasing process removed?
So, iv decided to create a proof of concept in order to show how this might work and named it genericsfaction.

Using genericsfaction requires an additional code manipulation stage in which the source code is scanned & gets its AST manipulated (meta data is introduced), each manipulated source file is dumped into a separate folder (named gen), all that is left is to compile the files under gen (instead of the original src).

At the moment there are only two enrichments implemented, the first is method input parameters annotation enrichment:


public void twoTypeParamsMet(@GenMeta(stringRep = "((Object ()) (Object ()))", classes = { Object.class, Object.class }) Map <Object, Object> map) {
   // method code
}

The second is variable initialization enrichment:


public static void main(String [] args) {
   List<Integer> list = (List <Integer>)MetaProxy.newInstance(new ArrayList<Integer>(),"(Integer ())",new Class []{Integer.class});
 }

The reason that annotations aren't used in this case is due to this limitation.

There is no release to play with yet, however the source is up on github (mostly Clojure), I am planing on making a release as soon as ill finish to implement a validation module that uses this meta data in runtime.

Newify your Object

2009-05-23T13:21:00.000-07:00

Update a generous Anonymous has left a comment that the following special macro form does the same as the newify function that i present later on:


(def nested-object (-> GrandFather. Father. GrandSon.))

Feel free to skip this entry (unless your interested in an alternative implementation).

Instantiating large nested object graphs can be tedious in any language Clojure included:


(def nested-object 
  (new Grandson 
    (new Father 
      (new Grandfather))))

All those new methods call get old pretty quickly and are not DRY, to remedy this will take advantage on a cool property of Clojure Homoiconicity.
Homoiconicity basically means that the code is represented by a basic data structure of the language itself (lists in the case of Clojure), this means that manipulating the AST is easy as pie!
It would be nice if we could write something like the following:


(def nested-object 
  (def nested-object (newify '(Grandson (Father (Grandfather)))))

The newify function takes a nested list of objects & adds new before each object, post that the function evaluates the resulting list:


(defn newify [e] (eval (newify-imp e)))
; required since used before defined 
(defn- newify-rest [e] )

(defn- newify-imp [e]
  (let [add-new (partial cons 'new) add-rest (partial cons (first e))]
    (if (not (empty? e))
      (-> (newify-rest e) add-rest add-new) e)))

(defn- newify-rest [e]
  (map #(if (list? %) (newify-impl %) %) (rest e)))

The newify-imp & newify-rest functions are mutually recursive, newify-imp adds the new symbol & the first list element to the result of the newify-rest function result, the newify-rest maps each list in the rest of the list to its newified value.

This implementation could be transformed into a recursive macro that will spare us from the list escaping:


  (def nested-object (newify '(Grandson (Father (Grandfather))))) 
  ; no escaping here
  (def nested-object (newify (Grandson (Father (Grandfather)))))

Ill have to dig that option later on.

NILFS on Jaunty

2009-04-30T15:56:00.000-07:00

The latest release of Ubuntu includes the long awaited Ext4 FS (works flawlessly on my system).
Ext4 is faster & more secure but still lacks the ability to manage FS snapshots (ZFS excels in that, but runs only in FUSE on linux).
An interesting alternative is NILFS:

NILFS is a log-structured file system supporting versioning of the entire file system and continuous snapshotting which allows users to even restore files mistakenly overwritten or destroyed just a few seconds ago.

NILFS maintains a repo for Hardy, the Jaunty repos contain only the user land tools which won't do us much good since we need the kernel module as well, this leaves us only with the option of installing it from source (still quite easy).


# a perquisite
$ sudo aptitude install uuid-dev  
# installing kernel module, result module resides in /lib/modules/2.6.28-11-generic/kernel/fs/nilfs2/nilfs2.ko
$ wget http://www.nilfs.org/download/nilfs-2.0.12.tar.bz2
$ tar jxf nilfs-2.0.12.tar.bz2
$ cd nilfs-2.0.12
$ make
$ sudo make install
# installing user land tools
$ wget http://www.nilfs.org/download/nilfs-utils-2.0.11.tar.bz2
$ tar jxf nilfs-utils-2.0.11.tar.bz2
$ cd nilfs-utils-2.0.11
$ ./configure
$ make 
$ sudo make install

Creating a file system on a file (ideal for playing around):


$ dd if=/dev/zero of=mynilfs bs=512M count=1
$ mkfs.nilfs2 mynilfs

The FS is only a mount away:


# mounting the file as a loop device
$ sudo losetup /dev/loop0 mynilfs
$ sudo mkdir /media/nilfs
$ sudo mount -t nilfs2 /dev/loop0 /media/nilfs/

Now lets create a couple of files:


$ cd /media/nilfs
$ touch 1 2 3 
# listing all checkpoints & snapshots, on your system list should vary 
$ lscp
                  CNO        DATE     TIME  MODE  FLG   NBLKINC       ICNT
                   7  2009-05-01 01:08:09   ss    -         12          6
                  13  2009-05-01 19:05:34   cp    i          8          3
                  14  2009-05-01 19:05:59   cp    i          8          3
                  15  2009-05-01 19:07:09   cp    -         12          6
# creating a snapshot
$ sudo mkcp -s
# 15 is the new snapshot (mode is ss)
$ lscp 
                 CNO        DATE     TIME  MODE  FLG   NBLKINC       ICNT
                   7  2009-05-01 01:08:09   ss    -         12          6
                  13  2009-05-01 19:05:34   cp    i          8          3
                  14  2009-05-01 19:05:59   cp    i          8          3
                  15  2009-05-01 19:07:09   ss    -         12          6
                  16  2009-05-01 19:08:59   cp    i          8          6

# our post snapshot file
$ touch 4

Now lets go back in time into our snapshot, NILFS enables us to mount old snapshots as read only FS (while the original FS is still mounted):


$ sudo mkdir /media/nilfs-snapshot
$ sudo mount.nilfs2  -r  /dev/loop0 /media/nilfs-snapshot/ -o cp=15 # only snapshots works!
$ cd /media/nilfs-snapshot
# as we might expect
$ ls 
 1 2 3

NILFS has some interesting features, its not production ready yet however it sure worth looking after its development.

MetaClasses can bite!

2009-03-06T07:30:00.000-08:00

Groovy has MOP classes built in like the MetaClass class, this class enables (among other things) objects introspection, we could for example use its getProperties() method in order to get the list of all the meta properties of an object and copy their values into another object:


class ParentModel {
    def String parentProp

    /**
     * Copying the current object properties into the other object
     */
    def copyInto(other){
        this.metaClass.getProperties().findAll{it.getSetter()!=null}.each{metaProp->
            if(metaProp.getProperty(this)!=null){
                metaProp.setProperty(other,metaProp.getProperty(this))
            }
        }
        other
    }
}

The usage is quite simple:


 def parent = new ParentModel(parentProp:"parent")
 def copiedParent = parent.copyInto(new ParentModel())
 assert copiedParent.parentProp.equals(parent.parentProp)

While this code runs perfectly fine with object that have identical classes it has some unexpected side effects when one of the classes derives from another:


class DerivingModel extends ParentModel{
    def derivedProp
}

def parent = new ParentModel(parentProp:"parent")
def derived = new DerivingModel(derivedProp:"derived")
def copiedDerived = parent.copyInto(derived)
assert copiedDerived.parentProp.equals(parent.parentProp)
assert copiedDerived.derivedProp.equals("derived")// throws groovy.lang.MissingPropertyException:
                                                  // No such property: derived

How can this be? the DerivingModel class has the derivedProp but after the copyInto invocation its missing!
Lets see what the getProperties method actually returns:


def parent = new ParentModel(parentProp:"parent")
parent.metaClass.getProperties().each{println it.name}// prints: class, parentProp, metaClass

It seems that we don't only get the parentProp that we defined but also the metaClass and class properties, this means that in the derived case the copyInto method has set the metaClass and class values of ParentModel into the DerivedModel instance (causing it to lose access to its derivedProp).
The fix is quite simple:


class ParentModel {
    def String parentProp
    def excludes = ['metaClass']
    def copyInto(other){
        this.metaClass.getProperties().findAll{it.getSetter()!=null}.each{metaProp->
            // we must not set the metaClass of the current object into the other
            if(metaProp.getProperty(this)!=null && !excludes.contains(metaProp.name)){
                metaProp.setProperty(other,metaProp.getProperty(this))
            }
        }
        other
    }
}

There is no need to exclude the class property since it keeps the original even if set.

Clojure on youtube

2009-03-01T14:41:00.000-08:00

Iv really enjoyed watching the Intro to Clojure series:

If your interested what the fuss is about check it out!

GroovyShell bindings validation

2009-02-28T11:24:00.000-08:00

Groovy 1.6 got released not long a go with a load of new features, one of these is AST transformations which basically lets developers manipulate/access Groovy's AST before it gets loaded into the JVM.
This feature enables some really cool MOP options to mind however iv decided to try it in solving a non MOP-ish issue.

The GroovyShell is a very versatile and useful tool that enables us to evaluate any Groovy script file at runtime:


def bindings = [lastDay:2]
def script = """
   import java.util.Calendar
   Calendar cal = Calendar.instance
   cal.set(2009,Calendar.FEBRUARY,2)
   def ghday = cal.time
   cal.set(2009,Calendar.MARCH,lastDay)
   def spring = cal.time
   def days = (ghday..spring).size()
   println days
  """
def shell = new GroovyShell(new Binding(bindings))
shell.evaluate(script)

The script get its input parameters from the bindings hash, forgeting to pass an input variable (lastDay in this case) will cause a groovy.lang.MissingPropertyException to be thrown.

This is quite reasonable during development time but not in other scenarios in which the script is written in one machine & evaluated on a remote machine.
The exception gets thrown only post its evaluation which might be too late (deep in the execution flow), wouldn't it be nice if it was possible to validate this at will on the client side?

We could scan the script for suspect variables that might not have been initialised, such scanning might be possible by inspecting the script AST, looking after variables that weren't declared in the current script, Groovy code visitors to the rescue!

The following implementation matches the bill perfectly:


package com.jdftm.script.valid
import org.codehaus.groovy.ast.ClassCodeVisitorSupport
import org.codehaus.groovy.ast.expr.MethodCallExpression
import org.codehaus.groovy.control.SourceUnit
import org.codehaus.groovy.ast.expr.VariableExpression
import org.codehaus.groovy.ast.expr.DeclarationExpression

class ClassCodeVisitorSupportImp extends ClassCodeVisitorSupport {

    def declared = []

    def existsByDefault=['context','args']

    def bindings

    def notInBindings = {name -> bindings?.keySet().find{it.equals(name)} == null}

    def notDeclared = {name -> declared?.find{it.text.equals(name)} == null && !existsByDefault.contains(name)}

    def notValid = {notDeclared(it.text) && !it.hasInitialExpression() && notInBindings(it.text)}

    def suspectVariables = []

    public void visitMethodCallExpression(MethodCallExpression methodCall) {
        def variables=methodCall.arguments.expressions.findAll{(it instanceof VariableExpression)}
        suspectVariables << variables.findAll{notValid(it)}
    }
    
    public void visitDeclarationExpression(final DeclarationExpression decleration){
        declared << decleration.variableExpression
    }

    protected SourceUnit getSourceUnit() {
        return null;
    }
}

This visitor keeps a suspects list of all the variables that are either not in the declared variables or in the bindings hash.
The following class encapsulates the visitor usage:


package com.jdftm.script.valid
import org.codehaus.groovy.ast.ClassCodeVisitorSupport
import org.codehaus.groovy.ast.ModuleNode
import org.codehaus.groovy.control.SourceUnit
import org.codehaus.groovy.control.CompilationUnit
import org.codehaus.groovy.ast.ClassNode
import org.codehaus.groovy.control.Phases;

class GroovyScriptValidator {

    def validate(script,bindings){
        def ast=getAST(script)
        def impl=new ClassCodeVisitorSupportImp()
        impl.bindings=bindings
        impl.visitClass((ClassNode)ast.getClasses().get(0));
        impl.suspectVariables.flatten()
    }

    def ModuleNode getAST(String source) {
        SourceUnit unit = SourceUnit.create("Test",source);
        CompilationUnit compUnit = new CompilationUnit();
        compUnit.addSource(unit);
        compUnit.compile(Phases.SEMANTIC_ANALYSIS);
        return unit.getAST();
    }
}

Validating the script is now simple:

 
package com.jdftm.script.valid

/**
 *
 * @author ronen
 */
class InParamValidationTest {

    public static void main(String[] args) {
        def bindings = [lastDay:2]
        def script = """
           import java.util.Calendar

           Calendar cal = Calendar.instance
           cal.set(2009,Calendar.FEBRUARY,2)
           def ghday = cal.time
           cal.set(2009,Calendar.MARCH,lastDay)
           def spring = cal.time
           def days = (ghday..spring).size()
           println days
        """
        def validator = new GroovyScriptValidator()
        def suspects = validator.validate(script,bindings)
        suspects.each{println it.text}
        if(suspects.size()==0){
            def shell = new GroovyShell(new Binding(bindings))
            shell.evaluate(script)
        }
    }
}

AST introspection is one cool feature to have!

Injecting Closures with Groovy BeanBuilder

2009-01-19T14:16:00.000-08:00

Programmatic Spring configuration has always appealed to me (can't wait for Spring JavaConfig to come out), the clarity and ability to cut down repetitive configuration meta data is the way to go.

Groovy eco system has got a lot of builders to configure any thing from build to you'v guessed it right Spring beans.
The BeanBuilder is a Groovy builder (google the pattern) class that enables us to define Spring beans in pure Groovy code, for example:


class AnyPojo {
    def c
}

def builder=new BeanBuilder()
def value="yummy"
builder.anyPojo(AnyPojo){
     c=value
}
def context = builder.createApplicationContext()
assert context.getBean("anyPojo").c.equals("yummy")

Note that an external value is injected into the bean (its not a spring bean), this might useful in cases that we want to pass behavior into our Spring beans like so:


def builder=new BeanBuilder()
def value={"yummy"}// returns "yummy"
builder.anyPojo(AnyPojo){
  c=value
}
def context = builder.createApplicationContext()
assert context.getBean("anyPojo").c.call().equals("yummy")

This should work!, however upon running this code we get this exception:


.. Error creating bean with name '(inner bean)': Instantiation of bean failed; nested exception is java.lang.IllegalStateException: No bean class specified on bean definition

The builder thinks that we are trying to created a nested inner bean:


builder.anyPojo(AnyPojo){
  c={ SomePojo p->
     //..
  }
}

No matter what as soon as the builder gets a closure as value for a property it fails.
The best solution that iv found (without altering the BeanBuilder code) is to wrap the closure in a delegating class like so:


class ClosureDelegate {
 def c

    ClosureDelegate(c){
        this.c=c
    }

    def call(){
        c.call()
    }
}

def builder=new BeanBuilder()
def value=new ClosureDelegate({"yummy"})// the diff
builder.anyPojo(AnyPojo){
   c=value
}
def context = builder.createApplicationContext()
assert context.getBean("anyPojo").c.call().equals("yummy")// this passes as well

This way we avoid the call to inner bean builder method (=(Closure c)).
This solution is partial (sometimes closures are applied without a call the the call method), but than again it should do it for most cases (oh and BTW you can get BeanBuilder without Grails from spring spring jar).

Demystifying Spring wiring process

2009-01-17T09:52:00.000-08:00

Many Java applications these days make use of Spring IoC, taking the initialization management from the hand of the developer has many benefits but also has a couple of down sides like the lose of some control on the wiring process itself.

Most of the time its a none issue however there are times in which Spring fails to resolve a dependency and all that the developer is left with is a cryptic stack trace to follow.

Iv been thinking on how to make it possible to track down Spring weaving process and see at each stage what has been wired up, basically there are three approaches that iv considered:

The first is to hook into the injection process by some public API, iv decided to drop it since i didn't find any API which notifies me upon beans creation and wiring.

The second was to wire some Aspect into Spring injection process, iv started to read Spring source code and saw that pin point all the spots in code in which the wiring takes place is very tedious and error prone to start with.

The third option was to think on Spring as an isolated container that has to interact with the JVM in order to create and inject objects into each other, tracing this interaction sholud give us the log of the injection process itself!

A little more digging (see org.springframework.beans.BeanUtils) revealed that Spring uses Java reflection API (java.lang.reflect.Constructor.newInstance, java.lang.reflect.Field.set) in order to build/wire beans, armed with this knowledge we are only left to devise a method for tracing the calls to these methods.

A possible option is Btrace, Btrace is a Java agent modeled after DTrace which is capable of instrumenting running Java classes, using the following Btrace script would activate the tracing of the wiring process on all the classes under the com.jdftm package:


package jdftm;

import com.sun.btrace.annotations.*;
import com.sun.btrace.AnyType;
import static com.sun.btrace.BTraceUtils.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Field;


@BTrace public class ReflecTracer {
    @OnMethod(
        clazz="/java.lang.reflect.Constructor/",
        method="/newInstance/"
    )
    public static void anyNewInstance(Constructor con,Object[] args) {
        if(con!=null && matches("public\\scom\\.jdftm(\\.|\\w*)*\\(\\)",str(con))){
         println(strcat(strcat("Object ",str(con))," got constructed"));
        }
    }

   @OnMethod(
        clazz="/java.lang.reflect.Field/",
        method="/set/"
    )
    public static void anyFieldSet(Field field,Object obj,Object value) {
         println(strcat("Set invoked on ",str(field)));
    }
}

Using the script with Btrace involve two steps, compilation:

btracec ReflecTracer.java

Agent attaching (attach before context creation, debugging is an option):

btrace <process id, use jps> jdftm/ReflecTracer.class

The following beans wiring:


public class BeanA {
    @Autowired
    private BeanB b;
}

public class BeanB {
    @Autowired
    private BeanA a;
}

Produces the following traces:


Object public com.jdftm.spring.context.BeanA() got constructed
Object public com.jdftm.spring.context.BeanB() got constructed
Set invoked on private com.jdftm.spring.context.BeanA com.jdftm.spring.context.BeanB.a
Set invoked on private com.jdftm.spring.context.BeanB com.jdftm.spring.context.BeanA.b

An interesting idea that i had is to create a graph out of these traces and give the developer even better visualization on the process.

Learning some Haskell

2009-01-10T13:19:00.000-08:00

Well iv been studying a little Haskell lately, mainly by reading Learn You a Haskell for Great Good!, I can only recommend any one to follow this book, my next read will be Real world Haskell.
Functional programing rulz!

Pure Java entertainment

2008-12-25T14:08:00.000-08:00

Iv really enjoyed this presentation about Java puzzlers.
The main moral of this presentation in my mind is that we should relay more on static tools in order to avoid such corner cases (there is no way to remember them all).
Take a look im sure that youl enjoy it as I did.

VMware recovery methods

2008-12-18T12:46:00.000-08:00

Iv been using VMware server and player for a time now and usually the hosted OS is XP, it happens to be that iv had the "luck" to witness the crash/corruption of such images and have devised two nifty tricks/methods of data recovery that i think worth sharing.
The first is for data recovery for an unbootable image, it matches cases in which you don't seem to be able to boot XP up but the image itself is readable & loaded by VMware (you see the black screen loading), the basic idea is to change the first boot device of the image to a Linux live cd (Ubuntu works perfectly), after booting up all you need to do is to mount the NTFS folder and copy it out (by scp, thumb drive, etc..).
The second one is more complex and comes to handle a case in which the image dose not load at all (vmware complains about a corrupted vmx file), in order to recover from this state there are a couple of prequisits:

VMware server installed.

You have another working XP image with a vmx file.

The corrupted image has a snapshot of a working state

The solution in this case is to copy the working vmx file into the folder of the corrupted image, load this image in VMware server and replace all the hard drive entries with the corrupted machine images, now all that is done is to revert to the last saved snapshot and see how the system is restored!
I hope that these two little methods help you as much as they helped me.

Java statefull callbacks

2008-12-16T13:32:00.000-08:00

Any programmer comes to know callbacks at some point or another, in Java it looks something like this:


public interface Callback {
    void doCall();
}

public class CallbackCosumer {
    public void execute(final Callback callback){
          callback.doCall();
    }
}

// usage
public class Main {
  public static void main(String[] args) {
    final CallbackConsumer consumer = new CallbackConsumer();
    consumer.execute(new Callback() {
        public void doCall() {
           System.out.println("doing my callback thingy");
        }
     });
  }
}

The biggest downside is that its hard to pass calling context state into the rigid callback interface, we could try something like:


public class CustomCallback <T> implements Callback {

    private <T> state;

    public void doCall() {
        System.out.println(state);
    }

    public void setState(<T> state) {
        this.state = state;
    }
}

Note that this implementation is limiting, the doCall method has to work for any type T, custom behavior will require sub classing (not reasonable expectation from the callback provider).
A somewhat better (the most elegant that iv found to date) solution is to take advantage of another interface:


public interface StatefullCallback<T> extends Callback{
       void addState(T state);
}

// Now we have a custom state object
public static class CustomState {
     // fields .. 
}

// And usage with a type matching logic
public static void main(String[] args) {
   final CallbackConsumer consumer = new CallbackConsumer();
   final StatefullCallback<CustomState> callback=new StatefullCallback<CustomState>() {
       private CustomState state;

       public void addState(final CustomState state) {
             this.state = state;
       }

       public void doCall() {
         // some custom logic that uses the custom state object
       }
   };
   callback.addState(new CustomState());     
   consumer.execute(callback);
}

Its quite easy to see how its possible to pass multiple types of state objects into the callback execution context and do it with relative ease, closure-blessed languages require no such hacking.

Keeping your Zen with Linux

2008-11-21T13:39:00.000-08:00

Creative mp3 players seemed to be a reasonable choice in the early IPod mania days, the single main problem that iv had for years with my trusty Nomad Zen Xtra is the fact that there was no Linux interoperability what so ever, the only (somewhat shaky) solution was to wait for Gnomad to mature.
Things has changed and the Zen access has worked with Gnomad, but two major issues remained:

No automation possible (like latest podcast copying with a matching playlist generated).

Ugly and limiting UI to deal with.

After a bit digging iv found mtpfs which is a FUSE file system that can mount MTP devices, installation and usage are simple as:


$ sudo aptitude install mtpfs
$ sudo mkdir /media/zen
$ sudo mtpfs -o allow_other /media/zen/ # allowing other enables non root access to zen folders
$ ls /media/zen
  Music  My Playlists  Playlists  WMPInfo.xml

The Music folder holds all the mp3 files in a flat structure and the Playlists folder hold m3u files in the following format (the player root is /):


/Music/Outlaws64.mp3
/Music/uupc_s01e18_high.mp3
/Music/JavaPosse217.mp3
/Music/seradio-episode117-branSelicOnUML.mp3
/Music/CyberSpeak_98_Nov_16_2008.mp3

Its quite easy to see how to automate the podcast download and copying combined with podget utility, my Zen has been restored :)

Objectifying conditionals

2008-11-13T11:02:00.000-08:00

Im sure that any programmer has come across a code snippet which included a long list of nested conditionals, like follows:


public class NaiveImpl {
 public void process(final String option) {// mapping a type code to behaviour
        if (option.equals("first")) {
            // first option .. 
        } else if (option.equals("second")) {
            // second option code ..
        }//.. a ton load of other conditionals
    }
}

Basically conditionals map between state (option) and behavior (a legacy which is carried from the procedural programming days), multiple conditionals are problematic:

They include multiple navigation paths in single condensed code sections.

They have a large number of inter dependencies between them (makes changes hard).

They are not objects (statements in Java, we cant access them in runtime, they are not "first class citizens").

One of my favorite ways of handling type code to behavior mapping without the resort to conditionals is binding Enum values to behavior:


   public class CleanImpl {

    private interface Handler {
        void handle();
    }
    private static Handler firstOptionHandler = new Handler() {
        public void handle() {
            // first option code
        }
    };
    private static Handler secondOptionHandler = new Handler() {
        public void handle() {
            // first option code
        }
    };

    private enum Option {

        First("first", firstOptionHandler),
        Second("second", secondOptionHandler);// more options to come ..
        private final String name;
        private final Handler handler;

        private Option(final String name, final Handler handler) {
            this.name = name;
            this.handler = handler;
        }

        private static Option fromString(final String optionString) {
            for (Option option : values()) {
                if (option.name.equals(optionString)) {
                    return option;
                }
            }
            throw new RuntimeException("no matching option found");
        }
    }

    public void process(final String option){
        Option.fromString(option).handler.handle();
    }
}

This code seem to be more verbose at first glance but its more than reasonable to split the handler interface and implementations into separate files (all in one file enables minimal visibility of members and getter-less code), its easy to see how all the above downsides are answered:

No multiple navigation paths in single condensed code section (each handler is seperated).

No inter dependencies between different options handling.

All round objects.

Hopefully will see more usage of similar patterns and enjoy an if-less world!

The spreading Java and Ubunut love

2008-10-24T07:05:00.000-07:00

These days it seems that the Java community is more and more Ubuntu friendly, the integration of Java and Linux (Ubuntu in particular) has been steadily improving making it easy to install (with a bit tinkering) Java 6 update 10, Netbeans and other Java goodies.
The Linux and Java open spirit are starting to merge, these are good times to be a Java developer on Linux systems.

Note:
It seems as if in Ubuntu 8.10 running sudo apt-get install sun-java6-jdk installs 6 update 10 by default.

Oracle Cursor and SimpleJdbcCall

2008-10-20T06:23:00.000-07:00

The title does sound innocent enough, calling a store procedure by using Spring SimpleJdbcCall should be simple and well documented, in usual circumstances this is the case however when Oracle Cursor is involved all hell brakes loose.

An example for such a procedure:


CREATE PROCEDURE GET_COUNTRIES_BY_INDEPENDECE (cursor OUT  types.ref_cursor , date NUMBER) AS 
BEGIN     
  OPEN cursor FOR select * from COUNRTY where INDEPENDENCE >= date;
END;

-- note that the ref_cursor type has to be declared in a package

CREATE OR REPLACE PACKAGE types
AS
   TYPE ref_cursor IS REF CURSOR;
END;

The first problem starts with the fact that the Oracle driver doesn't provide the metadata that Spring requires, this means that the programmer has to define all the in and out parameters by himself and that the metadata depended functionality of Spring has to be disabled (failing to do so make Spring ignore in/out parameter decelerations, verified by Spring source code debugging).

The second problem is how to make Spring work with the result set that the procedure provides via the cursor, i didn't find any mentioning of this on the web (besides some forum entries that didn't show a clear solution path), one tutorial that did help was jdbc related.

After a couple of attempts and Spring source code reading iv managed to find a winning solution:


  ParameterizedRowMapper<Map> mapper = new ParameterizedRowMapper<Map>() {
    @Override
    public Map mapRow(ResultSet rs, int rowNum) throws SQLException {
      BasicRowProcessor processor = new BasicRowProcessor();// commons dbutils 
      return processor.toMap(rs);
    }
  };

 
 final Map in = new HashMap();
 in.put(inParam, value);
 JdbcTemplate template = new JdbcTemplate(dataSource);
 SimpleJdbcCall jdbcCall = new SimpleJdbcCall(template).withProcedureName("GET_COUNTRIES_BY_INDEPENDECE").withCatalogName("CATALOG");

 // taking care of the cursor result set with a custom mapper
 jdbcCall.returningResultSet("cursor", mapper);

 // disabling metadata so that Spring won't reject parameter declaration
 // this is due to the lacking oracle jdbc driver 
 jdbcCall.withoutProcedureColumnMetaDataAccess();

 // order matters! spring uses them according to the position in the collection  
 jdbcCall.addDeclaredParameter(new SqlOutParameter("cursor",OracleTypes.CURSOR));
 jdbcCall.addDeclaredParameter(new SqlParameter(someDateInMili,OracleTypes.NUMERIC));

 List<Map<String, Object>> result = (List<Map<String, Object>>) jdbcCall.execute(in).get("cursor");// getting back the result set that was provided by the cursor

There are a couple of weird things in this code, first we must declare not only that the call returns a result set but also an out parameter for the cursor, second the order of the deceleration matters! (which makes sense since Spring can't guess the placement of the parameter without metadata).
Thats about it, hopefully iv saved you some time ;)

Gookup 0.0.3 is out

2008-10-17T08:31:00.000-07:00

For those of you who don't know Gookup is a backup utility for three Google online main services (Gmail Blogger and Reader), the basic idea is taking back control on your data and back it up.
Its true that Google has some strong back up procedures however even they can't protect you 100%.

Iv been using it now for a while to back up all my online content on Google servers and its been quite a useful tool, taking back the control on your own data is a liberating experience.

See the release notes and download link here.

Closjure it not a spelling mistac ;)

2008-10-03T09:52:00.000-07:00

Its seems that these days any programmer has to have a triple set of languages in his tool set, the first one is the static imperative which brings on the food to table (Java or C#), the second one is the dynamic imperative one which is fun and productive to use, it saves the ceremony code (let it be Ruby Python or Groovy) and is useful in configuration code, tests and fast prototypes projects.
As for the third type the magic keyword is functional, learning such a language won't make you code faster or more productive (not from day one at least) instead it will make you smarter and could improve the way in which you solve programing problems (functions all the way baby!!).
The main question here is which one to pick from (Scala, Haskell, ML etc..), i won't go deep into which one you should choose but instead propose a surprising contender called Clojure (a lisp dialect that runs on the JVM), some of the things that appealed to me from the start about Clojure were:

Dynamic typing

Complete Immutability (has STM and persistent collections) no hidden side effects

REPL

Macros

Java interop

Iv made a bold attempt to write a small clj program which emulates svn blame functionality, the implementation is a trimmed version of an existing svnkit snippet:


import java.io.File;
import java.util.Date;
import org.tmatesoft.svn.core.SVNException;
import org.tmatesoft.svn.core.SVNURL;
import org.tmatesoft.svn.core.internal.io.dav.DAVRepositoryFactory;
import org.tmatesoft.svn.core.internal.util.SVNFormatUtil;
import org.tmatesoft.svn.core.wc.ISVNAnnotateHandler;
import org.tmatesoft.svn.core.wc.SVNClientManager;
import org.tmatesoft.svn.core.wc.SVNLogClient;
import org.tmatesoft.svn.core.wc.SVNRevision;

public class Annotations {

    public static void main(String[] args) {

        DAVRepositoryFactory.setup();

        try {
            SVNURL fileURL = SVNURL.parseURIEncoded("http://gookup.googlecode.com/svn/trunk/gookup-jruby/build/artifacts.rb");
            SVNLogClient logClient = SVNClientManager.newInstance().getLogClient();//SVNLogClient is the class with which you can perform annotations 
            boolean ignoreMimeType = false;
            boolean includeMergedRevisions = false;
            logClient.doAnnotate(fileURL, SVNRevision.UNDEFINED, SVNRevision.create(1), SVNRevision.HEAD,
                    ignoreMimeType /*not ignoring mime type*/, includeMergedRevisions /*not including merged revisions */,
                    new AnnotationHandler(), null);
        } catch (SVNException svne) {
            System.out.println(svne.getMessage());
            System.exit(1);
        }
    }

    private static class AnnotationHandler implements ISVNAnnotateHandler {

        /**
         * Deprecated.
         */
        public void handleLine(Date date, long revision, String author, String line) throws SVNException {
            handleLine(date, revision, author, line, null, -1, null, null, 0);
        }

        /**
         * Formats per line information and prints it out to the console.
         */
        public void handleLine(Date date, long revision, String author, String line, Date mergedDate,
                long mergedRevision, String mergedAuthor, String mergedPath, int lineNumber) throws SVNException {
            String revStr = revision >= 0 ? SVNFormatUtil.formatString(Long.toString(revision), 6, false) : "     -";
            String authorStr = author != null ? SVNFormatUtil.formatString(author, 10, false) : "         -";
            System.out.println(revStr + " " + authorStr + " " + line);

        }

        public boolean handleRevision(Date date, long revision, String author, File contents) throws SVNException {
            // We do not want our file to be annotated for each revision of the range, but only for the last 
            // revision of it, so we return false  
            return false;
        }

        public void handleEOF() {
        }
    }
}


The Clojure implementation:
(in-ns 'main)
(clojure/refer 'clojure)
(import '(org.tmatesoft.svn.core SVNException SVNURL)
         '(org.tmatesoft.svn.core.wc ISVNAnnotateHandler SVNClientManager SVNLogClient SVNRevision)
         '(org.tmatesoft.svn.core.internal.util SVNDate SVNFormatUtil)
         '(org.tmatesoft.svn.core.internal.io.dav DAVRepositoryFactory))

(def url "http://gookup.googlecode.com/svn/trunk/gookup-jruby/build/artifacts.rb")

(def format (fn [notEmpty spacing value] (if notEmpty (SVNFormatUtil/formatString (str value) (long spacing) false) "         -")))

(def handler (proxy [ISVNAnnotateHandler] []
  (handleLine [date revision author line] ())
  (handleLine [date revision author line mergedDate mergedRevision mergedAuthor mergedPath lineNumber] 
      (println (format (>= revision 0) 6 revision)(format (not (nil? author)) 10 author) line))
  (handleRevision [date revision author contents] false)
  (handleEOF [] ())))

(defn main [args]
  (DAVRepositoryFactory/setup)
  (let [fileURL (. SVNURL parseURIEncoded url)  
        logClient (.. SVNClientManager (newInstance) (getLogClient))
        revision (SVNRevision/create (long 1))]
    (. logClient doAnnotate fileURL SVNRevision/UNDEFINED revision SVNRevision/HEAD false false handler nil))
)

The Clojure implementation is less verbose and demonstrates nicely the how well Java is integrated into the language (note the proxy method that implements the ISVNAnnotateHandler interface), the ".." macro is another nice feature that makes method calls on Java object feel more natural.
Clojure has also function objects (closures), the format closure saves yet more duplication in the handleLine method.
The ugly thing which is common to both implementation is the huge parameters list of svnkit (what were they thinking?).

Custom findbugs detectors and maven

2008-09-27T14:08:00.002-07:00

Iv been writing a custom find bugs detector during the weekend, the bug that this detector has to detect is String.getBytes() usages, default system encoding is used when converting the char sequence into bytes which can make it work on one machine and fail on another (use String.getBytes(charsetName) instead).
The writing of the detector was not straight forward but im not going to focus on this issue (see this and this), instead id like to focus on how to create a findbugs plugin by using maven and running it with maven findbugs plugin.
First here is the detector code:


package com.jdftm;

import java.text.DateFormat;
import java.util.Calendar;

import org.apache.bcel.generic.ObjectType;

import edu.umd.cs.findbugs.BugInstance;
import edu.umd.cs.findbugs.BugReporter;
import edu.umd.cs.findbugs.ba.*;
import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;

public class StringGetBytesDetector extends OpcodeStackDetector {

    private BugReporter reporter;
    private final ObjectType stringType = ObjectTypeFactory.getInstance("java.lang.String");
    private final static String tBugType = "SGB_STRING_GET_BYTES";

    public StringGetBytesDetector(BugReporter aReporter) {
        reporter = aReporter;
        new String("").getBytes();
    }

    @Override
    public void sawOpcode(int seen) {
        if (seen != INVOKEVIRTUAL) {// we are only interested in method calls
            return;
        }

        try {
            ObjectType tType = ObjectTypeFactory.getInstance(getClassConstantOperand());
            if (!tType.subclassOf(stringType) || 
                !getClassConstantOperand().equals("java/lang/String") || 
                !getNameConstantOperand().equals("getBytes")) {
                return;
            }

            reporter.reportBug(new BugInstance(this,tBugType, NORMAL_PRIORITY).addClassAndMethod(this).addCalledMethod(this).addSourceLine(this));
        } catch (ClassNotFoundException e) {
            AnalysisContext.reportMissingClass(e);
        }
    }
}

This class should reside in the src/main/java path of your maven module, findbugs requires another two files to be present in the plugin jar, findbugs.xml (contains bugs and detectors meta data):


<FindbugsPlugin>
<Detector class="com.jdftm.StringGetBytesDetector" speed="fast"/>
<BugPattern abbrev="SGB" type="SGB_STRING_GET_BYTES" category="CORRECTNESS"/>
</FindbugsPlugin>

And messages.xml (contains bug messages and detector description):


<MessageCollection>
 <Detector class="com.jdftm.StringGetBytesDetector">
  <Details>
    <p>This detector warns about String.getBytes uages.</p>
  </Details>
 </Detector>
 <BugPattern type="SGB_STRING_GET_BYTES">
   <ShortDescription>Call getBytes on String instance</ShortDescription>
   <LongDescription>Call getBytes on String instance</LongDescription>
   <Details>Using String.getBytes is bad!</Details>
 </BugPattern>
</MessageCollection>

Both files should reside in the src/main/resources path, the plugin also has the following dependencies:


<dependency>
 <groupId>findbugs</groupId>
 <artifactId>findbugs</artifactId>
 <version>1.3.5</version>
</dependency>
<dependency>
 <groupId>org.apache</groupId>
 <artifactId>bcel</artifactId>
 <version>5.2</version>
</dependency>
<dependency>
 <groupId>asm</groupId>
 <artifactId>asm</artifactId>
 <version>3.1>/version>
</dependency>
<dependency>
 <groupId>asm</groupId>
 <artifactId>asm-tree</artifactId>
 <version>3.</version>
</dependency>

The easiest way of getting them is by downloading findbugs distribution and deploying them from the lib folder into your favorite maven proxy (artifactory in my case).
All that is left is to deploy the plugin and to add it to your maven findbugs plugin configuration:


<reporting>
 <plugins>
  <plugin>
   <groupId>org.codehaus.mojo</groupId>
   <artifactId>findbugs-maven-plugin</artifactId>
   <version>2.0</version>
   <configuration>
      <effort>Max</effort>
      <threshold>Low</threshold>
      <xmlOutput>true</xmlOutput>
      <debug>true</debug>
      <pluginList>{artifact_path}/findstringtobyte-1.0.jar</pluginList>
   </configuration>
  </plugin>
 </plugins>
</reporting>

Thats about all :)

* A small note:
The findbugs maven plugin has a bug in the 1.2.0 release that was fixed for the 1.2.1 & 2.0 snapshot versions, it prevent the use of custom detector which means that youll need to use one of the snapshots versions.

AMF serialization from Java to Flex and back

2008-08-30T08:11:00.000-07:00

There are some scenarios in which you want to pass objects to and from a Flex application to a Java back end, if your using an Adobe framework (LCDS or BlazeDS) than you get this functionality out of the box however there are some cases that you wish to escape Adobe's grip and uses some third party technology.
Some solutions that may come to mind are JSon or XML, the problem with these solutions is that they may require a lot of bandwidth and even lots of computing power for complex objects graphs, AMF to the rescue.
AMF is a binary protocol which is used natively by the flash player, with the release of BlazeDS it was made accessible to any Java client that wishes to use it, in order to use AMF we need to serialize an object into bytes and pass it as the payload of any protocol that we choose, the easiest way to do so is to encode the resulting AMF bytes into BASE64 encoding (a format that transforms byte arrays into a readable string form) and append it to the existing payload.
Ill start with the Java side first:


import com.google.inject.Inject;
import flex.messaging.endpoints.BaseHTTPEndpoint;
import flex.messaging.io.SerializationContext;
import flex.messaging.io.amf.Amf3Input;
import flex.messaging.io.amf.Amf3Output;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 *
 * @author ronen
 */
public class AmfSerializer {

    @Inject
    private SerializationContext context;

    public <T> String toAmf(final T source) throws IOException {
        final StringBuffer buffer = new StringBuffer();
        final ByteArrayOutputStream bout = new ByteArrayOutputStream();
        final Amf3Output amf3Output = new Amf3Output(context);
        amf3Output.setOutputStream(bout);
        amf3Output.writeObject(source);
        amf3Output.flush();
        amf3Output.close();
        final BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(bout.toByteArray());
    }

    public <T> T fromAmf(final String amf) throws ClassNotFoundException, IOException {
        final BASE64Decoder decoder = new BASE64Decoder();
        byte[] input = decoder.decodeBuffer(amf);
        InputStream bIn = new ByteArrayInputStream(input);
        Amf3Input amf3Input = new Amf3Input(context);
        amf3Input.setInputStream(bIn);
        return (T) amf3Input.readObject();
    }
}

This code uses BlazeDS API (the messaging-core, messaging-common and messaging-remoting jars) in order to serialize an object of type T into AMF byte array the bytes are encoded to a Base64 string, encoding result of an instance of the following VO:


package com.jdftm.vo;

import java.util.Date;

public class CurrentDayVO {

    private Date now;

    public CurrentDayVO() {
    }

    public void setNow(Date now) {
        this.now = now;
    }

    public Date getNow() {
        return now;
    }
}

might look something like ChMzY29tLmpkZnRtLnZvLkN1cnJlbnREYXlWTwdub3cIAUJrjUw54AAA.

Now lets turn to the Flex side:


package com.jdftm.stomp.interop {
  import flash.utils.ByteArray;
  import mx.utils.Base64Encoder;
  import mx.utils.Base64Decoder;
  
  public class AMFSerializer {
     public function serializeToString(value:Object):String{
            if(value==null){
                throw new Error("null isn't a legal serialization candidate");
            }
            var bytes:ByteArray = new ByteArray();
            bytes.writeObject(value);
            bytes.position = 0;
            var be:Base64Encoder = new Base64Encoder();
            be.encodeBytes(bytes);
            var res:String = be.toString();
            be.reset();
            return res;
        }
       
        public function readObjectFromStringBytes(value:String):Object{
            var dec:Base64Decoder=new Base64Decoder();
            dec.decode(value);
            var result:ByteArray=dec.drain();
            result.position=0;
            return result.readObject();
        }         
  }
}

The logic is quite similar to the Java side code however when using the AMFSerializer we must register the serialized classes prior to serializing them:


registerClassAlias("com.jdftm.vo.CurrentDayVO", CurrentDayVO);

Failing to so will cause the de-serialization process (on both sides) to fail since it uses the alias in order to create the resulting instance object, its also required that the serialized classes on both ends to be in the same package as implemented in the CurrentDayVO Flex class:


package com.jdftm.vo{
 [Bindable]
 [RemoteClass(alias="com.jdftm.vo.CurrentDayVO")]
 public class CurrentDayVO{
   private var _now:Date;
  
   public function get now():Date{
    return _now;
   } 
   
   public function set now(value:Date):void{
    _now=value;
   }
 }  
}

As youv seen AMF isn't to hard to use and may prove to be a powerful contender in the crowded integration protocols market.

Updated 2/09/08
Here is the SerializationContext implementation which is used in the Java serialization class


import com.google.inject.Provider;
import flex.messaging.io.SerializationContext;

public class SerializationContextProvider implements Provider<SerializationContext> {

    @Override
    public SerializationContext get() {
        SerializationContext serializationContext = SerializationContext.getSerializationContext();// Threadlocal SerializationContent
        serializationContext.enableSmallMessages = true;
        serializationContext.instantiateTypes = true;
        serializationContext.supportRemoteClass = true;// use _remoteClass field
        serializationContext.legacyCollection = false;// false  Legacy Flex 1.5 behavior was to return a java.util.Collection for Array, New Flex 2+ behavior is to return Object[] for AS3 Array
        serializationContext.legacyMap = false;// false Legacy flash.xml.XMLDocument Type
        serializationContext.legacyXMLDocument = false;// true New E4X XML Type
        serializationContext.legacyXMLNamespaces = false;// determines whether the constructed Document is name-space aware
        serializationContext.legacyThrowable = false;
        serializationContext.legacyBigNumbers = false;
        serializationContext.restoreReferences = false;
        serializationContext.logPropertyErrors = false;
        serializationContext.ignorePropertyErrors = true;
        return serializationContext;

    /*
    serializationContext.enableSmallMessages = serialization.getPropertyAsBoolean(ENABLE_SMALL_MESSAGES, true);
    serializationContext.instantiateTypes = serialization.getPropertyAsBoolean(INSTANTIATE_TYPES, true);
    serializationContext.supportRemoteClass = serialization.getPropertyAsBoolean(SUPPORT_REMOTE_CLASS, false);
    serializationContext.legacyCollection = serialization.getPropertyAsBoolean(LEGACY_COLLECTION, false);
    serializationContext.legacyMap = serialization.getPropertyAsBoolean(LEGACY_MAP, false);
    serializationContext.legacyXMLDocument = serialization.getPropertyAsBoolean(LEGACY_XML, false);
    serializationContext.legacyXMLNamespaces = serialization.getPropertyAsBoolean(LEGACY_XML_NAMESPACES, false);
    serializationContext.legacyThrowable = serialization.getPropertyAsBoolean(LEGACY_THROWABLE, false);
    serializationContext.legacyBigNumbers = serialization.getPropertyAsBoolean(LEGACY_BIG_NUMBERS, false);
    boolean showStacktraces = serialization.getPropertyAsBoolean(SHOW_STACKTRACES, false);
    if (showStacktraces && Log.isWarn())
    log.warn("The " + SHOW_STACKTRACES + " configuration option is deprecated and non-functional. Please remove this from your configuration file.");
    serializationContext.restoreReferences = serialization.getPropertyAsBoolean(RESTORE_REFERENCES, false);
    serializationContext.logPropertyErrors = serialization.getPropertyAsBoolean(LOG_PROPERTY_ERRORS, false);
    serializationContext.ignorePropertyErrors = serialization.getPropertyAsBoolean(IGNORE_PROPERTY_ERRORS, true);
     */
    }
}

This is the guice provider which is used when creating such contexts.

Google collection API

2008-08-22T04:36:00.000-07:00

If your using Java collection API you should really see the following presentation about Google collection API, this is truly a gem for any Java programmer:

The first part

The second part:

Code is data or so they say..

2008-08-21T13:52:00.000-07:00

Iv been writing some custom checkstyle checks, the process of doing so is laborious and annoying, checkstyle uses an ANTLR visitor to allow the programmer to validate the tokens he wishes, this approach doesn't scale too well since it makes the programmer think of the "how" and not on "what", by that i mean that instead of being declarative its imperative.
After writing a couple of those it made me realize that there must be a better tool in which i could query the code instead of running along side the it, as a matter of a fact we are using such a tool every day, the IDE.
In the IDE we search for types, usages and other rather limited queries, we overcome these limitations by traversing the code wisely however there are still much more left be desired, for example the following query:


select field from classes where class.package=com.jdftm.* and field.visibilty=protected

which finds all the protected fields within the com.jdftm package, this kind of queries can be usefully not only on build time but also on development and runtime!

The runtime usage might sound a bit awkward but it might prove to be very powerful, imagine that we wish to write a test which validates that all the classes in com.jdftm package will not accept null parameters in any of their public methods, its possible to do so with some laborious reflection code but doing with a query tool would be much cleaner and easier to follow.

It seems that im not the first one to think in this direction still i would like to find some library that can run in pure Java code (no IDE dependency).

Update:
After yet some more googeling iv found yet two more interesting tools javaML and bbq

snipplr CLI gem

2008-07-15T14:31:00.000-07:00

Well being a CLI (Bash) kind of guy i really like to master my entire computer experience from within its black and white glory, one of the most frequent usages of CLI in my case is code manipulation.
Its only natural for me that ill be able to access my Snipplr stored snippets straight from the CLI and pipe them along, im not aware for such an existing tool therefor iv decided to create one by myself.
The utility is packaged as a gem (surprisingly named snipplr-rubygem) and should run smoothly on any platform which supports Ruby, find out more here.

Mocking & Spring tests

2008-07-04T15:51:00.000-07:00

Spring supports unit testing quite well, still it seems that its a bit tricky to inject mocks during tests, the documentation does states that using IOC framework can make it easier to do so but doesn't show you how.
Lets take for example the following common scenario, we've got a service that we wish to test which requires a DAO as a part of it functionality:


public interface ListingService {

    Person getPerson(String id);

}
public class ListingServiceImpl implements ListingService{

    @Autowired
    private PersonDAO personDAO;

    @Transactional
    @Override
    public Person getPerson(final String id) {
      return  personDAO.getPersonById(id);
    }

}

Now since we don't want to test the DAO (not integration testing) we are going to need to mock it (EasyMock), not only that but we rather use Spring testing framework that can save us a lot of hard wiring since we are already using auto-wiring in our code.
Usually mocking frameworks provides us with a static factory method that takes an interface and returns a proxy object (on which we may define behavior), this conflicts with the auto-wiring functionality since that wiring is performed according to return type of the factory method (Object) and not according to returned object itself (Spring will fail to inject the mocked DAO proxy into the service as discussed here).
This issue can be resolved by using Spring FactoryBean, this interface includes the getObjectType method that is used by Spring as the return type of this factory (exactly what we need!), all that we need to do is to implement this interface and to delegate the object creation to EasyMock like follows:


public class MocksFactory implements FactoryBean {

    private Class type;// the created object type

    public void setType(final Class type) {
        this.type = type;
    }

    @Override
    public Object getObject() throws Exception {
        return EasyMock.createMock(type);
    }

    @Override
    public Class getObjectType() {
        return type;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

Now our testing context looks like:


<beans name spaces...>
<!-- Mocks -->
    <bean id="factory"  class="com.jdftm.springmocks.services.mocks.MocksFactory"  name="PersonDAO">
        <property name="type" value="com.jdftm.springmocks.dao.PersonDAO"/>
    </bean>
<!-- The actual service-->
    <bean id="listingService" class="com.jdftm.springmocks.services.ListingServiceImpl" autowire="autodetect"/>
</beans>

And our test:


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:spring/mocksContext.xml"})
public class ListingServicesTest {

    @Autowired
    private ListingService service;
    @Autowired
    private PersonDAO personDAO;

    @Before
    public void setup() {
        expect(personDAO.getPersonById("123")).andReturn(new Person("joe", "123"));
        replay(personDAO);
    }

    @Test
    public void simplestTest() {
        Person person = service.getPerson("123");
        assertEquals(person.getId(), "123");
    }
}

This approach is useful but not very maintainable since we need to specify all the auto-wired properties (mostly mocks) of each service that we wish to test, it would be much nicer if all the properties are automatically injected for us, this may be achieved by resorting to programmatic bean definition:


public class AutoBeanDeclarer implements BeanFactoryPostProcessor {

    private Class mocksHolder;

    public void setMocksHolder(final Class mocksHolder) {
        this.mocksHolder = mocksHolder;
    }

    @Override
    public void postProcessBeanFactory(final ConfigurableListableBeanFactory context) throws BeansException {
        BeanDefinitionRegistry registry = ((BeanDefinitionRegistry) context);
        for (final Field field : findAllAutoWired()) {
            registerOn(registry, field.getType());
        }
    }

    private List<Field> findAllAutoWired() {
        return (List<Field>) CollectionUtils.select(Arrays.asList(mocksHolder.getDeclaredFields()), new Predicate() {
            @Override
            public boolean evaluate(Object field) {
                return ((Field) field).isAnnotationPresent(Autowired.class);
            }
        });
    }
    
    private void registerOn(final BeanDefinitionRegistry registry,final Class type){
        MutablePropertyValues values = new MutablePropertyValues();
        values.addPropertyValue(new PropertyValue("type", type));
        RootBeanDefinition definition = new RootBeanDefinition(MocksFactory.class, values);
        registry.registerBeanDefinition("factory"+type.getSimpleName(), definition);
    }
}

This class implements the BeanFactoryPostProcessor interface which enables the registration of beans as Spring loads up a context, the code scans a provided class for fields that carry the @Autowired annotation and registers for each one a matching mock.
For any number of auto-wired fields the context will contain only a single configure line:

 <beans name spaces.../>
 <!--Programtic configuration-- >
     <bean id="autoConfigurer" class="com.jdftm.springmocks.services.mocks.AutoBeanDeclarer" p:mocksHolder="com.jdftm.springmocks.services.ListingServiceImpl"/>    
 <!-- The actual service-->
    <bean id="listingService" class="com.jdftm.springmocks.services.ListingServiceImpl" autowire="autodetect"/ >
 </beans>

Fruitful mocking to us all.

Polish your ruby gems

2008-07-02T14:31:00.000-07:00

Rubygems was just released (by just i mean a week), for those of you who are no Ruby evangelist it won't ring a bell (Ruby equivalent of maven) for those who do its highly recommended to update.
On my system (Ubuntu with rubygems 1.1) the gem update --system approach didn't work so iv taken the second path and ran gem install rubygems-update followed by update_rubygems.
Now running gem --version yield the desired result (1.2).

Testing those black sheep

2008-06-23T12:36:00.000-07:00

One of the common reasonings for not writing tests is that writing tests for some code types isn't always possible nor cost effective, iv nicked them as the BDD black sheep, lets take for example command line API's, such API's are rarely tested & for some good(?) reasons like:

Its so simple, why do we need to test it?

Its hard to access, how can we assert anything in such an environment?

I hate it! let me get over this and get back to the safety zone of my UI!

While these are all compelling (>.<) reasons they are only plain excuses, writing command line API's is very tricky, it requires many validations and care in order to function properly, as for the hating part id replace it with deep lovin the sooner the better, command line is the most efficient user API and is here to stay (like it or not).
There are some technical challenges when performing assertions and mimicking user input however they can be easily overcome with two techniques, the first is mocking and its great for mimicking user input, now i know what your thinking, is he bulshitting me or what? how can a simple mock type the damn keyboard!?
Well the simple answer is that it don't have to, lets think for a minute what do we actually need to test (its not stdin!), we don't need to test that the keyboard works and that the typed data was placed correctly into ARGV, we need test how this data is handled, which means that a mocked data structure has to be created when writing tests, the reason that im using a mock (and not a fixture) is that im assuming that your using some sort of an input parsing framework (your not re inventing the wheel are you??) such as optiflag (Ruby) or JOpt (Java) and that this parser has to be mocked in order to provide some nice input into our program entry point.
The second technique is stream redirecting (who?), well its not that complicated lets recap for a minute, the user types in data and gets feedback in the form of text which is spat onto the screen via (youv guessed it write) stdout, this means that in order to assert the functionality of our program all that we need to do is to assert what ever is printed out in different scenarios, this can be achieved by using stream redirection into some sort of buffer, in Ruby such an approach might look somthing like this:


def redirect
  orig_defout = $stdout
  $stdout = StringIO.new
  yield
  $stdout.string
ensure
  $stdout = orig_defout
end

Which can be used like so:


  it "should say hello if -f flag is set" do
    ARGV.flags.should_receive(:h).and_return(true)
    outputStr = redirect { @bash.process }
    outputStr.should eql('Hello!')  
end

Don't forget that if there are other wanted side effects (file changes, table updates, etc..) they should be asserted like in any other code that your testing.

Effective Java Reloaded

2008-06-14T08:57:00.000-07:00

I don't think that this book needs any introduction (Effective Java written by Josh Bloch), in this day and age in which languages go in and fade out on a daily rate, I feel that we have a still long road to go with Java (and i like it!), checkout this Effecive Java Reloaded presentation.

I looooooovve Git!

2008-06-08T07:02:00.000-07:00

After using Git for a while returning back to subversion is like a step back to stone age, im going to use it in all of my personal projects narkisr@github.
Note: An excellent git screencasts web site.

JRuby and the pittfalls of bytes

2008-06-01T14:29:00.000-07:00

JRuby is an amazing environment to code in, you can get clean concise and elegant Java based code by using Ruby powerful constructs, like for example:


 JBIStream=java.io.BufferedInputStream

 def read_body_as_stream(method)
    bis = JBIStream.new( method.responseBodyAsStream())
    res = ''
    bytes=Java::byte[8192].new # creating new Java byte primitive array
    count = bis.read( bytes )
    while( count != -1)
      res << String.from_java_bytes(bytes)
      count = bis.read(bytes);
    end
    bis.close()
    res
  end

This code basically takes in an Apache commons http method and extracts its body by using its input stream, well almost!
This code contains a nasty and confusing bug, the String.from_java_bytes(bytes) chews up dirty bits on each iteration from its previous one, the soultion:


      res << String.from_java_bytes(bytes)[0,count]

The joy of bytes!!! :)

Gookup second alpha is out!

2008-05-27T14:02:00.000-07:00

In this version iv improved the Gmail backup process, its now fully resumable (download those Gig's of stored data in one shoot isn't always reasonable), faster and less resource hungry, progress info display.
On the duller side of things iv added a couple of specs and ironed out all sorts of bugs and errors.
Go check it out!

From ugly to usefull

2008-05-20T15:18:00.000-07:00

Iv encountered a troubling error in Flex remote services, those of you who are familiar with Flex remote Java services know that results of remote services are serialized into Action script objects by the Flex framework so that the RIA client may consume them.
The problem is that due to some weird reason Java Float values are not converted properly into Numeric objects, for example a float value of 1.51 on the server side will be converted into 1.5099999904632568 Numeric value on the client side.
This is actually the same value of new Float(1.51).doubleValue() in Java which leads me to believe that Flex takes float values and converts them into double values (a stupid floating point error).
The only solution that iv found is to return only double values from the server.

On a different note iv stumbled on this nifty called terminator, this tool enables the division of a single bash window into multiple ones (very useful for those multiple ssh sessions) it made me think where else such an approach could work nicely (Firefox?), anyway check it out!

Quick and dirty code search

2008-04-28T08:02:00.000-07:00

There are some situations in which i need to query some code folder quick and dirty on my hard drive.
There are existing tools like desktop search applications (such as Google desktop) but it usually takes some time for them to index new folders and they are also quite resources hungry.
Bash find utility is also an alternative how ever this tool works best only on Unix machines (NTFS & cygwin's find aren't the best pair for such a use case).

A nice quick and dirty solution it to use Ferret which is a Ruby text indexing framework inspired by Apache Lucence to quickly index the code & search it up, all by using two small snippets of Ruby code!
The code following code is based on this entry which in turn is based on this one, first is the indexing code (index.rb):

require 'rubygems'
require 'ferret'
require 'find'
include Ferret

index = Index::Index.new(:default_field => 'content', :path => '/tmp/index_folder')# creating the index
ini = Time.now
numFiles=0
IndexedExts=['.java','.properties']# the list of file extensions that we wish to index
Find.find('/code/to/index') do |path|

 if(IndexedExts.find {|ext| path.include?(ext)}==nil)
   next # this file is ignored
 end 
 puts "Indexing: #{path}"
 numFiles=numFiles+1

 if FileTest.file? path
  File.open(path) do |file|
   index.add_document(:file => path, :content => file.readlines)
  end
 end
end

elapsed = Time.now - ini
puts "Files: #{numFiles}"
puts "Elapsed time: #{elapsed} secs\n"

This code is quite simple, first we are creating an index folder then we use the Find module and iterate all the files which are contained within the 'code/to/search' folder, the files which don't have a matching extension are rejected the rest have their content added to the index, next is the query code (search.rb):

require 'rubygems'
require 'ferret'
require 'find'

wot = ARGV[0]
if wot.nil?
 puts "use: search.rb "
 exit
end

index = Ferret::Index::Index.new(:default_field => 'content', :path => '/tmp/index_folder')
ini = Time.now
puts "Searching.."
docs=0

index.search_each(wot, options={:limit=>:all}) do |doc, score|
 
 res= < -------------------------------------------------------
 #{File.basename(index[doc]['file'])} :
 #{index.highlight(wot, doc,:field => :content,:pre_tag => "->>",:post_tag => "<<-")}
STRING_END
 puts res              
 docs+=1
end

elapsed = Time.now - ini
puts "Elapsed time: #{elapsed} secs\n"
puts "Documents found: #{docs}"

In this code we first load up the index with the default query field content, the query itself takes its value from the wot parameter, after the query execution the code block prints out the matching highlighting of the found match in the file.
That all about there is to it, see ya.

Ububtu 8.04 is out!

2008-04-24T07:00:00.000-07:00

I'm downloading it at the moment, I'm pretty excited over this (more than i was when Leopold came out) & can't wait to get my hands on some of the new features, with its simplicity elegance & power Ubuntu is in my humble opinion one of the best Os's out there, go ahead and give a go!

Making FunFx Flex 2 compatible

2008-04-21T15:02:00.000-07:00

Moving to the latest and greatest software version in the enterprise takes time, Flex 3 came out not long ago and so did FunFx which a really cool tool for Flex integration testing.
FunFx got compiled with Flex 3 SDK which means that it won't run with Flex 2 projects out of the box, the developer does states that its possible to compile it from source with Flex 2 SDK however the procedure isn't trivial and took me some trial and error that i hope to save for the rest of you out there.
In order to get a Flex 2 compatible FunFx will need to compile the FunFxAdapter which is a swc library that any testable RIA has to depended upon, go ahead and grab its source from here, create a swc project within Flex builder called FunFxAdapter and add the source.
Now open the project properties and add in the following dependencies to the compiler options (your paths may vary):

 
-include-libraries "/Applications/eclipse 3.2.2/Adobe Flex Builder 3 Plug-in/sdks/2.0.1/frameworks/libs/automation.swc" "/Applications/eclipse 3.2.2/Adobe Flex Builder 3 Plug-in/sdks/2.0.1/frameworks/libs/automation_agent.swc"

The compiler options should look like:

Unfortunately the FunFxAdapter project depends upon the automation.swc library which was not a part of the Flex 2 SDK (it was introduced in Flex 3 SDK but this version isn't binary compilable with Flex 2 SDK), if your project is a legacy Flex 2 project than its most likely that you have access to this swc.
Compile the project and grab the compiled swc from the bin folder of the project, when adding it to the test target application you'll need to add some more dependencies in order to make it work with the compiled FunFxAdapter swc:

 
-include-libraries "/Users/ronen/Documents/workspace/FunFXAdapter/bin/FunFXAdapter.swc" "/Applications/eclipse 3.2.2/Adobe Flex Builder 3 Plug-in/sdks/2.0.1/frameworks/libs/automation.swc" "/Applications/eclipse 3.2.2/Adobe Flex Builder 3 Plug-in/sdks/2.0.1/frameworks/libs/automation_agent.swc" "/Applications/eclipse 3.2.2/Adobe Flex Builder 3 Plug-in/sdks/2.0.1/frameworks/locale/ja_JP/automation_agent_rb.swc"

hopefully iv saved your valuable time.
After publish comment:
Iv forgot to mention that you should add the AutomationGenericEnv.xml file to the src directory of the main project module and to the application folder under tomcat (a standard FunFx requirements also in the Flex 3 version).

The stuff that kept me busy latly

2008-04-04T16:31:00.000-07:00

Well this post will serve as a brief summary of some interesting things that i had the chance to mess with lately.
First but not least is Flex and actionscript, iv been pondering with the issue of testing Flex application, yeah sure there is FlexUnit still i wanted something slicker & less buggy to work with.
Iv stumbled upon FunFx which seems to answer my quest, getting it to work with Flex 2 wasn't easy (its compiled with Flex 3 sdk which isn't compatible, the documentation on the matter is lacking), it seems to be quite capable tool which leverages rspec framework and other Ruby goodies.
Another aspect which started to get my attention lately is functional programing (can you here the buzz?), iv studied Prolog during college but took the imperative way of doing things since than, i guess that my appeal to the subject right now comes from the need to find cool programing paradigms that can take advantage of Function objects in actionscript (the blog sphere is humming with similar ideas), currently im following some slides that are a part of an introductory course on functional programing (Haskel as the language of choice).
Gookup work has been delayed a bit, still there has been some progress made to the alpha 2 release.
Thats wraps it for now, happy coding.

Entering the Flex realm (with Spring & Cairnagorm)

2008-03-23T12:43:00.001-07:00

In this post ill present Flex development combined with the Cairngorm micro architecture & Spring IOC, it should provide an easy stepping point to any Java developer who wishes to get acquainted with the above.
Ill follow along these action items:

Flex server side setup & Spring related configuration.
Client side setup including Caringorm, Caringen & FlexBuilder.
Simple demo application client side walk through.
Simple demo application server side walk through.

Server side setup

Flex applications may be deployed on any Java container that supports War deployment, in order to keep things simple will stick with Tomcat.
Flex enabled War contains not only the default folders and files but also Flex configuration files & Jars, an easy way of getting a working skeleton of such a War is by using the BlazeDS binary distribution (an OSS project which provides the connectivity between Java remote services and Flex RIAs).
All that we need to do is to place the packaged blazeds.war that weve just downloaded into the webapps directory and start tomcat up (bin/./catalina.sh run), tomcat will unpack the War into its exploded form which will use as our base War to work with.
Stop tomcat & take a look at the webapps/blazeds/WEB-INF directory, it contains all the usual files and folders that you might expect with the following exceptions:

The lib folder contains flex Jars.
A new flex folder was added it contains flex configuration files.
Flex servlet & session definitions were added to the web.xml file.

Delete the compressed war (we don't need it anymore), will move on to configure Spring by getting Spring Jar and placing it into the WEB-INF/lib folder & by adding the following lines to the web.xml file (these will tell tomcat to bootstrap the spring environment):

     
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
  <listener-class>
    org.springframework.web.context.ContextLoaderListener
  </listener-class>
</listener>

Create the following applicationContext.xml file under WEB-INF:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
  <!-- Add your spring beans here -->
</beans>

Now its time to integrate Spring & Flex:

Download the following zip file & copy the bin/flex folder into the WEB-INF/classes folder, this folder contains a factory class that enables Flex RIAs to access remote Spring managed beans services.
Add the following lines to flex/services-config.xml file (making Flex aware to the Spring factory):

<services-config>
    <!-- Rest unchanged -->
    <factories>
      <factory id="spring" class="flex.samples.factories.SpringFactory"/>
    </factories>
</services-config>

Client side and Development environment setup

Will use FlexBuilder eclipse plugin in order to obtain Flex SDK and IDE support (you can use it freely for 60 days), first will create a Flex project with the presented settings:

Notice that in the last screen iv imported the Cairngorm.swc which is an external library (similar to a Jar), Cairngorm provides a structured architecture to use when developing Flex applications (basically conventions that tell what should go where), one of the best introductions to Cairngorm is available on David Tucker's blog.
In order to make things less tedious will use Cairngen in order to generate the basic Cairngorm folder & files structure (ala rails), Cairngen is ant based and only requires you to change a small number of properties in the project.properties to get going, for our project will use the following ones (remember to adjust the paths):

################################# PROJECT PROPERTIES ##################################
project.name        =FlexMusicArchiver
root.dir            =/Users/ronen/Documents/workspace/FlexMusicArchiver/src
com.dir             =com
domain.dir          =ronen
project.dir         =MusicArchive
cairngorm.version   =2.2.1

################################# CREATING SEQUENCES ##################################
sequence.name       =GetAlbumList

################################### CREATING VOs ######################################
vo.name             =Album

#################### ENABLE REGISTER REMOTE CLASS META-DATA IN VO #####################
vo.remoteClass      =false

############################### READ / WRITE MANAGEMENT ###############################
overwrite.files     =false
prompt.on.delete    =true

################################## LOG MODIFICATIONS ##################################
log.output          =true

################################ PROTECTED PROPERTIES #################################
namespace           =${com.dir}.${domain.dir}.${project.dir}
project-uri         =${root.dir}/${com.dir}/${domain.dir}/${project.dir}

Simple demo application client side walk through

Fire up ant under Caringen folder, the basic project structure will get generated:

The FlexMusicArchiver.mxml file serves as the main entry point to the application, paste in the following code lines into it:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application
        xmlns:mx="http://www.adobe.com/2006/mxml"
        xmlns:control="com.ronen.MusicArchive.control.*"
        xmlns:business="com.ronen.MusicArchive.business.*"
        layout="absolute" xmlns:view="com.ronen.MusicArchive.view.*">

   <!-- The component that contains remote services declerations-->
   <business:Services/>
   <!-- The application contoler which stores events to commands mappings-->
   <control:FlexMusicArchiverController/>
   <!-- A simple view component-->
   <view:AlbumsList/>

</mx:Application>

Now create a new Flex component named AlbumsList.mxml under the view folder and add in these code lines:

<?xml version="1.0" encoding="utf-8"?>
<mx:Canvas xmlns:mx="http://www.adobe.com/2006/mxml" width="100%" height="100%" >
        <mx:Script>
                <![CDATA[
                import mx.controls.Image;
                import com.ronen.MusicArchive.vo.Album;
                import com.ronen.MusicArchive.events.AlbumsFetchEvent;
                import mx.events.ListEvent;
                import com.ronen.MusicArchive.model.ModelLocator;

                private var  model:ModelLocator=ModelLocator.getInstance();
                private var  currAlbumPath:String;


                private function fetchAlbums(e:MouseEvent){
                        var fetchEvent:AlbumsFetchEvent=new AlbumsFetchEvent();
                        fetchEvent.dispatch();
                }

                private function albumSelected(event:Event){
                        if(event.target.selectedItem!=null){
                          this.currAlbumPath=Album(event.target.selectedItem).coverPath ;
                          this.albumCover.load("http://localhost:8080/blazeds/images/"+this.currAlbumPath);
                        }
                }
                ]]>
        </mx:Script>

<mx:Panel>
 <mx:Grid width="100%" height="100%" borderStyle="solid">
  <mx:GridRow>
    <mx:GridItem>
      <mx:Text id="title" text="A list of all albums:" fontSize="12"/>
    </mx:GridItem>
  </mx:GridRow>

  <mx:GridRow>
    <mx:GridItem>
      <mx:DataGrid id="albums" dataProvider="{model.albums}" change="albumSelected(event)">
       <mx:columns>
         <mx:DataGridColumn dataField="artist" headerText="Artist"/>
         <mx:DataGridColumn dataField="title" headerText="Album title"/>
       </mx:columns>
      </mx:DataGrid>
     </mx:GridItem>
                
     <mx:GridItem>
       <mx:Image id="albumCover" width="200" height="200"/>
     </mx:GridItem>
  </mx:GridRow>
  <mx:GridRow>
     <mx:GridItem>
       <mx:Button id="fetch" label="fetch albums" click="{fetchAlbums(event)}"/>
     </mx:GridItem>
   </mx:GridRow>
  </mx:Grid>
</mx:Panel>
</mx:Canvas>

This component makes use of a Grid layout to setup its UI components which includes: a DataGrid which is binded to the model.albums list (The Carinagorm ModelLocator idiom is used in order to get a reference to this list), an Image (its source is taken from the albumCover variable) and a fetch albums button that triggers the dispatching of the fetchEvent (the dispatching of the event in the fetchAlbums method is another Cairngorm idiom).
Add in the albums ArrayCollection deceleration to the model/ModelLocator.as file:

package com.ronen.MusicArchive.model
{
 import com.adobe.cairngorm.CairngormError;
 import com.adobe.cairngorm.CairngormMessageCodes;
 import com.adobe.cairngorm.model.IModelLocator;
 import mx.collections.ArrayCollection;
    
    [Bindable]
    public final class ModelLocator implements IModelLocator{
  public var albums:ArrayCollection;
  
  /**
   * Defines the Singleton instance of the Application ModelLocator
   */
  private static var instance:ModelLocator;

         public function ModelLocator(access:Private){
    if (access == null){
            throw new CairngormError(CairngormMessageCodes.SINGLETON_EXCEPTION, "ModelLocator" );
           }
    instance = this;
  }
   
  /**
   * Returns the Singleton instance of the Application ModelLocator
   */
  public static function getInstance() : ModelLocator{
   if (instance == null){
    instance = new ModelLocator( new Private() );
   }
   return instance;
  }
 }
}
/**
 * Inner class which restricts constructor access to Private
 */
class Private {}

This class is a singleton which gives an easy access to model data as we've seen in the AlbumsView component.
Now will head on to and create the events/AlbumsFetchEvent.as class:

package com.ronen.MusicArchive.events
{
        import com.adobe.cairngorm.control.CairngormEvent;

        import flash.events.Event;

        public class AlbumsFetchEvent extends CairngormEvent
        {

                public static const FETCH_ALBUMS:String = "FetchAlbums";

                public function AlbumsFetchEvent(){
                        super(FETCH_ALBUMS);
                }

                override public function clone():Event{
                        return new AlbumsFetchEvent();
                }
        }
}

This class does nothing more than to define the event that will be fired upon the fetch button click in the view, notice that it defines a constant value that will be used in the controller to map the event to its command, lets add the mapping in the control/FlexMusicArchiverController class:

package com.ronen.MusicArchive.control
{
    import com.adobe.cairngorm.control.FrontController;
    import com.ronen.MusicArchive.commands.*;
    import com.ronen.MusicArchive.events.*;

        public final class FlexMusicArchiverController extends FrontController{
                public function FlexMusicArchiverController(){
                        this.initialize();
                }

                private function initialize() : void{
                   this.addCommand(AlbumsFetchEvent.FETCH_ALBUMS,AlbumsFetchCommand);
                }
        }
}

As you can see weve added the mappings in the initialize method to a AlbumsFetchCommand class which we need also to implement, create the following commands/AlbumsFetchCommand.as class:

package com.ronen.MusicArchive.commands
{
        import com.adobe.cairngorm.commands.ICommand;
        import com.adobe.cairngorm.control.CairngormEvent;
        import com.ronen.MusicArchive.business.AlbumsFetchDelegate;
        import com.ronen.MusicArchive.events.AlbumsFetchEvent;
        import com.ronen.MusicArchive.model.ModelLocator;

        import mx.collections.ArrayCollection;
        import mx.rpc.IResponder;

        public class AlbumsFetchCommand  implements ICommand, IResponder{
                public function AlbumsFetchCommand(){
                }

                public function execute(event:CairngormEvent):void {
                  var fetchEvent:AlbumsFetchEvent = event as AlbumsFetchEvent;
                  var delegate:AlbumsFetchDelegate = new AlbumsFetchDelegate( this );
                  delegate.fetchAlbums();
                }

                public function result( event:Object ):void {
                  ModelLocator.getInstance().albums=ArrayCollection(event.result);
                }

                public function fault( event:Object ):void {
                  trace("CONNECTION ERROR");
                }

        }
}

This class implement two Cairngorm interfaces, the first ICommand requires the implementation of the execute method which calls for the AlbumsFetchDelegate fetchAlbums method (the delegate acts as a bridge between the Flex application and the remote services calls, this makes it easy to swap different services implementations without changing command execution logic).
The second one is the IResponder which requires the implementation of the result method, this method will be called upon by the delegate after the service result has been fetched (notice that a reference to the command object is passed to the delegate constructor), now will create the business/AlbumsFetchDelegate.as class:

package com.ronen.MusicArchive.business
{
 import mx.rpc.IResponder;
 import com.adobe.cairngorm.business.ServiceLocator;
 
 public class AlbumsFetchDelegate{
     private var responder:IResponder;
        private var service:Object;
        
 public function AlbumsFetchDelegate(responder:IResponder){
   this.responder=responder;
   this.service = ServiceLocator.getInstance().getRemoteObject("fetchAlbums");
        }

        public function fetchAlbums(){
          var call:Object=this.service.fetchAlbums();
          call.addResponder(responder);
          trace('fetch called');
        }
  }
}

This class access the ServiceLocator singleton (registers remote services) in order to get a reference to the fetch albums service, add the following declaration to the business/Services.mxml file:

<?xml version="1.0" encoding="utf-8"?>
<cairngorm:ServiceLocator xmlns:mx="http://www.adobe.com/2006/mxml" 
                       xmlns:cairngorm="com.adobe.cairngorm.business.*">
                      
    <mx:RemoteObject id="fetchAlbums" destination="albumsService"/>
    
</cairngorm:ServiceLocator>

One last class before we can call it off (on the client side) is the vo/Album.as:


package com.ronen.MusicArchive.vo{
   //The com.ronen.musicarchive.AlbumVO tells Flex that Album.as maps to AlbumVO.java
   [RemoteClass(alias="com.ronen.musicarchive.AlbumVO")]
    public class Album{

    public var artist:String;

    public var title:String;

    public var coverPath:String;

    public function Album(){
   }
  }
}

This class gives us a single coherent class to work with inside the Flex view classes without depending on the format which the service returns back (the conversion takes place at the command result method).

Simple demo application server side walk through

Will need to expose & create this service at the server side, will start by adding the following to the WEB-INF/flex/remoting-config.xml file (the file which exposes services to Flex RIAs):

<?xml version="1.0" encoding="UTF-8"?>
<service id="remoting-service"
    class="flex.messaging.services.RemotingService">
    <!--rest unchanged-->
    <destination id="albumsService">
      <properties>
       <factory>spring</factory>
       <!--This is the spring bean id which is declared in the applicationContext.xml file-->
       <source>albumsDao</source>
      </properties>
    </destination>
</service>

The albumsDao is actually the Spring bean id that we are about to create:


package com.ronen.musicarchive;
import java.util.Collection;

public interface AlbumsDao {
  Collection fetchAlbums();  
}

Now the implementation:


package com.ronen.musicarchive;
import java.util.ArrayList;
import java.util.Collection;

public class HardCodedAlbumsDao implements AlbumsDao {
    public Collection fetchAlbums() {
     Collection result = new ArrayList();
     result.add(new AlbumVO("the bends", "radio head", "Radiohead.bends.albumart.jpg"));
      result.add(new AlbumVO("MGMT", "latest fav", "MGMT_oracular_spectacular.jpg"));
      return result;
    }
}

The returned VO has to be created:


package com.ronen.musicarchive;

public class AlbumVO {

 private String title;
 
 private String artist;
 
 private String coverPath;

 public AlbumVO(){
  
 }
 
 public AlbumVO(String title, String artist, String coverPath) {
  this.title = title;
  this.artist = artist;
  this.coverPath = coverPath;
 }

 public String getTitle() {
  return title;
 }

 public void setTitle(String title) {
  this.title = title;
 }

 public String getArtist() {
  return artist;
 }

 public void setArtist(String artist) {
  this.artist = artist;
 }

 public String getCoverPath() {
  return coverPath;
 }

 public void setCoverPath(String coverPath) {
  this.coverPath = coverPath;
 }
}

This simple hard coded DAO dosn't require too much elaboration, just copy the compiled interface and class into the WEB-INF/classes folder, don't forget also to declare the DAO inside the application context file:


<bean id="albumsDao" class="com.ronen.musicarchive.HardCodedAlbumsDao"/>

If you got this far, start tomcat up and launch the FlexMusicArchiver.mxml file (inside eclipse right click Run as->Flex Application), if all went well you should see the application up and running :)

Troubleshooting, make sure that:

Tomcat has loaded witout any exceptions.
The Flex SWF compiles without errors.

JRuby application packaging P-1

2008-03-17T14:08:00.000-07:00

Any Info which regards the packaging of JRuby applications is quite scarce, in Java the options are clear and for the most part there is only one option (jar as you might have guessed already), jars aren't designed to carry Ruby code within them, they don't mix with the Ruby ecosystem too well (the interpreter cant run them directly, not without some wrapping) and they force some adjustments (like a Main Java class as an entry point).
Luckily JRuby does support Ruby's packaging system (rubygems) which offers some interesting options, still there are some pitfalls and issues to solve such as:

The creation/installation/distribution of a JRuby gem.

Jars and gems mixing (what is the correct mixture?).

Automation and build integration.

In this post and the following one ill try to introduce some solutions to these issues starting with the basic gem packaging procedure.

A useful tool for dealing with gems is newgem, newgem is a command line utility which generates a skeleton of folders & files, this approach is the easiest way to get going:


 newgem dummy # our dummy project gem

the resulting dummy folder will contain:


History.txt   Rakefile lib setup.rb 
License.txt   log tasks   website
Manifest.txt  config pkg test
README.txt    doc script  tmp

The lib folder is the destination of our Ruby code, at its post creation state this folder contains an empty folder which carries the application name and a single matching ruby script:


$:.unshift File.dirname(__FILE__)

module AppName

end

This script is the gateway to your application (it includes the first lines of code that will be executed upon gem requiring), in its naked form it only adds the code under the lib/app_name path to the interpreter's load path variable (LOAD_PATH aka $: which is an array), this will enable access to the the rest of the code:


# this loads up the gem
gem 'dummy'
# this will load up lib/dummy.rb and add /lib/dummy to $:
require 'dummy'
# now we may require any other piece of code under dummy
require 'dummy/bla'

Any to be packaged file & folder should have its name appended to the Manifest.txt file.

All that is left in order to package our code into a gem is to invoke:


rake package # The resulting gem will be placed under the pkg folder.
jruby -S gem pkg/app_name_version.gem # this will install it into the JRuby environment

Another nice feature that newgem offers is the ability to create a binary command (like rake, rails) which is integrated into the Ruby environment along side the gem installation:

ruby script/generate executable dummy # run this under the generated folder path

This will generate a bin folder which contains a single file, all that is left is to append the desired functionality at the bottom of this file and add it to the Manifest.txt.

Summary:
In this post wev'e taken a look on basic gem creation, on the next one ill explain how to inject jar's into our gem and take a look on some automated newgem manipulation with buildr & rake.

First gookup version released to the wild!

2008-03-11T01:29:00.000-07:00

Iv uploaded the first version of gookup & im quite happy with it, there's still more work to be done (as always) how ever im happy to say that from inception to realization this is all mine :).

Getting ahead with the program

2008-03-05T00:56:00.000-08:00

Well it's been a week since my last post (time moves fast isn't it?) and had the need to write about some new idea's/solutions/stuff that iv found, so without further ado:

In the gookup front iv made some progress with the packging scheme of the application, the problem is that Ruby/JRuby programs need to have at least a parser installed in order to work (well almost true since for Ruby you may use somthing like RubyScript2Exe), still i don't want to make my users have to install JRuby (the only requirement that im willing to live with is the need to have a working >1.5 JRE).
After goggling quite a bit iv found two main approaches, the first is to use a main Java class as an entry point to your JRuby main code and package the whole application in a Jar, the down side with this approach is that it doesn't seem to answer how to package ruby gems that your application requires in a clean manner (a possible answer might be to use something like JRubyGems ).
The second approach is to use jruby-complete.jar and create a working JRuby environment as a part of your install process with something like this:


 java -Xmx512m -jar jruby-complete.jar --command gem install gem-name

This will create a gem library under .jruby (or any custom library with the -Djruby.home=/custom/path flag) onto required gems will be installed.
In order to run your JRuby main code all you need to do is to issue:


 java -Xmx512m -jar jruby-complete.jar --command main.rb

Iv not decided which one of them ill eventually use (if any), the nice things about these kind of projects is how they evolve and grow.

Another two related tidbits:

Since this application will be command line base iv decided to look for a Ruby library that will save me the trouble of parsing commands from the user, cmdparse seems to meet my expectations, not only does it have an nice design but also a default help and version commands by default.

Another issue which bothered me along the development process was the lack of a debugger in my IDE, im used to the Intellij debbuger but it doesn't seem to support JRuby code yet (Netbeans does), ruby-debug seems to be have ported to JRuby (haven't tested it yet) and from this screen cast it looks pretty awesome!

In the Flex front iv been taking baby steps in trying to figure out how things are related to each other, iv noticed is that Adobe has a tendency to rename things quite a lot (marketing takes it tall i guess), so that Flex Data Services is now called LiveCycle Data services, LiveCycle consists of a couple of parts of functionality out of which im only interested (at the moment) in Flex remoting services and the way that they interact with Java backends, this small fraction of functionality is distributed in a OSS distribution named BlazeDS project.
~~One frustrating thing that iv noticed is that Flex 2 compiled SWF's aren't compilable with latest BlazeDS, iv learned this the hard way following this simplistic getting started guide,~~ (My bad it seems as if i haven't passed mxmlc flags during compilation)
iv learned that Flex RIA has couple of remote call options, one of which is RPC-type services which basically enable Flex RIA's to call remote Pojo methods and cosume the return values that they produce, its also possible to call managed Spring beans methods by using a custom factory.

Im planing to develope some toy project that will incorperate Flex, Spring and Hibernate, ill share my experience here so stay tuned!

Yet another informational post (yaip)

2008-02-27T02:10:00.000-08:00

After not writing for some time in this blog iv decided that i should post more regularly and share cool ideas/technologies that i encounter on daily/weekly bases, my agenda these days revolves around some of the following:

gookup - a Google services backup utility which takes your valuable online data and stores it localy on your hard drive for safe keeping.
Iv been working on it for the past couple of months, the nice thing about it (besides its usefulness i hope) is the fact that its fully JRuby based & uses Buildr as its build tool.
This matching allows some intresting combination like 'auto' Jar requiring in our JRuby code via the usage of the artifacts that we define in our build (ill elaborate on this on some other post).

Another subject that will keep me busy in the couple of following weeks is Flex, this nifty piece of technology will be a main part of projects that ill take part in the near future.
My plan is to study the following subjects:Flex Basics, Flex & Java/Tomcat integration, Cairngorm.
So far iv taken a look on Flex Builder (current idea support should get better on 7.0.3) and some online resources such as thirty-minute Flex test drive .
Still the best way to study a new technology is by getting your hands dirty and actually building something with it (ill figure something up).

Last but not least is Adobe AIR and JavaFX, im considering using one of the two for gookup front end (AIR dosn't support linux yet), still i might just use swing and profligacy instead if the integration with JRuby will prove to be impossible.

Buildr and groovyc

2007-12-18T00:56:00.000-08:00

Buildr is a build tool that iv mentioned in previous posts, its really flexible and easy to mold custom functionality into it due to its Ruby heritage and its AntWrap utilization.
In this post im going to demonstrate how to use the groovyc ant task in order to intruduce groovy compilation into your build (which is a bit tricky).
Lets dive head first into the code:


SP=File::SEPARATOR

desc "Dummy project"
define "Dummy" do
 #..
 def
  hashToPath(hash)hash[:group].gsub('.',SP)+SP+hash[:id]+SP+hash[:version]+SP+hash[:id]+'-'+hash[:version]+'.jar'
 end 

 def reslove_artifacts_paths(array)
    array.flatten.inject([]){|result,arti|  result << repositories.local+'/'+hashToPath(artifact(arti).to_hash)}.join(File::PATH_SEPARATOR)
 end
         
 desc 'compiling'
 compile.enhance([:groovyc])# this actully replaces the standart compile with the groovyc ant task
     
 desc 'groovyc task'
 task :groovyc do
  classpath=reslove_artifacts_paths(RUNTIME)
  ant('groovy') do |ant| 
    ant.taskdef :name=>'groovyc',:classname=>'org.codehaus.groovy.ant.Groovyc',:classpath=>reslove_artifacts_paths(GROOVY)
      ant.groovyc(:srcdir=>path_to('src', 'main', 'java') , :destdir=>path_to('target','classes') , :classpath=>classpath){
        ant.javac(:source=>"1.5" ,:target=>"1.5")
      }
     end
   end
 #.. 
end

The code above (if you havent guessed it until now) is the buildfile, lets disassemble it:

The groovyc task uses AntWrap in order to define and use the groovyc ant task, notice that we are using joint compilation which in essence suppresses the default compilation (since there wont be anything left to compile when its turn arrives) and makes our life easier (no need to mess with the ordering of the compilation steps).

The reslove_artifacts_paths method does what its name suggests and is required in order to make ant happy (i haven't found a nicer way of doing this) or else it wont find the required classes.

the GROOVY constant points to the groovy-all jar the RUNTIME points to all that is needed during compilation.

That all about there is to it.

Compilled vs non compilled Groovy Spring beans

2007-12-13T03:27:00.000-08:00

Spring offers great flexibility when working with dynamic languages, it enables the wiring of Groovy beans in your application with minimal effort (see), one of the coolest things about it is that it enables also the re-deployment of Groovy code with no more then a simple file override (see).

All this is fine and dandy except that it introduces quite an overhead on Spring context startup time and runtime usage, developers that use it may get the wrong impression that Groovy is Sloowww (partly true).
The fact is (as ill demonstrate next) that Spring's magic takes its toll and that there is a simple alternative to this mechanism which is to use the compiled code and not the source code in our bean definitions.

Take for example the following configurations:


Compiled:
⟨bean id="multiThreadedConversion" class="com.conversion.MultiThreadedConversion" scope="singleton"⟩
  ⟨property name="mapper" ref="mapper"/⟩
⟨bean⟩

⟨bean id="mapper" class="com.conversion.utils.ExtensionToAppMapper" scope="singleton"/⟩

⟨bean id="scavenger" class="com.conversion.utils.ConversionDataScavenger" scope="singleton"/⟩


Not compiled:
⟨lang:groovy id="multiThreadedConversion" script-source="classpath:com/conversion/MultiThreadedConversionNotCompiled.groovy" scope="singleton"⟩
 ⟨lang:property name="mapper" ref="mapper"/⟩
⟨/lang:groovy⟩

⟨lang:groovy id="scavenger" script-source="classpath:com/conversion/utils/ConversionDataScavenger.groovy" scope="singleton"/⟩

⟨lang:groovy id="mapper" script-source="classpath:com/conversion/utils/ExtensionToAppMapper.groovy" scope="singleton"/⟩

And two simple startup time benchmarks:


 
 public void compiled() {
  Date before = new Date();
  ApplicationContext compiled = new ClassPathXmlApplicationContext("application.xml");
  System.out.println(new Date().getTime() - before.getTime());
 }

 public void notCompiled() {
  Date before = new Date();
  ApplicationContext notCompiled = new lassPathXmlApplicationContext("not_compiled_application.xml");
  System.out.println(new Date().getTime() - before.getTime());
 }

Running them both resulted with the compiled version taking 0.203s to run and the the non compiled took 1.015s which is ~five times slower!

Should we conclude that the compiled version is always preferable?
Well it depends since it has its drawbacks:

We lose the easy deployment procedure when using the byte code.

~~G/Setter must be introduced in order to aid spring in identifying properties within classes (a serious draw back since in groovy we may use only the def keyword).~~
It seems that iv got this wrong (just match the Spring id with the Groovy property name and your set).

This leads to the answer:
Use the source when easy redeployment (business logic is one good example) is required, use compiled when performance is critical.

Keep on Grooving ..

Taking back control on your tests with TestNG

2007-12-04T01:04:00.000-08:00

I'm truly a testing fanatic, in fact i think that for each component coded tests should be an integral part the process.
The thing is that as your code grows it gets harder to maintain the tests that you've written in addition JUnit adds pain to misery due to its bad design.
Its true that latest 4.* versions had fixed some really annoying practices like the naming convention of test methods and the need to extend a test base class but still it lacks in many other areas.

One of the major problems in JUnit is the fact that the main grouping point of tests is the test class itself which isn't fined grained enough, TestNG on the other hand allows to include any test method within any group no matter in which class its defined, for example:


package tests; 

public class SomeCases {

    @BeforeMethod(groups = {"restore", "authorization"})
    public void cleanup() {
        // some common cleanup code
    } 

    @Test(groups = {"restore"})
    public void getSingleModel() {
     // .. 
    }

    @Test(groups = {"restore"})
    public void getManyModels() {
     // ..   
    }

    @Test(groups = {"authorization"})
    public void authorizationService() {
     // ..   
    }
}

This class holds a bunch of test methods which are divided to two major groups restore and authorization, this fine grained division enables all sorts of new possibilities like the handling of cross cutting concerns such as the cleanup method (we could easily move it to a super class to enable it on multiple classes).

Another possibility is to mix and match test suites that include test methods scattered around many classes, for example the next test method which belongs to the restore group that we've seen above:


package tests;

public class MoreSomeCases {
    @Test(groups = {"restore"})
    public void validateModelRestore() {
     // .. 
    }
}

is made executable (with all the other restore methods) by defining the following suite (XML):


⟨suite name="BASIC_FUNCTIONALITY" verbose="1"⟩
    ⟨test name="BASIC_FUNCTIONALITY"⟩
        ⟨groups⟩
            ⟨run⟩
                ⟨include name="restore"/⟩
            ⟨/run⟩
        ⟨/groups⟩
        ⟨packages⟩
            ⟨package name="tests"/⟩
        ⟨/packages⟩
    ⟨/test⟩
⟨/suite⟩

this will enable the running of all the restore methods no matter in which class they are defined (this is an easy way to run integration tests).

TestNG has a lot more to offer (only a partial list):
- Defining input parameters of test methods and injecting them with data providers.
- Defining dependencies among tests and groups.
- Run tests in parallel.

Head on and check it out!

Intellij 7.01 on Ubuntu => Java 6 upgrade

2007-11-01T06:05:00.000-07:00

Intellij now makes use of JDK 6 which means that one should upgrade his version (using synaptic you know the drill) and set IDEA_JDK to /usr/lib/jvm/java-6-sun at the .bashrc file.

But wait! thats not all!!
The upgrade that youv just made has changed the default Java version symlink (under /usr/bin) which is used in your bash!, this means that any bash invoked application (maven, JBoss) will use the new JDK instead the older one (a big no no if your still developing in 1.5 like me).

sudo update-alternatives --config java

Another pointer that i have found to be useful is to make sure to delete the older .IntelliJIdea70 hidden folder, that in case that you have used the M2 idea version prior to the final release.

Thats all, Idea Rock on!

Catch the bug

2007-10-08T04:20:00.000-07:00

Well iv just spent an hour or so on this cute little bug and thought to challenge you readers to catch it by yourself (using any debuggers IDE's etc.. isn't allowed!)
The code is in the Groovy programming language and involves two closures as follows:


def validate(assets){
 def asset = assets.find() {a ->
  [a.floor, a.houseNr, a.street, a.zipCode].find {val -> StringUtils.isEmpty(val)} !=null 
 }
 asset == null ? 'all addresses are ok' : 'one address is partial'
}

This little method finds an asset within an asset list that has at least one empty address value (emptiness is asserted by org.apache.commons StringUtils).

The method makes use of two nested find methods (both accept two boolean closures) with this simple logic:
We are trying to find any asset (the wrapping find call) that has at least one empty address value (the inner find), simple enough right?

Well lets Write some tests:


def asset= new Asset()
asset.floor='1'
asset.houseNr='1' 
asset.street='bla'
asset.zipCode ='1234' 
assetEquals('all addresses are ok',validate([asset]))// passes
asset.floor=''
assetEquals('one address is partial',validate([asset]))// passes 
asset.floor=null
assetEquals('one address is partial',validate([asset]))// bug strikes here!

Well that one last test is weird, the first initial instinct of mine was to check that isEmpty handles null as empty (ill give you a hint, it does).
Feel free to tackle it now, its not that complicated (or is it?) the following paragraph will contain the solution so stop reading now! (thats if you don't want to cheat).

The solution:
Ok lets follow along that last test:

The validate method input includes an asset that has a nullified floor, the first find is called.

The first find calls its inner find method call.

Now here is the tricky part, the inner find manages to scan only the first array value (floor) and returns its value (which is null!), the !=null assertion returns false to its wrapping find,now since there are no more elements in the assets list the outer find returns the faulty null.

Thats it another bug squashed!

Generics shall risen again!

2007-08-20T01:47:00.000-07:00

Here is a possible solution for cases in which some libraries that you depend upon and are not under your control (Spring, Apache Commons etc..) don't use generics (usually this is due to 1.42 backward compatibility), in such cases you'd usually write lines that might resemble something like this:


JdbcTemplate jdbcTemplate=new JdbcTemplate();
List⟨String⟩ result=jdbcTemplate.queryForList(/*query*/,/*params*/);

This code will result in unchecked assignment warning during compilation however the most annoying thing about it is that the IDE will not auto complete the generics types for us(=> more typing for us!).
My solution is based upon JRetrofit a framework that enables us to add interfaces to classes during runtime, first will create an interface that should contain all the commonly used JdbcTemplate methods:


public interface JdbcDynamicWrapper {
 List queryForList(String sql,Object[] args)throws DataAccessException;
}

And a factory method that will be used to get jdbcTemplate instances:


class JdbcTemplateFactory {
 public ⟨T⟩ JdbcDynamicWrapper⟨T⟩ getTemplateWraper(Class⟨T⟩ clazz){
  JdbcTemplate jdbcTemplate = new JdbcTemplate();
  return(JdbcDynamicWrapper⟨T⟩)
   Retrofit.partial(jdbcTemplate,JdbcDynamicWrapper.class);
 }
}

All that is left is to use the factory method:


JdbcTemplateFactory jdbcTemplateFactory=new JdbcTemplateFactory();
JdbcDynamicWrapper⟨String⟩templateWraper=jdbcTemplateFactory.getTemplateWraper(String.class);
List⟩String⟨ names=templateWraper.queryForList(/*query*/,/*params*/);

Now i know that this solution has its down sides (the need to add each method to the interface is one of them), but for methods which are very commonly used i think that its worth its price, don't you?

Building made easy..

2007-08-03T11:15:00.000-07:00

Well this post is devoted to Buildr a Maven like build tool intended for Java projects which aims to make the whole building process much simpler to write and maintain.
It Actually uses similar Maven idioms & concepts like:

Usage of remote Repositories.
Artifacts.
Different Life cycle stages.

Still it differs in its infer structure which is based upon Rake instead of Ant (no more XML and thank god for that!).
One of the positive things that i feel that Ruby can bring into the Java sphere is simplicity and Buildr is no exception, its really easy to start get going in a matter of hours not days!.
With that last statement in mind iv had some troubles with the installation of Buildr under Ubuntu, which lead me to the following conclusions:

download and install gem manually (don't use synaptic).
sudo apt-get install ruby1.8-dev, build-essential.
choose ruby versions when ever gem asks you.

Now lets go ahead and create our simple build example with the following structure (looks familiar?):

We want our build to supply us with the following simple services:

Compile our project.
Create an Intellij project (with all the dependencies already defined).
Package our project into a jar.
Deploy our project into a folder ready to run.
To clean up our acts.
Run some basic tests.

Buildr requires a single file (named buildfile) to be placed at the base folder of our project, this file will contain the project's tasks.
Our first step will be to define the artifacts that we depend upon, Buildr uses Ruby data structures (arrays, structs and even hashes!) to define them.
Its up to us to if we want to place these definitions in a separate file or not (usually we do), here is our artifacts.rb file:


#group:id:type:version
DUMMY_ARTIFACTS=['commons-collections:commons-collections:jar:3.1']

Now will go ahead and define our project and its repositories:


require 'artifacts'
repositories.remote << "http://www.ibiblio.org/maven2/"
repositories.local = "home/myuser/.m2/repository/"      
desc "our dummy project" 
define "Dummy" do               
  project.version = '1.0'           
  project.group = "Dummy"            
  manifest["Main-Class"] = "main.Main"# defining the jar's main class       
   
  desc "dummy single module"              
   define "dummy-module" do              
    # our tasks ..            
   end    
  end# the end of the dummy single module  end 
end

Buildr provides us with all the expected predefined tasks that you might expect:


 desc 'compiling'
 compile.with DUMMY_ARTIFACTS

 desc 'testing'
 test.with DUMMY_ARTIFACTS

 desc 'packing and including classpath in the manifest'
 package(:jar).with(:manifest=>
 manifest.merge("Class-Path" =>
 compile.classpath.collect{|dep| 
 "  "+File.basename(dep.inspect)}.join("\n").strip))

Don't be alarmed by the package task code it's quite simple (remember its all Ruby code!), each and every task can be referenced by using task(:name) (compile is equivalent to task(:compile)).
We are also referencing the manifest property which is a predefined data member of our project and setting the Class-Path property with all the artifacts that our project depends upon (the spacing is required due to weird manifest requirements), in order to run one of these tasks (at the project's base dir):


 bla@bla-desktop:~/workspaces/Dummy$ buildr taskname
 #in order to build an Intellij project simply use the idea task.

Now will head on to deploying our application into a folder in with the following structure:

This is a custom task that iv cooked up:


 desc 'deploying the application'
 task :deploy_app => [:package,:build_app_folders,:build_bin] do      
  FileUtils.cp(path_to('target')+'/'+File.basename(project.packages[0].inspect),lib_path)
  compile.classpath.each{|dep|FileUtils.cp(dep.inspect.gsub('Buildr::Artifact:','').strip,lib_path)}
 end

This task depends upon the package, build_app_folders and build_bin tasks, it basicly copies the project jar and all the artifacts the project depends upon into the application folder.
Take special notice to the usage of Buildr path_to method which returns the path to our module's target folder, since its a custom task will need to run it by specifying its full name:


bla@bla-desktop:~/workspaces/Dummy$ 
buildr Dummy:dummy-module:deploy_app

Here are build_app_folders and build_bin tasks on which deploy_app depends upon:


 desc 'building the application folders'
  task :build_app_folders do
  unless File.exists?(app_path)
   FileUtils.mkdir app_path ,:mode=>0777
  end
  ...
 end

 desc 'building the application launcher'
 task :build_bin do
  launch_cmd='java -Dfile.encoding=UTF-8 -jar ./lib/'+File.basename(project.packages[0].inspect)
  unless File.exists?(bin_path+'/'+'run.sh')
   f = File.new(bin_path+'/'+'run.sh',"w+")
   f.puts '#!/bin/bash'
   f.puts 'cd ..'
   f.puts launch_cmd
   FileUtils.chmod 0755,bin_path+'/'+'run.sh'
  end
 end

Now all that is left is to extend the clean task so that it will remove the application folder, in order to extend an existing buildr task will use the enhance method:


 desc 'cleaning up our act'
  clean.enhance {
   if File.exists?(app_path)  
   FileUtils.remove_dir app_path 
  end
 }

Thats all, happy building to us all :)

Dicsrete math & Java

2007-05-02T01:48:00.000-07:00

In my Bachelor's degree i had the pleasure to study discrete math, discrete math handles group theory which address well hmm... groups :).
A group is a math entity that has a proper definition and a collection of operations which are operable on them such as: intersection, union, disjunction, subtraction.

At this point you must be thinking "well this all doesn't matter to us Java folks ..", well in fact we can think of Java collections and sets as groups (not exactly since we wont insist on a binary operation), thinking of them this way can result in some clean code implementation.
For example imagine that we need to find which changes were made to an arbitrary list of uniquely identifiable objects (list which are new, removed or old), the simplistic approach will look like:


public void printChanges(List older, List newer) {
for(Object value:older){
 if(newer.contains(value)){
  log.info(value.toString()+" is old");
 } else {
  log.info(value.toString()+" was removed");
 }
}

for(Object value:newer){
  if(!older.contains(value)){
  log.info(value.toString()+" was added");
 }
}
}

Its not the most elegant code since it contains loops and conditionals, in simple cases this might not be so bad but in more complex cases keeping trace on this kind of code is not easy, as for run time its about o(n).

Now lets see how the groups approach might work, our input consists of two object groups and we are seeking for three other groups that contain elements from these two, the most easy one to detect is the intersection of the two which match the old objects.
Finding the removed and the new is the same symmetric problem which is to find the objects that exists in one group but doesn't exist on the other, in groups lingo the operation that finds such objects is called subtraction.
Now lets take a look at the group oriented implementation:


//making use of org.apache.commons.collections
public void printChanges(Collection older, Collection newer) {
 final Collection removed = CollectionUtils.subtract(older, newer);
 final Collection added = CollectionUtils.subtract(newer, older);
 final Collection old = CollectionUtils.intersection(older, newer);
 log.info("removed: "+removed);
 log.info("added: "+added);
 log.info("old: "+old);
}

Its easy to see that this implementation is much more easy to follow since there are no loops or conditionals (code complexity is lower), as for runtime its also o(n).

A glass of Watir to quench your thirst

2007-04-17T15:13:00.000-07:00

A couple of years ago (long before rails was in focus) Ruby has caught my eyes , to be exact it was Watir which is a Ruby based web testing framework that took my attention , at the time i didnt know how much useful it can be.
Watir is quite interesting since it drives the actual web browser UI (IE) during testing procedures , this makes it extremely simple to use , you don't have to sniff any http posts or use low level API , just select your DOM element and the operation that you wish the browser to perform on it:


 ie = IE.new # our IE window
 ie.goto("http://mytestsite")
 ie.text_field(:name, "typeinme").clear # clearing out a text field that carries the name typeinme

What can you do with it?
Well There are many applications (besides basic testing) that can utilize it such as:
• Web site monitors that scans web sites at certain intervals and look for errors.
• Web crawlers and Form data extractors.
• Applications that automatically recreate bugs (using saved user input data).

The fact that Watir is Ruby based makes its very extensible , you can use it in conjunction with Rails to create a web based management console for your application , fetching of input data can be done easily with ActiveRecord from you favorite DB.

Watir has its downsides too , its not very efficient since it requires an entire machine (as long your program keeps on running) , also since it works at the UI level (IE is its main resource) it takes a large amount of computing power (especially when there are a couple of them open).
Watir largest drawback is that its only supports IE at the current moment (support for Mozilla is planned on the next release) which is quite limiting (at least you can use this hack for running it on Linux) , still trust me Watir is one of the most useful frameworks youl ever stumble upon.

JBoss PermGen , same old error

2007-04-03T13:07:00.000-07:00

A couple of weeks ago iv stumbled upon the following post which carried the title "Good Riddance, PermGen OutOfMemoryError !", the thing is that this error happens quite alot when you are redeploying an application under JBoss for a couple of times.
The only way to recover from it is to restart JBoss which is quite annoying (especially when it takes 2min to load it up again).
Iv promised to myself to check the proposed post configuration and mailed the link to all my coworkers , obviously i forgot it totally :).
That was until one of my coworkers who read my email asked me if this thing actually works , his question had led me to perform the following test:

Iv compared two configuration of /bin/run.conf and counted how many times ill be able to redeploy an application without getting the error.

In the first (standard) configuration iv set JAVA_OPTS to "-Xms32m -Xmx64m -XX:MaxPermSize=64m .. " (the rest unchanged ) , this limits the memory size which is allocated to the JVM and to the perm gen memory section.

In the second (modified) configuration iv appended "-XX:+UseConcMarkSweepGC -XX:+CMSPermGenSweepingEnabled -XX:+CMSClassUnloadingEnabled" to JAVA_OPTS.

The results were quite disappointing , no matter how iv tried to set these parameters the results were identical , in fact the only thing that made a positive effect was setting "-XX:MaxPermSize=64m" to "-XX:MaxPermSize=128m".
Frustrated a bit iv went back to the post and noticed that it was updated , a link to another post was added , this one with the more realistic title "PremGen strikes back" :).