"The central enemy of reliability is complexity." (Dr. Daniel Geer)

Java is a powerful programming language. A smart developer can do nearly anything with Java. So the next question is, "How quickly can it be done? How many lines of code does it take to do common tasks?" Groovy greases the wheels of Java by decreasing the complexity of the language while preserving the raw power. At first glance, you might think that this talk is simply about how Groovy drastically reduces the lines of code you need to write. What this talk is really about is bringing simplicity, clarity, readability, and yes, beauty to your source code.

In this talk, you'll see common problems presented in Java and the corresponding solutions in Groovy. From something as simple as defining a JavaBean up through File I/O, XML, networking, and database interaction, Groovy offers identical capabilities in a fraction of the lines of code.

"XML is like violence: if it doesn't solve your problem, you aren't using enough of it." (Anonymous)

XML is everywhere. Whether you are dealing with local configuration files (web.xml, struts-config.xml) or remote web services (SOAP, REST, RSS, Atom), the modern software developer needs to be able to request, slice, and dice XML with ease. That requires a set of razor-sharp tools that reduce the inherent complexity of the problem, not multiply it. Once you see XML tremble in fear at the awesome power of Groovy, you'll wonder what you ever did without it.

In this talk, we look at various Groovy tools to create, parse, and export XML. To read in XML, we'll explore the XmlSlurper and the XmlParser. To write out XML, we'll use the MarkupBuilder, StreamingMarkupBuilder, and the XmlNodePrinter. We'll go beyond simple Plain Old XML (POX) and demonstrate using namespaces, CDATA blocks, and more.

"Simplicity is the ultimate sophistication." (Leonardo da Vinci)

The history of computer programming has been bridging the gap between what the user says ("We need to add sales tax to each item in the order") and what the programming language requires you to say ("for Iterator i = orderList.iterator();"). Building Domain Specific Languages (DSLs) allow you to express the solution in the language of the domain user instead of the language of the programmer.

DSLs can be written in any programming language, but the more flexible the programming language used, the closer to plain English the DSL can be. Groovy is a dynamic language for the Java platform that is ideally suited for creating DSLs. Come see how Groovy can leverage the power of Java in a way that your users might actually be able to read and understand.

"There's an old story about the person who wished his computer were as easy to use as his telephone. That wish has come true, since I no longer know how to use my telephone." (Bjarne Stroustrup)

The "lizard brain" is the oldest part of the human brain -- the part responsible for autonomic functions like breathing, heart rate, and navigating websites. OK, maybe not that last part, but your website should be easy to use. Stupid easy. Lizard brain easy. Any time your user spends figuring out how to do something -- even for a split second -- is wasted time due to poor design. Inspired by Steve Krug's book "Don't Make Me Think", this talk answers the question, "Why is that website so hard to use?"

In this talk, we look at what make a "good" website "good". Simple changes in the layout or sort order can yield drastic improvements. We'll get inside the heads of typical users and see how their view of our website is drastically different than what we painstakingly planned out. You'll learn how to cater to "Browsers" and "Searchers" -- the human kind, not the software kind. "Lizard Brain Web Design" answers these questions and more in a funny and informative way.

"The challenge of modernity is to live without illusions and without becoming disillusioned." (Antonio Gramsci)

There are plenty of sarcastic "Web 2.0" checklists out there -- be perpetually in BETA, when in doubt add rounded corners, etc. While we can all laugh at the superficial aspects of the Web 2.0 revolution, there are plenty of serious aspects to it as well. Is your website mash-up friendly or hostile? Do you tell your visitors when things change (via RSS or Atom syndication), or do you expect them to check in daily for updates? Is your website a silo or a part of a larger ecosystem?

In this talk, we discuss what makes a "modern shiny Web 2.0" website look the way it does. But we go beyond simple look and feel as we catalog the common features in modern websites and show you how to implement them yourself.

"The proof of the pudding is in the eating. By a small sample we may judge of the whole piece." (Miguel de Cervantes Saavedra)

Most Grails tutorials demonstrate how easy it is to build simple CRUD (Create/Retrieve/Update/Delete) applications. While skinning a database with a web front-end is undeniably one beneficial aspect of Grails, it isn't the only thing Grails is good for. As you'll see here, Grails can be used to build a wide variety of web applications. You won't see a single HTML table with "edit" and "delete" links, I promise.

In this talk, we look at a variety of Grails applications that go beyond the simple CRUD metaphor -- blogs, wikis, maps, portals, and more.