NFJS Bookstore

Drive Even More Value from Virtualization: Write VMware® Applications that Automate Virtual Infrastructure Management

Companies running VMware have already achieved enormous gains through virtualization. The next wave of benefits will come when they reduce the time and effort required to run and manage VMware platforms. The VMware Infrastructure Software Development Kit (VI SDK) includes application programming interfaces (APIs) that allow developers and administrators to do just that. Until now, there has been little documentation for the APIs. In VMware VI and vSphere SDK, software architect Steve Jin demystifies the entire VMware VI and new vSphere SDK and offers detailed, task-based coverage of using the APIs to manage VMware more efficiently and cost-effectively.

Jin walks you through using the VI SDK and cloud-computing vSphere SDK to manage ESX servers, ESX clusters, and VirtualCenter servers in any environment–no matter how complex. Drawing on his extensive expertise working with VMware strategic partners and enterprise customers, he places the VI SDK in practical context, presenting realistic samples and proven best practices for building robust, effective solutions. Jin demonstrates how to manage every facet of a VMware environment, including inventory, host systems, virtual machines (VMs), snapshots, VMotion, clusters, resource pools, networking, storage, data stores, events, alarms, users, security, licenses, and scheduled tasks. Coverage includes 

• Understanding how the VI SDK fits into your VMware VI and Cloud Ready vSphere Environment
• Discovering the VI and vSphere SDK from the bottom up
• Using the author’s new VI Java API to write shorter, faster, and more maintainable code
• Managing VI and vSphere inventory and configurations
• Moving running VMs and storages across different physical platforms without disruption
• Optimizing system resources, hardening system securities, backing up VMs and other resources
• Leveraging events, alarms, and scheduled tasks to automate the system management
• Developing powerful applications that integrate multiple API features and run on top of or alongside VMware platforms
• Using the VI SDK to monitor performance
• Scripting with the VI SDK: building solutions with VI Perl, PowerShell, and Jython
• Avoiding the pitfalls that trip up VMware VI developers
• Integrating with and extending VMware platforms using VI SDK 

This book is an indispensable resource for all VMware developers and administrators who want to get more done in less time; for hardware vendors who want to integrate their products with VMware; for ISV developers building new VMware applications; and for every professional and student seeking a deeper mastery of virtualization.

BlazeDS enables you to easily connect to back-end distributed data and push data in real time to Adobe Flex and Adobe AIR applications in order to garner more responsive Rich Internet Application (RIA) experiences. It is a scalable option for Flex and Java integration and allows you to create excellent RIAs with both Flex and Java.

This informative resource provides you with detailed examples and walkthroughs that explain the best practices for creating RIAs using BlazeDS. You'll begin with the essentials of BlazeDS and then more on to more advanced topics. Along the way, you'll learn the real-world concerns that surround enterprise-based Java and Flex applications.

• BlazeDS enables you to connect to back-end distributed data in order to garner more responsive Rich Internet Application (RIA) experiences
• Begins with an introduction to BlazeDS, and explains the necessary features for integrating new and existing Java data sources and applications with Flex-based RIAs
• Provides hands-on examples and addresses real-world concerns surrounding enterprise-based Java and Flex applications
• Serves as a comprehensive walk through for creating RIAs using BlazeDS

If you're looking to create rich, productive, and engaging applications, then this book is for you.

Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file.

The Definitive Guide to JavaServer Faces 2.0

Fully revised and updated for all of the changes in JavaServer Faces (JSF) 2.0, this comprehensive volume covers every aspect of the official standard Web development architecture for JavaEE. Inside this authoritative resource, the co-spec lead for JSF at Sun Microsystems shows you how to create dynamic, cross-browser Web applications that deliver a world-class user experience while preserving a high level of code quality and maintainability.

JavaServer Faces 2.0: The Complete Reference features an integrated sample application to use as a model for your own JSF applications, with code available online. The book explains all JSF features, including the request processing lifecycle, managed beans, page navigation, component development, Ajax, validation, internationalization, and security. Expert Group Insights throughout the book offer insider information on the design of JSF.

• Set up a development environment and build a JSF application
• Understand the JSF request processing lifecycle
• Use the Facelets View Declaration Language, managed beans, and the JSF expression language (EL)
• Define page flow with the JSF Navigation Model, including the new "Implicit Navigation" feature
• Work with the user interface component model and the JSF event model, including support for bookmarkable pages and the POST, REDIRECT, GET pattern
• Use the new JSR-303 Bean Validation standard for model data validation
• Build Ajax-enabled custom UI components Extend JSF with custom non-UI components
• Manage security, accessibility, internationalization, and localization
• Learn how to work with JSF and Portlets from the JSF Team Leader at Liferay, the leading Java Portal vendor

Ed Burns is a senior staff engineer at Sun Microsystems and is the co-specification lead for JavaServer Faces. He is the co-author of JavaServer Faces: The Complete Reference and author of Secrets of the Rock Star Programmers.

Chris Schalk is a developer advocate and works to promote Google's APIs and technologies. He is currently engaging the international Web development community with the new Google App Engine and OpenSocial APIs.

Neil Griffin is committer and JSF Team Lead for Liferay Portal and the co-founder of The PortletFaces Project.

Ready-to-use code at www.mhprofessonal.com/computingdownload

• The Case of the Devilish Details

• The Case of the Mistaken Identity

• The Case of the Single White Space

• The Case of the Float with a Mind of Its Own

• The Case of the Browser Who Hated Me

• The Case of the LOL Layout

• Internet fundamentals
• Planning, content strategy, and information architecture
• HTML and CSS
• Accessibility

JavaServer Faces (JSF) is the standard Java EE technology for building web user interfaces. It provides a powerful framework for developing server-side applications, allowing you to cleanly separate visual presentation and application logic. JSF 2.0 is a major upgrade, which not only adds many useful features but also greatly simplifies the programming model by using annotations and “convention over configuration” for common tasks.

To help you quickly tap into the power of JSF 2.0, the third edition of Core JavaServer™ Faces has been completely updated to make optimum use of all the new features. The book includes

• Three totally new chapters on using Facelets tags for templating, building composite components, and developing Ajax applications
• Guidance on building robust applications with minimal hand coding and maximum productivity–without requiring any knowledge of servlets or other low-level “plumbing”
• A complete explanation of the basic building blocks–from using standard JSF tags, to working with data tables, and converting and validating input
• Coverage of advanced tasks, such as event handling, extending the JSF framework, and connecting to external services
• Solutions to a variety of common challenges, including notes on debugging and troubleshooting, in addition to implementation details and working code for features that are missing from JSF
• Proven solutions, hints, tips, and “how-tos” show you how to use JSF effectively in your development projects

Core JavaServer™ Faces, Third Edition, provides everything you need to master the powerful and time-saving features of JSF 2.0 and is the perfect guide for programmers developing Java EE 6 web apps on Glassfish or another Java EE 6-compliant application servers, as well as servlet runners such as Tomcat 6.

On the surface of things, that is an intuitively obvious statement, given the title of this book. However, despite the apparent redundancy in saying it aloud, the sentence above elegantly describes what this book is about: The authors are not attempting to teach developers how to accomplish tasks from other languages in this one, nor are they attempting to evangelize the language or its feature set or its use "over" other languages. They assume that you are considering this book because you have an interest in learning the F# language: its syntax, its semantics, its pros and cons, and its use in concert with other parts of the .NET ecosystem.

The intended reader is a .NET developer, familiar with at least one of the programming languages in the .NET ecosystem. That language might be C# or Visual Basic, or perhaps C++/CLI, IronPython or IronRuby.

AdvancED Flex 4 makes advanced Flex 4 concepts and techniques easy. Ajax, RIA, Web 2.0, mashups, mobile applications, the most sophisticated web tools, and the coolest interactive web applications are all covered with practical, visually oriented recipes.

• Completely updated for tools new to Flex 4
• Demonstrates how to use Flex 4 to create robust and scalable enterprise-grade rich Internet applications
• Teaches you to build high-performance web applications with interactivity that really engages your users

What you’ll learn

Practiced beginners and intermediate users of Flex, especially those with a knowledge of other web development tools, will learn to leverage Flex 4’s new tools and capabilities to build truly advanced web applications.

• Get the most out of the new features introduced in Flex 4
• Integrate Flex 4 with PHP, Java, JavaScript, and Ruby on Rails
• Leverage architectural and design patterns
• Create mashups and collaborative applications using Flex 4
• Build rich media applications using audio and video streaming and open-source 3D libraries
• Tune the performance of your Flex applications

Who this book is for

This book is for web developers who want and need to create rich Internet applications on time and within budget. It is also for all Flex developers including those upgrading from Flex 3, intermediate users who want to build their skills to an advanced level, and other web developers who want to integrate their web tools with Flex.

Table of Contents

1. Building Applications Using Test-Driven Development  
2. Turbo-Charging Data Binding  
3. Workflow enhancements with Flash Catalyst  
4. Flex and AIR: Taking Applications to the Desktop  
5. 20 Enhancements Overview   
6. Creating Themes in Flex 4   
7. Integrating Flex with Java Using Services   
8. Integrating via Data Services  
9. Talking with JavaScript and HTML: Web Page Integration  
10. Flex Mashups   
11. Flash Security    
12. Migrating Web 10 Interfaces to RIA   
13. Working with Web 20 APIs    
14. Facilitating Audio and Video  
15. Using 3D in Flex

With over 3 million users/developers, Spring Framework is the leading “out of the box” Java framework. Spring addresses and offers simple solutions for most aspects of your Java/Java EE application development, and guides you to use industry best practices to design and implement your applications.

The release of Spring Framework 3 has ushered in many improvements and new features. Spring Recipes: A Problem-Solution Approach, Second Edition continues upon the bestselling success of the previous edition but focuses on the latest Spring 3 features for building enterprise Java applications. This book provides elementary to advanced code recipes to account for the following, found in the new Spring 3:

• Spring fundamentals: Spring IoC container, Spring AOP/ AspectJ, and more
• Spring enterprise: Spring Java EE integration, Spring Integration, Spring Batch, jBPM with Spring, Spring Remoting, messaging, transactions, scaling using Terracotta and GridGrain, and more.
• Spring web: Spring MVC, Spring Web Flow 2, Spring Roo, other dynamic scripting, integration with popular Grails Framework (and Groovy), REST/web services, and more.

This book guides you step by step through topics using complete and real-world code examples. Instead of abstract descriptions on complex concepts, you will find live examples in this book. When you start a new project, you can consider copying the code and configuration files from this book, and then modifying them for your needs. This can save you a great deal of work over creating a project from scratch!

What you’ll learn

• How to use the IoC container and the Spring application context to best effect.
• Spring’s AOP support, both classic and new Spring AOP, integrating Spring with AspectJ, and load-time weaving.
• Simplifying data access with Spring (JDBC, Hibernate, and JPA) and managing transactions both programmatically and declaratively.
• Spring’s support for remoting technologies (RMI, Hessian, Burlap, and HTTP Invoker), EJB, JMS, JMX, email, batch, scheduling, and scripting languages.
• Integrating legacy systems with Spring, building highly concurrent, grid-ready applications using Gridgain and Terracotta Web Apps, and even creating cloud systems.
• Building modular services using OSGi with Spring DM and Spring Dynamic Modules and SpringSource dm Server.
• Delivering web applications with Spring Web Flow, Spring MVC, Spring Portals, Struts, JSF, DWR, the Grails framework, and more.
• Developing web services using Spring WS and REST; contract-last with XFire, and contract–first through Spring Web Services.
• Spring’s unit and integration testing support (on JUnit 3.8, JUnit 4, and TestNG).
• How to secure applications using Spring Security.

Who this book is for

This book is for Java developers who would like to rapidly gain hands-on experience with Java/Java EE development using the Spring framework. If you are already a developer using Spring in your projects, you can also use this book as a reference—you’ll find the code examples very useful.

Table of Contents

1. Introduction to Spring
2. Advanced Spring IoC Container
3. Spring AOP and AspectJ Support
4. Scripting in Spring
5. Spring Security
6. Integrating Spring with Other Web Frameworks
7. Spring Web Flow
8. Spring @MVC
9. Spring RESTSpring and Flex
10. Grails
11. Spring Roo
12. Spring Testing
13. Spring Portlet MVC Framework
14. Data Access
15. Transaction Management in Spring
16. EJB, Spring Remoting, and Web Services
17. Spring in the Enterprise
18. Messaging
19. Spring Integration
20. Spring Batch
21. Spring on the Grid
22. jBPM and Spring
23. OSGi and Spring

Your co-workers' resistance to new technologies can be baffling. Logical arguments can fail. If you don't do politics, you will fail. With Driving Technical Change, by Terrence Ryan, you'll learn to read users' "patterns of resistance"-and then dismantle their objections. Every developer must master the art of evangelizing. With these techniques and strategies, you'll help your organization adopt your solutions-without selling your soul to organizational politics.

Finding cool languages, tools, or development techniques is easy-new ones are popping up every day. Convincing co-workers to adopt them is the hard part. The problem is political, and in political fights, logic doesn't win for logic's sake. Hard evidence of a superior solution is not enough. But that reality can be tough for programmers to overcome.

In Driving Technical Change: Why People On Your Team Don't Act on Good Ideas, and How to Convince Them They Should, Adobe software evangelist Terrence Ryan breaks down the patterns and types of resistance technologists face in many organizations.

You'll get a rich understanding of what blocks users from accepting your solutions. From that, you'll get techniques for dismantling their objections-without becoming some kind of technocratic Machiavelli.

In Part I, Ryan clearly defines the problem. Then in Part II, he presents "resistance patterns"-there's a pattern for each type of person resisting your technology, from The Uninformed to The Herd, The Cynic, The Burned, The Time Crunched, The Boss, and The Irrational. In Part III, Ryan shares his battle-tested techniques for overcoming users' objections. These build on expertise, communication, compromise, trust, publicity, and similar factors. In Part IV, Ryan reveals strategies that put it all together-the patterns of resistance and the techniques for winning buy-in. This is the art of organizational politics.

In the end, change is a two-way street: In order to get your co-workers to stretch their technical skills, you'll have to stretch your soft skills. This book will help you make that stretch without compromising your resistance to playing politics. You can overcome resistance-however illogical-in a logical way.

Since its release, Spring Framework has transformed virtually every aspect of Java development including web applications, security, aspect-oriented programming, persistence, and messaging. Spring Batch, one of its newer additions, now brings the same familiar Spring idioms to batch processing. Spring Batch addresses the needs of any batch process, from the complex calculations performed in the biggest financial institutions to simple data migrations that occur with many software development projects.

Pro Spring Batch is intended to answer three questions:  

• What? What is batch processing? What does it entail? What makes it different from the other applications we are developing? What are the challenges inherent in the development of a batch process?
• Why? Why do batch processing? Why can’t we just process things as we get them? Why do we do batch processing differently than the web applications that we currently work on?
• How? How to implement a robust, scalable, distributed batch processing system using open-source frameworks

Pro Spring Batch gives concrete examples of how each piece of functionality is used and why it would be used in a real-world application. This includes providing tips that the "school of hard knocks" has taught author Michael Minella during his experience with Spring Batch. Pro Spring Batch includes examples of I/O options that are not mentioned in the official user’s guide, as well as performance tips on things like how to limit the impact of maintaining the state of your jobs.

The author also walks you through, from end to end, the design and implementation of a batch process based upon a theoretical real-world example. This includes basic project setup, implementation, testing, tuning and scaling for large volumes.

What you’ll learn

• Batch concepts and how they relate to the Spring Batch framework
• How to use declarative I/O using the Spring Batch readers/writers
• Data integrity techniques used by Spring Batch, including transactions and job state/restartability
• How to scale batch jobs via distributed batch processing
• How to handle testing batch processes (Unit and functional)

Who this book is for

• Java developers with Spring experience.
• Java Architects designing batch solutions

Table of Contents

1. Batch and Spring
2. Spring Batch 101
3. Sample Job
4. Understanding Jobs and Steps
5. Job Repository and Metadata
6. Running a Job
7. Readers
8. Item Processors
9. Item Writers
10. Sample Application
11. Scaling and Tuning
12. Testing Batch Processes

This volume provides an overview and an understanding of REST (Representational State Transfer). Discussing the constraints of REST the book focuses on REST as a type of web architectural style. The focus is on applying REST beyond Web applications (i.e., in enterprise environments), and in reusing established and well-understood design patterns when doing so. The reader will be able to understand how RESTful systems can be designed and deployed, and what the results are in terms of benefits and challenges encountered in the process.

Since REST is relatively new as an approach for designing Web Services, the more advanced part of the book collects a number of challenges to some of the assumptions and constraints of REST, and looks at current research work on how REST can be extended and applied to scenarios that often are considered not to be a good match for REST.

This work will help readers to reach a deeper understanding of REST on a practical as well as on an advanced level.

More than ever, learning to program concurrency is critical to creating faster, responsive applications. Speedy and affordable multicore hardware is driving the demand for high-performing applications, and you can leverage the Java platform to bring these applications to life.

Concurrency on the Java platform has evolved, from the synchronization model of JDK to software transactional memory (STM) and actor-based concurrency. This book is the first to show you all these concurrency styles so you can compare and choose what works best for your applications. You'll learn the benefits of each of these models, when and how to use them, and what their limitations are.

Through hands-on exercises, you'll learn how to avoid shared mutable state and how to write good, elegant, explicit synchronization-free programs so you can create easy and safe concurrent applications. The techniques you learn in this book will take you from dreading concurrency to mastering and enjoying it. Best of all, you can work with Java or a JVM language of your choice - Clojure, JRuby, Groovy, or Scala - to reap the growing power of multicore hardware.

If you are a Java programmer, you'd need JDK 1.5 or later and the Akka 1.0 library. In addition, if you program in Scala, Clojure, Groovy or JRuby you'd need the latest version of your preferred language. Groovy programmers will also need GPars.

Thousands of software professionals have the necessary technical qualifications to become architects, but far fewer have the crucial non-technical skills needed to get hired and succeed in this role. In today’s agile environments, these “soft” skills have grown even more crucial to success as an architect. For many developers, however, these skills don’t come naturally–and they’re rarely addressed in formal training. Now, long-time software architect Dave Hendricksen helps you fill this gap, supercharge your organizational impact, and quickly move to the next level in your career.

In 12 Essential Skills for Software Architects, Hendricksen begins by pinpointing the specific relationship, personal, and business skills that successful architects rely upon. Next, he presents proven methods for systematically developing and sharpening every one of these skills, from negotiation and leadership to pragmatism and vision.

From start to finish, this book’s practical insights can help you get the architect position you want–and thrive once you have it!

The soft skills you need…

…and a coherent framework and practical methodology for mastering them!

Relationship skills

Leadership, politics, gracious behavior, communication, negotiation

Personal skills

Context switching, transparency, passion

Business skills

Pragmatism, vision, business knowledge, innovation

Get Started Fast with HTML5 Online Game Programming!

HTML5 will transform web and mobile gaming. As new browsers rapidly adopt it, HTML5 will do everything “legacy” technologies such as Flash and Silverlight have done—and much more. In Learning HTML5 Game Programming, pioneering developer James L. Williams gives you all the knowledge, code, and insights you’ll need to get started fast!

Williams combines detailed explanations of HTML5’s key innovations with examples, including two case study applications that address the entire development process. He guides you through setting up a state-of-the-art HTML5 development environment; making the most of HTML5’s canvas tag, SVG vector graphics, and WebGL 3D; and targeting diverse mobile and social platforms. It’s all here: from the essentials of online game design to the nitty-gritty details of performance optimization.

About the Website

All code samples and answers to chapter exercises are available for download at www.informit.com/title/9780321767363 and on Github at https://github.com/jwill/html5-game-book.

Coverage includes

·          Understanding the HTML5 innovations that make it possible to create amazingly rich games

·          Setting up a state-of-the-art open source HTML5 game development environment

·          Using JavaScript to drive sophisticated interactions between users and games

·          Building basic games fast, with the prototype-based Simple Game Framework (SGF)

·          Generating movement and gameplay with the canvas tag and surface

·          Creating games with SVG vector graphics using the RaphaëlJS Javascript library

·          Using Three.js to build powerful WebGL 3D games with far less complexity

·          Developing games without JavaScript, using Google Web Toolkit (GWT) or CoffeeScript

·          Building a complete multiplayer game server using Node.js and WebSockets

·          Planning and choosing tools for mobile game development with HTML5

·          Optimizing game performance with offline cache, minification, and other techniques

Learning HTML5 Game Programming is the fastest route to success with HTML5 game development—whether you’re a long-time game developer or a web/mobile programmer building games for the first time.

Web services have been used for many years. In this time, developers and architects have encountered a number of recurring design challenges related to their usage, and have learned that certain service design approaches work better than others to solve certain problems.

In Service Design Patterns, Rob Daigneau codifies proven design solutions for web services that follow the REST architectural style or leverage the SOAP/WSDL specifications. This catalogue identifies the fundamental topics in web service design and lists the common design patterns for each topic. All patterns identify the context in which they may be used, explain the constituent design elements, and explore the relative strengths and trade-offs. Code examples are provided to help you better understand how the patterns work but are kept general so that you can see how the solutions may be applied to disparate technologies that will inevitably change in the years to come.

This book will help readers answer the following questions:

• How do you create a web service API, what are the common API styles, and when should a particular style be used?
• How can clients and web services communicate, and what are the foundations for creating complex conversations in which multiple parties exchange data over extended periods of time?
• What are the options for implementing web service logic, and when should a particular approach be used?
• How can clients become less coupled to the underlying systems used by a service?
• How can information about a web service be discovered?
• How can generic functions like authentication, validation, caching, and logging be supported on the client or service?
• What changes to a service cause clients to break?
• What are the common ways to version a service? How can web services be designed to support the continuing evolution of business logic without forcing clients to constantly upgrade? 

This book is an invaluable resource for enterprise architects, solution architects, and developers who use web services to create enterprise IT applications, commercial or open source products, and Software as a Service (SaaS) products that leverage emerging Cloud platforms.

–From the Foreword by Robert C. Martin (a.k.a. Uncle Bob)

This isn’t the first book on Java application architecture. No doubt it won’t be the last. But rest assured, this title is different. The way we develop Java applications is about to change, and this title explores the new way of Java application architecture.

Over the past several years, module frameworks have been gaining traction on the Java platform, and upcoming versions of Java will include a module system that allows you to leverage the power of modularity to build more resilient and flexible software systems. Modularity isn’t a new concept. But modularity will change the way we develop Java applications, and you’ll only be able to realize the benefits if you understand how to design more modular software systems.

Java Application Architecture will help you

• Design modular software that is extensible, reusable, maintainable, and adaptable
• Design modular software today, in anticipation of future platform support for modularity
• Break large software systems into a flexible composite of collaborating modules
• Understand where to place your architectural focus
• Migrate large-scale monolithic applications to applications with a modular architecture
• Articulate the advantages of modular software to your team

Java Application Architecture lays the foundation you’ll need to incorporate modular design thinking into your development initiatives. Before it walks you through eighteen patterns that will help you architect modular software, it lays a solid foundation that shows you why modularity is a critical weapon in your arsenal of design tools. Throughout, you’ll find examples that illustrate the concepts. By designing modular applications today, you are positioning yourself for the platform and architecture of tomorrow. That’s why Uncle Bob is dancing.

If you want to keep up with the significant changes in this important language, you need the second edition of Programming Clojure. Stu and Aaron describe the modifications to the numerics system in Clojure 1.3, explain new Clojure concepts such as Protocols and Datatypes, and teach you how to think in Clojure.

Programming Clojure, 2nd Edition is a significant update to the classic book on the Clojure language. You'll get thorough coverage of all the new features of Clojure 1.3, and enjoy reorganized and rewritten chapters that reflect the significance of new Clojure concepts. Many code examples have been rewritten or replaced, and every page has been reevaluated in the light of Clojure 1.3.

As Aaron and Stu show you how to build an application from scratch, you'll get a rich view into a complete Clojure workflow. And you'll get an invaluable education in thinking in Clojure as you work out solutions to the various parts of a problem.

Clojure is becoming the language of choice for many who are moving to functional programming or dealing with the challenges of concurrency. Clojure offers:

The simplicity of an elegantly designed language

The power of Lisp

The virtues of concurrency and functional style

The reach of the JVM

The speed of hand-written Java code

It's the combination of these features that makes Clojure sparkle. Programming Clojure, 2nd Edition shows you how to think in Clojure, and to take advantage of these combined strengths to build powerful programs quickly.

What You Need:

Oracle JDK 6

A text editor

Presentation Patterns is the first book on presentations that categorizes and organizes the building blocks (or patterns) that you’ll need to communicate effectively using presentation tools like Keynote and PowerPoint.

Patterns are like the lower-level steps found inside recipes; they are the techniques you must master to be considered a master chef or master presenter. You can use the patterns in this book to construct your own recipes for different contexts, such as business meetings, technical demonstrations, scientific expositions, and keynotes, just to name a few.

Although there are no such things as antirecipes, this book shows you lots of antipatterns—things you should avoid doing in presentations. Modern presentation tools often encourage ineffective presentation techniques, but this book shows you how to avoid them.

Each pattern is introduced with a memorable name, a definition, and a brief explanation of motivation. Readers learn where the pattern applies, the consequences of applying it, and how to apply it. The authors also identify critical antipatterns: clichés, fallacies, and design mistakes that cause presentations to disappoint. These problems are easy to avoid—once you know how.

Presentation Patterns will help you

• Plan what you’ll say, who you’ll say it to, how long you’ll talk, and where you’ll present
• Perfectly calibrate your presentation to your audience
• Use the storyteller’s “narrative arc” to full advantage
• Strengthen your credibility—and avoid mistakes that hurt it
• Hone your message before you ever touch presentation software
• Incorporate visuals that support your message instead of hindering it
• Create highly effective “infodecks” that work when you’re not able to deliver a talk in person
• Construct slides that really communicate and avoid “Ant Fonts,” “Floodmarks,” “Alienating Artifacts,” and other errors
• Master 13 powerful techniques for delivering your presentation with power, authority, and clarity 

Whether you use this book as a handy reference or read it from start to finish, it will be a revelation: an entirely new language for systematically planning, creating, and delivering more powerful presentations. You’ll quickly find it indispensable—no matter what you’re presenting, who your audiences are, or what message you’re driving home.

Grails is a full stack framework which aims to greatly simplify the task of building serious web applications for the JVM. The concepts within Grails, like interceptors, tag libs, and Groovy Server Pages (GSP), make those in the Java community feel right at home.

Grails’ foundation is on solid open source technologies such as Spring, Hibernate, and SiteMesh, which gives it even more potential in the Java space: Spring provides powerful inversion of control and MVC, Hibernate brings a stable, mature object relational mapping technology with the ability to integrate with legacy systems, and SiteMesh handles flexible layout control and page decoration.

Grails complements these with additional features that take advantage of the coding–by–convention paradigm such as dynamic tag libraries, Grails object relational mapping, Groovy Server Pages, and scaffolding.

Graeme Rocher, Grails lead and founder, and Jeff Brown bring you completely up–to–date with their authoritative and fully comprehensive guide to the Grails 2 framework. You’ll get to know all the core features, services, and Grails extensions via plug–ins, and understand the roles that Groovy and Grails are playing in the changing Web.

What you’ll learn

• Discover how the Web is changing and the role the Groovy language and its Grails framework play
• Get to know the Grails Project and its domains, services, filters, controllers, views, testing, and plug–ins
• Experience the availability of plug–ins for Rich Client and Ajax, web services, performance/utilities, scheduling, security, functionality, and even Persistence
• See how Grails works with other frameworks like Spring, Wicket, Hibernate, and more
• Create custom plug–ins in Grails

Who this book is for

This book is for everyone who is looking for a more agile approach to web development with a dynamic scripting language such as Groovy. This includes a large number of Java developers who have been enticed by the productivity gains seen with frameworks such as Ruby on Rails, JRuby on Rails, etc. The Web and its environment is a perfect fit for easily adaptable and concise languages such as Groovy and Ruby, and there is huge interest from the developer community in general to embrace these languages.

Table of Contents

1. The Essence of Grails
2. Getting Started with Grails 2
3. Understanding Domain Classes
4. Understanding Controllers
5. Understanding Views
6. Mapping URLs
7. Internationalization
8. Ajax
9. GORM
10. Services
11. Dependency Management
12. Plugins