Forewords
The true goal of a foreword is to convince people to purchase the book. So, I guess you have three choices right now. First, you can save yourself some time, stop reading this foreword right now, and simply take my word for it that buying this book is a good way to invest your hard-earned money. Second, you could not trust me, which frankly is a smart thing to do because I'm a consultant, and continue reading this foreword on the chance I might actually say something that resonates with you and thereby motivate you to buy the book. Third, you could decide to not purchase the book, which is likely a really bad idea because the vast majority of Java programmers that I have met could really benefit from this material. In my opinion, the last thing that the Java community needs is another book describing some "really cool" Java technologies; there are hundreds of books out there already, thousands of magazine articles, and tens of thousands of web pages already covering really cool Java technologies. Luckily, that's not what this book is about. Agile Java Development is one of those rare books that teaches skills that you will use throughout your career. Yes, it does cover the fundamentals of Spring, Hibernate, Ant, and a bunch of other stuff that you need to succeed today. But, more importantly, it goes beyond the technology to describe agile techniques, adopted from Extreme Programming (XP) and Agile Modeling (AM), which enable you to succeed at modern software development. Most Java developers have heard about XP and many have adopted some of its techniques, such as test-driven design (TDD), refactoring, and even pair programming. This is a good start, but it's not enough. In this book, Anil brings his years of experience to the table, describing what actually works in practice. This is different from other books that often share a vision of what the author thinks will work in theory; but as we all know, theory and practice are often two different things. When Anil first approached me to be a technical reviewer of this book, the thing that most impressed me was his simple, yet effective, approach to modeling on Java projects. In fact, you might want to flip through the book right now and take a quick look at some of the models. I think that you'll notice that his diagrams are very similar to what you develop yourself on actual projectsa refreshing change from the advice presented in many of the modeling books available today. You'll also notice how Anil describes how to move from those simple models to the often-complex code that you write on a daily basis. This I think represents the greatest strength of this book: it presents real-world advice that reflects what top-notch developers actually do in practice. The book also shows how many of the common tasks that we perform, such as acceptance testing, unit testing, object/relational mapping, system integration, and refactoring, fit into the software development picture. The book starts with the "5,000 foot" process point of view, but dives down to ground level and describes how to use the tools in practice. Most books focus on one view but not the other, but Agile Java Development pulls it off nicely and covers both views well. Take a few minutes and browse the rest of this book. I think you'll see what I'm talking about.
This book is not easily categorized. Let me explain why it's unusual, and why it deserves your attention. Easily categorizable books abound in our industry. They are often books about a particular product or API. Some are good; some are bad. You can choose by the cover, the font, the publisher, the credibility of the authorbut you have already made a far more important choice: You know what book you are looking for. A good such commodity book may make you more efficient in a particular area, but it's unlikely to change the way you work. Books that are not easily categorizable are much rarer. They relate much more closely to their author, and potentially to you. The present book shows how valuable such a book can be. Anil Hemrajani has distilled his extensive experience as an architect and developer into a book that abounds in the practical insights of a successful practitioner. Like all the best books, it's an effective communication between author and reader. As with all effective communication, the topic is not limited to the predictable, and it's enjoyable: Anil has a natural writing style that is a pleasure to read. This book has a remarkably broad scope. It tackles topics that are rarely tackled together, but should be. The process we use to develop software is inextricably linked to the way in which we structure our code and the tools we use to write that code. No effective developer works in a compartmentalized fashionthe many decisions to be made are intertwinedbut most books make little attempt to paint the big picture that is essential to getting results. To develop Java software productively today, you need to understand key concepts such as O/R mapping and Dependency Injection; you need to understand how and why to use techniques such as unit testing and automated builds; andequally significantyou need to know the best tools for the job, such as frameworks and IDEs. You also need to understand some of the pitfalls to avoid, and how sometimes soft skills are as critical as technology. Anil has done a remarkable job of bringing these things together into a book that provides clarity in an area that many find confusing. It covers a lot of ground, but never loses sight of its aimto help readers complete successful projects. I see this book as a good map. It clearly shows you the path on your journey to successful enterprise Java development. Along the way, you may supplement it with more detailed maps of particular areas. But you will always benefit from the direction it provides. I recommend this book to anyone setting out to become an enterprise Java practitioner today. It may well change the way you work, for the better.
|
EAN: 2147483647
Pages: 219