The Dining Philosopher

2011-01-19T07:17:00.000-08:00

Review of: DSLs in Action

Author: Debasish Ghosh
Publisher: Manning Publications
ISBN-10: 1935182455
ISBN-13: 978-1935182450

$44.99 (Manning publishing) 375 pgs.

Overview
Once you implement a domain model in your favorite programming language, it no longer speaks the dialect that the domain expert can understand. If your implementation doesn't conform exactly to the specifications you agreed on with the domain user there's no way it can be verified by the person who understands the domain rules.

DSLs in Action addresses this by suggesting a DSL-driven application development model. Design your domain APIs around the syntax and semantics that the domain user understands. Then, even during the development of the code base, the user can do incremental verifications of the domain rule implementations. If your code speaks the language of the domain, it becomes clearer to the person who develops it, to the one who maintains it, and to a nonprogrammer domain expert who understands the business.

You will learn how to design and implement DSLs using the modern languages Ruby, Groovy, Scala, Clojure and Java. In addition, discussions of the strengths and weaknesses of these languages when designing a DSL are included.

Admittedly, not everyone will be familiar with all the programming languages used to implement the DSL structures in this book so the author has included short reference cards (or cheat sheets) for the languages in the appendixes. More thorough references are provided to complete texts to supplement them. The source code for all examples in this book is available from Manning's website, http://www.manning.com/DSLsinAction.

The author, Debasish Ghosh (@debasishg on Twitter), is the chief technology evangelist at Anshinsoft (http://www.anshinsoft.com). He's a senior member of the ACM and his blog is at Ruminations of a Programmer (http://debasishg.blogspot.com).

Summary of Contents
Part 1: Using DSLs
Chapter 1: Learning to Speak the Language of the Domain
What a DSL actually is and the benefits it can provide start this chapter. The structure of a DSL is covered. The chapter concludes by tying in appendix A and discussing what makes a well-designed abstraction.

Chapter 2: The DSL in the Wild
Here you create your first DSL using Java. Groovy is introduced to demonstrate how to make the DSL more Expressive. DSL implementation patterns are introduced and how to choose a DSL type is presented.

Chapter 3: DSL-driven Application Development
Integrating internal and external DSLs in an application is the main topic of this chapter. Once this topic is completed, error and exception management is discussed and performance optimization is covered.

Part 2: Implementing DSLs
Chapter 4: Internal DSL Implementation Patterns
The author demonstrates how to build a programmer's toolbox of architectural patterns that can be used to implement DSLs. The use of metaprogramming to aid in the construction is extensively covered.

Chapter 5: Internal DSL Design in Ruby, Groovy and Clojure
The running application typical of Manning books, in this case a stock trading processor, is introduced here. The initial implementation is in Ruby and then it is improved with Groovy. Clojure is introduced to demonstrate how one must think a little differently with this language. A discussion of the pitfalls of each of these languages concluded the chapter,

Chapter 6: Internal DSL Design in Scala
This chapter is dedicated to Scala to which the author gives a good introduction. Developing an internal DSL with Scala is then covered. A discussion of monadic structures rounds out the chapter.

Chapter 7: External DSL Implementation Artifacts
This chapter is dedicated to the tools used to generate an external DSL. Parsers are discussed along with ANTLR, the Eclipse Modeling Framework and Xtext.

Chapter 8: Designing External DSLs using Scala Parser Combinators
Beginning with a discussion of exactly what parser combinators are this chapter continues with the Scala parser combinator library. A discussion of packrat parsers follows and then a dive into Scala DSL design with the combinators finishes up.

Part 3: Future trends in DSL development
Chapter 9: DSL Design: Looking Forward
The main thrust of this chapter is to touch base on developing trends in the DSL world. DSL workbenches are canvassed. The important topic of DSL versioning and practices that you can adopt to ensure a smooth evolution of your DSL's syntax rounds out the book.

Opinion
Not for beginners. At first this book comes at you so fast that it can seem overwhelming but hold on it does get better. Although this reviewer would not call this a 'Magnum Opus' it is as close as you get without being one. It becomes immediately clear that the author knows what he is doing and does this sort of thing everyday.

Ruby, Groovy, Clojure and Scala along with Java are used in the examples and this reviewer and the author are willing to bet that the reader is fluent in at least one of those languages. The good thing here, as the author says, is all of the code is understandable regardless of whether you have experience with one of them or not. It should also convince readers to do what they've said they were going to do for the last three years and learn a new programming language. One excellent side effect of so many languages in such a small space is that you will learn how each of them makes you think about and approach a problem differently.

The book contains excellent discussions of domain cognizance with topics such as accidental complexity and minimalism in coding followed with a great review/introduction of the differences, strengths and weaknesses of Internal DSLs versus External DSLs. There is even a chapter dedicated to designing external DSLs via Scala parser combinators.

It is an exhaustively wide and deep coverage of the subject. By the time you've finished reading the book, you'll have a thorough understanding of the concepts that you need to master in order to design domain abstractions that your users can understand and appreciate. This will bring much added business value to any project.

Five languages with no trivial examples all in one book, highly recommended.

Swiz 1.0.0, finally!

2010-12-15T06:22:00.000-08:00

For you Flex and ActionScript developers out there, Swiz 1.0.0 has finally hit the street! This is by far the easiest Flex related framework to use with the least amount of code necessary to make it work. I've been using it since version 0.6.4 and have been impressed with the many additions that have been added during the long road here. I can remember the (sometimes heated) discussions about it not being a legitimate framework because it was a version less than 1.0. Well, it's legitimate now!
Everything you need, and more, has been provided for you. The release notes, source code in git, ASDocs and a zip of the SWC, docs and source is available.

Should you find yourself needing help, there is also a very active mailing list where you can get answers to any problems very quickly. For a while it seems I lived on that board.

Congratulations to the Swiz team. Here we go!!

2010-10-28T11:58:00.000-07:00

Review of: Flex On Java

Authors: Bernerd Allmon and Jeremy Anderson
Publisher: Manning Publications
ISBN-10: 1-933988-79-7
ISBN-13: 978-1-933988-79-5

$39.99 (Manning publishing) 266 pgs.

Reviewer: John S. Griffin

Overview
Adobe Flex has become a prolific toolkit for building RIAs. A primary advantage of Flex for RIA development is that it integrates easily with any back-end technology. By providing native XML, SOAP, and Data Remoting capabilities, Flex enables developers to build rich new UIs on top of existing services. For Java developers this combination is especially compelling because many Java systems have already embraced service-oriented architectures with SOAP Web Services, Spring, or one of numerous other technologies.

The book starts off by introducing the two technologies and building a sample Java application you can play with. After that you continue by building a Flex client for the Java application that ties into some Java web services. Part 1, introductory information, covers the first four chapters.

Part 2, chapters 5 and 6, introduces topics that allow Flex to connect to Java through object remoting, logging, and messaging. In chapters 5 and 6 a deeper dive is taken into backend integration with Java on the server side. Using the Spring Framework for Flex integration is demonstrated.

Part 3, chapters 7-11, covers a hodgepodge of topics, such as security and personalization, building graphs, desktop development with AIR, unit testing, and building a Flex and Grails application.

Maven is the build tool of choice for this book and its configuration is delved into as needed for the examples.

Summary of Contents
Part 1: Getting started
Chapter 1: Some Flex with your Java?
The book begins with a brief history of Java and Flex and continues with a rapid tour of Flex including how to start building a Flex application.

Chapter 2: Beginning with Java
This is a book about Java integration, but a simple Java web application is built. Frameworks were chosen that should ease the Java learning curve necessary to get a sample application up and running fast.

Chapter 3: Getting rich with Flex
A disconnected naked UI Flex client can take advantage of mock data and allow developers to easily prototype a UI without the complexity of external dependencies. This approach is demonstrated in chapter 3 where the beginnings of a rich UI for the FlexBugs sample application are created. This is the running application common to all Manning Publishing books.

Chapter 4: Connecting to web services
This chapter demonstrates connecting to the Java server side and how to leverage the Flex API for connecting to web services. Rather than use the typical approach of current literature, including the Flex online documentation, clean interfaces and views are created and a Flex client that will scale on demand is created.

Part 2: Strengthening the backend
Chapter 5: BlazeDS remoting and logging
This chapter demonstrates further how to connect a Flex client more directly to the server side using the open source BlazeDS framework. BlazeDS provides a mechanism for allowing Flex to call methods on Java objects through binary serialization with the Action Message Format or AMF. This chapter also covers BlazeDS logging in detail.

Chapter 6: Flex messaging
Here is a demonstration of how to develop Flex applications that take advantage of simple polling. We have to wait until chapter 11 for the discussion on how to connect using Java Message Service (JMS).

Part 3: Going above and beyond
Chapter 7: Securing and personalizing your application
This chapter demonstrates building authentication, authorization, and personalization with Spring Security (Acegi) integration.

Chapter 8: Charting with Degrafa
Degrafa is a declarative graphics framework that provides a suite of graphics classes. Degrafa is open source and can be used to build robust charts, tools, and other graph- ical elements with less effort and complexity than other frameworks. How to accomplish that is this chapter's topic.

Chapter 9: Desktop 2.0 with AIR
Comprehensive coverage of all aspects of converting a Flex application to an Air application including how to set up deployment is the topic of this chapter.

Chapter 10: Testing your Flex application
Every good programming book includes a discussion of unit testing. Some discuss Test Driven Design (TDD). This chapter discusses both of these topics.

Chapter 11: Flex on Grails
This chapter assumes that you are at least somewhat familiar with both Groovy and Grails, but if you have never seen or done any development using either, you should still be able to follow along. Idiomatic Groovy code is shown but not much detail about what the code does is given as that is apparently beyond the scope of this chapter. A simplified contact management application called Flex Contacts is built. Included are the details of exposing a Grails service to Flex and integrating Flex with JMS.

Opinion
To begin with, readers of this book should be familiar with software development in general, specifically Flex and Java. Although the book was written to teach integration techniques for Flex and Java, not language fundamentals, it was done in a manner making it easy for even Flex or Java beginners to get rolling quickly with both.

This book is absolutely loaded with example code and every (that's right, every) configuration file change is delved into step-by-step.

Chapter 5 is the bomb! To paraphrase a fellow reviewer, this chapter alone is easily worth the price of the book! The simplifications presented here utilizing Spring will easily save both Java and Flex developers a ton of time in development. The how to of Java/Flex messaging implementation leaves chapter 6 not far behind.

More and more of the upper class of technical books are dedicating at least some time to discussion of application testing. Flex on Java takes this a little further with coverage of Test Driven Development (TDD). It contains a very welcome and much needed canvas of continuous integration with Hudson.

When this reviewer first examined this book, Chapter 11 seemed to be kind of a redheaded stepchild chapter until the realization that co-author Jeremy Anderson is quite involved in the Groovy scene. This chapter's strengths are two-fold. It demos Rapid Prototype Development (RPD) by taking leave of the running application and presenting a new pared down application. Secondly, it shows the implementation of JMS and ActiveMQ but since this is done in a Groovy environment it is of questionable value to Java/Flex developers. Groovy developers should appreciate it, however.

If you are a Java and/or a Flex developer that must interface between one and the other of these technologies then this book's plentiful examples and timesaving techniques are for you. You can't go wrong.

2010-10-04T13:20:00.000-07:00

Here's another review. This one is of Manning Publication's Flex 4 in Action.

Review of: Flex 4 in Action

Author: Tariq Ahmed et al

Publisher: Manning Publications
ISBN-10: 1935182420
ISBN-13: 978-1935182429
Available: 28 Oct 2010

$33.74 (amazon.com) 600 pgs.

Overview
Flex 4 in Action is a rewrite and update of the original Flex 3 in Action published in February of 2009. The book retains its overall topic flow so it will feel like an old warm blanket for those that learned Flex 3 from the previous edition or used it as a reference. New readers will feel just as welcome as it is an easy-to-read, thorough tutorial of what you need to know to come up to speed with the new Flex 4. There are also a couple of additions to the book that take it a step above the others.
The authors are acknowledged experts in their respective fields and have converted organizations to utilizing Flex for enterprise class applications.

Summary of Contents
Part One: Application Basics
Chapter One: Making the case
The book starts by talking about challenges that a web developer faces and how to solve them using Flex by Adobe. It also dives into the mechanics of a Flex application and discusses the Flex ecosystem as a whole.

Chapter Two: Getting Started
The authors show you how to take advantage of open source tools. They spend a good part of this chapter discussing Flash Builder and how to begin producing Flex applications.

Chapter Three: Working with ActionScript
Chapter 2 introduced ActionScript and this chapter is dedicated to it. The authors admit that entire books could be and are written about it. This chapter focuses on ActionScript?s core concepts of variable types, operators, loops, conditions, arrays and functions.

Chapter Four: Layout and Containers
In this chapter Flex?s visual building blocks and types of containers are discussed. These components can be anything from buttons, tables and graphics to other containers.

Chapter Five: Displaying forms and capturing user input
Creating forms in Flex is the topic here using input components (controls) and capturing user input.

Chapter Six: Validating user input
In this chapter how Flex handles validation and the different types of validators?such as those which verify the proper formatting of phone numbers and the structure of email addresses is covered. They are put to use, employing several different approaches.

Chapter Seven: Formatting Data
Formatting raw data with Flex?s built-in formatters is the subject of this chapter. This includes types of formatters, real-time formatting, scripted formatting and finally dealing with formatting errors.

Chapter Eight: MX DataGrids, lists, and trees
The authors cover everything you ever wanted to know about using list-based components from the MX library. Topics include list-based components displaying flat data, displaying hierarchical data, handling user interactions and retrieving selected items from List-based components.

Chapter Nine: Using the Spark List controls
In this chapter, you learn about the list-based features and functionality that ship with the Spark library, which is new to Flex 4. The discussion starts with the Spark list-based component architecture, and continues with how to leverage the new list-based Spark functionality in your Flex 4 applications.

Chapter Ten: List customization
This builds on chapter 9 by demonstrating how to customize the list-based components. Topics covered include the labelField property, label functions, overriding itemToLabel, item renderers and editors, advanced item renderers and filter functions.

Part Two: Application flow and structure
Chapter Eleven: Events
The event system is introduced along with its all-important role in a Flex application. Integrating native and custom events in an application while gaining an understanding of event nuances is also covered.

Chapter Twelve: Application Navigation
This chapter looks at the following components that you?ll use to add standard navigational features to your application: Menu, MenuBar, ViewStack, ButtonBar, TabNavigator and Accordion.

Chapter Thirteen: Introduction to pop-ups
The different ways of creating and managing pop-ups as well as simple ways to style them are here along with how to utilize the pop-up manager to help you create, delete, position, close, and destroy windows.

Chapter Fourteen: Implementing View States
This chapter starts by introducing the concept of view states in general. It then continues by covering everything you need to know about them.

Chapter Fifteen: Working with data services
This comprehensive chapter is all about data-centric development with Flash Builder. Starting with connecting to web services it continues with using the HTTPService and WebService components and understanding the Action Message Format (AMF). Communication with JavaEE using BlazeDS, ColdFusion Communication and communicating with PHP via Zend_AMF rounds out the discussion.

Chapter Sixteen: Objects and classes
Exploration of a fundamental feature of Flex, objects and classes, is the core of this chapter along with some OO theory. Covered topics include OO concepts, implementing OO concepts, using ActionScript classes, how to create, invoke and destroy them, and extend those that already exist.

Chapter Seventeen: Custom components
This chapter covers the basics of creating and utilizing custom components and tackles ways of getting your components to communicate with each other. Starting off by taking a look at how components are handled in Flex 4 and the Spark architecture, the discussion continues on with types of components and the difference between simple and composite objects.

Chapter Eighteen: Creating Reusable Components
Code reuse is the topic of this chapter. The example used in this chapter takes a look at a scenario where a component that reveals content must be created, but in many different ways, yet without having to write a separate component for each implementation.

Chapter Nineteen: Architectural Design Patterns
A deep look into Flex-driven design patterns and the thought process behind the core Flex architecture is taken. Then, rolling your own Flex application architecture is discussed without getting over-complicated. This chapter covers the Model-View-Controller pattern, how to roll your own architecture and mentions the frameworks Mate, Cairngorm, Parsley, and Swiz along with a deeper discourse into the Robotlegs framework.

Part Three: The Finishing Touches
Chapter Twenty: Customizing the Experience
This chapter focuses on the user experience and how you can leverage user experience design techniques in Flex to enhance your applications. The VIBE Model, themes and skins, CSS in Flex 4 and best practices are discussed.

Chapter Twenty-One: Working with Effects
This chapter first explains what effects are and how to use them and then the types of out-of-the-box effects are discussed.

Chapter Twenty-Two: Drag-and-Drop
D&D is considered from a usability point of view rather than just because you can use it or because of the coolness factor. The authors discuss how a mindset change is needed to accomplish this.

Chapter Twenty-Three: Exploring Flex-Charting Chapter
In this chapter, exploration of what makes up a chart, the charts that come with Flex, and how to customize them is covered.

Twenty-Four: Debugging and Testing
Debugging applications using the Flex debugger, using the Flash Builder Profiler and Unit and Functional testing of your applications is discussed.

Chapter Twenty-Five: Wrapping up a project
Tying up loose ends and getting the project out the door by customizing the HTML wrapper and deploying it to a production server is this chapter?s topic.

Chapter Twenty-Six: Working with XML
In this final chapter, Flex's robust XML support, from its ability to use XML as a source of data, to how you can use Flex to directly manipulate XML code is presented.

Opinion
This new edition contains a thorough coverage of the new Spark components of Flex 4. It contains all you need to know to write applications with the new API.

The authors know from experience what you, as a developer, need to succeed and they make an admirable attempt at conveying it. This is nowhere more prevalent than their discussion in chapter 22 where they attempt to make you understand that just because something is 'cool' is not the reason to implement it in an application. When a feature will get the job done is the time to put it to use. You just need to change the way you look at things.

The book features two new chapters one of which was sorely missing from the previous edition. Chapter 19, Architectural Design Patterns, is a long overdue and very welcome addition. This chapter is a critically needed discussion of software architecture and assistive frameworks for Flex. Most books get atrociously overcomplicated, stay solely with theory and fail to bring those concepts to reality. They need to actually go through the process of designing architectures for actual enterprise applications. This chapter gives you the basics of how to go about it. This reviewer believes that a little two much time is spent with RobotLegs in this chapter at the expense of the others mentioned (one of the authors, Joel Hooks, plays a large part in the development and support of RobotLegs so that explains that). There aren?t even simple examples of the other second-generation frameworks Mate (pronounced ma-tay) and, this reviewer?s personal favorite, Swiz.

Chapter 9, Using the Spark List Controls, is the other new addition. This includes a thorough discussion of the Spark List Controls' class hierarchy and customization.

In chapter 24, Debugging, the authors could have spent a little more time on the Network Monitor and Profiler that comes with Flash Builder. There is a little more discussion of the Profiler but both of these topics are cursory at best. Also, this chapter provides sample code for unit testing Flex with the FlexUnit library. This is an absolutely essential addition.

Taken as a whole this new edition gives you good thorough coverage of the new Flex 4 and provides some sweet additions at the same time.

Those of you reading this who decided to pass on buying one of the other Flex 4 books before Flex 4 in Action made its appearance on shelves will be well served. It was worth the wait.

2010-09-28T06:08:00.000-07:00

Well, after a year layoff I'm back in the saddle again. I've been doing a lot of reading lately so I thought I'd make my comeback with a review of Manning Publication's iText in Action.

Review of: iText in Action 2nd edition

Author: Bruno Lowagie
Publisher: Manning Publications
ISBN-10: 1935182617
ISBN-13: 9781935182610

$37.79 (amazon.com) 700 pgs.
Reviewer: John S. Griffin

Overview
iText makes it possible to enhance applications with dynamic PDF solutions. It is one of the world's leading F/OSS (Free/Open Source Software) PDF libraries and is released under the Affero General Public License (AGPL). iText is available in two versions: the original Java version, and the C# port, iTextSharp. The iText web site is located at http://itextpdf.com/.

Both editions were written by the man who created the API. In the first edition of "iText in Action", readers learned why things work the way they do in iText, complemented with simple examples. This second edition takes readers further with more real-life examples and presenting comprehensive code samples that you can use to solve everyday problems.

The book utilizes a movie database, created for a (fictional) film festival as the running application for the examples as is usual for any Manning book. It is accessed from a series of simple programs and PDF files are created and manipulated in different ways that could be useful for the visitors of the imaginary film festival.

Summary of Contents
Part 1: Creating PDF documents from scratch
This section demonstrates how to create a document from scratch. Concepts such as iText's basic building blocks and direct content are introduced. Adding columns and tables to a document are discussed in great detail. Part one concludes by explaining how to add the finishing touch to your document using page events for headers, footers, page numbers and watermarks.

Chapter 1: Introduction
Creating a series of PDF documents from scratch begins the book. SQL statements are used to query a movie database, loop over the ResultSet, and add the data from each record to a PDF document using high-level objects such as Chunks, Phrases, Paragraphs, and so on. The creation of PDF documents without having to know anything about the PDF specification is the goal here.

Chapter 2: Composing a document using iText's Basic Building Blocks
Lines, shapes, and text are demonstrated to create a time table visualizing movie screenings, using a different color for every film festival category. To achieve this, low-level operations that demand a sound understanding of how PDFs work are utilized.

Chapter 3: Adding content at absolute positions
This chapter covers the basics of adding content to a page using methods that are referred to as low-level operations because they write PDF syntax directly to the content stream of the page. The ColumnText object is covered and reusing content with the PdfTemplate object is also discussed.

Chapter 4: Organizing content in tables
In one of the most important chapters of the first part, documents containing tabular data are created from the database. Almost everything there is to know about the PdfPTable and PdfPCell objects is presented.

Chapter 5: Completing your layout using table, cell, and page events
Knowledge about tables and cells will be completed by learning how to add custom behavior to a table and its cells using events. Also page events are discussed. The finishing touch to documents in the form of headers, footers, page numbers and a watermark is presented.

Part 2: Manipulating existing PDF documents
Part two deals with existing PDF files; be it documents created with iText as discussed in part one, or PDFs created with Adobe Acrobat, Open Office, or any other PDF producer. Different ways to copy, stamp, split and merge documents re examined. Actions and JavaScript are discussed along with everything on the subject of filling out interactive forms.

Chapter 6: Working with existing PDFs
PdfReader is used to access an existing PDF file, and one or more of these document manipulation classes is chosen for further changes depending on particular circumstances:

PdfWriter in combination with PdfImportedPage objects - taking "photocopies" of specific pages
PdfStamper - adding content to one existing PDF document
PdfCopy, PdfSmartCopy, or PdfCopyFields - combining a selection of pages from different, existing documents into a new PDF document

Chapter 7: Making documents interactive
A closer look at the PdfStamper class is taken. It is used to annotate a single document.

Chapter 8: Filling out interactive forms
A special type of annotation in PDFs are interactive form fields. They are used in forms by implementing AcroForm technology. Another type of PDF form is based on the XML Forms Architecture (XFA). Both types of interactive forms are discussed in chapter 8.

Part 3: Essential iText Skills
Parts one and two showed how to build a standalone application that is able to create and/or manipulate a PDF document in black and white, using standard fonts, and so on. Part three tells you how to integrate it into a web application, how to create images and colors, how to choose and use different fonts, and finally how to protect your document.

Chapter 9: Integrate iText in your web applications
For the sake of simplicity, most of the examples in this book are standalone applications, but a majority of projects use iText as a PDF engine in server-side web applications. You'll certainly benefit from chapter 9 if you want to avoid the pitfalls you might encounter while integrating your iText application into a Java Servlet.
Once your proof of concept is online, you'll probably be confronted with many extra user requirements some of which are covered in the next three chapters.

Chapter 10: Brighten up your PDF with color and images
There are eleven different color spaces available in PDF. Color spaces are expressed as PDF dictionaries. A reference to these dictionaries can be found in the resources entry of a PDF stream. This is explained in great detail in the PDF reference. How iText hides this complex theory by providing color classes is discussed.

Chapter 11: Choose the right font
How does one choose a particular font? Which font files can be used with iText? How about special writing systems? In some languages, you have to write from right to left, and from top to bottom. This chapter demonstrates that iText contains convenience classes that make it easier to select a font.

Chapter 12: Protect your PDF
Several important topics are presented in this chapter:

Providing metadata - information about the owner of this data and how to add and access it
Compressing and decompressing PDFs - the content of a document is compressed by default. iText can decompress content streams to read the PDF syntax that makes up a page or a form XObject.
Encrypting documents - PDF protection via passwords and encryption
Adding digital signatures - public and private keys

Part 4: Under the hood
An overview of the history of PDF is presented in chapter 13. It takes a look at the inner workings of a PDF document. It explains the different parts of a PDF file: the header, the body, the cross-reference table, and the trailer. Since the body of a PDF file consists of a series of objects, an examination of the different types of objects in the Carousel Object System is presented. The three final chapters focus on stream objects.

Chapter 13: PDF files inside-out
One of Adobe's important goals, was that every new version of the PDF specification had to be backward compatible. This was possible thanks to the well designed architecture of a PDF file, a.k.a. the Carousel Object System. By studying the different objects that make up a PDF document, you'll learn how iText creates a PDF file.

Chapter 14: The imaging model
The streams holding the content of a page in a PDF document is the focus of this chapter. All the methods to draw lines and shapes (graphics state), and to write letters and words (text state) are listed.

Chapter 15: Page content and structure
Making content optional is discussed, and also structure in the content stream of a page is introduced. A fair attempt to parse content streams of existing PDF pages is made and a closer look is taken at the other streams that can be found in a PDF document: images, fonts, file attachments, and rich media.

Chapter 16: PDF streams
In this final chapter, streams that contain images, fonts, file attachments, and rich media are covered.

Opinion
This book is a rewrite of the first edition. When this reviewer first started the book and read what the author had done with it compared to the first edition he was a little worried that interested readers might have to buy both books in order to completely understand the iText library and API. After reading deeper into it you can rest assured that this is not the case. iText beginners will have no problem understanding the API.

The chapters concerning basic building blocks (to get you started), fonts, tables, colors, web applications and all the others are still there and with better examples and explanations. Speaking of examples, there are a hugh number of them in this book which is an improvement over the first edition. Many of them can be used right out of the book to solve problems that the author is sure you will run into. They have also been updated from Java4 to Java5.

New topics include PDF security which covers public/private keys, encryption, compression, passwords and the like, manipulating existing PDFs (what you can and cannot do) and a deep dive into the imaging model and the actual inner workings of the page among other topics.

In this reviewer's previous work experience there were many copies of the first edition on the desks of report developers. This is one of the most important niches for iText. Yes, there are more pieces of PDF generation software out there today than you can count but their problem is that they are very difficult to automate for on demand, detailed, ad hoc reports. That is a very large workspace for iText. This reviewer expects to see many more copies of the new edition out there than there were original ones.

All in all, the book is well written and the examples are vastly improved over the first book. If you are creating a system for generating ad hoc reports, programmatically generating PDFs on the fly for web or other applications, modifying existing PDFs without their original documentation or doing just about anything else with PDFs, this is the book you need. Highly recommended.

It won't be another year before I write again. I'm going to put another review here soon on a book I'm extremely impressed with, Manning's DSLs in Action.

Update on my Speaking Engagement

2009-09-15T07:49:00.000-07:00

The Utah Open Source Conference
Things have settled down now and I'll be speaking on Friday the 9th at 6:15 PM on Lucene. Right after that I'm holding a BOF on how Hibernate Search solves Lucene's scalability problems along with several other shortcomings. Hope to see you there.

2009-09-04T07:52:00.001-07:00

Hey, I was just notified that my proposal to speak on Apache Lucene at the Utah Open Source Conference was accepted. The conference is October 8 - 10. I will also give a short discussion on Hibernate Search as it applies to the Lucene engine and how it fixes some of Lucene's shortcomings.
If you get a chance attend the conference. The admission change is minimal and if you volunteer to help it's free admission!!
Hope to see you there.

2009-07-11T14:45:00.000-07:00

Viral Patel gave a short discussion on his blog entitled Convert ArrayList to Arrays in Java. This is a good thing to know how to do but he did not cover the reverse operation, converting arrays to lists. It holds a few surprises for you. So here is a short snippet that demonstrates this opposite operation.


import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class ArraysAsList {
public statis void main(String[] args) {
 new ArraysAsList().start();
}

private void start() {
 String[] countries = {"India", "Switzerland", "Italy", "France"};
 List list = Arrays.asList(countries);
 list.add("India");
}
}

If we run this small program we get.....
WHAT!!!! an exception?!?!?!What going on here? All we wanted to do was add an element to the generated array. Here's the exception:


java.lang.UnsupportedOperationException at java.util.AbstractList.add(AbstractList.java:131)

Whaddaya mean unsupported operation? Let's look at the javadoc and see what it says:

"Returns a fixed-size list backed by the specified array."
Aha! there's the problem. That means that I can't remove anything either. Try it.
Don't forget this in your coding, it can bite you. Not a big deal but just what you need to deal with when you're under the pressure of a deadline.

Thanks to Damien for reminding me to show you the correct way to do this:

List list = Arrays.asList(countries);

should be:

List list = new ArrayList(Arrays.asList(countries));

This fixes the problem. Now you can add, delete, whatever.

Get more kids into Computing, Alice.

2009-07-04T11:39:00.000-07:00

Ok, I digress from technical topics again. This time though I think it's an important digression. Let's get more kids interested in computing!!
As of 2004 only 4.1% of all Bachelors degrees awarded were in Computer Science (that's the latest data the CRA had). In 2008, only 11.8 percent of U.S. bachelor's degrees in computer science went to women. This is another sore point but I'll make that a topic for another blog post someday. The point is we need to get more kids interested in computing!!
Many kids think that computing isn't fun (some programmers think the same thing) so we need to make it fun. Thus enters Alice. With support from the National Science Foundation, professor Susan Rodger of Duke University is hoping that Alice will get kids interested in computer science.
A ScienceDaily site gives an overview of the problem and discusses Alice at a high level. Basically, Alice is a 3D programming environment that makes creating animation for story telling easy. It is designed to be a first exposure to object-oriented programming and is available for Windows and Mac. According to the site, kids that have been introduced to Alice have a hard time stopping once they get started.
Yes, I know, maybe you consider this a rant and not a blog post but as I said earlier this is important if we are going to maintain a technological edge in computing. I can't believe I'm saying this but I'm thinking of trying to start a computing summer camp for younger children. I just have to fine the financial backing
(I don't believe I just said that?!?!) How about some other ideas?

ARE YOU KIDDING ME?!?!?!

2009-06-07T20:47:00.000-07:00

Alright alright, I apologize in advance about this digression from my technical postings but this was just toooo good to be true.

Ok Mabel, it's not an urban legend anymore!! I done seen it with my own eyes.

JavaOne 2009
Session - Cloud Computing, Show Me The Money.

Amazon, Google, Intuit, Microsoft and some other unlucky SOB are giving their cloud computing demo for the session. Each speaker was alloted 5 minutes max to demo their app and I have to admit some of these were really cool.
The first one was the capturing of San Francisco traffic maps, analyzing the data obtained from these and putting it into the cloud for everyone to use. Cool if you live in San Francisco but useless in New York.
The next demo consisted of a very simple 'hello world' servlet app written, compiled and uploaded to the cloud right in front of us. Quite easy and cool. Could we have had a litle more than 5 minutes please!!
Intuit was next with a similar easily deployable application. Sorry, but for the life of me I can't remember what the app did (that was impressive).
-----------------------------
Then it was Microsoft's turn.

The presenter hyped Azure and how easy it made deployment to the cloud. He had a pre-built application to upload and (you probably by now have guessed it) CRAAAAAASSSSSHHHH!!! The session attendees around me just started laughing (hence the title of this post) and since the URI was on the overhead several of them immediately went there (what?? are they masochists?) and captured a stack trace. Here it is and my apologies for unreadables but I OCRed this from an image:

HTTP Status 500 - Exception report description The.server encountered an internal error Q that prevented, it from fulfilling, this request. javax.servlet.ServletException: /index.jsp(45,16) '#{AzureResultBean.top5Results)' Error reading 'top5Results' on type com._____.javaone javax.faces.webapp.FacesServlet.service(FacesServlet.Java: root cause org.apache.jasper.el.JspELException: /index.jsp(45,16) '#{AzureResultBean.topSResults}' Error reading 1top5Results' on type com._____.je org.apache.jasper.el.JspValueExpression.getValue(JspValueExpression.Java:107) javax.faces.component.UIData.getValue(UIData.Java:582) javax.faces.component.UIData.getDataModel(UIData.Java:1063) javax.faces.component.UIData.setRowIndex(UIData.Java:417 J com.sun.faces.renderkit.html_basic.TableRenderer.encodeBegin(TableRenderer.Java:85) javax.faces.component.UIComponentBase.encodeBegin(UIComponentBase.Java:788) javax.faces.component.UIData.encodeBegin(UIData.Java:879) javax.faces.component.UlComponent.encodeAll(UlComponent.Java:884) javax.faces.render.Renderer.encodeChildren(Renderer.Java:137 J javax.faces.component.UIComponentBase.encodeChildren(UIComponentBase.Java:812) javax.faces.component.UlComponent.encodeAll(UlComponent.Java:886) javax.faces.component.UlComponent.encodeAll(UlComponent.Java:892) com.sun.faces.application.ViewHandlerlmpl.doRenderViewfViewHandlerlmpl.Java:245) com.sun.faces.application.ViewHandlerlmpl.renderView(ViewHandlerlmpl.Java:176) com.sun.faces.lifecycle.RenderResponsePhase.execute(RenderResponsePhase.Java:106) com.sun.faces.lifecycle.Lifecyclelmpl.phase(Lifecyclelmpl.Java:251) com.sun.faces.lifecycle.Lifecyclelmpl.render(Lifecyclelmpl.Java:144) javax.faces.webapp.FacesServlet.service(FacesServlet.Java:245) ... javax.xml.ws.WebServiceException: Java.net.SocketException: Connection reset com.sun.xml.ws.transport.http.client.HttpClientTransport.readResponseCodeAndMessagef HttpClientTransport.Java:210) com.sun.xml.ws.transport.http.client.HttpTransportPipe.process(HttpTransportPipe.Java:160) com.sun.xml.ws.transport.http.client.HttpTransportPipe.processRequest(HttpTransportPipe.Java:93) com.sun.xml.ws.api.pipe.Fiber. doRun(Fiber.Java:598) com.sun.xml.ws.api.pipe.Fiber._doRun(Fiber.Java:557) com.sun.xml.ws.api.pipe.Fiber.doRun(Fiber.Java:542) ...

I kinda felt sorry for the presenter when he clicked go... you could audibly hear him say 'pleeeease, don't do this to me!' Well, on second thought, maybe I didn't, he makes a lot more money than I do and, yes, sometimes my code doesn't work either but it does when it HAS to.

I hope the girl sitting next to me enjoys this post because she said she would definitely check it out. Sorry it took until Sunday but ya gotta admit it was worth the gloat... I mean wait (I really liked your EEEPC).

Next time back to the technical stuff (gloat, guffaw and I'll be damned, it's not just an urban legend).

JavaOne 2009 Best Sellers

2009-06-06T12:55:00.000-07:00

Just back from JavaOne 2009 and finally have the gumption to write about something. Here are the best sellers from the bookstore. Some surprises, some not, some wtfs. Would you expect anything less?

1. JavaFX: Building Rich Internet Applications - Addison Wesley ISBN: 013701287X
2. Essential JavaFX - PTR (out June 11, 2009) ISBN: 0137042795
3. Effective Java 2nd ed. - PTR ISBN: 0321356683
4. Java Puzzlers - Addison Wesley ISBN: 032133678X
5. Programming in Scala - Artima ISBN: 0981531601
6. Java Concurrency in Practice - Addison Wesley ISBN:0321349601
7. Beginning Java EE 6 Platform with Glassfish 3: From Novice to Professional - Apress ISBN: 1430219548
8. The Definitive Guide to Lift - Apress ISBN: 1430224215
9. Beginning Scala - Apress ISBN: 1430219890
10. OpenSolaris Bible - Wiley ISBN: 0470385480

At the end of the first day Programming in Scala was #1.
After Josh Bloch and Neal Gafter's Java Puzzlers session it moved to #1.
The JavaFX books moved to the top two positions towards the end of the show. Is Sun/Oracle too late with this language (shrug)? Only time will tell (and a short time at that).
The classics 'Effective Java' and 'Java Concurrency in Practice' were there as expected.
The ever growing Scala interest (including Lift) is very intriguing. Is it the next one? That's for the community to decide. Comeon people make a decision!!

I've got another post for tomorrow again from JavaOne. This is about Microsoft at JavaOne (what?!?!?!). It ain't no urban legend anymore Joyce!!

Free Chapters!

2008-12-10T05:51:00.000-08:00

Manning has made two chapters from the book available for free download (there isn't much available for free these days) from their MEAP program.
Chapter 2 entitled "Getting started with Hibernate Search" will give you an over-view of Hibernate Search: how to use it, how to express full-text queries, and how it fits into the Hibernate programmatic model.
Chapter 11 entitled "Accessing Lucene natively" starts with looking at Hibernate Search’s SearchFactory, which is the key entry point to Lucene. It also examines the effects that sharding presents, writing a custom DirectoryProvider and what you must take into account when you do.
We’ll also show you how to access the legacy Lucene document and several related values by utilizing a projection, and we’ll demonstrate how it affects performance.
Manning has also provided the book's source code for download from the same link.

Download them, sit back, do a little reading and see what you think.

Our Hibernate Search Refcard is out!

2008-12-01T06:40:00.000-08:00

has just released our Refcard on Hibernate Search. This is a 6 page "cheatsheet" for new and experienced users of this technology filled with summary information for quick lookup. We hope you enjoy it and its makes life a little easier for you.

It looks like we will just make the December launch of Hibernate Search in Action. We're hoping to be on the shelves during the last week of December. It will make a great 'IOU one Christmas present' for that someone you know. It would also be a fantastic birthday present. Buy it, you'll like it!

Hibernate Session and Transaction Utilizing ThreadLocal Variables

2008-10-13T07:57:00.000-07:00

At long last here is the post I promised that uses ThreadLocal variables to handle Hibernate sessions and transactions. The rather long helper class contains methods to obtain the current session (if one doesn't already exist it creates one), close the session, obtain a transaction, commit the transaction and rollback.
This is a good demonstration of the use of ThreadLocal variables and presents workable code that I hope you can use everyday. There is a lot more that can be added to this helper but that's a reader exercise.


public final class HibernateHelper
{
   private static final ThreadLocal threadSession = 
      new ThreadLocal();
   private static final ThreadLocal threadTransaction = 
      new ThreadLocal();
   private static SessionFactory mSessionFactory;

   static {
      mSessionFactory = ServiceLocator.getInstance().getSessionFactory();
   }

   public static Session getCurrentSession() {
      Session s = threadSession.get();
      try {
         if (s == null || !s.isOpen()) {
            if (mLogger.isInfoEnabled()) {
               mLogger.info("Opening new Session for this thread.");
            }
            s = mSessionFactory.openSession();
            threadSession.set(s);
         }
         else {
            if (mLogger.isInfoEnabled()) {
               mLogger.info("Using current session in this thread.");
            }
         }
      }
      catch (HibernateException ex) {
         throw ("unable to open hibernate session");
      }
      return s;
   }

   public static void closeSession() {
      try {
         final Session s = threadSession.get();
         if (s != null && s.isOpen()) {
            mLogger.info("Closing Session of this thread.");
            s.close();
         }
      }
      catch (HibernateException ex) {
         Throw.loggable(HBM_CLOSE_SESSION, ex, false);
      }
      finally {
         threadSession.set(null);
      }
   }

   public static void beginTransaction() {
      Transaction tx = threadTransaction.get();
      try {
         if (tx != null && !tx.isActive()) {
            tx = null;
            threadTransaction.set(null);
         }
         if (tx == null) {
            if (mLogger.isInfoEnabled()) {
               mLogger.info("Starting new database transaction in this thread.");
            }
            if (threadSession.get() != null && threadSession.get().isOpen()) {
               threadSession.get().close();
               threadSession.set(null);
            }
            tx = getCurrentSession().beginTransaction();
            threadTransaction.set(tx);
         }
         else {
            if (mLogger.isInfoEnabled()) {
               mLogger.info("Using current database transaction in this thread.");
               mLogger.info("Opening new Session for this thread.");
            }
         }
      }
      catch (HibernateException ex) {
         Throw.loggable(HBM_BEGIN_TRANSACTION, ex, false);
      }
      finally {
         if (threadSession.get() == null || !threadSession.get().isOpen()) {
            getCurrentSession();
         }
         else {
            threadSession.get().clear();
         }
      }
   }

   public static void commitTransaction() {
      final Transaction tx = threadTransaction.get();
      try {
         if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
         {
            Session s = getCurrentSession();
            s.flush();
            if (mLogger.isInfoEnabled()) {
               mLogger.info("Flushing session and committing transaction of this thread.");
            }
            tx.commit();
         }
      }
      catch (HibernateException ex) {
         rollbackTransaction();
         Throw.loggable(HBM_COMMIT_TRANSACTION, ex, false);
      }
      finally {
         threadTransaction.set(null);
         closeSession();
      }
   }

   public static void rollbackTransaction() {
      final Transaction tx = threadTransaction.get();
      try {
         if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
            mLogger.info("Trying to rollback database transaction of this thread.");
            tx.rollback();
         }
      }
      catch (HibernateException ex) {
         Throw.loggable(HBM_ROLLBACK_TRANSACTION, ex, false);
      }
      finally {
         threadTransaction.set(null);
         closeSession();
      }
   }
}

Next installment I want to continue our ThreadLocal variable discussion and problems you can run into when using them.

Help Me ThreadLocal Variables!

2008-07-21T08:59:00.000-07:00

I attended a local NoFluffJustStuff seminar last weekend and enjoyed every discussion I attended. Ted Neward was in excellent form as usual. There was one thing that bothered me though. There were quite a few attendees that did not know how to utilize ThreadLocal variables and some had never heard of them.
I'll discuss and demonstrate them here and in the next post I'll demo using hibernate Sessions with ThreadLocal variables. Hopefully, this will help out a lot of people.
ThreadLocal variables are instances of the java.lang.ThreadLocal<T> class. There are two methods (it has more) that we are concerned with get() and set(T value) which perform the normal accessor and mutator functionality. Here's the main point! These variables differ from the variables you are used to in that each thread that accesses a ThreadLocal variable via its get or set method has its own, independently initialized copy of the variable. That's where the class' name came from, the variable is local to the Thread that has it.
Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the ThreadLocal instance is accessible. When a Thread dies all of its ThreadLocal variables are garbage collected if there are no references to them.
This gives you what I call poor man's thread safety. Other threads won't bother it and it won't bother other threads. So how can I utilize these variables? It's actually quite simple. Here's the example I promised.

Class UserHelper {
  private static final ThreadLocal threadUser = new ThreadLocal();

   /** Retrieves the user name of this thread. */
   public static String getThreadUser() {
      return threadUser.get();
   }

   /** Stores the user name of this thread. */
   public static void setThreadUser(String username) {
      threadUser.set(username);
   }
}

This class stores the current user's name in a threadlocal variable attached to the current thread of execution and the Thread lugs it around wherever it goes. In any part of the application this user name can be accessed by simply calling the getThreadUser() method. Even though you may have two different threads executing the same part of an application, when the application calls the get method each thread returns it's own user's name. Simple huh?

Warning
Always remember that the ThreadLocal data is connected to the thread, not the user (in our example it has the user name but that's it) or anything else. A good idea is to delete the ThreadLocal data when it's no longer used.
MyThreadLocal.set(null);

We'll talk about the Hibernate ThreadLocal Session pattern in the next installment.

Entity Method Instances From hibernate.cfg.xml

2008-05-23T10:01:00.000-07:00

Wouldn't it be cool if you could obtain an instance of a particular annotated method from a Hibernate entity by simply examining the hibernate.cfg.xml file? It's not as difficult as you may think.
The key to the whole process is knowing how to read the configuration file and manipulate what it returns. Let's examine some code that does just that. We'll examine all the classes in our config file and retrieve information on each of the methods annotated with @Id. We'll put this information in a map with the map's keys being the classes themselves and the values being Hibernate IdMetaData objects.


Map idMap = new HashMap();
1  Configuration config = new AnnotationConfiguration().configure();

2  for (Iterator iter = config.getClassMappings(); iter.hasNext();)
{
3     RootClass root = ((RootClass)iter.next());

   try {
4       Class clazz = root.getMappedClass();

5        Method idGetter = root.getIdentifierProperty()
                                 .getGetter(clazz).getMethod();
6        Method idSetter = root.getIdentifierProperty()
                                 .getSetter(clazz).getMethod();
7        Class type = idGetter.getReturnType();
8        IdMetaData md = new IdMetaData();
9        md.setIdGetter(idGetter);
10       md.setIdSetter(idSetter);
11       md.setType(type);
12       idMap.put(clazz, md);
13       mLogger.info("mapping Id for " + clazz.getName());
 }
 catch (Exception e) {
     throw new Error("unable to initialize annotation map");
 }
}

Line 1 is the standard way to generate a Hibernate configuration instance. The Iterator of line 2 returns a Hibernate RootClass (line 3) for each of the defined classes in the config file. This class is the gateway to a lot of information.
root.getIdentifierProperty() in lines 5 and 6 returns a Hibernate Property object of the method marked with the @Id annotation. This allows access to the actual getter and setter methods. IdMetaData is a simple bean class that holds any information obtained from the RootClass object. Line 12 fills a HashMap with the class as the map key and the IdMetaData as the value. Once you know the trick you can programatically get at any information you wish to.

------------------

Developers read APIs, Engineers read the source code!

Whence the name?

2008-05-21T12:08:00.000-07:00

The dining philosophers problem is an illustrative example of a common computing problem in concurrency.
Five philosophers sit at a table doing one of two things - eating or thinking. While eating, they are not thinking, and while thinking, they are not eating. The five philosophers sit at a circular table with a large bowl of spaghetti in the center. A fork is placed in between each philosopher, and as such, each philosopher has one fork to his or her left and one fork to his or her right. As spaghetti is difficult to serve and eat with a single fork, it is assumed that a philosopher must eat with two forks. The philosopher can only use the fork on his or her immediate left or right.

The philosophers never speak to each other, which creates a dangerous possibility of deadlock when every philosopher holds a left fork and waits perpetually for a right fork (or vice versa).

Visit the DP Problem link on the right to see how it turns out.