Independent developer book reviews by and for practitioners

In many respects GIMP is one of the flagship products of the open source movement. From its origins back in the middle 1990s, to the present 2.8 release, the software has evolved and expanded much as the open source movement has. It's a core part of most Linux distributions, and is fully multi-platform with versions for Windows, Mac OS X as well as Linux. The functionality of the software has grown too, and it still often touted as a replacement for Adobe's Photoshop - which is certainly not the intention of the core development team.

For all that, like all complex graphics manipulation programs, the new user is bound to find the profusion of menus, toolbars, panes and palettes confusing when first opening the package. It's not simple, that's for sure. While there are plenty of web-based tutorials, there are many people (this reader among them), who find books more useful and so there's a need for some basic introductions to GIMP.

'GIMP for Absolute Beginners' really does mean what it says on the cover - the reader is assumed to have no knowledge at all. Not just no knowledge of GIMP, in the case the authors have assumed pretty much no knowledge of computers at all. While this is fine if you're one of those people unable to install a bit of software downloaded from the web without screenshots to help, for most of us the introductory chapter can safely be skipped.

Assuming the software is installed the book really does focus on helping to orientate the reader to the GIMP workspace. Wisely readers are advised to use Single Window Mode, which simplifies the process of helping readers navigate the complex user interface. [Continued]

The biggest problem with software methodologies is the real world. And what goes for the methodology goes doubly so for the books. Far too many books on development methodologies present scenarios that are either so simplified as to be fantasy, or else only really apply to very small projects over short time-scales. Which is why 'Lean From The Trenches' is such an engaging read - the trenches it describes are the familiar landscape to anyone involved in team development on significantly long or complex applications. In this case it's a 60 person development for the Swedish Police, using a mixture of Scrum, XP and Kanban-based methodologies. And, for those who care about these sorts of things, the application is about moving police operations from being largely paper-based to being largely online - with laptop access from police officers on the go to all relevant databases and applications.

The book consists of two sections - part one, the core of the book, is an extended case study of this particular project. Part two steps back and intrdouces a bit more about the Agile and Lean methodologies, going into more detail about specific practices and techniques. While it's possible to read part two as a standalone introduction to Agile techniques, it's really the first part, the detailed case study that makes this such a standout book. Particularly for those who learn best from concrete examples, the narrative in part one of the book is pretty compelling.

It's no surpise that the first part of the book is entitled 'How We Work'. It describes the nuts and bolts of day to day activity on the project (and there is a detailed introduction to the project itself, which sets the scene so that the reader is aware of the context - both in terms of the technical constrainst but also the political and organisation pressures that were at work). [Continued]

Apache Pig is an open source platform for parallel data processing tasks on large datasets. It uses a programming language called Pig Latin to generate map-reduce sequences that are executed on an underlying parallel processing system, generally the Hadoop platform. By using Pig the complexity of programming and executing complex, parallel processing tasks on massive data sets is eased considerably. And, as you'd expect from the title of this book, this slim volume introduces the reader to both the platform and the language, as well as showing how to extend things using Java coded User Defined Functions.

No previous experience is assumed, and the book starts with a quick intro into the history, background and philosophy of Pig. Some knowledge of Hadoop is assumed, but not much as the intention is to abstract the hard stuff and leave the Pig using concentrating on the writing scripts in Pig Latin. Once the intro is done, the next chapter moves on to installing, configuring and running Pig. This includes instructions on how to run Pig scripts locally, as well as on a Hadoop cluster or on a cloud service.

The next couple of short chapters look at Grunt (you've got to love the way the porcine references are slotted into place), the Pig command shell environment, and then it's on to look at Pig's data model.

The introduction to Pig Latin really starts in chapter 5 and continues in chapter 6. At heart this is a batch programming language that uses SQL-like operations that filter and collapse streams of data. The relational operators - filter, group, order etc - should be familiar to anyone who's had to work with relational data in other environments. [Continued]

Not quite boasting a cast of thousands, this five author book delivers 42 recipes that cover a range of web development topics and technologies. Organised into seven sections, the recipes cover user both the output side of things (eye candy, user interfaces, mobile devices etc), the content side of things (external data sources, for example), development (workflow, testing etc) and finally a section on hosting and deployment.

The cookbook style of the book means that it's easy to pick and choose chapters - this isn't designed to be read from cover to cover (though it was how this read tackled the book any how). Some of the recipes refer back to previous ones, but on the whole most of them are standalone. Each one introduces the topic at hand with a little scenario along the lines of 'your client wants X, but you can't use technology Y and it has to be ready yesterday…' While it's a convenient hook to explain what the recipe is tackling, it doesn't really add much to the content. And it's the content that is the strength of the book.

Each recipe proceeds in a logical fashion, taking a step by step approach to solving the problem that's set out at the beginning. There are plenty of screen shots and there's sample code to try out. For those who like to follow along many of the recipes involve the client and server end of things, and the book uses a VirtualBox and Ubuntu as the server platform. While there's an appendix which provides instructions for rolling your own, the authors have done the decent thing and also provided a downloadable image which you can configure and use to try out the recipes.

Finally, once the solution has been developed, refined and explained, the authors then finish off with hints and tips as to how extend what's just been developed.[Continued]

Previous articles on TechBookReport have shown how to use the FileSystemObject API from within VBA to access files, directories, text streams and so on. One area not explored in those tutorials was how access to file attributes - in other words how to identify whether a file is flagged by the operating system as hidden, or as a system file and so on. This short how-to will show how to access the information using the FileSystemObject (FSO) API, with Excel as the application platform - though the core of the code will work in any of the applications that support Visual Basic.

If you're unfamiliar with FSO then the first thing to do is to go to the start of the extended TechBookReport FSO Tutorial for an introduction.

In terms of the FSO model, the attributes belong to the file object. So the first thing that your code has to do is to get a reference to a specific instance of the file object, lets call it fl. Once that's done then the attributes are returned in the attibutes property, like this:

                     fl.Attributes

Note the plural - a file can have multiple attibutes. The value returned is a bit mask, with different bits indicating the different attributes.[Continued]

Webbots, Spiders and Screen Scrapers, The Joomla! Book and lots more...