Vala's claim to fame is that it simplifies GObject development by exposing it in a C#/Java like language. Unlike C# and Java Vala is translated to C and then compiled to a native binary. Presumably this leads to performant execution and a tight memory footprint compared to CLI and Java bytecode.

The GObject type system and Vala are new to me so I'm in no position to kick knowledge, but I'll share some of what I've written early in my learning process.

Example 1 Hello World:

using GLib;

public class HelloWorld : Object {
       public void run() {
              stdout.printf("Hello World\n");
       }

       public static int main(string[] args) {
              HelloWorld hellower = new HelloWorld();
              hellower.run();
              return 0;
       }
}

producing the output:

Hello World

Example 2 Getting Twitter Status XML:

using GLib;

public class Twitter {
  static int main (string[] args) {
    /* get the username from the command line */
    string username = args[1];

    /* format the URL to use the username as the filename */
    string url = "http://twitter.com/users/%s.xml".printf(username);

    stdout.printf("Getting status for %s\n".printf(username));

    /* create an HTTP session to twitter */
    Soup.SessionAsync session = new Soup.SessionAsync();
    Soup.Message message = new Soup.Message ("GET", url);

    /* send the HTTP request */
    session.send_message(message);

    /* output the XML to stdout */
    stdout.printf(message.response_body.data);

    return 0;
  }
}

This example will retrieves a twitter user's status via the REST API and outputs the XML response to the console. The Soup library is employed for the HTTP communication.

Example 3 XML parsing and XPath queries:

/* parse the xml into a document object */
Xml.Doc* status_doc = Parser.parse_memory(
  message.response_body.data,
  (int)message.response_body.length);

/* create the basic plumbing for XPath */
XPathContext* xpath = new XPathContext(status_doc);

/* execute an xpath query */
XPathObject* result = xpath->eval_expression("/user/status/text");

/* slap the result in a string */
string status = result->nodesetval->item(0)->get_content();

stdout.printf("%s\n", status);

The above code could be grafted into example 2 (requires slapping in a "using Xml;" directive) and would actually pull the status out of the XML response.

Conclusion

Vala is a young language, but an interesting one. It certainly seems like it could make native GNOME development a bit more accessible to C#/Java developers.

A few things that justify it's use over C++ that I haven't covered here are its support for "modern" features such as assisted memory management, the foreach construct, and exception handling.

One of the more elegant bits that I've seen for this purpose is Nokogiri which is a Ruby library that supports querying HTML content by both an XPath and CSS selector syntax.

XPath

First I'll demonstrate how to parse some content out of a page via the XPath syntax. This code uses the ruby documentation for the Bignum class as a parsing medium and essentially extracts the method names.

require 'nokogiri' 
require 'open-uri'

doc = Nokogiri::HTML(open('http://www.ruby-doc.org/core/classes/Bignum.html'))

doc.xpath('//span[@class="method-name"]').each do | method_span |
	puts method_span.content
	puts method_span.path
	puts
end

The above code simply iterates through a set of Node objects that represent every span tag with the CSS class "method-name" applied. It prints out the inner text and absolute XPath via the "content" and "path" properties respectively. Below is a sample of the output:

power!
/html/body/div[3]/div/div[24]/div[1]/span[1]

big.quo(numeric) => float
/html/body/div[3]/div/div[25]/div[1]/a/span

quo
/html/body/div[3]/div/div[26]/div[1]/a/span[1]

rdiv
/html/body/div[3]/div/div[27]/div[1]/span[1]

big.remainder(numeric)    => number
/html/body/div[3]/div/div[28]/div[1]/a/span

rpower
/html/body/div[3]/div/div[29]/div[1]/a/span[1]

CSS

Nokogiri also supports querying by way of CSS selector syntax. The following example iterates over every link that displays a javascript popup in the Bignum document used above and outputs its absolute css selector path and the text of the "onclick" attribute.

doc.css('a[onclick]').each do | popup_link |
  puts popup_link.css_path
  puts popup_link.attributes['onclick']
end

Practical

A real life use of this library and HTML parsing in general is Anemone which is a web spidering framework for Ruby. Like most things in Ruby it's programmer friendly and delivers quite a bit of power without much work.

The following Anemone example uses Nokogiri under the covers to crawl all links on this site and print out the URLs of articles.

require 'anemone'
require 'open-uri'

# crawl this page
Anemone.crawl("http://www.chrisumbel.com") do | anemone |
  # only process pages in the article directory
  anemone.on_pages_like(/article\/[^?]*$/) do | page |
    puts "#{page.url} indexed."
  end
end

Also, the WebRat DSL (which powers the Cucumber web acceptance testing framework) employs Nokogiri.

Conclusion

While the need for screen-scraping and HTML parsing has diminished over time the need still exists. It's nice to know that when we do have to do it the process is made simple by libraries like Nokogiri.

Last spring Amazon eased the pain a little by allowing us to batch PUT operations into a single command.

In order to demonstrate the use of this feature and analyze its performance I'll use C# and Amazon's .Net SimpleDB library.

Single PUTs

To establish a baseline I'm going to run a test with some sample data (Sun Micro's stock data from 1/3/05 to 7/9/2009 obtained from Yahoo! finance) and write it into a "StockPrices" domain one item at a time. This data is in CSV form and contains 1137 rows.

I conducted three trials locally and three trials on a small EC2 instance.

AmazonSimpleDB service = new AmazonSimpleDBClient("ENTER YOUR KEY HERE", 
"ENTER YOUR SECRET KEY HERE");

using (stockStreamReader = new StreamReader(File.OpenRead(@"JAVA.csv")))
{
    PutAttributesRequest putRequest;
  
    /* read column names */
    stockStreamReader.ReadLine();
      
    while (!stockStreamReader.EndOfStream)
    {
        putRequest = new PutAttributesRequest();
        putRequest.DomainName = "StockPrices";

        string line = stockStreamReader.ReadLine();
        string[] tokens = line.Split(',');

        putRequest.ItemName = string.Format("{0}_{1}", tokens[0], ticker);

        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "Ticker", Value = ticker });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "Date", Value = tokens[0] });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "Open", Value = tokens[1] });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "High", Value = tokens[2] });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "Low", Value = tokens[3] });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "Close", Value = tokens[4] });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "Volume", Value = tokens[5] });
        putRequest.Attribute.Add(new ReplaceableAttribute() 
            { Name = "AdjustedClose", Value = tokens[6] });

        service.PutAttributes(putRequest);
    }  
}

Resulting in the following times (in seconds):

	Local	EC2
Trial 1	54	34
Trial 2	49	32
Trial 3	57	32
Avg	53.3	32.6

As you can see there was a significant improvement simply by executing the code on Amazon's equipment (minimizing connection latency) but it's hard to argue that the performance was qualitatively bad even without something to compare it to.

Batched PUTs

Then I conducted a similar test using batched PUT operations as such:

AmazonSimpleDB service = new AmazonSimpleDBClient("ENTER YOUR KEY HERE", 
"ENTER YOUR SECRET KEY HERE");

using (stockStreamReader = new StreamReader(File.OpenRead(@"JAVA.csv")))
{
  BatchPutAttributesRequest batchPutRequest = new BatchPutAttributesRequest();
  batchPutRequest.DomainName = "StockPrices";

  while (!stockStreamReader.EndOfStream)
  {
    ReplaceableItem item = new ReplaceableItem();

    string line = stockStreamReader.ReadLine();
    string[] tokens = line.Split(',');

    item.ItemName = string.Format("{0}_{1}", tokens[0], ticker);

    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "Ticker", Value = ticker });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "Date", Value = tokens[0] });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "Open", Value = tokens[1] });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "High", Value = tokens[2] });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "Low", Value = tokens[3] });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "Close", Value = tokens[4] });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "Volume", Value = tokens[5] });
    item.Attribute.Add(new ReplaceableAttribute() 
      { Name = "AdjustedClose", Value = tokens[6] });

    batchPutRequest.Item.Add(item);

    /* Amazon limites batches to 25 items */
    if (batchPutRequest.Item.Count == 25)
    {
      service.BatchPutAttributes(batchPutRequest);
      batchPutRequest = new BatchPutAttributesRequest();
      batchPutRequest.DomainName = "StockPrices";
    }
  }

  /* send any that remain */
  if (batchPutRequest.Item.Count > 0)
    service.BatchPutAttributes(batchPutRequest);
}

resulting in:

	Local	EC2
Trial 1	7	6
Trial 2	6	6
Trial 3	6	6
Avg	6.3	6

Which was a marked improvement that effectively nullified the advantage the single writes got on EC2.

Conclusion

The overall comparison of the two approaches is as follows:

Type	Local	EC2
Single	53.3	32.6
Batched	6.3	6

Batched PUT operations offer a clear performance benefit regardless of where they're executed from. You just have to keep in mind you're limited to batch sizes of 25 items and 1 MB per request.

Note that PowerShell 2.0 is in CTP 3 at the time of writing and everything is subject to change.

Out-GridView

The Out-GridView cmdlet gives you a lightwieight sortable/searchable grid that you can easily pipe collections into as demonstrated below.

ls | Out-GridView

ScriptCmdlets

Previously the only way to develop your own Cmdlets was to resort to one of the higher level .Net languages such as VB.Net and C#. This restriction has been removed with the introduction of ScriptCmdlets.

Consider the following ScriptCmdLet that retrieves a user's Twitter status:

Cmdlet Get-UsersStatus
{
    # definition of the Cmdlet's parameters
     param([string] $username)
    
    $url = ("http://twitter.com/users/{0}.xml" -f $username)
    
    $webClient =  New-Object Net.WebClient
    $responseDoc = New-Object Xml.XmlDocument
    
    $responseDoc.LoadXml([Text.Encoding]::ASCII.GetString(
      $webClient.DownloadData($url)))
      
    $responseDoc.SelectSingleNode("/user/status/text")   
}

Which can now be executed Cmdlet style:

Get-UsersStatus "chrisumbel"

With a minor change to our param definition we can now accept input from the pipeline:

param([ValueFromPipeline][string] $username)

So our Cmdlet can be executes as such:

"chrisumbel", "wimbledon" | Get-UsersStatus

which gets the status all the users piped into it, chrisumbel and wimbledon in this case.

An interesting thing to consider is that ScriptCmdlets can override other Cmdlets, including those that are built-in.

PowerShell ISE

A weakness of PowerShell up to this point is that you typically had to resort to a third-party solution to get a rich development expirience. While the PowerShell ISE is certainly not a replacement for some of the fancy commercial offerings it's far more helpful than notepad. It grants the scripter syntax highlighting, one-click script running and a tabbed environment for working with multiple scripts.

Check out the following screenshot which contains the code from our Twitter status example:

Conclusion

These features go a long way to making a powerful shell environment even more powerful, not to mention quite a bit more friendly. Here's looking forward to the official release!

Keep in mind that installing the CTP requires uninstalling previous versions of PowerShell. Depending on the PowerShell and operating system versions involved the procedure can vary. Google/Bing is your friend.

Once bringing up PowerShell you have to enable remoting by invoking the aptly named Enable-PSRemoting cmdlet

Enable-PSRemoting -force

Now the meat. Consider the following code:

# copy bigfile.txt on a background thread
$job = start-job -scriptBlock { cp bigfile.txt bigfilecopy.txt }

# here's where we'd perform some other logic while our file copies

# wait for job to finish
wait-job $job

Note that you can also retrieve the status of jobs and the return values with the Get-Job and Receive-Job cmdlets respectively.

More interesting still is the ability to execute jobs remotely on other systems running PowerShell and WinRM. This can be demonstrated with the Invoke-Command cmdlet coupled with the -AsJob parameter as follows:

Invoke-Command -ComputerName Comp1, Comp2 -ScriptBlock { cp bigfile.txt bigfilecopy.txt } -AsJob

The -ComputerName parameter's values of Comp1 and Comp2 indicate that our script will will execute on two remote machines named Comp1 and Comp2.

In conclusion PowerShell 2 introduces some interesting features for asynchronous and remote operations. This opens many doors for administrators and developers alike with minimal code.