Howard Lewis Ship

By Howard Lewis Ship

Tapestry 5 is a complete rewrite of Tapestry from the ground up. It takes everything good about Tapestry and cranks the volume up to eleven, while removing the frustrating parts of using Tapestry. This session takes the wraps off this new and innovative technology, showing off important new features such as live class reloading (the ability to change your Java classes and continue using the application without interruption or redeployment), the simplified coding model, and the total lack of XML. This session is of interest to those already using Tapestry 4, and those new to Tapestry and ready to jump on the bandwagon.

Tapestry 5 really does take everything great about Tapestry and crank it up, all with the goal of making your job as a web developer easier. Being able to change your classes at will within a running application is just the tip of the iceberg; Tapestry 5 is designed to break down the barriers to developer productivity by simplifying every aspect of creating a web application.

Tapestry 4's base classes and abstract methods are all gone, replaced with pure POJOs and a handful of annotations. All the XML configuration of Tapestry has been removed as well. Tapestry 5 practices convention over configuration with a vengeance, introducing smart defaults and intelligent logic to let Tapestry do the right thing.

By Howard Lewis Ship

Part one (of two) covers the TestNG unit testing framework, and shows how it integrates with Selenium (for integration testing).

In part one of this two part session, we'll discuss the basics of unit testing and show how to use TestNG. We'll discuss how to use the tool, organize tests, and collect results, as well as integrate with IDEs, Ant and Maven. Lastly, we'll see advanced uses of TestNG combined with Selenium to automate integration testing within a test suite.

By Howard Lewis Ship

In part two (of two) we go in depth on EasyMock, the weird and wonderful tool for creating mock objects on the fly. We'll do a good bit of live coding as we examine how to use, tame and extend this powerful tool.

Unit testing with only gets you so far; even when you've refactored your code and hidden all your implementations behinds interfaces you are still stuck with the problem of testing the individual pieces. If you've hit this point and despaired, know that there are tools to help ... including the weird and wonderful EasyMock. We'll discuss unit testing in general, and how EasyMock is used to to generate mock objects, allowing you test each class in isolation. We'll be doing some live coding to show you step-by-step how to build up a unit test, interpret EasyMock's baffling error messages, and set yourself up for easy reuse of testing code.

By Howard Lewis Ship

A guide to the concepts behind Inversion of Control and a discussion of the similarities and differences between the best known of the containers, including Spring, HiveMind, Plexus, T5 IoC and Guice.

There's been a small explosion of IoC (Inversion of Control) containers over the last few years. It's not as confusing as the volume of web frameworks, but there is a lot of choices to be made. This session will identify the core features of an IoC container, and explain why using a container is such a powerful, enabling idea. We'll then cover some common cases, such as creating services with dependencies. Lastly, we'll discuss the pros and cons of each container, including how well they play with each other.

By Howard Lewis Ship

Everyone likes the Gang of Four design patterns, but it's not always clear just how to make use of them in your day to day coding efforts. Hidden inside Tapestry 5 is an Inversion of Control (IoC) container that is structured around several common patterns (Chain of Command, Strategy, Decorator and Filter Chain will be covered). This isn't academic navel-gazing ... this is about leveraging the common patterns so that you can write code you can easily test, and about creating frameworks and toolkits that can be easily extended.

We'll see how Tapestry uses these patterns, and go from there into how you can apply the same techniques to your own projects, resulting in better, cleaner, more testable code.

This session also serves as an introduction to the Tapestry 5 IoC container.

By Howard Lewis Ship

Groovy is a great programming language for removing the programming clutter of the Java programming language and getting to the essence of your code. Tapestry is a great web framework for removing the clutter of web development and getting to the essence of your application. Use them together and the whole is more, and more productive, than the sum of the parts!

We'll be using building and inspecting a Tapestry application written exclusively in Groovy: pages and components, Hibernate entities, and new services. We'll see all the advantages and skirt around a few minor pitfalls.

By Howard Lewis Ship

Go a bit deeper into Tapestry 5 and see the challenges and solutions you'll face when building real applications. This includes integration with Hibernate, managing server-side state, creating reusable components and libraries, and integrating and encapsulating JavaScript as components, and advanced customization of built-in components.

Tapestry is a rich environment for developing web applications; it manages all the busy work for you, but then gets out of your way. When building applications, you are frequently faced with challenges such as tracking what the user is up to, formatting, editing and validating data, or creating fancy JavaScript interfaces. We'll cover the tools Tapestry provides for all of these, and get a peek into Tapestry's holistic approach to building applications, and show how easy it is to build up libraries of components along the way.

By Howard Lewis Ship

Talk about strange bedfellows: what happens when you mix one part Lisp (one of the oldest computer languages), one part Java (so young, yet so well adopted), a healthy serving of functional programming, and add a state-of-the-art concurrency layer on top? That's Clojure, which "feels like a general-purpose language beamed back from the near future."

Clojure embraces functional programming with immutable data types and first class functions. It is fully interoperable with Java. Clojure's approach to concurrency includes asynchonous Agents, and Software Transactional Memory. Clojure is fast, elegant, dynamic, and scalable: a language for the future, today. This session introduces the challenges of concurrency. We then explore the nature and syntax of Clojure and show how Clojure bridges between the imperative programming style of Java and the functional programming world. Finally, we introduce the constructs in Clojure that support highly scalable, highly concurrent applications without locking or blocking.

By Howard Lewis Ship

Clojure packs a tremendous amount of power into a very small package. Clojure inherits the power and elegance of Lisp, and in this session we'll explore the features that make Clojure so attractive: macros, multimethods, meta-data, and an overview of Clojure's rich built-in library.

We'll also go into more detail about Clojure/Java interop, and explore Clojure's ability to create new Java classes on the fly, and take a look at Clojure's evolving "contrib" library.

Prerequisite: Clojure: Functional Concurrency for the JVM.

By Howard Lewis Ship

CouchDB is serious software heresy: ditch your relational database, ditch rows and tables and foreign keys, ditch Hibernate and ORM. Ditch SQL and JDBC. Replace it with "semi-structured" data stored as JSON (JavaScript Object Notation). CouchDB is a restful store from JSON documents, written in Erlang, that's fast, easy and replicated. The API is simple, RESTful HTTP requests. Find out why it might just be a great solution for your evolving data needs.

CouchDB takes a radical take on what it means to store information abandoning the constraints of tables, rows and third-normal form: CouchDB is modeled on the real world, where a document is entirely self contained. Without rows and tables, data can evolve easily over time, adding and changing document content almost at will.

CouchDB is written in Erlang, a popular functional programming language that is well known for its scalability and reliability. CouchDB databases can be replicated to any number of nodes and its basic design encompasses common problems with replication (such as conflicting updates). CouchDB's vision includes rich Ajax clients, in browser, communicating directly to CouchDB: a two tier solution.

By Howard Lewis Ship

Cappuccino is a rich web framework that all but redefines what's possible in the web browser. It brings the heritage and richness of the Apple Objective-C language and runtime directly into the browser, as Objective-J (Objective JavaScript). Cappuccino apps look and act like Desktop Mac OS X Applications -- a very high bar to set! In many ways comparable to Google Web Toolkit, Cappuccino is simpler and less obtrusive.

Like coding in JavaScript but hate the DOM? Cappuccino is for you; it replaces the rag tag DOM APIs with a slick, streamlined, cross-browser model based on the venerable AppKit libraries that power Mac OS X and the iPhone. It adapts Objective-C's syntax (itself derived from Smalltalk) to JavaScript, giving up nothing in the process. It gives great results quickly, and without all the gotcha's of traditional client JavaScript. We'll take a peek at a potential downside (debugging) and a huge upside (the upcoming Atlas interface builder).

By Howard Lewis Ship

Clojure is a functional programming language, and comes packaged with functions galore. Add in Clojure Contrib (the community library) and you end up with an overwhelming set of options. We'll explore many of the key functions and highlight the ones you really need day to day.

Of particular interest are Clojure's testing library, the pretty printing library and the monads library (don't be scared!) ... but once you pull back the covers, there is a tremendous amount in there! We'll focus on libraries and functions used day to day when building real applications and frameworks in Clojure.

Prerequisite: Clojure Deep Dive