Paul King

Presentations

XML and Web Services with Groovy

Groovy provides excellent facilities for parsing and creating XML. As well as providing syntactic sugar on top of traditional Java-based parsing approaches (e.g. SAX, DOM, StAX), it has its own XmlParser and XmlSlurper libraries which support XPath-like expressions at the object level (akin to LINQ in the .Net world). In addition, Groovy's markup builders provide an elegant and efficient way to create and modify XML. Groovy also has various options available for SOAP and RESTful web services. We'll examine the most popular of these.

We'll cover: * Reading, creating and updating XML using various approaches including the pros and cons of the various parsers and markup builders * dealing with XML namespaces and XPath * using other XML frameworks: XOM, Dom4j, JDom * integrating with XSLT, XQuery and validators * treating non-XML like XML * GroovySOAP, GroovyWS and Spring web services * JAXB, XmlBeans, CXF and Axis2 for SOAP web services * XML-RPC and RESTful options, RSS, ATOM * trade-offs using Apache Xerces or with native XML support on 1.4 through to 1.7 JVMs * Testing Web services with SoapUI * A quick look at Groovy integration in common XML/web-service tools * Groovy use in web service related products including ESBs and SOA frameworks

Agile Tools - Taking Your Agile Practices To The Next Level

Tools and practices as subscribed by the XP methodology are reasonably well known and used by the majority of agile project teams. As agile teams become more mature, so does their thirst for tools to push them to the next level of productivity.

In this talk, we will walk through a number of project tools used by some teams we work with. In some cases, we will explain how we hacked tools that you may already be using to make them more efficient or useful. In other cases, we’ll describe new tools designed by teams we have been working with who are trying to move to the next level.

• Lightweight storycard tools - Hacking tools like Jira + GreenHopper and XPlanner
• Collaboration tools - getting the most from tools like Confluence and Sharepoint
• Continuous Integration tools - using Hudson for build and environment management, using Scoreboard for visual and audible monitoring
• Testing tools - using WebTest, Groovy and DSLs to take testing to the next level
• Development Environments - testing your development environment, keeping development environments consistent, scripting your machine builds
• Deployment tools - using tools such as Tableaux, testing your deployment scripts
• Development tools - hacking your IDE, plugins, visualising your version control system
• Monitoring tools - live dashboards for better understanding characteristics of your production systems in real time
• Tools backlash - examples where computerised tools failed us and we reverted to other means

Experiences from Agile Projects Great and Small

Over the last five years we have been relentlessly applying Agile practices on a number of projects, great and small, with decent success. These successes, however, have not been achieved without challenges and lessons learned along the way.

This report identifies some of the important practices we have learned and specifically highlights examples from a number of different software development projects of varying sizes within this period and within the same organization. Main highlights of the talk are discussions about Team Practices, Developer Practices, Project Characteristics, Equipment, Tools and Facilities, People and Roles and Organizational change.

Groovy and Concurrency

This talk looks at using Groovy for multi-threaded, concurrent and grid computing. It covers everything from using processes, multiple threads, the concurrency libraries ear-marked for Java 7, functional programming, actors including GPars, as well as map/reduce, grid and cloud computing frameworks.

We'll look at leveraging Java techniques as well as Groovy specific approaches:

• Multiple Processes with Ant, Java and Groovy
• Multiple threads - Java and Groovy support
• The java.util.concurrent APIs, Fork/Join, Atomicity and more
• Useful Java libraries: Google collections and others
• Actor/Dataflow libraries: Jetlang, GPars
• Polyglot solutions with Scala and Clojure
• Grid computing and cloud solutions
• Testing multi-threaded programs

Groovy Scripting on the JVM

Groovy is a dynamic language for the JVM; it’s like a super version of Java. For Java programmers, it offers a syntax that closely resembles (in some cases exactly resembles) Java, but offers many improvements that not only greatly simplify code but also provide an enriched environment with many productivity features. In many cases, such features are promised in Java versions 7, 8 or up, but they are available today in Groovy.

This workshop will introduce attendees to Groovy, cover writing their first programs, run through a whirlwind tour of the basic language features, including data types, regex handling, XML processing, databases, graphics, file processing, build tasks, using Closures, testing and more.

The tutorial will also talk about the pros and cons of using Groovy, available tool support, great ways to introduce Groovy intro your project, what practices may change if you adopt Groovy, and briefly compare Groovy with other JVM languages.

Groovy Power Features

Groovy is a dynamic language for the JVM; it’s like a super version of Java. For Java programmers, it offers a syntax that closely resembles (in some cases exactly resembles) Java, but offers many improvements that not only greatly simplify code but also provide an enriched environment with many productivity features. In many cases, such features are promised in Java versions 7 and later, but they are available today in Groovy.

Some of the power features of Groovy you’ll learn about are: • Leveraging Groovy’s features to write DSLs • Writing Web Service servers and clients in a few lines of code • Replacing Design Patterns with language features and/or libraries • Talking to the Polyglot world from Groovy: Scala, Clojure, Jython, JRuby, JavaScript and Jaskell • Harnessing constraint/logic and functional programming • Simple but powerful tests • Simplify how you write build tasks • Accessing Hibernate through GORM • Harnessing parallel processing • Leveraging Spring and OSGI

Dynamic Languages Practices

Developer practices for traditional and agile Java development are well understood and documented. But dynamic languages (Groovy, Ruby, and others) change the ground rules. Many of the common practices, refactoring techniques, and design patterns we have been taught either no longer apply or should be applied differently and some new techniques also come into play.

In this talk, we'll relearn practices needed for dynamic languages. Along the way we will look at typing, design patterns, refactoring, functional style, SOLID principles revisited and more.