HJUG Reviews:
Essential Skills for the Agile Developer: A Guide to Better Programming and DesignIntegrating and Extending BIRT, 3rd Edition
Java the Complete Reference, 8th Edition
Learning Android - Building Applications for the Android Market
If you think you might be interested in reviewing a book, check out the review guidelines. Then if you are still interested send the name of the book you would like to review to Adam Roberts (contact info in the sidebar) and he will contact the publisher to see about getting a review copy for you.
Essential Skills for the Agile Developer: A Guide to Better Programming and Design
By: Alan Shalloway, Scott Bain, Ken Pugh, Amir Kolsky
Publisher: Addison-Wesley Professional
Released: August 29, 2011
Pages: 219
The book's page at InformIT
To get a User Group Discount
This is a well written book with a misleading title, a better title would be Essential Skills for the Object Oriented Developer (although most of the information would apply to Functional programmers also). I understand why they choose the title, as any developer who wants to do agile development must have a very firm grasp on these topics first. However, actual Agile techniques are barely mentioned, so anyone who buys this book looking to learn how to play planning poker or how to create an effective burn down chart will be disappointed.
This is a short book at just over 200 pages, and as such it will not be very useful when it comes to teaching a non programmer how to program. The entire book is well written and frequently insightful. I found the introduction (preface and notes) and its quotes from Buckminster Fuller especially thought provoking with its unique way of looking at software development.
The book is made up of a series short chapters, each of which briefly covers one programming best practice, which the book refers to as .Trim Tabs.. The .Trim Tabs. concept is explained in the introduction and is a way to look at the effect that minor changes to the way code is written can have major effects on productivity. Each chapter goes into just enough depth for someone with programming experience to understand the concept and nothing more. Each chapter also is very good at giving an example of a good book that is specific to the current topic so that anyone who wants more in depth information can easily find it.
The first half of the book is dedicated to the low level practices of development such as refactoring, test driven development, encapsulation, and removing redundant code. The book does an excellent job of covering this broad range of topics in just under 100 pages. However, due to the brevity, an experienced developer may find themselves arguing with the book.s oversimplification of some topics.
The second half of the book goes over more high level design and development practices such as the dangers of over designing a system, continuous integration, open-closed principle, Law of Demeter, and favoring aggregation over inheritance. It is in this section that I started to feel that the book should have been longer to do justice to some of the topics. All of the information they included was of the same high quality as the first portion of the book, but the complexity of the topics covered meant that a lot of information was left out. As an example, in the section on continuous integration there is only a page and a half on Continuous Integration Servers. No matter how well written that page and a half is, it isn.t going to convey the true value that CI servers can provide.
This book is perfect for someone who is moving from a procedural language into the OO world for the first time. Also, anyone who.s team is considering doing agile development for the first time and wants to confirm that their current development practices are up to the task will find this book to be very useful.
Reviewer: Adam Roberts
Integrating and Extending BIRT, 3rd Edition
By: Jason Weathersby, Tom Bondur, Iana Chatalbasheva
Publisher: Addison-Wesley Professional
Released: 2012
Pages: 880
The book's page at InformIT
To get a User Group Discount
Who the book is for:
- If you are looking to integrate BIRT into your Java EE or Java SE.
- If you want to extend report design tooling in eclipse.
- If you want to learn/use java and javascript scripting in BIRT reports
Who is this book not for:
While some parts of the book are easily understood even if you have no background knowledge of BIRT, things like scripting in reports require that you know the basics of designing BIRT reports.
Part I : Installing and Deploying BIRT. From my experience, the number of Eclipse plugins and options of getting them (standalone, plugins over eclipse etc) can be overwhelming if you are just starting with BIRT. This part covers all the components of BIRT, what each one does and all ways of getting these components installed. If you already have BIRT installed, you can ignore the first 3 chapters here. Chapter 4 - Deploying BIRT to Application server covers deploying BIRT into application servers. The chapter covers Apache Tomcat 6.0 as the application server to deploy BIRT to. Other than setting up connection pooling and configuring JNDI connection object, most of the steps are the same for other application servers as well. This chapter covers everything that you will need to know when you are deploying BIRT on an application server. Eclipse 3.6 are BIRT 2.6 are used here. Eclipse 3.7 is the latest version, if you are focussing on a new install, its better to use Eclipse 3.7.
Part II: Understanding BIRT framework is something you should not miss whether you are a report writer or someone looking to integrate and extend BIRT. It is presented in a simple way, so you should be able to understand even if its your first time reading about BIRT. Report Object Model is only briefly covered but enough to understand the overview of BIRT Report Object Model.
Part III: Scripting in Reports. Till here, the book can be easily understood even if someone has no knowledge of BIRT. But from here, the book assumes basic knowledge of BIRT Reporting and Report design. Java and Javascript event handlers and Debugging Event Handlers are covered and coverage is detailed. While everything you need to know about event handlers are covered, I wish there were more exercises in this part of the book.
Part IV: Integration BIRT into Applications: This part of the book is both a complete reference of all the Report and Charting APIs that one needs to know for integration and how to use the Report and Charting APIs.
Part V: Working with the extending framework: I had no knowledge of Eclipse PDE, extending framework knowledge requires knowledge of PDE. But this part also covers basic things required in Eclipse Plugin creation. I was able to create some basic extensions using this book without any problem.
Overall, I would have preferred to have more exercises while I am reading a programming book to confirm my understanding. While that is missing in this book, all the chapters are very detailed, screenshots are used whereever requried to enhance understanding and this book is like a complete reference if you want to integrate and extend BIRT with everything that you require covered.
Reviewer: Ravi Mutyala
I work for a software company which owns MES suite of products geared towards Pharma, Speciality chemicals and other batch processing industries. Our MES solutions are based on Java EE and we use EJBs, Hibernate, RichFaces, BIRT and Adobe Flex and deploy on Jboss AS. I was part of the team that evaluated possible reporting frameworks and decided on using BIRT.
Java the Complete Reference, 8th Edition
By: Herbert Schildt
Publisher: McGraw Hill
Released: June 22, 2011
Pages: 1152
The book's page at McGraw
The title of this book is "Java The Complete Reference", and it is 1116 pages long. This book does not duplicate or contain the Java platform javadocs. Instead it serves as a nice complement to the javadocs. This book does not cover a fair percentage of classes in the Java library; you should consider this book a guide book rather than a reference manual.
Schildt's writing is clear and luminous. The book feels solid and extraordinarily well crafted. The book contains plenty of code examples, usually snippets with an occasional longer example. Most pages have examples.
The book contents are distributed as follows. Part I (34%) covers the Java language. Part II (52%) covers the Java library. Part III (8%) gives some additional depth on JavaBeans, Swing, and Servelets. Part IV (6%) gives two extended examples: Financial applets/servelets, and a Swing Download Manager. The appendix describes Javadoc commands.
Part I covers the Java Language completely, but without wasting any space. A raw beginner may find this treatment a bit dense. I think that a beginner might prefer to learn the Java language from a more expansive and gentle teaching document. I do think that this part serves as a useful review and summary of the language for readers with some Java experience. It illuminates many areas of the Java language that I was unfamiliar with. Coverage of generics and try with resources are particularly interesting.
Parts II and III cover important parts of the Java library. Given the existence of the javadocs, Schildt is freed to focus on important areas, and to give context. He uses that freedom effectively.
Schildt gives plenty of tables. For a given topic, Schildt usually gives a table of the important classes or interfaces. For some classes, Schildt gives a table of table of methods. He uses the tables to explain concisely and effectively. They make it easy to quickly scan the info. I like how the tables highlight the new parts of the API: "Added by JDK7."
I particularly liked the coverage of servelets, regexp, and concurrency utils.
Chapter 20, Exploring NIO, is especially good. These APIs were significantly expanded in JDK7, and Schildt does a great job of explaining the new parts. He also explains how to work with the older part of NIO.
An example of the amount of coverage in the Java Library is Chapter 21, Networking. Schildt covers 13/40 (32%) of the classes in the java.net package. For a particular class that he covers, the DatagramSocket class, Schildt discusses the most important methods: send, receive, close, getInetAddress, getLocalPort, isBound, isConnected, and setSoTimeout. The other 20 or so methods are not described. He covers 8/28 (28%) of the methods. All in all, he makes very good choices about what to describe and what to leave out of the book.
I do however have a few critiques. All the examples with drawing code use the Graphics class instead of the Graphics2D class. Most drawing code would need the additional features of Graphics2D.
I do wish that Schildt had mentioned the Java Memory Model. He necessarily does cover threads. However, anyone writing threaded code without an appreciation of the JMM is going to inevitably crash and burn. I appreciate the difficulty -- a simple summary of the JMM is impossible.
Schildt missed a trick with the layout managers. Using a graphical tool to layout the GUI is in many cases a more desirable alternative to pounding out a lot of code. Two free ones are the NetBeans GUI Builder, and the Window Builder for Eclipse. Schildt talks about how to code the layout managers without mentioning the graphical tools.
Overall, I think this is an excellent book and recommend it highly.
Reviewer: Steven Reynolds (http://www.slreynolds.net)
Learning Android - Building Applications for the Android Market
By: Marko Gargenta
Publisher: O'Reilly Media
Released: March 2011
Pages: 268
The book's page at O'Reilly
I have been wanting to learn how to develop for Android for over a year now. I just didn't know where to start. I poked around the Android Web site, but even that seemed overwhelming. I just needed someone to show me the ropes about how to get started, then I could run with it.
Marko Gargenta has done that for me. His book, "Learning Android", is a 200+ page tutorial covering all of the most essential areas of Android development. The sample application is well chosen - a simple Twitter-like front end. This covers user interface, networking, internal services, security, and data storage - most things you will want to know when getting started. What I most appreciated was that he doesn't just walk you through the steps of how to create the different parts of the app. He walks you through a development discipline using best practices: what order things should be done, how to structure support files, etc. He is like an experienced mentor helping you to do things the right way from the beginning.
Things change fast in Android technology, so some of what he describes has changed since the book was published. For instance, he starts by walking you through setting up your development environment. Having a completely clean system, I tried to follow his instructions, but got stuck when I didn't have an Android Virtual Device defined yet. So I poked around and figured out how to make that work. Then I noticed that the AVD Manager was described in the next section. I learned to read ahead and be flexible regarding changes to the development environment in the rest of the tutorial.
In addition to the tutorial, he gives a nice introduction to using system services, with the code described in helpful detail. He also gives a quick overview of the Android Interface Definition Language, and even a nod to the Native Development Kit.
One notable oversight is that there is no discussion about how to post your app to the Google App Market. Since the subtitle for the book is, "Building Applications for the Android Market", I found the omission surprising.
In short, the book provides an excellent introduction to the Android platform and development tools, and a good development methodology. For anyone new to Android development, this would be a great place to start.
Reviewer: Scott Wierschem
HJUG Review Guidelines:
- The length is up to you. Reviews can be short and sweet or long and detailed. Do what works best for you.
- If you like something in a book, say what it is and why you like it. If you don't like something in the book, say what it is and say why you don't like it. Be as specific as you can--this information is important to other readers.
- If something was omitted in the book say what it is and why it is important.
- Make sure that the review contains an overall summary. Keep your favorite note taking utensils handy (pen & paper, laptop, iPad, etc) while you are reading so you can take notes as you read. But not notes as if you were studying the material, instead just write down what you were thinking while reading the book. If you find a particular example extremely enlightening, make a note of the page and how impressed you were. And the same goes true if you find something that makes you want to strangle the author! If you take notes on how you liked the book as you read it, writing the review will end up being more an exercise in formatting your notes than actually writing a review.
- You should keep the following questions in mind while reading and writing the review:
- What is the book about (title chapters) and how well does the book cover the topic that it claims to be about.
- What group of people would get the most out of the book? Novices, Intermediate, Experts, or .No One.
- How readable is the book? Is it a conversational easy to read book (Head First books)? Is it dense and full of information (C Programming Language)? Or is it poorly written?
- Are you familiar with other works by the Author or in the same series? If so how does this book compare?
- Remember: You are writing a review, not a summary of what the book covered, make sure that you give your opinion of the book (good or bad) and the reasons you came to hold that opinion.
