Ruby may not need XML, but XML sure benefits from Ruby!

In this talk we'll tour XML processing in Ruby:

• REXML
• Builder (used by Rails to emit XML)
• Stream parsing
• Pull parsing
• Tree parsing
• XPath

We'll conclude by metaprogramming Ruby to generate Ruby objects from XML domain vocabularies. Ruby's dynamic features make XML data binding a snap.

Have fun automating your builds and deployment!

Ruby rake has everything you need to automate your builds: In this talk we'll look at Rake's take on common build metaphors:

• Dependencies
• Tasks
• File management
• Automated tests
• Generating documentation

Then, we'll drill into what makes Rake special: Because Rake is a domain-specific language (DSL) built from Ruby, you have all the power of Ruby at your fingertips. This is a vast improvement over custom syntax (e.g. makefile) or tedious XML (Ant).

We'll look at a series of examples from a Rails application rakefile that demonstrate how Ruby code mixes seamlessly with Rake syntax to produce clean, simple, beautiful builds.

We'll conclude by looking at RubyGems, which is the de facto packaging system for Ruby libraries. We'll cover installing Gems, referencing Gems from your own Ruby programs, and packaging your own code as a Gem.

Java has always provided a model for concurrency and threads. With Java 1.5, this model received a major facelift. Learn how to use the new concurrency utilities to build responsive, scalable, and correct concurrent applications.

Java's support for threads is broad and deep. From the early days of the platform, programmers have used threads, synchronized blocks, and monitors to build safe multi-threaded applications. Java 1.5's new concurrency utilities greatly reduce the need to use these primitives directly. Now, Java provides a set of lock classes and task scheduling tools that provide much more leverage in writing real applications. We'll explore java.util.concurrent, and also see how the Java Memory Model has been corrected in 1.5.

Most of the advantages of java.util.concurrent can also be had in previous version of Java. We'll discuss Doug Lea's concurrency utilities and the backport of java.util.concurrent to 1.4. Both of these are appropriate for production use.

Finally, we'll look at common mistakes in multi-threaded programming. The most common mistake is using threads when you don't need them. We'll look at alternatives to threads, and how to choose between them.

Using the Action WebService pack that ships with Rails, you can rapidly create robust web services with the same productivity you see when developing classic web applications with Rails.

The integration of ActiveRecord as an ORM framework, plus Builders for rapidly generating XML documents, provides for rapid deployment of standard services. Add on Ruby's powerful metaprogramming strategies, and you can quickly and easily build a library of filters and interceptors to provide services like encryption, digital signatures, routing, etc. that enable your business rules.

For centuries people have used crypto to build (and break) secure systems. Computers have only raised the pitch of conflict, providing enormous cryptographic power at commodity prices. Most programmers do not write their own crypto libraries, instead relying on the services of an operating system or virtual machine. But even with all this support, building secure systems is a daunting task.

This talk will cover three things all programmers need to know: 1. the basic tools of computer crypto 2. the programmatic APIs to these tools 3. common programming mistakes that can undermine otherwise secure systems You will learn the basics of hashing, message digests, public key encryption, symmetric key encryption, certificates, and key management. With each, you will see programmatic examples, with advice for correct usage.

The Java platform is built from the ground up with security in mind. This talk will introduce the security features of the J2SE, building quickly from the basic classes to realistic examples.

You will learn the core APIs:

SecurityManager, AccessController, Permissions and Policy

JAAS Subjects, Principals, and LoginModules

You will then see how to invoke these APIs in real application scenarios. You will learn how to:

Partition your applications to safely invoke downloaded code

Read and write Java policy files

Extend the architecture with custom permissions

Provide secure services through PrivilegedActions

Use JAAS to authenticate and authorize users