Announcing: Slashdot Deals - Explore geek apps, games, gadgets and more. (what is this?)

Thank you!

We are sorry to see you leave - Beta is different and we value the time you took to try it out. Before you decide to go, please take a look at some value-adds for Beta and learn more about it. Thank you for reading Slashdot, and for making the site better!



Jboss AS 5 Performance Tuning

RickJWagner Re:Once again 8/10 (45 comments)

P.S. Validate my existence at www.rickwagner.blogspot.com. If you're feeling especially generous, click one of my ad-sense links. Though I've never cashed in yet, I think I get something like a dime for every million clicks! Or something like that...

more than 4 years ago

Jboss AS 5 Performance Tuning

RickJWagner Re:Once again 8/10 (45 comments)

Gee, thanks. (I think.) No, seriously, I'm a real-life code slinger and have been doing it for over 20 years. Am I an expert in every topic I write about? Sadly not. But if the topic is in the enterprise arena, there's a good chance I've got some hands-on experience there. I always try to call 'em like I see 'em, whether I've been working with the tech stack 15 years or 15 days. Thanks, Rick

more than 4 years ago

Jboss AS 5 Performance Tuning

RickJWagner Re:Once again 8/10 (45 comments)

You are correct, my personal blog has been heavy on Packt titles. But if you check other sources online, you'll find other reviews for other publishers. The common theme? Tech topics... (Packt has nicely asked if I'd post on my blog, others have not.) If you're really a glutton for research, hop out to Amazon where you can find "Data Engineering: Mining, Information and Intelligence". I actually got to write a few lines in that one! Rick

more than 4 years ago

Jboss AS 5 Performance Tuning

RickJWagner Re:Once again 8/10 (45 comments)

A good checklist, but you're totally wrong on the last point. I have never received a dime from Packt or any other publisher. (I did two reviews for Manning recently, for instance.) My total compensation? Sometimes a print copy of the book, sometimes an e-copy. I just like to keep current on tech topics, so I do a lot of reading. Rick

more than 4 years ago

Jboss AS 5 Performance Tuning

RickJWagner Re:Once again 8/10 (45 comments)

Well, I guess you're right, I probably am a little heavy on '8's. But there's a reason-- I get to pick the books I review, so I tend to pick ones that I'm going to like. (Why aren't there any 10s? I guess I haven't found the perfect book yet.) I would say that if I do any reviews in the future I'll try to throw in more variety, but I really don't see it happening. (I'm going to pick books that I like....) so I'd say please just read the reviews (they're honest) and make your own numeric rating. Rick

more than 4 years ago

NHibernate 3.0 Cookbook

RickJWagner Re:Packt Publishing? (72 comments)

Thanks for reading my stuff. Especially the blog, please do visit that one often. (I use AdSense, if you visit my blog about a million times I'll make a dollar or so.) ;) But do please note: I review tech books from other publishers, too. A few examples: http://www.javalobby.org/articles/jboss-seam-rick/ (Apress) http://www.javalobby.org/articles/beautiful-code/ (O Reilly) http://rickwagner.blogspot.com/2010/11/book-review-spring-dynamic-modules-in.html (Manning) Full disclosure: I always sign my real name to my reviews, I have never received payment of any kind from anyone, except for sometimes a copy of the book to be reviewed. My reviews tend to be honest but maybe a little on the kind side, as sometimes books appeal to some people but not all. I try to be as technically accurate as possible. Watch for future reviews: Erlang and OTP in Action (Manning) JBoss AS 5 Performance Tuning (Packt) Please do keep reading my reviews! Thanks, Rick

more than 4 years ago

Drools JBoss Rules 5.0

RickJWagner Re:Woot! (55 comments)

Yes, it's true I do a few book reviews. But there are a few things you should consider: - I never accept any payment from Packt or any other publisher. My reviews are done purely for the joy of reading and learning. - I always write what I honestly believe to be true. If a friend were to ask me what I thought of a book, I'd tell that friend just what you see in the review. - I always post reviews under my real name. It's part of giving you my honest opinion. So does that make me a shill? I don't think so, but it's in the eye of the beholder. Rick

more than 4 years ago

Drools JBoss Rules 5.0

RickJWagner Re:BREs can't solve every problem (55 comments)

Ah, I believe you are enlightened to 'the Rule Way'. Thank you for the comments, I believe we'd agree on many aspects of the topic. Best Regards, Rick

more than 4 years ago

Drools JBoss Rules 5.0

RickJWagner Re:Doesn't IBM JRules have BRMS... (55 comments)

Yes, they do. (I've recently worked with that one a bit, too.) But at it's heart ILog (the IBM product) is still a Rete implementation, which means it conforms to the 'IF/THEN' or 'WHEN/THEN' advantage/disadvantage. Interestingly enough, many vendors of BREs view their BRMS as the 'strategic advantage' that commands a higher price. The basic rule engine doesn't seem to be treated this way.... BR, Rick

more than 4 years ago

Drools JBoss Rules 5.0

RickJWagner Re:Fiendishly difficult (55 comments)

Hi PCM2. The point I was making is that IF/THEN questions are very easily answered. (And verified by the reader above who mentioned the ease of using spreadsheets.) But if you have a problem that isn't predicated on the attributes of a single object, things can get much trickier. But don't take my word for it-- go download Drools (especially with the excellent Eclipse plug-in) and give it a shot. You'll soon see that there are questions that are easily answered, and questions that are not.... Best Regards, Rick

more than 4 years ago

How can an old-school coder regain his chops?

RickJWagner Maybe try Python, for a sampling of the ages (3 comments)

I'd recommend starting with a language like Python. You can start with old-school straight-line code, then add in the object-oriented and finally dynamic bits. When you feel you're really ready to step into the 2000-era environment, you can pick up a nice api-heavy framework (say something like Plone) because that's how a lot of work gets done today. That'd bring you up to speed in all the relevant eras, while starting you out with something that'll be accessible right from the start. Good luck! Rick P.S. I started out in 1990 as a COBOL programmer and have thus far managed to stay on top of the wave by not getting out of the game. Hang on, the multi-core revolution looks ready to throw us into the next era (leaving the object-oriented, framework heavy era behind.)

more than 4 years ago

Plone 3 Products Development Cookbook

RickJWagner Re:Okay but... (52 comments)

Hi Kevin, I am RickJWagner, your humble book reviewer. I too consider myself well-versed in tech (after 20 years as a professional developer), but am surprised very frequently by new topics that pop up. In the old days, after I knew COBOL and a little Assembler, I thought mastering algorithms was all that was left (except for CICS and other mainframe stuff). Nowadays I am amazed at the number of languages/frameworks/technologies we have available. It's a much broader universe than I ever expected. As for my motives, I just love to code. I do volunteer (never paid) reviews of tech books and post them on several sites. I have a semi-popular blog, where I write on programming topics. (www.rickwagner.blogspot.com). Thanks for reading, and I hope you find something you like in my writings. Rick

more than 4 years ago



ETL-- what is it, why you should care

RickJWagner RickJWagner writes  |  more than 3 years ago

RickJWagner writes "ETL is an IT discipline that deals with efficient handling of multiple rows of data. Reading, writing, augmenting, transforming, validating, reporting-- all this is covered by ETL. See how it differs from an ESB (or Data Integration Framework) and why ease-of-use is a strong point."
Link to Original Source

Book Review for "Camel In Action"

RickJWagner RickJWagner writes  |  more than 3 years ago

RickJWagner writes "Book Review for "Camel In Action"

I'm pretty certain this is the definitive guide to Apache Camel, destined to be referred to as "The Camel Book" by Camel users for a long time. It covers Camel inside and out, upside and down, 550 pages worth of gritty detail that takes the reader from level zero to monitoring of your production applications. If you use Camel, or think you might want to, you need to pick up a copy of this book.

If you haven't used Camel, it's known as an "Integration Framework", a phrase that I like to equate to "ESB Lite". By that I mean if you want to route messages or transform them, this is a tool you might consider. Still not quite sure what I'm describing? Here's a couple of examples. If you want to read messages from a JMS queue, use the contents to invoke a web service and put the results of the web service call in a database, Camel's a good tool. If you want to read in a flat file, split it into individual lines, take a part from each line to call a web service, Camel's a good tool. Camel does all this and more, acting as a sort of universal router and message transformer. Camel aims to implement the famed "Enterprise Integration Patterns", which are easily understandable descriptions of processing snippets that provide functionality in likely scenarios when you're using messaging. If you're brand new to this type of programming, I'd encourage you to use Google to check out "Enterprise Integration Patterns"-- you'll quickly get a feel for the workspace Camel lives in.

The book is exhaustive in it's coverage of Camel. It shows the reader how to configure Camel using both Java code and Spring configuration snippets. It's meant to be progressive in nature, showing the reader simple uses to start with, then progressing to more advanced scenarios as the book gets into the latter chapters. (More about this later, it involves my only complaint about the book.) Along the way, the authors address real-world topics like transactions, production monitoring, and deployment to different hosting containers. All told, the book reflects the concerns of someone who has actually used Camel for real-world work, and as such will prove to be an invaluable resource for anyone moving Camel to production.

The source code that goes with the book is clean, easy to read, and above all it works right out of the box. It's all Maven-centric, so if you're not a Maven user yet you will be at least partially practiced in it by the time you're done with this book. The examples are straight out of the chapters, so you can look to the book for a detailed explanation of what you're running. (You can also run what's being described, and monkey with it to learn new things. Very handy.) I offer no improvement for the sample code, it works as advertised.

I was especially impressed by the care the authors took to explain the really nitty-gritty stuff that a real-world user is going to need. Concurrency and transactions fall into this category. All the sample examples in the world won't help you if the book doesn't help you scale you app and make it safe for production use, considerations you sometimes don't find in tech books. They're here, though, and covered in sufficient detail to meet your go-to-production needs.

This is a big book, and the text it contains is as simple as it should be but no simpler. The illustrations are simple and relevant. If you're brand new to Camel and want to read it front to back, be prepared to allocate a good number of hours for this task. This is because there's just a lot of material covered here, none of it fluff. If you're already an established Camel user, this book will serve well as a desktop reference for when you want to venture off into more of Camel's abundant functionality.

So what's not to like? The only criticism I have for this book is that the ordering of the chapters is not quite to my liking. It starts out with the simple canned examples, and they get progressively harder, 'till the reader is finally given the knowledge to write their own applications way out in chapter 11. If you're like me, you like to see an example or two, then you like to start hacking out your own "Hello World" apps to get a feel for how to build the artifacts you need to get things running. I thought chapter 11 was too late in the game for that knowledge. In fairness, if you're a reader who doesn't mind skipping around as you read, then just skip to chapter 11 right away and you needn't worry about this tiny nit.

So who's this book good for? Camel users of all types, from beginners to those who already own running Camel apps will benefit from this book. You won't be sorry-- you'll never wish you'd held out for a better book, because there just flat isn't going to be one, at least not for a long, long time. I give this book a solid 9 out of 10 stars.

The book can be found here: http://www.manning.com/ibsen/"

Link to Original Source

Review for 'BackTrack 4'. Hacking made simple.

RickJWagner RickJWagner writes  |  more than 3 years ago

RickJWagner writes "Book Review for 'BackTrack 4: Assuring Security by Penetration Testing'.

Watch out, System Admins. The floodgates to BlackHat Hackerdom are now open.

Packt Publishing has just released "BackTrack 4: Assuring Security by Penetration Testing", a how-to book based on the freely available BackTrack 4 Linux distribution. The intent of the book is to educate security consultants on the use of this devastatingly complete Hacker's toolkit, and to provide sage words of advice on how to conduct yourself as a penetration testing consultant. On both counts, the authors do well.

I have to admit, at first blush I wasn't impressed by the book. I usually start looking a tech book over by thumbing through it, quickly glancing over snippets every chapter or so to get a feel for how the book is written. My initial impression was that the book contained many 2-page introductions to what appeared to be system tools, showing how to invoke them and the type of text output they would produce. Who needs that, I thought? I settled down to read the text front to back, then realized the full horror of what I was reading. More on that later.

The book starts out telling you how to find BackTrack 4, how to install it or run it as a live DVD, and how to get the parts working. Suffice it to say this is all easy for anyone who's installed a Linux distribution before.

Next up, the authors cover some solid basics for the would-be security professional. There are other tips throughout the book, too-- what kinds of written agreements you should have, what types of reports you should produce, and generally how you should conduct yourself. Well done, and I'm sure anyone reading this book will have the thought that maybe they'll go into business doing this someday. At least that's what I hope everyone is thinking, because after that the gloves are off and you are shown the dark side of this magnificent machinery.

The authors outline a disciplined framework for penetration testing. By myself, I never would have considered such a thing, but these guys clearly have given this a lot of time and effort. The following chapters are broken out into each phase, and within those chapters the various tools of the trade are grouped. (So you'd find the tools that can provide you with a reverse shell in the 'Target Exploitation' chapter, for example.)

The first phase is Information Gathering, and here the reader is introduced to several tools that can glean information like domain names, IP addresses, host names, and other data that can identify potential targets. The 2-page tool introductions I mentioned earlier contain all the tools that do this kind of work. There's enough introductory material to let you figure out which ones you want to try (it seems each chapter covers at least a dozen tools), and how to get started.

Target Discovery is the next phase, it's all about finding hosts and identifying operating systems. Again, no malicious stuff goes on yet, just methodically gathering information. Par for the course, there are a variety of tools presented to help the user.

Target Enumeration is next. The user is exposed to applications that can help find which ports are open, which services (i.e. MySQL) are running, and even what kinds of VPN are present. By the way, throughout the book the authors throw in brief but relevant snippets concerning the topic at hand. As an example, in this chapter you'll find an example of the TCP protocol (SYN, SYN-ACK, etc.) that will tell you when a port's available and when it's not. There's more of this kind of information throughout the book, too. Some of it I knew (not much, really) and some I didn't, so I felt the book advanced my basic knowledge of IT systems in some ways.

Now that the user has all this useful information, they can proceed on to Vulnerability Mapping. Here the tools are used to help calculate which vulnerabilities might exist in the targeted systems.

The following chapters are where the really bad toys come out. They deal with Target Exploitation, Privilege Escalation, and Maintaining Access. True to their titles, they tell all about how the user can attack the targeted systems, set up shop, and leave a backdoor for returning later.

Of course, no good book on penetration technique would be complete without a chapter on Social Engineering, and so we have one here as well. Hardcore hackers might look down their nose at such a thing, but I imagine this is really one of the more effective avenues of attack.

So, who is this book good for? First, for security professionals. They'll want to get a copy just so they can be sure they understand what they're up against, and how to check their own systems using the same tools the bad guys have. Second, programmers with an active sense of curiosity. I fall into this category. Lastly, the bad guys will probably buy a copy (or pirate one), unfortunately. I hope they're too lazy to read it well and end up getting busted and thrown in the clink. Maybe they can talk ethics in programming with Hans Reiser while they're awaiting parole.

Rating? 9 (evil) stars out of 10.

If your livelihood depends on keeping a secure environment, you probably ought to get a copy of this book for your in-house penetration tester. It's an eye-opener."

Link to Original Source

Book Review for "R Graphs Cookbook"

RickJWagner RickJWagner writes  |  more than 3 years ago

RickJWagner writes "Once upon a time, I thought communication was one of my strong suits. Alas, a few years into my programming career I realized I'm more of the heads-down codeslinging type, not one of the schmoozing managerial types. So when I have a point to make, I really like to have my data ready to do the talking for me. In that capacity, this book is a very good weapon to have in the arsenal.

Right away, you should realize this is not a book that teaches R. R (an excellent open source statistical language) is a great tool for any technician. I've used it to analyze logs, find performance bottlenecks, and make sense of mountains of nearly unrecognizable data. But this book doesn't teach R, it teaches R graphing.

It turns out R has excellent graphing capabilities. You can draw scatter plots, line plots, pie graphs, bar charts, histograms, box and whisker plots, heat maps, contour maps and 'regular' maps. These are all good for demonstrating data in different ways, and the book lightly explains which graph will help you illustrate which point.

If you're getting a little interested, you'll also want to know that all this graphing can be scripted and scheduled. So you can get data-driven reports on a schedule, easily accomplished once you know how to write the graphing scripts (which are then scheduled using cron or a similar facility). One small caveat: To prepare your data for presentation, I think it's usually necessary to partner R with another language that's better for text extracting and manipulation. I prefer Python for this task, you might like another language.

The book is exceptionally easy to read and work with. This doesn't mean it's simplistic, though. Anyone who's tangled with R's graphing without a good example will testify that figuring out the various functions and arguments necessary to wrangle a descriptive graph can be really difficult. This book gives you the kind of graphs you need, with the bells and whistles you're going to want, in a series of snippets you can run immediately.

The book is written in Packt's 'Recipe' format. In a nutshell, this means that it's a series of how-to sections worded in a templated form. There are headings for sections that inform you what you're going to accomplish, how it's done, and why it worked. You quickly realize it's a repetitive format, but it serves to make the book an excellent resource for quick reference.

Another really nice feature of the book is the downloadable source code and matching data. Knowing the data is half the battle, really. The specific formulas given are certainly useful, but without knowing how the underlying data is formatted you really wouldn't get nearly the practical value. For that reason, I urge anyone using this book to be sure they examine the underlying data for at least the first few formulas. After that, it'll be automatic, you'll know you want to look at that data when you're trying to master some graph type. Then when you go to make your own data ready for graphing, you reach for that secondary language like Python, extract the fields you want in a way similar to your example data set, and presto-- you've got the graph you want.

The book starts out with a first chapter that introduces the kinds of graphs you'll be able to produce and situations where each type is most useful. The next chapters, up until the final one, are in-depth sections on each of the graph types. Maps are treated to a different chapter than pie graphs, for instance. The final chapter covers putting final touches on your graphs, including saving them in different formats (PDF, PNG, JPEG, etc.) and niceties like adding scientific notations, mathematical symbols, etc.

The book states that the target audience is experienced R programmers. I really don't think that's necessary, though. There is an obligatory R installation section, and I think that a reasonably competent programmer with Google at his disposal could get off the ground (for graphing purposes) with this book and a little bumbling. If you already know R, then you needn't worry at all, there is nothing here that will look foreign to you.

If I could change one thing about the book, I'd want a comprehensive index of all the functions and arguments that augment the basic core functions that produce the example graphs. These functions and arguments tweak the basic function in ways that make them much more appealing than what the basic function alone can provide. But the book isn't able to show each and every combination with each graphing function, so it's up to the reader to figure out how to pick some of the options from one recipe and apply it to another. It's not difficult to do, but having an index to help you find the options you want would make this process easier.

Final grade: 8 out of 10.

The book can be found here: https://www.packtpub.com/r-graph-cookbook/book


Link to Original Source

Book Review: "Android User Interface Development"

RickJWagner RickJWagner writes  |  more than 3 years ago

RickJWagner writes "Book review for "Android User Interface Development: Beginner's Guide"

So you want to be an Android developer? If you're like me, you've probably been wanting to learn how to program a mobile device, but just haven't found the time to master Objective-C. So now that Android is here, all of us garden-variety Java coders can jump on the bandwagon and start slinging apps out, right? Well, it turns out there's a little more to it than that. This book can make the trail from everyday Java code slinger to best-selling Android app writer a little more plausible.

The book does not teach Android development. For that, there are other books and the Android SDK documentation, which I found adequate for my uses so far. This book emphasizes teaching Android User Interface development, which is something I would not have had much of a clue about without the book. (The Java and XML-based configuration of Android is easy enough for a back-end Java coder like myself, but I've never been a web-design and layout guy. Or fat-client layout and design guy for that matter, either.) That's the sweet spot for this book.

Android newbies do get an introductory chapter that guides the reader through setting up the SDK and writing a quick first app. After that, the book starts to take a serious UI bent, and that's o.k. because that's where the book's intended to go. The earliest chapters cover UI-centric matters like asking the user a question and processing the answer that is returned. List selections are explained (i.e. single-select button choices versus multi-select). Functional features like adding a header or a footer are explained.

The middle chapters cover pragmatic issues like producing an image gallery, handling date/time inputs, and validating user inputs. Layouts in Android are explained, which will be somewhat familiar to Java Swing developers. I had an interest in learning how animation works (don't we all dream of writing the next viral-selling game?), this is explained as well.

The final chapters deal with styling (i.e. how to change the way a button looks) and themes. It's very important that your application 'feels' like it should, and this is given adequate coverage in the book. I'm sure a back-end coder like myself would botch this part horribly without guidance, so I can appreciate the reason the book emphasizes these things.

The book is written in Packt's 'Cookbook' style. If you haven't seen one of these before, the book is largely cut up into sections covering some general idea. Within the section you'll find headings for the topics "Time for Action", "What Just Happened" and "Have a Go, Hero". "Time for Action" is a series of instructions that spell out exactly what to do for a sample scenario. "What Just Happened" follows up with an explanation of why the reader was asked to execute the instructions. "Have a Go, Hero" is a section challenging the reader to extend the spoon-fed instructions by implementing a next-step challenge. This style of writing emphasizes hands-on knowledge transfer without a lot of verbose theory, so it'll be good for readers who like to learn as they code. Contrast this to books that have a lengthy section of text explaining all the details of some topic, followed by a monolithic code blob towards the end of the chapter-- this book is not written that way.

The sample code that's available on Packt's site is clean and easy to understand. It follows the same structure as the sample code you'd find in the SDK, so if you're brand new to Android development you might start with the SDK teachings and then extend it with the book as soon as you're ready. I thought the examples the book presented were almost all reasonably relevant. The author did a good job of keeping the exercises presented throughout the book well contained, so you're never asked to code too much stuff at one time. I like that, as it lets you read the book without having to set aside a huge block of time at once to see the results of your coding efforts.

So who is this book good for? I'd say it's a good resource for Android developers who aren't already UI experts. I'm not saying it's good for Android newbies who need to learn the basics of Android programming, because there's just too little introductory material for that. But if you can already hack something together, and want it to be appealing to someone besides yourself, this book can help. On a 1-10 scale, I'd give this book 7 stars.

The book can be found at https://www.packtpub.com/android-user-interface-development-beginners-guide/book"

Link to Original Source

Book Review for "jBPM Developer Guide"

RickJWagner RickJWagner writes  |  more than 3 years ago

RickJWagner (1297357) writes "jBPM is a mature, open source BPM solution. This book, written in a developer-centric manner, guides the reader through the framework and exposes many important considerations for production use.

BPM tools are used to define and execute business processes. They usually come with a graphical editor, which is used to drag and drop boxes onto a graph. The boxes represent activities performed by programs, activities performed by humans, and decision points. If this all sounds like 'graphical programming', it isn't. The picture does draw out the desired series of steps, but there's always configuration and maybe some programming involved as well.

Developers new to the scene will probably draw parallels between BPEL and BPM. While they both allow the designer to orchestrate a series of activities, BPEL uses web services exclusively. (BPM doesn't specify, and often uses Java classes to accomplish desired goals.) BPEL offers support for human-activities (from BPEL4People and WS-HumanTask), but BPM has offered human tasks from the early days, so probably is a better choice if you have lots of them.

The book is true to it's title, it's definitely a book for developers. In the early chapters the reader is guided through implementing their own mini-BPM engine. This is an interesting exercise and helps solidify in the reader's mind the core concepts behind jBPM. It also reinforces the notion that jBPM can be used in a lightweight manner-- it's just as easily embeddable in a standalone Java application as it is deployed in a JEE container.

Speaking of JEE containers, jBPM is a JBoss product, so it's natural that it makes use of available infrastructure like Hibernate, poolable data sources, and enterprise beans for enterprise use. These are all optional-- if you want to write a minimal application that sits outside of JBoss, that's fine. But if you have heavyweight needs, heavyweight infrastructure is readily available. The book covers these important options in detail, which will be useful for developers writing real-world applications.

jBPM is popular enough that it's mentioned in quite a few SOA books as an enabling technology for process management. Most of these books provide coverage of the minimal, embedded use of jBPM. This book differs in that it provides good explanations of the 'enterprise' use.

Normally I strongly prefer paper books to electronic versions, but in this case I'd recommend you might consider the eBook. I say that because the book is much more useful if it's used in conjunction with the source code found on the publisher's site. The book shows source code in each example, but it's just a snippet out of context. I found the content much easier to understand when it was viewed next to all the related artifacts, so you can understand how they relate. (By the way, the toolkit used includes Maven and Eclipse. The reader is given adequate instruction in the front part of the book on setting these up.)

There's not much fluff in the book. It runs about 350 pages. Heavy Developer-type stuff starts after about 40 pages and never really gets lighter after that. Screen shots and diagrams are given where necessary, but mostly it's code and text. Sometimes books are criticized for being light on technical content and overstuffed with pictures and basic diagrams. This criticism does not apply in this case.

A big part of jBPM development is in data handling-- how do you get data into your process instance, and how do you get data out? The author explains this well, and it is a necessary discussion.

You might wonder why you should be interested in this book, which covers jBPM 3.2.6. After all, jBPM 5 was just released. What about jBPM 4? I believe this book will be relevant for quite a while yet, as jBPM 4 is not going to be included in JBoss's support cycle. They'll stay with jBPM 3 (the current supported standard) and will eventually move on to jBPM 5 (after it's gone through the 'community trial by fire' on it's way to productization.) jBPM 5 is going to be a big change from the current landscape-- it's converging with the rules engine Drools. For these reasons, I expect there will be a lot of jBPM 3 development done for a while yet.

So, who would I recommend this book for? I'd say it's a good book for anyone supporting a jBPM 3 deployment, or anyone considering developing a process-centric application. jBPM is a good product, and this book can help a reasonably skilled Java developer get off the ground. I would not recommend the book for someone just out trolling for a technology book to pick up, or an analyst charged with developing the graphical process depictions. As the title says, this is a book for developers.

Overall rating: 7 out of 10.

The book can be found here: https://www.packtpub.com/jboss-business-process-management-jbpm-developer-guide/book"

Link to Original Source

Book Review for "OSGi and Apache Felix 3.0"

RickJWagner RickJWagner writes  |  about 4 years ago

RickJWagner (1297357) writes "Book Review for "OSGi and Apache Felix 3.0, Beginner's Guide"

OSGi is a Java framework that's designed to simplify application deployments in shared environments. It allows applications with differing dependencies to run side-by-side in the same container without any deployment time contortions. The end result is that your application that needs FooLib v2.2.2 can run right beside my application that needs FooLib v1.0, something not often possible in today's application servers.

OSGi is actually more than that, though. It's a framework with a very granular component lifecycle model, so you can carefully manage when the various parts of your application start up. It contains a service registry, so your application can either advertise or consume services. It's a controllable application runtime framework, complete with shell language that allows administrative tasks to be performed.

All these things and more are covered in the book. The author assumes the reader knows nothing more than what an average Java coder would know, so the development environment is given great coverage. (As is increasingly common, Maven2 is the build mechanism being used. The author goes to great lengths to explain how to construct every .pom file you'll need.) By the way, you'll be needing plenty of .pom files, as you are going to be incrementally building a simple bookshelf application, adding functionality chapter by chapter.

The book's example business logic is nothing out of the ordinary, which is good. If you're new to OSGi you're going to have your hands full learning the ins and outs of packing applications, the component deployment cycle, etc. Any experienced developer is going to instantly recognize the business problem you're trying to solve, so at least you won't be bothered by that. There is plenty of new material to study otherwise-- even tasks as ordinary as logging or deploying a servlet are vastly different than what you're probably used to. I remember I once read an article on the web about a new Java spec, the article was called "Don't make me eat the elephant again!" Well, if you're new to OSGi and want to get started.... break out the silverware!

In some ways, I'd compare Felix to an application server. It's an environment you use to deploy your applications, and it comes complete with a shell language used to administer the container. (The shell language, called 'Gogo', is given it's own chapter. You're also given Gogo commands throughout the book as you develop, deploy, and run your application.)

OSGi specifies a "Bundle Repository", which is a place where you can place your deployment artifacts so others can access them when they're listed as dependencies to their applications. (All this is done in the manifest files, by the way. You're given a good overview of all of this.) The OBR is yet another part of the landscape that will become important to you, so it's given good coverage in several chapters as you need to access it.

The development tasks are carefully covered. You are given very clear instructions on Maven to start, later on the author might withhold a little information to make you work a little. (Hint: the book's sample code fills in gaps nicely, if you get stuck.) The book also includes a series of 'Pop quizzes' to help you check your understanding of the material. More than once I found I might've been reading a little too quickly and paged back-- sure enough, the material had been presented, but I hadn't been paying enough attention. I liked this part of the book.

The application you're building is realistic enough, and you incrementally add functionality to it to make it something similar to what you might actually need in the real world. You start with the basic object model needed for a CRUD application, then add on niceties like a text UI, logging, a graphical interface, etc. Along the way you're introduced to things like iPojo, which is a dependency injection mechanism for OSGi. (Remember that elephant? Here's a small chunk...)

The book ends with a nice-to-have chapter on troubleshooting issues and two appendices. The first one covers the development environment, Maven/Eclipse. The second one covers advanced topics that should be within reach for the reader by the time they've reached the end of the book.

So, what's the bottom line? I'd say this book is good for anyone who wants to learn OSGi in general, or Felix in particular. No prerequisites exist, except maybe basic competency in Java. For developers just shopping around for an instructional book, without a need to pick up OSGi..... I'd say maybe not. (Why clutter your brain with this stuff, unless you're going to put it to good use?) Overall, the book is well written and presents things in an easily understandable way. On a scale of 1 — 10, I'd give this book an 8.1.

The book can be found here: https://www.packtpub.com/osgi-and-apache-felix-3-0-beginners-guide/book"

Book Review for "Jboss AS 5 Performance Tuning"

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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"

Look out Erlang-- There's a New Book in Town

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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/"

Link to Original Source

Book Review: "NHibernate 3.0 Cookbook"

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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"

Book Review for "Spring Dynamic Modules in Action"

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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."

Book Review: "Drools JBoss Rules 5.0: Developer's

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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."

Book Review for "Plone 3.3 Site Administration: Ma

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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"

Book Review for "Groovy for Domain-Specific Langua

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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.


Link to Original Source

Book Review for "Plone 3 Products Development Cook

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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"

Book Review for "Plone 3 Products Development Cook

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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"

Book Review for "CodeIgniter 1.7 Professional Deve

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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"

Link to Original Source

Book Review - "OpenX Ad Server: Beginner's Guide"

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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."

Link to Original Source

Book Review - "Funambol Mobile Open Source"

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) writes "Book Review for "Funambol Mobile Open Source" by Packt Publishing

Funambol is an open source data synchronisation application designed to keep email, contacts, calendars, and more synchronised across mobile devices. This book promises to introduce the reader to Funambol and to guide the reader through product installation and configuration. Prior to reading this book, I had no experience with Funambol or any other mobile data synchronisation application, so I'll be giving you a newbies perspective on the book.

The book cover says it will guide the reader from application installation through complete configuration. I found the cover truthful-- this book serves as an excellent expert-level user guide. I was a complete newbie, yet found no trouble installing the product or configuring various components as I worked my way through the book. The first part of the book (8 chapters out of 10) covered application configuration issues: installation, data synchronisation (high-level), high-level architecture, user management, configuring e-mail, managing PIM data (calendars, contact lists), desktop and client synchronisation, and the Funambol community. All these I found to be well written, with an easy to read style. There were plenty of screenshots covering relevant topics to guide the reader, supplemented with clear and accurate text.

The second part of the book (2 chapters of 10) covered technical material at a greater depth. These included SyncML, which is the protocol used by server and devices, and how to extend Funambol. I'm a compulsive developer, so I found these last two chapters to be very interesting. The author even went into detail about which build frameworks are recommended (Maven) and which artifacts to write and how to check them out. I found this impressive, as not many open source books help the reader this much.

So who is this book for? I'd say anyone who has mobile devices they want to keep in sync. Funambol is open source, so it's cheap to get started, and this book is thorough enough to guide you from step one. I think the book is put together well enough that no previous experience is necessary-- anyone with basic system admin skills (applicaiton installation, running a few scripts) can install and configure Funambol.

As I worked my way through the book, one small regret I had was a lack of environmentals. At times, you might wish you had more equipment at your disposal. To really see everything work, you'd need several different kinds of mobile devices (Blackberry, Outlook client, Java phone, etc.) if you're setting up Funambol to share with others. If you're a home user, you may find you wished your computer had a public IP address (necessary if you want to synchronise the phones). You can synchronize a local email client without one if you want, but phones may require a public IP. I suppose most users in the market for a product like Funambol will have these things at their disposal, so this is probably not a big issue.

All things considered, I found this book easy to read and very accurate in it's content. It lives up to it's promises and is a great resource to anyone who wants to use Funambol.

If you're still not quite sure if Funambol is for you, I'd suggest you might search YouTube. You'll find a series of videos that will cover a multitude of topics.

The book's main site is here: [spam URL stripped]
A sample chapter can be found here: [spam URL stripped]."

Link to Original Source

Book Review: JBoss AS 5 Development

RickJWagner RickJWagner writes  |  more than 4 years ago

RickJWagner (1297357) 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""

Link to Original Source


RickJWagner has no journal entries.

Slashdot Login

Need an Account?

Forgot your password?