Mark Volkmann

Presentations

Ruby Plays Well With Others

Developing applications entirely in Ruby isn't always practical. It may be desirable to utilize existing code written in other languages. Also, implementing some functionality in Ruby may not yield sufficient performance. When these situations arise, Ruby can invoke code written in Java or C.

The easiest way to invoke Java code from Ruby is to use JRuby (http://jruby.codehaus.org/). JRuby is maturing rapidly now that Sun is financing much of its development.

C code can be invoked from Ruby by using wrapper code that is generated using SWIG (http://www.swig.org/) or written manually.

This talk will provide and overview of JRuby. It will also cover the details of writing C wrapper code manually, which provides the greatest flexibility and performance.

Google Web Toolkit (GWT)

This talk introduces the GWT, an open-source, Java-based framework for creating Ajax web applications.

GWT makes writing web applications similar to Swing applications. It dramatically reduces the need to understand HTML and JavaScript, while retaining the use of CSS for formatting. We'll cover the advantages of using GWT over other web app. frameworks and walk through the steps to create a new application. An application will be written before your eyes to demonstrate how easy it is.

Implementing Languages with ANTLR 3

ANTLR 3 (http://antlr.org) is a Java-based tool that generates language parsers in a variety of programming languages including Java. This talk will walk through implementation of a domain-specific language (DSL) using ANTLR.

ANTLR differs from most other parser generators in that it supports unlimited lookahead to select between grammar rule alternatives.

While languages such a Ruby and Groovy can also be used to implement DSLs, they bring with them the baggage of their own syntax rules. ANTLR allows you to make the syntax of your DSL be exactly what you want to be.

We'll start with lexer rules to break a character stream into tokens, write parser rules that build an abstract syntax tree, and write tree parser rules that walk the AST and execute the code that was fed to the lexer.

We'll also demonstrate use of ANTLRWorks which is a free graphical editor and debugger for ANTLR grammars. It is particularly useful in stepping through the construction of ASTs.

After attending this talk you'll be ready to begin using ANTLR to implement your own languages.

ANTLR differs from most other parser generators in that it supports unlimited lookahead to select between grammar rule alternatives.

While languages such a Ruby and Groovy can also be used to implement DSLs, they bring with them the baggage of their own syntax rules. ANTLR allows you to make the syntax of your DSL be exactly what you want to be.

We'll start with lexer rules to break a character stream into tokens, write parser rules that build an abstract syntax tree, and write tree parser rules that walk the AST and execute the code that was fed to the lexer.

We'll also demonstrate use of ANTLRWorks which is a free graphical editor and debugger for ANTLR grammars. It is particularly useful in stepping through the construction of ASTs.

After attending this talk you'll be ready to begin using ANTLR to implement your own languages.

Writing XML From Java

Love XML or hate it, sometimes Java applications need to output XML. This talk presents two Java libraries for writing XML, XStream and WAX, that make it really simple! In addition, WAX is very memory efficient, making it ideal for writing large XML documents.

See http://ociweb.com/wax and http://xstream.codehaus.org.

The first library covered is XStream, an open source library for serializing Java objects to and from XML. Compared to Castor, another similar library, it is simpler and requires less configuration. The second library covered is Writing API for XML (WAX). WAX is a new approach to writing XML that

• requires less code than most other approaches
• uses less memory than other approaches
• is a small library (around 12K)
• doesn't depend on any Java classes other than standard JDK classes
• writes all XML node types
• provides extensive error checking
• automatically escapes special characters in text and attribute values when error checking is turned on
• allows all error checking to be turned off for performance
• knows how to associate DTDs, XML Schemas and XSLT stylesheets with the XML it outputs
• is well-suited for writing XML request and response messages for REST-based and SOAP-based services

Software Transactional Memory

Writing software applications in which parts of the application run in different, concurrently running threads introduces many challenges not present in single-threaded applications. Since the order of operations isn't fixed, failures can be difficult to repeat and thoroughly testing the software is more difficult.

There are many models for creating concurrent software that have been implemented in a variety of programming languages. Arguably the most popular models today are based on locks, actors and transactional memory. This talk briefly describes all three models, including their pros and cons. It then dives deeper into software-based transactional memory (STM). The talk ends with a detailed look at a specific STM implementation, that provided by the Clojure programming language.

Attendees will gain a better understanding of the options available for creating multithreaded software applications and gain a clear understanding of the characteristics of STM. This knowledge will aid software developers in making decisions about programming for concurrency regardless of the programming language being used.