Even though you have reached this point after reading the entire book and hacking with all the features introduced, Play! Framework 2 still has some areas where goodies can be learned.
The first thing worth mentioning is its internal architecture, which is completely modular. This allows Play 2 to provide developers with a range of end-points to integrate an application perfectly with the framework; for instance, the application life cycle, or its configuration.
These modules are called plugins (as always) and a specific API is available for creating our own. This API not only enables a developer to hook on the application itself, but also helps define global components that can be used along with the whole application. Mostly, they are used for integrating third-party libraries.
Another API is also available for those developers willing to interact with the application with a reduced set of needs; it is completely related to the application itself. This API is called global settings . For more information for the Java part on the 2.0.4 Version, go to http://www.playframework.com/documentation/2.1.0/JavaGlobal.
So far, so good; those APIs are there to extend the application's capabilities in some way. However, there are even more features that a regular Play! 2 application can offer.
The two features that are really important for scalable applications are the session-like functionality of a request and the caching system API, available out of the box.
The former enables a request to add or remove session information; this information is stored in the cookie until it expires and, on the other hand, short-lived data can also be consumed using flash scopes. For more information on the Scala part (2.0.4 Version), go to http://www.playframework.org/documentation/2.0.4/ScalaSessionFlash.
For shared data, or for other use cases like that, we could use the cache API that gives the ability to store or fetch data to a centralized destination, which is independent of the user or the request. For more information, check this page (still Version 2.0.4) for Java: http://www.playframework.org/documentation/2.0.4/JavaCache.
We didn't cover natural language and the classic internationalization (i18n) problem, but Play! Framework 2 already has everything covered for us. See http://www.playframework.org/documentation/2.0.4/ScalaI18N.
In this book we introduced CoffeeScript, but didn't spend enough time on it to grasp every single advantage of it. So, I'd recommend browsing this documentation: http://arcturo.github.com/library/coffeescript/index.html.
We didn't use LESS CSS here, but it's probably one of the best ways to achieve DRYness styling rules for a web application. This language aims to import all missing features to CSS, such as variables or functions. It's very easy to understand, and everything is documented at http://lesscss.org/.