Rick Wagner's Blog

Win the JBoss AS 7 Book!

2012-01-10T18:54:00.004-06:00

Now revised! No email necessary, we'll contact you after winners are selected!

Win Free Copies of JBoss AS 7 Configuration, Deployment and Administration book

Hello, Blog Readers! To celebrate the release of their new book- JBoss AS 7 Configuration, Deployment and Administration, Packt Publishing is organizing a Giveaway especially for you and three lucky winners stand a chance to win a copy of this book. Keep reading to find out how you can be one of the Lucky Winners.

Overview of JBoss AS 7 Configuration, Deployment and Administration book

* Covers all JBoss AS 7 administration topics in a concise, practical, and understandable manner, along with detailed explanations and lots of screenshots
* Uncover the advanced features of JBoss AS, including High Availability and clustering, integration with other frameworks, and creating complex AS domain configurations

Read more about this book and download free Sample Chapter: Sample Chapter

How to Enter?
All you need to do is head on over to the book page and look through the product description of this book and drop a line via the comments below over here to let us know what interests you the most about this book. It’s that simple

Product description for JBoss book: http://link.packtpub.com/caa3AV#in_detail

Winners from the U.S. and Europe can either choose a physical copy of the book or the eBook. Users from other locales are limited to the eBook only.

Deadline

The contest will close on January 31, 2012

If you'd like to include your email in the post, we'll use that to inform you if you win a copy. If you'd rather not leave an email, we'll try to contact you through your post identity or another blog post seeking you out.

Good luck!

Book Review for "Java EE 6 with GlassFish Application Server"

2011-12-26T20:25:00.003-06:00

I work with Enterprise Java a lot. I'm a support engineer working in the SOA workspace. This means I get regular exposure to web services, JMS, and other parts of the JEE stack. But here's the thing-- I almost always work with the same parts. For every part I usually work with (JMS, SOAP web services), there's at least one other part I don't work much with (JSF, RESTful web services, web-tier stuff.) So what's happened is I have become well versed in parts of the JEE stack, but have failed to keep up with the rest.

I chased the Enterprise Java rabbit all the way down the hole back in the J2EE 4 days. Quite a bit of what I learned then-- early EJBs, enterprise patterns, and so on-- is now thankfully useless. I knew there were lots of programming productivity-enhancers put in since JEE 6, but I just didn't want to take the time to read the internet again to once again become whole-stack proficient. So I picked up a copy of "Java EE 6 with GlassFish 3 Application Server" by David Heffelfinger.

I'd read David's work before, so I was expecting an easy to read book that contained plenty of minimal examples I could run and experiment with. I wasn't disappointed, this was exactly what I found.

The book divides the JEE stack into slices and explains each in turn. Each chapter contains several Maven-driven examples that can be easily compiled and quickly deployed. In this regard, the book does exceptionally well.

The first chapter is really basic-- downloading the tools you need, and a quick overview of GlassFish.

The second chapter covers Servlets. There are several basic examples that show web tier basics like extracting HTML form parameters, saving data in scope, and forwarding requests. There are also newer features like web-xml fragment processing, asynchronous processing (good for AJAX), filters and annotations instead of configuration. This chapter reminds me of an old book I learned a lot from, "Core Servlets and JavaServer Pages". Did you use that one? This chapter has the same ease of reading and practical applicability.

Chapter 3 was again a lot of basic web-tier stuff. JSP fragment includes, Custom Tag Libraries, Unified Expression Language, XML syntax and JSP syntax are covered. Reading this taught me a few new things, validated some of what I remembered.

Chapter 4 was about JSP's Standard Tag Library, including core features (i.e. iterator, looping, etc.), formatting (I18N with bundles), SQL, using XML JSTL (instead of JSP), and JSTL functions like split(), length(), toUpperCase(), etc.

Chapter 5 was the JPA chapter. I've done a little JPA work, so I'm not totally stuck in the Entity Bean era, but it was nice to have this chapter to outline modern Java persistence. In particular, the explanations of entity cardinality and the way to use annotations on your entity classes was well done.

Chapter 6 covered JSF, which was something I needed. I remembered the old Servlets and JSP way of doing things, but I haven't been in the web tier a lot since JSF came around. This chapter Explained tags, validation (including custom validation) and error messages. The explanations were easy to follow and very well done. I was especially happy to read the section on combining JPA and JSF, as it shows how sensible defaults connect the JSF page to a controller bean. Hurray, JEE can do a lot of wiring for you, using sensible defaults! (Once you understand what they are, it's easy to see how a few lines of code can accomplish a lot. But if you don't know what the conventions are, you'd have a hard time guessing what can be done for you by JEE!)

Chapter 7 was a JMS chapter. I work here a lot, so there weren't a lot of surprises for me. For those that don't work with JMS a lot, it'll be good.

Chapter 8 was about JEE security. As usual, well explained. (There seemed to be quite a bit of Glassfish specific stuff here, I wish that could have been reduced.)

Chapter 9 was the EJB chapter. Stateful, Stateless, MDBs, Singletons, Timers. Transactions (and how to have more than one transaction with UserTransaction). Easily understandable, modern EJBs make business logic fun.

Chapter 10 covered Contexts and Dependency Injection. Modern JEE servers are moving into the space traditionally inhabited by Spring, and this chapter explains how to use DI in a JEE container.

Chapter 11 covers Jax-WS web services. I spend plenty of time in this workspace, so I found most of it familiar. You can certainly find aspects of JEE that are not covered in this book (Jax-WS leaves quite a few nooks and crannies to explore), but this chapter covers the basics well.

Chapter 12 was about Jax-RS (REST web services). This is another chapter that illuminated an area I had experimented with in the past, enjoying mixed success. The 'convention over configuration' aspects are explained, which makes example Jax-RS snippets much easier to understand. This is one of the chapters I'm sure I'll refer to in the future.

There are also a couple of appendices, one on email in JEE and one on IDE usage.

The book's about a year old, but JEE 6 is still the current spec and will be on the upswing for quite a while. The book is very much relevant.

So, what's the final verdict? It's a doozy: This book will have a spot on my nearest bookshelf, because it is an excellent and easy to read reference for the whole JEE stack. What makes this remarkable is that I don't even use GlassFish! Ok, for this book I downloaded a copy and kept it right next to JBoss AS 7, my preferred JEE 6 container. It's a tribute to the JEE spec writers that I was able to run the majority of the sample applications with virtually no changes for the app server-- just compile via Maven, then plop the deployable artifact onto whichever server you want. (By the way, if you haven't used one of these new JEE servers yet, you're in for a small, fast surprise! Please try JBoss AS 7, you'll see what I mean.)

For coders like me-- those who don't spend a lot of time across the whole JEE stack-- I'd recommend this book as a quick way to be comfortable wherever you find yourself in the JEE stack.

The book can be found here.

Happy Productively Programming!

Book Review for "JBoss AS 7 Configuration Deployment and Administration"

2011-11-12T19:31:00.003-06:00

Book Review for "JBoss AS 7 Configuration and Administration"

Have you heard the buzz about JBoss AS 7? Happy days for the developer community-- the productivity gains of JEE 6 are combined with lightning fast speed and minimal footprint for AS 7. The downside to all this is there is much to learn (again). Packt can help.

The book's author is Francesco Marchioni. If that name sounds familiar, it should. This is the guy behind "MasterTheBoss", a very popular JBoss oriented developer website. Francesco has also authored well-written books on JBoss AS 5 development and JBoss AS 5 performance tuning, so he knows a thing or two about JBoss as well as how to churn the words out.

This is a "RAW" book, which means it's not yet finished. Some of this is reflected in the book's existing text, but mostly what's here is good. There are a few chapters yet to be written.

So what's in this book? Here's a quick chapter-by-chapter breakdown.

Chapter 1 - A nice overview of the new, improved JBoss. AS 7 is a major re-hang, with the old MicroContainer going by the wayside and being replaced by JBoss Modules and a Modular Service Container. (The most dramatic external changes are very fast startup speed and completely different configuration mechanisms.) JBoss Modules is a big change, and really is explained throughout the book, but your first exposure is here. You're also given a very newbie-friendly explanation of how to download, setup, start and stop JBoss.

Chapter 2 - We start the daunting task of learning to configure the new and improved JBoss. JBoss has always given administrators a lot of options to consider when it comes to configuration, and AS 7 is no exception. Suffice it to say the model is all new, but this book goes about explaining it in a clear way. (Pictures are used where appropriate.) Here we are given an explanation of how configuration now works-- there is a 'standalone' mode and a 'domain' mode, these are covered. A few bread-and-butter items like port configuration, datasources, and installation of JDBC drivers is here. The author's performance orientation shines through in a section that describes the various types of thread pools and how they can be used. The chapter ends with section on the latest messaging system (HornetQ) and Transactions.

Chapter 3 - Chapter 3 covers 'Enterprise' topics, which include the various flavors of EJBs. The book explains their lifecycles and how they are configured (down to details like cache pool sizing). If you're getting the impression this book covers some low-level topics, you would be right. The JBoss Web Container (very similar to Tomcat) is explained. Configuration of the default JBoss logger is covered, as is installation of Log4j should the reader decide to use it instead. Even though this is an administrative book rather than a development book, the author chose to throw in a simple example web application so the reader can have something to deploy. I tend to lag on web technologies (because I work with back-end technologies), so I really appreciated that part. Woohoo, I've used Facelets!

Chapter 4 - This chapter covers the all-new 'domain' mode. Domains are all about centralized configuration of groups of servers, a feature that will be very welcome in large shops and cloud environments. You may think this sounds a lot like the traditional JBoss simple clustering, and you would be wrong. This is something completely orthogonal to clustering! But it's given a good coverage, and by the time you're done with this chapter you'll be itching to go try to define your own domain and work it over.

Chapter 5 - Chapter 5 is about application deployment. The mechanisms you use will differ depending on whether you are 'standalone' mode or 'domain' mode. You also have several ways to deploy JEE artifacts-- these are all explained nicely. This makes for light reading, but the chapter is balanced out by a good section on Classloading in AS 7. If you've done much JEE development (on any platform) you are aware that classloading can be a tricky area. With AS 7, JBoss sought to straighten this out and this chapter explains how it all works.

Chapter 6 - is about the administrative interfaces AS 7 brings you. First, there's a web UI. In my opinion, the web interface is clean and adequate as far as usability, but it lacks depth. The alternative is a command line interface (CLI) that you can use to reach all kinds of nooks and crannies in AS 7's configuration. The CLI demands that you understand a somewhat arcane dialect, but it rewards you with useful functionality. If you know the current JBoss 'twiddle' utility, you should find the CLI very similar.

Chapter 7 - is the clustering chapter. Cluster configuration is explained, including the Infinispan and JGroups components you'll need to understand. Clustering has always been one of JBoss's strong suits, it should only get better with AS 7.

Still yet to be provided (this is a RAW book, remember):
Chapter 8 - on load balancing web applications.
Chapter 9 - Integration with other frameworks (I'd watch for Spring content here)
Chapter 10 - Tuning and slimming. (With the modular emphasis, we should have some very effective slimming available)

So who's this book good for? I'd say anybody using AS 7. (AS 7 will be the basis for the next 'supported' JBoss, EAP 6, by the way.) AS 7 is a major re-hang, so you're going to want a decent guide to learning your way around. I liked this book, and imagine I'll be using it as a reference on a regular basis.

Oh, that last paragraph begs the question: Who should be using AS 7? I think everybody should give it a try. JEE 6 has an associated learning curve, but it's the most productive version of Enterprise Java yet. With the speed and reduced memory footprint, I found that AS 7 is great to run in an IDE like Eclipse or JBDS, allowing me to deploy and start in a flash. I'd encourage every Java developer to give AS 7 a look, and while you're at it use this book as a reference.

The book can be found here.

Happy (productive) reading and coding!

Book Review for "Drools Developers Cookbook RAW"

2011-10-29T19:37:00.003-05:00

A Developer's Survey of the fast-moving Drools project

This review is for "Drools Developers Cookbook" from Packt. This book is currently available in 'RAW' format, which means it's not quite finished. The text is a little rough around the edges, and there are two chapters yet to be provided.

Do you work with Drools, the popular open source rule engine? If not, this is not the right book to get you started. There is no introductory material to get you started. But if you know Drools, this is your ticket straight to the current cutting edge! This book gives pointers and best practices for working with the latest and greatest features.

The first chapter gives you tips on working with rules. You'll see how to write rules in ways outside the usual, how to enable some diagnostic logging, and how to work with rules on timers and Calendars.

Chapter 2 deals with more 'bread and butter' Drools material, but this time not dealing with rules.

Chapters 3 and 4 cover Guvnor, the open source Business Rules Management System. Guvnor, a web app, allows you to author, categorize, and test your rules. This is how you can have business-analyst types write business logic instead of using programmers.

The fifth chapter is probably the most newbie-friendly chapter in the book, it deals with Complex Event Processing. CEP is a way of applying rules over windows of time, so you can express something like "Tell me if there are 100 online purchases in any half-hour period".

Chapters 6 and 7 deal with executing Drools remotely (mostly through 'Drools Server') and integrating Drools with other applications through Spring and Apache Camel. This is very handy-- after mastering Drools, developers sometimes wonder how to apply their newfound knowledge in a practical way. Here are some good ideas for solving that problem!

The two chapters that are not yet provided deal with Drools Planner (a tool for finding optimal solutions to problems like capacity balancing challenges) and jBPM5 (a re-hang of the popular jBPM Business Processing framework). These two will be very important, especially jBPM. I hope the author is putting a special emphasis on these.

All things considered, I find this book to be a good resource for Drools developers. As I've hinted, if you're new to Drools you probably need to start with something a little more basic. But if you're already into Drools, this is a quick way to get get a handle on state-of-the-art features.

The book can be found here.

Happy Drooling!

Book Review for "JBoss ESB Beginners Guide" in RAW Format

2011-10-14T18:21:00.003-05:00

An easy introduction to the popular JBoss ESB.

*Disclaimer* I work for Red Hat as a JBoss support engineer and work with JBoss ESB every day. This will allow me to make an informed review of this book, but you should be aware that I work often with the book's authors. Still, you can expect an honest review here.

Primer: What's an ESB? An ESB (Enterprise Service Bus) is a runtime environment that lets the user define services, consume services and route and transform messages. The user can wire together modular services to define desired functionality. ESBs are often used to mediate web service calls-- they stand in between the caller of a service and the provider of the service. From this man-in-the-middle position they are able to transform messages, manage security concerns, enrich messages, and audit activities. ESBs are also often used with JMS. In this context they are transactional, so they can string together a series of actions (including database inserts) that are transactional and can be initiated by a fire-and-forget client. ESBs offer great utility, but usually at a significant technological cost.

This book is the first book offered for JBoss ESB, and is currently offered in "RAW" format, which means it is incomplete and subject to editing as the authors continue to enhance it. The authors are all key contributors to the project, so the knowledge is first-rate. Presentation is also surprisingly good, probably because at least one of the authors is a prolific blogger and thus in good practice. The overall quality of the book is high.

So what's covered in this book? Here's what I would consider the highlights:

- Download and installation of JBossESB.
- Configuration of JBDS (an Eclipse-based IDE for use with JBoss products)
- Introduction to the JBoss ESB quickstarts. This is very important! This is an introduction to literally dozens of minimal, functional examples for JBoss ESB. (Think of them like "Hello World" examples for using different parts of the ESB.)
- Services, including the necessary configuration parts.
- Writing your own functionality for the ESB (Custom Actions). These can be implemented in Java, Groovy, etc.
- Messages. What they are made of, how to validate them, how they are carried on the ESB.
- Message Exchange Patterns (MEP). This is an important concept in ESBs, it determines if your client gets a response or not.
- Passing messages in memory for performance.
- The packaged Services that come with JBoss ESB. Like the quickstarts, this is a huge gateway to lots of functionality just waiting to be picked up and used.

The book's title includes "Beginner's Guide", which is partly truthful. It is a gentle enough introduction that a newbie will be able to make use of the book. But it also includes plenty of coverage of what I'd consider "Advanced Topics". (Remember, I answer support questions on this software every working day, so I think I have a fair idea of what's easy to do and what's not.)

Since this is a RAW book, it's not complete yet. At least one other chapter is promised, on Gateways. A Gateway is a component that accepts messages from sources other than the ESB itself, i.e. external JMS providers, HTTP, SQL, and so on. This should be another good chapter.

Who is this book good for? I'd say any user of JBoss ESB. If you're not yet a user of JBoss ESB, but think you might like an ESB, then I'd recommend this book for you, too.

If you think you'd like this book, I'd suggest you move fast. For the month of October, Packt is offering any Open Source eBook for only $10.99. That's hard to beat.

The book can be found here.

Happy JB-ESBing!

Book Review "Android 3.0 Application Development Cookbook"

2011-09-08T20:51:00.003-05:00

Book Review for "Android 3.0 Application Development Cookbook"

The Android Novice's guide to doing just about anything.

Android 3.0 Application Development Cookbook

This book is presented in Packt's "CookBook" format, which means it is a series of how-to steps that show the reader how to accomplish some task. In this case, the book shows how to program Android devices using the Eclipse ADT plug-in.

Establishing the development environment was a bit troublesome in my case. I've done a little Android development in the past, but the machine I used was underpowered for the emulator, so I decided to set up Eclipse and my Android environment on my Fedora 13 quad-core. The book is of little value here-- pretty much you are told what you need, and are left on your own to get it set up. Luckily, I'm familiar with this sort of task, so things were running smoothly after the initial install and about a half an hour of Google'd help from other ADT users.

In the early chapters, the book is very explicit about how to set up your Eclipse project and which files to edit. The author takes no chances that the reader is unfamiliar with the environment, and spells everything out in perfect detail. Normally, I prefer printed books to electronic, but this is one case where an e-book would've been handy-- for code copying purposes. I spent my learning time dutifully typing in the author's suggestions, though, and was rewarded with properly running examples each time.

The first chapter is about 'Activities', which results in a window being presented on the device. (In my case, the emulator.) You are shown how to make an Activity, how to store state, how to send an 'Intent' (which is like a message that can be sent to another Activity or other receiver). This chapter spells out the steps in complete detail, so the reader should be assured of success if he has his development environment set up correctly. Later chapters omit some of the detail, but you are never given so little that you can't accomplish what you want. It's just the first chapter that sets the basics for the reader.

All the chapters are set up the same way. There is little or no 'academic background', each chapter is a series of step-by-step descriptions of how to accomplish some goal. I think this book will be a very effective reference for development, I imagine many copies will be kept close at hand.

There is surprising depth in the list of tasks this book teaches. Here's an incomplete list, to show you some of the things that are presented:

- Drawing your UI
- Making menus, context sensitive menus, shortcut keys and submenus
- Storing data on internal storage, external storage, the included SQLite database
- Detecting device orientation, using the accelerometer, detecting user gestures and the available sensors
- Communicating with the user through Alerts, progress bars, status bars and dialogues
- Adding graphics, rotating images, and using animation
- Playing audio files and recording video, audio and taking pictures
- Sending and receiving phone calls and SMS messages, using internet content
- Detecting the device location, using Google maps and other mapping skills

Sounds like a pretty cool list, huh? Each of these tasks is shown in a manner that isolates it from other problems, so you are basically shown the way to write a tiny application that showcases just the feature you are interested in.

Readers looking for lots of explanatory text about the big picture are going to be disappointed-- this book is all about getting the task done. In that regard, it is quite effective.

All things considered, I liked this book and would recommend it to anyone who is doing Android development. Beginners will get a decent introduction to some small projects (they'd better be ready to augment their knowledge with the online APIs and other sources, though.) More experienced developers will probably know some of the material, but can surely learn from the wide variety of capabilities explored. Basic skills necessary are fundamental Java, a little knowledge of XML, and a willingness to follow instructions and look for details elsewhere. If you've got those, you can develop for Android with this book.

The book can be found here.

Happy Droid Development!

MEAP Review: Spring Integration in Action

2011-09-06T19:25:00.003-05:00

A hands-on guide for using Spring's Integration framework.

Disclaimer: I work for JBoss and support JBoss ESB, which can be viewed as a competitor to Spring Integration. This review will cover only the book "Spring Integration in Action" and only the features of Spring Integration it describes.

Spring Integration is a toolkit that fits the needs of Enterprise users who need to facilitate communication between disparate applications. If you're not familiar with the workspace, these toolkits allow the user to perform tasks like the following: read text files in and invoke backend web services for each record in the file; proxy a web service and allow you to alter either the data going to the targeted backend service or alter the response received from it; log http requests to a database; many others.

The book is well-written and describes Spring Integration usage often in terms of the famous 'Enterprise Integration Patterns'. The Patterns are well-known and time-tested methods of successfully achieving tasks, and the book's author does a good job of demonstrating how Spring Integration can be used to implement them.

"Spring Integration in Action" is broken up into 4 areas:
- Background
- Messaging
- Integrating Systems
- Advanced Topics

The 'Background' section has 2 chapters. There's a short introductory section that covers Spring, for those unfamiliar with this famous Dependency Injection framework. I expect most users will breeze by this, but it probably will be necessary for others. The second chapter deals with the "Enterprise Integration Patterns", which are time tested best practices in the Integration workspace. The book does justice to the topic in this chapter, but really spreads a lot of the 'Pattern' information around the rest of the book as well.

'Messaging', as the section title suggests, deals with the fundamental parts and pieces that help Spring Integration shuffle data from component to component. Integration toolkits require ways to pass messages along (Integration is mostly about messaging), in Spring Integration these are called "Channels". Channels are very important in Spring Integration, as they determine the runtime characteristics (i.e. number of threads) that will be part of your pipeline. This can be a topic of confusion, so it's good the author discusses it early.

Components deal with messages, messages travel along channels. In between these two is an 'Endpoint', another important topic. Endpoints can be outward-facing (gateways), and can be event-driven or polling in nature. Endpoints are covered in the same plain-spoken manner as the rest of the basic components.

The next few chapters deal with more 'generic' Integration best practices. These include the way messages are transformed (so different systems can 'talk'), the way messages can have information added to them, and how you can route and filter the messages that travel between components. If you've been in the workspace, this all probably sounds familiar. If you haven't-- the book provides a good explanation of how things work.

'Integrating Systems' deals with the construction of your message pipeline and some of the components you'll likely need. You'll be wanting to split and recombine messages, convert Java objects to XML (and vice-versa), and how to hook JMS into your pipeline. You'll also want to deal with the file system, web services and maybe email-- these are all explained here.

'Advanced Topics' is a potpourri of topics that you may or may not find a need for. It seems most every book today has to cover publishing to social media outlets, this one does as well. Batch application integration (using Spring Batch, naturally) is explained. There are also some chapters I found of very high value: managing and monitoring, scheduling and concurrency, and Test Driven Development best practices.

This book is in Manning's "MEAP" program, which means it is available for early purchase, but is still being worked on. In this reader's opinion, the current MEAP version is of sufficient value to warrant a purchase. There's a lot of good material here, it's probably very close to a completed state.

So, what's the final verdict? I like the book for the clear explanations of how Spring Integration works. For users of other integration toolkits, there's also a lot of generic 'Systems Integration' knowledge that would be of value. If you're a Spring Integration user, buying this book should be a no-brainer-- it will quickly pay for itself many times over. If you're not a Spring Integration user, but are a user of another system integration toolkit-- you still might consider it, for the overall Integration value. All things considered, this book will be a good reference for the Integration user.

The book can be found here.

ETL-- what is it, how it can be useful to you

2011-07-17T14:37:00.004-05:00

What's ETL, and what can it do for me?

ETL is short for "Extract, Transform, Load", and it's a well established discipline of IT. ETL tools are usually fronted with graphical front-ends that facilitate putting together processes that work on streams of data. The data can be filtered, augmented, sliced into pieces, and put into new repositories. (That's E,T,E and L if you're a discriminating reader.)

So what can this do for you? In my day-to-day job, I used to work for a company that worked with gobs of demographic data, so we used ETL all the time. Mostly handling large files, splitting them into fields, validating values, adding values where none was there, and loading databases. But now that I'm doing something else, I still see plenty of uses for it. Got a log file you need to parse to look for trends? ETL can help. Do you have a list of Garbage Collection stats you'd like to work over? Another good use case. How about writing out some XML or JSON from a source in another form? Check, check and check. Would you like to automatically validate the format of some data, and send an email out if it needs some work? Another good case. Almost any time you have a reasonable amount of data and want to add to it, subtract it, split it into streams, validate it or place it somewhere else or in a different format, ETL should be one of the tools you consider.

ETL vs. ESB vs. Integration Framework

Is ETL better than an ESB (like Mule or JBoss ESB)? How about a lightweight integration framework (like Camel or SwitchYard)? ETL is often accompanied by a nifty user interface that lets you quickly drag-n-drop components onto a canvas, making for a very productive user model. ETL is almost always used to process large volumes of data, not single transactions. So while an ESB or an Integration Framework's usual use case might be onesy transactions, the ESB is going to go after a lot more than one record. (The records can come from a database, a flat file, an XML document, or other stores. The idea is that there is probably more than one of them.) This is not a concrete rule-- ESB and Integration Frameworks can process files, for instance, or an ETL tool can be made to operate on single records-- but it's almost always true. ETL is more about files (or groups of records) than it is about a single message.

Where can I get one of those?

ETL tools have been around a long time. Commercial versions exist that contain many nice features, but I really like an Open Source version called 'Kettle'. Like many successful Open Source products, Kettle is available in a commercial version and in the 'project' version that's freely available. I'd urge you to download Kettle and give it a shot if you haven't done so already.

OK, I got the free one. Now how do I get started?
The Kettle download comes with a 'Getting Started' guide that should have you running a sample flow in less than an hour. Better yet, you'll see all the cool drag-n-drop operations you can use and will soon be hacking together flows to munge data faster than you ever thought possible.

We interrupt this blog posting for a brief Book Review...

I've been inspired to write this blog post after reading a new book from Packt Publishing, "Pentaho Data Integration 4 Cookbook". Now that we have a baseline understanding of what kind of ETL we're talking about, let's talk a bit about this book.

The book does not teach Kettle basics. If you don't know how to start Kettle, you're going to have to read the user doc, because you won't find it here. What you will find is a sizable collection of best practices for accomplishing things with Kettle. (Many of the patterns will apply to other ETL products as well, though the implementation steps will be different.) Here are some of the things you might expect, and will find in this book:

- How to insert, update, and delete from a database
- How to alter a database at runtime
- How to read and write fixed flat files, CSV files, and Excel documents
- Reading and writing XML documents
- Shuffling files in the usual ways (copying, moving, remotely copying and moving), deleting
- Writing reports
- Sending emails

I'd expect any decent book on ETL to cover all those topics. These things are all basic uses of Kettle and would quickly be needed by many users. But wait! The book goes deeper, providing advanced use cases that will leave many advanced users puzzled. These include:

- Changing a database connection at runtime
- Parsing unstructured files (like a log4j log file)
- Validating XML against a schema or DTD
- Matching data based on 'fuzzy' matching algorithms
- Augmenting data with web services
- Splitting a flow into 'sub-Transformations' to facilitate management and re-use
- Effectively dealing with your data stream-- forking it into different streams for 'good' rows and 'bad' rows, and treating each differently

It's this second list of topics that really makes this book valuable. Honestly, Kettle is fairly intuitive to use, so a competent developer will probably figure out the basics without much assistance. The difference between a basic user and an expert will be the ability to figure out the more advanced use cases, and that's where this book provides a nice value-add.

The book can be found here.

I'm pretty excited about using a few of the tricks I've picked out of the book to help me with some recurring tasks. One of these tasks involves preparing data for R, the statistical package. (If you're not an 'R' user, please look back in this blog or elsewhere on the internet to see what all the hoopla is about. It really is nice!) Prior to this, I'd usually use Python and Bash scripts to massage and extract data from the sources I want to examine, but this actually can get to be a bit tedious. Using the drag-n-drop Kettle interface, though, I hope to apply my newfound knowledge to help me quickly stage data for advanced analysis. Wish me luck in this endeavor as I wish you good luck in finding uses for your problems as well. We're lucky-- never before have we had such a wealth of freely available tools to help us solve problems!

Happy Kettling!

Book Review for "Oracle JRockit The Definitive Guide"

2011-07-02T09:35:00.003-05:00

Have you ever worked with someone who knew a lot about the JVM? I did once, and it was an eye opening experience. Not only was this guy the right person to go to for performance and GC questions, he also was confident he'd written his programs for optimal performance. I was so impressed I decided this must be one of the characteristics of a superior programmer, and decided I'd try to improve myself in this regard.

I've just finished "Oracle JRocket The Definitive Guide" and I think this book has helped me on my journey to Java mastery. The early chapters are a little deep for an application programmer, but they still make for interesting reading. (Just how deep? How about discussions of the assembly code generated for your Java source? The very lowest levels of the JVM are discussed.)

After the lowest level workings of the JVM are covered, we encounter some material that's more likely to be of use to the average Java coder. We start learning about memory management, including in-depth coverage of garbage collection. (This is sure to be of use to any serious Java developer.) Java constructs of interest like Soft References, Phantom References, etc. are discussed. IMHO, these are topics that are beyond basic Java-- another tool in your Java toolkit!

There's a whole chapter on threading and synchronization. Once again, treading ground beyond that occupied by Java programmers at the basic level. Here you'll encounter topics like thin and fat locks, spin locks, and the innards of how threading is implemented on a JVM. If you're starting to get the feel this book is partly about computer science, not just programming, I'd think you may be right.

There's a lot of material related to understanding how the JVM is working. (This includes benchmarking, profiling, and understanding the running JVM.) It goes without saying this is all of high value to any Java programmer.

The final chapters of the book are devoted to the tools associated with JRockit. JRockit comes with a bunch of handy tools to help you monitor and control your JVM. These chapters show you all the slick GUI features and low-level switches you can use now that you understand what the JVM is up to.

Final impressions? This is an interesting book, because it's written hardest-materials-first. If you can hang with the early chapters you stand a lot to gain.

Who is this book good for? Any Java programmer will benefit from the early chapters. (They aren't specific to JRockit.) The latter chapters will be of use only to JRockit users, but since it's now freely available under a user friendly license, these tools are available to everyone.

It's a big book-- well over 500 pages, and none of it is fluff. I liked this book, it can be found here.

Happy 'Rockiting!

Book Review for "Apache CXF Web Service Development"

2011-06-11T19:35:00.002-05:00

Book Review for "Apache CXF Web Service Development" (When bottom-up "Hello World" is not enough)

Do you use Apache CXF? If so, you might take an interest in "Apache CXF Web Service Development". Here's my impression.

The book does a good job of covering CXF use cases, going beyond the usual trivial Jax-WS examples. It also covers Jax-RS (RESTful) web services, and covers each in enough detail that you're likely to find what you need when working with CXF.

Jax-WS has largely demystified basic web service development, so there's a great amount of content on the web that will show you how to quickly annotate a POJO to get a web service up and running. But what if you need to do contract-first (top down) development? Lightweight resources often conveniently bypass this more difficult trail, but this book does a good job of handling it. (This is no great accomplishment for a book on web service development, but it does set the tone for the types of things this book will show.)

Let's say you have a need to work with the raw XML, rather than getting the message in the form of a POJO? That's the use case for using a Jax-WS 'Provider' web service, and the book covers this and the client-side equivalent component (Dispatcher.)

How about if you want to change the message in some way, maybe altering security information? Interceptors are useful in that case, these are explained.

RESTful web services are pretty popular, they're in the book as well. Not only REST, but also how to implement then with XML payloads or JSON. You're given knowledge of the tools to test all these things, as well.

So who would I recommend this book to? I'd say a Java developer either currently using or wanting to use Apache CXF. The book isn't a complete reference for CXF, but it does introduce all the important topics. Once introduced, there's enough content to either solve your problem or at least educate you enough to effectively research what remains.

The book can be found here.

Happy Jax-*'ing!

Rick

Book Review for "Apache Wicket Cookbook"

2011-05-27T21:51:00.002-05:00

Have you heard of Apache Wicket? It's a web framework that tries hard to eliminate all the XML configuration you see in most modern application frameworks. The developer produces two primary flavors of artifacts-- Java classes and HTML pages, and with these two your application is built. If this sounds interesting, you probably don't need to see this new book from Packt.

You may be wondering why I wrote that you don't need to see the "Apache Wicket Cookbook" if you found the description of Wicket interesting. The reason I wrote that is because this book is going to be of very little value to someone who's just found out about Wicket. But if the reader already knows the basics-- then this book is a powerful resource.

There's very little introductory material. The book is honest about this in stating the target audience-- it says if you've already written a couple of Wicket applications, then you're a good candidate to pick this one up. I agree. If you don't know the basics of Wicket, a lot of this will be over your head.

Still reading? Then you might be familiar with writing Wicket applications already, and might wonder what you'll find in this book. I'd summarize it by saying there's plenty of material for someone charged with writing real-world applications in Wicket. A few examples: Securing your application, editing pairs of fields based on values in each, displaying data in the form of charts and tables that are sorted when you click a header. Still want more? How about integration with Spring, Seam, and JPA? The book reads like a bunch of answers to support questions, provided by someone who really knows Wicket but doesn't have time to explain all the theory behind the answers. There's just a flat out explanation of what to do, backed by code examples that quickly import into Eclipse and run flawlessly. If you want to understand *why* what you're doing works, it's going to be up to you to follow up with Wicket reference material to see why. High level overviews are not in the very direct path this book takes.

The book is written by Igor Vaynberg, who is probably the most prolific contributor to Wicket, so you know the author knows his stuff. The use cases are supposed to be issues that real-world users will need to conquer, and again Igor is a good source for these. (He is well regarded in the Wicket community. I encourage you to consult your friend Google to check this out.) Igor knows what people are wanting to do, and he knows how to do it. This book is a collection of that kind of information.

The book is written in Packt's "Cookbook" format, which is exactly what this book needed. It presents a problem, tells you the steps to find the answer, then briefly (very briefly) explains how it works. In-depth research is up to you.

Final verdict: If you're an active Wicket user, you should buy a copy of this book. It'll pay for itself the first time you need to solve one of the roughly 50 scenarios it covers. You'll have the right answer, the first time, and a running example to help you understand it. If your sense of curiosity demands that you understand all the details of how those parts work-- that's extra credit research for you, dear reader. But your site will have the functionality you seek in short order.

The book can be found here.

Happy Wicketing!

Rick

Book Review for "Camel in Action"

2011-05-15T14:17:00.003-05:00

Book review for 'Camel in Action'

The Manning 'In Action' books are usually good ones-- readable, thorough, and suitable for use as both an introduction and a reference. This book is no exception.

The topic is Camel, Apache's open source framework for implementing Enterprise Integration Patterns. If you're wondering what that means, you might consider Camel an 'ESB Lite'. It's not a true ESB, I think mostly because it doesn't have it's own hosting runtime, but beyond that it does many of the things an ESB does.

Camel can be used to route messages. So let's say you want to listen on a JMS queue and use the results to call a web service. No problem for Camel, the book tells you how. Likewise, if you want to do some message transformation-- maybe read in a file, split it into lines, enhance each line with some stuff you get from a database-- no problem. The book does a great job of demonstration through simple examples, which I found to run well and easily. Warning: if you're not a Maven user yet (I think Maven is beginning to definitively prevail in the Ant/Maven battle), you'll want to brush up a little as it's used exclusively throughout the example suite.

The book is exhaustive in it's coverage of Camel-related topics. Sometimes tech books are written in such a way that development-centric topics are given great coverage, while operational issues are not. This is not the case here-- it's obvious the authors of this book have spent some time deploying, running, and monitoring applications as well as writing them.

The source code that comes with the book is well organized, clean, and relevant for the chapter material it augments. Most important, it runs out of the box.

Camel basics (routes, Java and Spring configuration, the Enterprise Integration patterns) are all covered in more-than-adequate fashion. These are basic but necessary topics any good Camel source should provide. Where this book excels is in the ancillary material: management, monitoring, threading, transactions, testing, deployment in popular containers, etc. Very thorough, it's why this book is 550 text-packed pages long.

If I had one complaint about the book, it would be that the chapter ordering wasn't quite to my liking. The reader is given plenty of example material (including some advanced topics like transactions and concurrency) long before the basics of setting up a user-concocted "Hello World" project are presented. This is a minor nit, though, and it does not detract from the overall excellence of the book.

Bottom line: this is a must-have resource for any user of Apache Camel. It can take you from ground-level to production use, and will no doubt serve as a valuable resource for as long as you use Camel.

The book can be found here.

Happy Camel'ing!

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

2011-05-05T21:47:00.004-05:00

Book Review for 'BackTrack 4: Assuring Security by Penetration Testing". White hats, get a copy now before the bad guys snap them all up.

I've just finished reading Packt Publishing's new book "BackTrack 4: Assuring Security by Penetration Testing". The book is meant to be a how-to guide for using BackTrack 4, a freely available Linux distribution whose sole purpose is to provide a platform for a hacker's arsenal. I'd never looked at Backtrack before, but believe me, it's a site to behold.

The distribution, once downloaded, can be installed on a machine or run as a 'live' DVD. (The book covers all this, naturally.) Once booted, the user has a *whole operating system* loaded to the gills with tools meant for breaking into computer networks and vulnerable hosts. It is frightening in it's scope.

The book is written for good guys, of course, so it includes a good amount of text that's of use to security professionals. It covers how you should make your agreements with the system owners you are assessing, the kinds of reports you should prepare, and a very useful framework for disciplined testing. The framework breaks penetration testing into discrete phases.

The first 'hacking' phase is Information Gathering. Here the user is introduced to about a dozen tools that can be used to find domain names, IP addresses, host names, and other information about the target environment.

The next phase is Target Discovery. Here the user finds hosts and identifies operating systems. Again, about a dozen different tools are presented.

The next phase is Target Enumeration. This phase allows the user to discover which ports are available, which services are offered, and what kinds of VPN are in use.

Once all this information is gathered, the user can proceed to Vulnerability Mapping. Here, another good sized set of applications are available to help the user determine what kinds of vulnerabilities exist in the target machines. This logically leads into the chapters on Target Exploitation, Privilege Escalation, and Maintaining Access.

Of course, no good book on penetration technique would be complete without a chapter on Social Engineering, and so we have one here.

So what did I think of the book? At first glance, honestly, I was unimpressed. Just picking up the book and thumbing through it revealed a great number of very brief introductions to tools. You'd see many pages where a tool is introduced, then given just a page or two of instructions on how to invoke it and what output to expect from it. It was only after I started actually reading the book that I realized the tools were neatly categorized (as explained above) and that the brevity of the introduction was soley because the authors already filled 350 pages and probably simply couldn't practically include more detail.

I've never intentionally hacked another system, but I have at times used tools like WireShark to observe network traffic as I sought to untangle some security problem or communications glitch. This book has provided me with several ideas for similarly useful tools, and introduced me to several I have no intention of ever using. (Unless I should decide to one day become a security consultant, and offer to hack into systems for profit. In that case, I'll make myself familiar with all the tools in the BackTrack toolkit.)

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

The book can be found here.

Happy (ethical) Hacking!

Tools to learn somebody else's codebase

2011-04-23T12:20:00.004-05:00

Writing code can be a difficult task, but reading it is usually even more challenging. Here's a quick tip to help you the next time you want to make sense of a bunch of code you don't yet know.

My day job is working support for JBoss. If you haven't noticed, JBoss doesn't let much moss collect-- projects are constantly moving, improving and springing up from the ground. If you want to keep up in this environment, you'd better learn to read code and digest it quickly-- and that's the need that produced this solution.

One of the things I like to do is add a quick function to my .profile (we'll see how to use this in a bit):

# Use this with 'tree'. Works with wildcards
getF() { THF=`find . -name $1`;export THF; /usr/bin/gedit $THF & }

I'd use this in conjunction with Linux's excellent 'tree' command. Use 'tree' to quickly see what the source base looks like, then use getF() to easily zero in on files that are of interest.

Let's go with an example. Today I'm looking at the just-released droolsjbpm-integration package (which looks good, and runs some neat examples out of the box, by the way.) So I might start like this:

rick:~/Tools/droolsjbpm-integration-distribution-5.2.0.M2/examples$ tree
.
|-- binaries
| `-- droolsjbpm-integration-examples-5.2.0.M2.jar
|-- runExamples.bat
|-- runExamples.sh
`-- sources
|-- pom.xml
`-- src
|-- main
| |-- java
| | `-- org
| | `-- drools
| | `-- examples
| | |-- broker
| | | |-- BrokerExample.java
| | | |-- Broker.java
| | | |-- BrokerServices.java
| | | |-- events
| | | | |-- EventFeeder.java
| | | | |-- EventGenerator.java
| | | | |-- EventImpl.java
| | | | |-- Event.java
| | | | |-- EventReceiver.java
| | | | |-- EventSource.java
| | | | `-- StockTickPersister.java
| | | |-- misc
| | | | `-- Utils.java
| | | |-- model
| | | | |-- Action.java
| | | | |-- Company.java
| | | | |-- CompanyRegistry.java

(More deleted. You get the picture, though. Get the picture.... get it? Hee hee.)

So we immediately get a view of what's in the codebase. You might see how much code is out there.....

rick:~/Tools/droolsjbpm-integration-distribution-5.2.0.M2/examples$ find sources -name *.java | wc -l
46

So only 46 java artifacts. Pretty reasonable.

If a codebase has a lot of interfaces and inheritence, it can be a little tougher to read. So we might have a look at how much of that is out there....

rick:~/Tools/droolsjbpm-integration-distribution-5.2.0.M2/examples$ find sources -name *.java |xargs egrep 'implements|extends' |wc -l
24

Hmmm, that seems a little rich, for only 46 java files. It could be that you're working with a framework built to allow lots of things like plug-ins and alternative implementation (in a good case) or it could be that you're reviewing code written by someone who reads too many academic textbooks and doesn't really grasp the proper use of such abstractions. In this case, I'm confident it's the first case.

OK, so now let's see how that function we put in .profile can be put to use:

rick:~/Tools/droolsjbpm-integration-distribution-5.2.0.M2/examples$ getF Cell*
[3] 2514

Immediately, my text editor pops up showing me Cell.java, CellState.java, CellGridCanvas.java, CellGridImpl.java, and CellGrid.java.

I grant you, much of this is also available via a nice IDE like JBDS or Eclipse, but sometimes (well, frequently, really) it's hard to wrangle the projects into an IDE without doing a bunch of classpath setup, dependency downloads, etc.

Happy Code Reading!

Book Review for "R Graphs Cookbook"

2011-04-16T21:03:00.004-05:00

Quick! What do James Gosling, Bill Gates, Linus, Bjarne, Larry Ellison, Uncle Bob, Martin Fowler, and Gavin King all have in common?

These are all graphs I produced with the book's samples.

They all know how to produce compelling presentations. While some of the above are good programmers (even excellent ones), we don't know of them because of that. We know of them because they influence our thinking. Every programmer who advances through the ranks eventually gets to the point where they need to influence people as well as sling code. (It's all about scalability. One person can only do so much-- but if that one person can effectively influence a group of others-- then the reach of that coder is greatly expanded.) So too it should be with you-- you need to learn how to produce artifacts that will influence people and bolster your arguments.

To that end, I am really pleased with "R Graphs Cookbook" by Packt. If you haven't used R yet-- regardless of whether you read this book or not-- you need to download this excellent open source statistical package and get yourself acquainted. Search this blog for examples, I've posted a few. R makes statistics easy, and statistics can lend assistance to everything from log analysis to garbage collection optimization. This book is about R's excellent graphical capabilities, though.

This book doesn't teach R, and it's target audience is an experienced R programmer. I really think even an R novice could use this book to produce impressive graphs, though-- each recipe is very short and shows what's needed to produce the graph you're after. By the way, I think one of the best parts of this book is the available source code-- you don't even have to type in the examples, and the sample data is invaluable. By the way, studying the way the data is structured is highly educational. I'd strongly recommend examining the data with each recipe to maximize your learning.

The book teaches you how to draw all kinds of graphs: scatter plots, line plots, pie graphs, bar charts, histograms, box and whisker plots, heat maps, contour maps and regular maps. The 'regular maps' covers maps of the world, a country, a state, etc.

If I had a wish to improve this book, I'd wish for a comprehensive index that covers every page where a specific function or argument was used. Sometimes functions are demonstrated in one graph recipe that could be useful in making a different kind of graph-- but if you don't know where to look for the example, it could be difficult to find. It's an omission I can live with, though.

This book will get a spot on my reference shelf. For those occasions where I need to produce the proverbial picture worth a thousand words, I know where I'll reach.

The book can be found here.

Happy Graphing!

Visualizing a Log's Timeline (without going blind reading text)

2011-04-07T21:14:00.005-05:00

How to Visualize a Log Timeline

Have you ever tried to read a massive log file? It can be difficult. Logs from multithreaded servers (or worse, clusters) can be miserable to work with. Sometimes a little visualization can help.

Log reading in small single threaded applications is easy. You just read through the log until you see the ERROR, then back up from there to see what went wrong. But what if your server is multithreaded? Then it gets a little more difficult. Or if you're dealing with distributed components like messaging servers and users of those servers. Things can also be ugly there.

Sometimes it's just fun to visualize data, looking for patterns. So how can you do this easily? I like to use R.

Let's take an example. Say you're working with JBoss AS 7, and your log looks something like this:

2011-03-20 21:22:38,854 DEBUG [org.jboss.logging.Log4jService] Installed System.out adapter

2011-03-20 21:22:38,855 DEBUG [org.jboss.logging.Log4jService] Installed System.err adapter

2011-03-20 21:22:38,859 DEBUG [org.jboss.logging.Log4jService] Added ThrowableListener: org.jboss.logging.Log4jService$ThrowableListenerLoggingAdapter@1815338

Pretty dry, right? Working with this log, I'd probably go about visualizing it by computing 2 fields and extracting one for convenience:

A timestamp field, formatted so it's easily sortable. You probably could do this in R, or even with shell script utilities, but I took the easy road for this one and used python to work my log for me.

A numeric value that maps to the log severity. 0 for 'TRACE', 1 for 'DEBUG', and so on for INFO, WARN and ERROR.

For readability, I also extracted the text value of the log level. Shame on me for carrying duplicate data, but it makes the extract file more convient to read.

So the first 4 lines of my extract file look like this:

TimeStamp LogCode LogLevel

76958854 2 DEBUG

76958855 2 DEBUG

76958859 2 DEBUG

The header line is necessary for the R script. I'm sure you would've figured this out, but the first field was calculated by taking the 'hours' value (21 in the first line above) and multiplying it by 60 * 60 * 1000. That was added to the 'minutes' value (22 above) by 60 * 1000. That was added to 38 * 1000, and that was added to 854. As I said above, python works great for that. If you're able to do that quickly in a bash script, my hat's off to you.

But I digress. So we've got our extract file, now to visualize it. Just run it past an R script that reads something like this:

logData <- read.table("my3FiledExtractFile.txt", header=TRUE)

summary (logData)

png("Graph.png", res=200, height=1200, width=1200)

plot (jitter(logData$TimeStamp), logData$LogLevel,

col="blue",

xlab="Time",

ylab="Log Level", yaxt='n')

axis(2, c(1, 2, 3, 4, 5))

rug(logData$TimeStamp)

dev.off()

q()

First, the summary() output will provide you with some interesting statistics:

summary (logData)
   TimeStamp           LogCode       LogLevel    
 Min.   :76958854   Min.   :2.000   DEBUG:31126  
 1st Qu.:76997498   1st Qu.:2.000   ERROR:   61  
 Median :77043075   Median :2.000   INFO :  647  
 Mean   :77096907   Mean   :2.027   WARN :    7  
 3rd Qu.:77236122   3rd Qu.:2.000                
 Max.   :77320903   Max.   :5.000

So in an instant we can see what's in this log we're dealing with. But that's not the visualization we're looking for, that's what we see below.

Isn't that cool? We can see we start out with a bunch of DEBUG messages (the heavy line at the bottom), then get our first WARN (the lonely first dot on level 3) , a bunch of more DEBUGs, a bunch of WARNs and then our first ERROR. The timeline reads from left to right, the error levels progress upward for the various levels.

I think data visualization is cool, and I intend to learn more about it to help me draw information from raw data sources. To that end, I've been working with Packt's "R Graphs Cookbook", and will provide a book review here soon.

Happy Visualizing!

Book Review for Android User Interface Development: Beginner's Guide

2011-03-18T21:04:00.002-05:00

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

This book teaches Android UI development in Packt's 'Cookbook' style. The book is written in a very understandable way, yet still teaches good UI design in reasonable depth. It covers technical aspects of UI development (use of widgets, themes, animation, styling) as well as development practices (how to validate input).

If you haven't seen a Packt Cookbook yet, it's a book primarily broken into recurring sections with titles "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.

Be aware this is not a book on Android development in the general sense. There is some introductory material here: installation and configuration of the SDK, a first rudimentary project, a little other ground-level material. But largely this book concentrates on UI aspects. To put that in context, if this were a book in the Enterprise Java workspace, it'd be entirely about JSF and have not much on EJBs or JMS. (I'm not sure if that's a good parallel, but I'm sure you get the idea.)

The sample code is well laid out and is structured in the same way the SDK examples are structured. (So if you're learning the basics of Android development by following the SDK doc, you'll be good with the book samples.) The topics chosen for inclusion in the book are a good representation of the kinds of UI issues an Android developer is likely to encounter. So what exactly can you expect to learn from this book? Here's an incomplete list, but one that shows the kinds of things that are covered:

- How to present a question to the user
- How to receive an answer
- How to handle list choices (multi-select? single?)
- Headers and Footers
- Making a photo gallery
- Handling Date/Time
- Layouts (Swing users will find this familiar)
- Validating inputs
- Animation
- Styling (i.e. changing a button's appearance)
- Application themes

If this list makes you think the book teaches a mix of programming skills and graphic design, I wouldn't say that you're wrong. (I've always been a programmer type, and never much of a polished UI presenter, so I learned some new things in the styling and theme categories.)

Who would benefit from reading this book? Android developers who want to write a professional looking application. If you're like me, your first instinct is probably going to be to just run out and read the SDK doc to hack together some sort of functional application. But if we want people other than ourselves to like it, then we'd better be sure it looks, feels, and acts like the user expects. That's the place where the book brings value-- teaching us how to make our Android apps pretty.

The book can be found here.

Happy (mobile) coding!

Win a year's worth of Packt e-Library

2011-02-16T20:05:00.002-06:00

Just a quick note tonight to pass along some news from my friends at Packt.

This month is IBM month at Packt-- books are offered at a discount, and every Tuesday they offer a chance to win a year of PacktLib. Wouldn't that be great!

If you're using IBM products, give it a look!

IBM Tuesday can be found here.

The Tuesday competition can be found here.

Happy Reading, and Good Luck!

Book Review for 'jBPM Developer Guide'

2011-02-12T15:34:00.002-06:00

jBPM is a mature and popular process management framework. This book can help you get beyond the basics so you can write useful real-world applications.

jBPM is a well established process management framework. BPM (Business Process Management) is a software discipline that allows a developer to build applications as a series of steps. Under ideal circumstances, designers drag and drop pictures onto a graph that later become a business process definition. The process centers around some business activity. For instance, an 'Expense Report' process might involve the steps: Gather expense information, Management Review, Approval/Denial branch and Produce check. Here's a sample picture to let you know what such a graph might look like:

jBPM is referenced in quite a few SOA books, and with good reason. It's a really good framework, and it's been in use for a lot of years, so it's feature rich and stable. jBPM can be used in a lightweight manner if your situation allows it (that is, just by including the right .jars, you can skip the designer part and in-line some XML in your application code. That's probably the lightest configuration, and the one many SOA books describe.) But what if you need to do some stuff not covered, like involve humans in the process?

Human interaction is a little trickier. With only automated activities, your BPM process can be handled something like b-flat BPEL. You can just describe the series of tasks (java classes and methods) you want to be invoked, and the framework executes them, bang, bang, bang. But what if you want someone to look at a web page and provide you some feedback? Now you're in the territory this book is covering. It goes beyond the basic usages, and tells you what you're really going to have to know.

You'd better be ready to download and read the book's source code, because without it you really won't get as much out of the book. The author includes and explains the relevant text in-line in the book, but you really need to view and understand all the pieces of the project to learn to piece together workable applications.

The book is true to it's title in that it is definately a developer's guide. The reader is coached through building their own Java-powered state machine in the early chapters, sort of a mini-jBPM. This is a good exercise, as it gives insight into how jBPM functions. Shortly after, the author introduces the development environment, which includes Maven and Eclipse.

The middle chapters deal with jPDL, which is the XML language that powers jBPM. The language is not complicated and the book does a good job of explaining it.

The final chapters work through case studies and explain persistence and enterprise features. Persistence is important because you'll want your business processes to maintain integrity through server recycles. Naturally, jBPM makes use of other parts of the JBoss stack like Hibernate, data sources, etc. so these are covered in sufficient detail for jBPM use.

So, what's my overall opinion of this book? I'd say it's a good resource, and would recommend it to anyone who's going to write a jBPM application beyond an example "Hello World". The book isn't perfect-- it's not written in an easy to read manner. (I suppose that's acceptable, given this is a book for developers.) This book was written near the end of life for jBPM, which will be JBoss's final supported version for a while yet as the next supported version will be based on the brand-new jBPM 5. (Which is quite a change from jBPM 3, by the way.) If you are going to use jBPM 3 (and there are a lot of good reasons why you should), this book is worth the price.

The book can be found here.

Happy Reading!

Book Review for "OSGi and Apache Felix 3.0 Beginners Guide"

2011-01-15T19:24:00.001-06:00

Book review for "OSGi and Apache Felix 3.0: Beginner's Guide"

This book promises to bring a developer from level zero through advanced usage of Apache Felix, a pretty ambitious goal. Before we get into how well it delivers, let's talk a little about what OSGi and Felix are.

OSGi is a specification meant to save Java developers deployment and classpath headaches. If you've ever used Eclipse, you have used OSGi, albeit as a user. OSGi is bigger than just Eclipse, though-- it's the basis for a whole new class of frameworks, and it's got buy-in from the guys at JBoss, Spring, Apache and others.

OSGi is meant to alleviate classloader headaches. It helps keep your deployments clean, allowing you to run application that have dependencies on libraries that might differ in version from what other deployments need. In other words, you can specify exactly which libs you need, and which versions, and OSGi will manage keeping all the applications happy.

This book teaches Apache Felix, which is a pretty mature OSGi implementation. The cruxt of the book is building, then improving a simple bookshelf application. Maven2 is used for the build duties, and the author is very generous with providing instruction about how to build your .pom files each step along the way.

Felix (and OSGi are much more than just a runtime container, though. Felix contains lifecycle startup mechanisms, so these are taught. You're also given a whole chapter on the shell language Felix provides for control functions.

Beyond that, it's mostly application development done the Felix way. Even tasks as mundane as logging are different under OSGi, and this book gives insights into all the nooks and crannies you'll need to implement the bookshelf application. (Note: I'm sure EVERY nook and cranny isn't explored, but if you follow the clear instructions this book provides you'll end up with a running application.) The book leads you through an incremental buildup of the app, so you'll add functionality bit by bit as you improve the application.

The book ends with a nice-to-have chapter on troubleshooting and a few quick write-ups on the dev environment (Maven and Eclipse) and other topics that should be within reach for the reader.

So, what's the verdict? OSGi coding is not trivial, and isn't something to be taken up lightly. (It's yet another Java framework to be embraced, complete with it's own set of twists and turns.) If you're going to learn it, though, this book is a very good from-the-ground-up resource to guide you completely through the learning process. So if you're going the OSGi path, this is a good place to start.

The book can be found here.

Happy Reading!

Packt begins publishing Microsoft books

2011-01-07T19:01:00.003-06:00

Hi all,

I like to review technical books, and I have reviewed plenty of them from Packt Publishing. Packt has always been a good provider of material on Open Source topics, but has recently branched out and is now offering Microsoft titles as well. Enclosed is a brief press release from the folks at Packt, for the benefit of MSFT readers.

Happy reading, and good luck in the Monday drawings!

Rick

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

On Monday the 24^th January, 2011 Packt Publishing is issuing five brand new Microsoft Books on a range of different subject matters:

Microsoft SQL Server 2008 High Availability
Microsoft Application Virtualization 4.5
Microsoft Forefront UAG 2010 Administrator's Handbook
Dynamics AX 2009 Administration
Microsoft Dynamics Sure Step 2010
(Microsoft SharePoint 2010 Administration Cookbook)

With five Microsoft books published at the end of 2010, the publication of a further five new books all on one day reiterates Packt’s commitment to producing specialist Microsoft book titles, and signifies their position as a top Microsoft publisher. James Lumsden, the Packt Enterprise Publisher states that “serving the needs of Microsoft professionals is one of our top priorities at Packt, and 2011 promises to be a bumper year. What better way to kick off the New Year than with five exciting new titles on Microsoft Monday! As always we want to do our utmost to serve you, the reader, so please email us if you have book ideas, general suggestions, or if you just want to offer some feedback. Have a great 2011”.

To mark this milestone Packt is also offering a 25% discount when you purchase two or more Microsoft books throughout January. And will be running a competition throughout January offering customers the opportunity to win a free 1 year’s subscription to PacktLib every Monday throughout January.

For further information on this, and other books published by Packt Publishing, please visit this link.

OSGi book preview and press release

2010-12-31T09:34:00.002-06:00

I'm currently reading (and will soon provide a review for) the new OSGi / Apache Felix book from Packt.

If you've never heard of OSGi, the following press release about the book might help provide some idea what it's all about. Here's the release:

Build your OSGi applications using Packt's new Apache Felix book

Packt is pleased to announce OSGi and Apache Felix 3.0 Beginner's Guide, a new book that will help readers to build their very own OSGi applications using the flexible and powerful Felix Framework. Written by Walid
Joseph Gedeon, this book will assist readers to get acquainted with the OSGi concepts in an easy-to-follow manner and build a completely operational real-life application using Felix.

Apache Felix is an open source implementation of the OSGi Release 4 core framework specification. Furthermore, the OSGi specifications originally targeted embedded devices and home services gateways, but they are ideally suited for any project interested in the principles of modularity, component-orientation, and/or service-orientation.

OSGi and Apache Felix 3.0 Beginner's Guide starts off with an introduction to the OSGi Service Platform, its parts and its bundle structure. It then walks users through setting up the Felix framework and their development environment. Additionally, this book explains the operation of the Felix Framework by means
of Gogo and teaches users practical implementation of OSGi, OBR repositories, dependency management, and bundle version management.

Using this book, developers will be able to discover the practical implementation of important OSGi concepts, understand the use of Maven to build and deploy OSGi bundles, create an OSGi-compliant application, learn the implementation of JSP Web Application Bundles, dive deep into Felix iPOJO, get an overview of the Felix Web Management Console and learn to troubleshoot an OSGi application with ease.

A relentlessly practical beginner's guide with step-by-step instructions, this book is ideal for Java developers, who wish to learn about writing reusable and network distributable software following the OSGi standards using the famous Felix framework. The book is out now and available from Packt. To read more about it, please visit: www.packtpub.com/osgi-and-apache-felix-3-0-beginners-guide/book

Well, there's the preview. Watch for a review in the near future!

Happy Holidays!

Pythonistas -- Packt books discounted this month!

2010-12-22T20:02:00.002-06:00

Hi all,

Just a quick note for the Python fans-- I've just been informed by my friends at Packt Publishing that they're holding a special on Python books.

Through the month of December, all books and e-books are offered at discounts of up to 30% off.

More details are available here.

Python is a great language, so go buy yourself a Christmas book if you need one!

Happy e-shopping!

Coming Soon: Apache Felix & jBPM

2010-12-21T21:00:00.008-06:00

OSGi is an interesting topic. Application server vendors and near-application servers like Spring are making provisions for it in their future offerings. Apache is helping lead the charge with Felix, an open source OSGi implementation. I hope to soon review a new book on the basics of OSGi, "OSGi and Apache Felix 3.0 Beginner's Guide" from Packt. Watch this space for a review in the near future.

Another interesting topic is Business Process Management. I've worked around this one for many years, and have at times used JBoss's JBPM product for my tasks. I look forward to reading another Packt title, 'jBPM Developer Guide', which promises to hold some good tips for optimal jBPM development.

BTW, how about that crazy upper/lower-case letter treatment for these two books? Totally coincidental!

The OSGi book can be found here.

The jBPM book can be found here.

Book Review for "Jboss AS 5 Performance Tuning"

2010-12-18T13:14:00.003-06:00

Let me make one recommendation, right off the bat. Do not pick this book up in the book store and page through the first chapter and a half before putting it back on the shelf. If you do that, you'd miss out on what is perhaps the best contemporary JEE tuning book in existence.

The first 50 pages are a little slow. Mostly they cover the author's recommendation for a performance tuning lifecycle, and a handful of open source tools that can be used to assist with performance tuning. The tools section in particular might lead you to believe the book is light on content-- there are plenty of big screenshots that show you things you could have picked up from the tool's website. But once you're past the tools section, the fluff ends there. What lies ahead is pure good stuff, and it will lead you from the O/S clear through the application server and into the application code.

The author has a clear bias towards Linux in the writing, but does include some Windows-centric advice in places. One constant throughout the book is the use of before/after metrics (captured with JMeter, as you are likewise taught to do) to demonstrate the effect some tuning tweak has had. This is consistent with the stated philosophy of basing things on hard data, not seat-of-the-pants observations. There are plenty of graphs pulled straight from JMeter, which is consistent with how the author recommends we go about measuring progress. Clearly, this guy believes in the methdology he suggests we use.

As the title suggests, the book deals mostly with JBoss AS 5 specific tuning recommendations. That doesn't mean that's all you get, though. Nearly everyone should benefit from the O/S advice, and Java users will benefit from a whole chapter on JVM tuning. Tomcat and Apache users will find many good tips in the latter chapters.

The book is sliced into layers, as code hosted on an application server would be. There are sections on the web layer, EJBs, JMS, ORM (including some good parts about Hibernate, with cache tuning) and cluster tuning. There are separate sections for web frameworks and web service based applications, too. Each of these sections tells you enough about that particular domain to let you know what you want to optimize and how to optimize it. Don't get me wrong-- there's not enough here to make you a clustering expert, for instance-- but there is enough here to let you know how to tune clustering once you've referred to other doc (i.e. the app server doc) and have something ready to run.

Basically, the book addresses nearly every aspect of what can be tuned and optimized, including in-line recommendations about how the application code should be written.

So, who would I recommend this book for? Here's my list:

- Anyone running JBoss AS 5 (Strongly recommend.)

- Developers writing JEE applications (Recommend. The JVM and O/S sections alone will be good, and other sections lend insites into how JEE application servers work. Tomcat users would benefit, too.)

- Java developers (Weakly recommend. The O/S and JVM sections are worthwhile, though.)

As for me, I work with JBoss every day, so I'm going to give this one a second read immediately. That's some of the strongest praise I've got to give.

The book can be found here.

Happy reading, and happy tuning!

Rick

JBoss Performance Tuning Book is out!

2010-12-09T20:35:00.004-06:00

The much-anticipated JBoss Tuning book is available now, and my copy is in the mail.

The book is authored by the same guy who brought us the JBoss 5 Development book, which I liked, so I look forward to reading this one.

Watch here for a review soon, else buy your copy today here.

Happy Reading!

Training Review: JB325, JBoss for Advanced Developers

2010-12-09T20:16:00.004-06:00

Disclaimer: I work for JBoss, but I do not work for the training department, nor am I trying to sell you training. I'm just trying to let you know about a worthwhile class you can attend.

I've just finished JB325, a four day live-instructor class. It was an intense 4 days. Roughly, here's what was presented:

JBoss architecture
The inside scoop on how the JMX microkernel and POJO microcontainer act as the framework upon which all the running parts of JBoss are placed. (Hint: you can change it all, through configuration files!) We learned the startup procedure and main abstractions involved, as well as important stuff like classpath isolation techniques. (Experienced JEE developers will probably recognize the need for these.)

AOP, Invokers, Interceptor stacks
Several times we discussed AOP in JBoss and the way chain-of-command is used to build stacks of interceptors used throughout the architecture. The 'Invoker' concept was also thoroughly explained.

JCA, DataSources, and Transactions
Valuable especially in preparing databases and JMS providers for use.

JBoss Cache, Clustering, and JGroups
Clustering is easy with JBoss, right out of the box. This section of the class showed us how it all works and how you can exploit the individual parts if you'd like.

Performance Tuning
This part alone made the class worth attending. Java performance tuning knowledge is always useful, we got some great tips here. (By the way, have a look at the blog post about the new JBoss tuning book.)

Security
As it applies across all the tiers.

Messaging
JBoss Messaging, how it's configured, and how it's used.

Student workstations were provided. Students were given the software (including the IDE) and were required to configure their own environments. Labs were challenging-- sometimes there were some easy parts, sometimes there were significant challenges.

Lunch was provided and was delicious every day. (Not relevant, I know. But if I were shopping around for a class, I'd want to know!)

The bottom line: I recommend this class to anyone using JBoss that's got a handle on application basics already. If you're not sure what goes into a .ear, you're probably not ready yet. But if you've done your share of development on the 'Boss already, you'd probably like this one.

Happy learning!

The 'Other' Erlang book

2010-12-04T08:54:00.002-06:00

Manning has just released a new Erlang title, called 'Erlang and OTP in Action' (available here). 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 covers 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. In my opinion, chapter 1 had some slow spots, but not unbearably slow. The language chapter is good, in some places better than Joe's book. The rest of the section is informative and well written. 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. Topics like logging and event handling are given a chapter, as is the topic of distributed computing in Erlang. The final chapters of the section cover Mnesia (the Erlang distributed database) and packaging considerations.

Chapters in section 2 generally introduce some high level concepts at the start of the chapter, then weave use of these mechanisms into the application-building storyline, finally providing code that brings the desired functionality into the ever growing demonstration application.

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 considerably 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 is written with easy-to-understand anecdotes that help the reader grasp the finer points of Erlang craftsmanship. You definitely 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 refer the reader to other Erlang books they may wish to read, and include several mentions of Joe Armstrong, 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. I would recommend this book to any Erlang programmer.

"Erlang and OTP in Action" can be found here.

Happy Reading!

Prestashop wins Open Source Award

2010-11-16T12:40:00.002-06:00

Another open source award-- congratulations to the winners!

Packt Publishing is pleased to announce that PrestaShop has won the inaugural Open Source E-Commerce Applications Award category in the 2010 Open Source Awards. Open Source E-Commerce Applications Award is a new category introduced to the Award this year, featuring various different types of type of web applications that simplify buying and selling of products on the Internet.

“This award is a great recognition for PrestaShop's hardworking team and, of course, the contributors who help us enrich our software every day,” said Bruno Lévêque, PrestaShop Co-Founder.

“We are glad to have received this award from both a panel of expert judges and our growing Community -whose members increased threefold in the past year! They have really mobilized to support our project,” adds Sabrina Maréchal, Head of Marketing & Communications for PrestaShop.

“PrestaShop have achieved a lot in a short period of time considering that it is a community driven project, with the product maturing steadily and in a way that will stand the test of time.” Added Paul Anthony, bespoke e-commerce solutions developer and one of the judges for the 2010 Open Source E-Commerce Applications category. “The structure of the product has also given rise to numerous creative implementations, and the community is large enough and responsive enough to cope with these requests for improvement.”

“Every day more than 40,000 merchants use PrestaShop to manage their online activity and we want to continually improve our software for them, as well as our future users and developers,” concludes Bruno Lévêque.

While PrestaShop occupied the top spot in the 2010 Open Source E-Commerce Applications category, popular shopping cart system OpenCart came in at the first runners up position, while the second runners up position was secured by TomatoCart.

With this announcement, the 2010 Open Source Awards has four more categories left, including the Open Source CMS category, for which results will be announced from November 17th through to November 19th.
For detailed results on each category and more information about the Award, please visit: https://www.packtpub.com/open-source-awards-home.

Happy Open Sourcing!

Pimcore Wins the 2010 Most Promising Open Source Project Award

2010-11-15T07:00:00.001-06:00

As a service to the open source community, I'll post awards from the 2010 Open Source Awards this week. Here's the first winner, as seen in Packt's Press Release:

Packt Publishing is pleased to announce that Pimcore has won the Most Promising Open Source Project Award category in the 2010 Open Source Awards. The Most Promising Open Source Project Award, sponsored by OpenCandy, is a revamped category for the Award this year, featuring Open Source projects, whose first release date is less than two years from 9 August, 2010.

“Winning this Award is a huge boost”, said Dietmar Rietsch, the founding member of Pimcore. “It’s not simply about the money either, it’s the recognition of a year of hard work and dedication from the team and Pimcore’s community.”

“Pimcore is an exciting content management system framework which has great long-term prospects. The project is growing at a fast rate and has good support from its community.” Added Marc Delisle, system administrator and one of the judges for the 2010 Most Promising Open Source Project category. “Pimcore is an easy to use new solution and a high sense of professionalism can be found in everything from the project website to the documentation.”

While Pimcore occupied the top spot in the 2010 Most Promising Open Source Project category, TomatoCMS came in at the first runners up position, while the second runners up position was secured by social networking software package BuddyPress.

With this announcement, the 2010 Open Source Awards has five more categories left, including the Open Source Graphics Software category, for which results will be announced from November 16^th through to November 19^th.

For detailed results on each category and more information about the Award, please visit: https://www.packtpub.com/open-source-awards-home

Book Review: "NHibernate 3.0 Cookbook"

2010-11-13T23:07:00.003-06:00

Are you a .Net developer looking for a way to persist complicated object graphs in your applications? If so, I've got a book you might want to take a look at: Packt's "NHibernate 3.0 Cookbook".

The book is written in Packt's 'Cookbook' style, which means it's really a series of short sections that guide you through achieving some goal you want to accomplish with NHibernate. Each section follows a template, with sub-sections "Getting Ready", "How to do it", "How it works", "There's More".

Let's take an example, say "Configuring the Cache". You may not yet know why you would want to configure cache for NHibernate, but you have a look at that section in the book.

- 'Getting Ready' tells you which artifacts you have to download and how to set up your machine

- 'How to do it' tells you which files to open and what to edit, which buttons in your IDE to click, and which scripts need to be run.

- 'How it Works' at last tells you why the actions you have been taking will be effective. This is the 'theory' that tells you how NHibernate works and why you might want to undertake the task you're currently engaged in.

- 'There's More' is yet more material related to the task in some way. In the cache example, this might be some text about how the cache fits in NHibernate, how you can read it or externally affect it, and other material that's a tangent to your task.

So what exactly is covered, in this decidedly hands-on style? Plenty. You get:

- Models and Mapping (sort of basic Hibernate theory)

- How to manage your schema and the parts that reference it

- Sessions and Transactions-- very important for enterprise applications!

- Queries using NHibernate

- Testing with NHibernate

- Data Access Layer concerns

- Extending NHibernate

- Other NHibernate related projects

Embedded in each of those topics (mostly within the 'How it Works' sections) is a lot of valuable advice about transactional applications in general. Any reader can gain some insights from those.

All things considered, I'd recommend this book to any .Net developer who's interested in using NHibernate. There is much good advice here that can be applied in a variety of situations.

The book can be viewed here.

By the way, the folks at Packt have passed along a couple of other items that might be of interest:

1) The results of the 2010 Open Source Awards are nearly in, they will be announced daily by category starting next Monday. As a professional open source advocate, I'll be happy to pass those results along as they are announced.

2) As a SOA practitioner, I have a respect for the IBM suite of products. (Though I do have to admit I'm partial to JBoss' offerings, as they pay my salary!) But if you're an IBM fan, Packt has a special deal this month on their products. See the details here.

Happy Reading!

Book Review: "Spring Dynamic Modules in Action"

2010-11-13T22:43:00.002-06:00

Book Review: "Spring Dynamic Modules in Action"

First, let me start with a strong statement: This book is going to be the definitive book on Spring DM, period. Users of Spring DM need to rush out and buy a copy, for this book is a reference that will save countless hours and loads of headaches. The authors (there are 3) have clearly travelled many miles with Spring DM, and their experience is laid out plainly for you to purchase for the measly price of a book. My only caveat: be sure Spring DM is the right tool for the problem you want to solve, for there is some work ahead of you. If you are certain it's the right technology, then this is without question the book you need.

Quick explanation for those unfamiliar with Spring DM and OSGi:

OSGi is a specification meant to help Java be more 'modular' and to help solve classpath issues. OSGi lets you specify, via properties in a manifest file, exactly which versions of which library you want your library to use. (You can even have two versions of the same library in use at the same time in your container!) Spring DM is a framework for integrating OSGi with Spring and a selection of it's sub-projects.

Roughly, here's what you can expect from the book:

- 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

- 500+ pages of advice that will keep your journey with Spring DM clear of potential pitfalls

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.

So, a final wrap-up: Spring DM users need to buy this book. It will be worth the cost many times over!

The book can be found here.

Happy OSGi-enabled development!

4 tips to get your support ticket worked pronto!

2010-10-30T08:12:00.003-05:00

Isn't software support great? It's one of the few ways possible to make your problem someone else's! But when you've got one of those problems, you usually want it to be worked ASAP. Here are 4 tips to help your ticket go through as quickly as possible.

1) Have your artifacts handy

By 'artifacts', I mean logs, core dumps, mangled transaction prints, etc. If these things are not attached with your original ticket, there's a pretty good chance your first contact from the support engineer will be a request for you to go get them. Meanwhile, while you're off gathering those things your engineer isn't idly standing by-- he's off working another ticket! When your artifacts finally come in, the engineer may or may not be ready to put down that second ticket, you may have to wait. Avoid the asynchronous wait time associated with this first exchange-- provide them in the first place.

2) Open the ticket at the appropriate level of severity

Most ticketing processes involve a user-defined 'level' that indicates how important the ticket is to the holder. (Usually severity 1, or 'sev one', is the highest.) It's tempting to mark every ticket you enter as a sev one, but guess what happens if your development-environment problem isn't really the production-crash that sev one defines? (Check your support agreement to see what the definitions are.) Your ticket will be examined, re-prioritised, and put in a lesser queue. So you lose time 'till that first evaluation, your ticket is delayed going into the proper queue, and you may establish a reputation as a less-than-honorable ticket opener. (That last one is a bad one. Read on....)

3) Playing nice pays off

Often times there are more tickets than support engineers available, which means sometimes the engineer gets to decide which ticket to work first (all other things, like severity, being equal). In situations like these, the 'tone' of the ticket can make a difference. A polite and professional ticket tells the reader that the sender is a savvy user that's ready to collaborate and address the issue. On the other hand a defensive or accusatory note might signal an uncooperative sender. Which would you rather work first?

4) If at all possible, replicate the problem in a minimal environment

This is a big one-- if at all possible, encapsulate the problem in a minimal environment and attach it to the ticket. If your problem lies in a Spring application, isolate the offending components and attach them with an application context to run them. If it's a problem with JSF, build the smallest .war possible that shows the problem and attach the artifacts necessary to build it. It's not always possible, but when it is possible this really helps the engineer! Your ticket will be promptly picked up, and the problem will be put under the best microscopes the engineer has available.

That's it-- follow those 4 steps and your ticket will proceed at max speed.

Happy ticketing!

ORM the Hibernate way -- on .Net!

2010-10-28T21:00:00.004-05:00

I've been a casual user of Hibernate in my Java applications for a long time, but have never gotten around to using it's .Net cousin, NHibernate. Now I've got a reason to finally give NHibernate a look!

Packt has just released a new book, "NHibernate 3.0 Cookbook", described here. The book promises to teach the full range of features available and looks to be an easy read. It's a Packt "Cookbook", which means the book will be presented in a series of 'How To' episodes written in a consistent format. These books emphasize practical application over deep theory, so I have high hopes I'll be rapidly developing database-backed applications in .Net not long after cracking the cover. (Time will tell. I'm waiting for my copy to arrive in the mail.)

Watch these pages for a review sometime soon.

Meanwhile,

Happy Coding!

How to find which .jar a class is in (easily)

2010-10-23T08:36:00.005-05:00

Along with the many blessings a high level language brings you are a few curses. In Java's case, one of the biggest downfalls is the dependency graph your code becomes part of as you develop applications. This is especially noticeable when you're using frameworks like JEE or Spring.

A Java developer feels this pain in a couple of ways:

- Compile time, manifested with errors such as "(ClassName) cannot be resolved to a Type" or "The import some.class.SoughtFor cannot be resolved".

- Runtime, where the errors will show themselves with messages like the all-time favorite "java.lang.ClassNotFoundException".

But what if you had a report like this? Wouldn't that be nice?

So what do you do then? Many coders start by trying to guess which .jars hold the missing classes, then add them to the classpath one by one. This can be an exercise in frustration, as often times .jar names give you little clue as to which classes are inside.

A second methodology developers sometimes use is the 'throw everything but the kitchen sink at it' approach, where they build huge classpaths loaded with every .jar they can find. This inexact coping mechanism obviously leads to bloat.

But wait! There is an exact way to cure the problem, and it's easy and open sourced! Here's how to do it:

1) Download and unzip JBoss Tattletale. It can be found here.
2) Make a run script for Tattletale.
3) Run the run script.
4) Read the report Tattletale makes for you. It's that easy!

The script is easy to write. It takes the form 'java -jar tattletale.jar DIRECTORY_TO_RECURSIVELY_SEARCH DIRECTORY_FOR_REPORTS.

Here's an example:
java -jar tattletale.jar /home/rick/Tools/JBoss/jboss-5.1.0.GA /home/rick/rpts

Then you just go to the reports directory and view the index. To find your classes in .jars, have a look at the 'Class Location' report. It'll tell you which jar holds the missing classes!

Tattletale has many more capabilities, which are well documented in the packaged docs. I hope you'll find this tool useful in your day-to-day development work.

Happy Coding!

Solve your Java runtime mysteries easily with Byteman

2010-10-09T09:02:00.006-05:00

Have you heard of Byteman? It's sort of like AOP-lite. With a small script and a lightly doctored startup command, you can have x-ray vision into your Java applications. You don't even have to alter your source code, and it's easy to use.

Here's a quick example. Let's say we have a Java application where some method is called at some point, and you want to know when that method is called and what's being passed to it.

So let's say we have an application that provides this output. (I'll show you the source code in a bit.)

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

Suspects about to do stuff!

Thump! A murder happens!

Suspects done moving around!

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

Well, we don't know much about who committed the crime, do we? (In fairness, we don't even know who the suspects are yet.) But how about if you had the source code? Then could you tell? I doubt it. Here's the source:

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

public class Clue {

private void makeMystery(){

List suspects = new ArrayList();

suspects.add("Colonel Mustard");

suspects.add("Mr. Green");

suspects.add("Miss Scarlet");

Random gen = new Random();

// determine the killer!

int theKiller = gen.nextInt(3);

System.out.println("Suspects about to do stuff!");

for (String suspect : suspects){

walkThroughKitchen(suspect);

// maybe commit the crime!

if (suspect.equals(suspects.get(theKiller))){

commitCrime(suspect);

}

walkThroughLibrary(suspect);

}

System.out.println("Suspects done moving around!");

}

private void walkThroughLibrary(String suspect) {

// walks through...

}

private void commitCrime(String suspect) {

System.out.println("Thump! A murder happens!");

}

private void walkThroughKitchen(String suspect) {

// walks through

}

public static void main(String[] args) {

Clue clue = new Clue();

clue.makeMystery();

}

I defy you to tell me who committed the crime! But with Byteman you can tell!

So let's set things up. Aside from downloading Byteman (found here), you need to do a few things.

Make your application into a jar (using jar -cvf someJar.jar *.class, perhaps). This is done as a convenience to make it easier to put on a classpath.
Make a Byteman script, telling it what you want to see.
Make a command-line script to invoke your application.

Step 1 should be familiar to most Java coders.

Step 2. For the above class, let's make a script like this:

 # clue_script.txt  -  A simple script to intercept calls to a method
 #
 RULE Simple byteman example - watch a method
 CLASS Clue
 METHOD commitCrime(String)
 AT EXIT
 BIND THE_MURDERER = $1
 IF TRUE
    DO traceln("Caught the murderer!  It was " + $1)
ENDRULE

Step 3. Add the necessary agent to your startup shell script.

java -javaagent:/home/rick/Tools/Examples/Byteman/byteman-1.3.0/lib/byteman.jar=script:clue_script.txt -classpath clue.jar Clue

Now when we run the script, we see this:

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

Suspects about to do stuff!

Thump! A murder happens!

Caught the murderer! It was Colonel Mustard

Suspects done moving around!

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

There we have it! Byteman has let us find out which arguments were being passed to that method, and we did it without altering the source for the application, without attaching a remote debugger, and without much trouble.

Byteman can do much more, though. It can provide stack traces on demand, it can inject faults for testing and other neat tricks. Best of all, it doesn't cost anything. Check it out today, here.

Happy Inspecting!

Voting now open for 2010 Open Source Awards

2010-10-02T05:50:00.003-05:00

The nomination stage is now closed and voting has begun in the 2010 Open Source Awards.

Your vote could reward an open source project with cash awards (I know the developers will appreciate that!) Registering to vote will require your name and email, and it's a single button click to cast your vote.

Here are the finalists, in categories:

Open Source CMS Award

Every Content Management System (CMS) that is based on one of the Open Source licenses is eligible to participate for this category. Vote for your favorite Open Source CMS here.

Finalists:

CMS Made Simple
MODx
mojoPortal
SilverStripe
XOOPS

Hall of Fame CMS

This category is reserved for those CMSes that have won the Overall Open Source CMS Award at least once in the past. Since the launch of the award in 2006, only Joomla!, Drupal and WordPress have won the Overall Open Source CMS Award, therefore, this category will feature only those three participants in 2010. Vote for your favorite Hall of Fame CMS here.

Finalists

Drupal
Joomla!
WordPress

Most Promising Open Source Project

This category is for all Open Source projects, whose first release date is less than two years from 9 August, 2010. Vote for your favorite Most Promising Open Source Project here.

Finalists

BuddyPress
LiveStreet CMS
Pimcore
Tomato CMS
WolfCMS

Open Source E-Commerce Applications

This category is reserved for the type of web applications that simplify buying and selling of products on the Internet. This will include complete e-commerce applications or frameworks designed for e-commerce. E-commerce modules or extensions to other systems can also be nominated. If a system is general purpose (like a CMS such as Drupal or Joomla!) the specific e-commerce functionality should be nominated, not the base system.Vote for your favorite Open Source E-Commerce Applications here.

Finalists

Magento
nopCommerce
OpenCart
PrestaShop
Tomatocart

Open Source JavaScript Libraries

This category is reserved for JavaScript libraries, libraries of pre-written JavaScript controls which allow for easier development of RIAs (Rich Internet Applications), visually enhanced applications or smoother server-side JavaScript functionalities.Vote for your favorite Open Source JavaScript Libraries here.

Finalists

Dojo ToolKit
Ext JS
jQuery
Mootools
Raphaël

Open Source Graphics Software

This category, as the name suggests, is for all Graphic Application Software that is used for graphic design, multimedia development, specialized image development, general image editing, or simply to access graphic files. It can also include graphics libraries, which use command line references or programming language inputs to design or edit graphics.Vote for your favorite Open Source Graphics Software here.

Finalists

Blender
Gimp
InkScape
jMonkeyEngine
Scribus

Happy Voting!

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

2010-09-13T17:06:00.006-05:00

Business Rules Engines are a curious thing. For years they've been promising to ease the burden of writing and maintaining business logic, yet they never quite seem to live up to the promise. Want to give one a try? Let's have a look at a prominent Open Source BRE (Drools) as guided by this book from Packt.

The book starts out simply enough, with the first chapter introducing the idea of a BRE and the second covering rule authoring basics. From there, the author launches into building a banking application.

Chapter 3 is the 'Validation' chapter. This is a natural strong suit for a BRE, as they favor 'if/then' (or, as this author writes, 'when/then' logic). The author does a good job of introducing necessary parts of the Drools infrastructure, i.e. the 'rule context' which is useful in taking action when some condition exists.

Chapter 4 is about data transformation, it's not a far leap from Chapter 3. I think this was somewhat imaginitive on the author's part, as XSLT or a tool like Smooks tends is probably a better choice for transformation than a BRE would be. This book is all about Drools, though, so it makes more sense to do it this way.

Chapter 5 is the 'DSL' chapter. Rules tend to look a little awkward to coders unaccustomed to seeing them. A good example might look like this:

when

$customer : Customer (balance <>

then

$customer.setMinBalanceWarning();

warning (kcontext)

end

Instead of dealing with that kind of stuff, it's possible for some rules (if they fit a pattern) to be written something like this:

when

There is a Customer with a balance less than $200.00

then

Set the Minimum Balance Warning

Report this

end

Isn't that cool? It's really not all that mysterious, chapter 5 shows you how to do it. Warning: When managers see BRE marketing presentations, they sometimes watch something like this demonstrated and get all kinds of ideas about firing all the programmers and replacing them with business analysts. Rest assured, there is a programmer behind it all. (And a very skilled programmer at that. But this is for the rule practitioner to see....)

Chapter 6 covers stateful sessions, something that can be handy when your application doesn't experience big swings in the data it's crunching on. The author does his usual good job of providing an implementation, then some tests to prove the code. Once again, technical tidbits are introduced to the reader as they are needed.

Chapter 7 is about Complex Event Processing, somewhat a hot topic in today's Developer landscape. It's an interesting use case for Drools, so I was glad to see it.

Chapter 8 covers 'Drools Flow', which is one of the ways you can influence the order in which your rules are executed. To a garden-variety Java coder, this might seem like a strange statement-- how can you NOT influence the order in which your rules are executed? But that's the BRE way, and the author shows you one way to productively manage this 'feature' of the BRE.

Chapter 9 builds the Sample Application, which is the app that houses all the work done previously. It suffers a little scope creep, as the reader is expected to enclose their Drools work in Spring, Tomcat, etc. but I expect this won't be too much to ask of the type of reader who picks up this book.

The next chapter is about testing, always something nice to understand in whatever language or framework you're dealing with. Chapter 11 follows, that one covers integration issues. (Roughly, how do you take all your useful Drools code and apply it somewhere?) It's another nice thing to have spelled out.

The final chapter is on performance. It's a little funny because this final chapter enlightens the reader on the inner workings of the rule engine, something you might expect to see in the front of the book rather than the back. But it's good stuff, so I'm glad it was included.

There are 3 appendices, focused on helping with preparations for running the code the book provides.

So, what's the verdict? Here are the things I like:

- Gives some expert insights into how to write an application with a BRE

- Covers lots of the different facets offered by Drools

- Provides good explanations for technical tid-bits

Now for some dis-likes:

- Not enough guidance on best practices. Some are here, buried in the text, but you have to realize what you're looking at. The market really cries out for a book that explicitly provides these.

- Probably not enough to get a BRE newbie off the ground. Combined with the Drools user doc ('Cheese Shop'!) it may be enough.

- The author does a good job of using Drools for several purposes, but does not give the reader much guidance on when it really is smart to use a BRE and when it isn't. (There are plenty of places where it isn't-- I guess it's up to you to decide!)

All things considered, I liked the book. Next time I'm into Drools, I'm certain it'll be by my side!

The book can be found here.

..........

you liked this article

then

come back again another time!

end

Rick

New, less expensive Online Book Library available

2010-09-11T08:04:00.004-05:00

Are you familiar with online library services like Safari or Books 24 x 7? These are places where you can access large libraries of technical books online on a subscription basis. Now there's a new entry in the workspace for you to consider.

The newcomer is Packt's online library, found here. I've signed up for the free trial and can offer the following assessment:

I like the cost, compared to Safari or Books 24 x 7. Packt is a little less than $200 a year, where the others are right at $500.
The catalog size is less than what the competitors offer. Both Safari and Books 24 x 7 host titles from a list of publishers, where Packt is offering books from their catalog only.
With the trial account, you get access to 9 free titles. I don't have an interest in most, but there is a Plone development title there and one on Microsoft Live Small Office, though. I think those would be interesting.

Packt currently has over 400 titles available in the section you have to pay to see, and they do seem to include what I would consider the best books in Packt's arsenal. For those unfamiliar with Packt's publishing model, they are no longer focused entirely on up-to-the-minute open source topics. They've split their catalog into two sides, open source and 'Enterprise'. Enterprise includes things like Oracle's SOA suite, so you can see the distinction between the two.

I always think it's better for consumers to have more choices in almost any arena. Viva la competencia! (Long live the competition!)

'Till next time,

Happy Online Reading!

Book Review for "Plone 3.3 Site Administration: Manage your site like a Plone professional" by Alex Clark

2010-08-16T21:44:00.001-05:00

Book Review for "Plone 3.3 Site Administration: Manage your site like a Plone professional" by Alex Clark.

Are you a Plone administrator or content editor? If so, there's a new book from Packt that's worth your attention.

"Plone 3.3 Site Administration: Manage your site like a Plone professional" guides the reader through site installation and configuration of many useful add-ons. The tool of choice for a modern Plone site is 'zc.Buildout', and this book makes extensive use of buildout in each chapter as the author guides the reader from a basic Plone site to one well adorned with add-ons to enhance the appearance, functionality, and scalability of the site.

One thing I'd like to emphasize is that this book is all about configuration of these add-ons. As an example, the book will introduce the reader to some desirable non-standard bit-- let's say the Varnish HTTP accelerator-- and give step-by-step instructions on how to get Varnish downloaded and configured for your Plone site. What's missing is an overview of exactly what Varnish is. There are no diagrams and not much text explaining how it works. This pattern is repeated nearly everywhere-- you get the buildout configuration (and the response to expect when running buildout), but it's up to you to get your head wrapped around exactly what it is that you're adding to your site. I find this ok, given that the book is targeted to readers who are already site administrators and should recognize most of the products we're dealing with. (For the products that I didn't recognize, Google was able to round out my education, so I didn't feel slighted.) I did think this was an important thing to point out so a first-time reader of the book will recognize what's in store in this book.

There's a lot of good advice that's not Plone specific. Best practices regarding version control of configurations, database maintenance, database packing, and more are covered. These are the sort of thing that an experienced administrator will see value in, and a new administrator will appreciate having spelled out for them. (One way or another, new administrators will adapt policies like these. Maybe after reading some text and realizing the value, maybe after getting burned once or twice and learning it the hard way.) In that regard, even one of these tips is probably worth the price of the book.

I continue to be impressed by the Plone community and the effort they have put forth to build the impressive ecosystem around this impressive CMS. This one's for the admins, an audience that probably doesn't get as many books as they should.

The book can be found here.

Happy Administering!

Rick

2010 Open Source Awards now open

2010-08-09T21:15:00.003-05:00

Do you have a favorite open source project? Would you like to thank an open source provider in a tangible way? How about nominating them for the 2010 Open Source Awards, a contest put on by Packt Publishing that offers US $24K in cash awards?

Nominations are accepted this year for the following categories: Content Management Systems, E-Commerce Applications, Graphics Software, and JavaScript Libraries. On a side note, nominators are entered into a drawing for a free Kindle, so maybe your kindness will be rewarded as well.

Happy Voting, and to ALL the open source coders-- Thanks!

Rick

P.S. For those interested, I'll include the Packt Press Release in it's entirety:

Packt launch fifth annual Open Source Awards

Birmingham, UK. 9^th August 2010

The 2010 Open Source Awards was launched today by Packt, inviting people to visit www.PacktPub.com and submit nominations for their favorite Open Source project. Now in its fifth year, the Award has been adapted from the established Open Source CMS Award with the wider aim of encouraging, supporting, recognizing and rewarding all Open Source projects.

WordPress won the 2009 Open Source Content Management System (CMS) Award in what was a very close contest with MODx and SilverStripe. While MODx was the first runner up, SilverStripe, a Most Promising CMS Award winner in 2008, made its way to the second runner up position in its first year in the Open Source CMS Award final.

The 2010 Award will feature a prize fund of $24,000 with several new categories introduced. While the Open Source CMS Award category will continue to recognize the best content management system, Packt is introducing categories for the Most Promising Open Source Project, Open Source E-Commerce Applications, Open Source JavaScript Libraries and Open Source Graphics Software. CMSes that won the Overall CMS Award in previous years will continue to compete against one another in the Hall of Fame CMS category.

These new categories will ensure that the Open Source Awards is the ultimate platform to recognise excellence within the community while supporting projects both new and old. “We believe that the adaption of the Award and the new categories will provide a new level of accessibility, with the Award recognizing a wider range of Open Source projects; both previous winners while at the same time, encouraging new projects” said Julian Copes, organizer of this year’s Awards.

Packt has opened up nominations for people to submit their favorite Open Source projects for each category at www.PacktPub.com/open-source-awards-home . The top five in each category will go through to the final, which begins in the last week of September. For more information on the categories, please visit Packt’s website www.PacktPub.com/blog/packt’s-2010-open-source-awards-announcement

Contacts

Julian Copes

PR Executive, Packt Publishing

julianc@packtpub.com | www.PacktPub.com

About Packt

Packt is a modern, unique publishing company with a focus on producing cutting-edge books for communities of developers, administrators, and newbies alike.

Packt’s books and publications share the experiences of fellow IT professionals in adapting and customizing today's systems, applications, and frameworks. Their solutions-based books give readers the knowledge and power to customize the software and technologies they’re using to get the job done.

For more information, please visit www.PacktPub.com

3 Great (and Free!) Tools for Knowledge Workers

2010-08-09T20:30:00.007-05:00

Once in a while I happen across a tool that helps me in my work. Here are three.

Spreeder
This website helps me to read material at a much faster rate than I normally would. You can dial up the rate (in words per minute) so you can control how fast you read. You provide the text, via cut-n-paste. Sometimes I miss having the diagrams, and the structure of the words is lost, but all things considered this is a great tool.

www.spreeder.com

Freemind

This desktop app is great for helping you round out your ideas. I'm not sure why it helps so much, but for me it does. You quickly get used to adding new ideas, prioritizing them, shuffling them around, etc. It's really very easy to get started.

http://freemind.sourceforge.net/wiki/index.php/Main_Page

jMemorize

Here's another desktop application, this time one that helps me to remember things. As an example, I am just terrible at remembering people's names-- but jMemorize helps with that! By making electronic flashcards (yes, images can be put on one side!) you can use the provided 'Learn' mode to review all the cards in a group, removing the ones you get right. It's easy to use, you just run the java jar and away you go.

http://sourceforge.net/projects/jmemorize/

I hope these are as useful to you as they are to me.

Happy Thinking!

Rick

Book Review for "Plone 3 Multimedia"

2010-07-28T21:39:00.002-05:00

I've just finished "Plone 3 Multimedia", another Packt Plone title.

If you're not experienced with Plone, you probably need not pick this one up for a while. But if you are running Plone and want to use video, audio, photos, etc. to snazz it up-- there's a lot here for you. Here's the full review:

Plone 3 Multimedia

This is a book for Plone power users and administrators. The focus of the book is on multimedia capabilities, the content type is a wide-ranging survey with details for each of the many mini-subtopics. For anyone with a need to add multimedia content to a Plone site, I would recommend this book.

Chapter 1 is a brief chapter that defines Plone, ZCA (Zope Component Architecture), the excellent zc.buildout, and multimedia itself. The author gives us a brief introduction to Plone4Artists, which is an initiative that addresses many multimedia concerns.

Chapter 2 is all about images. The author tells us how to organize, resize, and group images in ways that make the site more appealing to the user. You are taught how to produce thumbnail images (which can be clicked into larger images) and how to use gallery/slideshow products. This is the first chapter to use a recurring theme: The author first explains the capabilities of a basic Plone installation, then later explains what sort of add-ons you might use to gain further capabilities. This is a meaty chapter with lots of technical content. If you're a serious Plone admin, this chapter alone might make the book worth your while.

Chapter 3 is the audio chapter. Audio formats are explained along with the advantages and disadvantages of the various types. A good explanation of audio metadata is included-- I found that part especially interesting. The author explains how to include audio players on your Plone site, and demonstrates writing a player view in HTML5. Like chapter 2, this chapter is a deeply technical one with plenty of specific advice to guide the reader.

It seems only natural that video content should follow audio and images, and so it is. Chapter 4 tells us how to stream and embed videos in your Plone site, also how to leverage videos hosted on external sites like YouTube. By now you'll recognize the familiar chapter format: First the basic capabilities of Plone are covered, then fancier alternatives are introduced including the Plone4Artists parts that address this chapter's needs. Once you recognize the chapter layout pattern, it really makes the material easier to divide into logical sections.

Chapter 5 concerns Flash in Plone. Several Flash helpers are covered, as well as some problem spots that can be avoided. As a special bonus, Silverlight is given coverage, too.

The next chapter was really interesting to me-- it was all about content organization and control. The first part dealt with categorization, and ways to optimize flexibility in Plone's folder-centric way of doing things. This was followed by a good discussion on content metadata, and an explanation of the Dublin Core standard for metadata. Tagging and rating of content followed this, and geo-location and the use of maps was the ending of chapter 6. There was enough information here that I am going to read it again!

Chapter 7 was all about Syndication, including RSS and Atom. As usual, the author outlined what a basic Plone installation can do, then suggests some add-ons that can further enhance your Plone site. Another common theme throughout the book is the suggestion of add-ons that will be helpful for the current problem set, then advice on how to configure the add-on for best usage.

Chapter 8 covers advanced uploading techniques. Say you have a whole photo album you'd like to move onto Plone, but you'd really rather not do it one file at a time. This chapter is for you, then! The author discusses FTP, WebDAV, and a few external tools that can be of use in this case.

The next chapter is all about persisting data. The author first covers the vanilla Plone default (ZODB, the object data base) then offers alternatives. The main concern is large binary files, which is natural since this book is all about multimedia data types. For these, Plone can be configured to use external sources (like YouTube) or file system mechanisms to hold the data outside of ZODB.

Chapter 10 is the final chapter of the book, and it covers the important topic of performance optimization. Varnish, the reverse proxy cache server is explained as is the Red5 video server. CachFu, a commonly used content caching mechanism, is also explained.

You might think 10 good technical chapters would be enough, but as they say on infomercials, that's not all! You also get not 1, not 2, but 3 appendices. Appendix A covers multimedia formats and licenses, including a nice explanation of various codecs you're likely to encounter. Appendix B is about Syndication formats, including RSS1, RSS2, and Atom. Appendix C covers links and places to find more information about Plone, it's build-out system, and more.

All things considered, this book is just what it purports to be-- an excellent resource for anyone using Plone to host multimedia content. There is enough diversity and depth in this book that I'm sure nearly everyone will learn something new (and many of us will learn many new things!) I would not recommend this book for a Plone newbie, as there is no gentle introduction preceding the technical content-- the author assumes the reader is already a reasonably competent Plone integrator. (This is all spelled out on the book's back cover and in the introductory text, though. If you miss that and come away disappointed, shame on you.) I'm sure this book will soon become a go-to reference for Plone lovers everywhere.

The book can be found here.

Happy Reading!

Free eBooks!

2010-07-28T20:42:00.002-05:00

Hi all,

Once in a while, something really good comes along and you feel you just have to share it with people. That's what's going on today, I have some free eBooks to share.

Packt Publishing has recently decided to give away some of it's eBooks, free of charge. Here are at least 5 titles:

Building Online Communities with phpBB 2
Upgrading to Lotus Notes and Domino 7
Invision Power Board: A User Guide
Building Websites with e107
The PEAR Installer Manifesto

The link that told me about these give-aways is here.

Besides free eBooks, Packt is also converting their electronic books to the 'ePub' format, which promises superior display capabilities, flexibility in formatting, and a host of other benefits. There's a nice press release about it here.

I hope you find something good there.

Happy Reading!

P.S. If you don't want to follow the above link to the ePub announcement, I'll include the announcement as it reads on their site. Here it is:

by Julian Copes | July 2010 | Enterprise Articles Open Source
Packt Publishing announced today that its eBooks will be available to download from www.PacktPub.com in ePub format with immediate effect. Following feedback from customers, the fast-growing publisher made the move to provide this popular format and expects it to be well received.

ePub (short for electronic publication) is a free and open eBook standard by the International Digital Publishing Forum (IDPF). ePub allows greater flexibility with content. With an ePub-formatted book, the display of text can be optimized for the reader's device. Other ePub features include improved design and layout, Inline raster and vector images, better search functionality, while enabling DRM protection and embedded metadata.

The company’s marketing manager Damian Carvill said “Packt listens to all feedback from customers and attempts to act on it accordingly. After receiving a number of requests, we made it a priority to convert all of our existing eBooks into the ePub format. All of our future books, and we hope to publish over 20 in July, will also be available in this popular eBook format.”

Packt is inviting all customers, who have purchased an eBook, to download the ePub version of the book and enjoy its features and great flexibility. Alternatively, customers can sample the ePub format by accessing one of Packt’s free eBooks. All purchases of new eBooks from today will be made available to download as an ePub file, as well as the standard PDF.

Packt ePub formatted eBooks are available from Tuesday 20th July 2010. To access your first Packt ePub eBook, either previously purchased or one of Packt’s free eBooks, please log into www.PacktPub.com and go to My account.

New Plone Admin book available

2010-07-27T20:42:00.005-05:00

I've been learning Plone lately, thanks mostly to LearnPlone.org and Packt's excellent library of new Plone titles.

A site admin can always use a book of new tips, and sure enough, Packt has that one covered too. There's a brand new title available, "Plone 3.3 Site Administration". The book can be viewed here.

There's a copy coming via mail, I promise to provide a review ASAP.

Meanwhile, please try to stay cool in the summer heat.

Happy coding!

P.S. Check that chain on the book cover-- I guess they're plugging Plone's top-notch security. I read today on Slashdot that the CIA uses Plone-- it must be pretty secure!

Book Review for "Groovy for Domain-Specific Languages"

2010-07-05T17:34:00.003-05:00

Book Review of "Groovy for Domain-Specific Languages", or how to teach a Java guy Closures and Meta-Programming

Are you an accomplished Java Coder, but not very experienced with the 'dynamic' languages like Python, Ruby or Groovy? I am.

Sure, I know a little about all those languages, especially Python. For quite a while now, I've used Python for scripting and even for quick Hadoop jobs. But the way I used Python wasn't much different than how I'd use Java-- mostly plain Object Oriented technique at the fanciest, more likely just plain old procedural scripting for quick-n-dirty text manipulation jobs. I'd read the occasional article about dynamic language features (like closures, metaprogramming, and built-in builders) but I didn't really have a good idea what those meant.

That all changed after I read "Groovy for Domain-Specific Languages" from Packt.

Groovy, it turns out, is a language built on top of the JVM and it offers really easy integration with Java. (So much so that your Groovy code compiles to JVM bytecode, so all the current Java code you have available to you is also available to your Groovy code.) The book goes about introducing Groovy in terms a Java coder will easily understand, and I think the author did a good job in this respect.

Groovy can be an easier Java. Language verbosity is relaxed, so coders can drop parenthesis, semi-colons, and variable types where it makes sense. This saves a few keystrokes at code-writing time, but more importantly it produces code that's a lot leaner so it can be much more readable. But that's not what helps in DSL construction.

DSLs, for those of you impervious to the growing dev-space din, are "Domain Specific Languages", or little languages meant to serve a single purpose. Never heard of that, you say? How about 'Regular Expressions', 'Make', and 'Ant'? I'm sure you've heard of those! They're all examples of little language that are designed to perform some very specific task, and make the user's life easier than if they had to use a general purpose language like C or Java to accomplish something like compiling a .jar.

This book goes about explaining some of the features a dynamic language like Groovy has that make DSL authoring an easier task. One such feature is the 'Closure' something Java doesn't have at this time. So what's a closure? I'd call it a method, except it's packed up in such a way that you can send it to other methods as a parameter. Confused? Check this example:

def islanders = ["Skipper", "Gilligan"] // This is a List in Groovy
def aClosure = { println "Hello, ${it}" }
islanders.each (aClosure) // This will print "Hello, Skipper" "Hello, Gilligan"

Another DSL-friendly feature of Groovy is Meta-Programming. Meta-Programming is writing code that can change it's behavior at runtime. One flavor of this is Reflection, which I knew from Java-- given the String name of a class, I could conjure up an instance of that class. I'd also seen in Python how you can add properties to an object 'on the fly'-- if that property wasn't there, the class just somehow put it there as soon as you accessed it, and the code went chugging along. But that's just the tip of the iceberg! In Groovy you can have your class respond to method calls that you didn't write at the time the class was authored. Weird! Yet very handy if you're writing a DSL, as the book explains.

The book is really a double-whammy, covering both Groovy-for-the-Java-Coder and Best-Practices-in-Writing-a-DSL. IMHO, it covers the first topic in more detail than the second, but I liked what I got from both.

The book can be found here.

There have been several times in my career where I've written a little language, probably with mixed levels of effectiveness. The next time this topic arises, I have a new weapon to bring out, so I'm waiting on it now!

'Till then,

Happy Coding!

More Top 3 Take-Aways from Enzee Universe

2010-06-23T15:10:00.004-05:00

Top 3 take-aways from Netezza Conference, day 2

Once again, here are the top 3 take-aways I got from sessions at "Enzee Universe" this year. If you're not sure what a "Netezza" is, please see yesterday's notes.

"Expanded Capacity, Improved Performance & More: Netezza Performance Software Release 6.0 Under the Hood"
1) The Netezza has a part called the "Field Programmable Gate Array". This is sort of like a chip that you can program, so you can sort of write functions to augment SQL. Data is automatically compressed as it travels between the disks and the FPGAs-- at a minimum 2x, but it can be up to 32x compression!
2) For users of ordered data (like dates), you can use "Zone Maps". This means you give Netezza a clue about your data and it will order it and make metadata about the high and low values contained in each block on the disk. Then when a read operation comes along, Netezza can just look to the metadata to see if that value is going to be between the high and low values-- if it isn't, Netezza just skips that block.
3) In 6.0, Netezza now allows "Alter Table" without actually re-creating the whole table behind the scenes.

"Practical Applications and Challenges of Advanced Analytics" by Usama Fayyad
1) Think of segmentation as a way to reduce data. By grouping like items into segments, you can disregard (or discard) the mounds of source data that go into the segmentation algorithms.
2) Mr. Fayyad used to be the 'Director of Data' at Yahoo, where they added 25 TB to the corporate stack each day. He offered the opinion that dedicated grids for handling this data (he even singled out Yahoo's Hadoop grid, something I like the idea of) are very expensive. Wherever possible, he suggested using rented grids (like Amazons) if conditions allow it.
3) He had an interesting example of a retailer who once asked what kinds of queries users were making that did NOT result in hits on the retailer's web site. It turned out that people were viewing print ads and selecting accessories (belly-button rings, to be exact) the models were wearing but were not part of the clothing being advertised. Once given this knowledge, the retailer was able to make inventory stocking decisions that allowed sales of the belly button rings, too.

"TwinFin Advanced Analytics Tutorial & Technical Underpinnings" by Brian Hess
(This was a really good session. There were many great points in this one, but here are the top 3)
1) Netezza now offers Hadoop Map/Reduce style programming right on the machine. With only minor modifications to your existing Hadoop classes, you can forklift the jobs right onto Netezza. Unfortunately, the larger Hadoop eco-system (Zookeeper, for example) is not available so you have to sequence your jobs yourself.
2) The R statistical language is now available right on the box, too. They tried to follow R's data constructs as closely as possible (i.e. an R 'dataframe' is a Netezza 'table') so it should be a snap for R users to work on the Netezza. For my uses, I imagined using R to handle data profiling duties.
3) On Netezza, the user can provide their own extensions to SQL (my terminology there) in the form of "User defined functions" that are used on the Field Programmable Gate Arrays (FPGA). Formerly you could only do this in C, but now you can use C, C++, Java, Python, or Fortran. We saw some example Java, it looked very straightforward. I think this is a great feature.

"Netezza Data Compliance"
1) Netezza now comes with 'Mantra', a data compliance tool meant to help with SOX, CISP, and other data regulatory needs.
2) Mantra will help you monitor who is accessing which data, and at which times they are accessing it. It will alert you to off-hours data access or other unusual access patterns.
3) Mantra isn't tied just to the Netezza-- it can help monitor other databases, flat files, mainframe resources, etc.

"A View into the Future -- Netezza's Technology RoadMap" by Phil Francisco
1) Netezza is adding 2 new classes of machines. 'Cruiser' is a much bigger data storage device that can hold up to 10 Petabytes in one machine. 'Skimmer' is sort of an edge device, maybe meant to help take load off the primary Netezza machine similar to how mainframe controllers sometimes reduce load on the primary box. (That's my guess on Skimmer, though. I might be wrong on that one.)
2) Netezza's Twin Fin has had improvements in concurrency, where it now handles 40-50 queries per second. In the future they'd like to get up to around 200 per second.
3) In the future, they'd like to support loads in the 10 TB/hour range.

That's it for day 2! If you're new to massive data warehousing, some of these notes may have been a little odd. But I hope you've found at least something of interest.

'Till next time,

Happy Coding!

Top 3 take-aways from Enzee Universe

2010-06-23T15:01:00.002-05:00

I've been at "Enzee Universe", the world-wide Netezza conference and offer these top 3 take-aways from the sessions I've seen at day 1.

What's a Netezza?
A Netezza is a database appliance. That means it's a refridgerator-sized box that has about 100 disk drives in it, with many cpus, and a high-speed network inside. It's optimized for data warehousing, so when you add data to a table the data automatically gets divided over the 100 disk drives. This dramatically lowers database operations, as each table is 1/100th the size it otherwise would have been, so scans happen 100 times faster.

"Best Practices With Netezza" by David Birmingham (author of "Netezza Underground")
1) Make floats into ints. Ints compress on the Netezza and thus are more efficient.
2) When making performance changes, consider all 3 components of the ETL/Data Warehouse/BI stack. Don't optimize one at the expense of another.
3) Use CTAS (Create Table As Select) often. Intermediate steps (making 'work tables') is good practice.

"Netezza 101" by Ed Patterson
1) The Netezza has a 10GB internal network, and can currently hold up to 7 Petabytes of storage.
2) The SCSI drivers allow up to 110 MB/second of data transfer, but since data compression is transparent and automatic (right next to the disk), effective rates are really more like 440 MB/second per disk.
3) The Netezza can currently load data at a rate of about 1 TB an hour.

Featured keynote by Donald Feinberg, Distinguished Analyst at Gartner
1) Memory is getting much bigger, now over 1 TB on a server. The future of data warehousing may be in-memory, not on SSD or Flash as some expect.
2) Memory is more expensive to buy than disk, but it requires only 1% of the electricity. This will become an important economic consideration.
3) There is a bright future in Predictive Analytics.

That's it! I hope you found something of interest in all that. If so, tune in again for another list from Day 2.

'Till then,

Happy Coding!

Book Review for "Plone 3 Products Development Cookbook"

2010-06-13T21:00:00.003-05:00

Let me make one thing clear to start: This is a book by developers, for developers. The authors clearly state in the Preface that the readers should have some knowledge of Python, Plone and Zope and I believe this is very true. There's little material here to get the newbie up to speed on basic concepts. But if you're already at that point, then this book reads like working notes from an expert Plone 3 consultant, and there is much worthwhile content here for you.

The first chapter is the only one that offers a newbie-level entry level. It covers Plone 3 installation, and gives some advice on establishing your initial Plone site. Once that chapters done, hang on tight-- the coddling is over! The text then jumps straight to recommendations for tools used for development. The authors clearly have a good amount of experience in adding functionality to Plone, and they offer great advice on which tools will be useful. Given the base of those two chapters, the book then launches right into the proper way to develop products for Plone 3.

The goals of the book are really outlined back in the preface. The authors have selected 10 pieces of functionality that are not found in a base Plone 3 installation. I found all 10 to be requests you might easily find in the 'real world'. (Examples: Prepare the website for internationalization, allow multimedia content that should be both playable on the site and downloadable. The rest are just as reasonable.)

Once you know what the authors are setting out to accomplish, you are presented with answers to all these challenges. The answers are formatted in a pattern repeated for each action that adds functionality:

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.

Along the way the authors provide tips and techniques for expert Plone development. These include debugging, documentation, testing, and packaging. I was especially pleased that the authors took time to provide text on performance considerations, something not always present in books of this type.

If I had one wish for this book, it would be for more illustrations and a little more remedial material for developers not already knee-deep in Plone development. Outside that, I'd recommend that anyone doing Plone 3 development should look at this book. There are so many expert level tips and tricks contained here, I imagine nearly everyone is going to learn something-- many will learn many things.

The book can be found here.

Happy Reading!

Profession in Crisis -- The Moving Ladder problem

2010-06-12T09:00:00.002-05:00

Let me be clear about this: I love my work. Programming has been very good to me, and I've loved the challenges it presents. But I wonder if industry is making short-sighted decisions that will eventually bring crisis to our profession.

I work for a fairly large company (6,000 employees, a little over $1B in revenue). For the past few years we've been following what I think is typical industry practice: currently employed programmers are largely domestic, while new hires are sourced almost entirely from offshore data centers. At first, we had new-hire data centers in India, then we started in Poland and most recently in China.

By the way, this is not a rant against the offshore programmers. Who can fault anyone for seeking employment and providing for their families? Today's column is about a business problem, not the offshore debate.

Anyone who's ever worked with consultants will recognize that effective programming is comprised of two primary pieces: knowledge of the toolset (language, frameworks, configurations, etc.) and knowledge of the business domain. High-end consultants typically start an assignment with a lengthy debriefing in which business knowledge is described to them. This is necessary because it's impossible to make informed strategic decisions without a good understanding of the business context you're working in. The same is true of stay-in-place programmers: only entry-level coders bring value solely through toolkit knowledge. Mid-to-upper level coders have to understand the business, so they can make informed architectural level decisions. The higher up the ladder you go, the stronger the business/technical see-saw tilts towards business knowledge.

OK, here's the problem: With our moving-low-dollar-hiring model, we've effectively cut off the business domain accumulation pipeline. Today's entry level coders are tomorrow's application subject matter experts. What we have done is constantly moved the bottom rungs of the ladder, so nobody is being given the time to thoroughly understand how the complicated applications work. We've still got domestic experts on the top end of the ladder who learned the ropes while bottom-level jobs led directly to the top-level jobs. But noone is going to be able to climb to the top of the ladder in the future-- the bottom rungs keep moving.

What will happen when today's set of application architects retires or moves on? There won't be any mid-level experts in India-- those experts took other jobs when the coding work went to Poland. And there won't be any domain experts in Poland, either-- that feeder pipeline was shut down when the low-end work went to China. I'm sure China's surging economy will eventually price the Chinese coders out of the business too, and we will again move the bottom rungs of the ladder somewhere else.

I guess a pure capatilist would say that this is forcing efficiency somehow, that the business will adjust to this problem as it seeks to become more efficient. I just don't see that working out-- the people who know how to make effective strategic decisions are invariably those people who have had years, maybe decades to understand how a company's applications power the enterprise. I think it's a short-sighted business anti-pattern, and short-term greed is driving it.

Maybe the end result will just be sub-optimal business performance in the long run. Like all engineers, I just hate to see inefficiency, especially if it's something that's shaping up to manifest itself years down the line.

But for today, I've got a couple of new books to read. One's on Plone, the other on DSLs in Groovy. So I'm going to go study a little just-for-fun low level coding, just for the joy of learning new things. That's something all programmers across the globe can enjoy!

Happy Coding!

Your allies in IT: The Ops crew

2010-06-06T16:34:00.021-05:00

I've always worked in shops where the 'Development' side of the house produced applications and the 'Ops' side of the house ran those applications.

If you've never heard the term 'Ops', that means the folks that manage data storage, migrate programs from environment to environment (dev to test to cert to prod, etc), and FTP files back and forth to clients. If your company deals with printed materials (statements, bills, etc.) it's the ops folks that produce these. They might also manage tape libraries, migrate applications from old servers to new ones, or manage your virtualized environment. In short, they take all the stuff developers produce and put it to use so the company can make money. They're the ones that RUN your application.

Today, I'd like to present five things every developer should know about Ops.

Ops is NOT boring and repetitive work
Ops is about efficiency and proper execution. To be good in ops, you have to understand the resources the applications use (disk, processor consumption, printers, etc.) and know how to continually improve usage of these finite resources. This means lots of analytical thinking, and lots of adrenaline on days (nights, probably) when changes are made to the all important production eco-system. Ops work is most definately NOT boring unless your shop has had very good leadership for so long everything's already smoothed out and nothing ever changes.

Ops thinks Dev is a bunch of Prima Donnas
Somewhat true - Depending on the quality of your Dev shop, you may have a few unenlightened souls running around thinking they're superior to Ops in some way. Not true, Kemo Sabe-- and thinking that way is a good way to leave valuable bridges unbuilt. Many times I've had my skin saved by Ops personnel willing to work a little harder to restore a dataset or run some special fix-it job that will cover a mistake I'd made. (Sometimes they even concoct the scheme necessary to fix things.) It's easy for the Dev-Ops relationship to be somewhat adversarial, though, if there's not mutual respect. In that case the Ops guys can be like the fabled Chinese philosopher who just waited by the river for the body of his adversary to come floating by. In this case, a friendly Ops ally can fish you out and resuscitate you-- if you've invested in building the relationship. If you haven't they just have to wait and sooner or later laugh at you when your application goes belly up and you need a special favor.

Ops is a dead-end job - NOT!
Definately false. Ops gives you the perspective needed to understand your shop's core business. You have to know the way things work and the deadlines associated with application run times. Ops also has to have a handle on online (transactional) operations and the SLAs associated with them. Ops jobs can definitely lead to strong management positions (i.e. the CIO-type career path), if that's your desired career progression.

Ops knows who you are
They quickly pick up on who's who in the Dev side of the shop-- sharp Devs can be granted extra priveledges at crunch-time while Dev Bozos will almost certainly be subjected to every stringent by-the-book mandate they have available. Ops will ultimately be given this power, because they feel a lot of the pain when things go wrong. So if a particular Dev/Architect type has caused them problems in the past, that Dev is going to have a rougher time getting things done. (Getting things done is what ultimately leads to Dev promotions and pay raises, so this is an important consideration.)

Smart Ops shops pay a little more
It is true that some Ops jobs don't require a CS degree or any particular certifications. Your company can hire people with a limited skill set-- but only if your work is largely one-dimensional and so simplistic it really doesn't require much thought. But if your work is heterogeneous and you have many time-sensitive deadlines and resources to balance, your shop will be money ahead to pay for good analytical thinkers. The very best shops I've seen have hired entry-level people to start, then paid them well enough to keep them around for many years. If they've hired smart (though inexperienced) people, those people will accumulate valuable knowledge as time goes by and will yield an incredible ROI over time as they keep your IT machine smoothly running. A single salvaged SLA can pay for a lot of marginally bigger paychecks!

So if your shop runs production applications, I'd urge every Developer and Architect to adapt the right mindset towards our friends on the Ops side. It'll pay off, big time!

'Till next time,

Happy Coding!

Can you program without coding?

2010-05-29T08:28:00.013-05:00

Do you think you can program without coding? I never would have thought so, but now I do. It's possible to make user-defined types and interfaces, call services, create a service, make a deployment artifact, deploy and test-- all without writing a single semi-colon, angle bracket, or curly brace.

You don't believe it? It's true! I've been working with SOA toolkits from several vendors over the past several months, and have been deeply impressed by how much behind-the-scenes coding can be abstracted away from the coder. Check these out:

Defining a user-defined type (This picture shows Intalio, one of the less expensive UIs)

Define a user-defined type (similar to a class)
Using the UI, you click an icon to 'add a field'. You type in a name for the field, then choose a type for the field. The available types are XML types-- string, int, long, etc. (Or user-defined types you've earlier declared.) Behind the scenes the UI will build you an XML schema (XSD). The nice part? The XML is well-formed every single time, without any hand-coding of the XML!

Define an interface
A few clicks of a button lets you declare a new interface. You choose the input and output types from XML primitives and the user-defined types you have made.

WSDL, used graphically to call partner web services

Call Web Services
You import references to external services from a registry or directly from the wsdl offered by that service. This will give you a UI widget you can then drag onto your canvas to call the service.

Declare a service
Once you have your interface defined and the business logic (declaring variables, calling services, etc.) defined, you can generate an implementation for that service. This makes your logic available (usually as HTTP/SOAP, JMS, etc.)

Branches
Again, using UI figures you place a branch in your logic and indicate through XML XSDs how to decide which path your code should follow. (Of course you don't actually see XML, you see grid boxes of field names, you click on the one you want.) You can make loops in a similar fashion.

Make a deployment artifact
You can choose to 'export' your business logic as a .JAR or .EAR. Without any scripting, your IDE will produce an artifact ready to deploy.

Test your logic
Some of the high-end tools come with embedded application servers. This allows you to seamlessly deploy your component and test it right from the IDE.

You can do all this, and more. So what does this mean to us?

I have no doubt these toolkits will continue to get better and more refined as time goes on. It is already possible to be a productive programmer without writing any traditional code or actually seeing any XML.

But the main point is this-- the person doing this programming still has to think like a coder. You still have to know when you need a variable, have to understand primitive types (long, int, etc.), still have to understand how a loop works, etc. Perhaps most important, you still have to think in a logical and methodical way. For this reason, I am actually optimistic about these developments-- I think it's just making a programmer more productive.

So how do you get started? For no money, I'd suggest you have a look at Intalio BPM. This freely available toolkit will let you validate what I've said here and get some idea what these toolkits can do.

Happy (Codeless, this time) Programming!

Packt Plone double-whammy

2010-05-25T20:53:00.003-05:00

Packt Plone double-whammy

Have you tried Plone? It's an open source content management system that can be used as the basis for many kinds of websites. Plone strong points are its flexible and adaptable workflow, very good security, extensibility, high usability and flexibility. Sound interesting? If so, you're in luck. I'll be reviewing 2 new Plone books in the near future and you have the opportunity to purchase Plone books at a discount.

The first new book is "Plone 3 Products Development Cookbook", which promises 70 Plone recipes, and can be found here:

The book offers a sample chapter, it reads cleanly and clearly.

The second book is "Plone 3 Multimedia", which tells how to build a media-rich website with images, audio, video, and Flash.
The book is found here and a sample chapter is here.

In addition to the special pricing (discounts of 20% on print books and 30% on e-books) my friends at Packt tell me they'll be offering a chance at a 'lucky draw' iTunes or Amazon gift card to early purchasers of these books. I'm not privvy to exact details of that part of the promotion, so watch the web site for that one.

The special offer is detailed here.

I look forward to providing reviews on this blog in the near future. 'Till then,

Happy Reading!

'Enterprise' 101 - Location Transparency

2010-05-23T13:06:00.007-05:00

Let's say you wrote a nice service, something like getHello(), and put it on a server. Now you want to write your client and use it to invoke your service. If you're following most development cookbooks, you're writing some code like this:

public class TestClient {
public static void main(String [] args) {
try {
String endpoint =
"http://ws.apache.org:5049/axis/services/echo";

Service service = new Service();
Call call = (Call) service.createCall();

call.setTargetEndpointAddress( new java.net.URL(endpoint) );
call.setOperationName(new QName("http://soapinterop.org/", echoString"));

String ret = (String) call.invoke( new Object[] { "Hello!" } );

So what's wrong with that, you ask? Your code is going to work-- your client will be able to call the server. But you're missing an important ingredient-- Location Transparency.

The client code you see above is less than Enterprise-worthy because the service endpoint is embedded directly in the client source code. What happens when the server has a hardware failure and needs to be replaced? Your client code will be irreversably broken and will need to be recompiled. Also, you are confined to hitting one service from your client-- if the server becomes a bottleneck, you don't have a good way to scale out.

Location Transparency-- the Registry solution

One solution to the Location Transparency problem is to use a registry to find your server. The registry is a well-known place where servers are registered and clients go to ask locations of servers. UDDI is the 'spec' answer for web services, though it hasn't worked out as well as the spec writers probably would have liked. Today there are other web service-centric registries that serve the same purpose as UDDI, but offer 'value adds' from the implementors. In the CORBA world, you might use a 'Name Service' to act as your registry. Still others might code their own registry using a database or some other CRUD data store.

Here are some pros and cons of a registry solution:

Registry Pros
- Allows loose coupling between client and server
- Can be implemented in a way that lets the client 'discover' services based on attributes like method arguments

Registry Cons
- Does not take into account servers that crash. If a server is registered then crashes, the registry will still steer clients toward the dead machine.
- Does not make a provision for load balancing. A registry isn't usually charged with telling a client which like-typed server to run against-- it just provides a list of the servers.

Niceties
- If you can code your services to self-register with the registry when they start, that's a good thing. Your operational admins probably have better things to do then key new services into the registry.
- You'll also want the services to self-unregister when they come down gracefully. Note that this doesn't help a crashed server, though.

There are other ways to address the Location Transparency problem, though-- through Messaging and through a Load Balancer are a couple of good ones. But those are posts for another day.

'Till then,

Happy Coding!

Book Review "CodeIgniter 1.7 Professional Development"

2010-05-19T21:10:00.003-05:00

This book is a good introduction to the CodeIgniter library. CodeIgniter is a multi-purpose PHP library that contains a lot of good functionality and is easy to use. This book is a survey-level guide to the library, accompanied by a great many easy to read code snippets that help the reader understand CodeIgniter usage.

Here are some of the topics I found most useful:

- MVC programming
- PHP Style
- Benchmarking (timing ticks)
- Input and security
- Email
- File Upload
- Pagination
- Session management
- Database interaction (to include 'Active Record' implementation)
- User Authentication & Security
- Tips on building a large-scale application
- RESTful Web Services
- Extending CodeIgniter and sharing back with the community

I found this book to be an easy read. I've done a little PHP coding, but not a great deal, so I really appreciated the easy to read code snippets that accompanied nearly every topic. The book covers a lot of territory, so there's not a great amount of detail on any of the covered topics, but there is enough material to give you a taste of what the library holds. If that's not enough to help you implement what you need, at least you're aware of what CodeIgniter can do for you.

The book's back cover says this is a book for advanced PHP developers, but I'm not sure that's the right target audience-- I'd expect a true expert might feel they're getting too little advanced material here. For newbies to mid-level PHP coders, though (like myself) I think this book does a great job of introducing the types of things you can do in PHP and some really easy code examples to leverage.

If you've got an interest in PHP and are looking for a good library to let you write advanced web site functionality easily, I'd encourage you to check out "CodeIgniter 1.7 Professional Development". You can find it here.

Happy Coding!

Simplicity Drives the Net's Most Popular Framework

2010-05-15T07:51:00.007-05:00

Do you know which framework is dominant on the web? Have a look at this chart to see which frameworks are hot, and which are not.

You can check the current stats whenever you want here:

I was somewhat surprised to read those statistics. I would've thought some of the less popular frameworks would've done better, and I would've thought some of the most popular wouldn't be doing so well. I started thinking about why PHP is doing so well, and I've drawn the conclusion that it's the amazing simplicity. (To be sure, the made-for-the-web functionality has a large part to do with it, but other frameworks offer that, too.) Here are a few of the things I think make PHP easy to use:

- No compiles or compiled artifacts to shuffle around
- No complicated configurations to master, no lengthy XML files to edit
- As simple and procedural as you want it to be
- Plenty of power, if you need it. If you don't, only blissful simplicity
- Easy language syntax. To me, it reads something like plain old C.
- Everything's in one place -- You can just mix Server-side scripting right there with your HTML pages (Wow, that flies right in the face of the justification for JSPs and ASPs, doesn't it?)
- Fantastic iterative cycle-- you make a directory and edit scripts with GEdit/Notepad/Vim/etc, then check it in the browser. Nothing could be simpler!

Here's an example:

<html>
<head>
<title>My First PHP Page</title>
</head>
<body>
<?php
echo "Hello World!";
?>
</body>
</html>

What could be more simple than that?

If you haven't tried PHP, I'd urge you to do it. It really can be fun.

How do you get started?

1) Get a web server that's PHP enabled. (You can search the web for any of the pre-packaged stacks. I use the excellent EnterpriseDB PostGres/Apache/PHP stack found here)

2) Find the web root for your web server. For my Apache installation, it's called 'www'. Put a new directory under that one, and add a simple PHP script to that directory. (Maybe the hello world above. Put it in a file called 'Hello.php' or something like that.)

3) Point your browser to http://localhost://Hello.php Maybe something like http://localhost:8080/HelloExperiment/Hello.php

4) Edit the file to add more PHP and watch the results change in your browser as you refresh. That's it!

The web is full of great sites on PHP, including the excellent www.php.net. Read/Edit/Watch the change!

I love this simplicity, don't you? That's something we could all use more of.

Happy Coding!

Every programming language should have a tool like Acire!

2010-05-08T08:19:00.004-05:00

I updated my laptop to Ubuntu Lucid Lynx last week, and along the way I picked up a few new tools. One of these is 'Acire', a learning utility for Python.

Acire is a great idea-- you can browse code snippets for topics you're interested in, view some simple source code, and observe the execution all in one 3-pane window. Simply put, it makes for a very easy reference library for Python and a great way to learn more about the language.

Acire is packaged for Debian, and I'm not sure if it runs off Ubuntu. (I print this to save you time if you're not an Ubuntu user.) I wish it would run everywhere, and I wish even more for this to be available in multiple languages. It's a great learning tool!

Acire can be found here:
http://www.jonobacon.org/2010/01/12/acire-0-2-released/

For those of us who can use it, enjoy!

Happy Coding!

4 Ways To Become a Better Developer, in No Time

2010-05-01T07:41:00.010-05:00

If you're like me, you're working hard to find the right work/life balance. In that game, I think any little edge can be of value. Here are 4 tips I use to self-improve without sacrificing any time from the 'personal' side of the ledger.

Multi-purpose your MP3 player
If you have an MP3 player, put some tech-talks on it as well as music. Then when you're out doing something that allows effective multi-tasking, listen to them. I like to go running, on some days I'll listen to a podcast on software engineering. Google will help you find lots of good podcasts, one of the best sources is "Software Engineering Radio", found here.

Put a tech book (or at least tech tutorial printout) in your car
There are going to be times when you end up waiting somewhere-- these are ideal times to read material you just might not have time for otherwise. Probably my favorite example is a shopping trip. My wife loves to shop, I hate it. But now I just leave a tech book in the car, which I take out only after we get to the store we're driving to. Once we're there, I let her go through the store while I catch up on my reading. Then when she's done at that store, I put the book down as we talk and drive to the next place. Everybody's happy! (Warning: We programmers can be overly focused sometimes, which can lead to spousal displeasure. Be cognizant of the fact that you shouldn't keep reading once your spouse returns to the car!)

Take a book to the Oil Change
If you're like me, you've got two cars in the family. That means every 3 months somebody's going to be going to the shop for at least an hour-- twice! To make these waits more bearable, I've started taking a book in with me. The same technique works well at the doctor's office-- sitting in the waiting area for my checkup can be time well spent!

Leave a 'Boot-Up' Task for Tomorrow
My work laptop takes a long time (several minutes, at least) to boot up. This isn't because the machine is overloaded or needs a cleanup-- it's because this is when corporate IT pushes scripts and patches onto the box. I like to leave myself something to work on while this is going on-- a small diagram reminding myself what I was working on, a tech document, a to-do list to think about, etc. Then when my machine is busy waking up, I can start getting myself back into the right mindset.

I'm sure there are a lot of other ways to effectively use time that would otherwise be spent unproductively. If you've got a favorite, please leave it as a comment.

Happy Coding!

4 Things That are Almost like Programming, but not quite

2010-04-24T10:26:00.002-05:00

Do you sometimes struggle in explaining your work to others? Especially at project planning time, I sometimes reach for metaphors to explain why estimating can be hard. Here are a few of the metaphors I've used in the past, and a few reasons they aren't adequate.

Building a house or bridge
This is a common analogy, and one often used by those that believe programming is 'engineering'. It's true that you can break the problem down into smaller pieces, then plan constructing the pieces. Repeat this cycle, going into ever greater detail, until you have your 'plan'. In this way, construction is similar to traditional 'waterfall' methodologies. There are similarities to 'agile' practices, too. A house is built iteratively-- you pour the foundation, then put up the framing, then the roof, etc. At any point along the way you can evaluate and make small changes as you go.

But.... a building is a lot more like other buildings than one computer program is like another computer program. We've been building houses and bridges for centuries, and there are only so many variations among them. Programs, on the other hand, have only been built for about 50 years and they have a lot more variables that can change. Programs also have temporal issues to deal with-- the order of things happening must be considered. (A bridge, on the other hand, mostly just stands there and lets things go over it.) For these reasons, I don't usually like this analogy.

Writing a book
In both cases, you're using text to build your deliverable. You have to break things into smaller pieces (classes, layers, etc. in software, chapters in books). You follow style guides, and have an ordering of things. All the little details you conjure up have to be consistent. In books, your characters should have past experiences that 'fit' in the context of the story. In programming, you need to make sure the data you need is available to all facets of the application that require it.

But.... I think writing a book is probably a lot less restrictive than programming. You have more freedom in the way you express things, for instance. (I don't think most editors are as picky as compilers.) In some ways, this makes programming easier-- once you have your goals defined, the ways you can go about achieving them are narrowed down. The degree of creativity is high in both cases.

Painting a picture
Painting a picture can be like programming because you're making something creatively, and you're building it in a sort of iterative manner. This is somewhat like the book argument, except the painting seems a little less constrained in places. You can choose your medium-- oil paint, water color, chalk, etc. much as you can choose your implementation language in programming. Programmers can also bootstrap projects by copying the work of others. ('Hello World', anyone? It can be seen sort of like paint-by-numbers.)

But.... paintings don't have to be exact. Their 'goodness' is found in the eye of the beholder. Oh, if only programs were that way!

Assembling a child's toy
Have you put together a bigger toy lately? They usually come in a cardboard box with about a hundred different parts in it, with an instruction sheet written in half a dozen languages. The assembler (you) reads the instructions and attaches part A to part B. The instructions (like documentation in software) are sometimes good, sometimes not. Sometimes you have to refer to a picture of the toy to see how to do it. This is like studying design patterns or reference implementations. In today's programming world, (especially Java) we have a lot of frameworks that make programming seem like this.

But... You never really fabricate anything by yourself in the toy scenario. You're using parts somebody else made. So I don't think this one is exactly right, either.

Those are some of the metaphors I've used. If you have any better ones, please share!

Happy Coding!

Book Reviews on the Way: CodeIgnitor, Groovy DSLs

2010-04-21T20:43:00.006-05:00

The good folks at Packt Publishing are about to release 2 new books with interesting subjects.

CodeIgnitor 1.7 Professional Development
The book's available here.
Have you noticed that PHP development is red-hot? Check the web statistics-- the majority of web development is done with PHP. (Based on today's data, found here.) This title promises to teach sound PHP practices, including REST style web services. I look forward to reading it!

Groovy for Domain-Specific Languages
This book can be found here.
DSLs are little languages written in the business terms your users are familiar with. I've often written DSLs (even before they were commonly called DSLs) but never stopped to think about best practices in doing so. Coupled with the easy-to-use Groovy language, this book has the potential to increase my productivity, so it's another one I look forward to reading. Another great topic!

Watch this blog for reviews as soon as the books are out. 'Till then, Happy Coding!

9 reasons I like cubicles better than offices

2010-04-17T09:08:00.005-05:00

Sometimes developers get offices, sometimes we get cubicles. I'm not convinced in office is always a better choice, though. Here are 9 reasons why I think cubicles are better, and 2 reasons they are not:

1) You're part of the Dev Network. Hopefully, your cubicle is in a row with other developers and architects. If that's the case, you get to listen in on and take part in all kinds of conversations about a wide range of work topics. In turn, this lets you benefit from other's opinions and experiences.

2) You have a face. Unfortunately, I've worked at places that have had layoffs. In fact, I've seen some good technicians let go before less effective counterparts-- because the guys who were kept were more familiar to everyone. Once you're in an office, you become a little less known to your local work group. (Along the same lines, I've known top-notch technicians who were given less 'street cred' by the senior techs in the shop because the guy worked remote. Had that guy been a local cube-dweller, I'm sure his opinions would have carried great weight.)

3) You're the first to know about food carry-ins, where cube-dwellers gather and share treats. 'Nuff said.

4) If you're single, you have an excuse to mingle. It worked for me-- I've been married for 12 years to the hot chick from across the wall.

5) It helps keep the amount of clutter in check for us pack rats. I for one would have TONS of old developer magazines, books, printed tutorials, etc. if I had an office. As it is, I probably only have half a ton in my cube.

6) You can easily ask a co-worker for a second set of eyes on a problem. Two heads are better than one-- it would be much more difficult to leave the office, pull someone from the cubes, etc.

7) You can build on your all-important social/work network. So maybe it's not the best use of your time to talk about World of Warcraft or sports once in a while. It does help you form bonds with your co-workers, though, and that can later pay off when you need to leverage the network (i.e. referal for a new job).

8) You won't lose face if your work area gets moved. If you work in a big building and your work team gets moved, it's no big deal if you go from a cube to another cube. But if you had an office and got moved to a cubicle, it might seem like you 'lost something'.

9) You're on the right side of the Dilbert labor/management spectrum when you're in a cube. Once you get an office, you're more like the pointy-haired type than the engineering type.

And a few reasons you'd really rather have an office

1) It gets you out of the noise when you need to concentrate. On those occasions, it's nice to be able to close the door and get lost in your code. If you're in a cubicle, headphones might be the next best thing.

2) You can make phone calls without the whole world listening in. Business or not, sometimes there are calls you'd rather not have overheard. Luckily for cube-dwellers, vacant conference rooms can help fill this need.

3) Good old hubris. Let's face it, an office just carries a little more prestige, doesn't it? But that's not a good motivation, IMHO.

Happy Coding!

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

2010-04-11T20:52:00.004-05:00

Do you have an interest in online advertising? Are you a blogger or website administrator that would like to monetize your workspace? If so, I know of a book that might be of interest to you.

Packt Publishing has just released "OpenX Ad Server: Beginner's Guide". True to the title, I found this book can guide the reader from zero knowledge of online advertising to capable user of the popular OpenX Ad Server. (An open source platform for configuring and running online advertising campaigns.)

The author assumes the reader has no previous knowledge of online advertising, so the basic concepts are clearly explained in the opening chapters. Advertisers, Campaigns, Banners, and Zones are all given high level introductions, then later deep-dives as you are exposed to all the configuration and minute details associated with each. The book is set up in a very logical manner, with a nice template used for the detail chapters: Explain the component in a high level, then walk the reader through Open X's implementation of the abstraction in step-by-step detail. (The steps are accompanied by many useful screenshots, by the way. The high level theory is accompanied by understandable diagrams.)

All things considered, I believe this book delivered on it's promise. OpenX is made clearly understandable to the reader, no matter how much experience the reader had before cracking the book open. I wish every technical book were this straightforward!

The book can be found here.

Happy Coding!

Comfort Words after a Bug

2010-04-10T07:23:00.002-05:00

Last week a good friend of mine stopped by my cubicle*. He was upset because a bug had been found in his code and the code was now delayed in going to production. Here are the things I said to him then, and I will hope to hear back in the future when I have a newly found bug:

"It's your turn in the hot seat."
I told him "I was to blame when we found that bug I wrote in the Locator service, so now the heat's off me. Don't worry, I'm sure I'll claim it back again after a while."

"Even the very best developers write bugs."
It's true. This is because software development is just plain hard. Look at 'Quick Sort', for instance-- it's been around for decades, yet new and subtle bugs still crop up once in a while. No matter how smart the author, no matter how well understood the task, there will be bugs.

"If you're not breaking something, you're not doing anything."
I first heard this one when I worked a summer on a golf course. A tractor had just been driven over a sprinkler head, causing the sprinkler head to break off it's pipe and causing a big water leak. The boss told the disheartened tractor driver that these things just happen and the only way to avoid breaking things was to sit frozen and not do anything. Likewise, the only way to completely avoid writing bugs is to stop writing code. (Which nobody wants, of course.)

That's what I said then-- he'll probably be echoing it back to me next week. What do you say to your friends in this situation?

Happy Coding!

* I'll write a future post about why I think senior developers should work in cubicles, not offices.

Performance testing tip -- Visualize your data to help reveal patterns!

2010-04-03T08:34:00.007-05:00

When you're doing performance testing, take a little extra time and examine your data for patterns. Sometimes the patterns aren't easy to see, but with the help of some tools they'll jump right out at you. Let's look at an example.

Here's some sample data that represents the amount of time it takes for a test driver to invoke the server. Do you see the pattern?

latency
0.7630
0.0626
0.0662
0.0705
0.0833
0.0631
0.0656
0.0712
0.0841
0.0623
0.0671
0.0699
0.0840
0.0619
0.0659
0.0720
0.0835
0.0630
0.0659
0.0706
0.0835
0.0619
0.0671

I can't see the pattern immediately. So let's have a look using 'R', the excellent open source statistical language. (If you're not using R yet, you might consider looking at it. It really is easy to use, and it gives you excellent statistical capabilities. There are lots of nice web tutorials on how to use it, as well as the excellent Manning title "R in Action") Here's the R script:

timingticks <- read.table("/home/rick/Blog_Temp/My.dat", header=TRUE)
attach(timingticks)
'Count'
length(latency)
summary(timingticks)
plot(latency, col='blue')
axis(2, tck=1)
q()

The script is pretty self-explanatory, but what we're saying is roughly this:
- Use my data file.
- Get me the number of records (length) of that file, call it 'Count'
- Give me a statistical summary of the file
- Make a plot of the file, using units of '1' on the left axis. THIS IS THE PART THAT SOMETIMES MAKES THE PATTERNS JUMP OUT!

So let's run the script then have a look at the results. First, the statistical output:

[1] "Count"
[1] 23
latency
Min. :0.06190
1st Qu.:0.06435
Median :0.06710
Mean :0.10036
3rd Qu.:0.07765
Max. :0.76300
> proc.time()
user system elapsed
0.732 0.028 0.747

This alone makes using R worthwhile. With almost no effort, I got some good information about my application timing performance. But that's not the real pay-dirt in this case! Let's have a look at the plot:

Now that's more interesting! Let's ignore the top dot, which represents a 'first transaction'. These are often much longer than the following entries due to 'warm up' issues. But look at the little repeating saw-tooth at the bottom! This is indicative of some sort of repeated behaviour.

In a real-world scenario, this was exactly what I saw when we found some server-side code that was trying to improve performance with a cache. The code was caching a value in a list, then when the list got to a certain size it tossed the cache and started over again. (In this case, the list size would be 4. See how the data goes in patterns, the timing gets a little longer each time for 4 cycles, then it 'busts' and starts over again?) It turned out our "performance-enhancing" cache was actually costing us performance! We removed the cache.

This is just one sample of how data visualisation can be used to help you find patterns in performance data. It doesn't take much time, and it can lead you to valuable insites. It's also fun!

Happy Coding!

Easy Web Service And Test in 5 Minutes

2010-03-28T14:05:00.020-05:00

This post will show how to quickly make a web service and test it in less than 5 minutes.

Tools you will need:

NetBeans 6.8 (choose to install GlassFish with the IDE)
SOAPUI 3.5

First, make your NetBeans project. Make it a Web App.

Choose defaults for the deployment options:

Right-click the source package and choose to add a new Web Service:

Give the Web Service a name. My examples often deal with the game of bowling.....

Put the cursor in the body of the Web Service class and right click. Choose to 'Insert new code', make it a Web Service, and add the method signature you want.

Add some logic for your method. When you're done, right-click the Application in the Applications tab and choose 'Clean and Build', then 'Deploy' (after you've cleaned up any compile errors, if there are any.)

Now choose the 'Services' tab. You need to go get the WSDL for your Web Service so you can test it....

Choose 'View Endpoint'....

Click the link for your WSDL, and copy it into your clipboard. You'll be using it in a few seconds....

Now to test the Web Service! Fire up SOAPUI, and start a new Project. Paste your WSDL URL (from the address you got after clicking the 'view WSDL' link a bit above).

Now alter the sample SOAP message SOAPUI has kindly provided you. In my screenshots, I'll check to see if a nine count makes a strike. (It does not, of course.)

That's it! A couple of very important points:

This is a 'Bottom-up' Web Service. (One where you start with code, not start from WSDL). These are easy to develop, but may not fit well in your 'Production' environment.

There are other ways to test your Web Service, including facilities within NetBeans itself. I wanted to use SOAPUI, though, because it's a great tool that's very versatile.

Happy Coding!

SOA Best Practice: Start with the schemas

2010-03-20T09:38:00.003-05:00

We've been doing some deep-dive evaluations on SOA tool suites at work, so I've had some recent exposure to a variety of toolsets. We've been investigating both proprietary and open source suites and components, so I've been able to work with a variety of SOA IDEs.

One thing I've noticed: In many cases, your life is much easier if you start with your schemas that represent the messages being shuffled from component to component.

A short while back, this would've caused me a little distress. I've had bad feelings about XML, based on memories of pain filled hours spent hand-editing XML files. Namespaces, the order things have to appear in XML files (Mule 1.4 config, anyone?), and others tripped me up time and again. I imagine this is common, else bottom-up web service development wouldn't be so popular.

Well, I'm pleased to announce that XML tooling has matured to the point where I found myself not dreading working in a top-down (XML schema first) manner. I've recently worked with both proprietary and open source tools that effectively hid the underlying complexity of the XML from me.

Most of the tools have nifty 'Design View' panels that let you visualize (drag and drop) the XML document you want to write. They'll have property tabs that allow you to add the syntactic elements, and a way to change views to see the underlying XML document if you want to. After a short while, I started really liking this way of working with XML.

So back to the SOA storyline-- because of these nifty visual editors, I found it totally natural to work in a top-down (contract first) manner. The SOA toolkits liked this much better, as they are able to provide meaningful dialogues that let me choose which data bits should be marshalled, transformed, whatever. I got to see the other side of the coin, too. Most of the tools let you design in a schema-less way (dragging components onto a BPEL canvas without specifying the schema, for example), but these efforts turned out to be much more difficult than starting with the schemas. (Or so it seems to me.)

So I'd have to call this one a triumph for technology. What used to be hard is now easier, and it leads to one of my personal best practices for SOA: Start with the schemas.

Coming Soon: Review of 'OpenX' Ad Server book

2010-03-19T17:25:00.007-05:00

I'm anticipating reviewing Packt Publishing's soon to be published "OpenX Ad Server: Beginner's Guide".

The book's description (found here) promises to instruct any reader with an understanding of IT basics on how to use OpenX. OpenX is an "Ad Server", or a platform to help you run advertising campaigns. It's supposed to help you display ads, find which ads are most effective, utilize GeoTargeting, provide metrics to help you judge your effectiveness, and more.

I have to be honest, this appeals to me. I use Google Analytics to track readership of this blog and I've become addicted to the statistics it provides. If I had a similar package that would help me serve a few relevant ads, track reader interest in these ads and maybe even make a few bucks in the process somehow, that would be really cool!

The book is slated for print soon, watch these pages for a review.

'Till then,

Happy Coding!

A shortcut from Junior Programmer -> Journeyman

2010-03-16T20:57:00.006-05:00

Programmers generally have 2 transitions they can go through in their career lifespan:
-From Junior Programmer to Journeyman
-From Journeyman to Heavy Hitter

Some programmers don't make the transition to Journeyman. Mostly these are folks that just aren't suited to the profession for one reason or another and quit within the first 3 years or so. Very rarely, you'll find a 10 year Junior Programmer, but these are a rare breed.

Most programmers stay at the Journeyman level for the duration of their career. There's nothing bad about this-- these folks make up the bulk of the workforce and get most of the work done. These are people who prioritize their life in such a way that they spend a 'fair' amount of time on their career, but don't go out of their way to constantly study IT in the off-time. These are the people everybody depends on to carry out their orders and keep things moving.

A small percentage of programmers make it to the 'Heavy Hitter' level. Every organization has them-- the folks who set new directions and establish development processes. These guys can't afford to stagnate (because they are relied upon to bring new ideas) so they're always studying.

This column deals with that first transition. If you're a Junior programmer today and are looking for a way to make it to the next level, read on.

I know of a technique that can be used to accelerate the first phase and move you to the second one as quickly as possible. This is important for two reasons:
- It brings more responsible assignments (and with them more pay and geeky prestige)
- It starts your 'time in grade' in the Journeyman level, which is a necessary prerequisite towards advancing to the 'Heavy Hitter' level, if that's your ambition

To use this shortcut, you'll require 3 things:
- A solid, working plan of self-improvement
- A reliable pipeline of work assignments, at least 4 or 5 months worth
- A viable alternative place of work that is hiring

1) A solid working plan of self-improvement
You need to conduct yourself in such a way that your boss realises you are on the way to more responsible work assignments. Back when I was a junior programmer (in the stone ages), this meant reading IBM manuals and workshop binders, and taking home thick mainframe greenbar compile listings. Today, this means studying things on the web and on your home computer, and studying your company's business artefacts in your off time. If you aren't willing to part with the time to devote to these activities, stop reading now because this shortcut won't work for you.

2) A reliable pipeline of work assignments
You need to have a steady stream of assignments in your near future, tasks you know your boss is going to assign to you. Some of these will be things that you are best suited for based on your skill sets. Some can be tasks you volunteer for because nobody else wants to do them. Either way, you want to position things so that your boss considers you the go-to person for a bunch of work that's slated to happen in the near future.

3) A viable alternative place of work that's hiring
Of the 3 requirements, this is the only one that requires something other than disciplined hard work. What it does require is a little research and a healthy dose of 'guts'. You need to look inside your company and out for a job posting that's for a programming job at the Journeyman level. They aren't hard to find-- if it's not paying at the guru pay scale and if it doesn't say 'Junior Programmer', then that's your target. Make sure it's someplace you actually would consider working for and make sure you're reasonably qualified for the posting (albeit at the low end).

The Plan:
After making absolutely certain you have your 3 requirements met, make an appointment to talk to your boss. In your conversation, say something like this:
"I've been working hard on advancing my career, and I think I'm ready for more responsible tasks. I really like what I'm doing here, and think I'm making a difference, but I'm tempted to look into this position I see at (name your third Requirement). Can you help me get promoted here so I can advance my career, but still stay here?

If your boss acts like mine did, he will immediately adapt a defensive position in which he hurriedly explains why you can't just ask for a promotion and it's not your time yet. This is fine-- his job is to keep expenses low and to maintain stability in personnel matters. What he really needs is a little time to think things over, because you really are bringing him a good business proposal. Your response should be something like "Well, I'll keep working and learning, but please give it a little thought. How about if we follow up in a week?"

That should give your boss plenty of time to really consider things. If you've done a good job with your prerequisites, your boss should be thinking thoughts like these:
- If I don't keep (insert your name here), I have to train somebody else to do all this stuff. It'll take forever to get a Junior programmer to that level again.
- (Your name) has already been taking on some mid-level assignments. It's a little early, but that promotion will come soon anyway.
- Crap! Where am I going to get someone to handle that stream of work I've got lined up for the next 4 months?
- (Your name) is being a little ambitious here, but I respect that he wants to advance his career.

Then in your follow-up, there are a few things that might result:
- You get the promotion. In that case, congratulate yourself and send me a nice thank you note.
- You are told you're still a little green, but you can work on your development plan and perhaps get your promotion soon. If this happens, BE SURE TO ASK ABOUT TIMELINES. It's up to you to decide how much emphasis to put on the 'viable alternative place to work' at this point. (Do NOT over-emphasize this, as your position really isn't that strong. The purpose of that requirement was to lend a matter of urgency for your request-- the "Why now?" factor). NO MATTER WHAT, YOUR CAREER IS YOUR RESPONSIBILITY, SO SECURE SOME COMMITMENT TO A TIMEFRAME FOR YOUR ADVANCEMENT. Think of it as a project deliverable-- you need to establish a timeline.
- You are flatly denied. In this case, you will have been given some valuable feedback in some form or other-- think about what it means.

Remember, your boss is a business manager, and as such is going to respect the business aspects of your proposal. If you've been diplomatic (and not a ham-handed extortionist) you should not have angered your boss. If anything, your boss will have a newfound respect for your professionalism. (And if not, again-- you have some valuable feedback.) To get to be your boss, this person has had to have gone through a few promotions, too. They know what it's like to want to move ahead.

This plan worked for me 18 years ago. If you choose to try it, I hope it works for you, too. Good luck, and Happy Coding!

"PHP 5 e-commerce" by Packt

2010-03-13T09:47:00.004-06:00

I've just finished reading "PHP 5 e-commerce" published by Packt Publishing and wanted to provide a review.

Make no mistake about it, this book is all about writing an e-commerce web site and little about teaching the reader PHP 5. That's ok for us hard-core developers, though, as the included PHP is so clean and so simple it won't be a problem for PHP novices.

The core of the book is about writing a web site to sell things. Early on the author introduces the handful of patterns that will be used (MVC, Registry, Singleton) then immediately provides a runnable skeleton MVC framework that handles only Products and Categories. After that, it's an incremental build chapter by chapter as the author adds features to the web site.

Without question, one of the book's strong suits is the author's knowledge of e-commerce features. The book covers all the features you're going to want (Search, Payment, Discounts and Vouchers, Recommendations, User Reviews, etc. etc.). Each of these is given adequate coverage and a clear implementation, chapter by chapter. The book ends with some tiny chapters on odds and ends like password recovery, calling out to other commerce sites, etc.

If you're looking for a PHP book, this isn't the title you want. There's simply nothing here (besides plenty of good, well commented source code) to teach you the language. But if you're looking to learn how to write an MVC application, there is value here.

I'd recommend this book to anyone that's building an e-commerce site. The author's care in enumerating the many features you'll want is valuable advice you can leverage.

PHP 5 e-commerce can be found here.

SOA's beginning to feel a lot like CORBA

2010-03-13T06:29:00.008-06:00

If you ever visit my garage, you'll find a couple of book shelves out there. On the shelves are an array of computer books, on all sorts of topics. I'll sometimes buy books at garage sales, at the GoodWill store, or especially off Amazon from the 'used' section. Most of the books I buy are cheap-- I'll buy 2 or 3 books off Amazon for a few bucks each plus shipping. I like books better than online reading because I can mark them up and take them with me wherever I go. (Sorry, a Kindle just doesn't seem the same. I ease my conscience by telling myself I'm buying used, so I'm not really causing any new trees to be felled.) A few of the books I've bought this way are terrible, but most have at least a few good chapters and a couple have been really good. I'm able to get more perspectives on a topic by buying in quantity rather than spending more money for quality. (By the way, I keep a few books inside the house-- any 'high dollar' new books, or any books that have my name inside them for some reason. By keeping only a subset of my books inside the house, I've found my married life is much happier!) Among my 'outside' books you'll find a couple of volumes on CORBA.

We still use CORBA in places where I work. Mostly we make use of the 'Naming Service' and the data-marshalling capabilities (which we find to be very performant, BTW). The 'Naming Service' is a sort of registry for CORBA services. When my service comes up, it uses a well-known (that is, hard-coded and shared by other services) address to reach out to the Naming Service. My service then registers itself with the Naming Service by supplying a name for itself and the address of the machine it's running on. (So my service might pick the name /Persistence/Sharding/ShardLocator.) Then whenever a client wants to use my ShardLocator service, it uses the same well-known address to get to the Naming Service, and it asks it where it can find /Persistence/Sharding/ShardLocator. The Naming Service will pick either my service or another machine that hosts this service and tells the client that's where the service can be found. When my service shuts down, it is obligated to un-register with the Naming Service so the registry in theory contains only 'live' service instances. (Note to newbies: This is done so clients don't have to hard-code the location of servers they need to talk to. Then when a machine fails or you add a new server instance, it's easier.)

If I look through one of my ancient CORBA books, I see great tales of what CORBA should be used for. There are distributed transactions, mechanisms for dynamically finding and invoking methods, a query mechanism, etc. etc. But as I said, we make use of only a few simple services. I think this is common-- I bet most people that still use CORBA only use a few parts of the whole spec.

Lately, I've been working on a team charged with architecting a sizeable new greenfield application. We're considering different SOA components to use-- an ESB, an orchestration engine, maybe some other parts. If you look at SOA suites offered by big vendors, you'll see quite a laundry list of components-- Governance helpers, Business Rules Engines, Complex event processing, etc. (By the way, the open source guys offer these too.) But I'm not sure we'll be using all that stuff, probably just the parts we really need. The whole thing is beginning to feel vaguely like CORBA.

CORBA and SOA are also similar in that they were largely spec-driven efforts that tried to answer all the problems the industry was trying to solve. I think it's widely accepted that the reason they didn't realise full potential was that the specs grew too complicated (WS-* anyone?) and the vendor implementations didn't really interoperate.

It's been over a year now since a prominent industry analyst proclaimed "SOA is Dead". (Google that one, you'll find plenty.) So it looks to me like SOA has roughly followed the same lifecycle CORBA did:

CORBA was lively from roughly 1990 - 2000
SOA was lively from roughly 2000 - 2010

Cloud, to me, is a lot like SOA re-packaged with some machine requisition thrown in.

I'm left pondering a few questions:
- How will we look back at SOA a few years from now?
- Will we have another tech stack arise for the next decade? What will it be?

Thanks for reading, and Happy Coding!

A secret key to 'Senior' level programming

2010-02-26T19:37:00.008-06:00

When I first started in DP ('data processing', we called it then) 20 years ago, I was working for a company that acted as an outsourcer for banks. I started with the company as a trainee, then graduated to the first programmer 'rank' of Junior programmer. Internally, this title carried the cryptic title 'E07'.

I soon found out my company ranked programmers in this way:
Junior programmer = E07
Programmer = E08
Senior Programmer = E09
Superhero = E10 (a very rare breed)

Payscales, of course, were tightly coupled to these ranks, much the same way they are today.

Like all junior programmers, I hoped to spend my required year or two in the E07 ranks, then move up. One thing I was lacking, though, was an understanding of what made the difference between the programmers that went to the very highest ranks and those who stayed in the lower levels.

One day I was working on a project with a kind-hearted E10 named James. We were having a friendly conversation about the kinds of tasks we had ahead of us when James made a profound statement. He said "The work is all the same, whether you're an E07 or an E10".

I was dumbfounded. Not until that moment had I realized that the work I was doing was just as important to the success of the project as the task James was working on. I was doing analysis and coding, James was doing analysis and coding. Even though he worked at the stratospheric E10 level, he used the exact same compiler I used, he worked on the exact same data I worked on, and he used the exact same development environment I used. A failure on his part would embarrass the shop, and a failure on my part would embarrass the shop. In the context of this project, we were peers!

Now, don't get me wrong. Junior programmers are most certainly NOT worth the same money senior programmers are. Today, I depend heavily on widespread recognition of this fact. But at that time, I gave this matter a little thought and came up with an observation that has benefited me immeasurably, to this day.

I looked to my friend the E10 and asked myself what the difference was between his skill set and mine. I drew the conclusion there were at least 2 areas in which he was superior: breadth and depth.

Breadth meant that he had a much wider array of tools at his disposal. At that time, I possessed a moderate amount of knowledge about batch COBOL programming. My friend was knowledgeable about batch COBOL, online COBOL, assembler, JCL, system skills, and more. In today's world, this would equate to something like a Java guy standing next to a Java guy that also knows C++, C#, Ruby, Python, Erlang and a good number of frameworks for each. If the project du jour is just plain Java, those two are on equal footing. But when the next project comes along things could most certainly be different.

The other dimension is depth, which refers to the amount of knowledge held in the workplace domain. In my yesteryear story, I knew how to write and compile my COBOL program, maybe even as well as my friend. But if my program had a bug, I had one trick up my sleeve-- diagnostic debug statements. My friend had that and the ability to read core dumps, knew how to make the compile listing show assembly language (which he could look over for performance heuristics) and more. In other words, beyond the surface of the program source code we produced, he had a much better understanding of the platform we were operating on and how to exploit it. Again, my source code might have been a match for his, but if we needed to go to the next level..... there was an indisputable difference.

In today's world, this might mean the senior guy understands how to tune a JVM, or how to extract meaningful data from profiling tools. The senior level guy knows how to install, configure, debug and profile the platform. The senior guy will know how to establish the build environment, the junior programmer will likely only be productive once it's established.

So I guess I figured out that I had a lot to learn, and set about trying to increase my own depth and breadth. (An effort that continues to this very day!) James' words from two decades ago have helped me measure myself against my peers to see where I need to improve, and this has furthered my career in more ways than I can imagine. If you're on the young side of your career, I hope they can help you, too.

Happy Coding!

Rick

E-commerce in PHP

2010-02-24T18:12:00.006-06:00

I recently had a chance to sit down with a workplace friend of mine who specialises in writing UI applications. I really don't spend a lot of time in that workspace, so I was happy to listen to what my friend had to say about current trends in UI authoring. The discussion was mostly about the right parts to use in building a corporate portal, but I was shocked when my informed friend told me a great amount of the high-volume online work is actually backed by PHP and C.

Everybody likes PHP, right? Mostly I thought of it as a hobbyist's language, though. Clearly, I have some learning to do about the things making today's cash registers ring.

Luckily, Packt Publishing has just the title to help enlighten me. It's called "PHP 5 e-Commerce Development". I started with the free sample chapter, which can be found here.

The table of contents looks promising, so I hope to get some good insites from this book. Watch this space for a review soon.

What in the world is a "List Comprehension"?

2010-02-20T08:24:00.004-06:00

Sometimes I'll read something about a programming language I don't know and I'll be a little curious about some term I'm not familiar with. The writer will rave on and on about how great this language is because it supports this thing, yet I don't understand what it can do for me. Until recently, this is how it had been for me with "List Comprehensions".

Well, I found an excellent explanation of List Comprehensions in Erlang. Here's my thumbnail explanation:

"A List Comprehension is a way to apply some function to every member of a list."

Now, for an example. Here's an example, straight from the Erlang shell:

1> AList = [1,2,3,4].
[1,2,3,4]
2> ListDoubled = [ X * 2 || X <- AList ].
[2,4,6,8]

Let's look at this, line by line.

1> AList = [1,2,3,4].
This is me typing in the List I want to start with. Obviously, it contains 1,2,3, and 4.

[1,2,3,4]
This is the Erlang shell, responding with the right hand side after binding the list to the variable AList.

2> ListDoubled = [ X * 2 || X <- AList ].
This is the List Comprehension. It reads something like this: "A variable named ListDoubled should be bound to a new list made from applying the function "some variable times 2" to every item in an existing list, which is called "AList".

[2,4,6,8]
This is the result of my List Comprehension. As it should be, every member of the first list was doubled.

So that's it! A List Comprehension is just a very compact way to apply some function (and some filters, it turns out) to a list. The result is another list.

For more on List Comprehensions, I'd refer you to the excellent book "Programming Erlang" by Joe Armstrong. It's very readable, and makes learning new concepts easy.

Happy Coding!

Rick

Book Review - "Funambol Mobile Open Source"

2010-02-15T18:04:00.001-06:00

Book Review for "Funambol Mobile Open Source"

If this book sounds interesting to you, it can be found here.

I've just had the chance to read a copy of "Funambol Mobile Open Source" by Packt Publishing. Here's a quick review of what you'll find in this book.

First, for those of us who haven't heard of Funambol before-- it's an open source platform for synchronizing data on mobile devices. Funambol will let you keep your email, personal contacts, and other data kept current on multiple devices. The server is available for Windows or Linux and is easy to operate.

The book is really two books in one-- the first part is a well-detailed user's guide, the second part is a developer's guide for those who want to develop software rather than just use it.

Part one covers product installation, an explanation of the application architecture, user administration, e-mail, PIM (address book and calendar), and the Funambol community.

Part two brings starts the heavy technical content. It contains SyncML (the protocol used to pass data back and forth between the Funambol server and the various devices it connects to) and a detailed chapter on how the reader can extend the server's Data Synchronization Service.

Being technical by nature, I enjoyed the content of the last two chapters-- there were some really good ideas there about how to extend Funambol if it doesn't do exactly what you need it to.

All things considered, I'd think this book would be great for anyone who has a need to syncrhonize data across mobile devices. The first part of the book really is user-friendly-- it starts from ground zero and presents all the steps necessary to use Funambol in a clear and logical manner. There are many screen shots, and everything is spelled out in sufficient detail. This part of the book reminds me of really well written professional-grade documentation. (Except it's written in sort of a use-case manner, leading the reader alongside a mythical user of the application as she sets up her system.)

If you're in the market for a data synchronizer for your mobile devices, give this one a read!

Happy Coding,

Rick

Let's go Funamboling!

2010-02-02T20:09:00.006-06:00

Funambol Mobile Open Source available here

What's that, you say? You've never been Funamboling? Well, that's good, because neither have I. In fact, I believe I've just made that word up, so we may very well be the first people ever to "go Funamboling"! So what does that mean?

As a programmer, I'm always interested in learning new things, especially if I can put them to some practical use. In the recent past, I've studied R, Drupal, and Erlang, to name a few. Sometimes I learn something I can immediately add to my programmer's toolkit, and sometimes I just learn something different to keep my brain elasticity up. In that spirit, I will soon offer a review of a Funambol book, something I have never touched before.

Funambol, which I have just become aware of today, is an open source technology used to synchronize smart phones and other devices with PCs. Using Funambol, you can keep your calendars aligned, sync your email, and keep your notes in order on multiple devices. It has Java and C++ APIs, so I'm hopeful I'll be ready for the code portion if not a master of the problem domain immediately. It sounds interesting, so it should be a good learning journey.

If this sounds like something you might try, I'd encourage you to check out some of the videos on YouTube. (There are a bunch! How did this thing get so big without me hearing of it?) One such example is here.

The book's in the mail, so watch this space for tales of my ventures into Funamboling soon!

Book Review - JBoss AS 5 Development

2010-01-31T20:10:00.003-06:00

This book found here.

Book Review for "JBoss AS 5 Development" by Packt Publishing

This review is for "JBoss AS 5 Development", which has the subtitle "Develop, deploy, and secure Java applications on this robust open source application server". Having gone through the book with IDE in hand, I would have to say I find the subtitle more indicative of the content than the first part of the title. Later I'll try to explain why I feel so.

The book promises to cover a great amount of territory. Roughly, the 14 chapters cover these topics:
- Installation of the application server and Eclipse-based IDE toolkit
- Major differences between JBoss AS 5 and previous versions
- Customizing your JBoss installation
- Developing EJB 3 Session beans
- Working with JPA
- Writing a web application (JSF)
- The new JBoss messaging subsystem (JMS)
- Writing Hibernate applications on JBoss
- JMX and MBeans
- JBoss Web Services
- Clustering JBoss servers
- Writing Clustered Applications
- JBoss AS Security
- Securing applications under JBoss

If that seems like quite a list to digest, I would agree. The last 4 chapters give a hint to the depth of content the reader will encounter. In those cases, the author first presents an overview chapter about how the application server handles the topic (clustering, security), then follows it up with a whole chapter about applying the implementation details. I thought this struck the right balance between being too high-level (as many books might be) versus being overly detailed (as the old JBoss 4 AS doc book could be in places.)

I think this book will be an excellent acquisition for anyone who is certain they will be working with JBoss AS 5. The author has a deep understanding of the application server and writes in an easy to understand style. The book covers a great amount of 'real world' territory that is sure to be of interest for anyone tasked with moving an application to production under JBoss AS 5. Subjects like security and clustering (must-haves in a production environment) are given enough coverage that they can be of immediate practical use. (Note: these topics are not of vital importance in a pure development effort. A great amount of development can be done without paying attention to either security or clustering.) This is one reason I consider this book to be an interesting blend of development material and administrative material-- it is clearly not a pure development book.

For those that are interested in learning JEE but are not certain they'll be using JBoss, I'd suggest they should consider this book but also compare it to other titles, perhaps one of Packt's excellent NetBeans/GlassFish titles. This is not the fault of the book-- the author does a good job of walking the reader through various exercises in building EJBs, a JSF front-end application, a web service application, etc. The reason I don't suggest this book for new students of JEE is that the raw toolkit is just not at the same level some other open source development stacks are at. (Notably, NetBeans 6.8 and GlassFish). Putting it plainly, there are more than a few things that can go wrong in putting together a JEE application with JBoss Tools-- if the user isn't seasoned in problem analysis and debugging, it could easily lead to frustrations and an unsatisfactory experience.

If you're already confident in your ability to write and deploy JEE apps, you should find this book to your liking. Intermediate to advanced JEE developers ought to find plenty of material to keep them interested. Performance tips, JBoss specific extensions, and expert usage tips for enterprise Java development all get good coverage. The author knows the ins and outs of using JBoss AS 5, and is generous in providing tips in effective usage of facets the reader is likely to encounter. The author also provides good high-level overview material (which usually precedes the detail), which helps keep the reader grounded in the larger context of what's being conveyed.

The book provides a reasonable number of illustrations, including screen shots of JBoss Tools wizard screens. I found these of reasonable value, but have to admit I'm of mixed emotions on the toolset itself. It does a great job of some things (I love the packaging wizard that let's you declaratively roll up .jars, .ears, etc.). On the negative side, it makes some actions much more difficult than they have to be. I thought the author did a good job of providing meaningful illustrations where an abstract idea was being presented, especially in the security and clustering chapters. I once made a presentation at JBoss World about studying for the Sun Certified Enterprise Architect exam using JBoss-- I wish I'd had those illustrations then! I guess my SCEA is now a depreciated asset-- maybe we'll have to study for 'Oracle' architectural credentials in the future.

All things considered, this book will be an excellent source of information and reference for anyone using JBoss AS 5. I'm sure it will prove value time and again as the reader delves into the various corners of enterprise Java. This book offers expert insites on many topics and does it in an easy to read manner.

Happy Coding!

Birth of a NetBeans fan-boy

2010-01-27T20:24:00.003-06:00

As I mentioned at last post, I've been reviewing the Enterprise Java development stack. I've just finished writing some basic JPA applications using two different Application Servers (JBoss, GlassFish) and toolsets (JBoss Tools, NetBeans). I really like Eclipse and JBoss, but I really have to hand it to the NetBeans folks on this one. Here's what I found to like:

- NetBeans will generate your Entity Beans for you, based on your schema (JBoss Tools does this, too)
- NetBeans will generate Session Beans based on those Entity Beans
- NetBeans will even generate a JSF CRUD application for you, exposing those Entity Beans!
- NetBeans will generate your Persistence Unit for you
- NetBeans will generate your DataSource for you (I think JBoss makes you copy a template file by hand for that one)

All these things alone aren't so stunning, but what's really cool is the cohesive feeling the IDE gives you. All that, plus integrated App Server control, Database control, etc. (In fairness, JBoss Tools offers a lot of these, too.)

Now, for the grand whammy: I am ecstatic about the NetBeans Hadoop plugin from Karmasphere, which I first saw here. That plug-in just flat out rocks! Using that plug-in, I ran my first Windows Hadoop job this afternoon about 20 minutes after I first saw the article. Tonight, I ran a second job on my Ubuntu laptop (which runs an honest Hadoop installation as well) in about 2 minutes, without looking back at the instructions. Everybody needs to look at this plug-in, it's flat out cool and makes Hadoop development an easy, desktop proposition.

So here I sit, a several-year Eclipse user absolutely stunned by NetBeans 6.8. I can only hope Oracle lets this IDE continue, it is definately raising the bar.

So go get yourself a download of NetBeans 6.8, and Happy Coding!

Rick

A few things I like (and don't like) about EJB3

2010-01-21T19:12:00.002-06:00

What I like (and don't like) about EJB3 and recent IDEs

It's been a long time since I worked with JEE, so I've recently been working with late-model application servers from Sun and Jboss. (I wanted to work with both at the same time to see which toolset I really liked best, and to help me better understand things.) This week I've been working with EJBs and I'm delighted to report EJB3 really does fulfill the promise of greatly simplified development. After a few hour's practice, I am now confident I could crank out a Session bean from scratch in less then 5 minutes on either JBoss or NetBeans. (In the old days, this never would have been possible.)

Here are a few of the things I liked and disliked about my re-acquittance with EJBs.

What I like:
1. Plain annotated POJOs in a .jar -- no XML, and it really does work.
2. NetBean's 'Insert Code'/'Call Enterprise Bean' wizard. Client code made simple!
3. The excellent online tutorial here
4. Using JBoss Tools, I really like the 'Archive Manager' view. It gives you a great UI to make a .jar, .war, .ear, whatever you need. With no scripting!
5. The JBoss Tools 'Server' view. Easy, in-Eclipse way to start/stop the Application Server
6. Ditto for NetBeans and the GlassFish controls. (Extra credit to NetBeans for Database control in the IDE, too.)

What I didn't like:
1. NetBeans generating a bunch of stuff behind my back. (Of course you can use jar -tvf to see what it is, but I'd rather see it up front where I can easily understand it.)
2. JBoss and the never-ending story of how you really write EJB3 beans. They now have a bi-monthly plug-in you have to apply to keep your app server up to date! If you Google for a JBoss EJB3 tutorial, guess what you'll find? 17,000 blogs that tell you the way that guy did it, most of which won't work for you. (At least that was my experience.)
3. Writing a JBoss client that needs a properties file or in-line setting of necessary properties. In the old days that was fine, but NetBeans has raised the bar on that one. (Counterpoint: I guess I have to use the default ports, etc. for the NetBeans auto-magic client to work. Fine with me, for today at least. BTW, I recognize this is inconsistent with Gripe #1.)

If you've never written an EJB, or haven't written one lately, I'd really encourage you to have a look. (If you're really new to it, I'd suggest the NetBeans/GlassFish route, I think it's a little easier.) If this is the future direction of Enterprise Java, I am encouraged.

Next up: JPA persistence. Let's see how that one goes!

'Till then, Happy Coding!

Keeping Current with JEE-- the App Dev showdown, round 1

2010-01-16T14:20:00.005-06:00

JEE Development -- contemporary toolkits, Round 1

As mentioned earlier, I'm on a quest to refresh my Java EE skills. I've decided to explore two popular toolkits-- Netbeans/GlassFish and JBoss Tools/JBoss AS 5.1. This entry is the first of a short series documenting my findings.

Resource guides
To help me navigate the JEE waters, I'm using 3 titles from Packt publishing:

Java EE 5 Development using GlassFish Application Server
GlassFish Administration
JBoss AS5 Development

By the way, if you follow the above links you'll find free chapters and other resources.

Initial impressions:

Setup
GlassFish comes optionally packaged with NetBeans, in a very convenient single download. Everything was easy to use and worked out of the box.
JBoss Tools and JBoss are not integrated. JBoss Tools is a set of Eclipse plug-ins which you have to download into your Eclipse instance. On my Ubuntu laptop, both the app server and the Tools plug-ins downloaded and configured as advertised.
Advantage: Netbeans/GlassFish (hereafter 'Sun') for the tight integration.

App Server Configuration
I started out with some knowledge of old-school app server configuration, but it's been at least 2 years since I worked in this space. For that reason, I relied pretty heavily on my books for this section.
GlassFish offers both a well-put together UI and a command-line interface for most every configuration task. The UI is top-notch and intuitive to use.
JBoss offers 3 different UI consoles (Administrative Console, JMX Console, JBoss Web Console) and a wide array of XML-based files that can be used to perform most common administrative tasks.
Advantage: Sun, for ease of use. In the long pull, JBoss may offer a little more granularity in configuration, but unless you spend a lot of time learning the nooks and crannies, you're going to be up to speed much faster with the Sun toolkit.

So we end today's blog with the score 2-0, favoring the Sun JEE stack. Let's see if this holds true as we enter the application development arena in a near-future blog.

'Till then, Happy Coding!

GlassFish vs. JBoss -- current best dev kit?

2010-01-06T21:08:00.005-06:00

As I previously posted, lately I've been working with the Netbeans/GlassFish combination in an effort to keep my Enterprise Java skills current. I've been very pleased with the ease of application development and have to say that JEE has never been easier.

I have a concern, though. The shop I work at is a JBoss shop, which makes me wonder about the current state of the development world for JBoss developers.

I've worked with JBoss for a number of years, but never did find it especially easy to keep current on toolkit usage, especially compared to the aforementioned Sun toolkit. I really like the latest NetBeans all-in-0ne toolkit that runs the databases, App server, dev tools, etc. all within the IDE. To counter that, the last time I checked JBoss had a free offering that was comprised of a set of Eclipse plug-ins that offered similar functionality. It's been a while since I used that kit, but I don't remember it being nearly as slick as this latest NetBeans offering. Maybe it's time I have a fresh look at what the JBoss folks have in store for us.

I know I'm going to get results fastest if I seek expert counsel, so I'm going to refer to "JBoss AS 5 Development" from Packt Publishing. The book promises to cover plenty of ground, going from app server install, through the development process, security, and deployment all the way through app server clustering.

I've already had a read through the FREE sample chapter, which can be found here. The sample chapter covers use of Hibernate and Hibernate tools under JBoss, written in a very easy to understand step-by-step manner. In my next code practice session I'll get JBoss installed and try to establish my own basic Hibernate web app, based on the contents of this chapter.

I'll blog more about my luck with the JBoss kit after I've had a chance to read the book and write a few sample applications. Here's hoping we find good things there!

'Till then, Happy Coding!

Rick

Book Review - "GlassFish Administration"

2009-12-29T21:45:00.003-06:00

Book Review of "GlassFish Administration", Packt Publishing

Available here.

This book is meant to be a resource for users of the GlassFish application server. It covers many aspects of GlassFish usage, including installation, configuration, application deployment, clustering, performance monitoring, and more. I would believe this book is appropriate for Enterprise Java administrators of all experience levels.

The book is generously illustrated, often times making use of screen shots to help users navigate the excellent GlassFish administrative UI. Better yet, the book also provides the Command Line equivalents wherever the UI is shown. These handy tips will allow experienced administrators to script installations, significantly cutting down both time and errors.

The CLI tips are just one example of the author's mastery of advanced server control issues. The author, Xuekun Koum, clearly understands the needs of enterprise server administrators and clearly spells out many best practices. For this reason, I would recommend this book for anyone planning to use GlassFish in a production environment. The chapters on performance tuning, monitoring, and security alone will make this book worthwhile for that audience.

In addition to that audience, I would also recommend this book to Enterprise Java developers who wish to keep abreast of best coding practices for the Java EE platform. Have you ever seen a coding demo given by Sun engineers? Using Netbeans and GlassFish, they are usually able to quickly generate flawless Java EE applications using mostly plain intuitive Java. (No hand-configuration of deployment descriptors!) This book, paired with a recent release of Netbeans and "Java EE 5 Development using GlassFish Application Server" (another Packt title) will allow you to knowledgeably generate Enterprise Java applications as easily as the Sun folks do. I'll be honest-- I'm usually not a NetBeans/GlassFish user, but this combination makes it drop-dead simple to generate entire applications in no time. Best of all, the generated source and configuration files are so clean that it's a snap to understand what each component does so you can brush up on how the whole things works. GlassFish does it's part by nicely bundling all the required resources (databases, application server instances, JMS providers, etc.), making them all very easy to administer. I've long thought Microsoft developers had a leg up on productivity given their excellent IDE and matching runtime environment, but after working with this toolset for a while I now believe the gap is closing.

I own some other titles on application server administration as well as this one. Frankly, I find this the most readable of these books. The instructions it provides are straightforward and very easy to follow. The author provides expert insights that probably came from many hours of working with GlassFish in different production settings. (Some of these ideas extend beyond current use of GlassFish, as well. In this regard, the book provides some best practices that should give the reader some wisdom without having to pay for it the hard way.) This book also touches on topics that really aren't specific to GlassFish, but rather are of interest to anyone working with an application server. Of particular interest in this area are sections on application monitoring and load balancing.

As for complaints, I have few. The primary thrust of the book is GlassFish 2, which is the current production mainstay. There is a chapter on GlassFish 3, but I wish the book were weighted a little more heavily towards version 3 so the book would maintain relevance longer. (In fairness to the author, I guess it's not possible to offer real-world experienced opinions on products that haven't been in use for much time. So I guess the version 2 / version 3 ratio is about right, realistically.) I wish this title contained a little of the content from some of Packt's other developer-centric titles (i.e. Netbeans tips). Other than those, I can't think of any other wants.

All things considered, this is a solid addition to any Java architect/developer's library. I'd urge you to check it out!

Adventures in ORM

2009-12-24T14:43:00.004-06:00

I've been spending a little time over the Christmas break working with toolsets I don't usually use. (I think this helps me better appreciate the tools I use, no matter what they are.) For the past couple of days I've been having a look at Java ORM solutions.

I had a quick look at Spring 3 / Hibernate 3, but hit some resistance in the form of strange errors I couldn't easily resolve. Sometimes in this case I'll just dig in and spend as much time as I have to, but in this case I decided to put down this toolkit and pick up another.

I've been doing a little work with the GlassFish application server, so I thought this would be a good chance to pick up NetBeans and make use of some of it's neat features. Every time I see the Sun folks talk, they really make NB look attractive, so I was hoping to find something good there.

Well.... I initially liked what I saw. I already had a PostGres database (also not my usual choice), so I made use of a cool code-gen feature to instantly make some Entity objects. Really easy!

The Entity beans weren't much use without a wrapper class to use them, so I also auto-generated (all this through right-click!) some Controller classes off the Entity beans. Also very easy!

Now just to hand-code a 'Main' and invoke the Controller classes. Much to my chagrin, all my nicely generated code didn't work. What was up?

A quick look at the log showed the query that was generated. Something like this:
select Name, Id from BC_Schema.BowlingCenters

That was a good clue. I knew from running hand-built queries that PostGres preferred something like this:
select "Name", "Id" from "BC_First_Schema"."BowlingCenters"

The difference was only the quotation marks. (Maybe this seems natural to PostGres users. I don't often use it, so it seemed odd to me.)

After quickly searching the web (thanks Google!) I found the quick cure was to doctor up the generated Entity class. Wherever an annotation referenced a keyword in the query, I added a backslash-double-quote to make it print the quotes when it gen'ed the query. Example:

@Column(name = "Id")

Was fixed to be:

@Column(name = "\"Id\"")

After that, I was able to quickly generate Entities and Controllers, building out a db-based application in no time. Very productive!

Probably the most valuable idea I got from the whole adventure was this:

When working with a new ORM setup, start out by coding a plain JDBC snippet to view a few rows. This will convince you you've got your credentials right, allowing you to work with fewer factors as you run down your initial bugs.

Happy Coding, and Merry Christmas!

Hadoop Solution for the Hoppity problem

2009-12-18T18:04:00.002-06:00

The latest in the Code Snippet series.

A highly contrived solution to the Hoppity problem, using Hadoop.

Why in the world did I do this? After all, Hadoop is a batch framework for working with large amounts of data in parallel, hardly the right tool to solve a trivial small-data problem on a single laptop.

I did it primarily to exercise my Hadoop skills, though even here it's a light workout. But I think Hadoop is well worth learning and practicing, so here goes!

The Setup
- You have to have Hadoop installed. For that task, I used Michael Noll's excellent Hadoop-on-Ubuntu blog entry.
- If you have a problem running after Michael's instructions, if it's a host naming problem, be sure your hosts file has 127.0.0.1 as 'localhost'.

Run scripts
You'll probably want to use utility scripts for the following tasks:

# Compile
javac -cp /usr/local/hadoop/hadoop-0.20.1/hadoop-0.20.1-core.jar:/usr/local/hadoop/hadoop-0.20.1/lib/commons-cli-1.2.jar Hoppity.java
jar -cfv hoppity.jar *.class

# Make a directory
bin/hadoop dfs -mkdir /user/hadoop/HoppityInput

# Copy the file containing Hoppity input into the directory
bin/hadoop dfs -copyFromLocal numHops.txt /user/hadoop/HoppityInput

# Run
bin/hadoop jar hoppity.jar Hoppity /user/hadoop/HoppityInput /user/hadoop/HoppityOutput

# View your output
bin/hadoop dfs -ls /user/hadoop/HoppityOutput
bin/hadoop dfs -cat /user/hadoop/HoppityOutput/part-r-00000

# Destroy the output directory for the inevitable re-runs as you learn
bin/hadoop dfs -rmr /user/hadoop/HoppityOutput

Finally, the code

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class Hoppity {

  public static class HoppityMapper 
       extends Mapper<Object, Text, Text, Text>{
    
      
    public void map(Object key, Text value, Context context
                    ) throws IOException, InterruptedException {
        int theValue = Integer.parseInt(value.toString().trim());
        StringBuilder result = new StringBuilder();
        for (int idx = 1; idx < (theValue + 1); idx++){
            if (isModN(idx, 3) && isModN(idx, 5)){
                result.append("Hop~");
                continue;
            }
            if (isModN(idx, 3)){
                result.append("Hoppity~");
                continue;
            }
            if (isModN(idx, 5)){
                result.append("Hophop~");
                continue;
            }           
        }
        Text resultKey = new Text("ResultKey");
        Text resultValue = new Text(result.toString());
        context.write(resultKey, resultValue);
    }
    
    private boolean isModN(int num, int mod){
        if ((num % mod) == 0){
            return true;
        }
        return false;
    }
  }
  
  public static class HoppityReducer 
       extends Reducer<Text,Text,Text,Text> {

    public void reduce(Text key, Iterable<Text> values, 
                       Context context
                       ) throws IOException, InterruptedException {
      for (Text val : values) {
          String[] hops = val.toString().split("~");
          for (String hop : hops){
                  Text blankText = new Text();
              context.write(blankText, new Text(hop));  
          }
      }      
    }
  }

  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
    if (otherArgs.length != 2) {
      System.err.println("Usage: Hoppity <in> <out>");
      System.exit(2);
    }
    Job job = new Job(conf, "hoppity");
    job.setJarByClass(Hoppity.class);
    job.setMapperClass(HoppityMapper.class);
    job.setCombinerClass(HoppityReducer.class);
    job.setReducerClass(HoppityReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(Text.class);
    FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
    FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

Happy Coding!

A fish of a different color....

2009-12-14T18:40:00.004-06:00

It seems there are many books available tell you how to develop software for various JEE application servers. These books are invaluable when you are writing your software components, especially when the technology is new or you are venturing into territory you haven't visited before.

But there comes a time when your development work is done, and you need to go to the next level. You need to integrate your work with external entities like JMS providers. You need to harden the environment and secure it. You need to monitor the application server, watching for resource usage trends and guarding against future failures. You need a book that emphasizes Application Server administration, not component development.

I've just been informed of a new book from Packt Publishing that emphasizes administration of the excellent GlassFish AS. The book, titled "GlassFish Administration", is scheduled for publishing later this month. I read the sample chapter and found it well written, illustrated generously with easy to read diagrams and friendly screenshots.

I hope the rest of the book is as good as the sample chapter. Watch this blog for a full review as soon as the book is available!

Happy Coding!

Erlang solution for the Hoppity problem

2009-12-12T15:01:00.007-06:00

The latest in the Code Snippets series.

An Erlang solution to the Hoppity problem.

For those who have never tried functional programming, here's a taste of what you might encounter. For those who know how to program in this way, I salute you! I did much learning on the way, there is much more road to travel.

To run the code:
Put the code in a file called hoppity.erl.
In the Erlang shell ('erl'), compile the file by typing:
c("hoppity").

Run the code in the Erlang shell:
hoppity:start().

-module(hoppity).
-export([start/0]).

start() ->
    {ok, Device} = file:open("/home/rick/Programming/Hoppity_Hop/data.txt",[read]),
    ALine = string:strip(getALine(Device)),
    {AsInt, Junk} = string:to_integer(ALine),
    printHoppity(AsInt),
    io:fwrite("~n~s", [" "]).


getALine(Device) ->
    case io:get_line(Device, "") of
        eof  -> file:close(Device), "None";
        Line -> file:close(Device), Line
    end.

printHoppity(Num) ->
    printHoppityNTimes(1, Num).

printHoppityNTimes(Current, Max) ->
    if Current > Max ->
        pass;
    true ->                % 'else'
        ByThree = Current rem 3,
        ByFive = Current rem 5,
        %io:fwrite("~n~s", [integer_to_list(ByThree)]),
        %io:fwrite("~n~s", [integer_to_list(ByFive)]),
        printHoppityValue(ByThree, ByFive),
        printHoppityNTimes(Current + 1, Max)
    end.

printHoppityValue(0, 0) ->
    io:fwrite("~n~s", ["Hop"]);
printHoppityValue(0, _) ->
    io:fwrite("~n~s", ["Hoppity"]);
printHoppityValue(_, 0) ->
    io:fwrite("~n~s", ["Hophop"]);
printHoppityValue(_,_) ->
    pass.

C++ Solution for Hoppity problem

2009-12-12T14:12:00.005-06:00

Here's a C++ language solution for the Hoppity problem. This is part of the Code Snippet series.

To run this:
Make a simple Make file and a script to run the resulting executable, or else run it in your favorite C IDE. I used Netbeans to build this one. The only argument to the exe is the path to the file that contains the number as described by Hoppity.

The code:

#include <stdlib.h>
#include <iostream>
#include <fstream>

using namespace std;

bool isModN(int num, int mod){
    if ((num % mod) == 0){
        return true;
    }
    return false;
}

int main(int argc, char** argv) {

    if (argc < 2){
        cout << "Must have 1 argument, the file name" << endl;
        exit(1);
    }

    ifstream inFile;

    inFile.open(argv[1]);
    if (!inFile) {
        cout << "Unable to open file" << endl;
        exit(1); // terminate with error
    }

    int theNum;
    while (inFile >> theNum) {
        //  assume it's good -- don't do this when coding for 'real'!
    }

    inFile.close();

    for (int kount = 1; kount < (theNum + 1); kount++){
        if (isModN(kount, 3) && isModN(kount, 5)){
            cout << "hop" << endl;
            continue;
        }
        if (isModN(kount, 3)){
            cout << "Hoppity" << endl;
            continue;
        }
        if (isModN(kount, 5)){
            cout << "Hophop" << endl;
            continue;
        }
    }

    return (EXIT_SUCCESS);
}

Python solution for the Hoppity problem

2009-12-11T09:10:00.004-06:00

An entry in the Code Snippet series.

Here's a Python solution to the Hoppity problem.

How to set it up:
Copy the script below into a shell script.
Copy the code below into a file, Hoppity.py
Make a data file that contains the number, as required in the Hoppity problem.

How to run it:
Run the script, give it the path and name to your data file.

The script:
echo "Tell it the path to your data file, i.e. /home/rick/FaceBook_Puzzles/data.txt"
python3 Hoppity.py

The code:
import sys

#input_file = open("/home/rick/FaceBook_Puzzles/data.txt",'r')
line = sys.stdin.readline()
input_file = open(line.strip(),'r')

as_string = input_file.read()
the_val = eval(as_string)
for idx in range(1, (the_val + 1)):
if ( ((idx % 3) == 0) and ((idx % 5) == 0)):
print ("Hop")
elif ((idx % 3) == 0):
print ("Hoppity")
elif ((idx % 5) == 0):
print ("Hophop")

The Hoppity Problem

2009-12-11T08:55:00.002-06:00

Here's the first problem I'd like to post in the new Code Snippet series. Thanks goes to Facebook for providing this one!

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

Hoppity Hop!
Write a program that takes as input a single argument on the command line. This argument must be a file name, which contains a single positive integer. The program should read this file and obtain the integer within, and then output a sequence of strings based upon the number (details below).

Input specifications
The input file will contain a single positive integer (in base 10) expressed as a string using standard ASCII text (e.g. for example, the number "15" but without the double quotes). This number may or may not be padded on either side with white space. There will be no commas, periods, or any other non-numeric characters present within the number. The file may or may not terminate in a single new line character ("\n"). An example input file is below:

15

Output specifications
The program should iterate over all integers (inclusive) from 1 to the number expressed by the input file. For example, if the file contained the number 10, the submission should iterate over 1 through 10. At each integer value in this range, the program may possibly (based upon the following rules) output a single string terminating with a newline.

* For integers that are evenly divisible by three, output the exact string Hoppity, followed by a newline.
* For integers that are evenly divisible by five, output the exact string Hophop, followed by a newline.
* For integers that are evenly divisble by both three and five, do not do any of the above, but instead output the exact string Hop, followed by a newline.

Example output (newline at end of every line):

Hoppity
Hophop
Hoppity
Hoppity
Hophop
Hoppity
Hop

The Code Snippets series

2009-12-11T08:51:00.003-06:00

I've decided to launch a series of blogs detailing my journey through programming tasks. I'll post a problem to be solved, then some solutions coded in different languages. My hope is that the code snippets will be small and clear enough that the blogs can be used as a reference, sort of a cut-n-paste repository to help coders quickly get program shells running.

The code snippets will not be industrial-strength implementations. They'll probably lack error handling, flexibility, optimized performance, and other attributes you'd like your real-world code to have.

The code snippets will offer quick'n'dirty implementations of common programming problems, formatted for maximum re-use.

Critiques and alternative implementations are welcome. Iron sharpens iron, they say, so feel free to suggest a better way. Watch for the first post soon.

Happy Coding!