Just FYI, this is not a discussion on self-help to keep you from divulging your deep and dark secrets in real life. It’s about YQL and the various web secrets such as API keys, Consumer Keys and other key-secrets for personal use which you’d rather not give out to anyone visiting your web applications.

With that disclaimer, let me jump right into the scenario that I’m talking about. There are quite a few YQL Open Data Tables such as Netflix Catalog, NY Times Article search, Amazon Product Advertising table etc which require a user to register and enter an API key and/or Secret into the query. Issuing a query in YQL Console for testing purposes seems great. You can see the results and ensure that the query is working as you desire before adding it into your webpage/webapp.

This YQL query can then be run, either by issuing a HTTP GET request call from your website or by directly embedding it in your webpage as part of the Javascript. In the former case, since you own the website, there is no need to hide the Consumer-Key and Secret. In the later case, where the query is directly embedded in the client-side JS code running in the browser, you run the risk of exposing your ConsumerKey and Secret which can then to be used to run various other queries on your behalf. In this post, I show how one can hide the secrets from the user and also lock down the secrets to a single table.

Brief Introduction to ‘SET‘

‘SET’ statements in YQL let you decouple the constant keys from the varying keys in the where clause of the YQL statement. For example if I wanted only the PDF search results for a given search term, I would issue:

select * from search.web where query='yql' and type='pdf'

Try in console

Since the type=’pdf’ expression will be a constant key in all of my queries, I can decouple it by issuing the following query

SET type='pdf' on search.web;
select * from search.web where query='yql'

Try in console

In essence, the YQL compiler applies all the ‘SET’ clauses for a particular table to each compatible branch of the YQL statement and then executes the query.

Here is another example which shows the Amazon product listing api wrapped in YQL that requires your AWSAccessKeyId and the secret to be part of the query. To test this query I would use the entire query:

use 'http://nagiworld.net/yqldefs/yql/amazon.ecs.xml' as amazon.prodlist;
set AWSAccessKeyId='YOUR_KEY' on amazon.prodlist;
set secret='YOUR_SECRET' on amazon.prodlist;
set AssociateTag='YOUR_ASSOCIATE_TAG' on amazon.prodlist;

select * from amazon.prodlist where Title = 'panasonic' and SearchIndex="Electronics" and ResponseGroup='Images,ItemAttributes,SalesRank' and ItemLinks.ItemLink.Description='All Offers'

Storing your secrets

YQL provides a way to store data in Yahoo’s own Sherpa. For a deep dive into storing data with YQL you can checkout the Hosted Storage docs

Building on the ‘USE’ and ‘SET’ statements described earlier, we can easily decouple the query into two components. The first component has all the ‘SET’ statements whereas the second component has your query. Now to hide all the secret bits in YQL, all I have to do is insert the ‘SET’ statements into yahoo.storage with the following query

insert into yql.storage.admin (value) values ("use 'http://nagiworld.net/yqldefs/yql/amazon.ecs.xml' as amazon.prodlist;
set AWSAccessKeyId='YOUR_KEY' on amazon.prodlist;
set secret='YOUR_SECRET' on amazon.prodlist;
set AssociateTag='YOUR_ASSOCIATE_TAG' on amazon.prodlist;")

The response contains the various keys such as execute, select and update.

<results>
<inserted>
<execute>store://h0L6f1ecl32llKITPZEbOg </execute>
<select>store://xGnPqWdslS..sqvoOYObn </select>
<update>store://tiJkslt0pE..QEecsQyQn5 </update>
</inserted>
</results>

Each element described in the response has specific properties.

Given that we have the execute key, we can now provide the execute key to the query parameter called ‘env’. This tells the YQL Servers to pull the data from the store and prepend it to your query before actually running it. So in essence YQL does a read through execution of the query.

http://developer.yahoo.com/yql/console?env=store://h0L6f1ecl32llKITPZEbOg

Once you pass in the env, you can issue the following query:

select * from amazon.prodlist where Title = 'panasonic' and SearchIndex="Electronics" and ResponseGroup='Images,ItemAttributes,SalesRank' and ItemLinks.ItemLink.Description='All Offers'

Try it in Console

As you can be seen, the above query does not expose any of the your secrets specifically the amazon id, secret and your associate tag. None of the diagnostics or the debug information leak your URLs which at this point could contain the various keys that you’d like to keep secret.

Selecting an execute key does not show the secrets you put into the query

select * from yql.storage where name='store://h0L6f1ecl32llKITPZEbOg'

Try in Console

As expected this returns the following and thus Mission Accomplished! Secrets safe

<results>
<error>No select permission or doesn't exist</error>
</results>

Picture licensed from nostri-imago under Creative Commons

use 'http://nagiworld.net/yqldefs/bit.ly.shorten.xml';
select * from bit.ly.shorten where login='nag...' and apiKey='....'
           and longUrl='http://cnn.com/'

This looks pretty easy but seems like a lot of work for a single URL to be shortened. Isn’t it? You can always go to the bit.ly site and do the same in a single click. right? Yes! Infact the reason for this table is to shorten multiple URLs in a single statement using a YQL sub-select i.e.

select * from bit.ly.shorten where login='nag...' and apiKey='...'
       and longUrl in ('http://cnn.com', 'http://yahoo.com')

The output of the query looks like the following. Only the results element is shown here for brevity. Given this data, I can project the necessary fields and get either the shortened url or other elements.

    <results>
        <bitly>
            <errorCode>0</errorCode>
            <errorMessage/>
            <results>
                <nodeKeyVal>
                    <userHash>xzV1m</userHash>
                    <shortKeywordUrl/>
                    <hash>31IqMl</hash>
                    <nodeKey><![CDATA[http://cnn.com/]]></nodeKey>
                    <shortUrl>http://bit.ly/xzV1m</shortUrl>
                </nodeKeyVal>
            </results>
            <statusCode>OK</statusCode>
        </bitly>
        <bitly>
            <errorCode>0</errorCode>
            <errorMessage/>
            <results>
                <nodeKeyVal>
                    <userHash>h4H0n</userHash>
                    <shortKeywordUrl/>
                    <hash>2deaFR</hash>
                    <nodeKey><![CDATA[http://yahoo.com]]></nodeKey>
                    <shortUrl>http://bit.ly/h4H0n</shortUrl>
                </nodeKeyVal>
            </results>
            <statusCode>OK</statusCode>
        </bitly>
    </results>

Better yet, take an entire html page, rss/atom feed or even a CSV file as an input containing all the URL’s to be shortened and zip it through YQL in a single statement. Now, Insn’t that something cool!

select * from bit.ly.shorten where login = 'nag..' and apiKey='...'
    and longUrl in (select link from rss where url='.....')

Note: Once you register with bit.ly, you can find the apiKey by going to the Account section.

This table is already checked into the YQL Open Table github repository. There are many other open data tables of use ranging from bit.ly to amazon to iplocation contributed by the community.

Lastly, if you’d like to contribute your awesome open data table you can checkout Fork me! YQL Open Tables!. This article gives an excellent overview of how to get your table into github.

Here’s the direct link to the YQL Execute Screencast on YDN. In the screencast, Sam Pullara gives an introduction to YQL Execute and I follow it up with a demo to show the power of this new feature.

For folks who prefer to read and follow the tutorial instead, here is the transcript of the entire demo along with the YQL queries as well as the Open Data Tables used to create the examples.

Let’s get started with a little review on Open Data Tables to set the stage.

Dynamic Tables Recap

YQL already provides dynamic tables which let you access data from many formats across the internet such as rss, atom, raw xml, json, csv or even html.

You can select xml directly from the yahoo local webservice.

select * from xml where url="http://local.yahooapis.com/LocalSearchService/V3/localSearch?appid=YahooDemo&query=pizza&zip=94306&results=2"

Try in YQL Console!

Behind the scenes, I read up the documentation on Local search and formed this query. Although this query returns the data from the remote service, you have the burden of constructing the URLs required. It also doesn’t give me the full power of YQL where I can use nested binary operators using the various query or path parameters. In essence you’d have to write all the code to collect the parameters and conditionally create the URL.

This issue can be easily resolved by using an open data table.

Open Data Tables

With an Open Data Table, we expose a way to bind YQL to your webservice with a single XML file. Let’s create an open data table for the local service

<?xml version="1.0" encoding="UTF-8"?>
<table xmlns="http://query.yahooapis.com/v1/schema/table.xsd">
    <meta>
        <author>Nagesh Susarla</author>
        <description>Yahoo! Local Data table</description>
        <documentationURL>http://developer.yahoo.com/search/local/V3/localSearch.html
        </documentationURL>
        <sampleQuery>select * from {table} where zip='94085' and query='pizza'</sampleQuery>
    </meta>
    <bindings>
        <select itemPath="ResultSet.Result" produces="XML">
            <urls>
                <url>http://local.yahooapis.com/LocalSearchService/V3/localSearch</url>
            </urls>
            <paging model="offset">
                <start id="start" default="1"/>
                <pagesize id="results" max="20"/>
            </paging>
            <inputs>
                <key id="zip" type="xs:string" paramType="query" required="true"/>
                <key id="query" type="xs:string" paramType="query" required="true"/>
                <key id="appid" type="xs:string" const="true" private="true" paramType="query"
                     default="YahooDemo"/>
            </inputs>
        </select>
    </bindings>
</table>

The open data table contains a root “table” element which contains a meta tag. The meta element describes metadata such as author, documentation url and a sample query for the table. The next element “bindings” contains one or more select blocks. This element describes how YQL should map to the webservice. Each select has the base URL followed by the various input keys that it supports. (Before writing the table I read up the documentation and listed the various query parameters here)

Once I have the open data table ready, I simply upload it to my website and access it in yql console by performig the following query.

use 'http://nagiworld.net/yqldefs/mylocal.search.xml' as mylocal;
select * from mylocal where query = 'pizza' and zip = 94085

Try in YQL Console!

I can even abitrarily nest the binary operators and YQL will do the work of creating the URLs and fetching the data.

use 'http://nagiworld.net/yqldefs/mylocal.search.xml' as mylocal;
select * from mylocal where query = 'pizza' and (zip = 94085 OR zip=94536)

Try in YQL Console!

This is an easy way to bring the power of YQL to disparate data sources.
With YQL Open Tables, you can take almost any publicly available Web service and make it available as a table for others to use.

Now, what if you wanted to augment or enhance the results of a webservice?

YQL Execute

YQL Execute, our newest feature, lets you enhance or shape the resulting data to suit your needs. You can use “YQL Execute” to mash together or join data from multiple services and return the resulting data.

Let’s say I got an idea to build the next killer app. The idea is called “Search Rank” and its requirements are as follows:

Inputs:
• Give me a topic to search for & such as “pizza”
• Give me link to rank such as “pizzahut”

Output: The App should return you the search rank of the link as seen by Yahoo Boss.

Let’s see what search.web already provides today. For this lets go to console and try the following query.

select * from search.web where query = 'pizza'

Try in YQL Console!

results …

<?xml version="1.0" encoding="UTF-8"?>
<query...>
    <diagnostics/>
    <results>
        <result xmlns="http://www.inktomi.com/">
            <abstract><![CDATA[Official site of Papa John's <b>pizza</b> delivery and carry-out chain. Includes store locator, nutritional info, and franchise and employment opportunities.]]></abstract>
            <clickurl>http://.......JWbks-/SIG=10u9f6tba/**http%3A//www.papajohns.com/</clickurl>
            <date>2009/05/02</date>
            <dispurl><![CDATA[www.<b>papajohns.com</b>]]></dispurl>
            <size>2237</size>
            <title>Papa John's</title>
            <url>http://www.papajohns.com/</url>
        </result>
	 </results>
</query>

You can see that the search results include a dispurl - which is the display URL. The only thing missing is the ranking. So lets write an Open data table to add a rank to each of these results.

<?xml version="1.0" encoding="UTF-8"?>
<table xmlns="http://query.yahooapis.com/v1/schema/table.xsd">
    <meta>
        <author>Nagesh Susarla</author>
        <documentationURL>My Search Rank</documentationURL>
    </meta>
    <bindings>
        <select itemPath="results.result" produces="XML">
            <urls>
                <url/>
            </urls>
            <inputs>
                <key id="query" type="xs:string" paramType="variable" required="true"/>
            </inputs>
            <execute><![CDATA[
                    var search = y.query('select * from search.web(100) where query=@query',
                     {query:query}).results;
                    var rank = 0;
                    //y.log("initing rank");
                    default xml namespace = 'http://www.inktomi.com/';
                    for each (var result in search.result) {
                        rank++;
                        //y.log("rank for " + rank);
                        result.rank += <rank>{rank}</rank>;
                    }
                    response.object = search;
            ]]></execute>
        </select>
    </bindings>
</table>

The only additional element in this open data table is the <execute> block. This is where you add the code to enhance or reshape or mashup your data.

Here we use an object called “y” which is implicitly provided by the engine. Among the various methods that it supports is the “query” method which lets me run a YQL query right from inside my execute.

Here, I’m simply wrapping the search api, I issue a search.web call and get the results. Since search already orders the results according to their popularity, all I need to do is add a <rank> element to each result. Also note that the rank is just the index of the unmodified search result. So I loop over each result and use E4X to add a new element to it. Finally I upload this to my website and issue the following query to try it in the console.

use 'http://nagiworld.net/yqldefs/searchrank.xml';
select * from searchrank where query='pizza' and dispurl like '%pizzahut%'

Try in YQL Console!

Result from console:

<?xml version="1.0" encoding="UTF-8"?>
<query>
    <diagnostics/>
    <results>
        <result xmlns="http://www.inktomi.com/">
            <abstract><![CDATA[Official site for Pizz Hut provides online ordering for dine-in and delivery, a <b>Pizza</b> Hut store finder, coupons, and menu.]]></abstract>
            <clickurl>http://..._ylc=X...**http%3A//www.pizzahut.com/</clickurl>
            <date>2009/05/02</date>
            <dispurl><![CDATA[www.<b>pizzahut.com</b>]]></dispurl>
            <size>14113</size>
            <title><![CDATA[<b>Pizza</b> Hut]]></title>
            <url>http://www.pizzahut.com/</url>
            <rank>4</rank>
        </result>
    </results>
</query>

Voila! and you have the ranking of the particular element. Now I only have to wrap this in a nice UI and I have a killer app which does searchranking using YQL.

Here is the final product using some YUI goodness to wrap the YQL calls: SearchRank

Useful links on YQL Execute:

• Select * from Internet and Execute With YQL
• YQL Execute Docs
• DataTables.org: Community site for data tables and a pointer to the best examples on YQL Execute
• github repository: Open Data Table repository

Open Hack Day was an awesome event. It was very well organized and provided the ideal medium for hackers to put forth their ideas. Among the hackers, there was a lot of energy, enthusiasm and the will to do something innovative. I had the pleasure of meeting with a lot of the hackers and also helping answer their challenging questions on YQL and OAuth in anyway I could.

Being a developer of YQL, it was obviously very fulfilling to see YQL being used extensively by the hackers. After the electrifying weekend at hackday, I’m back at work building some cool YQL features.

Read more about hackday from the blog post on YDN by Chris Heilmann aptly named “We came, we hacked, we picked winners - Open Hack Day Bangalore was a blast”

Here are the slides from my YQL talk at OpenHackDay ‘09

YQL Queries FAQ:

YQL provides tables which let you access the social profiles, connections, contacts as well as updates of a Yahoo User. The actual apis around which YQL builds can be found at http://developer.yahoo.com/social/. A compilation of questions and answers on the various social tables provided by YQL are listed below. More specifically, this post deals with questions about how to get the necessary data (guids) which can then be used for querying the social tables.

• Whats with a GUID being used in many Yahoo webservices?

A guid is a unique identifier which is NOT the YAHOO ID. Even though your yahoo id is unique, the guid is different and it looks pretty cryptic - example HEMOFFCCOH3MJ5HYPYQQQPI. I do agree that many users have very cryptic yahoo ids; what with all their birthdays and their birth city zipcodes and their lucky numbers right in the id, but the guid is just more uniformly cryptic and unique )

• How do I get my guid? Do i have to remember and type it in for each table that requires it?

YQL has already done this for you with the identifier me. It can be used anywhere your guid would appear. Just remember to drop the quotes and directly use the identifier me.

select * from social.profile where guid = me

• How do I get a guid from a yahoo id?

YQL provides the yahoo.identity table which has a one-way mapping between a yahoo-id (yid) and a guid. Currently there is no way to get a yahoo id from a guid. This is prevent any possibility of spam that could have arisen from your Yahoo Id being exposed by such a service.

Given a yahoo id (yid), you can get back the guid by running the following query:

select guid from yahoo.identity where yid = ‘tom’

• Is there a way to query the social.profile table with a yahoo id instead of a guid?

Yes! You can use a “IN” subselect query to find a the social profile given only a yahoo id

select * from social.profile where guid in (select guid from yahoo.identity where yid=’tom’)

• How do I list out all the profiles of my connections?

As listed in one of YQL’s examples you can run the following query which first gets all the guids of your connections (friends) from social.connections and then fetches the profiles of each of the guids.

select * from social.profile where guid in (select guid from social.connections where owner_guid = me)

• Only 10 of my connections show up when querying social.connections but I’d like to see all of them.

To see all your connections, one needs to use an unbounded query listed in the documentation here. The following query returns all the connections. By specifying the (0), you’re telling YQL to do all the necessary paging.

select * from social.connections(0) where owner_guid = me

Similarly you can use the social.contacts table to fetch a guid’s contacts.

Note: To view a guid’s profile or connections, you need explicit access from the guid. This is accomplished via 3 legged oauth. Unless the guid is your connection, you may not be able to see their profile in the yql console.

If you have more specific questions, let me know in the comments and I’ll do my best to answer them.

Motivation:

With two-legged OAuth, there are only two parties involved i.e. the consumer of the api and the service provider. It doesn’t deal with user credentials or other private data that come into the picture with three-Legged OAuth. YQL is one of the services which uses OAuth exclusively for all webservice access. (apart from the console)

Two-Legged OAuth requires a user to sign the request in a spec mandated way and this implies that using a service such as Yahoo! Pipes to fetch non private data from YQL wasnt possible.

Requirements:

1. The service should ask for everything it needs and respond with the result of the backend service. Simply put, the service must act as a proxy. Take in the Consumer Key, Consumer Secret and the YQL query, do the necessary signing and return the response.
2. What if I do not want to expose my consumer key/secret for the fear of it being compromised? This brings up a requirement that there should be a way to mask the Key and Secret. This is accomplished today by explicit registration. The user is asked to register their Consumer Key and Secret with the service and in return they get an appId which is URI friendly.
3. AppId should be disposable. If an AppId is compromised, it should be possible to regenerate a new one which inturn uses the same underlying key/secret pair. (Note that I still want the underlying Consumer Key and Secret to be the same for many track-ability reasons and relationship with the service provider)

Implementation:

I deployed on Google App Engine (for lack of a platform that runs Java on the cloud!) and picked up a bit of python along the way. I must say that GAE’s been pretty easy to pick up and use. Finally the service exposes two main endpoints

• Executes a query given the following parameters (http://oauthify.appspot.com/yqlQuery)
  • Scenario 1: http://oauthify.appspot.com/yqlQuery?ckey=aghvYXV0aGlmeXIOCxIIVXNlcklhZm8YBgw&csecret=PQ&q=show%20tables
    • ckey - Consumer Key (required)
    • csecret - Consumer Secret (required)
    • q - YQL Query (defaults to show tables)
    • format - xml or json (passed to the backend) (defaults to XML)
  • Scenario 2: http://oauthify.appspot.com/yqlQuery?appId=aghvYXV0aGlmeXIOCxIIVXNlcklhZm8YBgw&q=show%20tables
    • appId - App Id provided by the service. (Also see the next endpoint)
    • q - YQL Query
    • format - (same as above)
    • Note that the prequel to this Scenario is that the user gets the appId by registration.

• Register the Consumer Key and Secret to get an appId (http://oauthify.appspot.com/register)
  • Requires a user to Login (using a google account). This is to protect the user’s Key and Secret.
  • Provides a way to store CK and CS
  • Provides a way to see all previously stored Keys and to regenerate AppIds as needed.

Finally:

Was the Goal of running 2 Legged YQL in Pipes accomplished? Yes! check out http://pipes.yahoo.com/nageshs/yqlquery which uses a PrivateString fields to use CS and CK from Scenario 1 above and last but not the least http://pipes.yahoo.com/nageshs/yqlquerymodule which uses an AppId from the web service. Here is a screen shot of the Pipe. I’m not in the least worried about sharing my AppId, since OAuthify will let me regenerate it any time I like

Enjoy & Curl your YQL queries today!

Update 1: Thanks to Sam, OAuthify is now accessible via the rightly named domain http://OAuthProxy.com

I was involved in creating YQL and was responsible for leading the query engine implementation. I am very pleased to see it being released to the public today. Check out Jonathan’s talk which gives a great overview of YQL. (Jonathan’s posted about the YQL Launch here)

YQL adds the simplicity and self describable nature of SQL to the Web. In addition to this, you can also join disparate webservices with common keys. For example Yahoo’s “guid” can be used to join many common webservices which are keyed on “guid”s.

The basic goals that we had in mind while designing YQL are as follows:

• Ease of use - SQLish syntax lowers the barrier to entry since its very popular with developers everywhere.
• Self describing - desc <table>, show tables (the beauty of SQL lies in its simplicity and self describing nature and we wanted to piggy back on these fundamentals)
• Data Access Options - With YQL you can access both Yahoo’s webservices as well the Web’s data (with tables such as RSS, ATOM, FEED and XML). We also support external webservices to stress on the ‘O’ in YOS (Open)
• Extensible - (Still in the works but we intend to make it easy to extend the list of supported tables)
• Best Effort - In the Web world we realise that disparate services have different strengths and weaknesses. Keeping this in mind, YQL employs a “best effort” query fulfillment strategy with warning/error messages as necessary (in the diagnostics section of the response)

Please try out the console at “http://developer.yahoo.com/yql/console” and provide your feedback here. As with all 1.0 stuff, please bear in mind we still have a lot of work to do and wrinkles to iron out.

Kudos to the rest of the YQL team - Brad, Josh, Paul, Sam and Jonathan.

Happy Diwali

“Find me the java packages in classpath ‘X’ which are already present in ‘Y’”
where X = Classpath of an application;
and Y = System Classpath or some other classpath

I wrote a small command line utility which answers this question and groks the list of duplicate patterns. For WebLogic Server users, this tool finds the duplicate packages and also emits some xml which can be pasted into ‘META-INF/weblogic-application.xml’ to ensure that the version in the application always wins.

Here’s the usage:

~/code$ java -jar ./utils/dist/dupPkgfinder.jar
Usage: net.nagiworld.utils.DupPackageFinder
      -appclasspath [String] Application Classpath
      -parentclasspath [String] Classpath to compare against
      -advice [flag] Emit Advice for use with WebLogic Server
      -verbose [flag] Show me what's going on

Example: Lets say I have a webapp which uses a specific version of log4j.jar. Since WebLogic already packages a version of log4j.jar in its System Classpath, using a different version requires an explicit descriptor element.

Given that the jar is in WEB-INF/lib, I ask the tool to help me out:

~/code/utils/test$ java -jar ../dist/dupPkgfinder.jar
-parentclasspath $CLASSPATH -appclasspath './WEB-INF/lib/*'
-advice

Duplicate Packages:
org/apache/log4j
org/apache/log4j/chainsaw
org/apache/log4j/config
org/apache/log4j/helpers
org/apache/log4j/jdbc
org/apache/log4j/jmx
org/apache/log4j/lf5
org/apache/log4j/lf5/util
org/apache/log4j/lf5/viewer
org/apache/log4j/lf5/viewer/categoryexplorer
org/apache/log4j/lf5/viewer/configure
org/apache/log4j/net
org/apache/log4j/nt
org/apache/log4j/or
org/apache/log4j/or/jms
org/apache/log4j/or/sax
org/apache/log4j/spi
org/apache/log4j/varia
org/apache/log4j/xml

Recommendation: Add the following snippet to 'META-INF/weblogic-application.xml'.

<prefer-application-packages>
<package-name>org.apache.log4j.*</package-name>
</prefer-application-packages>

If you’re familiar with FilteringClassLoader, then this tool is an excellent aid to creating the filter patterns that should be added to the weblogic-application.xml descriptor. See http://edocs.bea.com/wls/docs92/programming/classloading.html for more details on FilteringClassLoader.

NOTE: Duplicate packages in your application does not necessarily imply that FilteringClassLoader be used. Often times unused jars also end up in WEB-INF/lib

This tool is a thin wrapper our DepHandler from jarjar. In addition to that it also depends on cli-parser which is used for command line parsing. (using cool annotations!). The tool supports wildcards thanks to the jarjarlinks support for wildcards.

You can download the tool here - dupPkgFinder.jar

Enjoy! Please do share your comments and any other cool uses/improvements for the tool

JavaPolis ‘06 was held in Antwerp, Belgium from Dec 11th through 15th. It had all the elements of a perfect developer conference - Beer, geeks, frites and more geeks. Our bea booth had Lafe on tap which made it a lot easier to talk about very deep and serious topics
Thanks to the JavaPolis organizers for making the talk available online. It’s easily one of the best java conferences I’ve ever been too. Unconventional and original! is how I’d summarize the conference in two words.