18135328
submission
RickJWagner writes:
20 percent inert ingredients, 80 percent nitro glycerin. That's how I'd describe "JBoss AS 5 Performance Tuning" from Packt. The first 50 pages are nothing to get excited about. This first chapter and a half describes the author's performance tuning life cycle methodology and introduces us to a handful of open source tools that can assist us in our tuning efforts. The tools section seems especially weak-- there are plenty of screenshots showing the tool's menu screens, something you'd normally pick up in about a minute from the tool's distribution website. Honestly, at this point I was beginning to wonder if this book was going to live up to my expectations. Luckily I pressed on for a few more pages, and hit the rich paydirt that makes up the rest of the book. From that point on, every section yielded valuable tuning advice.
The author breaks the environment down into slices: Operating System, Application Server stack components, application code. Starting with the O/S, the book tells us the signs to watch for in various situations (i.e. how to detect and compensate for high or low utilization of the processor, or the disk.) The author explains likely causes for the problem, and what can be done about it.
Java programmers need to understand JVM tuning, and here it is given a whole chapter. This includes a lengthy explanation of how to correctly size your heap, followed by a nicely illustrated section on garbage collection, gc sizing, and choosing the best algorithm for your needs. All well done and very readable.
The book's subject is JBoss AS 5, and it's given a whole chapter, too. Thread pools and Connection pools are explained, as well as proper tuning of prepared statements and logging recommendations. Every programmer knows that logging can really drag performance down, right? Here we learn how to optimize it.
The middle of the book deals with JEE applications and the application server components that enable them. EJBs are given extensive coverage. JMS, a JEE hot-button, is also covered well. (Both JBoss Messaging and the newer HornetMQ are explained.)
The persistence layer is given holistic coverage. Starting with database design recommendations, the author proceeds to indexing, JDBC, connection pooling, and JPA/Hibernate. The Hibernate section is a good example of the kind of detail you'll find-- the author explains caching (first and second level) and the considerations you'll want to make to optimize their usage. Besides tuning the application server parts, there are recommendations for your application code, too. Hopefully you've bought into the recommendation to tune your code all throughout the development life cycle. If not, well, too bad for that one. Ditto for the database design.
One of the things JBoss makes really easy is clustering. Note: I didn't say cluster tuning, I said clustering. To optimize clustering, you'll have to understand all that low-level networky stuff like ethernet flow control and UDP buffer sizing. (I'm guessing this is not something your garden-variety developer thinks about every day, and make specific mention here as a demonstration of the kind of depth you get in this book.) Besides these bottom-layer concerns, the book also covers higher level parts of the stack like JGroups and JCache configuration, replication, and tuning cache storage. Unless you're really, really a bit-head, all that probably sounds a little deep. But the book explains it all in a way that makes it understandable and approachable.
JBoss uses Tomcat for it's web server tasks, so Tomcat is given good coverage as well. Nothing here seems JBoss specific, so most any Tomcat user could benefit from this part of the book. Connector configuration, thread pool sizing, and the Apache Portable Runtime are included. JBoss web server integration with Apache introduces us to mod_jk, mod_proxy, and mod_cluster. As throughout the book, the author uses JMeter to capture metrics to demonstrate to us the kind of performance we might get from each.
The final technical chapter deals with web application frameworks and web services. Web applications seem especially tunable in the development stage, while web services get code construction tips as well as configuration hints. The book ends with one more suggestion to make performance tuning part of your every day life rather than something crammed in after deployment time.
Like many technicians, I respect technical knowledge. This book is crammed full of it, and it's all presented in a readable manner. What's the bottom line? I'd recommend this book to any JBoss user (strongly), any JEE developer (with little reservation, especially Tomcat users), or any Java coder (who has a little extra money to spend.) Anyone else can probably live without this book. But if you're running JBoss (and you're technically minded), spend the money, you'll be glad you did.
The book can be found here: https://www.packtpub.com/jboss-as-5-performance-tuning/book
17862102
submission
RickJWagner writes:
Look out Erlang-- There's a New Book in Town
Manning has just released a new Erlang title, called 'Erlang and OTP in Action'. For quite some time now, there's been a definitive guide to Erlang-- Joe Armstrong's excellent book 'Programming Erlang'. Well, guess what-- it's time to make a little extra room on the bookshelf, because the Erlang book-o-sphere has just shifted. There are now two must-have resources for an Erlang programmer.
The book is divided into three sections. The first one deals with the basics of Erlang and details about the OTP application framework. Part two shows how to build a production-worthy application in Erlang. The third part of the book is about integration and tuning.
Section 1 has chapters that cover the following: basics of Erlang and OTP, Erlang language fundamentals, writing a TCP-based RPC server, OTP and the supervisor model, and graphical tools to help your development efforts. Language newbies will spend some time here, as Erlang can be a little odd to programmers coming from non-functional environments. (Concepts like recursion are given great coverage, as it should be.) OTP, the Erlang ubber-framework, is explained in detail as well. Section 1 alone would make a decent book on Erlang, but there is much more here.
Section 2 covers building a production application. The example given is a caching application, designed to increase throughput of a web application. In addition to expected topics like logging and an event-framework, the reader is exposed to Erlang's built-in distributed database, Mnesia. Application packaging and deployment considerations are also covered here.
Chapters in section 2 follow a helpful pattern to guide the reader through building an application. First, there is an introduction to some high level concept. Next, it is shown how this new widget can be used to further the needs of our production-worthy caching application. Finally the authors provide code that brings the desired functionality into the ever growing caching application. Erlang code tends to be somewhat dense-- not much code goes a long way-- so much of the latter part of each chapter is explanatory text explaining why you'd want to implement things in the way the authors did. Chapters in this part of the book read like an in-depth tutorial, and that's not a bad thing.
The third section of the book shows how to integrate with external users via HTTP, how to allow programs written in other languages to communicate with your Erlang code, and how to tune your environment. It's notable that Java gets a whole chapter on integration, through JInterface (in comparison, Joe's book offers about 4 lines on this topic. In fairness, that's a much older book, though.)
Throughout the book, simple illustrations are used to demonstrate key concepts. I found these to be extremely helpful, as Erlang in general is quite different than most programming languages. The delta between Erlang application development and other-language development is an order of magnitude different than something like the difference between Java and Ruby or Python and .Net. It's got different characteristics and different concepts. Given these large differences, I really appreciated the illustrations.
The book covers language built-ins like management tools, profilers, etc. (If you've ever used GNU development tools to profile an application, some of these might look a little familiar). The reader is given a lot to think about, and it's scattered over nearly 400 pages. To make a Java analogy, it's like an all-in-one book that teaches the language, the JDK and tools, JEE, and shows how to integrate your enterprise application with external entities. It's ambitious, but the book does a good job in explaining everything. That's why the impressive page-count helps. A skinnier book probably wouldn't be able to pull all that off.
The book is written with easy-to-understand anecdotes that help the reader grasp the finer points of Erlang craftsmanship. You definately get the impression the authors have written 'real' code, and they offer strong direction to guide the reader through constructing application code. There is a big difference between understanding language syntax and understanding best practices in application construction. Section 2 in particular is loaded with best practices, and this alone makes this book a worthwhile read for Erlang coders writing production applications.
Probably the best thing I can say about this book is that the authors seem to put the advancement of Erlang above all else. To bolster that statement, I'd point out that they give the reader a list of other Erlang books they may wish to read, and they also include several mentions of Joe Armstrong. (Joe is the author of what has been the most popular Erlang book.) In my opinion, the authors can afford this indulgence, as this book is strong enough to merit inclusion on the Erlang programmer's bookshelf.
So who is this book good for? I'd recommend this book to anyone who wants to program in Erlang. It can get beginners off the ground, and will reveal many best-practices to those who already know their way around Erlang.
"Erlang and OTP in Action" can be found here: http://manning.com/logan/
17510972
submission
RickJWagner writes:
Are you a .Net developer? Do you have to persist your application objects to a database? If so, I know of a book you might be interested in. The book is Packt Publishing's "NHibernate 3.0 Cookbook", and it's out in print now.
NHibernate is a port of the popular Hibernate object-relational mapper (ORM, for those who like TLAs.) An object-relational mapper is a framework that lets the developer get and retrieve application state from a database, and it does so in an efficient, non-intrusive, and flexible manner. Hibernate is the top of the line ORM implementation, yet it's easy enough to learn that even a newbie will find it easy to get started.
This book is written in Packt's 'Cookbook' style, which means it's really a series of how-to templates that guide the reader through some goal-centric activity. A 'recipe' is a formula for accomplishing something, like setting up a session for a web application, or using a profiler with NHibernate, or creating a validator class. You may not know what some of these things do-- but you will when you read the recipe! Each recipe follows a repeated pattern, with sub-sections "Getting Ready", "How to do it", "How it works", "There's More". At first glance, this can be a little deceptive for readers of technical books-- there's really no lengthy text sections that explain the basics of the tool in the early chapters of the book. You might be lulled into thinking this means there's no explanation for how things work, but that would be wrong! The truth is, there is plenty of good NHibernate theory and explanation, it's just that it's contained within the "How it Works" and "There's More" section of each instructional section, not in a chapter devoted to overview just by itself. For this reason, I'd urge bookshelf browsers to be sure to read one topic through front-to-back thoroughly, to get a feel for how the book presents theory as well as practical hands-on-the-keyboard instruction.
As far as content goes, there is a lot of useful content in this book. The author presents 70 different recipes for activites that range from the basic (i.e. your first class-to-database mappings) to the unusual (i.e. using NHibernate Spatial for solving distance-related problems.) The author offers plenty of good text in most of these, but again-- don't be upset by the placement of the high-level material. It's all there, it's just placed a little differently than what you'd find in most technical books.
The book is easy to read. The text is plain and straight to the point, and the author's writing style is quite readable. The code examples are likewise clean and well-formatted. (By the way, I'd urge you to go to Packt's site to get the source bundle if you buy the book. There's a lot of code referenced, you certainly wouldn't want to type it all by hand if you can get it handed to you.) The book runs a little over 300 pages, and most of the type is generously spaced. This is not a strong theoretical reference, but it is more than adequate as a primer for the vast majority of the tasks you'd want to accomplish with NHibernate.
So who is this book good for? I'd give it high marks for .Net developers who want to use NHibernate, regardless of experience level with the tool. I say that because there are enough use cases presented that there is almost certainly a subset of new material for almost anyone. How about Java Hibernate users? I think it's a decent book for them-- NHibernate is a very close port of the base product, so a Java user can get something out of this book, too. (For that crowd, this would obviously not be a good primary choice, but is worthwhile reading if you already have a Java go-to reference for Hibernate.) For anyone else wanting a good high-level overview of ORM use-- I'd say this book is only of marginal value. This is because the bulk of the explanatory material is presented in the context of 'how to' accomplish some particular task and isn't easily accessible without skipping from recipe to recipe.
By the way, lest you think NHibernate is only for .Net devs, I mostly ran the code samples under MonoDevelop on Ubuntu. This was my first adventure with MonoDevelop (the open source IDE for Mono, which itself is an open source, multi-platform port of .Net.) I was pleasantly surprised by the level of polish in the development environment, it really is a nice environment. Again, if you're a Java developer, I'd consider this book a decent learning supplement but would not recommend it as a primary for Hibernate proper.
There you have it-- your pocket guide to the NHibernate 3.0 Cookbook. I hope your recipes turn out well!
The book can be viewed here: https://www.packtpub.com/nhibernate-3-0-cookbook/book
17510838
submission
RickJWagner writes:
Every once in a while a technical book comes out that so exhaustively covers a topic that it becomes the definitive word on the topic. These books are the end-all reference, the final authority, the singular go-to reference that every practitioner falls back to in their hour of need. This book review covers one such book, the newly released "Spring Dynamic Modules in Action" from Manning.
First, a quick word about OSGi. OSGi is a specification meant to make Java more 'modular'. In practice, this means it is an attempt to solve the age-old problem of 'jar hell', including all the class loading issues that go with it. (Users of JEE application servers know what I'm talking about here.) OSGi lets you specify every external library your component needs, to the version. So if you need FooLib v1.2.3, and the application beside yours needs FooLib v10.9.8, that's not a problem at all-- both applications can happily run in the same OSGi container, at the same time.
Should you care about OSGi? The answer is 'maybe'. It's without question a big deal to the makers of Java application containers-- everybody from JBoss to Mule has an opinion on OSGi, and many vendors are busy baking it into their infrastructure. What will differ to you, the user of the container, is how the container developers decided to make OSGi available to their users. This book is about how Spring went about it, and what you need to do to use Spring and OSGi together.
Spring DM (short for 'Dynamic Modules') is a framework that enables you to use the popular Spring framework with OSGi. Spring, of course, comes with a multitude of components for solving all kinds of enterprise application needs. So this book is all about using Spring with OSGi.
It's a big book, over 500 pages, written by 3 authors. In those 500 pages you get lots of valuable content:
- An introduction to OSGi and an explanation of its purpose
- Explanation of how Spring can be used within an OSGi container, review of the currently available containers
- Details about how Spring DM works, and the parts you need to understand
- Details about OSGi services, and how they relate to Spring DM
- In depth best practices for data access, enterprise Java projects, and web applications (includes specific advice for popular web application frameworks)
- Testing practices
- Extended uses of OSGi, including likely future direction
A big part of what makes this book valuable are the many pieces of advice from the authors as they explain best practices for using various tools. So you want to use Eclipse, Ant or Maven? No problem, these are all covered. About to use MyFaces, Wicket, or DWR? All covered. Are you a Tomcat user or Jetty? Check and check. I'm sure you get the picture-- if you use these tools, the path ahead of you is already blazed and you can avoid some headaches by leveraging the author's experience.
Make no mistake about it, there will be some headaches ahead of you. Seldom is an application written today that doesn't use an external framework or library of some sort. Using these pre-packaged bits of functionality (and we need to be thankful for them!) might mean 're-packaging', if the library isn't offered as an OSGi bundle. This re-packaging means pealing apart some .jar files and editing the manifest files inside-- yuck! Luckily, this book offers you two things to help you with this task: tooling and advice. Tooling comes in handy because it can automate a lot of the manual, error-prone drudgery that goes along with such a task. Advice is even more valuable-- these authors have already worked done the hard work and have written down what you need to do to make your efforts successful.
So who is this book appropriate for? I'd say anyone who is going to use Spring DM. If you're convinced this is the right framework for your needs, you need a copy of this book. If you're not sure, or if you're just a casual reader wanting to know more about OSGi-- then I'd say you should look through the book first before you buy it. You might like it, or you might not because a lot of the book is all about hands-on use of Spring DM and the little tricks you need to make it work right the first time. But if you're just interested in an overview of the technology, this book might be too detail-oriented and not enough high-level for your tastes.
The book can be viewed at http://www.manning.com/cogoluegnes/.
Final opinion: If you use Spring DM, you need to buy a copy of this book. It's going to be the definitive resource on the topic for a long time.
16194582
submission
RickJWagner writes:
Book Review for "Drools JBoss Rules 5.0 Developer's Guide"
Drools (sometimes called "JBoss Rules") is a Business Rules Engine and supporting ecosystem. Drools, like other BREs, promises to lower the barriers to entry for application programming. Armed with this book, can a Business Analyst be used to write application logic? I don't believe so, and I'll tell you why.
Business Rules Engines, especially those based on the Rete algorithm, strongly favor rules written in 'if/then' format. (Sometimes the marketers will call this 'when/then' logic.) The basic premise is that you write your rules as a series of rules that individually specify matching logic for some objects you make available to the engine, then you specify what to do if any of the objects match your conditions. Example "IF there is a customer with age > 60, THEN allow senior discount". That's the marketing promise, anyway.
This book does a great job of showing you how to build a banking application, complete with validation, data transormation, and reporting functions. Each of these are implemented using Drools, of course, and workable code is provided at every step. The author takes care to explain nearly every line of code provided and highlights important classes and features as they occur. I think the author did well here.
Writing business rules is quite a bit different than writing logic in a language like Java or C++. I'd compare it more directly to writing SQL-- you're declaratively specifying which objects (out of a group) you want something to happen to, so you're thinking in terms of matching logic rather than ordered steps in an algorithm. You also don't always have complete control over the order in which your rules are fired, so it's not like garden-variety coding where it can be treated like a 5-step recipe. It just takes a different mindset. Once you're used to it, things are easier to understand, and this book can help. (By the way, I've fooled around with BREs for about a decade now, and support a production application that uses Drools, so I'd consider myself moderately skilled in BRE usage.)
In the course of writing the banking application the book is anchored upon, the author occasionally makes design decisions that are specific to doing things "The Rule Engine Way". One example is the use of 'global' facilities for validation reporting. The author might have chosen to implement this another way, but chose what he considered the best path and briefly explained his reasoning in making the choice. That's exactly the kind of thing that I think a BRE-literate reader would find of value-- expert insights into how to use this tool, not mere explanations of syntax, etc. Unfortunately, these insights were relatively few in nature and not highlighted where they were presented, so they might not be apparent to readers that aren't already thinking in the BRE way.
One thing the book glossed over that I wish was given more coverage is Guvnor, the Drools Business Rule Management System. Basically, a BRMS is a web application used to change existing rules, write new rules (provided they have been pre-templated by a rule author, usually), and version the rules. I'm told this is one of the key differentiators between Drools and commercial offerings like IBM's JRules, so it's a little disappointing that it was given virtually no coverage in this book.
As the author fleshes out the banking application, we encounter a little scope bleed as the reader is introduced to iBatis, Spring and Tomcat. While I see how these are necessary for the provided application, I viewed them as distractions and potentially barriers to successful implementation for some readers. To counter that, I offer the author kudos for covering a multitude of Drools facets like Domain Specific Language inclusion, Complex Event Processing, and rule ordering through "Drools Flow". All these are valuable tools in the Drools user's toolbox and they are given adequate coverage.
As I hinted at in the opening paragraph, marketers of BREs love to show demonstrations where rules are written in shocking clear 'if/then' syntax. These rules are purported to control powerful application logic and can be maintained by low-cost business analysts. Is this reality with Drools? No, I'm afraid not. It's also not true with JRules, Blaze, or any other Rete-powered BRE. What marketers will show you is how easy rule maintenance can be-- but they're not showing you how difficult things can be when your logic doesn't neatly fit the 'if/then' paradigm. For example, commercial vendors love to show insurance logic where they offer rules like 'IF the driver's age is over 25, THEN give them a discount'. Next time you see one of those, ask the marketer to show you something along the lines of 'Calculate the average age of the drivers in the household'. Notice how that doesn't say 'IF'? Requests of this type will typically require a skilled rule author, not a business analyst copying from a rule template. This type of logic does not play to the strengths of the engine. Actually, implementing this type of logic can be fiendishly difficult-- that's the reason BRE developers are among the best paid of application developers (Check Dice or Monster.com). I say all this to let you know BRE usage sometimes is easy, sometimes is really hard. In a workspace like that, I like to have advice handy from a multitude of providers, and I'll be happy to add this book to my reference collection. I just wish there were more highlighted best practices in this book to help the user leverage the author's expert experience. (By the way, there are a few more books on rules engines available, but most all of what I've seen is truly awful. I do believe they were written by business analysts, and probably ones who have never actually written an application powered by a BRE. I do not find that fault with this book.)
So, what's the verdict? I'm glad I read this book (twice, to make sure I got everything) and would recommend it to anyone using Drools. If you're not yet a Drools user, I don't think this book offers enough remedial material to effectively help you get on board-- for that I recommend the excellent documentation offered online with the product. (By the way, I hope you like cheese. The Drools doc authors seem to have some sort of cheese fixation, so references to cheese are plentiful.) For a Drools user like me, this book offers a view at parts of the toolkit I hadn't yet used and a view of how an expert user might go about designing an application. I'll call it a keeper.
15218150
submission
RickJWagner writes:
This book is written for the person who has to set up and run a Plone site. It's not a development book-- it doesn't show you how to write software, rather it shows you how to acquire, install, and configure software components that will greatly enhance your Plone site. It covers a lot of ground, but much of it is covered in only the barest detail to instruct you in how to add a feature to your site. It doesn't devote much text to explaining what the add-ons do, only how to get them and how to integrate them into your site. There's also a lot of good general advice for a web-site administrator.
Here's a rough run-down on the contents of the book:
Chapter 1
What you'll need to run a Plone site (computer and basic tools, like a text editor) and installation procedures.
Chapter 2
Is titled "Site Basics" and covers the use of Buildout, which is a framework for installing add-ons in Plone. Buildout is very important for a Plone administrator, so it's nice to have coverage of the tool. Truth be told, I wish there was a little more material on Buildout in this book, but this is enough to get you introduced and the web can tell you the rest. To the book's credit, it uses a hands-on approach and immediately instructs you on how to use Buildout to change the default portlet navigation feature of your site and how to add blogging capabilities.
Chapter 3
The third chapter is about appearance, so it covers themes and changing the way your Plone site looks. As with much of the book, there isn't a lot of introductory overview, just step-by-step instructions on how to accomplish some given action. (In this case, the action is changing the look of your site through a new theme.) Buildout is used, of course. Also covered here are some handy tools for examining the things that make up a 'theme' and how to make your own theme. In making your own theme, the book instructs the user on the use of ZopeSkel and Paster, two tools important to Plone development. Again-- the book covers very little "Here is a tool, this is what it does, here's a nice diagram", rather there is "do this, do that, run this script, see how it changed your site".
Chapter 4
This is the administration chapter. The first topic covered is one that confused me on my first Plone site-- how do I add a user account without the requisite mail account? The author covers this topic well, I'm sure it will be appreciated by many Plone tire-kickers. Next, the book gives us the low-down on Zope 2 administration as a prerequisite to user and group management in Plone. (By the way, the CMS application Plone is running on the Zope application server. Sort of like the JBoss administration console is a feature-rich JEE application that runs on top of JBoss, for you Java-types.) The chapter concludes with a very nice section on using Plone with LDAP, which I'm sure is going to be a real-life concern for many corporate Plone users.
Chapter 5
The next chapter is the "Deployment and Maintenance" chapter. It covers such necessities as backing up and packing Plone's underlying database. It also covers log rotation and automation of tasks through mechanisms like cron and windows task scheduler.
Chapter 6
Chapter 6 is the Optimization chapter. It starts with some good advice about keeping Buildout configs (of course!) in source control for managing production deployments. From there, the book gets a little recommendation-happy as it shows how to install and configure several caching components (choosing which is best for you is left as an exercise for the reader), a couple of load balancers and a process supervisor. Front-end HTTP server configurations are covered, again in the usual "You'd better know what you want, but here's how to configure a few" style. Lastly, performance monitoring and viewing is given good coverage.
Chapter 7
This chapter is the 'security' chapter, and it carries some valuable tips. The first is how to restrict TCP/IP access to your host, then you are told how to effectively manage user permissions. Application of patches in Plone is covered, which naturally comes with some good advice about your buildout configuration files. There's also a section about using Apache Cassandra for monitoring user permissions-- in typical fashion, this side-topic is given little material outside the instructions on how to install and configure it. (Figuring out what Cassandra is, how it works, why you would choose it, etc. are left for you to figure out.)
Chapter 8
The final chapter again offers advice on using zc.buildout effectively, this time in the context of upgrading to future versions of Plone.
Overall Impressions
This book is difficult to categorize. On one hand, it often shows the reader how to install an add-on with precious little instruction on exactly what it is you're installing. On the other hand, it does provide very good instructions on how to get those add-ons downloaded and configured for your site. For readers unafraid to augment the book's material with a web browser, there is a lot of valuable insite here. (But for readers who like nice high level diagrams and introductory text that gives you some hint about products you're about to introduce to your environment-- this may not be your favorite book.) I think there is a lot of knowledge about use of buildout here, the reader certainly has enough examples that it will be a familiar friend by the time you're done with the book. There's also a lot of good advice about administering a production CMS site in general. Use of cache products, version control tips for configuration, ongoing maintenance, etc. are all covered. The back of the book states this book is meant as a resource for Plone administrators and content editors. For this audience, I think the book hits the mark well. For others interested in Plone-- i.e. developers who don't have a production site to run-- the book may not feel like such a good fit. All things considered, I think this book is a good resource for the Plone administrator, it's stated target audience.
The book can be found here: https://www.packtpub.com/plone-3-3-site-administration/book
13997492
submission
RickJWagner writes:
This is a book targeted primarily towards the Java programmer who doesn't yet know Groovy. Groovy is a dynamic scripting language that runs on the JVM and offers easy integration with the Java language. Groovy also offers dynamic language features that lend themselves to the creation of DSLs (Domain-Specific Languages). This book attempts to simultaneously teach the reader how to use Groovy and how to build a DSL.
DSLs are something of a hot topic these days. A DSL is a 'Little Language' or a language written just for one business domain. As programmers, we're familiar with DSLs whether we realize it or not-- each time you use 'Make' to build a C project, or use 'Ant' to make a Java project, you're using a DSL. A DSL is a purpose-built language, with it's own verbs, rules, syntax, etc. It's made for one purpose only, and is meant to make things as easy as possible for the intended user. If the user has a need outside what the DSL can provide-- they're just tough out of luck! General purpose languages are for doing whatever the user needs-- DSLs are for doing only one task, but making that one task exceedingly easy for the user.
The book does a good job of making Groovy understandable for a Java coder. Programmers of other stripes would be able to use the book, but the author aimed squarely for the Java sweet spot and I think did a good job of hitting it. Where language integration was to be shown, the JDK was the recipricol part in the examples, and the classes singled out for interfacing were ones that would be well-known to a Java coder.
Writing DSLs has been done for many years, but was largely an undocumented process until just recently. I think the rise of dynamic languages has something to do with that. Dynamic languages offer some key features that make DSL creation a little easier. A few of these features the book covers are closures and meta-programming. Closures are anonymous methods, packaged in such a way that they can be passed as parameters to other methods. Meta-programming is using code to write other code, and can be used to perform some neat tricks like allowing the user to call methods that don't have a previously written definition. (If that sounds really strange to you, I agree. But it turns out this is something very handy if you're writing a DSL!)
The book is written in a way that thoroughly the breadth of features offered by the Groovy language, but not a lot of depth in all of them. For this reason, I found myself sometimes referring to external sources when I was encountering some language construct that seemed a little less familiar than most. It wasn't a problem-- the book did a fine job of letting me know of the existence of some language feature and how it might be used in writing a DSL. If I didn't immediately grasp the use of the feature after the typical single example of seeing it used in sample code, I'd just pop out to the internet and get a few more examples. The book is nearly 300 pages as it is, and very little of that is wasted. I give the book good grades for technical content.
Style-wise, I found the book reasonable to read but not great. As well as the author does spelling out the nuances of the Groovy language, the DSL parts are interspersed among the chapters and sometimes could be hard to find unless you read a lot of surrounding technical content. Maybe this is the only way to cover two meaty topics at once, I don't know. But I found myself doing quite a bit of paging when I wanted to refer back to DSL-specific advice, sometimes falling back to the chapter-by-chapter summary in the front of the book to get myself in the right neighborhood.
The book has plenty of sample code, which I found well constructed and easy to read. The author adapted the practice of writing small snippets of code, then used assertions to demonstrate the behavior the reader would expect if the code were to be executed. I really liked that. The code itself was always cleanly formatted and minimal in length, which made it very easy to read.
So, did the book hit it's target? I believe it did. The strengths of using Groovy for Domain Specific Languages are drawn out, and the Groovy language is given a thorough overview. Java coders will find this book a reference that will let them start using dynamic features while still staying on the JVM. (By the way, Groovy compiles to Java, so all your existing Java code is usable from Groovy. So you might write an application that's 95% Java and 5% Groovy, and that's just fine with Groovy.) I think this book covered a lot of ground and did it well.
13693872
submission
RickJWagner writes:
Book Review for "Plone 3 Products Development Cookbook"
This book takes an interesting path to teaching Plone 3 development. Unlike most software instructional books, it starts way back in the often-unread Preface by listing 10 requirements a mythical customer is asking the reader to implement in Plone 3. The requirements are realistic and I think would probably be quite a stretch for an inexperienced Plone developer. The rest of the book is dedicated to implementing those 10 features, and coaching the reader on Plone 3 development along the way.
I wouldn't say this is a good book for a novice Plone user. There really isn't much introductory material, and there is little material to transition the reader from Plone installation to meaty development. A newbie could certainly use this book if it were augmented with additional material (say, the Internet and a fair amount of time allocate), but the reader had better be ready to self-educate on Plone/Zope/Python development if they are not already proficient in these areas. For developers who already know their way around Plone, however, this book is an excellent step-by-step guide to adding serious functionality to the platform.
The book follows a consistent theme throughout. The desired functionality is briefly (very briefly) described, then the reader is given the following sections: Getting Ready, How to Do It, How it Works, and (sometimes) There's More. Here's how these work:
Getting Ready — outlines installation prerequisites, the things you'll need to gather.
How to Do It — step by step instructions on how to implement your changes.
How It Works — after you've configured things in the previous step, this step explains why things work.
There's More — an optional section where further reading can be found, or maybe extras like test procedures.
The book includes more than just the 10 specified features from the Preface, though. The authors cover development best practices, documentation, a section on testing, and many other goodies that are not directly in the path of implementing those 10 requirements. I especially liked the parts about performance improvements, a consideration that's sometimes lacking in development books.
Many expert-level techniques are revealed to the reader, especially those concerning production of Products for Plone 3. The authors are obviously well versed in their domain and they freely share best practices the reader will be able to leverage. These tips deal with the whole development cycle, distributed in a sort of holistic manner, sprinkled into several chapters along with the primary material for that section. It's not a book on the development process, but if the reader is willing to listen as advice is given, they will become aware of many development best practices (automated testing, documentation, etc.) along the way.
Besides just the how-to aspect of Product development, the authors give the reader some insight into runtime aspects of a Plone site. The chapter covering cache configuration, for example, was lighter on Product development verbiage and much longer on advice that is bound to be helpful for a Plone site administrator rather than a Product developer. I imagine it's probably not uncommon for people to wear both these hats, so this is another useful characteristic. Developers and Administrators alike can profit from this kind of advice.
The book definitely reads differently than most tech instructional books-- it's more like an expert's working notes than it is a typical dev book. It took me a few chapters to catch on, but after I figured out how to best use this format I can see how this would be very useful for random-access reference work. You don't need to do everything in sequence, just skip right to where you need to go.
There's a lot of text provided, too. There are nearly 370 pages here, almost all of it good, meaty instructions provided in the soon-familiar instructional template the authors established early on. If you know exactly what you want to do, there is little room for ambiguous interpretation-- you're bound to get it right. Some might consider portions of the text verbose, but that can be a desirable trait in a book that's going to serve as both introductory survey and later valued reference.
If you're charged with doing Plone 3 development, I'd recommend this book. There's a lot of expert advice here, and it covers a wide range of development activities. I would imagine almost every developer will learn some things from this book, and many developers will learn a great deal. For producing Plone 3 products, it will provide a quick answer for many commonly encountered questions.
The book can be found here: https://www.packtpub.com/plone-3-3-products-development-cookbook/book
ISBN: 1847196721
13325730
submission
RickJWagner writes:
This book takes an interesting path to teaching Plone 3 development. Unlike most software instructional books, it starts way back in the often-unread Preface by listing 10 requirements a mythical customer is asking the reader to implement in Plone 3. The requirements are realistic and I think would probably be quite a stretch for an inexperienced Plone developer. The rest of the book is dedicated to implementing those 10 features, and coaching the reader on Plone 3 development along the way.
I wouldn't say this is a good book for a novice Plone user. There really isn't much introductory material, and there is little material to transition the reader from Plone installation to meaty development. A newbie could certainly use this book if it were augmented with additional material (say, the Internet and a fair amount of time allocate), but the reader had better be ready to self-educate on Plone/Zope/Python development if they are not already proficient in these areas. For developers who already know their way around Plone, however, this book is an excellent step-by-step guide to adding serious functionality to the platform.
The book follows a consistent theme throughout. The desired functionality is briefly (very briefly) described, then the reader is given the following sections: Getting Ready, How to Do It, How it Works, and (sometimes) There's More. Here's how these work:
Getting Ready — outlines installation prerequisites, the things you'll need to gather.
How to Do It — step by step instructions on how to implement your changes.
How It Works — after you've configured things in the previous step, this step explains why things work.
There's More — an optional section where further reading can be found, or maybe extras like test procedures.
The book includes more than just the 10 specified features from the Preface, though. The authors cover development best practices, documentation, a section on testing, and many other goodies that are not directly in the path of implementing those 10 requirements. I especially liked the parts about performance improvements, a consideration that's sometimes lacking in development books.
The book definately reads differently than most tech instructional books-- it's more like an expert's working notes than it is a typical dev book. It took me a few chapters to catch on, but after I figured out how to best use this format I can see how this would be very useful for random-access reference work. You don't need to do everything in sequence, just skip right to where you need to go.
If you're charged with doing Plone 3 development, I'd recommend this book. There's a lot of expert advice here, and it covers a wide range of development activities. I would imagine almost every developer will learn some things from this book, and many developers will learn a great deal. For producing Plone 3 products, it will provide a quick answer for many commonly encountered questions.
The book can be found here: https://www.packtpub.com/plone-3-3-products-development-cookbook/book
12579656
submission
RickJWagner writes:
CodeIgniter is a multi-purpose, open source PHP web application framework that can dramatically reduce the amount of coding required in developing a full-featured web site. This book promises to introduce the reader to the most productive APIs and demonstrate their usage with minimal code snippets. In that regard, I think the book lives up to it's promise.
The first chapter covers CodeIgniter's MVC framework, which provides a way for a programmer to logically partition code so it's easier to maintain. For those of us who aren't accomplished PHP coders, this chapter also contains a PHP style guide, which I thought was a nice feature. By the way, the code snippets throughout the book are clean and easy to read-- the author must have followed his own advice on code style.
The second chapter is an introduction to some of the more productive libraries you'll find in CodeIgniter. Here you'll find some excellent advice on how to take timing metrics in your application, how to secure it, and how to accomplish routine activities like retreiving data from the user's request. Other 'web topics' are addressed here, like how to manipulate the session, how to manage emails and file uploads, and much more.
Chapter 3 handles form inputs and databases. As is common throughout the book, the reader is given minimal technical overview. What you'll find instead is a very brief explanation of what's about to be covered, then a few very readable source lines that demonstrate use of CodeIgniter in action. If this book were your only resource, I'm sure there would be times where you didn't find enough material to get everything done you wanted to do. But if you have a web browser (and Google) handy, a book of this type can be an effective index to help you find the parts of a framework you want to leverage.
The next few chapters cover user authentication and application security. I found these to be a little spotty-- heavy in some places, light in others. Still, the material was useful and not difficult to read or understand.
A nice chapter on tips for building a large-scale application was next. I found this one interesting-- many of the ideas were well-known, but a few had not occurred to me before. I liked reading it. Next up was a chapter on Web Services. I didn't take the time to test the provided code for this chapter, but I would like to sometime. If it works as I hope it will, I may have a new way to stand-up test web services!
The final 2 chapters are on extending CodeIgniter (it's great that the library authors institutionalized this!) and donating code back to the community.
So who is this book for? The book itself tells you it's for expert PHP coders, but I don't believe that's exactly right. Given the easy-to-read nature of the book and the light treatment given to some of the meatier topics, I'd say this book is about right for a novice-to-intermediate level PHP coder. I haven't done a lot in PHP, yet I found the code reading very easy.
If I had a wish for the book, I'd wish for a little more depth in the harder topics and maybe some quick overviews for a few topics. (Diagrams accompanying the overviews would be nice, too. This book has few illustrations except for screen-shots.)
All things considered, I'd recommend this book to coders that are getting started with PHP and CodeIgniter. It's easy to read and will get the reader pointed in the right direction for solving many web problems.
The book (and a sample chapter) can be found here: https://www.packtpub.com/codeigniter-1-7-professional-development/book
11339120
submission
RickJWagner writes:
Book Review: OpenX Ad Server Beginner's Guide
This book outlines use of the OpenX Ad Server. This open source software is used by bloggers, website hosts, and marketeers to set up and execute advertising campaigns. It lets the user define which banners should be shown on which web sites, how often, for which advertisers, and for how long. It also tracks results for the campaign so you can fine-tune your results as the user clicks occur.
The book promises to teach an absolute novice how to use OpenX. In that regard, I find the book kept the promise it made. The reader is given clear instructions on how to download OpenX and apply it to their environment. Even the mechanisms used to FTP files around are given clear text and step-by-step screen shots. Once the software is installed and in use, the same kind of detailed instructions guide the user through every task needed to effectively set up and execute marketing campaigns.
For those new to online advertising, the book provides clear explanations of the underlying concepts. Advertisers, Campaigns, Banners, and Zones are all spelled out clearly in text and with accompanying diagrams. The diagrams, by the way, are clear and easy to understand. This is all necessary prep work, as the reader is then treated to chapter by chapter deep dives on working with each of these fundamental building blocks. The chapters instruct the reader on the necessary details and options associated with each of these constructs. Once the reader recognizes the patterns used by the books authors, one chapter after the other spells out how to configure and make best use of the options provided by OpenX.
The first chapters are devoted to the high-level basics, the middle chapters to implementing those high-level components, and the final chapters to administrative issues and gathering statistics for your advertising campaigns. I found this layout to be logical, as it gives the user the big picture first, followed by the exciting middle topics, and lastly the parts you need to really maintain the product.
After reading this book, you will be able to:
- Understand online marketing and the terms associated with it
- Install the OpenX ad server
- Manage relationships between advertisers and publishers, campaigns and websites, users and campaigns
- Use the OpenX server to place advertisements in specific areas of webpages, and determine which ads will show in which frequencies
- Generate statistics on your advertisements, so you can understand and refine effectiveness
- Upgrade OpenX
- Use 'GeoTargeting' to direct users to appropriate ads by geography
- Use 'Channels' to direct ads by type to web site areas that fit the topic
- Manage your users and administrators (including allowing users to affect the content of their own campaigns)
All things considered, I found OpenX to be a very capable platform for serving online advertisements and I found this book is an excellent introduction to both online advertising and the OpenX server. If you have an interest in online advertisement, I would recommend you have a look at this title.
The book can be found here: https://www.packtpub.com/openx-ad-server-beginners-guide/book
About the author: Rick Wagner is an Enterprise Architect and developer working in the customer demographics workspace. Rick is a Sun Certified Enterprise Architect and member of the International Association of Software Architects.
9237198
submission
RickJWagner writes:
Book Review of "JBoss AS 5 Development" by Packt Publishing
I've just finished a review of the latest JBoss book by Packt Publishing. I wouldn't call it a development book, but wouldn't call it an administrative book, either-- it's really a little of both.
The book promises to cover a lot of territory, and it keeps it's promise. The 14 chapters, in a nutshell contain the following:
- Installation of the application server and Eclipse-based IDE toolkit
- Major differences between JBoss AS 5 and previous versions
- Customizing your JBoss installation
- Developing EJB 3 Session beans
- Working with JPA
- Writing a web application (JSF)
- The new JBoss messaging subsystem (JMS)
- Writing Hibernate applications on JBoss
- JMX and MBeans
- JBoss Web Services
- Clustering JBoss servers
- Writing Clustered Applications
- JBoss AS Security
- Securing applications under JBoss
Notice the last 4 chapters-- Intro to Clustering, then Writing Clustered Applications. Intro to JBoss Security, then Securing Applications. This will give you a hint about the depth the book provides-- it gives a reasonable overview, followed by a deep-dive into content a technician will find usable. I thought the book did a good job of presenting high-level content, yet providing the detail a code-slinger requires. Kudos to the author for that.
The book is reasonably illustrated. There are plenty of high-level illustrations (and some are needed, for the more abstract topics). The book also provides plenty of screen shots, mostly featuring JBoss Tools. More on that later, but for now let's say I was only moderately impressed with the performance of that set of tools.
As a developer/architect, I found the depth of the book somewhere on the middle-to-high-end. I don't think it's a good book for complete newbies-- rather, I'd suggest this book for devs that are already somewhat confident in their JEE coding abilities. You may be wondering why I'd say such a thing-- mostly it's because JBoss tools are just not in the same league as NetBeans 6.8 at this point. If you're a complete newbie to Enterprise Java, I'd suggest you first pick up a copy of NetBeans and GlassFish, then learn the ropes with this easy-to-use combo. Later, once it's all old hat you can pick up JBoss Tools.
This in no way diminishes the value this book will hold for a user of JBoss AS 5. There are plenty of expert level tips for performance, security, customizations, etc. There are also coding tips any developer will appreciate, hence my earlier assertion that this book straddles the developer/administrator line. If you're a JBoss user, you'll find some good stuff here, no doubt about it.
The book is written in an easy to read manner. If you're not an expert on the whole JEE stack, don't worry-- all the major components are given gentle introductory chapters that coach you through writing a JSF application, an EJB, a JPA application and a Hibernate one, etc. If you're lucky, the tools will behave as they're supposed to and you'll quickly have a reference application you can use to model your real-world needs. (If you're not lucky, you'll get some good practice at problem analysis and application debugging. Let's be real, that practice is going to come in handy if you truly are going to use JBoss in production. This is how experts are made....)
There's a lot of content here for a technical book. (There are surely smaller books. But then again, JBoss 5 brought some significant changes, so a big book is warranted.) Comparing this title to the old 'official' JBoss 4 AS doc I have a copy of, I'd praise this book for not filling pages with stuff I don't need to know. It also offers some candid quick-n-dirty tips in places that will give the developer some quick insites into the platform that can quickly be leveraged. Nice.
The author deserves a little praise for decent readability. Truth be told, those folks on the cutting edge of technology are not always the greatest communicators, written or otherwise. This guy makes everything flow well, though, so I give the book good marks in this regard.
All things considered, I'd recommend this book to the following audiences:
- Anyone planning to use JBoss AS 5 in production (Developer or Administrator)
- Intermediate to Advanced level Enterprise Java coders
- Architects in need of high-level descriptions of the latest JEE components
Audience I would *not* recommend this book for:
- Developers not yet proficient in Enterprise Java coding. You might work your way through the book, but you might spend a little time gathering valuable debugging experience on the way.
Happy Reading, and Happy Coding!
Author biography
Rick Wagner is a Sun Certified Enterprise Architect, Sun Certified Java Programmer, and member of the International Association of Software Architects. Rick lives in Arkansas with his wife and 3 kids. You can read his blog at www.rickwagner.blogspot.com"
9167022
submission
RickJWagner writes:
Book Review for "JBoss AS 5 Development" by Packt Publishing
This review is for "JBoss AS 5 Development", which has the subtitle "Develop, deploy, and secure Java applications on this robust open source application server". Having gone through the book with IDE in hand, I would have to say I find the subtitle more indicative of the content than the first part of the title. Later I'll try to explain why I feel so.
The book promises to cover a great amount of territory. Roughly, the 14 chapters cover these topics:
- Installation of the application server and Eclipse-based IDE toolkit
- Major differences between JBoss AS 5 and previous versions
- Customizing your JBoss installation
- Developing EJB 3 Session beans
- Working with JPA
- Writing a web application (JSF)
- The new JBoss messaging subsystem (JMS)
- Writing Hibernate applications on JBoss
- JMX and MBeans
- JBoss Web Services
- Clustering JBoss servers
- Writing Clustered Applications
- JBoss AS Security
- Securing applications under JBoss
If that seems like quite a list to digest, I would agree. The last 4 chapters give a hint to the depth of content the reader will encounter. In those cases, the author first presents an overview chapter about how the application server handles the topic (clustering, security), then follows it up with a whole chapter about applying the implementation details. I thought this struck the right balance between being too high-level (as many books might be) versus being overly detailed (as the old JBoss 4 AS doc book could be in places.)
I think this book will be an excellent acquisition for anyone who is certain they will be working with JBoss AS 5. The author has a deep understanding of the application server and writes in an easy to understand style. The book covers a great amount of 'real world' territory that is sure to be of interest for anyone tasked with moving an application to production under JBoss AS 5. Subjects like security and clustering (must-haves in a production environment) are given enough coverage that they can be of immediate practical use. (Note: these topics are not of vital importance in a pure development effort. A great amount of development can be done without paying attention to either security or clustering.) This is one reason I consider this book to be an interesting blend of development material and administrative material-- it is clearly not a pure development book.
For those that are interested in learning JEE but are not certain they'll be using JBoss, I'd suggest they should consider this book but also compare it to other titles, perhaps one of Packt's excellent NetBeans/GlassFish titles. This is not the fault of the book-- the author does a good job of walking the reader through various exercises in building EJBs, a JSF front-end application, a web service application, etc. The reason I don't suggest this book for new students of JEE is that the raw toolkit is just not at the same level some other open source development stacks are at. (Notably, NetBeans 6.8 and GlassFish). Putting it plainly, there are more than a few things that can go wrong in putting together a JEE application with JBoss Tools-- if the user isn't seasoned in problem analysis and debugging, it could easily lead to frustrations and an unsatisfactory experience.
If you're already confident in your ability to write and deploy JEE apps, you should find this book to your liking. Intermediate to advanced JEE developers ought to find plenty of material to keep them interested. Performance tips, JBoss specific extensions, and expert usage tips for enterprise Java development all get good coverage. The author knows the ins and outs of using JBoss AS 5, and is generous in providing tips in effective usage of facets the reader is likely to encounter. The author also provides good high-level overview material (which usually precedes the detail), which helps keep the reader grounded in the larger context of what's being conveyed.
The book provides a reasonable number of illustrations, including screen shots of JBoss Tools wizard screens. I found these of reasonable value, but have to admit I'm of mixed emotions on the toolset itself. It does a great job of some things (I love the packaging wizard that let's you declaratively roll up .jars, .ears, etc.). On the negative side, it makes some actions much more difficult than they have to be. I thought the author did a good job of providing meaningful illustrations where an abstract idea was being presented, especially in the security and clustering chapters. I once made a presentation at JBoss World about studying for the Sun Certified Enterprise Architect exam using JBoss-- I wish I'd had those illustrations then! I guess my SCEA is now a depreciated asset-- maybe we'll have to study for 'Oracle' architectural credentials in the future.
All things considered, this book will be an excellent source of information and reference for anyone using JBoss AS 5. I'm sure it will prove value time and again as the reader delves into the various corners of enterprise Java. This book offers expert insites on many topics and does it in an easy to read manner.
Author biography
Rick Wagner is a Sun Certified Enterprise Architect, Sun Certified Java Programmer, and member of the International Association of Software Architects. Rick lives in Arkansas with his wife and 3 kids. You can read his blog at www.rickwagner.blogspot.com
8652864
submission
RickJWagner writes:
"GlassFish Administration" is a handbook for administrators, developers, and users of the GlassFish application server. Since GlassFish is the reference implementation for the Java EE stack, it stands to reason that an astute reader of this book will be exposed to all the slick features of JEE. (I found this to be true, by the way.) Since I've long been a fan of Sun's ability to make tools that are easy to use (at least as far as JEE allows), I dove into this title expecting to find new and easy ways to leverage the Enterprise Java stack. I wasn't disappointed.
This book promises to cover GlassFish from the point of view of the administrator. This has actually been an overlooked niche, I think-- there are many books to assist the JEE developer, but few are written exactly to help you when your role involves the care and feed for the running server. In addition to administrator-types, I'd also highly recommend this book to Enterprise Java Developers. A copy of this book, coupled with the excellent NetBeans IDE will give the user a powerful and easy to use toolkit for understanding the intricacies of JEE.
The table of contents promises the following:
- Basic GlassFish architecture
- Application deployment
- The usual administrative activities around connection pools, databases, and JMS queues
- Security (a must-have)
- Monitoring (Hey, that's good!)
- Clusters and High Availability
- Tuning and TroubleShooting (Tuning is another really good thing to see!)
The book delivers on what the Table of Contents promised, and does it in a very readable way.
I was especially pleased with the generous use of illustrations. The author made good use of diagrams to help the reader understand abstract ideas, as well as showing screenshots to help guide the reader through the GlassFish UI. As an unexpected bonus, almost every UI action was accompanied by the command line equivalent. (Very useful for those admins who like to script actions for repeatability and auditing purposes.) If you're like me, you probably don't mind using a graphical UI the first few times you do something, but the CLI is much faster once you know exactly what you're doing. For that reason, I'm really glad the CLI was given enough coverage.
The text was easy to read and packed with useful real-world advice on best practices for owners of a JEE Application Server. (Note that much of the advice given was not particular to GlassFish-- there are quite a few best practices here that can be applied to other App Servers as well.) I was especially appreciative of the sections on performance tuning and server monitoring, two areas that don't usually receive a lot of attention. Here are some particular likes and dislikes I had with this book:
Like
- Easy to read
- Lots of expert tips on app server usage
- Decent coverage of application development matters, could be used as a refresher for those of us who aren't JEE current
- Advice on tuning and monitoring always holds great value to 'real world' users
Dislike
- Covers GlassFish v2 extensively, but v3 is only covered by one chapter (in fairness to the book, version 3 is brand-spanking new and version 2 is the current production mainstay)
- I wish it contained a little more content on GlassFish development with Netbeans, as 'Beans and 'Fish are a dynamite combination (sorry, I couldn't resist. The two do go really good together, though.)
Conclusion:
I'd recommend this book for anyone who uses GlassFish, and anyone who needs an easy way to work with JEE. It's a really easy read.
About the author:
Rick Wagner is a Sun Certified Enterprise Architect and avid software developer. You can read Rick's blog at www.rickwagner.blogspot.com
