I recently was tasked with creating a Firefox add-on or extension for a client and here are some of the things I wish I had known before I began. XML User Interface Language (XUL) pronounced “zool” is the programming language created by Mozilla used to create Firefox extensions and cross platform applications. It is a language similar to DHTML allowing someone with DHTML experience to quickly learn XUL. So far my experience with XUL has been a pleasant one. Please support the XUL community and leave comments with your experience with XUL.

Tips for development

XUL files can be opened in Firefox making it much easier to quickly view the changes you make to your code. Use the Error Console in Firefox to view error messages your XUL code may produce which can be found under the Firefox Tools menu. The Extension Developer has a nice “reload all chrome” option, but it closes all the web sites you currently have open and crashed Firefox on my computer if I had Gmail open.

XUL tools

Spket IDE is the best IDE for editing XUL I was able to find and is based on the Eclipse IDE.
Extension Developer is a Firefox add-on for building extensions.
Firebug is an awesome Firefox add-on for debugging web pages.
XUL Explorer is a nice little application to help you get started with XUL development

Resources

Mozilla Developer Center is the official web site for XUL with documentation.

Born Geek contains several great tutorials.

XUL Periodic Table has a nice web page containing most of the user interface components with source code.

XUL Planet is the unofficial web site for XUL with documentation.

I had the pleasure of attending the Semantic Web Technologies RDF and OWL workshop with Bob DuCharme at the UVA New Horizons Conference. Bob is a well respected contributor in the semantic web community and has written several books related to the topic. After attending this workshop I feel like I finally grasped the concepts of the semantic web technologies. Bob did a great job of explaining the different technologies in a way that a technical person could easily understand.

The workshop began with a discussion of Resource Description Framework (RDF), which is a means to store metadata about resources. A resource can be anything from an audio (mp3, wma, wav), video(wmv, mov, mpg), e-book, etc. The metadata can be stored within the actual file or in a separate linked location. The metadata is made up of a simple data structure containing a subject, predicate and object. Personally I am not fond of these terms as they are a bit confusing and I find the best way to describe them is with an example from Wikipedia.

<rdf:RDF
  xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#”
  xmlns:dc=“http://purl.org/dc/elements/1.1/”>
     <rdf:Description rdf:about=“http://en.wikipedia.org/wiki/Tony_Benn”>
        <dc:title>Tony Benn</dc:title>
     </rdf:Description>
</rdf:RDF>

The RDF code above can be parsed into the following triplet:

Which in plain English translates into, “The title of this resource, which is published by Wikipedia, is ‘Tony Benn’”. Now we could add several more tags to this example similar to the “dc:title” tag to describe many aspects of the object such as publisher, contributor, etc.

RDF can be assigned to a resource in several different ways and using different syntax. For example, Notation 3 is a syntax for defining RDF in a readable format without the use of XML. RDF can be embedded in HTML as well to define resources within a web page. Several popular web sites currently embed RDF in their web pages including www.wikipedia.org and www.digg.com.

Bob also discussed another web semantics technology referred to as Web Ontology Language (OWL). OWL is an extension of RDF Schema which is a common set of terms defined to describe a domain (A domain being something such as music, psychology or biology). Which basically means an agreed upon list of terms to be used to describe something. The Dublin Core is commonly used to describe video, sound, image and text with several metadata elements or “terms”.

Another technology discussed during the workshop was SPARQL Protocol and RDF Query Language (SPARQL) which is the query language used with RDF. If you think of RDF as a huge database available on web, SPARQL would be the SQL language used to query the database. It was with this thought during the workshop that I realized the remarkable potential these semantic web technologies possessed. Now imagine all these RDF “databases” are linked together and you can query all of them at once. DBpedia is a project designed to do just that by extracting information from Wikipedia, making the information available on the Web and linking to other data sets such as MusicBrainz.

This past Thursday, May 8th I had the privilege to attend a presentation at the Library of Congress by Alistair Miles, key developer of SKOS, and semantic web practitioner at the University of Oxford. The presentation was held at the Library of Congress because they are very interested in using this emerging technology for their catalog. SKOS is very close to becoming the W3C standard for publishing thesauri, classification schemes and subject headings as linked data in the Web. SKOS is built upon Resource Description Framework (RDF) and its main objective is to enable easy publication of controlled structured vocabularies for the Semantic Web. SKOS was developed to provide a more simplified alternative to OWL.

Alistair started out the presentation by demonstrating the value of HTML links and how they have made web pages and the Internet more accessible. He then described SKOS as the standard means of linking data across the Internet. SKOS has concepts of a label, alternate labels, notes, broader and narrower where the label is the title, alternate labels are different spellings, notes are a description and broader and narrower attributes are used to link to related concepts.

RDF was developed as a means to declare metadata of resources in a standard way. An RDF description of a resource contains a subject, predicate and object where the subject is the title of the resource, the predicate is the type of resource, and the object can be data or another resource. RDF is basically a standard XML schema for defining resources such as music, books, articles, etc. For an example take a look at the following from Dublin Core. An example of using RDF in an XHTML file is as follows:

  <p class="contactinfo" about="http://example.org/staff/jo">
    <span property=”contact:fn”>Jo Smith</span>.
    <span property=”contact:title”>Web hacker</span>
    at
    <a rel=”contact:org” href=”http://example.org”>
      Example.org
    </a>.
    You can contact me
    <a rel=”contact:email” href=”mailto:jo@example.org”>
      via email
    </a>.
  </p>

This example contains several attributes with the word “contact” in it. Each attribute defines a piece of the contact information, for example, the attribute contact:fn defines the contacts first name.

If you have a need for linking data in your web applications take a closer look at the technologies above for use in your application.

I attended the Continuous Integration and Testing Conference (CITCON) in Denver Colorado last weekend and I have to say that I was impressed by the effectiveness of the the OpenSpace conference format. The following are highlights from the sessions I attended:

What is Continuous Integration? What should be including in Continuous Integration 2.0?

This session was focused on an introduction of continuous integration and a discussion on what should be included in the next version. The following contains a few bullet points of what was discussed at the session:

• Modularize the code to create smaller faster tests and quicker builds
• Source control packages should provide an option to enable automatic updates on commit
• Source control packages should verify build is green before allowing a commit to the code
  
• Commit frequently to shorten the feedback cycle to discover errors or problems quickly
• A good roll back process can eliminate downtime when a build is broken

How to make builds faster?

A person responsible for the builds at a company has run into the problem with large build times on their project. They were looking for ways in which they could reduce the time for the build. The ideas that were suggested for reducing the time of the build were as follows:

• A common practice is to restart the application server after a successful build to setup for the next build.
• Modularize the build so that only the modified code may be built and not the whole project. Maven has a built in method for modularizing the code.
  
• Add or upgrade the build server hardware. The build server should have as good of hardware as the developers hardware.
• Implement a distributed computing model to offload the build onto multiple machines
  
• Analyze the build to determine which part of it is inefficient and determine if the increase in build time is justified, specifically related to tests
  
• Tests are a common culprit in extending build times
• Break tests up into unit, function, integration and system tests. Consider only running each type of tests when it is appropriate
• Assign a member of the team to monitor the build time using metrics to determine if the build has exceeded the set metrics and analyze the change made to determine if the build time increase is acceptable.

Test data setup techniques

A participant of the conference was interested in discovering the different ways people setup data when they run their tests. The following items were discussed at the session:

• Add code to the tests that will add data and later remove the data when the tests have completed. This solution can slow down the build and does not allow the tests to be run independently.
• Write a script to duplicate the production database with minimal or no data and run update scripts on the newly created database. This gives you a clean database to start testing the application.
  
• Maintain scripts to create the database with minimal or no data and run update scripts on the newly created database.

I attended the Continuous Integration and Testing Conference (CITCON) in Denver Colorado this past weekend and experienced first hand the OpenSpace conference format. I was skeptical about the concept of the OpenSpace conference format because it just did not seem structured enough. It turns out I was pleasantly surprised by the amount of real world practical knowledge I received at the conference. For those of you who are not familiar with the OpenSpace conference format I will provide a quick description.

The conference begins with introductions and an overview of the conference. Next all parties attending the conference are invited to propose a topic that they are interested in learning more about or information they would like to share. The attendees then vote on the proposed topics and the topics with the most votes are assigned to a session. Each session is a discussion by all members of the session participants of the topic at hand. The OpenSpace conference format abides by the “law of two feet”, meaning if you are not getting what you like out of the session you are obligated to use your two feet and move onto another session.

This format is different in that anyone can present, propose and discuss information at each session. The sessions become a discussion of the topic by peers rather than a power point presentation from an “expert”. You get a real world perspective on what is and is not working for your peers. Often the sessions turns into a debate on the benefits and drawbacks of a specific framework, technology or software package. I learned quite a bit at the CITCON conference and I feel it is largely due to the OpenSpace conference format.

If you are not already aware the long over due awaited Windows Vista SP1 is available for download at: Download Windows Vista SP1. As a long time Windows user I vowed not to upgrade my home desktop computer to Vista before Service Pack 1 became available (From what I have heard the upgrade to Leopard is no picnic either). However, upon employment with Opensource Connections I jumped at the chance to try out Vista with the purchase of my new work laptop. Thus far I have been pleased with Windows Vista and have only experienced a few minor software crashes. I have to mention that my favorite new feature is the “Instant Search” functionality. This feature allows you to press the Start key on your keyboard and begin typing the name of the program or file you wish to open and it magically appears. I never realized how inefficient the start menu was until I started using this feature.

(more…)