Back in the early 90s, we were introduced to the magical world of “cyberspace,” a place where you could chat with friends, check “electronic mail,” and even talk to strangers.  “Going on cyberspace” was like copulating with a pack of unicorns — no one had ever done it before, so everyone wanted to know what it was like:  How does it feel?  How does it work?  How can I get a screechy dial-up modem too?

But once cyberspace became mainstream, its better half decided that it would take on a whole new meaning.  In the seedy dark corners of AOL chatrooms, “cyber” lost its innocence.  With this transformation, thousands of curious 13-year olds were lured into predatory situations with creeps who wanted to “cyber”… Yes, like any rogue prefix-turned-slutty-verb, “cyber” became a term of virtual copulation.

So, forgive me for not embracing “Cyber Monday” as a new retail holiday.  To me, it’s as if retailers decided to name a random day “Boom Boom Tuesday” or “Bang Me Wednesday,” then offer 30% off all items in stock.  Sorry, but that doesn’t make me want to buy Ginsu knives, even if they’re 43% off on Amazon.  In fact, I feel less inclined to shop on Cyber Monday, and more inclined to join shady chatroom discussions about Grady Sizemore.

I am surprised that conservative watchdog groups haven’t boycotted “Cyber Monday” yet for its underlying sexual innuendo.  Perhaps they’re too busy snapping up Sarah Palin’s book on eBay… or maybe these “teabaggers” just don’t get the reference.

In the end, there are so many words in the English language that we’ve allowed to die an honorable death, like “beeswax” and “cassette tapes” and “groovy” (although this may still be used to describe Hideki Matsui’s face).  Had it not been for this inane Monday, “cyber” would be with them now.  I would like to call for an end to using this word (though, really, it’s a prefix), and retire “cyber” to Cyberia (apologies).  Let’s just call “Cyber Monday” for what it really is: “Virtual Deals… Monday.”

Note: The complete sourcecode is available on github here. For just downloading, unzipping and importing the project into Eclipse, press on the github site (detailed instructions below).

Besides the Google Web Toolkit (GWT), there is a nice web application framework for Java-only users called Vaadin.
Out-of-the-box, it has a more polished interface and prettier components than GWT.
I used it in a small application, my experience was very positive, even though I used Vaadin in a non-standard way (periodic asynchronous updating of a component by a infinitely running process), it works very well and there was really good support by the Vaadin team.
Note: This post is not an introduction to Vaadin, I hardly know it myself. A great developer-friendly entry are the sample applications. For more info, there is a step-by-step tutorial and a book for deeper understanding.

Intention

Automated testing of a web application is used in a Continuous Integration Environment. Furthermore, load/stress testing of the web application takes place in a Performance Test setting. A process should monitor logfiles in these test environments and report errors in a web-based report.

Technically, a thread must monitor several logfiles, aggregate these errors in a managed component which must be analyzed by a visualizing component (eg. a automatically refreshing table), which must be accessible from several clients.

So, now with technological annotations…

Technically, a thread must monitor several logfiles (Groovy), aggregate these errors in a managed component (Groovy, JMX) which must be analyzed by a visualizing component (eg. a automatically refreshing table), which must be accessible from several clients (web based, Vaadin).

Ok, lets go.

The “server side components”

The server side just consists of a simple Groovy script:

import javax.management.remote.*
import javax.management.*
import groovy.jmx.builder.*
import java.rmi.registry.LocateRegistry

class ServerState implements Serializable {
    def list=[]
}
def jmxbean = new ServerState()

Thread.start {
    def jmx = new JmxBuilder()
    def beans = jmx.export {
        bean(name: "jmx.builder:type=ExportedObject", jmxbean)
    }
    LocateRegistry.createRegistry(9000)
    jmx.connectorServer(port: 9000).start()
}

def worker = { logfile ->
    println "analyzing ${logfile}"
    logfile.withReader { reader ->
        reader.skip(logfile.length())
        while (true) {
            def line = reader.readLine();
            if (!line) {
                Thread.sleep(1000);
            } else {
                def inner = [:]
                inner["server"] = logfile.name
                inner["ts"]= new Date().toString()
                inner["error"] = line
                jmxbean.getList().add(inner)
            }
        }
    }
}

new File("c:/temp/").eachFileMatch(~/^log.txt.*/) { file ->
    Thread.start worker.curry(file)
}

First, a thread is started that exports the aggregating bean via JMX (it’s so easy in Groovy).
After calling jmx.connectorServer(port: 9000).start(), the bean is available under the JNDI-Name service:jmx:rmi:///jndi/rmi://localhost:9000/jmxrmi to client processes (using the name jmx.builder:type=ExportedObject).
Afterwards, a worker closure is created. Nothing special in there, just the reader.skip(logfile.length()) makes sure the end of the file is used at the beginning (before the monitoring process starts).
The last three lines are quite dense, though. Here, all files matching the pattern (eg, log.txt, log.txt1, log.txt2) are used to create threads which monitor these files. This is easily achieved by using currying, which is described in detail here.
In this case, file is applied and the rest (the partially applicated closure) is submitted to Thread.start, which takes a closure (now with an already defined logfile) as the argument.

Tip: Using the Groovy script

All information necessary to run Groovy in any environment is stated here.
However, there is a really cool way of testing Groovy scripts without any settings, etc. Just JAVA_HOME must be set correctly.

1. Download Groovy, unzip or install to some directory (eg. c:\dev\groovy)
2. Set your JAVA_HOME environment variable to your Java installation (eg. set JAVA_HOME=c:\java\jdk1.6.0_17).
3. Start groovyConsole.exe (in \$GROOVY_HOME\bin). Paste the script there. Run it.

Located in GROOVY_HOME\bin: groovyConsole

groovyConsole in action

The “client side”

Testing with jconsole

jconsole is included in the Java SDK (JAVA_HOME\bin)

The JMX-URL is determined by the Groovy script

Result of calling the exported operation getList()

Creating a web app client with Vaadin

1. Download the Vaadin Eclipse plugin.
2. Download the zipped files (click on ). It’s subproject Vaadin.
3. Create new Vaadin project, choose Vaadin jar (cmp. image) – this post was tested with vaadin-6.2.nightly-20091016-c9216.jar.



4. Delete generated src and Webcontent (!! except WEB-INF/lib !!) directores and copy from downloaded zip.

Structure and Functioning

The JMX-component to connect to Groovy-JMX-server

public class JmxService {

	private JMXServiceURL url;
	private JMXConnector jmxc;
	private MBeanServerConnection mbsc;
	private ObjectName mbeanName;

	private static JmxService INSTANCE;

	private JmxService() {
		try {
			url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9000/jmxrmi");
			jmxc = JMXConnectorFactory.connect(url, null);
			mbsc = jmxc.getMBeanServerConnection();
			mbeanName = new ObjectName("jmx.builder:type=ExportedObject");
		} catch (MalformedURLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (MalformedObjectNameException e) {
			e.printStackTrace();
		} catch (NullPointerException e) {
			e.printStackTrace();
		}
	}

	public static JmxService getInstance() {
		if (INSTANCE == null) {
			INSTANCE = new JmxService();
		}
		return INSTANCE;
	}

	public ServerState getServerState() {
		return JMX.newMBeanProxy(mbsc, mbeanName, ServerState.class, true);
	}

}

The table with its on-click-listener is created in pure Java

	private Table initTable(final IndexedContainer container) {
		final Table table = new Table();
		table.setContainerDataSource(container);
		table.setWidth("100%");
		table.setPageLength(PAGE_LENGTH);
		table.setColumnExpandRatio("error", 1);
		table.setSelectable(true);
		final Application self = this;
		table.addListener(new Table.ValueChangeListener() {
			@Override
            public void valueChange(ValueChangeEvent event) {
				Object o = table.getValue();
                if (o != null) {
                	preformattedText = new Label("Here can be sources");
                    preformattedText.setContentMode(Label.CONTENT_PREFORMATTED);
                    self.getMainWindow().addComponent(preformattedText);
            	} else {
                    self.getMainWindow().removeComponent(preformattedText);
                }
          	}
        });
		return table;
	}

The Refresher”pattern” is explained here, the sources are in the repository. All necessary sources are also included in the github sources to this post.

Running the project

You can just start the server-side Groovy script (after configuring the file matching loop at the end of the script corresponding to your system). Afterwards, just start the Vaadin project with “Run on Server”.
Now, you have to change a monitored file (eg. add a line and save the file). If you have chosen “Aktualisierung starten” (ie. start polling for new JMX events) the changed line should appear in the table. You can choose the line (details view is not implemented yet) to display more information. The table scrolls accordingly (the last item is always displayed at the bottom of the table).
The refresh mechanism necessary for polling the JMX state is copied from here.
Note: for real usage, it would be much better to use JMX notification for this use case.

Lo mejor del día después de dormir acompañado es el perfume que te queda. Y si es en tu cama, el aroma en tu almohada que dura por noches.

back again with another oldie of the week. this time I was very inspired by the jazzy stuff coming from labels like ninjatune, mo-wax and wall of sound records and the allover smooth n relaxed vibes from releases of f.e. luke vibert, amon tobin, funki porcini, clifford gilberto, etc.

one example of my jazzy experiments is the 1998 tune ‘allthatjazz’ – a lush groovy swingtune flavoured with livedrums. I sampled a lot of fragments from old jazz records, like trumpets, trombones, bass, etc. – enjoy and have a chilled sunday!

hell g. – allthatjazz

My on-line Etsy store is dedicated to bringing you groovy, glam &  glitz. I thought it would be fun to focus on what’s groovy. Here’s the wikipedia definition….

Groovy is a slang term that gained popular currency during the 1960s and 1970s and which is often associated with the counterculture of that era. It is roughly synonymous with words such as excellent, fashionable, or amazing, depending on context. Groovy originated in the jazz culture of the 1930s, in which it referred to the groove of a piece of music.

Here are some groovy vintage pieces that are fun and available right now for you to enjoy. Click on the pictures to learn more about them or to purchase.

L’esempio seguente mostra come processare un XML attraverso l’utilizzo del linguaggio Groovy. L’obiettivo è leggere un xml , cercare tra tutti gli elementi solo quelli che hanno un attributo valorizzato in un certo modo e infine riscrivere un XML con solo gli elementi trovati.
Ho incluso anche un metodo che fa lo stesso lavoro in java utilizzando l’api DOM4J , è interessante notare quanto risulti decisamente piu conciso e leggibile il codice scritto in groovy.

E’ bene ricordare che all’interno di classi scritte in groovy il codice java è interoperabile al 100%. Inoltre classi di servizio scritte in groovy possono essere facilmente iniettate in classi java mediante l’uso di Spring.

import groovy.util.XmlSlurper
import groovy.xml.MarkupBuilder

import org.dom4j.Document;
import org.dom4j.Attribute;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;

class XMLService {

	static def XML_SOURCE = '''
                        <root>
                            <item nome="carlo" cognome="bianchi" datadinascita="25/05/1978" />
                            <item nome="carlo1" cognome="rossi" datadinascita="10/10/1971" />
                            <item nome="carlo2" cognome="rossi" datadinascita="10/10/1972" />
                            <item nome="carlo3" cognome="rossi" datadinascita="10/10/1973" />
                       </root>
		'''

def parseGroovyXml(xmlSource,attribute,value){

		def root = new XmlSlurper().parseText(xmlSource)
		def result = root.item.findAll { it.@"${attribute}"=="${value}" }
		def writer = new StringWriter()
		def xml = new MarkupBuilder(writer)

		xml.root { result.each { item(it.attributes()) } }

		println writer

	}

public void parseJavaXml(String xmlSource,String attribute,String value){

      Document document = DocumentHelper.parseText(xmlSource);
      List<Node> nodes = document.selectNodes( "//root/item[@"+attribute+"='"+value+"']" );
      StringBuilder xml = new StringBuilder("<root>");

      for (Node n : nodes) {
         Element e = (Element) n;
         xml.append("<item ");
         List<Attribute> list = e.attributes();

            for (Attribute a : list) {
                String name = a.getName();
                String val = a.getValue();
                xml.append(" "+name+"=\"").append(val).append("\"");
            }

       xml.append(" />");

    }

     xml.append("</root>");
     System.out.println(xml.toString());
 }

  static void main(args){
	new XMLService().parseGroovyXml(XML_SOURCE,'nome','carlo1')
        new XMLService().parseJavaXml(XML_SOURCE,"nome","carlo1");
  }

}

Phytologie PhytoPanama Mild Protecting Shampoo Reviews

Phytologie Phytopanama Mild Protecting Shampoo

Phytologie PhytoPanama Mild Protecting Shampoo Features

• 6.8 oz
• with 65% Quillaja decoction

Check Price and Read More Details of Phytologie PhytoPanama Mild Protecting Shampoo…>>

Customers Who Viewed This Item Also Viewed

• Pureology hydrating Shampoo and Conditioner duo for .95. (max 2 deals p/order)

I am currently working at a Project that should be internationalized ( Arabic – English ).  I am still developing it. I needed list of countries to be internationalized and I wanted it to be in the domain constraints (inList). I may later put the data in the database, but for the time being; I’m putting the data in the domain class.

Here is what I did

I put the data in the model like this :

class Address {

static constraints = {
gpsLng(nullable:true)
gpsLat(nullable:true)
address()
//                area(nullable:true)
city()
state()
country(inList:['afghanistan',
'albania',
'algeria',
'american_samoa',
.
.
.
'zaire',
'zambia'])
dateCreated(nullable:true)
lastUpdated(nullable:true)
}

Date dateCreated
Date lastUpdated

String gpsLng
String gpsLat

String address
//        String area
String city
String state
String country = ‘egypt’

String toString(){
“$address”
}
}

And at the properties files I did the internationalization like this

address.country.afghanistan=Afghanistan
address.country.albania=Albania
address.country.algeria=Algeria
address.country.american_samoa=American Samoa
…

And in the view .. I did this  ( I’m using beanField plugin too )

<bean:select beanName=”address” property=”country”
name=”country” id=”country”
from=”${address.constraints.country.inList}”  valueMessagePrefix=”address.country” value=”${fieldValue(bean:address,field:’country’)}”   optionValue=”${message(code:it)}” />

And this is it ..  The valueMessagePrefix is used to indicate the prefix to be added to the key in inList list and get the value from the properties files. optionValue is what user see ( Label ).

When the form is submitted, the value in the inList will be passed back to the controller.

Hope I was helpful to someone.

On a good day I have trouble understanding my boss due to the accent.  But now, the boss has taken to throwing in French words.  Tomorrow I’ll clear up what may be a misunderstanding. Maybe the boss thinks I know French.

More likely the boss is showing off and successfully putting me in my place.  Whatever place that is.  I already know the boss test me with regard to grammar. That’s right.  The boss plants grammar mistakes in drafts for me to find and correct.

That’s why I’m reading grammar books.

Es o si que es.  (that’s not French, but the best I can do)

It’s great to see fellow Pixstanaut Tomás Lin talking at the forthcoming Grails Exchange conference in December. He’ll be talking about building rich GUI apps with Flex and Grails. There are still a few tickets left if you can make it.

Acabo de hacer una sarpada lasagna.

Invoco a los testigos (?)

Background: Viola is Dad’s mother. He calls her by first name.

Dad: We’re ging to Viola’s this weekend for a spaghetti dinner. Of course, I’ll be eating a salad, but I’m the only one that’s watching her waistline.

——–

Dad: Benjamin Franklin and Dolly Parton are two really cool people.

I’ve noticed that most of my journal entries are more like lists rather than narratives.  Blame it on the booze, the drugs, the milk and cookies, or the genes, it is was it is.  Here are a few such entries for your judgment and ridicule, which usually involves laughter and euphoric feelings.

Music stuff, don’t forget

“In My Secret Life”
Not sure of artist, from L Word

Needfire
Dolly Parton, “I will Always Love”

Fresh Air Podcast

Oasis

Jesse Marshon from Montreal writes under name JBM. “Cleo’s sung.” Album Not Even in July.

Bishop Allen “The Ancient Common Sense of Things.”

Ginsberg “Melody” album is history of Melody Nelson. He’s a perv and there is some video of him on YouTube. Song is French

Ace of Base, “I Saw the Sign”

Words to Know

Caduceus (a cardboard caduceus from Germany)   —Side note: This sentence doesn’t help me at all.  Why didn’t I write the definition?  For the record, I do not know this word.

Temerity

Stunning        —Side note: Word like this, words that are commonly circulated, I like to look these up in different dictionaries. It can often be stunning what history and influence they can be hiding.

Extremely

Slog

What?

Foot worship party.

Riding Boots.

Need new bras; nude and black.

Never cared for lingerie. Prefer naked.

Dan Savage.

Need smart satchel or hobo, leather and kiss clasp would be best.

Rain hat.

Rain boots.

Digitaldesire.com

I feel that if I wore a burka people wouldn’t ask me to make copies for them.

“Gum in My Hair”, title for my book.

40-year-old fags.   — Side note: If you’re offended by my usage of “fag” get over it. Our favorite sex advice columnist and all around good guy, Dan Savage, endorses the casual use of fag.  Similar to how ladies will refer to themselves as sluts or cunts and African-Americans use…yeah, nope, I can’t do this one, but y’all know what I mean.

Boy George, yummy. More about the novel that inspired the play.

The other day, Scott Davis published an article at developerWorks entitled Practically Groovy:  SwingBuilder and the Twitter API, Part 2.  I’m sure you won’t be surprised to hear that it’s a good article.  No surprise there, given Scott’s excellent reputation and abilities.

As it turned out, though, I was teaching a Java Web Security class when the article came out and we’d already discussed mechanisms for doing authentication.  In the article, Scott pointed out that while Twitter prefers OAuth authentication (see here for details), they allow for HTTP Basic authentication.

Scott wrote a nice Groovy GUI client, based on Groovy’s excellent SwingBuilder.  The authentication part looked like this:

def authString = "username:password".getBytes().encodeBase64().toString()
def conn = addr.toURL().openConnection()
conn.setRequestProperty("Authorization", "Basic ${authString}")

The process starts with a username and a password and concatenates them together with a colon in the middle. Then you convert the result into a byte array by calling getBytes(). Then, as you can see from the GroovyDocs, Groovy adds an encodeBase64() method to byte[]. The return type is a Writable, which is then converted back to a String using the normal toString() method.

Add the word “Basic” in front of it and you’ve got an authorization header that can be used in an HTTP request.

Okay, that’s cool, and it works, but whoa is that dangerous. Say I’m a sniffer on the network. I see a request go by, and inside it I find:

Authorization: dXNlcm5hbWU6cGFzc3dvcmQ=

We now have a beautiful illustration of the difference between encoding and encrypting. Just because this is Base 64 encoded doesn’t mean it can’t be read. All I have to do is write:

def (user,pass) = new String("dXNlcm5hbWU6cGFzc3dvcmQ=".decodeBase64()).split(':')

and lo and behold, I’ve got the username and password. This works because Groovy gives the String class a nice, convenient decodeBase64() method, and String has a constructor that takes the resulting byte array as an argument. I’m also using the new (as of Groovy 1.6) mechanism that allows me to return two separate values from a method call, so here I return the username and password separately from the split() method.

Of course, the real reason this works is that HTTP basic authentication passes the encoded string in nice, clear text. No decryption is required. If this was being transmitted over HTTPS, at least the network would be encrypted, but there’s no requirement for that.

Yikes. I’d guess the Twitter web site itself uses form authentication over HTTPS, but I wonder how many of those client-side Twitter applications are just doing basic authentication like this?

Maybe I should change my Twitter password.

Just for reference, here’s a complete script showing both encoding and decoding, with some assertions for completeness:

def u = 'username'
def p = 'password'
def encoded = "$u:$p".getBytes().encodeBase64().toString()
println "$u:$p -> $encoded"
assert encoded == 'dXNlcm5hbWU6cGFzc3dvcmQ='
def (user,pass) = new String(encoded.decodeBase64()).split(':')
println "(user,pass) = ($user,$pass)"
assert user == u
assert pass == p

Read the details of the problem here

Summary

For how many triangles in the text file does the interior contain the origin?

Solution

This question had me wondering for a while as to what the best approach to take might be. In the end I went for a simple approach that just relied on the fact that the interior angles from any point within a triangle to the vertexes would add up to 360° or 2 * Pi radians. To calculate the angles at the origin I relied on some things I’d learned when I used to write computer games as a hobby.

The dot product of two 2D vectors, U and V, is equivalent to the following two formulae:

U•V = U₀V₀ + U₁V₁

U•V = |U| * |V| * cos θ

Where |U| is the magnitude of the vector U, i.e. sqrt( U₀² + U₁² )

So this gives: cos θ = ( U₀V₀ + U₁V₁ ) / ( |U| * |V| )

The coded solution is then quite trivial and just calculates the angle at the origin subtended by vectors out to the pairs of vertices for each line segment.

new File("euler_P102_triangles.txt").eachLine {
    def (x0, y0, x1, y1, x2, y2) = it.split(",")*.toInteger()
    def ( a, b, c ) = [ [ x0, y0 ], [ x1, y1 ], [ x2, y2 ] ]
    def theta = 0.0

    [ [ a, b ], [ a, c ], [ b, c ] ].each {
        def ( u, v ) = it
        def dot = u[0] * v[0] + u[1] * v[1]
        def ul =  Math.sqrt(u[0] * u[0] + u[1] * u[1])
        def vl =  Math.sqrt(v[0] * v[0] + v[1] * v[1])
        theta += Math.acos(dot / (ul * vl))
    }

    if (Math.abs(theta - 2 * Math.PI) < 1E-7) answer++
}

It ran in 0.96 seconds and wasn’t difficult to write once I’d decided what approach to take! Note the importance of using an epsilon value (1E-7) when comparing floating-point numbers as you can’t rely on an exact equality.

There are probably quicker ways to do this (in fact, I know there are) but this approach was nice & straightforward to code off the top of my head and ran in an acceptable time.

Conclusion

Groovy makes reading a text file and parsing it into appropriate data structures quite simple. It didn’t really make any difference to the rest of the solution apart from perhaps the nice syntax on the <list of sides>.each{} loop as it was mostly just straightforward maths.

Hi everyone. I have a new line of shirts that I’m just presenting. Hope you like them and hope you and your friends buy some. Let me know if you want a custom shirt or if you want me to customize one of mine.

I Left My Brain in San Francisco

My design company:

Olachacha.com

Support the start up. Buy a shirt. Get the word around to everyone you know.

Love, Joan

Hi everyone. I have a new line of shirts that I’m just presenting. Hope you like them and hope you and your friends buy some. Let me know if you want a custom shirt or if you want me to customize one of mine.

My design company:

Olachacha.com

Support the start up. Buy a shirt. Get the word around to everyone you know.

Love, Joan

Read the details of the problem here

Summary

Which base/exponent pair in the file has the greatest numerical value?

Solution

I took the straightforward approach to this one. As the resulting numbers would be huge it was just a matter of using log10(base) * exp and comparing those values. The coded solution is trivial.

def ( i, answer, max ) = [ 1, -1, 0.0 ]

new File("base_exp.txt").eachLine {
    def ( base, exp ) = it.split(",")*.toDouble()
    def log = Math.log10(base) * exp
    if (log > max) ( answer, max ) = [ i, log ]
    i++
}

It ran in 46 ms and took a very short time to write!

Conclusion

Groovy was a very nice language to use for this. It was very easy to read the file and process the contents. See how the spread-dot operator is used on the list resulting from the split to convert both operands in to Doubles ready for the next step. The only slightly irritating part was that I had to maintain my own record count as there is no eachWithIndex() method available on a File object. I could have treated this differently by reading into a list first but this seemed quicker!

As there was no heavy maths processing performance was fine, it was quick to write and the code intent is clear.

El jueves me escapaba temprano de acá un par de horas para ir a felicitar a Mai, Pau y Ani que defendían la tesis. Yo no les dije nada, pero en realidad ya sabía que se iban a sacar un 10. En el momento de reflexión que ocurre cuando estás soltando un huevo en la cabeza de otro es como si la fuerza con que lo arrojás tironeara, efecto pañuelos de colores atados, algunos pensamientos. Pensamientos como uy, mirá cuando me hagan esto a mí, qué copado.. Lo único, imaginate que entre los que me hagan esto a mí estén mis hijos. Eso sería triste. Agh qué baranda que larga el pelo de esta piba…

El aroma a recibida penetra por tu nariz como una pica te atraviesa el paladar y te sale por el polo norte de la cabeza.

Sadly, and annoyingly, groovy.util.slurpersupport.NodeChild doesn’t have a nice toString() implementation when dealing with results obtained from groovy.util.XmlSlurper. For convenience, you can add the following meta-method to NodeChild to serialize xml nodes:

NodeChild.metaClass.toXmlString = {
	def self = delegate
	new StreamingMarkupBuilder().bind {
		delegate.mkp.xmlDeclaration() // Use this if you want an XML declaration
		delegate.out << self
	}.toString()
}

In grails, you would typically run such code from a thread-safe location such as from within a plugin or inside BootStrap.groovy. Then, in your application you can use:

def xml = new XmlSlurper().parseText('<a>b</a>')
println xml.toXmlString()

This is handy when building REST APIs that require both text and node based version of xml, such as an API proxy.