NFJS Bookstore

Gradle in Action

Agile Retrospectives: Making Good Teams Great

Java Concurrency in Practice

"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book."
--Martin Buchholz
JDK Concurrency Czar, Sun Microsystems

"For the past 30 years, computer performance has been driven by Moore's Law; from now on, it will be driven by Amdahl's Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today's--and tomorrow's--systems."
--Doron Rajwan
Research Scientist, Intel Corp

"This is the book you need if you're writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you've ever had to synchronize a method and you weren't sure why, you owe it to yourself and your users to read this book, cover to cover."
--Ted Neward
Author of Effective Enterprise Java

"Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance."
--Kirk Pepperdine
CTO, JavaPerformanceTuning.com

"This book covers a very deep and subtle topic in a very clear and concise way, making it the perfect Java Concurrency reference manual. Each page is filled with the problems (and solutions!) that programmers struggle with every day. Effectively exploiting concurrency is becoming more and more important now that Moore's Law is delivering more cores but not faster cores, and this book will show you how to do it."
--Dr. Cliff Click
Senior Software Engineer, Azul Systems

"I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian's book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. This is a book I am recommending to all my readers of The Java Specialists' Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today."
--Dr. Heinz Kabutz
The Java Specialists' Newsletter

"I've focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it's destined to be a very important book."
--Bruce Tate
Author of Beyond Java

" Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java's concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere."
--Bill Venners
Author of Inside the Java Virtual Machine

Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications. Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice , the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them.

However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant.

This book covers:

• Basic concepts of concurrency and thread safety
• Techniques for building and composing thread-safe classes
• Using the concurrency building blocks in java.util.concurrent
• Performance optimization dos and don'ts
• Testing concurrent programs
• Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model

Spring in Action

Spring Recipes: A Problem-Solution Approach

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

Learning UML 2.0

Lucene in Action, Second Edition: Covers Apache Lucene 3.0

Learning Web Design: A Beginner's Guide to (X)HTML, StyleSheets, and Web Graphics

Service Design Patterns: Fundamental Design Solutions for SOAP/WSDL and RESTful Web Services

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.

Jenkins: The Definitive Guide

Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers)

Core JavaServer Faces (3rd Edition)

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.

Groovy in Action

Continuous Integration: Improving Software Quality and Reducing Risk (Addison-Wesley Signature Series)

This is the eBook version of the printed book.

For any software developer who has spent days in “integration hell,” cobbling together myriad software components, Continuous Integration: Improving Software Quality and Reducing Risk illustrates how to transform integration from a necessary evil into an everyday part of the development process. The key, as the authors show, is to integrate regularly and often using continuous integration (CI) practices and techniques.

 

The authors first examine the concept of CI and its practices from the ground up and then move on to explore other effective processes performed by CI systems, such as database integration, testing, inspection, deployment, and feedback. Through more than forty CI-related practices using application examples in different languages, readers learn that CI leads to more rapid software development, produces deployable software at every step in the development lifecycle, and reduces the time between defect introduction and detection, saving time and lowering costs. With successful implementation of CI, developers reduce risks and repetitive manual processes, and teams receive better project visibility.

 

The book covers

• How to make integration a “non-event” on your software development projects
• How to reduce the amount of repetitive processes you perform when building your software
• Practices and techniques for using CI effectively with your teams
• Reducing the risks of late defect discovery, low-quality software, lack of visibility, and lack of deployable software
• Assessments of different CI servers and related tools on the market

Design Patterns in Ruby

Praise for Design Patterns in Ruby

" Design Patterns in Ruby documents smart ways to resolve many problems that Ruby developers commonly encounter. Russ Olsen has done a great job of selecting classic patterns and augmenting these with newer patterns that have special relevance for Ruby. He clearly explains each idea, making a wealth of experience available to Ruby developers for their own daily work."

—Steve Metsker, Managing Consultant with Dominion Digital, Inc.

"This book provides a great demonstration of the key 'Gang of Four' design patterns without resorting to overly technical explanations. Written in a precise, yet almost informal style, this book covers enough ground that even those without prior exposure to design patterns will soon feel confident applying them using Ruby. Olsen has done a great job to make a book about a classically 'dry' subject into such an engaging and even occasionally humorous read."

—Peter Cooper

"This book renewed my interest in understanding patterns after a decade of good intentions. Russ picked the most useful patterns for Ruby and introduced them in a straightforward and logical manner, going beyond the GoF's patterns. This book has improved my use of Ruby, and encouraged me to blow off the dust covering the GoF book."

—Mike Stok

" Design Patterns in Ruby is a great way for programmers from statically typed objectoriented languages to learn how design patterns appear in a more dynamic, flexible language like Ruby."

—Rob Sanheim, Ruby Ninja, Relevance

Most design pattern books are based on C++ and Java. But Ruby is different—and the language's unique qualities make design patterns easier to implement and use. In this book, Russ Olsen demonstrates how to combine Ruby's power and elegance with patterns, and write more sophisticated, effective software with far fewer lines of code.

After reviewing the history, concepts, and goals of design patterns, Olsen offers a quick tour of the Ruby language—enough to allow any experienced software developer to immediately utilize patterns with Ruby. The book especially calls attention to Ruby features that simplify the use of patterns, including dynamic typing, code closures, and "mixins" for easier code reuse.

Fourteen of the classic "Gang of Four" patterns are considered from the Ruby point of view, explaining what problems each pattern solves, discussing whether traditional implementations make sense in the Ruby environment, and introducing Ruby-specific improvements. You'll discover opportunities to implement patterns in just one or two lines of code, instead of the endlessly repeated boilerplate that conventional languages often require.

Design Patterns in Ruby also identifies innovative new patterns that have emerged from the Ruby community. These include ways to create custom objects with metaprogramming, as well as the ambitious Rails-based "Convention Over Configuration" pattern, designed to help integrate entire applications and frameworks.

Engaging, practical, and accessible, Design Patterns in Ruby will help you build better software while making your Ruby programming experience more rewarding.

Manage It!: Your Guide to Modern, Pragmatic Project Management

Web Design in a Nutshell: A Desktop Quick Reference (In a Nutshell (O'Reilly))

HTML5 & CSS3 For The Real World

Programming Ruby: The Pragmatic Programmers' Guide, Second Edition

Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers)

Groovy Recipes: Greasing the Wheels of Java (Pragmatic Programmers)

Designing Web Interfaces: Principles and Patterns for Rich Interactions

The Zen of CSS Design: Visual Enlightenment for the Web

Proving once and for all that standards-compliant design does not equal dull design, this inspiring tome uses examples from the landmark CSS Zen Garden site as the foundation for discussions on how to create beautiful, progressive CSS-based Web sites. By using the Zen Garden sites as examples of how CSS design techniques and approaches can be applied to specific Web challenges, authors Dave Shea and Molly Holzschlag provide an eye-opening look at the range of design methods made possible by CSS (Cascading Style Sheets). By the time you've finished perusing the volume, you'll have a new understanding of the graphically rich, fully accessible sites that CSS design facilitates. In sections on design, layout, imagery, typography, effects, and themes, Dave and Molly take you through every phase of the design process--from striking a sensible balance between text and graphics to creating eye-popping special effects (no scripting required).

Java Message Service

The Java Message Service (JMS) provides a way for the components of a distributed application to talk asynchronously, or for welding together legacy enterprise systems. Think of it as application-to-application e-mail. Unlike COM, JMS uses one or more JMS servers to handle the messages on a store-and-forward basis, so that the loss of one or more components doesn't bring the whole distributed application to a halt.

JMS consists of a set of messaging APIs that enable two types of messaging, publish-and-subscribe (one-to-many) and point-to-point (one-to-one). The highly lucid explanation of the ways in which these work makes the technical content a lot more approachable. In practice, however, Java Message Service is still a book for Java programmers who have some business programming experience. You need the background.

After a simple JMS demonstration in which you create a chat application using both messaging types, the authors dissect JMS message structures, explore both types in detail, and then move on to real-world considerations. These include reliability, security, deployment, and a rundown of various JMS server providers. The appendices list and describe the JMS API, and provide message reference material.

Considering the complexity and reach of the subject matter, Java Message Service does a great job of covering both theory and practice in a surprisingly efficient manner. It's easy to see why JMS has become so popular so quickly. Recommended. --Steve Patient, Amazon.co.uk

REST in Practice: Hypermedia and Systems Architecture

Java Servlet Programming (Java Series)

Aimed at Web developers with some previous Java experience, Java Servlet Programming, Second Edition, offers a solid introduction to the world of Java development with Servlets and related technologies. Thoroughly revised and newly updated with over a half-dozen new chapters, this title brings an already useful text up to speed with some leading-edge material. It excels particularly in explaining how to program dynamic Web content using Java Servlets, with a fine introduction to all the APIs, programming techniques, and tips you will need to be successful with this standard.

Besides a useful guide to APIs, the book looks at a variety of techniques for saving session state, as well as showing how Servlets can work together to power Web sites. You will learn performance tips and ways to get Servlets to work together (like forwarding and redirection), plus the basics of database programming with JDBC, to build content with "live" data. A later chapter examines what's next for Servlets with the emerging Servlet 2.3 API standard. Importantly, the authors go over deploying and configuring Web applications by editing XML files, a must-have for successfully running Servlets in real applications.

Since the first edition of this title, the choices for Java Web developers have grown much richer. Many of the new chapters in this edition look at options beyond Servlets. Short sections on application frameworks such as Tea, WebMacro, the Element Construction Set (ECS), XMLC, and JavaServer Pages (JSP) let you explore what's out there for Java developers today with a survey of some current tools that can speed up creating new Web applications.

The text closes with reference sections on Servlet APIs (and other material) that will be useful for any working developer. Although Servlets are not the only game in town, they are still important tools for successful Web development. This updated edition shows you just how to do it with plenty of basic and advanced tips for taking full advantage of this powerful Java standard. --Richard Dragan

Topics covered:

• Overview and history of Java Servlets
• Fundamentals of HTTP
• Web applications (including deployment and configuration using XML files)
• The Servlet lifecycle (initializing, processing requests, cleanup, and caching)
• Multimedia content (images and compressed content)
• WAP and WML for wireless content
• Servlet session tracking techniques (hidden form fields, cookies, and URL rewriting)
• Security issues with Servlets (including certificates and SSL)
• Tutorial for JDBC and Java database programming
• Using applets and Servlets together
• Servlet collaboration
• Quick introduction to Java 2 Enterprise Edition (J2EE)
• Internationalization issues
• Survey of third-party Servlet application frameworks and tools: Tea, WebMacro, the Element Contruction Set (ECS), XMLC, and JavaServer Pages (JSP)
• Miscellaneous tips for Servlets (including sending e-mail and using regular expressions)
• Description of the new Servlet 2.3 API spec
• Servlet API quick reference

The Definitive Guide to Grails 2

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

Practices of an Agile Developer: Working in the Real World (Pragmatic Bookshelf)

JBoss at Work: A Practical Guide

Head First Software Development

Learning HTML5 Game Programming: A Hands-on Guide to Building Online Games Using Canvas, SVG, and WebGL

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.

 

Oracle Coherence 3.5

This title covers Coherence features progressively, from simple to more advanced topics, and provides best-practice guidance on when and how to use each. Numerous examples are provided throughout the book that will help you become familiar with Coherence APIs. You will also be able to reuse many of the sample classes or mini-frameworks encapsulating Coherence best practice and providing missing features directly within your own applications. This should significantly increase your productivity when developing Coherence applications. Finally, a sample application that you can download from the companion web site will show you how to use Coherence as part of the broader infrastructure stack, including Spring Framework and Hibernate, as well as how to access Coherence from a WPF-based .NET desktop application. This book is written for architects and developers responsible for the design and development of Internet or Enterprise applications (web-based or otherwise) that need to scale to support a large number of simultaneous users, while at the same time providing fast response times and high availability. The book assumes a solid knowledge of Java, and a familiarity with Domain Driven Design (DDD) is helpful.

Grails in Action

The Definitive Guide to Grails (Expert's Voice in Web Development)

The rise of Ruby on Rails has signified a huge shift in how we build web applications today; it is a fantastic framework with a growing community. There is, however, space for another such framework that integrates seamlessly with Java. Thousands of companies have invested in Java, and these same companies are losing out on the benefits of a Rails–like framework. Enter Grails.

Grails is not just a Rails clone. It aims to provide a Rails–like environment that is more familiar to Java developers and employs idioms that Java developers are comfortable using, making the adjustment in mentality to a dynamic framework less of a jump. 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 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 Rails 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.

Professional JavaScript for Web Developers

Professional JavaScript for Web Developers, 2nd Edition, provides a developer-level introduction along with the more advanced and useful features of JavaScript.

Starting at the beginning, the book explores how JavaScript originated and evolved into what it is today. A detailed discussion of the components that make up a JavaScript implementation follows, with specific focus on standards such as ECMAScript and the Document Object Model (DOM). The differences in JavaScript implementations used in different popular web browsers are also discussed.

Building on that base, the book moves on to cover basic concepts of JavaScript including its version of object-oriented programming, inheritance, and its use in various markup languages such as HTML. An in-depth examination of events and event handling is followed by an exploration of browser detection techniques and a guide to using regular expressions in JavaScript. The book then takes all this knowledge and applies it to creating dynamic user interfaces.

The last part of the book is focused on advanced topics, including performance/memory optimization, best practices, and a look at where JavaScript is going in the future.

This book is aimed at three groups of readers:

• Experienced developers familiar with object-oriented programming who are looking to learn JavaScript as it relates to traditional OO languages such as Java and C++
• Web application developers attempting to enhance the usability of their web sites and web applications
• Novice JavaScript developers aiming to better understand the language

In addition, familiarity with the following related technologies is a strong indicator that this book is for you:

• Java
• PHP
• ASP.NET
• HTML
• CSS
• XML

This book is not aimed at beginners who lack a basic computer science background or those looking to add some simple user interactions to web sites. These readers should instead refer to Wrox’s Beginning JavaScript, 3rd Edition (Wiley, 2007).

This book covers:

• What Is JavaScript?—Explains the origins of JavaScript: where it came from, how it evolved, and what it is today. Concepts introduced include the relationship between JavaScript and ECMAScript, the Document Object Model (DOM), and the Browser Object Model (BOM). A discussion of the relevant standards from the European Computer Manufacturer’s Association (ECMA) and the World Wide Web Consortium (W3C) is also included.
• JavaScript in HTML—Examines how JavaScript is used in conjunction with HTML to create dynamic web pages. Introduces the various ways of embedding JavaScript into a page, including a discussion surrounding the JavaScript content-type and its relationship to the element.
• Language Basics—Introduces basic language concepts, including syntax and flow control statements. Explains the syntactic similarities of JavaScript and other C-based languages and points out the differences. Type coercion is introduced as it relates to built-in operators.
• Variables, Scope, and Memory—Explores how variables are handled in JavaScript given their loosely typed nature. A discussion about the differences between primitive and reference values is included, as is information about execution context as it relates to variables. Also, a discussion about garbage collection in JavaScript explains how memory is reclaimed when variables go out of scope.
• Reference Types—Covers all of the details regarding JavaScript's built-in reference types, such as Object and Array. Each reference type described in ECMA-262 is discussed both in theory and how they relate to browser implementations.
• Object-Oriented Programming—Explains how to use object-oriented programming in JavaScript. Since JavaScript has no concept of classes, several popular techniques are explored for object creation and inheritance. Also covered is the concept of function prototypes and how that relates to an overall OO approach.
• Anonymous Functions—Explores one of the most powerful aspects of JavaScript: anonymous functions. Topics include closures, how the this object works, the module pattern, and creating private object members.
• The Browser Object Model—Introduces the Browser Object Model (BOM), which is responsible for objects allowing interaction with the browser itself. Each of the BOM objects is covered, including window, document, location, navigator, and screen.
• Client Detection—Explains various approaches to detecting the client machine and its capabilities. Different techniques include capability detection and user-agent string detection. Each approach is discussed for pros and cons as well as situational appropriateness.
• The Document Object Model—Introduces the Document Object Model (DOM) objects available in JavaScript as defined in DOM Level 1. A brief introduction to XML and its relationship to the DOM gives way to an in-depth exploration of the entire DOM and how it allows developers to manipulate a page.
• DOM Levels 2 and 3 Explains how DOM Levels 2 and 3 augmented the DOM with additional properties, methods, and objects. Compatibility issues between Internet Explorer and other browsers are discussed.
• Events—Explains the nature of events in JavaScript, where they originated, legacy support, and how the DOM redefined how events should work. A variety of devices are covered, including the Wii and iPhone.
• Scripting Forms—Looks at using JavaScript to enhance form interactions and work around browser limitations. Discussion focuses on individual form elements such as text boxes and select boxes and on data validation and manipulation.
• Error Handling and Debugging—Discusses how browsers handle errors in JavaScript code and presents several ways to handle errors. Debugging tools and techniques are also discussed for each browser, including recommendations for simplifying the debugging process.
• XML in JavaScript—Presents the features of JavaScript used to read and manipulate eXtensible Markup Language (XML) data. Explains the differences in support and objects in various web browsers, and offers suggestions for easier cross-browser coding. This also covers the use of eXtensible Stylesheet Language Transformations (XSLT) to transform XML data on the client.
• ECMAScript for XML—Discusses the ECMAScript for XML (E4X) extension to JavaScript, which is designed to simplify working with XML. Explains the advantages of E4X over using the DOM for XML manipulation.
• Ajax and JSON—Looks at common Ajax techniques, including the use of the XMLHttpRequest object and Internet Explorer's XDomainRequest object for cross-domain Ajax. Explains the differences in browser implementations and support as well as recommendations for usage.
• Advanced Techniques—Dives into some of the more complex JavaScript patterns, including function currying, partial function application, and dynamic functions. Also covers creating a custom event framework to enable simple event support for custom objects.
• Client-Side Storage—Discusses the various techniques for storing data on the client machine. Begins with a discussion of the most commonly supported feature, cookies, and then discusses newer functionality such as DOM storage.
• Best Practices—Explores approaches to working with JavaScript in an enterprise environment. Techniques for better maintainability are discussed, including coding techniques, formatting, and general programming practices. Execution performance is discussed and several techniques for speed optimization are introduced. Last, deployment issues are discussed, including how to create a build process.
• Upcoming APIs—Introduces APIs being created to augment JavaScript in the browser. Even though these APIs aren't yet complete or fully implemented, they are on the horizon and browsers have already begun partially implementing their features. Includes the Selectors API and HTML 5.
• The Evolution of JavaScript—Looks into the future of JavaScript to see where the language is headed. ECMAScript 3.1, ECMAScript 4, and ECMAScript Harmony are discussed.

JavaServer Faces 2.0, The Complete Reference

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

Behind Closed Doors: Secrets of Great Management (Pragmatic Programmers)

Beginning Groovy and Grails: From Novice to Professional

Web frameworks are playing a major role in the creation of today's most compelling web applications, because they automate many of the tedious tasks, allowing developers to instead focus on providing users with creative and powerful features. Java developers have been particularly fortunate in this area, having been able to take advantage of Grails, an open source framework that supercharges productivity when building Java–driven web sites. Grails is based on Groovy, which is a very popular and growing dynamic scripting language for Java developers and was inspired by Python, Ruby, and Smalltalk.

Beginning Groovy and Grails is the first introductory book on the Groovy language and its primary web framework, Grails.

This book gets you started with Groovy and Grails and culminates in the example and possible application of some real–world projects. You follow along with the development of each project, implementing and running each application while learning new features along the way.

What you’ll learn

• Understand the fundamentals of the open source, dynamic Groovy scripting language and the Grails web framework.
• Capitalize upon Grails’ well–defined framework architecture to build web applications faster than ever before.
• Improve your web application with cutting–edge interface enhancements using Ajax.
• Use Grails’ object–relational mapping solution, GORM, to manage your data store more effectively than ever before.
• Take advantage of Groovy to create reporting services, implement batch processing, and create alternative client interfaces.
• Deploy and upgrade your Grails–driven applications with expertise and ease.
• Discover an alternative client in Groovy as well.

Who this book is for

Java and web developers looking to learn and embrace the power and flexibility offered by the Grails framework and Groovy scripting language.

Building and Testing with Gradle

Presentation Patterns: Techniques for Crafting Better Presentations

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.

Beginning Spring Framework 2

The Spring Framework is designed from the ground up to make it easier than ever to develop server-side applications with Java Enterprise Edition. With this book as your guide, you’ll quickly learn how to use the latest features of Spring 2 and other open-source tools that can be downloaded for free on the web. With each subsequent chapter, you’ll explore an area of Spring application design and development as you walk through the steps involved in building a larg production-scale example.

Manage Your Project Portfolio: Increase Your Capacity and Finish More Projects (Pragmatic Programmers)

Designing Web Navigation: Optimizing the User Experience

GIS for Web Developers: Adding 'Where' to Your Web Applications

Java Application Architecture: Modularity Patterns with Examples Using OSGi (Robert C. Martin Series)

“I’m dancing! By god I’m dancing on the walls. I’m dancing on the ceiling. I’m ecstatic. I’m overjoyed. I’m really, really pleased.”

–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.

Professional Java Development with the Spring Framework

The Spring Framework is a major open source application development framework that makes Java/J2EE(TM) development easier and more productive. This book shows you not only what Spring can do but why, explaining its functionality and motivation to help you use all parts of the framework to develop successful applications.

You will be guided through all the Spring features and see how they form a coherent whole. In turn, this will help you understand the rationale for Spring's approach, when to use Spring, and how to follow best practices. All this is illustrated with a complete sample application. When you finish the book, you will be well equipped to use Spring effectively in everything from simple Web applications to complex enterprise applications.

What you will learn from this book
* The core Inversion of Control container and the concept of Dependency Injection
* Spring's Aspect Oriented Programming (AOP) framework and why AOP is important in J2EE development
* How to use Spring's programmatic and declarative transaction management services effectively
* Ways to access data using Spring's JDBC functionality, iBATIS SQL Maps, Hibernate, and other O/R mapping frameworks
* Spring services for accessing and implementing EJBs
* Spring's remoting framework

Who this book is for

This book is for Java/J2EE architects and developers who want to gain a deeper knowledge of the Spring Framework and use it effectively.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Beginning Groovy and Grails: From Novice to Professional

Web frameworks are playing a major role in the creation of today's most compelling web applications, because they automate many of the tedious tasks, allowing developers to instead focus on providing users with creative and powerful features. Java developers have been particularly fortunate in this area, having been able to take advantage of Grails, an open source framework that supercharges productivity when building Java–driven web sites. Grails is based on Groovy, which is a very popular and growing dynamic scripting language for Java developers and was inspired by Python, Ruby, and Smalltalk.

Beginning Groovy and Grails is the first introductory book on the Groovy language and its primary web framework, Grails.

This book gets you started with Groovy and Grails and culminates in the example and possible application of some real–world projects. You follow along with the development of each project, implementing and running each application while learning new features along the way.

What you’ll learn

• Understand the fundamentals of the open source, dynamic Groovy scripting language and the Grails web framework.
• Capitalize upon Grails’ well–defined framework architecture to build web applications faster than ever before.
• Improve your web application with cutting–edge interface enhancements using Ajax.
• Use Grails’ object–relational mapping solution, GORM, to manage your data store more effectively than ever before.
• Take advantage of Groovy to create reporting services, implement batch processing, and create alternative client interfaces.
• Deploy and upgrade your Grails–driven applications with expertise and ease.
• Discover an alternative client in Groovy as well.

Who this book is for

Java and web developers looking to learn and embrace the power and flexibility offered by the Grails framework and Groovy scripting language.

Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (Pragmatic Programmers)

Ship it! A Practical Guide to Successful Software Projects