Overview
Got another opportunity to review a book from Packt Publication and that too related to ExtJS. As usual, it is a great feeling while reviewing and learning stuffs related to Sencha. The book, Enterprise Application Development with Ext JS and Spring by Gerald Gierer is intended to be a practical hands-on guide for developing large-scale enterprise level web application using Sencha’s Ext JS 4.x framework. After reading this book only one thing came to my mind again and again – why this book was not written 4-5 years ago when I was involved in active coding.
This book covers everything that you would expect a seasoned developer on your project to know. While it doesn’t cover the concepts in the greatest detail, it does set you up for the project development. This book uses typical Java Enterprise Application environment using Netbeans as the development IDE. While the concepts talked in this book are equally applicable for any kind of web application, the topics explained in this book are very important for any large scale enterprise application. The Task Time Tracker (3T) example used by the author demonstrates the whole life cycle of the application development. This book will give a great comfort to anyone who is new to the technology.
For a change, I hardly found anything which was not well written. However, there are points, which I really liked and I would like to mention some of the key points over here in my review comment.
What I really liked?
I have seen separate books on topics like Maven, MySQL, ExtJS, Hibernate & Spring, a lot of Jargon on Glassfish, etc. However, this book puts everything into perspective in little over 400 pages. Of course there is a lot of code into the book, which increases the page count, but overall it is a commendable job to put the whole thing into perspective into a single book.
The author has literally walked you through the complete lifecycle of application development. For example he has talked about
– Setting up environment
– Installing database
– Creating project
– Designing schema
– Password encryption
– Generating and using DAO
– Deciding on server side architecture and developing service layer
– Designing front end using MVC architecture
– Generating codes / project using Sencha command
– Build and Deployment Automation
– Logging & Tracing
– Allowing you to visualize how end-to-end process works
– Importance of Unit Test Suite
– Deploying in production
– etc
Also, the author keeps introducing all the technologies being talked in this book and at the same time there seem to be a conscious effort to remain focused on giving you a working example to guide you through the enterprise level project development. There would have been a huge scope of getting diverted and get too deep into one specific topic. However, the author has exhibited a great sense of balance by ensuring that people are able to follow and at the same time if they want to master those topics individually then they can refer to the dedicated books / materials on such topics. In nutshell, the author enables you to build application and guides you to refer to other materials for in-depth knowledge.
At many places the author has explained the tricky situations in which developers often find themselves into. For example
– on different operating system things may work differently and at many places author has explicitly mentioned about these differences
– similarly, there are situations where two or more choices (e.g. List Vs Set, GET vs POST, flat directories Vs structured directories) may look like fitting into the solution and in such cases author has mentioned his preference and the reason for that preference
The book is filled with the personal experience of the author and many times I could say “I was there and I have seen that”. Also, many times the authors has put strong recommendations and I felt that the message was really put in right context. This is why I feel that one should pay close attention to those experiences shared in this book so that he / she will make less mistake during the project development using similar set of technologies. In fact, the author has highlighted (generally a notes) various coding guidelines and best practices that one often see in a matured team and as a developer you must pay close attention to them; preferably review your existing coding guidelines and incorporate some of these comments into that.
The detailed coverage of the service layer testing and test automation did remind me of my early days when I switched from C++ to Java & J2EE. Seeing those jUnit test cases ticked was always fun and I am sure the reader will benefit from the documentation in this book.
The introduction of ExtJS and MVC architecture is again simple and effective. It walks you through the creation of models, stores, views, controllers and relationship among them. It uses sufficient components (e.g. viewports, grid, form, tree, templates, toolbars, combo box, summary features, Drag & Drop, etc) and eventually makes use of themes to give the reader the overall perspective.
Especially when you are starting a PoC (proof of concepts), which can lead to a big project in future then this book looks ideal. Of course you cannot have many people on the PoC and one person may not have all the knowledge required to be able to deliver an excellent PoC. This book just fits in nicely for such a critical PoCs.
The exercises in the end are really cool. Specially if you are a student who may not be involved in actual project (similar to explained in this book) then those exercises may prove to be very important in confirming your learning. I again consider this step as addressing concern of the larger audience.
While the developers will become more efficient in developing, debugging and testing, I am confident that by following the approaches listed in this book they team can save significant amount of dollars that are often spent on refactoring the code to meet the enterprise level expectations.
What could have been better?
I see following area where the book could have added more values:
- The diagrams were a bit plane and boring. For example a colorful diagram for demonstrating where the DAO layer sits, would have looked better to eyes.
- Most of the enterprise level applications takes care of scalability and load balancing. A chapter on that specific topic would have provided further completeness into this whole discussion.
- The UI Test Automation is another area, which people have started expecting in enterprise level application. Specially when things are getting developed in an agile mode, this has become very important topic. I felt that the book could have touched on that topic as well.
- While I was impressed with the server side explanation and specifically the way annotations were used to achieve various stuffs, I would have loved to see something on the documentation side (JSDuck) for ExtJS as well.
Additional Resources
While this book is an excellent resource, I will also recommend readers to refer to following learning material to master the related concepts and write better software
- Sencha MVC Architecture
- Ext JS 4 Web Application Development Cookbook
- Learning ExtJS
- Sencha Docs
- Sencha Tutorials
Where can I buy this?
You can buy this book on the following URL:
http://www.packtpub.com/enterprise-application-development-with-extjs-and-spring/book
Summary
I hope you find this review useful and it helps you to take better advantage of this book. Personally, I see that this book will be useful for anyone who is trying to execute an enterprise level project using ExtJS for the first time.
Along with Sencha, Walking Tree does endeavour to make application development as easy as possible. I am encouraged to see more and more people joining hands in this endeavour. Thank you Gerald Gierer for writing this book.
