Recently, my attention was drawn to XML::Twig by other monks. I have been using it a lot since. I am pretty sure it can solve your problem. All you need to do is write a little logic around it. But there are more/many ways leading to Rome of course. I have no experience with XML:Writer. From a quick look at CPAN I think it is well possible to write XML files, I am not sure about the updating part though.

you said XML twig allows it, but how?
The idea is to check if there's a root and if there's a root, then add the child node to it and then the data nodes as child nodes to that node.

How would i achieve this using Twig, i checked it's tutorial and my head's spinning faster than a top.

I dun mind using XML::SIMPLE, XML::WRITER, XML::TWIG, XML::SMART, XML::DUMPER...anything that lets me create a XML file and then open it at a later instance to add another node.

A handy trick that mirod pointed out is to use two files. The first contains your enclosing <a> elements and uses a DTD to define a named entity that refers to the second file. The second file contains just the series of <b> elements with their contents, and no enclosing top level element.. E.g.:

<!DOCTYPE doc [<!ENTITY real_doc SYSTEM "/path/to/real/file.xml">]><a>
+&real_doc;</a>
[download]

This allows you to append to the second file without having to worry about the encolsing element tags.

I don't know if I'd like to solve it this way in production but this works. I prefer XML::LibXML for XML stuff but it doesn't do marshalling with Perl data so we bring in XML::Simple which I don't generally recommend but for simple, predictable data it can be nice.

use strict;
use warnings;

use XML::LibXML;
use XML::Simple;

use constant XML_STORAGE => "./whatever.xml";

my %data = ( d20 => int(rand(20) + 1),
             time => time(),
           );

save_data_as_xml(\%data);

# Take a look.
open my $xml_fh, "<", XML_STORAGE or die $!;
print while <$xml_fh>;
close $xml_fh;

sub save_data_as_xml {
    my $data = shift || return;
    my $doc = _get_or_initialize();
    my $new_raw_xml = XML::Simple::XMLout($data);
    my $parser = XML::LibXML->new();
    $parser->recover(1);
    my $new_node = $parser->parse_string($new_raw_xml);
    my $root = $doc->documentElement();
    $root->appendChild( $new_node->documentElement() );
    $root->appendChild( $doc->createTextNode("\n") );
    _save($doc);
}

sub _get_or_initialize {
    my $parser = XML::LibXML->new();
    my $doc = eval { $parser->parse_file(XML_STORAGE) };
    warn $@ if $@;
    return $doc if $doc;
    return $parser->parse_string("<container/>");
}

sub _save {
    my $doc = shift;
    $doc->toFile(XML_STORAGE);
}
[download]

so if i got it right, you are suggesting that i copy contents from an existing file, and push it into a new file(new by name of just replacing the old one) along with the additional data i am pushing in this time. :)

sure XML::SIMPLE would do that, but there's ought to be a simpler way. right?

It depends... Do you mean simple in the sense of performance? Well, who says that your existing XML file has to be treated as such (parsed and validated)? Seek to the end of the file, before the </a>, add another <b>...</b></a> sequence and done. But I guess, you want a little bit more than that...and a little bit more robustness?
The previous suggestion is simple to program, but surely not the fastest way to append a node to a (potentially large) file.