Monthly Archives: September 2012

Review: Version Control with Git

Posted on by
Reply

A Review of Version Control With GITAlready having a background in advanced usage of ClearCase, CVS, and SVN, I picked up Version Control with Git by Jon Loeliger and Matthew McCullough (O’Reilly publisher) to understand how Git could help me solve some of the feature challenges I have been working through with other VCSs.  This book certainly was able to deliver to my expectations.

The authors work through the processes to setup and configure Git step-by-step.  In addition, they also spends a great deal of time delving into the more important topics required to work with Git as a power user.  The examples were useful and the diagrams where acceptable to convey the points needed.  There is no doubt that that the authors understand Git.  The time they take in explaining why to “do something” is important in moving the reader from a simple user of Git into becoming a power user.  The “Submodule Best Practices” chapter was helpful in solving some of my current challenges while the “Tips, Tricks, and Techniques” chapter gave me some quick wins.

While there are many ways to solve the same problem when using any VCS, I felt like the authors worked hard to provide an honest and open view of their approaches.  I highly recommend Version Control with Git to the reader that wants to understand more about a VCS like Git than simply a small number of quick commands via an IDE.  While this book is not a definitive reference guide in all things Git, it provides a solid foundation that allows the reader to head in the right path as they learn more about Git’s inner workings.

Disclaimer: I received a free electronic copy of this book as part of the O’Reilly Blogger Program

Review: Introducing Regular Expressions

Posted on by
Reply

Regular Expressions Reviewed by Jason ArmstrongI read Introducing Regular Expressions by Michael Fitzgerald (O’Reilly Media) to gather deeper insights into the details behind regular expressions.  Fitzgerald does not disappoint.  The reader should sit back and prepare to drink from the fire hose as Fitzgerald drives through regular expressions in many of their entry level flavors and styles.  Introducing Regular Expressions is not for the faint of heart as the reader must navigate lots of regex simulator tools and platforms in order to practice the examples that Fitzgerald fires at the reader without mercy.

If the reader is prepared for a no fluff introduction into regular expressions, then this book is for them.  The reader must be prepared for the technical hurdles needed to execute the samples provided in the book.  Fitzgerald has the reader execute regex in toolsets such as sed, grep, perl, Cygwin, vi, ack, vim, and even more regex simulation tools.  The tool setups can quickly become a distraction to the reader as they spend more time bouncing between tools than actually understanding at depth the reasons behind the samples themselves.  However, as long as the reader takes the time to work through the tools and samples, they will not only gain knowledge in regular expressions, but also many common toolsets.  At its heart, this toolset requirement demonstrates to the astute reader an understanding that unlike many IT “languages” there is no single regular expression structure or behavior.  Demonstrating that you may have to customize your use based on the tools you choose.

Overall, I’d recommend this book for two main reader types.  The first is for the reader that is looking to understand the overall behaviors and traits of regular expressions without a 500 page manual with lots of fluff.  The second is for the reader that has a basic understanding of regular expressions but would like a quick reference on why the expressions work the way they do in many cookbook and internet examples.

Disclaimer: I received a free electronic copy of this book as part of the O’Reilly Blogger Program

Review: Head First Design Patterns

Posted on by
2

I picked up Head First Design Patterns by Eric Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra while working through some particularly difficult design/code reviews.  In these reviews, I found that very few developers actually knowingly use design patterns beyond the most simplistic of forms.  In fact, during several interviews, I asked candidates what design patterns they could name and most could not name a single one.  However, when I asked them if they had heard of the Singleton Pattern, they immediately began giving examples of writing code to meet this pattern.  With this discovery, I quickly began recommending this book to java developers of all levels as a way to renew why we design code the way we do.

Head First Design Patterns quickly gives the reader exposure to some of the most common patterns and why they work.  Does this book cover every possible pattern and the intricacies in its use?  No.  However, it brings to the reader a mode of thought that begins to look at design patterns as a way to solve common problems without “reinventing the wheel.”  The examples are relatively simple to understand and the writing style straightforward and logic in its flow.

I recommend Head First Design Patterns to any entry through advanced level developer or designer in the object-oriented world that desires to find a solution to common problems in a way that allows your design/code reviewer and maintainers the ability to understand why the design/code was “done” the way that is was “done” in a less-than-four-hour line-by-line review meeting.