Before I continue, some brief background about me and my experiences working with the Spring Framework. I took an interest in Spring a couple of years ago while working on a web application to manage administrative data about a large-scale biotechnology research project. Not too long after starting on my project, I heard about Spring Roo. At that time, it was a rather new offering from SpringSource, before version 1.0 was ready for prime time. It was and still is a great tool for very quickly developing straight-forward CRUD applications. However, my interest soon drained as I was concerned that the ease of development would compromise my ability to customise applications for customers. That opinion changed soon after reading this book. I’ll explain later.

Ten chapters have been written so far, providing a comprehensive coverage of key component technologies that make the Spring Framework such a great technology for developing web and enterprise applications – database, web, messaging, integration and testing. Even with the ease of designing and configuring software using Spring – as the authors aptly point out – developers are often caught in a conumdrum of chosing the right set of frameworks. Often losing sight of our primary goals: building usable software that meets clients’ expectations (and schedules).

However, as mentioned earlier, I was concerned that the Spring Roo was generating a lot of artifacts that are deeply intertwined with the tools, such that it becomes very difficult to customise without breaking any code. I liken this to a beginner .NET developer experience. Visual Studio was a very powerful IDE that allows anyone (well almost) to create usable applications in a short amount of time. That is definitely useful during early stages of development, where it was important to quickly prototype and impress your prospective customers. As time goes by, as we learn more and more about the user’s requirements, we begin to realise that there’s a fair amount of tweaking to be done. Then you’re hooped.

I feel the authors were very conscious of this issue, and throughout the early chapters, assured me that there was a not-too-difficult exit strategy when the project needed more intricate plumbing: Push-In Refactoring. There is an entire chapter devoted to this topic and I certainly look forward to reading it when ready.

There’s so much to say about this book, but I think my remaining thoughts are best condensed into these key points:

• The book is well written with the developer at heart. The authors exhibit great empathy with the many issues that developers face daily.
• Well organised and covers all layers of the development cake.
• Clear concise instructions, great visuals and easy to follow. All you need is a computer with tools installed to follow along.
• Talks about IDE integration: SpringSource Tool Suite (STS) and IDEA’s IntelliJ. For STS, they don’t just stop at the basics, there are some tips and tricks that could be very helpful in your development experience.
• The authors don’t just talk about all things Roo. There are some good pointers and guidance for software development and architecture considerations and best practices.
• Chapter 11 is about Cloud Computing. I’m gonna guess that it has to do with CloudFoundry and the newly released MicroCloud. As developers and solution providers, as much as we hate buzz words, Cloud Computing is here to stay and I see this as a very important technology in the year ahead.

Prior knowledge about the Spring Framework would be good, but definitely not a prerequisite. If Spring Roo is a beginner’s portal into the world of Spring, then this book is your wormhole. If only I could give this must-have handbook a 5.01 rating!

The book is broadly organized into three main categories of algorithms currently implemented in Mahout: Recommendations, Clustering and Classification. The authors take a single strategy with each category. They begin with a general introduction, the algorithms available and basic examples. Later chapters go in depth on each group of algorithms with even more examples and measuring outcomes.

In many tutorial books and articles, we often find examples where data is magically pre-formatted for use and the outcome is pretty much orchestrated. I like the fact that the authors bother to go through the rigor of obtaining and preparing your data that includes cleaning, transformation etc. real-world data. Learning to pre-process your data is crucial for any successful ML application. Data sources are often “dirty”. For ML algorithms to be useful, we must learn to deal with the imperfect world of data collection.

Many of the examples presented in the book are also familiar with most people, e.g. classifying news articles, recommending products, clustering Twitter users. I find real-world examples and common knowledge a great way to learn a new subject. Some of these examples might even be useful and can be applied to existing projects. Bear in mind that many data sets that they point you to are actual data collected from familiar websites and applications.

The authors also examine and provide examples on using Hadoop to support your Mahout implementation. As pointed out in the text, using ML techniques over large datasets often puts a strain on your computing resources. Mahout was designed from ground up to use Hadoop for High Performance Computing. You could buy a focused book to read about Hadoop (e.g. Hadoop in Action), but I find the coverage is sufficient enough to get you started. In the examples, again you will learn to prepare your data, not only for the analytics, but formulating a data structure that is compatible with Hadoop.

Learning about Machine Learning can be very daunting. It sometimes is dry and confusing for me, especially when books focus a lot on the Mathematics involved. I have found the authors approach to this field of Computer Science well balanced. There is enough details to get you started, but a whole lot more hand-holding, through examples, to demonstrate how ML can be useful in your projects.

In summary, this another great book to add to my fairly large collection of Machine Learning textbooks. Here’s why:

• Authors are major contributors
• Examples examples examples
• Practical examples
• Two books for the price of one

Before I talk about the book, a brief technical background about my interest in the subject matter. I am currently with an IT group focusing mostly on software development and High Performance computing. We are starting to deploy quite a few Windows 2008 R2 servers and gradually rolling out Windows 7. We manage desktops outside of Microsoft suite of system administration capabilities and rely mostly on Novell products. So I quite often get requests from my colleagues to write scripts to help configure desktop systems and remotely deploy applications.

So, the first reason to buy this book. It is written by Bruce Payette, a key person in the Powershell Team. Bruce is a great writer. The text is fluid, detailed and at times, humourous. You will find many useful quotes and codes! Well, the latter is more useful. I especially like the breakdowns telling you what each segment of a command does. You’ll see a lot of this in DB2 and Oracle documentation that describe intricate SQL statements.

On to the second reason. Like many Manning ebooks that have successive editions, you get free access to the older versions. You might wonder how useful that is, but consider this: Windows 2008 (the first release) and Vista still use Powershell v1. Hence if you are managing a heterogeneous environment containing both Windows 2008 and Windows 2008 R2, you might still want to keep the 1st edition for reference… just in case.

Now the meat… the book is divided into two parts. The first part covers most of the fundamentals, similar to how most other introductory books are structured. The first seven chapters are probably sufficient for you to write your first useful script (after Helloworld). If you have more demanding needs, Bruce looks at how you can distribute code and perform magical tasks remotely. Chapters 14 and 15 provides you the necessary skills to not wanna tear out your hair when your script misbehaves.

As mentioned earlier, the author is very careful to describe textually, graphically and by example how things work in PowerShell. The amount of detail can sometimes make it rather dry to read, and that’s why I particularly appreciate the occasional interjection of humour. Details are good.

Part 2 will probably be more useful to most, compared to earlier advanced topics discussed in Chapters 8 to 13… well, at least for me. Oh, and please read Chapter 21 on Security before you question and complain about why your scripts ain’t running.

Last but not least, the Appendices. I have yet to receive them, but certainly looking forward to the much needed code samples (Appendix B) and quick reference sheets (Appendix C).

This review should come timely. During this holiday season, it is almost customary for Manning to be handing out free ebooks or at the very least, great discounts. This book deserves a 5/5 rating, so if you are keen on making Windows work harder for you, then this is a MUST read!

• .project
• .classpath
• .settings (added on 17-Jan-11)
• .springBeans (added on 14-Dec-10)
• target (and/or bin)

The last segment of this book focuses a lot on the business and ethics related to building your first LBS application.

I enjoyed reading the overview of server-side technologies (Chapter 9) involved in creating a back-end supported lbs application. Location-based services are usually client-server applications. Hence, you would usually find two types of developer roles in such projects – one to work on the GUI, and another to create the data-driven components. I am more of the latter kind of guy. There are a myriad of spatial server products out there, some of which have a hefty commercial fee. Hence you would probably appreciate reading a good overview as opposed to downloading and installing a number of trial software. The review helps you quickly evaluate the features that each vendor provides, thereby allowing you to filter what solutions might work for your lbs app.

Chapter 10 again talks about privacy, and rightfully should, even though it is one debate that never ends. It is good that the authors rose to the challenge and highlighted pitfalls and concerns to think seriously about when creating your blockbuster app.

As an iPhone developer wannabe, I have been greatly put off by the annual developer fee of $99. Part of the uncertainty is not knowing what the program entails and what the development to production cycle is like. That is why the experiences shared by the authors in Chapter 11 is invaluable. Thank you!

That’s not all. In Chapter 11, the authors also present other distribution channels and great marketing ideas to kick-start sales. Writing a great app won’t roll in the dough till it gets through the door, out in the wild and into people’s portable hi-tech devices.

The book concludes with important issues close to my heart and one that should concern you whether you are for or against – protecting your intellectual property (IP). This is the first technology book I have read that dedicated a full chapter on this topic. The patent process is long, convoluted and extremely expensive. I wouldn’t have known that for a fact had my previous employer required me to patent a few ideas in the past. So good insight into this long arduous process if you haven’t already been involved.

When I first started reading this book, my expectations were mismatched. I was hoping for a more in-depth technical read. Gradually, I realized its intent and as the authors summarized, this book was written to give a 360-view of developing LBS application. For that, it scores a 4/5 stars from me. Good read if you need an overview of technology and business before getting into the game. Enjoy!

This post follows my earlier review of the first six chapters of “Location Aware Applications”. I recently received an update containing two new chapters covering topics on connectivity issues and how to monetize your LBS applications.

Chapter 7 briefly looks at issues affecting mobile devices that affect connectivity, e.g. acquisition rate of the GPS and battery consumption. A few code snippets in this chapter also demonstrates to the reader how you can obtain geolocation data from the different devices: iPhones, Androids, Java ME and Palm WebOS devices.

I like Chapter 8 the most so far. Well, who wouldn’t? Software metrics has always been a challenging art – yes ART! So a chapter that provides pointers on how to commercialize your application is certainly welcomed!

The authors describe several ways of turning your application usage into cash churning machine. Several options on how to charge consumers for the use of your software are presented and includes many considerations – the pros and cons – for each method. I especially like Figure 8.2, a matrix for helping you decide which charging model best fits the type of application you have. Learned a few new keywords like “Long Tail Kings” and “Boot Campers”.

The iPhone App for WordPress was recently updated to version 2.6 (see announcement). It has got quite a few interesting new features and was made compatible with WordPress 3.x. Strangely though, it had always worked on my previous installation, but connection broke after this update. What an irony!

If you recently updated the application and got this error (“Communication Error. Bad user name or password“) while attempting to connect to your blog site, here’s the simple solution that worked for me:

1. Click the navigation button “Blogs“.
2. Click the button “Edit”.
3. Click the red delete button.
4. Click the add (“+”) button and reenter your settings.

Simple eh? I haven’t had the opportunity to test out the new features (mostly because the iPhone keyboard is really bad for typing), but I would sure like to try them out! Meanwhile, we can expect more WordPress App users with the massive migration of Windows Live Spaces (by Microsoft) blogs over to WordPress.

I recently got my hands on a copy of the MEAP book, Location Aware Applications. At the time of this post, only 50% of the book has been completed. So here are my early impression of this upcoming title.

GPS and many other devices are becoming ubiquitous features in cellular phones. The availability of maps and APIs to access geospatial data are plenty. There is also increasing effort in making data open and linked, providing a multitude of information that can be consumed, meshed and presented to the mobile user. Thus it is no surprise that a lot of software developers (or not) are looking into making use of location-based information, hoping to spin some big bucks out of technology.

If you are one of them, then this book might be for you. The authors provide a very good introduction for someone looking for headway into developing location-based, location-aware applications. Part 1 is a comprehensive overview of the history and development of LBS technologies and is very informative for newcomers. The beginning four chapters will also be a good refresher for experienced GIS developers or geeks, so you might want to quickly glance through so that you are kept at the forefront of development. In chapters 3 and 4, the authors survey a broad range of content and mapping APIs with sample codes to showcase how they can be used. And this is a first I have seen: at the end of each code sample, the authors provide somewhat like a pseudocode to describe the program flow. This is very effective and helpful in understanding how the code works.

I do hope though that the authors might consider adding some introduction to LinkedData and the Semantic Web, and how these novel developments might help spur more LBS applications.

That’s it for now. I will update this post as more chapters are completed in the coming weeks/months. Stay tuned, or if you can’t wait, grab a MEAP copy now! This book is available either from Manning or Amazon.

To make my life easier, I used a simple ImageMagick workflow based on this tutorial to quickly watermark a bunch of images files. At first, I had this post-processing job running as a Bash script in a Linux Virtual Machine, but it soon became too troublesome to shuffle files between the two operating systems. PowerShell comes pre-installed with Windows 7, so that was a great option for creating a script to process multiple files.

So here’s what’s involved when I process files to be posted on Flickr:

1. Create a watermark image file. I made this a transparent image and saved it in PNG format. Place the watermark file in a your working directory (e.g. c:\myworkflow).
2. Next, create the directories for your source image files (e.g. c:\myworkflow\source) and copy your photos into this sub-directory. Make any edits here before performing the watermarking process.
3. Create two more directories for the ImageMagick to save the resized and watermarked files (e.g. c:\myworkflow\flickr\resized and c:\myworkflow\flickr\watermarked respectively).
4. Create a temp directory if preferred (e.g. c:\myworkflow\temp). Piping processes worked fine in Linux, but I did not have much success in Windows. Hence, intermediate outputs are written to the file system instead.
5. Place this script in the working directory and edit the variables if necessary.
6. The $filePattern variable is useful if you would like to iterate your source files selectively. I sometimes prefix my photos with a set number. Photos within sets were usually taken in the same year. I can then use the set numbers to watermark the image with the matching copyright year.

The code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$srcDir = "C:\myworkflow\source"
$resizedDir = "C:\myworkflow\flickr\resized"
$watermarkFile = "C:\myworkflow\watermark_image.png"
$watermarkedDir = "C:\myworkflow\flickr\watermarked"
$tempDir = "C:\myworkflow\temp"
$filePattern = "*"
 
foreach ($f in ls "$srcdir\$filePattern") {
    $f = split-path $f -Leaf
    Write-Host "Processing: $f"
    convert -resize 800x800 "$srcDir\$f" "$resizedDir\$f"
    convert $watermarkFile -fill grey60 -colorize 30 "$tempDir\temp.miff"
    composite -dissolve 50 -gravity south "$tempDir\temp.miff" "$resizedDir\$f" "$watermarkedDir\$f"
}

The parameters for ImageMagick commands may not be optimal for all scenarios. Change them if necessary. If you have any feedback or suggestion for improvement, please feel free to give me a shout.

I had some early setup problems trying to get the wireless keyboard and mouse to work, until at last I found out that there was a small wireless adaptor embedded in the mouse battery compartment. This adaptor has to be connected to one of Revo’s several USB ports. I tried the top-most port first. Both peripherals seemed to work on bootup, but as soon as Windows started up, the keyboard would become non-functional. That frustrated me quite a bit. Finally, I tried a different port, one at the back of the computer and that seemed to help.

The remaining hardware issue was with the keyboard’s layout. For some strange reason, I could never authenticate correctly with the keyboard. If you have any clue about why that is, please let me know. My current work around – short of connecting a second USB keyboard – is to use the on-screen keyboard to type in the password. Alternatively, get Windows to perform an auto-login at startup.

Getting MKV videos play smoothly on the Revo can be challenge. I use the VideoLAN player for this, and today, I found a neat little trick to make use of GPU power in Nvidia’s Ion chipset to help boost the video playback performance on my Revo and it worked!

If you are wondering how, do this:

1. Go to Tools > Preferences, or simply press Ctrl-P.
2. Next click on the “Input & Codecs” tab.
3. Check the “Use GPU acceleration (experimental)”.
4. Click “Save”.

That is it! You should be able to enjoy HD playback on your Revo. Believe me, I initially could not even get the video to play.

With all the minor heartbreaks, I would still give the Revo a 3.5 out of 5 rating. It is rather inexpensive and is a good media entertainment device for the family to enjoy an evening together. The setup experience could be improved with better documentation. Hence the reason for this post: a one-stop tip to not only get started, but to get the most out of your Revo.

Have fun!