I discovered the other day that the Pentax DA* 55mm lens has very tight tolerances for the provided lens cap. It fits tightly over the outside of the lens and doesn’t allow any overlap by an attached filter.

Pentax 55mm w. B+W Filter

I was trying to use a B+W MRC Nano UV-Haze filter which slightly overlaps the outside of the lens.

Pentax 55mm side view with attached B+W filter

A close up photo shows the 1mm overlap.

B+W Filter overlap

That extra 1mm prevents the lens cap from attaching. I’ll try another brand soon and post which one fits.

Creating a Grails Execute and Wait Interceptor (a Grails Service) A year or so ago I was building a simple payment processing website using Grails and realized that I wanted an ‘execute and wait’ interceptor’, similar to what I had become used to in WebWork (the basis of Struts2). I wanted the user to be able to submit their payment information, and the page to refresh with progress information and then finally display the results. WebWork’s EaWI prevents the HTTP request from timing out by wrapping the action request in a background thread and returning a result to the browser. The browser can then ‘check in’ periodically, using a META refresh or AJAX call, and retrieve the current status of the backgrounded thread. When the background process has completed, the next browser check in cycle displays the result to the user. While this is simple to implement in WebWork, Grails doesn’t seem to have a similar concept. I ended up using a Grails Service, and checking in on it’s progress periodically. First, handle the form submit:

class OrderController {
// grails injected services
def paymentService
...
def payment = { CreditCard creditcard ->
if (request.method != 'POST') {
// error   flash.message = 'A problem occurred in your order'
redirect(action : 'index')
return
}
def orderDetails = new OrderDetails(params)
if (!creditcard.validate() || !orderDetails.validate()) {
return [ creditcard : creditcard, orderDetails : orderDetails ]
}
if (paymentService.inUse) {
flash.message = "A credit card submission for you already appears to be in progress. Please return again after 30-40 minutes."
return [ creditcard : creditcard, orderDetails : orderDetails ]
}
session.orderDetails = orderDetails
paymentService.processCreditCard(creditcard, orderDetails)
redirect(action : 'processing')
}
...
}</pre>
The action <code>payment</code> begins with defining a <a href="http://grails.org/doc/1.0.x/guide/single.html#6.1.9%20Command%20Objects">Command Object</a> which allows you to bind posted form fields to a temporary object that supports the standard validation system. I’m not using a domain object here because the user’s credit card details should never be persisted on your system. They’re privileged information that you should only hold for the purposes of actually processing a transaction. Next, a simple check to ensure that the user is submitting the form via a ‘POST’ request. Though it’s a simple <a href="http://www.owasp.org/index.php/Cross_Site_Scripting">XSS</a> check, a GET request should never change or store information on the system. The order details are then captured from the form and the two objects validated. After that a quick check to ensure that the <code>paymentService</code> is not already in use by this user. Though there’s a possibility of a race condition here if there are two quick form submissions, it’s still best to check. The <code>orderDetails</code> are stored in the session for later use and the <code>paymentService</code>is then called to process the transaction and the browser shown a processing status page.
<pre class="brush:groovy">def declined = {
flash.message = "Your payment was declined " + flash.errorMsg
if (!session.orderDetails)
render(view : 'payment')
else
render(view : 'payment', model : [ orderDetails : session.orderDetails ])
}
def processing = {
if (!paymentService.inUse) {
flash.message = "A problem occurred processing your order. "
if (!session.orderDetails)
render(view : 'payment')
else
render(view : 'payment', model : [ orderDetails : session.orderDetails ])
return
}
// show the 'your order is being processed' waiting page
if (paymentService.finishedProcessing) {
def orderDetails = paymentService.processedOrderDetails
paymentService.processedOrderDetails = null
if (paymentService.hasError || paymentService.declined) {
flash.errorMsg = paymentService.getErrorMsg()
paymentService.inUse = false
redirect(action : declined)
return
}
paymentService.inUse = false
flash.orderDetails = orderDetails
redirect(action : 'finished')
return
}
[orderDetails : orderDetails]
}

The declined action simply displays the error message to the user and likely provides them with a way to change their payment information. The processing action gets called repeatedly to check in on the status of the credit card transaction. It first checks to make sure that are actually in the middle of processing a card, then checks whether the transaction is completed. If it is, then the orderDetails are retrieved from the paymentService and if the transaction was declined the user is sent to the declined action. If the transaction was approved we’re redirected to the finishedaction. Otherwise we’re shown the in-progress status page.

def finished = {
if (!flash.orderDetails) {
flash.message = "A problem occurred processing your order. "
if (!session.orderDetails)
render(view : 'payment')
else
render(view : 'payment', model : [ orderDetails : session.orderDetails ])
return
}
session.removeAttribute('orderDetails')
def orderDetails = flash.orderDetails
[orderDetails : orderDetails]
}

The finished action displays the Thank You page to the user with the details of the order. But the interesting bit of the code is the paymentService

class PaymentService {
static scope = 'session'
static transactional = true
boolean inUse = false
boolean finishedProcessing = false
boolean hasError = false
boolean declined = false
OrderDetails processedOrderDetails
synchronized processCreditCard(CreditCard cc, OrderDetails orderDetails) {
while (inUse) {
// already processing a credit card from another submission
sleep 500
}
inUse = true
finishedProcessing = false
hasError = false
declined = false
// store the order in the DB before we go to the payment processor
// this ensures that if our server goes down or
// we don't hear back from the processor, but the card is authorized
// we have a record of the purchase. Also it builds an incrementing
// unique orderid which is usually required by the payment processor
OrderCache orderCache = new OrderCache()
orderCache.cache = orderDetails.dump()
orderCache.save()
String orderId = 'CC-' + orderCache.id.toString()
processedOrder = orderDetails
// create the transaction request
PreAuth preAuthRequest = new PreAuth(
orderId,
cc.number,
cc.expiryMonth,
cc.expiryYear,
cc.name,
cc.cvv,
...
);
// create a thread to run the payment request
Thread.start {
hasError = false
try {
// the constructor actually performs the remote call to the processor
// so it will possibly take real time
HttpsPostRequest paymentReq =
new HttpsPostRequest(
preAuthRequest
...
);
processedOrder.receipt = ...
if (paymentReq.isSuccessful) {
// save the order to the database
processedOrder.orderId = orderId
processedOrder.save()
// send confirmation email...
}
else {
declined = true
}
}
catch(Exception e) {
log.error(e.getMessage(), e)
hasError = true
}
finishedProcessing = true
}
}
}

Here we define the PaymentService as being both transactional and having a session scope. This means that it participates in transactional database scopes and that each browser session will be guaranteed a unique instance of the PaymentService. For safety’s sake, I first cached the order details to ensure that if the unthinkable happens and the server computer fails during processing we’ll still have a record of it, and secondarily it we get a incremented order ID that we can send to the card processor. We build the payment request, and start a thread so that the actual processing will happen in the background. Flow of control then returns back to the controller so that we can send a status update to the user. In the mean time the thread is waiting for the payment request to return and if it turns out to be successful it saves the order to the database and updates a flag indicating that we’re finished. At this point the next time the user’s browser comes back to check the order status, the controller will notice that it’s finished and display the appropriate result. While this code is a bit abstracted, the major components are there. One rough point would be how Grails session objects are handled between requests (or across servers if they’re replicated across a cluster). Since the service object is unique to the session it’s possible that it might be serialized too, Tomcat will do this just between normal shutdowns and restarts. That would be an interesting experiment.

The back story is that my cat has developed a kidney condition which requires daily subcutaneous fluid drips. It didn’t take long before she started recognizing the signs: “He’s about to stick a needle in me and I don’t like that!”. The end result is a chase which always results in a stressed cat and a frazzled caregiver. That got me thinking: “Is this a conditioned reflex on her part?”

So taking a walk down the anthropomorphic laneway, I outlined the mental steps that my cat might have gone through the first several times I gave her the subcutaneous drip. By associating my preparations to the insertion of the needle each day she may have thought each day in turn:

1. No association
2. Huh?
3. Interesting.
4. I wonder if…
5. Could it be?
6. Anticipation! (or more appropriately: Fear!)

Your kilometrage may vary, and you might choose to rename the steps but it’s likely that a similar pattern will be followed in most conditioning situations.

Of course some may argue that an animal can’t “think” through these steps like a human can; that my cat is exhibiting a purely conditioned relex: an instinctual reaction. My response is that the burden of proof is on those who insist on creating an artificial separation between humans and the rest of the animal kingdom. If you wish to elevate yourself based on ego, my response will be: “the id will prevail”. But any such differentiation is a human concept, a human conceit. And in turn, as we have experienced, an environmental disaster.

By separating ourselves from the environment around us we are no longer capable of understanding the consequences of our actions. Apparently, to a large number of humans, even the idea of an ‘environmental system’ that we are a part of is an abomination. We have been bequeathed unlimited control with no responsibility. Not unlike an addiction, this ideological high will have a painful rehabilitation.

For most of human history we’ve likely been at stage 1 in our ability to understand the association of our actions to their larger environmental outcomes. By the late 1800’s there were a few that had moved to stage 2 or stage 3 but they were hidden in a society proud of the concept of ‘progress‘. In the 1960’s there was a movement by a select group past stage 3 to sometimes stage 6. But the larger part of western society is still stuck at stage 2 despite the last 15 years of educational outreach, and at that I’m being overly generous.

Politicians, I would suggest, are in general at stage 3; or more likely they’ve relabelled it “sounds very expensive”. Where the word ‘expense’ comes to play, our society brings with it a cacophony of economic memes that our society has engendered. All of them are over simplified models that ignore the fact that we exist in a context, a context that is a complex adaptive system. The collapse of the world’s economic systems in 2008 reminds us that the idea of getting something for nothing is a childish, perhaps churlish, fantasy.

If a resource is a one time only resource then it cannot be renewed. If it can’t be renewed then, if we are lucky, it can only be reused. And economic growth can only happen if there remains expansion room in the system. As we start hitting our head on the limits to expansion, and the reactions of the system to our actions then each of us will in turn, move along these Pavlovian conditioning steps. Unfortunately, as my cat experiences daily, the last step can be labelled ‘Fear’.

A friend’s Mac needed some hand holding the other day and I pulled out all of the repair tools that I’ve collected over the years. The best one of all is another Mac itself because you can put the sick Mac into target disk mode (hold down the ‘T’ key while it’s booting) and you’ll see it’s disks as FireWire attached disks on the repair Mac. Of course this assumes that both Macs support Firewire — Apple is changing its mind here with the latest MacBooks.

From the repair Mac you can now run disk utilities against the sick drive without the interminable wait of booting from a CD or DVD disk. And you can also copy over any important files assuming you can get to them (and that for some weird reason they’re not in your Time Machine backup — you are using it aren’t you?).

One of the really neat target disk tricks is to put the repair computer into target disk mode and use it’s DVD drive to boot from a Mac OS disk or repair disk if the sick Mac’s DVD drive is bad. This is also handy if the sick Mac has only a CD capable drive and you need to boot from a DVD disk. The normal Mac boot key trick of holding down the ‘C’ key to boot from CD won’t work in this case though, use the boot disk chooser interface instead by holding down the ‘Opt’ key while the Mac is booting. A menu of all attached system disks will appear allowing you to choose a Firewire attached DVD drive and proceed (by clicking on the right arrow button in the screen.)

So then we come to volume repair utilities themselves. What’s the best option? I’ve had mixed results with TechTool Pro though it has many handy diagnostic features and sometimes will save the day. Diskwarrior is my fave as it doesn’t attempt to simply correct the damaged file system tables but instead replace them with a rebuilt one. It walks the file system and builds a new table structure from scratch. Apple’s own Disk Utility is sort of a ‘first try’ tool. I dont’ expect it to fix the problem but it’s aways a good choice to start with.

Fixing disks is something that you don’t want to be doing and you don’t pay attention to until you need to. My collection of tools had grown old with outdated boot disks and warning screens about not being tested with this version of the OS.  Updating them is frustration itself. Neither Diskwarrior or TechTool Pro boot disk updates can be downloaded, you have to pay for a physical disk to be shipped to you. Not a likely solution in an emergency. After Apple’s Disk Utility refused to help fix the damaged disk I went looking for an alternative. Drive Genius seemed to fit the bill and you can download a DVD boot image and burn it immediately. Imagine that! The internet allows you download large files! Hopefully the other guys figure out that times have changed too.

But while Drive Genius seemed to be a saviour it soon proved itself an also-ran. It gives the same warning messages, the same error messages and the fails in the same places as Apple’s own Disk Utilitiy. So my running assumption is that it is the same. They’ve simply wrapped Apple’s disk repair with their own GUI. If you need a repair boot disk in a hurry and don’t have a Mac OS disk with Disk Utility handy then it’s a good choice, otherwise look carefully at the additional features that it has (which I have not tested) before deciding whether it’s worthwhile.

Hopefully Apple will move to ZFS soon and we can enjoy having some of the dynamic volumes, flexible RAID, and filesystem recovery snapshot features that other OSs are starting to enjoy.

I just received an email notification of my Bell e-bill and noticed that its branding was still from the previous version.

Bell has recently undergone a total rebranding; at a minimum as a desperate attempt to convince their market that they’re not the same company that has only been capable of losing money for the last 10 years. Perhaps employing talking rodents has its downside after all.

Their new branding is a much needed improvement though their current ad campaign of “er” is meaningless but quirky.

Of course being the good customer that I am, I took the e-bill at it’s face value and decided to give it more than the 1.3 seconds I usually would. What could Bell have have in store for me that would make my life better?

Well, apparently nothing. Almost none of the links on the e-bill notification actually work because they take you to pages on their old site from before the rebranding. Pages that don’t exist anymore.

Error.

I’m glad that their monthly email communication with me, one that I might actually have a reason to read has value to them. Perhaps marketing really is all about undermining customer touch points.

From their error landing page, I navigated around a bit to see if I could find what I was actually looking for. I never did, but I stumbled upon their new Samsung Instinct micro-site.

Can this phone compete with the iPhone? Let’s see what Bell has to say about that. Since I’m interested in mobile email, I went to that section and noticed that Bell actually does have something in-store for me:

More foreshadowing seems unnecessary. Thrasher

If you’re looking for a video out accessory for a recent iPod (nano 3rd generation, iTouch, iPhone) then there’s really only one cable vendor: Apple’s composite or component video out cables.

Previous video capable iPods allowed you to use a 1/8th” adapter for video out but this option has been removed. Now you must use the dock connector instead. The reason is that the iPods now require a video ‘authorization’ chip to be embedded in the accessory (cable or dock). It doesn’t seem clear whether this is a new DRM requirement or a simple accessory tax on Apple’s part.

While the 3rd party product, Monster iTV Link for iPod, uses the dock adapter it doesn’t embed the authorization chip so can’t display video on recent iPods.

One benefit to the Apple video cables is that they include an AC/USB power adapter so you don’t need to buy a separate charger. Ironically, this makes it one of the first accessories you should buy with a new iPod rather than one of the last.