Howard Lewis Ship
Creator of Apache Tapestry
Howard Lewis Ship is the creator and lead developer for the Apache Tapestry project, and is a noted expert on Java framework design and developer productivity. He has over twenty years of full-time software development under his belt, with over ten years of Java. He cut his teeth writing customer support software for Stratus Computer, but eventually traded PL/1 for Objective-C and NeXTSTEP before settling into Java.
Howard is respected in the Java community as an expert on web application development, dependency injection, Java meta-programming, and developer productivity. He is a frequent speaker at JavaOne, NoFluffJustStuff, ApacheCon and other conferences, and the author of "Tapestry in Action" for Manning (covering Tapestry 3.0). Lately, he's been dipping his toes into alternate languages, including Clojure.
Howard is an independent consultant, offering Tapestry training, mentoring and project work as well as training in Clojure. He lives in Portland, Oregon with his wife Suzanne, and his children, Jacob and Olivia.
Apache Tapestry is a fast, easy to use, high-performance, general purpose web framework. Tapestry eschews heavy XML configuration, base classes, and boilerplate code: instead it embraces convention-over-configuration, letting you build your application from simple, concise POJO (Plain Old Java) page and component classes. Tapestry is laser-focused on giving you maximum bang for your programming buck, and this shows up as a broad range of well-integrated features, including extensive Ajax support. Don't let unfamiliarity get in the way of learning this powerful, friendly tool.
Tapestry is different from traditional action-oriented frameworks, such as Struts and SpringMVC, because it is component-based: it organizes the overall application into pages, and builds pages from reusable components. Tapestry leverages this overall map of the application to take over many responsibilities normally tossed in the developer's lap, such as building and dispatching on URLs, and managing server-side state.
A brief introduction to the Clojure programming language: combining the best features from 40 years of Lisp heritage with the familiarity, performance, and ubiquity of Java and the Java virtual machine.
Maybe you've heard the buzz around Clojure. It's Lisp for the JVM (what does that even mean?). It has immutable data structures (why would you want that?) It has agents and software transactional memory (what does that buy me?). At first glance, it's just a jumble of new concepts and confusing choices wrapped in a vastly unfamiliar syntax. Despite that a lot of heavy hitters are embracing this little language that's breaking all the rules, leaving Java and Ruby behind and never looking back. This talk is an introduction to the language, focusing on the syntax (quite minimal, that's half the point), the basic data structures and core functions, the concurrency support, and the interoperability with Java. You'll get a feel for why people quickly learn to love this language, embracing 40 years of elegance from the Lisp side, combined with the ubiquity and performance of the Java virtual machine.
If you're of an, ahem, certain age, you may remember the joy of text adventures: adventure games powered by prose and the player's imagination. The days of "Zork" and "Planetfall" and commercially available text adventures are long gone … but the concept, now known as "Interactive Fiction", has been reborn around modern tools and a modern community. Where games of the past were simple dungeon romps and puzzle quests, modern games are an interactive equivalent of the short story, complete with characters, conversations, and carefully crafted plots … and lots of room for imagination and "thinking outside the box".
This session will get you started with the basics of Inform 7: a free, integrated development environment for authoring interactive fiction. You'll see how easy it is to create rooms to visit, objects to examine and manipulate, rules to manage your world, puzzles to solve … even other characters to interact with. Inform 7 is a great way for writers to learn about programming, and programmers to learn about writing … and also a great way to create games if you can write and code, but not draw!
Spock is a fabulous new testing framework for the JVM. Spock leverages all the DSL power of the Groovy language to make testing a breeze. Spock tests are concise and readable, with excellent support for error reporting and for mock object creation. Spock removes much of the pain from test driven development!
Spock is a testing DSL (Domain Specific Language) that transforms the Groovy programming language into a language specifically targeting testing. Spock can be used to test Java, Groovy, or any JVM language.
In Spock, classes are test specifications; methods of those classes are used to describe expected features of the system under specification. Each feature method is broken up into blocks that specify a stimulus (such as invoking a method) and a response (the behavior or state from that method invocation). Spock keeps you honest about what kind of code can appear in each block, and the end result is a highly readable, highly maintainable test.
Spock also has first class support for mock-object testing, and the Spock DSL uses an elegant and obvious syntax to specify how the mock objects interact with the system under specification. Rolled together, Spock is a formidable tool ... and makes using any other testing framework a highly illogical choice.
However, Underscore doesn't make your application look pretty: that's the job of Twitter's Bootstrap: a standard set of CSS rules that give your applications a modern "Web 2.0" look and feel. Bootstrap is developed by experts to look good across all the major browsers. We'll dive into how to use Bootstrap: how to get good looking results up quickly, how all the CSS classes work together, and how to get even better results using the bundled jQuery plugins.
If you build web applications and cringe at the phrase "but how are we going to test it?" you're going to love Geb: the browser automation and testing tool. Geb is a Groovy framework for testing web applications: it builds on Selenium, but draws ideas from jQuery and elsewhere to make it productive and fun to test your applications in-browser.
Geb is rich with ideas to keep your tests clear, concise and maintainable. It is useful in all major testing frameworks: JUnit, TestNG, and Spock. We'll see how to navigate around the browser, clicking links, submitting forms, and verifying results. We'll also see Geb Pages and Modules, which allow you to define elements inside a page once, and reference them across many tests. Basically, Geb removes the excuses for not testing your web application, and that's a great thing!
Clojure is an elegant language … concise, and expressive, without going overboard (I'm looking at you Haskell!). Weaving together the language itself, the immutable collection types, the carefully crafted mutable reference types, lazy evaluation, and the macro capabilities, results in a pretty comprehensive set of tools that can be applied to your hardest, and most interesting, problems.
Clojure is all about creating a sane and scalable approach to dealing with complex problems … including dealing with concurrency, which normally makes even the simplest programs complex. Combining immutable collections with well-defined reference types (mutable slots with well defined concurrent behavior) gives Clojure a leg up on solving challenging and interesting problems. Of course, part of the point of Clojure is full interoperation with Java; we'll see how easily Clojure functions and Java objects can work together. At the other end of the spectrum, we'll see how Clojure macros allow you to add new language features to Clojure … in Clojure itself!
CoffeeScript also includes a fair number of wonderful heresies ... such as jettisoning the curly braces of the C language world in exchange for Python-style indentation. In CoffeeScript, every statement (even an if ... then) is an expression whose result can be stored, and every function returns a value.
If you've done a cursory look at Gradle, you might think "that would be nice, but we're stuck on Maven." Well, you aren't, and you shouldn't be layering on the technical debt by staying with Maven. Moving from Maven to Gradle is quite reasonable; we'll cover the basic process, as well as some key pitfalls to avoid.
Maven is well known as a tool with some great core ideas, and an implementation that causes quite a few developers to froth at the mouth. Until recently, we all just had to grin and bear it ... but now there's Gradle, which keeps the best ideas from Maven, discards the rest, and comes up with something that's fast, reliable, and scalable.
If you think you're wedded to Maven ... you're not. Moving from Maven to Gradle isn't automatic, but it doesn't have to be painful, either. We'll cover the basic process, as well as the pitfalls and how to avoid them.
Call it "single page" or "rich client", but modern web applications have advanced far beyond the "click this link and wait for the page to render" approach. Clients demand that pages react immediately to the user: no waiting allowed. Frameworks like jQuery and Backbone may let you manage the DOM and respond to events ... but AngularJS goes far past that: it lets you seamlessly marry your data objects, controllers, and the UI together gracefully and naturally ... or create your own HTML elements or attributes as needed. Rather than work with HTML the way the W3C provides it, you can create the markup you want.
We'll cover the basics of setting up a page with AngularJS and delve into its core concepts: templates, bindings, scopes, controllers, routing, partial templates, and its dependency injection framework. From there we'll discuss communication with the server as well as how to extend AngularJS.
Imagine the perfect database: it would be easy to code against, without using or needing an ORM (such as Hibernate). It would be easy to setup, and easy to test against. It would be flexible enough for you change your mind about how data is stored ... even after your application is in production. It would be fast, and scale from tiny applications to massive ones. It would be ACID. It would be deployable in the cloud. And it would never forget anything. That's Datomic, the database that stands to change everything.
Datomic is a new product from Relevence (it is not open source, but has a limited Free edition). Datomic is implemented in Clojure, but has a Java API as well as a REST web interface.
Datomic challenges you to rethink what your database is: not a scratchpad of rows and columns, but a set of entities and facts about those entities. Datomic side-steps the challenges of object/relational mapping by being data oriented (not rows and columns, and not objects).
Datomic breaks the traditional ties between identity and state: where a traditional database updates rows in place, and loses those prior values, Datomic records new facts about entities. Since updates occur inside transactions, it is possible to query the database as it existed in the past, or even query the database about how entities have changed over time.
Complete SQL queries got you down? Datomic uses the awesome Datalog logic programming language instead. Worried about scaling? Datomic shifts the cost of queries from the database to the clients (or "peers") and its data model is amazingly cache friendly. Concerned about data changing during queries? Don't be ... in Datomic the database is a value, consistent to a specific moment in time, even as changes occur later. Datomic understand time in a way traditional databases simply can not. Can't figure out how to efficiently implement inheritance? Datomic is about data not objects; any entity can have any attributes you application wants, so inheritance has no meaning.
Free your mind from what databases are and come see what databases should be. It's easy to set up, easy to get going ... and hard to go back to anything else, SQL or otherwise.
by Howard M. Lewis Ship