Category Archives: Book Review

Book Review : Instant Responsive Web Design [Instant] – Cory Simmons

Quick and to the point 

RWD is short introduction to designing responsive web pages. It includes start code, some best practices and lots of pointers to information that will help you learn more about responsive web. It is written in a simple and clear manner keeping it short and to the point. The author focuses on the main point and you can read this book and try out lots of code in a day.

Some examples of what is covered in the book:
1. media queries like max-width, braille, handheld
2. screen, print interface
3. Different strategies to make responsive websites
Goldilocks Approach
The Fluid Approach
4. Design aspects
Desktop first v Mobile first
5. Media
Images and Movie responsive

Table of Contents
Instant Responsive Web Design
Instant Responsive Web Design
So, what is Responsive web design (RWD)?
Getting started
Quick start – making your first responsive web page
Step 1 – creating an HTML page
Step 2 – adding a stylesheet
Step 3 – making it responsive
Top 5 features you need to know about
The power of CSS Media Queries
Media types
Logical operators
Different strategies to make responsive websites
The Goldilocks approach
The Fluid approach
Desktop-first versus Mobile-first
Desktop-first
Mobile-first
Gotchas and best practices
Putting it all together
People and places you should get to know

Download code : http://www.packtpub.com/support/14547
Link to book : http://www.packtpub.com/responsive-web-design/book

Advertisements

Book Review : Grails 1.1 Web Application Development

 
Grails 1.1 Web Application Development(Jon Dickinson – $35.99 Amazon)
(https://www.packtpub.com/grails-1-0-web-application-development/book)
Table Of Contents http://www.packtpub.com/article/grails-1-0-web-application-development-table-of-contents
Preface
Chapter 1: Getting Started with Grails
Chapter 2: Managing Users with Scaffolding
Chapter 3: Posting Messages
Chapter 4: Introduction to Groovy
Chapter 5: Authentication with JSecurity Plug-in
Chapter 6: Testing
Chapter 7: File Sharing
Chapter 8: More GORM and Criteria
Chapter 9: Services
Chapter 10: Managing Content through Tagging (sample chapter)
Chapter 11: AJAX and RIA Frameworks
Chapter 12: Searching, RSS, and REST Services
Chapter 13: Build Your Own Plug-in
Chapter 14: Deployment and the Real World
Index

Tag Line: Reclaiming Productivity for Faster Java Web Development
The target audience are Java developers looking for ways to develop web applications faster and more easy without throwing away their previous knowledge or leaving the java platform. Grails utilizes Java and other related proven technical libraries under the covers. With very simple explanation of basics the author tries to lure the average Java programmer to take a second look. But the book gets too technical and complex in some parts as it touches unwanted territory. Prior knowledge of java web application development is required.

Chapter 1: Getting Started with Grails
Right upfront an argument is given as to why Grails should be used and how it is based on proved technologies like Hibernate and Spring. The chapter lists the following important points in favor of Grails:-

  • Requiring less configuration
  • Faster setup
  • Shorter develop/test cycle
  • Consistent development environment
  • Domain-specific language for web development
  • Fewer dependencies

Perhaps some of the points would have been Grails v Java or Grails v Rails.
This is followed by installation of Grails. I think this is a very important and many books do not cover such topics. This part is has Windows and Mac screen shots. This follows creation of a new application called teamwork using create-app command. This creates the skeleton for domain, views, controller, conf, i18n, helper services, taglibs. To run this application run-app command is used.
Throughout the book a team communication portal application is used. The requirements and architecture of this application is explained in brief.

Chapter 2: Managing Users with Scaffolding
This explains the use of scaffolding and what pages and actions to expect as a result. Domain classes are created for the application using create-domain-class command. Controllers are created for all the domain classes using create-controller command. The def scaffold =DomainClassName magically creates all the CRUD code necessary for the application to work.
Grails uses in-memory HSQLDB database by default and at this point no configuration is necessary to get this started. Introducing static constraints helps in basic validation of data and to determine which input type is used when rendering a form. This is to get your application running quick but I hardly find a real-life example of this. Most databases are full of complex composite keys and foreign keys which cannot be modeled with scaffolding and need a lot of customization in Grails.
Relationships are created in this application. Since Grails uses hibernate under the covers the supported types of relationships are: One-to-one, One-to-many, Many-to-many, Many-to-many. Bootstrapping of data is done though grails-app/conf/BootStrap class which helps in loading data into the application on start up.
In short a fully loaded chapter to get started.

Chapter 3: Posting Messages
I find the title of this chapter irrelevant to Grails. Chapters should be given names relevant to Grails context and not application/example context. In this chapter the author talks about basic building blocks of grails – more domain classes, respective controllers and views, validation and GORM (Grail’s Object Relational Mapping). dateCreated and lastUpdated are very special properties of type Date in Grails and they are handled automatically. This time the controller is not created with create-controller command but rather a file is directly created in the appropriate directory.
Groovy Server Pages (GSP) are introduced as being similar to JSP. The view code is then provided and again the command is not used for create.gsp. Grails uses simple yet powerful SiteMesh layout mechanism which uses tags g:layoutTitle, g:layoutHead, and g:layoutBody. There is more manual code to get the form appropriately displayed along with a short note about grails form tags g:form
The Grails input form, Grails form binding, validation and save cycle of Grails is explained briefly. The flash scope which holds the success or failure message between two consecutive HTTP requests is added. redirect is used to forward the user after a successful operation while render is used to show error information back to the user in order to correct it and re-send it.
The application home page creation is explained – domain, controller and views. Detailed explanation is provided of listing all messages by querying the database as well as the valid parameters for the list method. The author then explains how to change the default home page to go through the home controller index action. This is important when using plug-ins like cas for Single Sign On. The css style sheets are updated with the code available with the book. The author ends with an excellent section on cross-site scripting and validation. Grails provides a g:message tag that is used to look up messages in a message bundle based on a message code. This explains how i18n can be used in Grails.

Chapter 4: Introduction to Groovy
Groovy is the primary language used in Grails. This chapter covers some high level basics of Groovy with respect to Java, installation, data structures, closures, POGO, metaprogramming, builders. Definition of Groovy along with explanation of its properties are explained – Object Oriented, Dynamic and functional loosely typed. Similarly there are questions why Groovy makes software development simpler : familiar syntax like Java & direct integration into Java. The next phase takes us into how to install and configure Groovy on local PC and Mac. Groovy shell is a command line where you can type up some Groovy code. The Groovy console is a Swing application which allows user to write and execute Groovy scripts. This follows an explanation of difference between Groovy classes v scripts – Groovy scripts having less overhead and simpler to write.
All the basic features of Groovy language are explained including-
Optional Semicolons, different ways to express String, Numbers and utility methods, easier way to work with List, enhanced Maps, Range – which is a new data type to simplify iteration and work with collections, slightly different way to operate with Truth and equality, Closures – blocks of code which can be passed as arguments and executed, Plain Old Groovy Objects (POGO) whose properties are published as getters and setters automatically, Metaprogramming – also called Dynamic Groovy or compile-time metaprogramming and builders. All these features are well explained with simple examples which makes for good understanding of concepts.
This chapter was a welcome adding to the Grails book.

Chapter 5: Authentication with JSecurity Plug-in
This is where the power of Grails lies – the plug-ins! Some basic functionality would be developed as modules by programmers and made available to the world as plug-in. Installing a plug-in and following some simple configuration would give your Grails application some new features with cheap coding. Firstly, I would advise you to be careful of plug-ins since they are a double edged sword – in terms of who have developed them and the testing. Secondly, some plug-ins just don’t work as advertised!!
The author has given example of JSecurity plug-in. This can be an excellent start for someone who is yet to think of a security strategy. Honestly it is scary for those who are new to plug-ins and find it so many pages to go through to get started. I would have loved to play with simple plug-ins like searchable, cas, filter pane. Such plug-ins are more commonly used. The author has used basic idea of users and roles. JSecurity system covers users, roles, permissions, subject, principle and realms (Realm class) . A method is defined to allow authentication. This is where the concept of dynamic finders is introduced. These methods do not exist but the name of method is used by Grails to query against database. There is good coverage of this topic including the operators that can be used for constructing the method name and their limitations. Querying by Criteria is explained with hasRole method which tests if a user has a particular role. Such queries are more complex and more widely used. But the explanation is short. Authentication is added to the Grails application using a Grails Filters which is quick and easy. Password encryption is achieved through Sha1Hash. This spins my head into thinking whether I want to really learn JSecurity or stick with my good old cas filter. It feels I am learning cryptography and not grails! Three more things are discussed which are: 1. Encryption of users’ password: This uses the ‘Open Session in View’ pattern of hibernate which means the object is not persisted until all server-side operations have finished and the author actually changes the password after calling save method – Neat! 2. Permission denied page: This is done by implementing the unauthorized action in AuthController and creating unauthorized.gsp view. 3. Sign Out: This uses the signout tag provided by JSecurity which leads to a table listing of all JSecurity tags. The service layer of Grails and how to inject the service is discussed very briefly.
Hibernate’s lazy loading property and how it affects the relationships in an application is discussed. The n+ 1 problem can be solved with eager loading (lazy:false)
In short, I feel this chapter was more a case study. There is a potpourri of new topics which are all discussed in short – plug-ins, JSecurity, authentication, authorization, encryption of passwords, services, lazy loading, eager loading, relationships to name a few – phew!

Chapter 6: Testing
This chapter starts with a background of testing. A couple of the links were very weird – pointing to a yahoo group? The chapter then goes on to define why tests are needed and how to write tests. There is a basic review of JUnit concepts before diving into how Grails leverages JUnit and extends it with some useful methods. The focus of the chapter is on unit testing, mocks, integration and functional testing (Functional Test plug-in) The author goes into detail to explain what makes a good test which touches the assumption of your libraries to be perfect, testing production code and using descriptive test names. A listing of all assertion methods and Grails provided assertion methods are provided. Most of this is self-descriptive but the shouldFail and shouldFailWithCause are explained with examples since they take a closure. When create commands are executed a test case is automatically created. A testcase is created by extending GrailsUnitTestCase. Running the test creates an HTML report.
An important point brought out is that the dynamic methods and properties supported by Grails framework are not available when running unit tests since they do not run within the Grails container. Mocking support helps us solve this issue. An in-depth example explains this behavior. This example also uses the delegate property on the closure. After testing the metacontroller the next test is of validations. Unit testing limitations are explained which leads to Integration testing. Integration testing is explained with only one example.
Limitations of Integrations test brings us to functional test. Functional testing is achieved in Grails through plug-ins eg. HtmlUnit. The book takes us through the installation of the functional-test plug-in and creation of functional test case for login.
I had a few issues getting the code to work. But overall a good attempt has been made to demystify the details of why we need tests, what are the different types of tests available and how to best take advantage of them.

Chapter 7: File Sharing
Grails has good support for file upload and download. To accomplish this a File domain is created with necessary attributes like data, name, size etc. Two methods of uploading are discussed 1. Using data binding, 2. Using Spring MultipartFile interface. The code uses the latter to achieve desired results. This model results in a file being loaded into the memory. Using the fact that relationships between domain objects are lazy by default the author then creates a more efficient model by extracting data out of the model thus creating a new domain called FileData containing this binary data. Thus FileData belongsto File. The last piece is the downloading controller and gsp. I found some glitches in the code.

Chapter 8: More GORM and Criteria
This talks about maintaining version history and advanced query techniques through GORM. Through Data Modeling, existing responsibilities of File class are extracted into FileVersion domain and FileData now belongsTo FileVersion. This makes the File class simply a container of FileVersion. (hasMany FileVersion). The explicit declaration of the version property as a SortedSet tells Grails that the items contained in this relationship must be ordered. This moves the discussion to criteria queries which help to retrieve data. This is where Grails taps into the power Hibernate (HibernateCriteriaBuilder) which is built on top of Hibernate criteria API. Dynamic finders in Chapter 5 are replaced with criteria equivalents. Each node is used to build on the criteria. Logical operators and Querying across relationships is explained next. The change in code affect the Hibernate EAGER fetch. There is discussion of fetchMode.EAGER which can be used to restore it. Table containing a full list of available criteria and logical operators for nodes is listed. There is not a lot of discussion of properties of criteria except for maxResults but links to Projections and Scrollable Results are provided.
This discussion leads to code changes in other layers. Updates to create method in controller and view are explained. Due to the domain changes, the save method in controller also needs to be changed. I observed that there is no error handling in the code and view.

Chapter 9: Services
Introduction explains why we need the service layer so that we can leave the controller to just handling the control of flow. This makes the service layer more testable and reusable and there is clear boundary where the business logic is placed. The command to create a Service is given which results in a Service class in appropriate directory. Grails uses Spring’s declarative transactions. boolean transactional = false removes this transactional behavior. Similarly, Grails uses Dependency Injection mechanism to inject services into domain objects. This is an interesting and detailed discussion since Grails uses convention over configuration. It is so simple to write def fileService and inject an instance of FileService using loose typing without reloading application.
Strongly typed property FileService fileService can be injected but needs application restart. Services by default are singletons, and hence not thread-safe. Scopes of the Service can be changed using property static scope=’prototype’. There is a table listing all scopes. The code is then modified to extract as much business logic from Controller into service as possible. How and why this is extracted and modified is explained. Thus the Controller is simplified.

Chapter 10: Managing Content through Tagging (sample chapter)
Being a Grails book, I would have thought of a better Chapter title. Check out this chapter online with the link given above.
The concepts discussed here are :

  • Working with inheritance in the domain classes, and looking at which strategies GORM supports for persistence
  • Using polymorphic queries over a domain inheritance hierarchy
  • Encapsulating view-rendering logic in GSP templates
  • Manipulating collections with the Groovy collect and sort methods

The Tagging Domain model is discussed and a new directory is created to separate the tagging classes from application domain classes.
Tag—to store the name of the tag
Tagger—to store the relationship from domain objects to a tag.
The domain classes are created and a service is created TagService having methods to create tag relationships. The collect method is used here as explained in Chapter 4. Elvis operator of Groovy is used in one of the methods.
Integration tests are created to make sure the relationships are working before introducing in application. During the integration tests the setUp method id overloaded and BootStrap class is used to create test data. Relationship with Message is created and TagService is injected. This is a very good and simple example of running Integration test.
Chapter 11: AJAX and RIA Frameworks
AJAX and rich applications have been the buzz word recently. This chapter touches on some plug-ins used for UI design in Grails. Grails uses Prototype framework for this support. remoteLink and formRemote tags of Grails are introduced and a complete listing of attributes and usage is provided. For inline editing of tags in the application Taggable controller is created. The author then takes us through the explanation of how this is to be done. I think this is an excellent start.
The next trick in UI design is the auto-complete of tags. There are two plug-ins: GrailsUI and RichUI out of which RichUI is explained in detail. Both these are developed on top of YUI. After installation, dynamic finder is used to match partial tag and come up with options. These options are converted to XML using renderAsXml method which take in a closure. This output is then used by the RichUI auto-complete widget richUI:autoComplete to create the autocomplete input field. Required gsps are created we are up and running. Beautiful example!
Another fashion is the the cloud of tags representing popularity. RichUI provides a component that handles all the client-side presentation work. The tag is richui:tagCloud. After a look at the available options we conclude that we need a map of tag and occurrences for this functionality. By adding another method to the service layer we get this matrix and controllers are changed to reflect this. listDistinct method is used on CriteriaBuilder inorder to get a distinct list. Clouds are then rendered using richui:tagCloud in appropriate gsps.
This chapter is beautifully written to capture user attention by tagging and then using these tags for auto-complete and clouds. This also helps in organizing and filtering content.

Chapter 12: Searching, RSS, and REST Services
This chapter introduces some more excellent techniques to help customers. Grails has an excellent plug-in for search : searchable plug-in which uses Lucene as the back-bone. This plug-in is easy to install and use. But people have just seen the tip of the iceberg. When I tried this plug-in on some complex projects with composite key relationships it wouldn’t work. The project is pretty active and I hope all bugs get fixed. But by just including one line in the domain we can make a class searchable static searchable = true. Honestly, I used this section to make my first site-wide search and integrate it into my grails application. I was very pleased with the explanation. The trick is to create a search box in main.gsp and then create search controller which uses the search service to provide results. The results can be viewed by creating index.gsp in the search directory. The book then takes us into how to integrate this search in the application by adding code to main.gsp which is shared across pages as a header and creating a search controller which get its results from a search service. This SearchableService (provided by the plug-in) is injected into the controller. There are further changes to views and templates to display the search results.
This takes us into RSS feeds which is useful for customers to track new content. Grails has a Feeds plug-in built on ROME API. But the author takes this opportunity to introduce Builders in Grails rather than using this plug-in. Surprisingly, there is no definition about builders or why we use them!! To get around the problem of dynamic methods in controllers a separate utility class is created with a collection of items and closure. This is then called the controller to achieve desired results. Authorization is removed from this RSS which in terms of design seems wrong.
The last part takes us through REST support in Grails which is url based. This just involves tweaking the url mappings, controllers and security for handling HTTP method and XML data. Various URL mapping configurations in Grails are explained by snippets of code. The controller makes use of Grails converters (as XML). This should be used carefully when providing interfaces to clients. This follows  a scheme for authentication of REST API messages through the same JSecurity scheme. The credentials are passed in the header of the request through the Spring application context. A script is used to test REST.

Chapter 13: Build Your Own Plug-in
Plug-ins are the selling point of Grails and they want you to write plug-ins! The book takes you into how to develop a tagger plug-in. Grails plug-ins are created similar to an application using grails create-plug-in command which creates a directory structure of an application plus a configuration file for the plug-in. This configuration file contains version, author and lifecycle details. The code previously used in the application is stripped out and plugged into this plug-in application. The plug-in templates are then exposed as tag libraries to applications so that the GSPs can render the appropriate templates. Similarly these templates can also be rendered through controllers.
The author then exposes an ugly flaw in the plug-in which is the domain classes need to extend the Taggable class for the plug-in to work. Later we are taught how to package a plug-in and create a distributable zip file which can then be installed using install-plug-in command.
The rest of the chapter talks about how to tap into the lifecycle events- (build time and run time) through Grails plug-ins. The Build events are not described in detail but the runtime events are explored in detail with regards to what they do and how they can be used. Runtime event handlers are enabled by declaring a closure with the relavant name in *Plugin descriptor class. The book then talks about inspecting Grails artifacts in this case all Grails classes to find a static property value of taggable. If found means the domain is taggable. The rest of the chapter talks about how to re-model the relationships between a domain object and its tags to remove the dependency and how to add taggable behavior into the application. This gets very complex and is beyond the scope if you are new to Grails.
I wish writing plug-ins was as easy as described in this chapter! Writing plug-ins is a major investment and even I would say half of the Grails plug-ins have unsolved issues with them. This also requires deep understanding of Groovy and meta-programming. The benefit is of course you have made a reusable component for the future.

Chapter 14: Deployment and the Real World
This chapter deals with installing and configuring MySQL and Tomcat to run on your system. The DataSource definitions in Grails are extracted out to DataSource.groovy with clear distinction between development, test, production.
To summarize, it was a good read. There are simple running examples of code tutorials. I would have liked advanced examples of the plug-ins like searchable. Filter pane which is an important plug-in is missing in the book. The Grails web site also has pretty simple and straightforward examples to learn from. Unfortunately for the book, plug-ins are the heart of Grails and keep updating. I wouldn’t be surprised if the code runs out of date in a short period. I would have definitely liked more structured matter. Working in Grails – I find the biggest challenge is interacting with legacy database. There might be doubts about the correctness of the code and pattern used but it is important to remember that this is a starter book.

Who can use the book:
Starters who want to learn Grails. It assumes prior web development experience with Java & web applications. It contains a robust example of a web application being developed – a team communication portal.
You can visit http://www.packtpub.com/support/book/grails-1-0-web-application-development to directly download the example codes in the book

Language English
Paperback 328 pages [191mm x 235mm]
Release date May 2009
ISBN 1847196683
ISBN 13 978-1-847196-68-2
Author(s) Jon Dickinson
Topics and Technologies Open Source, Java, Web Development

About the Author (As on the site)
Jon Dickinson is the principal consultant and founder of Accolade Consulting Ltd. (http://www.accolade-consulting.co.uk) and can be contacted at jon@accolade-consulting.co.uk. He specializes in developing web applications on the Java platform to meet the goals of users in the simplest and least obtrusive way possible.

Review – Spring Web Flow 2 Web Development

Spring Web Flow 2 Web Development (Sven Lüppken (Author), Markus Stäuble – $35.99 Amazon)


Table Of Contents
(http://www.packtpub.com/develop-powerful-web-applications-with-spring-web-flow-2/book/swfaop?utm_source=swfaop&utm_medium=website&utm_term=middle&utm_content=image&utm_campaign=packtpub.com#)
1. Introduction to Spring Web Flow
2. Setup of Spring Web Flow 2
3. The basics of Spring Web Flow 2
4. Spring Faces (Downloadable for free!! : http://www.packtpub.com/files/spring-web-flow-2-web-development-sample-chapter-4-spring-faces.pdf)
5. Mastering Spring Web Flow
6. Testing Spring Web Flow Applications
7. Security
Appendix A : flow.trac:The Model for the Examples
Appendix B : Running on the SpringSource dm Server

For those who would like to choose a web framework, this book deserves a glance.

From the documentation, Spring Web Flow is the module of Spring for implementing flows. The Web Flow engine plugs into the Spring Web MVC platform and provides declarative flow definition language.

The book directly dives into the details of the Spring Web Flow and where it stands as compared to the other layers of Spring like MVC. It has covered Spring Web Flow 2.0 in great depth and gets the Version 1 users up to speed with “whats changed”. Chapter 2 deals with the development environment and with this the book makes an exception from the (in)famous Hello World example into something more sophisticated. Now this is big in Spring where the web site lists simple one liner examples (most of them from the older versions – I have personally submitted bugs 😦 )

I like the way they explain the initial setup like
1. Build tools : Ant, Maven
2. The IDE configuration in Eclipse with “Spring IDE plugin” and Netbeans “Spring MVC plugin” is covered. Although IntelliJ and the Spring Source Tool Suite is missing.
There is also a quick start tutorial with examples (example applications provided within the Spring distributions), service and database layers, deployment description and dependencies (web flow, beans, views DispatcherServlet)
Spring Web Flow 2 release effort addresses two major themes: Integration and Simplicity. It focuses on providing the infrastructure for building and running rich web applications. As a Spring project, Web Flow builds on the Spring Web MVC framework to provide:

  • A domain-specific-language for defining reusable controller modules called flows
  • An advanced controller engine for managing conversational state
  • First-class support for using Ajax to construct rich user interfaces
  • First-class support for using JavaServerFaces with Spring

Modules of Spring Web Flow 2 :

http://static.springframework.org/spring-webflow/images/spring-webflow2-distribution.png
Spring Web Flow
Spring Faces
Spring JavaScript
Spring Binding

The book is written in a very simple understandable language in a step by step manner interlacing the code, explanation and example to create a running application in the end. Chapter 3 delves into the basics of Spring web flow including the elements of flow, entry point, section data, states, exit point, section footer and configuration (FlowRegistry, FlowExecuter etc..) There is a little bit about validation.

After the flows it moves to Spring Faces (integrates rich user interface with support for JSF) to deliver the GUI of the web application. Just the basics of JSF are explained to bring others up to speed. There are good details about the configuration (enabling Spring Faces support, ResourceServlet, application context) and the integration with other JSF component libraries like JBoss RichFaces and Apache MyFaces. There is a detailed listing of all the tags available in Spring Faces and a complete example of create input page, handling errors, actions of buttons, display of results. Note: the code is interspersed in the explanation. An important part of Chapter 4 is the explanation of the integration of RichFaces (richfaces is a component library for JSF).

Further the book goes deeper into Spring Web Flow with subflows, Spring JavaScript and AJAX. This is the most interesting section of the book. Apache Tiles integration and configuration is also covered although the book does introduce Apache Tiles 2. Detailed listing of all XML configuration elements of Spring Web Flow is defined with sample code.

Spring Web Flow has good support for unit test and the book has an exhaustive discussion on testing web flows including MockExternalContext, startFlow(), assert(), resumeFlow(). It explains how to test your flows, subflows, persistence contexts and also gives a short introduction to EasyMock, which helps you to create mock implementations of your interfaces to test services. There is a sample example and explanation of how to integrate a test-driven development approach.

The last chapter deals with integration of Spring Security in the Spring Web Flow – how to set it up, web.xml, application context configuration and advanced configuration, the different types of AccessDecisionManagers, AccessDecisionVoter, how to define roles and authorities and SecurityFlowExecutionListener. The example given shows how to retrieve users from a database and secure parts of a webpage or a method and changing user’s password.

And finally I read an interesting aspect of buying books from Packt publishing which is their commitment to open source. A great way to give back to the Open Source ecosystem.
“Packt Open Source Project Royalties”
When we sell a book written on an Open Source project, we pay a royalty directly to that project. Therefore by purchasing Spring Web Flow 2 Web Development, Packt will have given some of the money received to the Spring project.

In summary, I believe this is the good book for Spring Webflow. Through this book developers will be able to design, develop, and test your web applications using the Spring Web Flow 2 framework. They will also learn about the integration of JavaServer Faces (JSF) with Spring Web Flow, and how to organize and manage the storage of data inside their web applications. There is nothing about web services or GWT. Java developers will learn about the essential modules of the Spring Framework stack, and will be shown how to manage the control flow of a Spring web application. They will be introduced to Spring Faces, Spring JavaScript, and Spring Binding, and will learn how to improve the handling of the web flow. The functioning of the Testing, which is an important aspect of the software development process, is covered in this book, thus teaching developers how to go about using it in their Spring applications. In addition to this, users will also be ale to secure their web applications using Spring Security and Spring Web Flow. The chapters have enough code samples which helps you to setup an web project based on Spring Webflow.

Here is what thw authors have to say”In my opinion our book is different because it does not only explain how to create flows with Spring Web Flow, but also shows the integration with other technologies like JavaServer Faces, EasyMock, Hibernate, Spring Security and, additionally, how to use the powerful Spring JavaScript library (which is included with Spring Web Flow) to create compelling user interfaces. As written in the book, it is not designed to replace the reference documentation, but it includes step-by-step instructions which get you started with Spring Web Flow really quick.

Who can use the book:

Any beginner who wants to use the power of Spring web flow. It assumes prior basic knowledge of Spring and configuration. If you get into details you would need to know the basics of specific techniques like JSF, security before you can go though the chapter although there are some starting points.

The source code for the book can be downloaded at http://www.packtpub.com/files/code/5425_Code.zip
Paperback: 272 pages
Publisher: Packt Publishing (March 20, 2009)
Language: English
ISBN-10: 1847195423
ISBN-13: 978-1847195425
Product Dimensions: 9.2 x 7.5 x 0.7 inches

About the Authors (As on the site)
Sven Lüppken

Sven Lüppken has a degree in computer science, which he passed with distinction. He is currently employed as Java Software Developer at one of the leading broadcasting and production companies in Germany. Sven started programming in C and C++ at the age of 16 and quickly fell in love with the Java programming language during his studies.

When he got the chance to write his diploma thesis about object-relational mapping technologies he accepted at once.
Since then, he has integrated Hibernate and the JPA in many projects, always in conjunction with the Spring framework.

Markus Stäuble
Markus Stäuble is currently working as CTO at namics (deutschland) gmbh. He has a Master degree in Computer Science. He started programming with Java in the year 1999. After that he has earned much experience in building enterprise java systems, especially web applications. He has a deep knowledge of the java platform and the tools and frameworks around Java.