Posts Tagged BookReview

Book Review: Selenium 1.0 Testing Tools

The Book

Title: Selenium 1.0 Testing Tools (Beginner's Guide)

Author: David Burns

Publishers: Packt Publishing


First half of the book is dedicated to Selenium IDE and the second half covers -- Selenium Remote Control (RC), Selenium Grid, and discusses the upcoming changes in Selenium 2.0.

This is a how-to book, a detailed step-by-step guide, with several screenshots. The book starts off with the installation and setup of Selenium and then proceeds to cover Locators and Pattern Matching in the subsequent chapters. If you could identify the elements on the web page that's a battle half won in the test automation. Various techniques are in display to locate the elements including XPath, CSS, element IDs, link text. Pattern matching covers finding elements by using regular expressions and globs.

There is a lot of emphasis on Selenium IDE. If you are someone who are not too comfortable writing test scripts using Selenium RC (API-driven) you can take the best advantage of the bulk of the book. Later on in the book, the author discusses how you can convert your IDE-based tests to Selenium RC (as you get more familiar with APIs).

The discussion on the Remote Control and Grid is adequate. Integration of Selenium with JUnit and TestNG is nice, very handy if you would like to run your tests in parallel.

Given that the Selenium 2.0 is going to be released very soon (in the next couple of months?), I'm not so sure why the author concentrated on 1.0 for the most part of the book. Last chapter of the book is dedicated to discuss Selenium 2.0 changes. If my understanding is correct, most of the impact from Selenium 2.0 is in the Remote Control side, merging WebDriver stuff. The book, in general, is organized very well. The only complaint I have in the organization is: in the earlier chapters, may be the author should have pointed out which APIs are changing or would get impacted because of Selenium 2.0.

This is a beginner's guide, as printed on the cover of the book. Nothing less, nothing more. If you are looking for more advanced techniques of functional/acceptance testing, and want to learn internals of Selenium then look elsewhere. But if you are starting out and have little or no familiarity with Selenium then this book can certainly help you to get upto speed real quick.


Tags: , ,

Book Review: REST in Practice

The Book

Title: REST in Practice (Hypermedia and Systems Architecture)

Authors: Jim Webber, Savas Parastatidis, Ian Robinson

Publisher: O'Reilly Media


Couple of years ago, the authors of this book penned one of the finest articles explaining the principles of REST titled How to GET a Cup of Coffee. I was so thrilled when I first heard that the same authors are expanding the concepts into a book form! Now that the book is out and I finished reading it, here are some of my thoughts ...

This book covers a wide spectrum of ideas related to the RESTful systems including RPC-style systems, CRUD-based services, hypermedia systems, caching, Atom syndication and publishing protocol, security, and semantic web. The key is too see HTTP as an application-level protocol and not as a transport protocol. Start with that basic understanding, each chapter in the book deal with various integration challenges in the enterprise. Heart of this book is the focus towards building the systems in a web-centric way.

As the concepts evolve from chapter to chapter they are evaluated against the Richardson's maturity model. At the base of the Richardson's model are the systems that use RPC-style (HTTP-as-transport-protocol) systems. The next level up, Level 1, are the systems that work in a resource-oriented model. Endpoints give way to thinking in terms of resources and URIs (e.g: OrderRequest end-point where a particular function on order is invoked vs. Order as a resource,

Going up the pyramid, Level 2 maturity is attained by conforming to a uniform interface (HTTP verbs) and well-known HTTP response codes. There are many systems that claim to be RESTful but don't go beyond Level 2  (I don't want to sound pedantic, but just pointing out!). There are other articles and books with good details about Level 1 and Level 2 systems. If there is one take away from this book I have to say it's the understanding of the Level 3 of the maturity model, hypermedia systems. HATEOAS (Hypermedia as the Engine of the Application State) principle has been often discussed in various forums but perhaps not that well understood.

As with their InfoQ article, Restbucks, a coffee store web-application, is being built as the discussion proceeds from simple concepts to the more advanced ones. A domain that almost everyone can identify with, and puts the focus on the technical discussion rather than on the domain model intricacies. REST in practice, as the name suggests, takes the approach of implementing the concepts as they are discussed; Java and .NET are used in the book. Reading code is some times easier than understanding the abstract concepts, if you are like me.

Discussion on Atom and Atom publishing protocol is one of the best. If you don't have low latency (in micro seconds) requirement Atom format is the one that has to be given a good consideration while designing event-driven systems. In the penultimate chapter the authors compare Web services (SOAP and WS-* stack) with web-based (REST) systems. They compared both models in great length with respect to security, reliability, transaction management (including two-phase commits). A compelling read for anybody who is trying to get a hang of what these models offer.

Subbu Allamaraju's RESTful Web Services Cookbook is one of my favorites on the topic. I was fortunate enough to read the book during it's draft stage, which actually helped me immensely in understanding and reinforcing some of my concepts.  This book, REST in practice, helped me further in understanding more advanced topics like semantic web (RDF, OWL), and the event-driven system integration. I thoroughly enjoyed the book, and would certainly recommend for all REST enthusiasts (and doubters).

Tags: , ,

2009 Roundup: Blog, Books and Twitter

It's that time of the year to review the progress, and to set the goals for the future. Firstly, I would like to thank all who have (directly or indirectly) helped me learn so much during the past year. It was a fun ride in many ways. In this post I would like to review about three items -- this blog, books that I read, and about my Twitter experience.


I have this blog up for a couple of years but it's in 2009 I've started taking it more seriously. My goal with the blog is straight and simple -- share what I learn, and in turn benefit from the collective wisdom of my readers, friends and fellow bloggers. Towards that effect, 2009 is a satisfactory year.

Here are the top posts of the year --


Regardless of the vast number of resources that are available online, a book is still my preferred choice. A good book helps in learning something new (or reinforce the concepts) in a systematic and a structured manner. A well-written book may not answer all the questions but helps in generating enough enthusiasm for further exploration.

Here is the list of books that I read in 2009. I could have done bit better on this front, but given all the constraints in place this may not be so bad --

  • Groovy in Action: Groovy has become one of my favorite scripting languages. [My review]
  • Career 2.0: As the name indicates, a career-oriented book from Pragmatic Bookshelf. [My review]
  • Grails in Action: An excellent book on Grails. [My review]
  • Hello World: A cool book for Python beginners. [My review]
  • The Passionate Programmer: The title says it all, a great read. [My review]
  • RESTful Web Services Cookbook: Not released yet, scheduled for the first quarter of 2010. I had great fun reading and reviewing this book. Watch out for it, has got delicious recipes for all REST enthusiasts. [O'reilly link and Safari online]

There are a few more books that I haven't finished reading yet. I will be writing about them soon.


I've resisted so long to sign-up on Twitter. Primary reason for that resistance was I was not sure how that 140-character thing would be transformed into something meaningful. That resistance broke down just over an year ago. 1700 tweets later, I'm here to report how much I learnt via Twitter for the last one year or so.

I use my Twitter account primarily to tweet about software, architecture, programming languages and the stuff related. Feel free to follow me there, if you are into it.

There are quite a few geeks out there, Twitter gives a great chance to peek into their thought process. It's also a great place to share the links and articles you are reading. I'm also glad that I gained some great friends and met some of my ex-colleagues with whom I lost touch a little while ago.

It is extremely easy to waste the time and not find any use of Twitter based on how you use it. For me, all that matters is to follow the folks who are willing to share their knowledge, and strictly stick to the passion -- technical topics. You don't see any tweets about what I ate for my lunch, etc. Not that anything wrong with it, I just don't find much value in providing that kind of information.


2009 is an year that I'm reasonably satisfied with some of the milestones that I've set out for myself. However, I know there are many more miles to go ...

Tags: ,

Book Review: The Passionate Programmer

The Book

Title: The Passionate Programmer

Author: Chad Fowler

Publisher: The Pragmatic Bookshelf


This is the second edition of the book that was titled as 'My Job Went to India (And All I Got Was This Lousy Book): 52 Ways to Save Your Job' in the inaugural edition. As the author admitted in the first few pages of the book, that title gave some impressions that the book is only about how to merely save the job.

The title for the second edition is more apt considering the intent of the author. If you read Andy Hunt's books on Career Development, this book by Chad Fowler falls into the similar genre.

The key emphasis of the book is --

Think of your career as if it is the life cycle of a product that you are creating. That product is made up of you and your skills.

From My Notes

There are a lot of useful tips and sound advice in the book, just want to touch on a few of them --

How to choose a technology stack to work with and how to choose a business domain is discussed. I completely agree with the author's view on how many of us end up doing whatever comes our way. In the author's own words -- "Our career is one big series of undirected coincidences".

Fowler says that both ends of the technology adoption curve might prove to be lucrative. I see where he is coming from, although I haven't seen many people intentionally taking up gigs to work on old/outgoing technology. Even the ones who take up such jobs, they are doing so because they can do only that.

These kind of folks they may call themselves specialists, but Fowler says that too many of us seem to believe that specializing in something simply means not knowing about other things. A very good case is made in the book why you want to be a generalist and at the same time being a specialist!

Fowler (being a musician in his past life) says it may be a good thing for being the worst guy in every band you are in -- which translates to work and hang around with people who are smarter than you. Great advice, I can attest to that from my own experiences, especially from the early phases of my career.

Simply being good at programming alone is not good enough. You ought to make sure that you understand the business domain well enough. Without understanding the business domain is it even possible to do justice to the job -- either making or saving money for the business.

One of the suggestions was to practice coding and read the open source code to learn new tricks of the trade. Great advice, but open source community is not immune from bad code, so choose your projects wisely!

There are some execution tips -- productivity boost from do-it-now mentality, push yourself to accomplish something every day, working towards a team goal (your managers' successes are your successes), don't panic. Another important aspect is to question yourself are you adding enough value to justify your worth. Author suggests that there will be many opportunities that you can spot if you ask such questions.

Fowler explains why marketing one's skills is important -- If you kick ass and no one is there to see, did you really kick ass? Who cares? No one. Perceptions do matter and it's not a wrong thing to manage perceptions. Build your brand (this concept is also explained well in Career 2.0 book by Jared Richardson. Richardson explains quite well the importance of writing and public speaking activities as a part of brand building).


The book is organized into short chapters under five broad categories / sections -- Choosing your Market, Investing in your Product, Executing, Marketing, Maintaining your Edge. Each chapter ends with an 'Act on It' section. Author suggests a few items in this part of the chapter on how you can act based on the content discussed. Although they are nice, the real "act on it" is on the readers, coming up with the action items that is more specifically tailored for them.

You may actually finish reading this book in a few hours, perhaps in one sitting. I'd rather suggest taking your time, and go with a cycle similar to:

read_a_chapter --> introspect --> prepare_a_plan [act_on_it, of course]


As Chad Fowler suggests, this book isn’t about struggling to maintain the level of mediocrity required not to get fired. It’s about being awesome. It’s about winning. I remember Uncle Bob saying -- you employer is not your mom. True. You have to make your choices and treat your job as a career, and develop the skills needed to keep you up-to-date. If you are currently looking for some inspiration or not so passionate about your career, then this book is for you.

Tags: ,

Book Review: Hello World!

The Book

Title: Hello World! Computer Programming for Kids and Other Beginners

Authors: Warren D. Sande and Carter Sande

Publishers: Manning Publications


As I reviewed couple of Manning books earlier, they contacted me recently to find out whether I was interested in reading this book and provide feedback. I was not sure at that point. Later on I read somewhere that a dad and his 12-year old son have written this book, and that too using Python to explain the concepts of programming. So that background tempted me into reading this book.

I'm here to report that I do not regret that decision. In fact, I've enjoyed the entertaining narration of the book. Concentrating on the fundamentals of a programming language is essential, especially if you are about to begin learning the art of programming. The authors did a great job explaining the basics in simple terms.

After hearing rave reviews about Python, couple of months ago, I've ventured into learning it. I started to appreciate the beauty of the language. Python as a language of choice is a great one, that too if you are learning your first programming language. Python, in my opinion, is an easy to learn language relatively speaking. Authors made a great choice and introduced the concepts in a systematic way -- variables,  Math functions, decisions, looping, lists, functions, objects, modules.

As a kid or an adult beginner you don't want a book to overwhelm you with lofty jargon. What you need is a book that keeps you interested just enough so that you can learn the concepts, play with the language, and take out any fear you may have about programming. This book, I think, succeeds in doing just that.

Every chapter has got some assignment questions. A nice way to learn a programming language; learn the concepts and test your knowledge. Although I'm not a big fan of games, children would certainly love to learn a language and develop their own games. They can certainly take clues from the gaming examples provided in the book. Drawing, animation, sounds and events are all covered.

As this book is meant for beginners it doesn't cover topics that a more advanced user would otherwise like to see. It would not be fair to compare this book with a book like  Learning Python (O'Reilly).

Last but not the least, illustrations in the book are really nice and will also play a major part through out the book and provide some interesting tidbits. I have no hesitation to say that this book would be a perfect gift for any 12-year old (or for any beginner) interested in learning a programming language but doesn't know where to start.

Tags: ,

Book Review: Grails in Action

Grails in Action Cover

The Book

Title: Grails in Action

Authors: Glen Smith, Peter Ledbrook

Publisher: Manning


The book is organized into four parts:

  • Introduction: The very first chapter is aptly titled as 'Grails In a Hurry'. If you are a complete beginner to Grails you will be blown away with the productivity and the powerful feature set of Grails on display. Many concepts explained in detail in the later chapters are summarized with a simple example. Second chapter goes over Groovy basics, which is adequate.
  • Fundamentals: I think taking up a non-trivial example to explain the concepts of a framework is nice. A Twitter-like application is built during the course of this part of the book. This part explains about using GORM (Grails Object Relational Mapping Library), techniques for using Constraints for validation, power of Grails scaffolding, usage of dynamic queries, controlling application flow and the usage of services, introduction to GSPs and the discussion about views and layouts (along with AJAX stuff).
  • Building more features into your applications: How well different levels of testing (unit, integration, functional) are integrated into the framework is discussed. This part then continues with the basics of plugins and their usage. One of my favorite chapters in this book follows next, workflow with Grails Webflow. Security is discussed in some detail, but the chapter that follows really stands out (especially for a huge REST fan like me) -- explains how to design and implement a RESTful API showcasing Grails support for this architectural pattern.
  • What you need to know for real work: The last part of the book explains about -- messaging and scheduling, some advanced GORM concepts, how to use Spring and transactions with Grails, and about plugin development. The chapter on advanced GORM concepts is well written; folks who intend to use Grails for enterprise-level applications will certainly benefit from this chapter.

This is my first formal reading of a Grails book, but have some decent exposure to the concepts of Grails (from the available documentation, and by the presentations that I attended in the past). So for me, introductory chapters and some of the fundamentals are well-needed refreshers, but the last two parts really stand out. Some points from my notes:

  • For integration tests, Grails bootstrap the database and wires up all components just as it would for a running web app.
  • Domain class relationships (1:1, 1:M, M:N) are explained quite well from the Grails point of view -- belongsTo variations, hasMany and GORM magic of automatically adding new methods to account for the defined relationships.
  • Groovy querying with dynamic finders: Dynamic finders take advantage of funky Groovy metaclass magic to intercept all method calls on a domain object; leverages Groovy's methodMissing feature.
  • Use flash scope for passing messages to the user when a redirect is involved.
  • Extensive discussion on the Grails form taglibs, and on creating your own tags.
  • Mocking is built-in the framework for productive unit testing.
  • Webflow introduces a new scope: flow scope. Items put in flow scope live for the life of the flow. Favor flow scope over session scope -- Webflow will cleanup the storage for you and give you more efficient server memory.
  • The chapter on implementing the REST architectural pattern is a must read; Grails supports the pattern out-of-the-box.
  • Grails uses OSCache as its default cache library (for Hibernate's second-level cache). The reason suggested was that it plays well with Grails developer restarts, something I would like to understand further in reference to Ehcache. But the authors actually used Ehcache in the book suggesting that it is a better library (I agree!).
  • So easy to declare caching at the domain level:
    static mapping = {
        cache: “read-write”
  • Discussion on integrating with legacy databases is interesting, but would like to see some case studies to understand the real pain involved.
  • Transactional services are implemented using Spring's AOP mechanism (Spring's TransactionProxyFactoryBean).
  • Integration tests run inside a transaction by default, which is then rolled back after each test finishes. This ensures that data changes don't affect other tests, but it means you can't check whether transactions are rolled back or not. If you want to test transactional behavior then you need to add a static transactional property to your test.


The book is very well organized and the topics chosen are well thought of. An easy conversational tone is used through out the book. In my opinion, this book succeeds in building a sustained interest about the framework. It is also an excellent reference book on the topic. Strongly recommend the book for all Grails enthusiasts.

Tags: ,