Follow Slashdot blog updates by subscribing to our blog RSS feed

 



Forgot your password?
typodupeerror
DEAL: For $25 - Add A Second Phone Number To Your Smartphone for life! Use promo code SLASHDOT25. Also, Slashdot's Facebook page has a chat bot now. Message it for stories and more. Check out the new SourceForge HTML5 Internet speed test! ×

Submission + - Book review: Effective Python (59 specific ways to write better Python)

MassDosage writes: If you are familiar with the “Effective” style of books then you probably already know how this book is structured. If not here’s a quick primer: the book consists of a number of small sections each of which focus on a specific problem, issue or idea and these are discussed in a “here’s the best way to do X” manner. These sections are grouped into related chapters but can be read in pretty much any order and generally don’t depend on each other (and when they do this will be called out in the text). The idea is that you can read the book from cover to cover if you want but you can also just dip in and out and read only the sections that are of interest to you. This also means that you can use the book as a reference in future when you inevitably forget the details or want to double check something.

Effective Python stays true to this ethos and delivers 59 (not 60, nope, not 55) but 59 specific ways to write better Python. These are logically grouped into chapters covering broader conceptual topics like “Pythonic thinking”, general technical features like “Concurrency and parallelism” as well as nitty gritty language details like “Meta classes and attributes”. The range of topics is excellent and cover relevant aspects of the language that I’d imagine pretty much any developer will encounter at some point while developing Python programs. Even though there is no required order to reading the various sections if you want to read the book from cover to cover it’s organised in such a way that you can do this. It starts off with getting your head around coding in Python before moving on to specifics of the language and then ending with advice on collaboration and setting up and running Python programs in production environments.

I really enjoyed the author’s approach to each of the topics covered. He explains each item in a very thorough and considered manner with plenty of detail but manages to do this while still being clear and concise. Where relevant he describes multiple ways of achieving a goal while contrasting the pros and cons of various alternative solutions, ending off with what he considers the preferred approach. The reader can then make up their own mind based on the various options which applies best in a given situation instead of just being given one solution. The author clearly understand the internals of the Python language and the philosophy behind some of the design decisions that have resulted in certain features. This means that instead of just offering a solution he also gives you the context and reasoning behind things which I found made it a lot easier to understand. The discussions and reasoning feel balanced and informed by the experience of a developer who has been doing this “in the trenches” for years as opposed to someone in an ivory tower issuing dictats which sound good in theory but don’t actually work in the real world. The vast majority of the topics are illustrated through code samples which are built on and modified at each stage along the way to a final solution. This gives the reader something practical they can take away and use and experiment with and clearly shows how something is done. The code samples are easily comprehensible with just enough code to demonstrate a point but not so much that you get distracted by unnecessary additions.

While most of the topics are Python specific plenty of the best practices and advice apply equally well to other programming languages. For example in one section the author recommends resisting some of the brevity offered by the Python where this can lead to unreadable code that is hard to understand but the same could be said of writing code in many other languages (I’m looking at you, Perl). This also applies to a section related to choosing the best data structure for the problem at hand — if you end up nesting Maps within Maps in your code then you’re probably doing something wrong regardless of the language. Still, the main focus here is Python and the author does not shy away from going deep into technical details so you’ll definitely need some knowledge of the language and ideally some experience using it in order to get the most out of it.

Effective Python is not a book for complete newbies to Python and I think it’s suited more to intermediate users of the language wanting to take their skills to the next level or advanced programmers who might need some fresh takes on the way they do things. The subjects and opinions in this book could either convince you to do something differently or reassure you of the reasons why you’re already doing things a certain way (external affirmation that you’re right is also useful at times!) I’m no Python expert but I found the book drew me in and kept my attention and I certainly learnt a lot which will come in handy the next time I put on my Pythonista hat and do some Python coding. Highly recommended.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.

Submission + - Book Review: Lauren Ipsum

MassDosage writes: Lauren Ipsum (A Story About Computer Science and Other Improbable Things) Book Review by Mass Dosage

As the full title to Lauren Ipsum (A story about Computer Science and Other Improbable Things) indicates, this is a book about Computer Science but what’s surprising about it is that it manages to be about Computer Science without actually ever directly referring to the subject or even to computers at all. It is in fact a fictional story about a young girl called Lauren who gets lost after wandering into a forest near her house after an argument with her mother. She stumbles into a world populated with all kinds of strange creatures and colourful characters some of whom she befriends in order to figure out how to get back to her home. The “figuring out” part of the plot is where things get interesting as she has many attempts at solving this problem with different characters giving her often contradictory advice and Lauren then has to decide what exactly she’s trying to do and which of the various possible solutions is the best. This involves a fair amount of trial and error, learning from certain mistakes and trying different approaches. If this is starting to sound familiar to those who have written software then that’s the whole point. Lauren Ipsum is cunningly littered with references to Computer Science and in particular to things like algorithms, logic puzzles and many other of the theoretical underpinnings of the subject.

In the course of her adventures Lauren encounters characters like Xor the chameleon, Hugh Rustic the shop owner, a flock of round Robins and a Wandering Salesman. Anyone who knows a bit about computer science will be aware of the topics that are being alluded to here. This is also evident in some of the places she visits — a forest made up of red and black trees, the Island of Byzantium and a Garden of Forking Paths. All these insider references are obviously more enjoyable if you know the subject but it doesn’t really matter if you don’t get them as the story itself is separate from all the in-jokes. It’s also almost certainly the intention of the authors to stimulate people to look up some of the things they refer to and thus learn more about computer science. Lauren Ipsum can thus be read on two levels — one as a straightforward adventure story and the other as a “find and research the hidden references” book. The title of the book is itself a play on words of “Lorem Ipsum” which I’ll leave you to read up on on your own.

The chapter I enjoyed the most was one that covered building up a solution to a problem by breaking it down into smaller pieces and then combining these to come up with the final answer. In the book Lauren first learns how to draw a line and then that she can then draw and connect four of these to make a square. Even better is the discussion of the seemingly simple task of how to draw a circle which demonstrates that there are different ways of doing this, each having their own pros and cons. The solutions can be easily described as a set of steps and the question of how to control the size of the circle can be specified separately from the steps themselves. This is done without referring to any of the technical terms directly (one of the first chapters in the book is all about avoiding jargon) however what is actually being described will be instantly recognisable to anyone who has written some code — namely algorithms,algorithmic complexity, variables and parameter passing. This is quite a different way of illustrating programming concepts instead of the usual manner which involves lots of theory and code examples. Lauren Ipsum’s approach offers a much lower learning curve with simple story driven metaphors that can then be applied practically later.

The target audience of the book is probably children from around the age of 8 and up with the intention being to spark an interest in computers without the intimidation and possible connotations of boredom that a textbook might evoke. The story is entertaining but relatively simple and most of the more serious subject matter is just touched on in passing. There is an Appendix at the end which covers a few of the topics in more technical and mathematical detail but there is plenty that isn’t covered and it is up to the reader whether they want to find out more in their own way.

I found Lauren Ipsum an entertaining read, even though some of the computer science references are a bit forced. I ended up looking up a few things I wasn’t entirely sure about and learnt something new in the process and I can imagine this being even more the case for someone new to the subject. Even if the reader isn’t an aspiring geek-to-be there should be enough in the story here for them to enjoy and maybe help convince them that Computer Science can actually be fun or at the very least give them a taste for why problem solving is interesting and useful.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.

Submission + - Book Review: Build your own website

MassDosage writes: At the the risk of exposing my age I remember building my first website using a rudimentary Unix text editor (Joe) and carefully handcrafting the Hypertext Markup Language (HTML) while directly logged on to the web server it was being served from. Back then Cascading Style Sheets (CSS) weren’t even a glint in the eyes of their creators. A lot has changed and there’s now a world of fancy WYSIWYG web page editors to choose from as well as Content Management Systems that allow you to create websites without looking at the underlying code at all. While this is all very useful and allows less technical people to create websites I still feel that having at least some knowledge of how everything works under the hood is empowering — especially in situations where you want to go beyond the limits placed on you by a certain tool. This is where Build your own website (A comic guide to HTML, CSS and Wordpress) comes into the picture. Its aim is to enable people new to web development to learn the subject by teaching the fundamentals of HTML and CSS first and only then describing how to use a Content Management System (CMS) — in this case Wordpress. While Wordpress might not be everyone’s kettle of fish it’s a good choice as an example of a modern CMS that is easily accessible and very popular. The concepts presented are simple enough that it should be easy enough for a reader to apply them to a different CMS should they want to.

To be clear, this book is intended for people who have little to no experience building websites and it is appropriately written in a non-formal, fun and non-threatening manner. Each chapter has the same format where a topic is initially covered at a high level in the form of a cartoon that is really easy to grasp. This is then followed by a more in-depth repetition of the same content using more “traditional” text and diagrams. Most chapters then end with a summary of the key points which can be used as a simple reference. This layout means that if you’re a quick learner or are familiar with some of the concepts you can just read the comic section and then try implementing the material covered on your own. On the other hand if you want more information and depth you can read the text that follows.The material is presented in such a way that it should be easy for the reader to “learn by doing” as they copy or modify what the main character in the cartoon does (in this case building a website for her photography portfolio). All that’s needed to get started is a browser, a text editor and some knowledge of how to organise files on a file system. This coverage of raw HTML and CSS may sound off-putting to non-technical people but it’s presented in such a simple manner that pretty much anyone should be able to follow along. The benefit of this “back to the basics” approach is that one is not limited to using only a certain piece of software and instead the fundamentals can be applied to other tools later.

The book provides a good introduction to HTML and describes some useful tags that can be used to start creating a simple website. CSS are explained in a similar manner and the reader is shown how they can be used to easily change the look of a website. These two technologies are the bedrock on top of which pretty much all web development rests and thus understanding them is a prerequisite for anyone wanting to create their own websites. The book also does a good job of showing how a content management system like Wordpress builds on top of these foundations and how you can still get to the underlying HTML and CSS should you want to (as well as why this might be useful if you want to modify something that Wordpress does or doesn’t do). On the Wordpress front the basics are covered — from creating pages and page hierarchies to how these can be categorised and grouped. Unfortunately when going into more detail on this topic things lose a bit of coherence. Wordpress is obviously a big beast which has entire books devoted to it and cramming in a summary of it means having to leave out a lot. It seems as if the author might have had to trim these sections down and this has resulted in the text feeling a bit rushed and confusing which is in contrast with the rest of the book where the topics are covered in a slower and more detailed manner. Any book that describes using a piece of software like Wordpress to the level of explaining how to point and click one’s way through certain step risks becoming outdated as the software changes in future. For the most part this shouldn’t be too much of an issue as Wordpress isn’t covered in too much detail but it does mean that this book probably won’t be a reference you still use in five year’s time.

On the whole Build your own website succeeds in its goal of presenting a gentle learning curve and guiding people through what is needed to create a website from scratch. It is just technical enough that readers should be able to understand the fundamentals of what they are doing while being non-intimidating and introducing concepts at a relaxed and fun pace via the comic format. By the end of this book readers should have a solid grasp of the basics of website creation and be able to set up a simple site themselves, either by coding this up in HTML and CSS directly or by using Wordpress. For anything more advanced one would need to move on to other books or self-teaching but this book is a great starting point if you’re new to the subject.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
Book Reviews

Submission + - Book Review: Super Scratch Programming Adventure!

MassDosage writes: "I first heard about the Scratch programming language a few years ago and the idea of a simple language designed to teach kids to program in a fun, new way has always appealed to me. For those of you who don’t know, Scratch was developed by the wonderfully named “Lifelong Kindergarten Group” at the MIT Media Lab. It’s a programming language that allows programs to be built by dragging, dropping, configuring and combining various blocks that represent common coding concepts such as if/else statements and while loops. Scratch also provides tools for doing simple animation, playing audio and controlling sprites. The idea behind it is to make programming simple, fun and accessible to first time programmers so they can understand the key concepts without first needing to learn complex syntax which can come later when they move on from Scratch to other languages. It has been very successful and there are literally millions of Scratch programs freely available from the Scratch website and many others.

The Super Scratch Programming Adventure book has recently been translated from the Chinese original and is in keeping with the Scratch ethos of bringing programming to a new generation of programmers. It is hard to tell what the age group for this book is as children have such varied technical skills but I would say it’s best for relatively computer savvy youngsters who know the basics of computing and are comfortable with a mouse and keyboard and know how to drag, drop, open, save, cut, paste etc. It should be suitable for ages from 8 up to young teenagers but even those a bit older looking to learn programming could find it useful while younger children might also be able to get something out of it if guided by someone older.

The book starts of with a bit of background and points the reader to where they can freely download and install the Scratch application which is used to create Scratch programs. This is available for Windows, Mac and Linux and was a breeze to install on Ubuntu Linux. All programming is done via a GUI to avoid having to deal with typos and syntax errors. The Scratch environment is fairly simple and intuitive and easy to get started with. A downloadable zip file accompanies the book and contains skeleton programs with sound and images that are used for creating applications as well as fully complete programs which can be used for reference if you get stuck creating your own versions. The zip file also contains a “Getting started with Scratch” guide that is a very useful prelude to the book if you’ve never used Scratch before and covers the main concepts and tools that are used in the book itself. It is important to note that this book is not a manual for Scratch and doesn’t provide exhaustive coverage of what Scratch can do or how to use all of its features. Super Scratch Programming Adventure takes a “learn by doing” approach by guiding you through the creation of a few programs and leaves you to figure the rest out yourself. Given the target audience this makes a lot of sense — most youngsters would much rather build some cool applications right away than wade through lots of dry documentation first.

Super Scratch Programming Adventure is divided into various “stages” (computer game speak for “chapters”) that are linked by a colourful cartoon adventure story. Each stage guides the reader through creating a computer game from... err... scratch and teaches them some fundamental concepts along the way. Later stages build on lessons learnt earlier so they should be read in order and the book steers one towards this with the cartoon linking what you do in the various stages together as you build games which in turn become part of the story. The early stages start off showing how to use sprites and move them around and how to use the palette to build up programs and attach behaviours to things. Later stages cover user input, broadcasting and reacting to events, flow control, collision detection, variables, animation and audio with each stage harder than the previous one right up until the final stage which involves creating a fighting game with numerous sprites and interactions between them and the user. I found all the games fun to build and use and could definitely see the distinct lessons each one was designed to teach.

The learning curve is a bit higher than I expected and there is little hand holding, at some points you just have to look at the included code blocks and figure out yourself how to build them up. It’s not always easy and readers will need to be fairly computer literate and able and willing to figure a fair amount out on their own but ultimately this is probably a good thing as explaining everything in minute detail would take a lot longer, be quite boring and would lead some to just blindly copying things instead of being forced to understand what they are doing. I could imagine that some young readers might find this a bit challenging so it’s probably a good idea to have a computer literate adult around to help out if they get stuck. The included complete source for each game also helps although looking at this does feel a bit like cheating. Each stage ends with suggestions for further programming on ones own and I felt that these are really the key for this book to succeed as a learning tool as these make one think about and apply what was just read. Again I think this would be a good point for a parent or someone older to step in and encourage a younger reader to build on what they’ve learnt and suggest creating something new for themselves. The book contains plenty of pointers to online resources where readers can learn more, ask questions and share their creations with others.

I would definitely recommend Super Scratch Programming Adventure for those eager to learn programming but be aware that to really get the most out of it it’s probably best if someone who already knows how to program is around to read along, help out and encourage further creation outside of what the book shows. There is a wealth of Scratch related information on the internet but this book provides a good way to get started by demonstrating how to build fun applications and hopefully this in turn will encourage readers to move on to creating more on their own.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion."
Book Reviews

Submission + - Presentation Patterns Book Review

MassDosage writes: In a remarkable show of good timing Presentation Patterns turned up on my desk for review within days of me having been asked to give a presentation at a large tech conference. So I decided to read the book as I worked on my presentation and apply any lessons learned as I worked my way through it. The word “patterns” in the book’s title will be known to most software developers as a reference to the seminal “Gang of four” software design patterns book which codified common solutions to software problems. The concept of patterns originated in building architecture with the idea being that by categorising and naming solutions to problems, a common vocabulary could be built up that allowed practitioners in a certain field to communicate more effectively. This was hugely successful and has spawned the idea of looking for patterns in many other areas which is where this book comes in.

Presentation Patterns aims to apply patterns to the task of creating and delivering presentations and for the most part it succeeds. The format of the book is slightly biased towards those in the software industry as the authors all have software backgrounds. However after reading the introduction which explains the rationale behind patterns in general, as well as the specifics of how they are covered, this book should be useful to anyone interested in improving their presentation skills. The book is divided into chapters which follow the timeline of creating a presentation — starting with patterns on preparing a presentation (e.g. “Know your audience” and “Narrative Arc) through to actually building a presentation (e.g. “Defy defaults” and “Infodeck”) and ending with patterns related to the final delivery of the presentation (e.g. “Seeding satisfaction” and “Breathing room”). This temporal categorisation of patterns is logical and worked very well for me as I could read through a section and apply it to the part of the presentation I was working on at the time before moving on to the next section.

Each pattern is described using a standard format which includes: other names for the pattern; a definition of the pattern; a motivation for why it is relevant; a discussion of where it is applicable as well as the consequences of using it; and a list of related patterns. Because each individual pattern is described in the same way it’s easy to compare them and see why and how they should be applied. While patterns give advice on things that one should do, just as important is advice on what not not to do. The authors include plenty of this in the form of “antipatterns” which are described in the same way as patterns, the only difference being that they are things to avoid in a presentation, some examples being “Ant fonts” and “Disowning your topic”.

Scattered throughout the book are anecdotes from the authors that describe real world situations where certain patterns were useful and some additional back stories to how they were discovered or applied. These add some welcome variety to the text while also showing that this isn’t pure theory but has been derived out of the actual experiences of the authors (all of whom are regulars on the presentations circuit). Presentation Patterns can be read from beginning to end but after an initial read it will probably be even more useful as a reference — particularly by those who present regularly as they can look up information on a specific pattern that is of interest at a particular time.

While a lot of the patterns and antipatterns covered are fairly general and not tied to any particular technology, the authors do assume that most presentations will be created and delivered in a digital format. They try to avoid discussing any specific presentation software but in a few cases they go into more depth and describe how a certain technique would be implemented using Microsoft’s Power Point and Apple’s Keynote software. I’m a Libre Office user but fortunately most of their descriptions were easy enough to translate to another tool . Having said that, these cases are not the norm and if you are looking for a tutorial or manual on how to build presentations using a certain piece of presentation software then this book is not for you. I got the feeling that the authors were aiming for their advice to be timeless and have tried to describe generalities rather than the specifics of a particular tool.

Presentation Patterns is well written and contains lots of good advice, backed up by concrete examples from the authors’ past experiences. A wide variety of patterns are covered and the breadth and the depth of these mean that there should be something relevant for most possible usages. Not every pattern is applicable to every type of presentation so it is up to the reader to understand when and where to apply specific patterns. For example, if your presentation is primarily going to be delivered by e-mail and read by people as opposed to you presenting it in person then certain patterns make more sense than others. The patterns are cross-referenced against each other so you can see how using one might influence the use of another. This is slightly annoying at the beginning when you are not familiar with all of them but as you expand your pattern vocabulary it starts to make a lot more sense.

I finished reading this book at around the same time I completed and then delivered my presentation and I definitely learnt some lessons that, when applied, made my presentation better than it would have been without them. At the end of the day most of the content is common sense and probably won’t be that surprising to anyone who has given or viewed presentations in the past but it is still useful to have it all written down in one place. I will definitely use the book again, probably not to read it from cover to cover but more as a checklist and refresher of what to aim for and what to avoid when I work on my next presentation. The patterns format might not be for everyone and will take a bit of getting used to by those for whom it is new but on the whole I think it works very well for this material and would recommend it to anyone hoping to improve how they prepare, create, build and deliver presentations.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
Book Reviews

Submission + - Wonferful Life with the Elements book review

MassDosage writes: Wonderful Life with the Elements Book Review By Mass Dosage

I’ve always found Chemistry interesting, particularly in high school when I had the good fortune of having a Chemistry teacher who was not only really good looking, but a great teacher too. I studied it for a year at University and then moved on and haven’t really given the periodic table and its elements much thought since. This changed when the Wonderful Life with the Elements was delivered to me two weeks ago. It’s one of those books that aims to make science fun and, unlike many other attempts which turn out to be pretty lame, this actually succeeds in presenting the periodic table in a fresh, original and interesting manner.

Wonderful Life with the Elements is the brainchild of a Japanese artist, Bunpei Yorifuji, who has published a few other books in Japan and created some adverts for the Tokyo metro (which you can find by doing an image search for his name and “Do it at home”). His animation style for these adverts features simple, clean cartoon characters drawn in yellow, black and white. In a Wonderful Life with the Elements he has taken this technique and applied it to the periodic table by drawing each element as a cartoon character where every detail has some scientific significance. Elements that were discovered a long time ago have beards while more recent discoveries have dummies (pacifiers for those in America) in their mouths. Heavy elements are fat. Elements with lots of industrial uses wear suits while those that are man-made look like robots. He also adds amusing little touches to each element and it is obvious he took a lot of time and care in doing this and researching and then presenting the details about each of them. It really feels like the elements have individual personalities which is quite an achievement for what is often presented as rather boring and dry subject matter.

This book isn’t merely a collection of cartoon drawings — information is also included covering when and how the elements were discovered, what they are (or were) used for and other interesting or amusing pieces of trivia. There are also the more traditional facts like atomic number, symbol, position in the periodic table, melting and boiling points and density. Some elements get more detail than others depending on how well known and/or useful they are. My only real criticism of the book is that the elements in period 7 only get small drawings and a cursory description each. I’m not sure why they were singled out for this treatment. Did the author get bored towards the end? Was there lack of budget? Did he run out of time? Does he have a personal grudge against period 7? Considering that this period includes rather famous elements such as Uranium and Plutonium and that they get the same low level of detail as relative unknowns like Ununseptium and Darmstadtium this feels like a rather odd omission.

The main stars of the Wonderful Life with the Elements are the elements themselves but the introductory and closing chapters are worth reading too. The book starts off with an overview of the elements and which ones are found most commonly on our planet and in our living rooms before moving on to the periodic table itself and an explanation of what the various details on the cartoon drawings of the elements mean. The closing sections describe which elements are an important part of a human diet and what the effects of eating too little or too much of each of them are before wrapping up with a warning about the possibility of us running out of certain elements and what the negative impact of this could be. This is all written in an informal, humorous style that makes all these facts appear really interesting and, dare I say it, fun to read.

Wonderful Life with the Elements is a very enjoyable book and the author has done a great job of injecting some colour and personality into what many people would view as a rather dull topic. If I had had a book like this in high-school I think I would have found Chemistry interesting, even without the attractive teacher. It is worth pointing out that is isn’t a replacement for a Chemistry text book — it only touches the surface of the large body of theory that underpins the elements and the periodic table. However I would still wholeheartedly recommend this to anyone with even just a casual interest in the subject. The original presentation of this material and the amusing personal touches are fantastic and turn this book into a fun, easy read which isn’t something one can say about most books that deal with Chemistry.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
Book Reviews

Submission + - Book Review: Think Like A Programmer

MassDosage writes: After nearly 15 years or of writing code professionally it was refreshing to take a figurative step back and read a book aimed at people getting started with computer programming. As the title suggests, Think Like A Programmer tries to get to the core of the special way that good programmers think and how, when faced with large and complex problems, they successfully churn out software to solve these challenges in elegant and creative ways. The author has taught computer science for about as long as I’ve been programming and this shows in his writing. He has clearly seen a lot of different people progress from newbie programmers to craftsmen (and craftswomen) and has managed to distil a lot of what makes this possible in what is a clear, well-written and insightful book.

Think Like A Programmer is probably best read by those with at least a year’s experience with programming, such as first or second year computer science students or those picking up programming on their own. The code examples in the book are all written in C++ so a basic knowledge of C++ syntax is required but this should be easy to pick up by anyone with familiarity with related or similar languages. Experienced programmers looking to brush up on their fundamentals will most likely find something useful here too. They probably do a lot of what is suggested here already without being aware of it but it can be encouraging to see this formalised in a book. I found it gratifying to see that some of the techniques I use daily were covered here — it’s good to know that I’m not the only one who scrawls down funny diagrams and sketches out a rough plan before actually typing any code.

Different types of problem solving are discussed in separate chapters which cover the use of data structures, pointers, recursion and code libraries before wrapping up with a final chapter that brings all the previous approaches together. The book is intended to be read in its entirety with later chapters making frequent references to topics covered earlier. Think Like A Programmer is not a cheat sheet or cook book with quick fixes but a more substantive book that rewards those who read it as thoroughly as it has been written. Each chapter contains a few examples which are used to explain the topic under discussion and these have been well chosen to illustrate the key concepts. A series of exercises are also included which build on and extend each chapter. The author stresses that if the reader really wants to learn something and improve their problem solving skills then these exercises should be considered even more important than the text. The best way to learn how to program is by doing and the exercises force one to put what one has just learned into practise. The first few exercises at the end of a chapter are relatively simple and are basically variations on the examples that help the reader build confidence before moving into more challenging and tricky exercises that push one to apply one’s recently acquired knowledge to new limits.

Throughout the book everything is explained in a good level of detail and enough background information is provided so that the reader should never feel out of their depth. The pros and cons of the various presented solutions are clearly weighed up with logical backing. The author is obviously very knowledgeable and experienced with teaching hard concepts to new learners and this shows in his no-nonsense, down-to-earth but enjoyable writing style. The code samples are clear and well thought out as are the diagrams that accompany the various examples. The chapter on classes was the only one where I felt like focus was being lost due to too many C++ implementation details but perhaps that’s just the nature of the language. I would have liked the example here to show more clearly how classes can turn a morass of functional code into something more logically grouped and easier to understand. To be fair, the exercises at the end of this chapter do ask one to do this by asking one to convert a collection of string utility functions into a more logically organised string class. This again shows the importance of actually doing the exercises and not just simply reading them.

The core idea of how programmers take a complex problem and then break this down into smaller, more manageable and solvable parts is well described. The importance of having a plan before jumping in and writing code without thinking is stressed and there are great suggestions for how to take stock of your own personal strengths and weaknesses and come up with a personal plan that works for you. The example is given of someone who likes jumping right into coding — for someone like this it probably makes sense for them to do early prototyping as a way to start solving a particular problem, as long as the longer term plan involves taking a step away from this and incorporating the lessons learned into a more thoroughly thought out solution later. In this, as in the rest of the book, the author shows his years of experience teaching a wide range of people with different skill sets and approaches to problem solving. There is no single way to think like a programmer, but rather a number of tried and tested strategies that can be employed in various ways. Think Like A Programmer captures this core idea in an satisfying, down to earth manner and I can highly recommend it to anyone wanting to improve their problem solving capabilities. I wish I had had this book when I started studying computer science — the fundamentals contained here would have been a valued addition to the text books teaching syntax and specific technologies.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
Book Reviews

Submission + - How Google Tests Software Book Review

MassDosage writes: "Having developed software for nearly fifteen years I remember the dark days before testing was all the rage and the large number of bugs that had to be arduously found and fixed manually. The next step was nervously releasing the code without the safety net of a test bed and having no idea if one had introduced regressions or new bugs. When I first came across unit testing I ardently embraced it and am a huge fan of testing of various forms — from automated to smoke tests to performance and load tests to end user and exploratory testing. So it was with much enthusiasm that I picked up How Google Tests Software — written by some of the big names in testing at Google. I was hoping it would give me fresh insights into testing software at “Google Scale” as promised on the back cover, hopefully coupled with some innovative new techniques and tips. While partially succeeding on these fronts the book as a whole didn’t quite live up to my expectations and feels like a missed opportunity.

The book is written in an informal, easy to read manner and organised in such a way that readers can read chapters in any order or just choose to focus on the parts that interest them. One annoying layout choice is to highlight and repeat certain key sentences (as is often done in magazines) resulting in one reading the same thing twice, often only words away from the original sentence. Thankfully this is only the case in the first two chapters but it highlights the variable quality of this book — possibly due to the authors having worked separately on different chapters. How Google Tests Software isn’t a book for people new to testing or software development. The authors assume you know a fair amount about the software development lifecycle, where testing fits into this and what different forms testing can take. It is also largely technology neutral, using specific examples of testing software that Google uses only to illustrate concepts.

After a brief introduction as to how testing has evolved over time at Google the book devotes a chapter to each of the key testing-related roles in the company: the “Software Engineer in Test” (SET), the “Test Engineer” (TE) and the “Test Engineering Manager” (TEM). SETs are coders who focus on writing tests or frameworks and infrastructure to support other coders in their testing. The TE has a broader, less well-defined role and is tasked with looking at the bigger picture of the product in question and its impact on users and how it fits into the broader software ecosystem. These two sections form the bulk of the book in terms of pages and interesting content. The TEM is essentially what the name says — someone who manages testers and testing and coordinates these activities at a higher level within Google.

The descriptions of each of these testing roles highlights the ways Google’s thinking about testing has matured and also shows how some of these approaches differ from other companies. There are also explanations of the tools and processes that people in these roles use and follow and this for me was the most interesting part of the book. Topics covered include: specific bug tracking and test plan creation tools; risk analysis; test case management over time; and automated testing. Particularly of note are discussions on using bots to perform testing of web pages to detect differences between software releases, cutting down on the amount of human interaction required as well as the opposite approach — using more humans via “crowd sourced testing” among first internal and then select groups of external users. The tools that Google utilizes to simplify tester’s jobs by recording steps to reproduce bugs and simplifying bug reporting and management sound very useful. Many of the tools described in the book are open source (or soon to be opened) and are probably worth following up on and investigating if this is what you do for a living.

In addition to the main body of text most chapters also include interviews with Google staff on various testing related topics. Some of these are genuinely interesting and give the reader a good idea of how testing is tackled at Google on a practical level. However some of the interviews fall into the “navel gazing” camp (especially when the authors interview one of themselves) and feel more like filler material. I enjoyed the interviews with Google hiring staff the most — their take on how they recruit people for testing roles and the types of questions they ask and qualities they look for make a lot of sense. The interview with the GMail TEM was also good and illustrated how the concepts described in the book are actually performed in practise. The interviews are clearly marked and can thus be easily skipped or skim read but one wonders what more useful text could have been included in their place.

The book wraps up with a chapter that attempts to describe how Google intends to improve their testing in the future. The most valuable point here is how testing as a separate function could “disappear” as it becomes part and parcel of the product being developed like any other feature, and thus the responsibility of all of the people working on the product as opposed to it being a separate thing. Another key point made throughout the book is how the state of testing at Google is constantly in flux which makes sense in such a fast moving and innovative company but leaves one questioning how much of this book will still be relevant in a few year’s time.

How Google Tests Software isn’t a bad book but neither is it a great one. It has some good parts and will be worth reading for those who are interested in “all things Google.” For everyone else I’d recommend skimming through to the parts that grab your attention most and glossing over the rest.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion."
Book Reviews

Submission + - Book Review: Getting started with Audacity 1.3

MassDosage writes: Getting Started with Audacity 1.3 by Bethany Hiitola covers the basics of using the Audacity software package for recording and editing audio. This book is written in a tutorial style and stays true to its title by covering Audacity from a newcomer's perspective with lots of diagrams and detailed explanations of how to install and setup Audacity and use its most essential features. This is all very much aimed at people who are new to audio software and are looking for a simple way to get started and be guided through creating and editing an audio recording. On the whole it achieves this but is occasionally let down by overly simplistic content and shoddy editing.

Audacity 1.3 is the latest version of this well known free and open source software program that runs on GNU/Linux, Windows, Macs and any other operating system that an aspiring techy gets the source code to compile on. The author has done a good job of keeping the software's cross-platform nature in mind by minimising anything operating system specific and describing alternative approaches where necessary. I followed along with the book's examples using Linux and didn't run into any platform-specific issues.

I've personally had a fair amount of experience with many different audio editors over the years but haven't worked that much with Audacity so I was interested in what this book had to offer me. To be honest most of what is covered I had already figured out myself just from playing with Audacity in the past. This book is really targeted at complete newbies — if you've used an audio editor of any form in the past and are comfortable recording or importing audio and applying some basic filters and effects to it, then the very basic, tutorial nature of this book probably won't be of much interest to you. However, for those who don't know much about audio editing and are looking for somewhere to start then this might just be what you're looking for.

It may not be the prettiest audio tool on the planet, but Audacity really is "good enough" for those wanting to do simple editing. The fact that it is totally open and free for anyone to download and use means that the software itself is a great starting point for an aspiring audio editor or creator as the barriers to entry are very low. The first few chapters of the book take one through installing Audacity and explaining how the program works and how its user interface is laid out. The minimal equipment needed to make a vocal recording (i.e. a microphone, soundcard and headphones) is touched on and again it is very clear that there is a low barrier to creating something simple. If you want to make state of the art recordings then you may need to spend a fortune on equipment but for the purposes of getting started one really doesn't need much.

The main example in the book covers creating a podcast from scratch which is a good choice as its something that many casual users are probably interested in. This also provides an opportunity to discuss most of the important aspects of recording audio and doing common tasks like removing noise, splitting up tracks, adding background music, fading sound in and out and applying various effects.This is all done with lots of diagrams and step-by-step explanations of the menu items and buttons to push to achieve this. Strangely enough the author mentions keyboard shortcuts (which is good) but instead of describing probably the most useful shortcut of all (CTRL-S to save) she describes going to the file menu and selecting "Save" each time.

The podcast example is expanded upon to show how audio can be cut, pasted, silenced and made louder or quieter. Noise removal is covered in a bit more depth than the other topics which is a good thing as the filter that is used to do this isn't very user friendly — after selecting the noise profile it vanishes with no information on what to do next. This is also something most users will probably need at some point as are the steps on how to normalise and compress the audio. The effects and filters covered are also the ones that a new user is most likely to want to start playing with. The bare essentials are wrapped up in a chapter explaining how to export audio to MP3 (or other formats) and some suggestions are given as to how to make this publicly available via an RSS feed or by uploading the audio to iTunes. It would have been nice to have some pointers to alternative ways of doing this, especially some more open form of publishing than Apple's proprietary and closed platform. There is even a whole section on how to circumvent Apple's DRM by converting locked iTunes audio files to CD and then importing from there into Audacity which is probably useful to some but feels a bit out of place in a book about an open tool like this.

The book also covers a number of other topics which are assembled somewhat randomly but are generally useful. These include adding background music, time shifting, adjusting pitch and tempo as well as various options for aligning, splitting, joining and moving multiple tracks around. Every effect that ships with Audacity is covered and this is serves as a reference guide for what each of them does. Adding more functionality to Audacity via the use of plugins is touched on but this is really just a teaser and isn't covered in much depth (probably due to the platform-specific nature of their installation).

I was a bit disappointed in the book as I didn't learn as much as I would have liked, this is really more of a "how to do the basics" and doesn't provide much depth on Audacity or audio concepts in general. It would have been nice if the book had wrapped up with some pointers for those wanting to know more or go further with their audio editing skills. The overall tone of the book is friendly which suits its "for beginners" approach but at times it is let down by not sounding very authoritative or convincing. The bad grammar and silly typos that weren't caught by the editors don't help much in this regard either. Give it a go if you're the type of person who needs a tutorial guide to get started, otherwise you can probably figure out most of the topics covered by just playing with the software yourself.
Book Reviews

Submission + - Book Review: Software Build Systems

MassDosage writes: Software Build Systems Review by Mass Dosage

Software Build Systems by Peter Smith is a well written, albeit rather lengthy book that covers the intricacies of systems used to build software. It tries to do this in a technology-neutral manner where possible but covers existing tools like Ant, Make and Scons as a means of illustrating the various concepts covered instead of just focusing on theory. The real world examples illustrate building Java, C/C++, C# and Python software and cover scaling up from small builds with tens of source files up to massive builds with tens of thousands. All of the technologies used are introduced in some depth which newcomers should find useful but experienced build developers may want to skim over.

Software Build Systems weighs in at a hefty 580 odd pages and covers a lot of ground. It is targeted at developers, managers and build engineers and while there is definitely something for all of these groups, each of them will most likely find themselves skipping sections which are either not of interest to them or are too basic. It is also important to note that this book is not a hands-on tutorial of how to set up a build system from scratch but instead uses a variety of detailed examples to illustrate its concepts with pointers to external documentation for those wanting to actually implement a complete build system of their own.

The book is clearly divided into parts which move from "The Basics" to "The Build Tools" and then on to "Advanced Topics" and finally "Scaling Up". "The Basics" really is basic and most build engineers and developers worth their salt can probably skim read most of this. The fundamentals of C/C++, Java and C# are also covered illustrating a major theme in this book in that it tries to be programming language neutral and just use the different languages as examples to explain various concepts. While this is an inclusive, worthwhile aim it does mean that someone only interested in say, building Java software, will find large parts of the book irrelevant. This applies particularly to the chapters on the various build tools where Make, Ant, SCons, CMake and Eclipse are all covered in painstaking detail. The pros and cons of each of these tools are discussed in a non-biased manner using real world examples where possible. Anyone who has actually written a build system using one of these tools probably won't find much they don't already know but for a manager or someone new to any of these technologies the author provides a a good introduction with mentions of similar tools and pointers for finding out more about each of them.

"Advanced Topics" is where things start to get interesting as concepts like dependency graphs, change detection and version management that the build tools rely on to function are discussed in depth. A lot of the advice in these chapters feels like it comes from practical experience and the best parts are where tool-neutral tips are provided. There is a bit too much detail here as well as the odd digression which feels unnecessary in a book of this length. Do we really need to know the details of lex and yacc in order to create a build system? The author clearly has an understanding of open source development and competently discusses the wild world of building software that may run on a plethora of machines and platforms that the developers have little or no control over as well as software that is built in a more clinical manner for a limited set of environments.

Build systems for massive software projects are covered in "Scaling Up" and the author acknowledges that this probably isn't relevant for everyone. I however think that the first chapter in this section ("Reducing complexity for end users") is the best in the whole book and applies to all build systems, regardless of size or technology. A better title for this chapter would have been "Best practices for build systems" as it doles out plenty of good tips such as how to automatically detect dependencies, what not to keep in a source control system, when to abort a build (early), why to ensure there is always a way to clean up all build-generated artefacts and so on. The gist here is to try to reduce complexity wherever possible and the advice is all very well reasoned and practical. The book wraps up by covering methods for reducing the size of a build and ways to speed up and optimise builds.

Overall this is a very well written, edited and structured book but it does suffer from attempting to cover too much and going into detail on topics which aren't going to be of interest to everyone. A prime example of this is the section on packaging technologies where I doubt that someone concerned with creating Debian packages will find the information on the Nullsoft Scriptable Install System very useful, or vice versa. The same applies to the varying levels of technical detail in the book — a manager may find the introductions to concepts like compiled versus scripted languages enlightening but to most developers this will be old hat. Conversely the intricacies of how Make calculates its dependency graph is probably interesting to a build engineer but most managers will be out of their depth.

This isn't the kind of book most people will read from cover to cover. Instead I recommend skimming through the sections that aren't immediately applicable and just focusing on the parts that discuss the particular build technologies the reader is interested in as well as the more technology neutral parts towards the end. It is obvious that years (if not decades) of real world experience have been distilled in Software Build Systems. It is just a shame that this process wasn't a bit more focused as this could have been a great book, instead of just a good book with some great sections and some sections that most readers will find themselves skimming over.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.

Comment Re:Slashvertising (Score 1) 53

Thanks @ajo_arctus. I don't consider myself a "shill" as my reviews are my own honest opinion and Packt have no influence on what I say about their books. This is only the second Packt book I've read, the other one (Solr 1.4 Enterprise Server) was actually pretty good so I'm not sure I'd write off *all* their other books. I haven't read the Postgres book you mention, the title sounds interesting though and I'd be curious to know opinions of anyone else has read it.
Books

Submission + - Book Review: Apache JMeter

MassDosage writes: "Apache JMeter written by Emily H. Halili is very much an introductory guide to using Apache’s open source JMeter testing tool. Unfortunately a book that should have been good fodder to wet the appetites of testers is spoiled by shoddy editing, poor writing and very little content that isn’t already included in JMeter’s own user manual.

I am one of those (fairly) rare software developers with a genuine interest in testing and first tried using JMeter many years ago after its initial release as a tool primarily focused on testing the Apache Tomcat web/application server. It was a bit rough around the edges and poorly documented in those days so I was looking forward to a book that would re-familiarise me with JMeter in its current form. This book clearly targets itself at the testing community and doesn’t require any programming (or even much testing) knowledge.

Apache JMeter starts off with a not particularly convincing overview of why one would want to automate testing and goes off on a tangent trying to prove the monetary savings this leads too. Any testing will depend very much on the type of software being tested, the skills of the tester, technology stack in use etc. so trying to come up with a general formula proving that testing will save money is probably impossible and pointless. It would have been far more useful to include some practical examples where testing saved time, effort, caught bugs early etc. A very brief history of JMeter is provided as well as an overview of its GUI and the the various elements available. For those who haven’t used it before — JMeter acts as a client which sends requests to the application being tested and can then act on the responses returned. Overall this isn’t the smoothest of introductions with lots of grammatical errors, fragmented text and repeated concepts, which doesn’t bode well for the rest of the book.

Installing and setting up JMeter is covered next and this is straightforward and simple. A good overview of what a JMeter test plan consists of is provided and this covers controlling how many simultaneous users a test will use, what logic and timing will be used to issue requests, the type of requests (e.g. HTTP for web sites, FTP for file retrieval etc.), various configuration options, how to assert the contents of responses and so on. The book is a bit dated and the version of JMeter I was using didn’t always match up with the text and diagrams but most of the differences were self explanatory so this wasn’t really an issue.

The chapter on load and performance testing is the best on offer and provides sensible guidelines on this type of testing. These include tips such as ensuring network bandwidth between the machines under test, running the tests on physically separate machines from the software being tested, running tests for long periods of time and what to monitor. This is mainly common sense but it’s good to see them summarised and the book would have benefited from more sections that appear to be informed by the author’s practical experiences as a tester. The example given in the book is the load testing of a web site over HTTP and it’s left up to the reader to translate the various types of request being made to an example website of their own. The screen shots of setting the various GUI values are clear and useful. Remote testing (i.e. not using a single JMeter GUI but multiple command-line instances of JMeter) is mentioned but sadly not covered which is a shame as any serious load or stress testing usually requires this. Using JMeter as a proxy to quickly generate a test plan by recording HTTP requests from a browser is both neat and useful and explained well.

JMeter is not just limited to load testing but can also be used to do simple functional tests as it can inspect the values returned by requests and perform assertions on these responses (e.g. checking that the returned HTML contains some text). Unfortunately functional testing is covered very poorly with far too little detail and no explanation of how to run the examples yourself. The author should have stuck to one simple use case (ideally that the reader could follow along with) which would show how to add one’s own custom values to requests and to assert the results returned. In the end I could figure it out for myself, but I’d expect a book to guide me through this.

Advanced features are up next and the reader is pointed towards the sample code included with the book (a .rar file inside a .zip file, why?) but absolutely no explanation is given as to what one should actually do with the bunch of PHP and SQL files included in it. Using regular expressions and configuring JMeter to run tests using loops is covered but this doesn’t make much sense as there is no context for the example used in setting this all up. Fortunately the sections on using JMeter to test a database and an FTP server are introduced with clear setup steps that are easy to follow. I wouldn’t classify most of this material as advanced, it just gives the reader the knowledge that JMeter can be used to test more than just HTTP sites and provides a few very simple examples which they can build on.

Finally the book wraps up by stressing once again that it’s just an introduction to JMeter and a concluding table clearly showing that more is not covered than actually covered. The appendices consist of definitions of nearly every JMeter element that can be accessed in the GUI (a good quick reference), some pointers to material for readers interested in learning more, and a glossary of testing terms, the vast majority of which are never used in the book itself. Unfortunately the latter is yet more evidence of the biggest weakness of this book — the appalling editing that doesn’t even remove sentences which are completely incorrect. “You can too contribute.” (the closing sentence of Chapter 1) is just one of many examples of poor writing that somehow survived into print.

On the whole the book does give one an overview of how to get started with JMeter and the section on load testing a website is a useful introduction to various JMeter concepts. This is the only printed book on the topic out there so if you learn best reading from print then you don’t have many options. This is a shame as a niche topic like this could do with an interesting, well-informed and authoritative guide. For everyone else I would suggest reading the User Manual on the JMeter website as it covers all the material here (and much more) and is far more readable.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion."
Books

Submission + - Book Review: Solr 1.4 Enterprise Search Server 1

MassDosage writes: "[Note to Slashdot editors: my e-mail address is massdosage@gmail.com if you need to contact me. Please do NOT publish this on the site.]

Solr 1.4 Enterprise Search Server written by David Smiley and Eric Pugh provides in-depth coverage of the open source Solr search server. In some ways this book reads like the missing reference manual for the advanced usage of Solr. It is aimed at readers already familiar with Solr and related search concepts as well as those having some knowledge of programming (specifically Java). The book covers a lot of ground, some of it fairly challenging, and gives those working with Solr a lot of hands-on technical advice on how to use and fine-tune many parts of this powerful application.

Solr 1.4 Enterprise Search Server starts off with a brief description of what Solr is, how it is related to the Lucene libraries (which it is built around) and how it compares to other technologies such as databases. This book is not an introduction to search and this chapter covers only the basics and assumes the reader already knows what they are getting into or that they will read up on search concepts themselves before reading further. Solr is free, open-source technology licensed under the Apache license and is available here. This book covers the 1.4 version of Solr and was published before this version was actually released so it is a bit patchy in areas which were still undergoing change but the authors point this out very clearly in the text where applicable.

The book provides details on downloading and installing Solr, building it from source and the manifold options available for configuring and tweaking it. A freely available data set from Music Brainz is provided for download along with various code examples and a bundled version of Solr 1.4 which is used as the basis for many of the examples referred to throughout the text. In some ways this dataset is limited as it only allows for fairly simple usages compared with the challenges of indexing and searching large bodies of text. Again, the authors clearly mention these limits and briefly describe how certain concepts would be better applied to other data sources.

The basics of schema design, text analysis, indexing and searching are covered over the next three chapters and these include a wide-range of essential search concepts such as tokenizers, stemming, stop-words, synonyms, data import handlers, field qualifiers, filters, scoring, sorting etc. The reader is taken through the process of setting up Solr so it can be used to index data that is to be searched and then how this data can be imported into Solr from a variety of sources like XML and HTML documents, PDF’s, databases, CSV files and many others. Using Solr to build search queries is covered with examples that the reader can run via the Solr web interface and provided sample data.

More advanced search techniques are covered next and at this point I felt a lot of what was being discussed went over my head. Perhaps this was because my own search experience hasn’t extended very far and the behind-the-scenes algorithms powering search aren’t something I’ve had to directly work with. There were sections here that definitely felt aimed at people with a much more thorough understanding of the theory underpinning search and how a knowledge of mathematics and the data being searched are essential for search algorithm design. Having said this, these chapters felt like they would be really useful to come back to at some point in the future and I’m sure that people working with search on a daily basis would find some useful advice here for how to get the best out of Solr.

Solr provides much more than just indexing and search and the fact that various components are available to do many other common search-related functions is one of its main benefits. These components provide things like the highlighting of search terms in returned results, spell-checking, related documents and so on. The authors cover components which ship with Solr to provide this functionality as well as a mentioning a few that are currently separate software projects. One can easily see how all of this would be directly applicable if one was adding search capability to one’s own product or web site as there are a lot of wheels that Solr saves you from having to re-invent. The book also mentions the various parts of Solr that can be extended to modify or add new behaviours, which of course if one of the many advantages of its open source nature.

The final three chapters move on to the more practical side of actually using Solr in the “real world” and discuss various deployment options, how it can be monitored using JMX, security, integration and scaling. In addition to Java (which is the probably the most powerful and straightforward way of integrating with Solr) support for languages like JavaScript, PHP and Ruby is described. I felt the Ruby section was way too long, maybe one of the authors has a soft spot for the Ruby language? The sections on writing a web crawler and doing autocomplete were far more interesting and probably also more generally applicable. The book wraps up with a thorough discussion on how to scale Solr from scaling high (optimising a single server through techniques like caching, shingling and clever schema design and indexing strategies), scaling wide (using multiple Solr servers and replicating or sharding data between them) and scaling deep (a combination of the former two approaches).

On the whole this is a very thorough, detailed book and it is clear that the authors have a lot of experience with Solr and how it is used in practice. This book does not cover a lot of theory and assumes a fair amount of prior knowledge and is definitely aimed at those who need to get their hands dirty and get up and running with Solr in a production environment. The authors have a straightforward, open and honest writing style and aren’t afraid of clearly stating where Solr has limitations or imperfections. While the book may have a somewhat steep learning curve, this is isolated to certain chapters which can be skipped and returned to later if necessary. The fact that the writing is concise and to the point means one doesn’t have to wade through pages of flowery text before getting to the good bits. If you’re seriously thinking about using Solr or are already using it and want to know more so you can take full advantage of it, I would definitely recommend this book.

Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion."

Slashdot Top Deals

I don't want to be young again, I just don't want to get any older.

Working...