Slashdot Mirror

jddp writes "MacDonald is a programmer's programmer, and Pro Silverlight 4 in VB is a model of what a programmer's guide should be. He explains a mass of technical information in considerable detail without losing the big-picture. His clear and concise exposition of concepts and functionality is never confusing or needlessly repetitive. The book's organization is logical, yet the chapters can be read in isolation, as the need or interest arises." Keep reading for the rest of jddp's review. Pro Silverlight 4 in VB author Matthew MacDonald pages 896 publisher Apress rating 9/10 reviewer jddp ISBN 1430235489 summary An invaluable reference for professional developers wanting to discover the new features of Silverlight One thing this book doesn't provide is an overview of the subject for a novice trying to get the big-picture. After the briefest of introductions (10 pages), the author leaps right into building applications. Nor does it provide every technical detail you will need to complete your application. (That's why we have the web). However, if you want a book that can take you from having a rough map of the territory to being a self-sufficient Silverlight developer, I highly recommend this one.

Starting from the fundamentals of Silverlight such as XAML, Layout and Elements, McDonald rarely puts a step wrong as he winds through the technical details, progressing to specific functional areas such as such as Animation, Data Binding and Web services. Each chapter provides a brief overview of the functionality addressed before stepping through the programming details. His code examples are concise, but also convey the significance and use of the features very clearly. The examples do not sprawl across pages and pages, as in weaker tutorials, but they do build upon one another when necessary. Working code implementing the examples from the text is available at MacDonald's personal site for anyone to download — but apparently only in C# (as far as I could see. The VB version may be coming later, just as the VB book lagged the C# version). Due to the intelligent choice, structuring and clear implementation of his examples, I have found them a useful jumping-off point for "real-life" applications on several occasions. The author has gone beyond the scope of the book in at least one case, implemented an "advanced" capability (support for large file up/downloads via a Web Service) that I was specifically interested in.

As mentioned, the book does not contain an extensive technology overview and this is reflected by the absence of many of the buzzwords associated with Silverlight from the index. You will find no mention of RIA services. MVVM is only touched upon in the context of the new SL 4 support for the Command pattern. (Even so, his brief explanation is a great example of MacDonald's lucid and economical expository style. You could trawl the web for a long time without finding such a straightforward explanation.) However, while MacDonald does not attempt to convey any over-arching architectural vision, he is perfectly capable of clarifying some abstract design concepts. In Chapter 4 of the book he is already tackling the intimidating-sounding topics of Dependency Properties, Attached Properties and Routed Events. By the time you've read a few pages you're wondering what all the fuss was about. After less than six pages, MacDonald is working through a meaningful application of attached properties (a custom layout panel). Most of the chapter is devoted a detailed explanation and illustration of Mouse and Keyboard event handling, and to the new Commanding support in SL 4.

A final caveat: This is not a book for someone wanting to catch up on what's new in Silverlight 4. The information is there, but it is dispersed among the relevant sections of the old book, and there is no helpful index. Contrary to the impression given by the back-cover, the very occasional "What's New" boxes don't help much in homing in on new features. In fact, the organization of the material and most of the content is unchanged from the SL 3 edition, so I wouldn't buy this if you already have that book.

While reading this book, I sometimes wished for a wider view: discussions of the merits of different architectures; comparisons to design patterns used in other technologies, and so forth. This book will not be much help in defining the architecture for your next mega-app. This is a book to seize on when you need to get a handle on programming specific Silverlight features fast. You won't learn about every possible shortcut or dead-end on the trail, but you will never have to wonder where the heck you are.

While this book it isn't all things to all developers, it is hard to overstate its consistent intelligence and clarity, or its sheer usefulness (to programmers). Programmers just aren't supposed to be so articulate – are they?

You can purchase Pro Silverlight 4 in VB from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

J. Ayen Green writes "When the request came for me to review Drupal 6: Panels Cookbook by Bhavin (Vin) Patel, I was excited. I've been a software developer forever, a Web developer for as long as there's been a Web, and a Drupal developer since D6 was imminent. I have two Drupal books myself, and am working on one about D7 Views, but with all that, one glaring hole in my self-education has been Panels; it would be my first chance to use it." Keep reading for the rest of J. Ayen Green's review. Drupal 6: Panels Cookbook author Bhavin (Vin) Patel pages 220 publisher Packt Publishing rating 9/10 reviewer J. Ayen Gree ISBN 1849511187 summary contains step-by-step instructions for Drupal users to make optimum use of the Panels module Panels is the big cousin of the Views module, and big brother to the Panels Everywhere module. All were written by Earl Miles, aka merlinofchaos, a deserving macha in the Drupal community and, in my opinion, a topnotch coder: all the more reason to look forward to the book.

I need to mention the parameters within which I formed this review. I first considered the book format, because it greatly influences my expectations. A Packt 'cookbook' does not have the format or aims of a standard computer reference or 'Bible' text. It is meant to give the reader a broad but shallow exposure to a topic by using a plethora of step-by-step examples. Basically, if you come away from a cookbook feeling excited by the technology and wanting to dive deeper into learning it, the author has done a good job.

Patel starts off the book with the obligatory chapter on installation and setup, though this one contains a bit more since it is a broader Getting Started chapter. Panels is a contributed module, and installing it will be a familiar process to Drupalers. He covers installing Chaos Tools (Ctools) as well, since it is a required module. There are instructions for those upgrading from a prior release of Panels, too. Having installed and set up the module, Patel then leads you through creating a basic Panels page and node, the building blocks of a Panels layout.

It was early on that I discovered a couple things that made using the book more challenging than it needs to be. Patel uses a non-American dialect of English. While it's quite understandable, at times the usage and sentence structure require one to stop, blink, and reread the passage. Some might find this to be annoying. I looked at it as reading dialogue written by Dickens or Twain, and was fine with it. The other thing is that the instructions at times seem to skip a step, going from point A to point C without a mention of the requisite point B. Again, this causes the occasional confusion for a few moments, but nothing one cannot get past.

Chapter 2 covers a number of topics related to navigating and making use of the Panels interface and related topics. One might be biting at the bit to start creating meaty layouts by now, but Panels is a fairly complex framework to use, so having these 'recipes' available is important. Keep in mind that a 'cookbook' is designed so that most recipes are independent of each other, so they can usually be skipped over, if desired.

This chapter also touches on the topic of context, the context of 'context' here being the circumstances in which a layout exists. For example, with the standard capabilities of Drupal, a block is a fairly independent piece of content. If you want the content of a block to be intelligently related to the main content on the page, it's a difficult nut to crack aside. It can be achieved to some extent with the crafty use of Views, more so by writing a custom module, but becomes pleasantly easy using Panels. This is a big and important topic, and though this is a cookbook and not meant to be deep, I think this subject could have done with a chapter of its own.

Theming is the topic of Chapter 3. Even though Panels handles much of the work, there will likely be the desire to (re)theme its output to varying degrees, and this chapter guides the reader through examples of manipulating it with CSS, adding it to a theme region, and other useful topics.

In Chapter 4 we jump into examples of what is expected from Panels, doing things like replacing the front page, overriding the node edit form, using Panels with feeds and even using mini panels, basically panels within blocks. In Chapters 5 through 9 we move on to using Panels with other common Drupal add-on functionality: organic groups, the custom content kit (CCK), the advanced profile kit, composite layouts and Views.

Chapter 10 builds on much of what was covered and what Panels excels in by creating an example of a travel industry web site. The travel tie-in really doesn't matter, though, as one can easily extrapolate the example to whatever subject matter the intended site will contain.

I enjoyed working my way through the book. I found Patel's recipes to be creative and useful, and they gave me a sufficient understanding of Panels and its capabilities to begin considering possibilities for its use on existing and upcoming sites.

You can purchase Drupal 6: Panels Cookbook from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

FrederickSeiler writes "When David Harriman, this book's author, was studying physics at Berkeley, he noticed an interesting contrast: 'In my physics lab course, I learned how to determine the atomic structure of crystals by means of x-ray diffraction and how to identify subatomic particles by analyzing bubble-chamber photographs. In my philosophy of science course, on the other hand, I was taught by a world-renowned professor (Paul Feyerabend) that there is no such thing as scientific method and that physicists have no better claim to knowledge than voodoo priests. I knew little about epistemology [the philosophy of knowledge] at the time, but I could not help noticing that it was the physicists, not the voodoo priests, who had made possible the life-promoting technology we enjoy today.' Harriman noticed the enormous gulf between science as it is successfully practiced and science as is it described by post-Kantian philosophers such as Feyerabend, who are totally unable to explain the spectacular achievements of modern science." Read on for the rest of Frederick's review. The Logical Leap: Induction In Physics author David Harriman pages 272 publisher NAL Trade rating 9/10 reviewer Frederick Seiler ISBN 0451230051 summary Explains how scientists discover the laws of nature Logical Leap: Induction in Physics attempts to bridge this gap between philosophy and science by providing a philosophical explanation of how scientists actually discover things. A physicist and physics teacher by trade, he worked with philosopher Leonard Peikoff to understand the process of induction in physics, and this book is a result of their collaboration.

Induction is one of the two types of logical argument; the other type is deduction. First described by Aristotle, deduction covers arguments like the following: (1) All men are mortal. (2) Socrates is a man. (3) Therefore, Socrates is mortal. Deductive arguments start with generalizations ("All men are mortal.") and apply them to specific instances ("Socrates"). Deductive logic is well understood, but it relies on the truth of the generalizations in order to yield true conclusions.

So how do we make the correct generalizations? This is the subject of the other branch of logic induction and it is obviously much more difficult than deduction. How can we ever be justified in reasoning from a limited number of observations to a sweeping statement that refers to an unlimited number of objects? In answering this question Harriman presents an original theory of induction, and he shows how it is supported by key developments in the history of physics.

The first chapter presents the philosophical foundations of the theory, which builds directly on the theory of concepts developed by Ayn Rand. Unfortunately for the general reader, Harriman assumes familiarity with Rand's theory of knowledge, including her views of concepts as open-ended, knowledge as hierarchical, certainty as contextual, perceptions as self-evident, and arbitrary ideas as invalid. Those unfamiliar with these ideas may find this section to be confusing. But the good news is that those readers can then proceed to the following chapters, which flesh out the theory and show how it applies to key developments in the history of physics (and the related fields of astronomy and chemistry). These chapters do a wonderful job at bringing together the physics and the philosophy, clarifying both in the process.

Harriman argues that as concepts form a hierarchy, generalizations form a hierarchy as well; more abstract generalizations rest on simpler, more direct ones, relying ultimately on a rock-solid base of "first-level" generalizations which are directly, perceptually obvious, such as the toddler's grasp of the fact that "pushed balls roll." First-level generalizations are formed from our direct experiences, in which the open-ended nature of concepts leads to generalizations. Higher-level generalizations are formed based on lower-level ones, using Mill's Methods of Agreement and Difference to identify causal connections, while taking into account the entirety of one's context of knowledge.

Ayn Rand held that because of the hierarchical nature of our knowledge, it is possible to take any valid idea (no matter how advanced), and identify its hierarchical roots, i.e. the more primitive, lower-level ideas on which it rests, tracing these ideas all the way back to directly observable phenomena. Rand used the word "reduction" to refer to this process. In a particularly interesting discussion, Harriman shows how the process of reduction can be applied to the idea that "light travels in straight lines," identifying such earlier ideas as the concept "shadow" and finally the first-level generalization "walls resist hammering hands."

Harriman's discussion of the experimental method starts with a description of Galileo's experiments with pendulums. Galileo initially noticed that the period of a pendulum's swing seems to be the same for different swing amplitudes, so he decided to accurately measure this time period to see if it is really true. Concluding that the period is indeed constant, he then did further experiments. He selectively varied the weight and material of the pendulum's bob, and the length of the pendulum. This led him to the discovery that a pendulum's length is proportional to the square of its period. Harriman notes the experiments that Galileo did not perform: 'He saw no need to vary every known property of the pendulum and look for a possible effect on the period. For example, he did not systematically vary the color, temperature, or smell of the pendulum bob; he did not investigate whether it made a difference if the pendulum arm is made of cotton twine or silk thread. Based on everyday observation, he had a vast pre-scientific context of knowledge that was sufficient to eliminate such factors as irrelevant. To call such knowledge "pre-scientific" is not to cast doubt on its objectivity; such lower-level generalizations are acquired by the implicit use of the same methods that the scientist uses deliberately and systematically, and they are equally valid.' One powerful tool for avoiding nonproductive speculations in science is Ayn Rand's concept of the arbitrary, and Harriman brilliantly clarifies this idea in the section on Newton's optical experiments. An arbitrary idea is one for which there is no evidence; it is an idea put forth based solely on whim or faith. Rand held that an arbitrary idea cannot be valid even as a possibility; in order to say "it is possible," one needs to have evidence (which can consist of either direct observations or reasoning based on observations).

Newton began his research on colors with a wide range of observations, which led him to his famous and brilliant experiments with prisms. Harriman presents the chain of reasoning and experimentation which led Newton to conclude that white light consists of a mixture of all of the colors, which are separated by refraction.

Isaac Newton said that he "framed no hypotheses," and here he was referring to his rejection of the arbitrary. When Descartes claimed without any evidence that light consists of rotating particles with the speed of rotation determining the color; and when Robert Hooke claimed without any evidence that white light consists of a symmetrical wave pulse, which results in colors when the wave becomes distorted; these ideas were totally arbitrary, and they deserved to be thrown out without further consideration: "Newton understood that to accept an arbitrary idea even as a mere possibility that merits consideration undercuts all of one's knowledge. It is impossible to establish any truth if one regards as valid the procedure of manufacturing contrary 'possibilities' out of thin air." This rejection of the arbitrary may be expressed in a positive form: Scientists should be focused on reality, and only on reality.

After discussing the rise of experimentation in physics, Harriman turns to the Copernican revolution, the astronomical discoveries of Galileo and Kepler, and the grand synthesis of Newton's laws of motion and of universal gravitation. But this reviewer found the most historically interesting chapter to be the one about the atomic theory of matter; this chapter is a cautionary tale about the lack of objective standards for evaluating theories. This story then leads to Harriman proposing a set of specific criteria of proof for scientific theories.

The final, concluding chapter addresses several broader issues, including why mathematics is fundamental to the science of physics, how the science of philosophy is different than physics, and finally, how modern physics has gone down the wrong path due to the lack of a proper theory of induction.

So, with the publication of Logical Leap, has the age-old "problem of induction" now been solved? On this issue, the reader must judge for himself. What is clear to this reviewer is that Harriman has presented an insightful, thought-provoking and powerful new theory about how scientists discover the laws of nature.

You can purchase The Logical Leap: Induction In Physics from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

brothke writes "Securing the Smart Grid: Next Generation Power Grid Security, authors Tony Flick and Justin Morehouse provide a comprehensive and first-rate overview of smart grid technology and what is needed to ensure that it is developed and deployed in a secure and safe manner. An issue is that smart grid has significant amount of hype around it, including the promise that it will make energy more affordable, effective and green. With that, promises around security and privacy are often hard to obtain." Read on for the rest of Ben's review. Securing the Smart Grid: Next Generation Power Grid Security author Tony Flick and Justin Morehouse pages 320 publisher Syngress rating 9/10 reviewer Ben Rothke ISBN 1597495700 summary Excellent overview on smart grid technology and its related security, privacy and regulatory issues While the books notes early on that there is no singular definition of what defines smart grid, a generally accepted definition is that it is a "network of technologies providing real-time two-way communication that delivering electricity from utilities to consumers".

Most importantly, it is crucial to understand that the smart grid is an evolving environment, not a single entity or technology.

As important as the smart grid and security is, roughly 80% of Americans claim to know little or nothing about the smart grid, while 76% lack knowledge or understanding of smart meters, according to results of the latest Market Strategies International E2 Study.

From a security perspective, securing the smart grid is a complex endeavor. When you combined this with a public that is oblivious to the security and privacy issues, it gets worrisome quite fast.

The books 14 chapters provide a good overview of the various aspects of smart grid, energy and utility transmission, security, privacy attack vectors and more. The book offers a good balance of the topics, in a very readable format.

In chapter 1, the authors note that a smart grid is not a single device, application, system network, or even idea. And that there is no single authoritative definition for what a smart grid is. With that, the initial chapter sets and defines the various aspects to smart grid.

Chapter 2 provides an overview of the threats and impacts of smart metering at the consumer level. A large part of smart grid technologies is advanced metering infrastructure (AMI), which is a set of systems that measure, collect and analyze energy usage, and interact with advanced devices such as electricity meters, gas meters, heat meters, and water meters, through various communication media. Once smart grid is ubiquitous, AMI will be a hacker's platform of choice.

With all those benefits of AMI come security and privacy issues, and those open the metering infrastructure to smart thieves, stalkers, and a broad range of other threats and attacks. AMI also opens up a new set of privacy issues in that the AMI devices will be collecting significant amounts of personal energy data, which may or may not be transmitted over a secure channel.

Unfortunately, leaving security to vendors of home-based products has traditionally not been met with much success. Let's hope the smart grid vendors learn from the security debacles of the past and build effective and strong security into their products.

Chapter 4 notes that smart grid security is a matter of national security and that the US government is playing a large role in directing the effort. Numerous groups have efforts in place to secure smart grids, including DOE, FERC, DoC, DHS and more.

An important group working on this is the NIST Cyber Security Working Group (CSWG). The primary goal of the CSWG is to develop an overall cyber security strategy for the smart grid that includes a risk mitigation strategy to ensure interoperability of solutions across different domains/components of the infrastructure. This strategy addresses prevention, detection, response, and recovery.

The CSWG recently created NISTIR 7628 — Guidelines for Smart Grid Cyber Security, which complement everything detailed in this book. It also has the added benefit of being free. At 577 pages, it is also much more comprehensive.

Chapter 11 is especially fascinating, which deals with the topic of social networks and smart grid. While smart grid can leverage the power of social networking, it is inevitable that people will start tweeting about their energy usage. While that energy data may seem like an innocuous tweet, that information can be used to determine if the people are at home, on vacation, using specific appliances, etc.

For example, the Lyceum is the oldest building on the University of Mississippi campus. The Lyceum also has a twitter feed about its energy usage. While this is more informational, when individuals start sharing their energy usage, without effective social media controls, the security outcome is quite predictable. With that level of information disclosure, it is quite easy to determine if a family is home, not home, sleeping, entertaining guests, etc.

As to users who in the future will integrate tweets and other energy data into their social networking, the chapter illustrates how much of a security risk this can pose by detailing vampire energy cost estimates for over 75 different types of electronic products. Attackers can use the energy data and extrapolate what products are in use, when, and more.

The chapter concludes with a smart grid social networking security checklist. The smart grid social networking security checklist contains five categories for implementing basic security controls, name around: identity, authentication, information sharing, networking and usage.

The book also includes a number of sidebar Epic Fail stories, which detail major failures and catastrophes in various energy topics.

Overall, Securing the Smart Grid: Next Generation Power Grid Security provides an excellent overview on the state of smart grid technology and its related security, privacy and regulatory issues. The book provides an excellent introduction for anyone looking to understand what smart grid is all about, and its security and privacy issues.

You can purchase Securing the Smart Grid: Next Generation Power Grid Security from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "While it is possible to create a simple website using a base installation of Drupal, the real power of this content management system is achieved through the use of modules, which can be thought of as add-ons that extend the capabilities of Drupal in specific ways — oftentimes in conjunction with other modules. These modules are developed and contributed by PHP programmers who understand how to use one or more of the Drupal application programming interfaces (APIs) to access information stored in a Drupal database, such as content, user profiles, and theme settings. These APIs have changed with Drupal version 7, and thus Drupal coders could benefit from a book that explains how to create Drupal 7 contrib modules." Read on for the rest of Michael's review. Drupal 7 Module Development author Matt Butcher, Greg Dunlap, Matt Farina, Larry Garfield, Ken Rickard, John Albin Wilkins pages 420 pages publisher Packt Publishing rating 8/10 reviewer Michael J. Ross ISBN 978-1849511162 summary A thorough guide to module building for intermediate to advanced Drupal coders. One such resource, titled Drupal 7 Module Development, was made available by Packt Publishing on 3 December 2010, under the ISBN 978-1849511162. It has half a dozen authors, all of whom are highly experienced Drupal programmers and contributors to this burgeoning open source project: Matt Butcher, Greg Dunlap, Matt Farina, Larry Garfield, Ken Rickard, and John Albin Wilkins. This team effort spans 420 pages, organized into a dozen chapters, and two appendices. Angie Byron, the Release Manager for Drupal 7, starts it off with an interesting and upbeat foreword that concisely summarizes the primary goals of this latest release of Drupal. Following it is a preface whose chapter summaries are poorly written — almost as though the writer knew nothing about Drupal. Speaking of technical knowledge, readers are expected to be familiar with Drupal, PHP, HTML, and CSS — the more so, the better. For the jQuery material, an understanding of that library and JavaScript itself would be valuable. Packt Publishing hosts a book Web page that offers a detailed description of the book, links for purchasing the print and electronic copies of the book (or the two combined, for a large discount), and the example source code for nine of the chapters (also available from the book's GitHub repositories). As with all of its other titles, the chapters end with summaries, which provide no value and simply waste space.

This book's first chapter, "Developing for Drupal 7," provides an overview of the purpose of custom modules, the practical approach that the authors will take in explaining how to create such modules, the Web technologies underpinning Drupal, the Drupal architecture, its major subsystems, and various tools commonly used for Drupal programming. Oddly, the authors hope "that the code mentioned in this chapter can serve as a foundation for your bigger and better applications," and yet no code per se is mentioned. Nonetheless, the chapter does serve as a decent introduction for PHP programmers new to "the Drupal way." The second chapter, "Creating Your First Module," shows the reader how to do exactly that, using a very simple module to illustrate the basics, such as the files that typically compose a Drupal module, as well as some Drupal coding standards. Unfortunately, regarding the code on page 38 that checks whether the $path variable is "admin/help#first," no explanation is provided as to why the "#" is not a "/," given that the URL path in the reader's browser will be "/admin/help/first," and the "#first" does not refer to a page anchor. After a worthwhile detour into Drupal internationalization and the t() function, the authors introduce both the Block API and the Testing module, through example. Incidentally, readers trying out the sample code will want to add "static" to "public function getInfo()" in first.test — as is done in all of the other Drupal 7 core test files — to avoid a PHP "strict" warning of a static call to getInfo() in simpletest_result_form().

The next two chapters focus on theming — specifically, Drupal's theme layer and techniques for theming a custom module. The material in both chapters is arguably comprehensive, and thus ideal for a reader already well-versed in Drupal 6 module development. But, for anyone else, it will likely be overwhelming in its dense detail and in the fast pace at which it is presented — and thus will discourage most newcomers. The former chapter presents numerous high-level concepts, while the latter is intended to illustrate those ideas by focusing on module theming. Yet even if the reader carefully examines and implements the sample code — usually the best way to learn any sort of programming — these chapters will probably prove quite difficult for readers to comprehend thoroughly, unless they have prior experience along these lines. Oddly, the Chapter 4 summary tells the reader that she should have "learned a little bit about contributing your experiences [sic] and knowledge back to the Drupal community," but the material does not explain how to do so. (More on that topic later.)

Chapter 5, "Building an Admin Interface," provides a detailed survey of the Drupal menu system, the Form API (including how form data is saved, which is inadequately covered by some other books), Drupal's built-in e-mail system, and the use of tokens therein. The coverage is again detailed, and would be even better had the remaining commonly-used HTML form elements — such as list boxes and radio buttons — been shown in the example code. For those readers whose heads are still spinning from the previous two chapters, this material may be a welcome change, in that the explanations are slower paced, with seemingly greater attention given to whether the Drupal newbie will be able to learn what is being taught, step by step. However, any reader who is using this chapter as a reference when creating a custom implementation of hook_menu(), will doubtlessly become frustrated by the inadequate advice on determining the valid possibilities to be used in the access arguments array: "[check] the hook_perm() implementation of the module in question." But what module? The reader is presumably creating a new one from scratch, with no permissions already set; so the authors must be referring to an existing module — but which one? If the reader were to search through all of the core and example modules, he would find no hook_perm() functions. Do the authors mean hook_permission()? This illustrates how critical it is for authors and technical editors of books purportedly for beginners, to strive to put themselves in the shoes of the poor reader, who does not possess their knowledge and experience.

As with any CMS, "content is king" for sites built using Drupal. Thus it is critical for Drupal module developers to know how to dynamically create and manage all of the elements required by a module working with content: node, entities, fields, etc. In earlier versions of Drupal, the familiar "node" concept did not encompass all of the non-node data types, such as users and comments — forcing developers to create workarounds in their modules and in their sites as a whole. Version 7 introduces "entities" and "bundles" (which can be thought of as sub-entities), to allow greater flexibility for programmers. Chapters 6 and 7 delve into these concepts, with plenty of example code and explanations thereof. Readers learn how to create database tables indirectly using the Schema API, define new entities, give users the capability to manage them, encapsulate multiple database operations into transactions, and define new field types, widgets, and formatters.

Chapter 8, which focuses on how to set and use permissions within modules, is straightforward, and includes sections on the secure use of regular form processing, as well as AJAX callbacks (for interactive form behavior that avoids the necessity of reloading the current page). Incidentally, there appears to be an error in the code on page 221: "function example_menu() example_menu() {." Chapter 9 continues in the same realm of security, specifically, use of the Node Access system within Drupal. The coverage is quite thorough, and the only problem is that some of the "tips" blocks repeat information found in the regular text. The chapter concludes with some valuable advice on how to test and debug node access modules, which can be especially difficult.

The last three chapters of the book cover some interesting and worthwhile topics: JavaScript, file management, and installation profiles. Readers learn how to add JavaScript and CSS to a site, how to use the Drupal Library API, and related matters. Sadly, readers may be perplexed by the numerous poorly-constructed sentences — especially near the beginning Chapter 10 — such as "JavaScript within a group and within the sub-group of being or not being included in every page are ordered by weight" (page 291), which sounds like a joint effort by Hamlet and the IRS publications department. The next chapter demonstrates how to use the new files and images API that was introduced in Drupal 7, and which allows developers to reduce the number of contrib modules required for building even the most basic website. Confusingly, the reader is told that, when installing Drupal (presumably version 7), he will probably see three error messages resulting from missing sites/default/files directories; but I certainly did not see this when installing any of the beta or release candidate versions, nor heard this from anyone else. The authors also explain stream wrappers, the Image API, and image styles (and the effects they can utilize). The last chapter shows how to set up custom Drupal profiles, their tasks, and the distributions that can make use of them. The reader is told that "input formats" are now referred to as "text filters," but Drupal 7 appears to have standardized on the term "text formats." The book's two appendices discuss Drupal 7's improved database layer, and security techniques applicable to all versions.

Packt's website states that there are no known errata, so one can only assume that the publisher's editors failed to spot many obvious flaws: "a[n] introduction" (page 1), "eXtensible" (page 10), "However, Not" (page 16), "it's own data" (page 17), "though means" (page 18), "architecture advanced" (page 25; it presumably should read "advanced architecture"), "( a," (page 28), "an[d] equal sign" (29), "the the" (41 and 146), "exercising [of] every" (49), "test[,] absolutely" (53), "a child element[s]" (78), "its" (84; should read "their"), "short-coming" (85), "then" (90 and 98; should read "than"), "you will be passed to" (108), "lets" (120 and 129; should read "let's"), "FormsAPI" (235), "to post spam [to] the site" (254), "ever[y] page" (291), "html" (311; twice), "is to" (318; should read "to"), "how to we" (326), "let's make create" (326), "is [a] result" (365), and "many [of] types" (376). The reviewers section lacks page numbers, but does not lack errors: ", (," "and [a] bug," and "including[,] reviewing."

The writing quality varies from chapter to chapter, and some passages are awkwardly phrased and confusing, such as "each of these two lines were split on to one line" (page 57). Scattered throughout the book, one will find cases of semicolons used where dashes are called for, commas where semicolons are called for, title case used when inappropriate or missing when appropriate (the book's preface is a veritable minefield), compound adjectives missing hyphens, adjectives incorrectly tied to nouns using hyphens, needed commas missing (Appendix A has some egregious examples), and the term "was" used where the subjunctive "were" is called for — in other words, the usual grammatical flaws found in books written by techies. Fortunately, the material is livened up with a few welcome bits of humor, and not the overreaching kind found in many programming books. Even more admirable is the attention to internationalization, unit testing, and other good practices.

The example code within the text may be intimidating to those new to Drupal, but it really helps demonstrate the concepts discussed in the text. The downloadable source code is helpful for avoiding retyping that code from the text, but needs to be cleaned up. For instance, the code for Chapter 4 is in a directory named "1162_04_All code," which suggests that it contains all three versions, but it does not. The code for Chapter 5 is split between a subdirectory named "old," which contains the newest code, and in another directory, "1162_05," which contains older code. The directory "1162_07_Code" contains no fewer than six different (and possibly differing) copies of its example module. How can the reader know which is the correct copy to use for following the book's discussion? Moreover, for some of the chapters, such as 5, the source code listed and discussed in the book does not fully match that provided in the downloadable archive file.

Overall, this book is a substantial contribution to the Drupal literature, but it is weakened by two obvious problems: Firstly, it lacks a chapter or appendix to explain how the reader could contribute a newly-created module to the Drupal community — specifically, Drupal.org's Modules section. This is a glaring omission, particularly in light of the (laudable) encouragement to the reader to participate in the community, as well as the authors' many contributions to the same. Secondly, because this book is supposedly suitable for Drupal beginners, and given the complexity of Drupal's APIs and their code requirements, the authors should have presented the concepts in more digestible chunks, at a slower pace, so as to be easily comprehended by someone new to Drupal programming using APIs. This is especially true of the second and third chapters.

The aforementioned problems could be corrected in a subsequent edition, which would be well worth the effort: Drupal 7 Module Development is an information-packed and wide-ranging resource for experienced Drupal programmers who want to enhance their existing module-building skills, and transfer them to version 7.

Michael J. Ross is a freelance Web developer and writer.

You can purchase Drupal 7 Module Development from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

theodp writes "Dave Winer was already upset that Amazon Web Services (AWS) pulled the plug on WikiLeaks for posting classified US government documents. So, he wasn't exactly thrilled to receive email three weeks later from an AWS PR flack boasting that 'the US federal government continues to be one of our fastest growing customer segments.' Writes Winer: 'It makes perfect sense that the US government is a big customer of Amazon's web services. It also makes perfect sense that Amazon wouldn't want to do anything to jeopardize that business. There might not have even been a phone call, it might not have been necessary.' Amazon, which wowed the White House with its ability to scale video slideshow site Animoto, was able to get its foot in the Federal door as a Recovery.gov redesign subcontractor."

eldavojohn writes "The third edition of Hello, Android brings the book up to date on Android versions from 1.5 to 2.2 (FroYo). The book is predominantly tied to the Eclipse editing environment with several pages devoted to screen shots of the IDE. As the title suggests, this book aims to give the user the equivalent of a "Hello, world!" application in Android and succeeds in doing that but doesn't take the reader much further. From creating a sudoku application with increasing support to dabbling in OpenGL ES, the book's prime audience are people who know a little Java (with no aversion to Eclipse) and XML but absolutely no Android. You can find the source for all the examples." Keep reading for the rest of eldavojohn's review. Hello, Android: Introducing Google's Mobile Development Platform author Ed Burnette pages 300 publisher The Pragmatic Programmers rating 8/10 reviewer eldavojohn ISBN 978-1934356562 summary An introduction to creating several kinds of basic Android Mobile Applications; a "Hello World" primer for Android. The first aspect of this book that jumps out at me is that it assumes the user is using Eclipse — even late in the book like on page 231, an entire page is a screenshot of the project creation wizard in Eclipse. While this might be helpful for initiates to Eclipse, it seemed like a bit of overkill at times when actions in Ecipse are revisited throughout the brief book. For example that same screenshot with different options checked can be found engulfing page 10. "If you don't want to use Eclipse (there's one in every crowd)" says the author on page 4 before referring the reader to Android's command line reference. It gets to the point that when Burnette is going to sign his app at the end, he uses an Eclipse wizard.

The second aspect of this book that jumped out at me is that Android apps are written by extending Java classes and utilizing a very verbose XML. So between the overridden class methods and the layout meta data in the XML, there is a lot of code consuming vertical space in the book. Ellipses are provided to avoid redundancy in some instances but in others it seems there is no avoiding the space consumption. A strength of the book is that, when possible, it shows how to do something simple in both XML and Java and gives reasoning for picking a certain way the rest of the book.

The chapters are laid out with brief introductions and "Fast-Forwards" at the end of each chapter that try to push the user past this Hello, Android introduction to complex concepts. The book is well divided with part one (chapters 1 and 2) providing instructions for setting up your emulator and the basics of Android like a state transition diagram showing how all Android applications transition through Java methods in a life cycle. Part two (chapters 3 through 6) builds the sudoku application with increasing support. Part three (chapters 7 through 10) focus on more complex aspects of Android like device sensors, SQLite and OpenGL. The fourth and final section delves into the future of multi-touch on Android, writing for all resolutions and devices as well as publishing to the Android Market. Throughout the book the author takes care to to mention when you will need to put in a permissions requirement in the manifest file when utilizing something on the device.

In creating the sudoku application, Burnette does a good job at introducing the reader to some basic concepts like procedural designing versus declarative designing and Dips versus Sps. The author introduces the automatically managed R.java file and the first extension of android.app.Activity with a good explanation of how we're going to add menus from XML strings. This chapter nicely sets up the sudoku game to have an opening screen, a settings menu, a theme and exiting the game. It is lengthy but introduces the reader to click listeners as well as explicit information about how to debug. Android 2.2 adds a cute debug level of Log.wtf() which stands for "What a Terrible Failure."

Following that chapter, the author delves into some basic two dimensional graphical capabilities involving extending View in order to manipulate the canvas object inside onDraw. The chapter sums up drawables and gives a short example of text in a circle before returning to the graphics in our sudoku application. Burnette shows explicitly how to draw the game board and give it a nice embossed effect, how to add and center numbers in each of their cells, how to override key events to bring up an input screen with only valid numbers and how to continuously update the game screen. The chapter even goes as far as showing you how to shade the squares in order to give hints to the user. One thing I did not care for in this chapter (and something that persists through the rest of the book) is that the author has no qualms with calling a method in code (like calculateUsedTiles on page 68) and not defining what it does or how it works until the end of the chapter twenty pages later. Given that its signature is descriptive and it's not key to understanding Android, it's probably the best way to teach but left me doing a lot of page flipping since I like understanding apps from the bottom up. Something else to note about this chapter is that the author mentions on page 70 that he experienced "many false starts" of trying different approaches like multiple ImageView classes in XML before finding the fastest and easiest way of having only one view. There's just a couple paragraphs on this in a side box but I really wish the author had expanded on this as it sounds like a vital part of the learning Android process.

What good is a phone app without some sound? Chapter five covers Android's MediaPlayer which Burnette calls "a fickle beast" although it improves with each release of Android. The chapter also touches on playing video in Android which takes just a few lines of code. The author helps the reader by continually explaining what happens in Android when the device is rotated (in these examples the video restarts since the app is recreated). He explains how to avoid this several different ways. He also discusses why using a background service for music isn't a great idea if you intend the music to end when your program ends. By the end of the chapter, you've got some music for your sudoku app.

The next chapter very briefly covers local data storage. This is not the SQLite chapter but rather the PreferenceActivity API as well as the instance state stored via the Bundle in Android's application stack. The author doesn't spend a lot of time on these and wraps the chapter up with a brief description of accessing the internal file system as well as an external SD card.

The seventh chapter covers the need for a browser capability inside your Android application. At first I thought this would be very rarely used (you've already got a web browser) but the author points out that when you need some ability past basic text views, you might opt instead to provide that file through a lean web browser in Android as opposed to a basic test viewer. The author argues this isn't as crazy as it seems because you don't want to waste your time enhancing a text view with more and more functionality when the web browser can do that already. So you get a wrapper around WebKit that allows you to add another view to your application resulting in a browser. Should this connect to the internet, the author explains how to ask for permission to do so and how to access those pages inside your application. The next part of the chapter is probably going to put a lot of security minded folks on edge and the author makes sure to explain very carefully that allowing JavaScript to call Java can be dangerous. So internal to the WebView class, the author demonstrates JavaScript in the web browser invoking your method in Android (and vice versa). Finally the chapter covers the intricacies of interfacing with web services. What the author did really well in this section was discuss his methods of how he came about adding millisecond delays to accommodate the user. The other great thing that makes this chapter so lengthy is that the author introduces threads both through ExecutorService and Handler.

Chapter eight covers GPS and other sensors your device might have that are supported through the latest Android API. The author takes care to understand how you need to setup your emulator if you are testing this on your computer and discusses listening for updates from sensors as well as interpreting that data. Unsurprisingly, the Android API has a MapActivity class to extend for applications that wish to impose data onto a map. I feel the author could have spent more time on the more novel sensor types that are becoming prevalent in cell phones but the GPS and maps might be adequate for an introductory book.

The ninth chapter is an introduction to SQLite in Android. Android supports other data storage solutions like db4o but the author sticks to SQLite and covers all SQL relational database aspects up to a simple cursor. It's done very well and anyone with a little knowledge of SQL should be able to create, modify and update tables inside Android applications with this chapter. A very interesting thing about this chapter is that it covers how to implement inter-process communication by way of a content provider. Android utilizes URIs that programmers can define to provide a framework for storage. The book is mediocre at describing both SQLite and ContentProviders in this chapter although I felt like the ContentProvider has enough material to deserve its own chapter — even in an introductory book. I personally feel it would be interesting to consider a chapter devoted to defining a content provider with reuse by a community intended. We get an EVENTS and EVENTS_ID example but I feel this falls short of the real beauty of ContentProviders.

The next chapter is a venture into three dimensional graphics in OpenGL ES (embedded systems). Twenty pages isn't a lot of space to work with when you're discussing OpenGL but this is a good basic introduction that leaves the reader with the means to do very basic OpenGL. The chapter starts off with some good fundamentals but also carefully explains that your devices might not have 3D hardware. The API is still there but the lag might be intolerable. The author thanks John Carmack for "single-handedly" saving us from Direct3D and starts off on the very verbose code of OpenGL. In it, there are great explanations on some basic options like ambient, diffuse and specular lighting as well as discussions of fixed versus floating point. Several pages later we have a transparent rotating cube with an Android image for a surface.

Chapter eleven is devoted to the buggiest part of Android: multi-touch. A side note titled "Warning: Multi-bugs Ahead" warns the reader about how problematic the following code is going to be and how it might perform differently on different quality of hardware. As Burnette builds out the image viewing application it's a lot of similar code to view an image with the new stuff revolving around debugging logs to give the reader key insight into how the author's phone interpreted his multi-touch interactions. Dragging and pinching are covered to zoom and move the image in the viewer and seems simple enough with the exception of bugs.

Twelve will show you how to build widgets and implement live wallpapers. To a lot of developers this chapter might be a turn off but to a lot of people looking to make money with Android, this seemed like the fastest route. The example just displays a semi-transparent "Hello World!" string but it is then demonstrated how an overriding the update allows you to put date or whatever else you might need to display. The live wallpaper seemed to me like the perfect way to drain the battery on a phone. Although more complicated than the widget, the chapter covers extending the Engine class to provide a drawing engine that will redraw the background — even with our OpenGL code from a previous chapter that the author then implements. The author really goes the distance on the live wallpaper, even explaining how to extend the surface of your wallpaper so that when you transition to another part of your space it slides the rotating cube. For better or for worse, you too can have a continuous rendering of OpenGL code for your home screen!

Chapter thirteen addresses the "fragmentation" issue that so many people have been criticizing Android for. It discusses declaring and demanding an API version as well as building different emulators out on your computer in order to run your application (although earlier in the book, the author heavily criticized the emulator as being terribly slow compared to the real hardware and I experienced the same thing with my Motorolla DROID). The author does a great job of discussing the unfortunately lengthy and complicated process of preparing your software for all hardware. From subclassing to reflection to delegation/factory, he analyzes each one and explains the strengths and weaknesses. If you're having problems with your application across hardware, this chapter is a great starting point. In the next piece of this chapter, the author calls out the Android API on a bug in the ImageView class that prevents the setImageMatrix from working in some cases (this is from 1.5 and has since been fixed). For those of you who are seriously dependent on Android, the author describes in detail his five steps in discovering and addressing this bug with the final step being a peak at the commit comments to the source tree. It's good to see an author doing legwork like this and telling the story but it's also a little unnerving to see the bug. Nevertheless, I applaud the author on this frank discussion. The final parts of this chapter are spent addressing screen size (an increasing issue with tablets) and installation by way of the SD card (something that can be auto or preferred).

The final chapter addresses publishing to the Android market and provides some actually really good insight into how one should approach this and how to interact with your user community. I'd like to note a couple things that the author lists as lessons learned. The first I found interesting was "you can make a paid app free, but you can't make a free app paid." What that means is if you publish something as free and then you update the app to move a piece of what was one free functionality to requiring payment, the backlash might destroy your app's user base. The other thing is something I flat out don't agree with: "If possible, I suggest you perform frequent updates, every two weeks or so." He claims it makes users happy and gives them a feeling of support as well as bumping it up to the top of the recently updated apps in the Market. I personally find it annoying and if I have an app that I use infrequently that frequently requests updates, I uninstall it. Case in point for me is TuneWiki Social Media Player. It seemed every other week that app was requiring an update and since I used it seldom, it was promptly uninstalled. I don't know if I'm alone in this sentiment but I found this chapter to be very insightful with the exception to that suggestion.

The appendices of this book were actually fairly interesting. I didn't know what the subset of the current Android app was for the Java Standard Edition 5.0 library. You can find a list of packages that will be unavailable to you like much of javax. The author also gives great pointers like try to avoid the expensive reflection no matter how elegant it might be for you.

This book is well written with only a few minor editing mistakes. It has a lot of illustrations which are often Eclipse screen shots. While some aspects of this book might alienate a few users, it is a great learning tool for its intended audience. I found it to be "okay" for my needs but perhaps was geared a bit more towards a more novice programmer.

You can purchase Hello, Android: Introducing Google's Mobile Development Platform from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RickJWagner writes "20 percent inert ingredients, 80 percent nitro glycerin. That's how I'd describe JBoss AS 5 Performance Tuning from Packt. The first 50 pages are nothing to get excited about. This first chapter and a half describes the author's performance tuning life cycle methodology and introduces us to a handful of open source tools that can assist us in our tuning efforts. The tools section seems especially weak-- there are plenty of screenshots showing the tool's menu screens, something you'd normally pick up in about a minute from the tool's distribution website. Honestly, at this point I was beginning to wonder if this book was going to live up to my expectations. Luckily I pressed on for a few more pages, and hit the rich paydirt that makes up the rest of the book. From that point on, every section yielded valuable tuning advice." Keep reading for the rest of Rick's review. Jboss AS 5 Performance Tuning author Francesco Marchioni pages 312 publisher Packt Publishing rating 8/10 reviewer Rick J Wagner ISBN 184951402X summary A very good book on performance tuning in general and JBoss in particular. The author breaks the environment down into slices: Operating System, Application Server stack components, application code. Starting with the O/S, the book tells us the signs to watch for in various situations (i.e. how to detect and compensate for high or low utilization of the processor, or the disk.) The author explains likely causes for the problem, and what can be done about it.

Java programmers need to understand JVM tuning, and here it is given a whole chapter. This includes a lengthy explanation of how to correctly size your heap, followed by a nicely illustrated section on garbage collection, gc sizing, and choosing the best algorithm for your needs. All well done and very readable.

The book's subject is JBoss AS 5, and it's given a whole chapter, too. Thread pools and Connection pools are explained, as well as proper tuning of prepared statements and logging recommendations. Every programmer knows that logging can really drag performance down, right? Here we learn how to optimize it.

The middle of the book deals with JEE applications and the application server components that enable them. EJBs are given extensive coverage. JMS, a JEE hot-button, is also covered well. (Both JBoss Messaging and the newer HornetMQ are explained.)

The persistence layer is given holistic coverage. Starting with database design recommendations, the author proceeds to indexing, JDBC, connection pooling, and JPA/Hibernate. The Hibernate section is a good example of the kind of detail you'll find-- the author explains caching (first and second level) and the considerations you'll want to make to optimize their usage. Besides tuning the application server parts, there are recommendations for your application code, too. Hopefully you've bought into the recommendation to tune your code all throughout the development life cycle. If not, well, too bad for that one. Ditto for the database design.

One of the things JBoss makes really easy is clustering. Note: I didn't say cluster tuning, I said clustering. To optimize clustering, you'll have to understand all that low-level networky stuff like ethernet flow control and UDP buffer sizing. (I'm guessing this is not something your garden-variety developer thinks about every day, and make specific mention here as a demonstration of the kind of depth you get in this book.) Besides these bottom-layer concerns, the book also covers higher level parts of the stack like JGroups and JCache configuration, replication, and tuning cache storage. Unless you're really, really a bit-head, all that probably sounds a little deep. But the book explains it all in a way that makes it understandable and approachable.

JBoss uses Tomcat for it's web server tasks, so Tomcat is given good coverage as well. Nothing here seems JBoss specific, so most any Tomcat user could benefit from this part of the book. Connector configuration, thread pool sizing, and the Apache Portable Runtime are included. JBoss web server integration with Apache introduces us to mod_jk, mod_proxy, and mod_cluster. As throughout the book, the author uses JMeter to capture metrics to demonstrate to us the kind of performance we might get from each.

The final technical chapter deals with web application frameworks and web services. Web applications seem especially tunable in the development stage, while web services get code construction tips as well as configuration hints. The book ends with one more suggestion to make performance tuning part of your every day life rather than something crammed in after deployment time.

Like many technicians, I respect technical knowledge. This book is crammed full of it, and it's all presented in a readable manner. What's the bottom line? I'd recommend this book to any JBoss user (strongly), any JEE developer (with little reservation, especially Tomcat users), or any Java coder (who has a little extra money to spend.) Anyone else can probably live without this book. But if you're running JBoss (and you're technically minded), spend the money, you'll be glad you did.

You can purchase Jboss AS 5 Performance Tuning from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

rsk writes "The first time I came across fake reviews on Amazon, it was hilarious. Using Amazon's Window Shop app, I came across a great category, 'Peculiar Products,' and was more than happy to look through it. Almost every one of the products I found on the list (Uranium Ore, 1 Gallon of Milk, Parent Child Test, Fresh Whole Rabbit) were fake, with thousands of reviews on them. As a shopper, I wasn't aware of how easy it was to apparently fake product reviews and it bothers me. When I'm shopping, the first (and a lot of times only) place I visit is Amazon to read the reviews if I'm in the market for something. I don't expect the reviews to be the word of God, but I do assume a certain level of legitimacy for most of them. While this won't affect my use of Amazon (especially not at this time of the year) I would like to bubble this up to Amazon's attention so some time is spent on improving the quality of the reviews."

rsk writes "The first time I came across fake reviews on Amazon, it was hilarious. Using Amazon's Window Shop app, I came across a great category, 'Peculiar Products,' and was more than happy to look through it. Almost every one of the products I found on the list (Uranium Ore, 1 Gallon of Milk, Parent Child Test, Fresh Whole Rabbit) were fake, with thousands of reviews on them. As a shopper, I wasn't aware of how easy it was to apparently fake product reviews and it bothers me. When I'm shopping, the first (and a lot of times only) place I visit is Amazon to read the reviews if I'm in the market for something. I don't expect the reviews to be the word of God, but I do assume a certain level of legitimacy for most of them. While this won't affect my use of Amazon (especially not at this time of the year) I would like to bubble this up to Amazon's attention so some time is spent on improving the quality of the reviews."

rsk writes "The first time I came across fake reviews on Amazon, it was hilarious. Using Amazon's Window Shop app, I came across a great category, 'Peculiar Products,' and was more than happy to look through it. Almost every one of the products I found on the list (Uranium Ore, 1 Gallon of Milk, Parent Child Test, Fresh Whole Rabbit) were fake, with thousands of reviews on them. As a shopper, I wasn't aware of how easy it was to apparently fake product reviews and it bothers me. When I'm shopping, the first (and a lot of times only) place I visit is Amazon to read the reviews if I'm in the market for something. I don't expect the reviews to be the word of God, but I do assume a certain level of legitimacy for most of them. While this won't affect my use of Amazon (especially not at this time of the year) I would like to bubble this up to Amazon's attention so some time is spent on improving the quality of the reviews."

rsk writes "The first time I came across fake reviews on Amazon, it was hilarious. Using Amazon's Window Shop app, I came across a great category, 'Peculiar Products,' and was more than happy to look through it. Almost every one of the products I found on the list (Uranium Ore, 1 Gallon of Milk, Parent Child Test, Fresh Whole Rabbit) were fake, with thousands of reviews on them. As a shopper, I wasn't aware of how easy it was to apparently fake product reviews and it bothers me. When I'm shopping, the first (and a lot of times only) place I visit is Amazon to read the reviews if I'm in the market for something. I don't expect the reviews to be the word of God, but I do assume a certain level of legitimacy for most of them. While this won't affect my use of Amazon (especially not at this time of the year) I would like to bubble this up to Amazon's attention so some time is spent on improving the quality of the reviews."

RickJWagner writes "Manning has just released a new Erlang title, called Erlang and OTP in Action. For quite some time now, there's been a definitive guide to Erlang-- Joe Armstrong's excellent book Programming Erlang. Well, it's time to make a little extra room on the bookshelf, because the Erlang book-o-sphere has just shifted. There are now two must-have resources for an Erlang programmer." Keep reading for the rest of Rick's review. Erlang and OTP in Action author Martin Logan, Eric Merritt, Richard Carlsson pages 500 publisher Manning Publications rating 9/10 reviewer Rick J Wagner ISBN 1933988789 summary Teaches you to apply Erlang's message passing model for concurrent programming The book is divided into three sections. The first one deals with the basics of Erlang and details about the OTP application framework. Part two shows how to build a production-worthy application in Erlang. The third part of the book is about integration and tuning.

Section 1 has chapters that cover the following: basics of Erlang and OTP, Erlang language fundamentals, writing a TCP-based RPC server, OTP and the supervisor model, and graphical tools to help your development efforts. Language newbies will spend some time here, as Erlang can be a little odd to programmers coming from non-functional environments. (Concepts like recursion are given great coverage, as it should be.) OTP, the Erlang ubber-framework, is explained in detail as well. Section 1 alone would make a decent book on Erlang, but there is much more here.

Section 2 covers building a production application. The example given is a caching application, designed to increase throughput of a web application. In addition to expected topics like logging and an event-framework, the reader is exposed to Erlang's built-in distributed database, Mnesia. Application packaging and deployment considerations are also covered here.

Chapters in section 2 follow a helpful pattern to guide the reader through building an application. First, there is an introduction to some high level concept. Next, it is shown how this new widget can be used to further the needs of our production-worthy caching application. Finally the authors provide code that brings the desired functionality into the ever growing caching application. Erlang code tends to be somewhat dense-- not much code goes a long way-- so much of the latter part of each chapter is explanatory text explaining why you'd want to implement things in the way the authors did. Chapters in this part of the book read like an in-depth tutorial, and that's not a bad thing.

The third section of the book shows how to integrate with external users via HTTP, how to allow programs written in other languages to communicate with your Erlang code, and how to tune your environment. It's notable that Java gets a whole chapter on integration, through JInterface (in comparison, Joe's book offers about 4 lines on this topic. In fairness, that's a much older book, though.)

Throughout the book, simple illustrations are used to demonstrate key concepts. I found these to be extremely helpful, as Erlang in general is quite different than most programming languages. The delta between Erlang application development and other-language development is an order of magnitude different than something like the difference between Java and Ruby or Python and .Net. It's got different characteristics and different concepts. Given these large differences, I really appreciated the illustrations.

The book covers language built-ins like management tools, profilers, etc. (If you've ever used GNU development tools to profile an application, some of these might look a little familiar). The reader is given a lot to think about, and it's scattered over nearly 400 pages. To make a Java analogy, it's like an all-in-one book that teaches the language, the JDK and tools, JEE, and shows how to integrate your enterprise application with external entities. It's ambitious, but the book does a good job in explaining everything. That's why the impressive page-count helps. A skinnier book probably wouldn't be able to pull all that off.

The book is written with easy-to-understand anecdotes that help the reader grasp the finer points of Erlang craftsmanship. You definitely get the impression the authors have written 'real' code, and they offer strong direction to guide the reader through constructing application code. There is a big difference between understanding language syntax and understanding best practices in application construction. Section 2 in particular is loaded with best practices, and this alone makes this book a worthwhile read for Erlang coders writing production applications.

Probably the best thing I can say about this book is that the authors seem to put the advancement of Erlang above all else. To bolster that statement, I'd point out that they give the reader a list of other Erlang books they may wish to read, and they also include several mentions of Joe Armstrong. (Joe is the author of what has been the most popular Erlang book.) In my opinion, the authors can afford this indulgence, as this book is strong enough to merit inclusion on the Erlang programmer's bookshelf.

So who is this book good for? I'd recommend this book to anyone who wants to program in Erlang. It can get beginners off the ground, and will reveal many best-practices to those who already know their way around Erlang.

You can purchase Erlang and OTP in Action from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

terrywallwork writes "Lance Flavell and Apress have been busy writing another Blender 2.5 based book. Lance Flavell (known as Lancer in the Blender community) is a very knowledgeable Blender user. So I was very interested to find out about this book when Apress announced its availability. So off I went and ordered the Ebook version of the book in PDF format." Read on for the rest of Terry's review. Beginning Blender - Open Source 3D Modeling, Animation, and Game Design author Lance Flavell pages 448 publisher Apress rating 85% reviewer Terry Wallwork ISBN 978-1-4302-3126-4 summary Beginners Guide to Blender 2.5 features and how to use them. This is a book aimed at Blender beginners who are using the Blender 2.5x series. It takes the approach of introducing a subject and then giving examples and exercises for the reader to try and carryout and as a result learn how some of Blenders features work.

The pictures in the Ebook version are full color and apparently the paper book version also has full color pictures, which is useful. The pictures in the PDF version, unfortunately often had compression artifacts making them look very pixelated. Luckily most of the time the quality of the pictures was just good enough to get the point across, it's a shame the pictures were slightly below par but the rest of the content of the book is a much better standard.

Chapter 1 — This chapter deals with explaining what Blender is, how it came about and what makes it special when compared with other software. Instructions on how to obtain and install Blender are gone over, not in massive detail but in enough to be usable. Especially interesting was the good description of what opensource is and why it is so important.

Chapter 2 — Covers various beginner topics on using Blender, from interacting with the user interface in various ways to manipulating the 3D Cursor and explaining how it works and what it is used for. Once the basic interface features have been described the chapter moves on to explaining Blenders different types of primitive shapes and how to use them to construct simple models. A very good explanation of how to manipulate various parts of meshes and the interface using both the keyboard shortcuts and the mouse manipulations is explained. Usefully notes on possible issues with shortcut key conflicts with various different operating system platforms are highlighted, which I think would be extremely useful for a beginning Blender user to be aware of, as this can often be a problem users encounter and it's not often obvious how to fix it or that anything is wrong when it happens. At the end of this chapter the reader is given an exercise to make a simple robot model. I found this a good way to re-enforce committing to memory the subjects described previously in the chapter. Another thing I liked was the way that keyboard shortcut keys were almost always used and described, even some of the less well known shortcuts were mentioned.

Chapter 3 — Covers the fundamental topics of modeling in Blender, covering the differences between Object Mode and Edit Mode. There is a very clear explanation of what mesh topology is and how it impacts on the overall quality of a finally produced model. Simple modifiers such as Blenders Mirror Modifier and Subsurface Modifier are demonstrated and their uses enumerated. I was surprised the Sculpting and the use of Multi-Resolution Modifier was covered at this point in the book, I was expecting it later on, none the less it was well laid out and easy to understand and guided the user to sculpt a simple cat model. Another very useful feature of Blender covered in this chapter was Blenders Retopology feature. A lot of new Blender users and even some not so new users tend to not know about the Retopology feature (or only find out what it is much later) and I found it very useful that it was covered so early on within the texts. Another example of providing information that is often left out of beginners books is the description of how to use proxy objects when linking objects from a file in Blender. How to create proxy objects is often overlooked as a feature that is advanced and therefore not normally covered, this is not a mistake this book makes.

Chapter 4 — Covers the topics of Lighting and Procedural Texturing. It also covers setting up the camera for doing renderings and its various settings that affect render sizes. A topic I found helpful was how to setup the Blender camera to track objects and lights. After camera setup is covered the various lighting techniques and types supported by Blender are described, not in massive detail but more that enough for a beginning Blender user. Although to my mind the description of how Hemi lights worked was a little inaccurate, but not in a way that is likely to affect new Blender users. The important lighting parameter Dist: was explained very well as were the Spot Light parameters and their uses. How to setup simple lighting rigs and simple explanations of lighting theory were explained but don't expect advanced coverage of the theory side of lighting rigs, but there is a enough there to start with. Good explanations of what Key, Fill and Rim lights are and how they can be combined and positioned for effective lighting of a scene within Blender is described.

Ambient Occlusion and Environment Lighting is very briefly covered. I would liked to have seen more information on how to use environment lighting features and how useful it can be, but in a book of this size, space is limited and you get enough information to get you started.

Having covered the basic lighting features the chapter moves on to describing procedural texturing. It does this by taking a Text object and converting it and applying textures to it, in the form of bump maps and color textures. Applying multiple textures to a material is described and demonstrated on the text object. It was easy to follow and showed just how powerful Blender material and texture system can be.

Chapter 5 — Covers texturing using UV Mapping techniques and the steps involved in preparing textures for modification in external applications such as The GIMP. The description of how to use the Uv Image Editor to unwrap mesh objects is clear and useful. Surprisingly Projection Painting is described, as are texture brushes and how to use them. Another highlight of this chapter was the description of the difference between Bump and Normal Mapping, very informative, as often the distinction is not clear. Also very educational was the description of how Normal maps can be made manually. For those that want to use Blenders ability to create Normal Maps automatically this is also covered. I also really appreciated the section on ways to fix common normal map problems when they are baked, lots of people may benefit from this information not just beginners.

Chapter 6 — Covers Curves, Nurbs and MetaBalls. While curve are often documented in Blender books and tutorials, Nurbs and MetaBalls are much less frequently documented. This is a shame as Nurbs and MetaBalls have features that when used in the right situations can be very useful. The description of how MetaBalls and Nurbs work was not the clearest and it took me a couple of re-reads to get to grips with the information, even so still a useful section. Another small problem with this section is that the text refers to fields and parameter names that have been changed in recent version of Blender, so the names the book gave for parameters do not match, which may be slightly confusing to new users. The coverage of 3D Curves, Bevel Objects and Taper Objects were very clear and I think will be very informative for new user, even not so new users. It's a shame this book was not released a month later as it would have been able to cover RotoBeziers addon which allows for keyframed animated curves, but as it was still a very useful chapter.

Chapter 7 — Goes over basic animation and rigging techniques as well as covering the standard terminology and methodology involved in rigging and animation. The explanation of keyframing both what it is and how to do it within Blender were clear and to the point. Time saving features such as auto-keyframing were noted and their use demonstrated. A simple animation is constructed using a monkey model. The uses for the Graph Editor and Dopesheet are documented, here though I do wish more information had been given as to the differences between what the graph editor is used for and what the Dopesheet is used for. The various bone types and weighting methods are described and each is demonstrated in various ways. Though strangely Blender Auto/Heat Weighting method did not appear to be described, I could have just missed it but if not I do find that very strange.

Chapter 8 — Carries on where things left off in Chapter 7, but this time covering more advanced rigging topics such as what FK and IK is, what Control Bones and Bone Layers are and how and why they are used and the differences between them. A demonstration of how to rig a finger and a leg are gone over as are custom bone shapes. Slightly more exotic features such as Pole Targets are used and a good description of why they are useful is also done. Various ways to create both simple and more advanced foot rig designs were gone over. Once the rigging explanations were completed the chapter moves on to the subject of animation and a basic animated walk cycle is created. The section on shapekeys is very useful as shapekey are often a feature that can be difficult to get to grips with. They are used to demonstrate how to do lip syncing on a speaking character. Overall this chapter was better than most other beginners books in showing some of Blender more useful features, very good chapter.

Chapter 9 — Covers how to use Blender in your Movie Making pipeline. Once you get to this point in your Blender education it becomes useful to use the Video Sequence Editor and Compositing Nodes. So this chapter covers the use of the Video Sequence Editor and Node Compositor to make and do the post processing tasks needed to make movies in Blender. How to use Depth Of Field is covered. The various different methods of Greenscreen usage and filtering is gone over, then it is shown how to composite live action footage and CG together and various Video Sequence Editor filters are demonstrated also.

Chapter 10 — Demonstrates how to use Blender Physics, Particle and Hair features. It's a fast moving chapter and quickly goes over each feature very quickly, but generally in enough detail to be useful as a jumping off point to further study. The features are demonstrated by making a simple exploding rocket that animates a model and particle systems. After the particle settings are described the chapter moves on to describing how hair particles work, and a simple wig is constructed using them. Lastly fluid and smoke simulations are covered, again only very briefly but with enough information to be useful.

Chapter 11 — Covers using the game engine to make simple games. Done mainly using Blender Logic Bricks to construct a couple of simple interactive games. The games that result are very good examples of what can be done with the Blender Game Engine. This is a very brief chapter but game creation is very complex and not a lot can be covered in such a short amount of space. But as a taster of what's possible with the Blender Game Engine it's useful to get you started with game creation in Blender.

Chapter 12 — This final chapter connects up various lose ends topics such as where to get further information on Blenders various features and also has an FAQ section answering and fixing the most common problems encountered by new Blender users. The FAQ section to me seemed very useful as the questions answered were definitely the ones that I encountered when I first started using Blender so I would assume they will be useful to other readers.

So on balance this is an excellent book for a Blender beginner, it even had me re-remembering things I had forgotten. This book is a combination of detailed enough to give a Blender user most of the salient information needed to use Blender effectively, and not to difficult as to make it confusing or overwhelming. Personally I think this is currently the best general purpose beginners book to basic Blender 2.5 features so far. Other lesser books would try to cut down on the number of topics covered and probably make a much smaller book but I think this book benefits from the larger amount of pages. It's not a perfect book it does have its problems, such as having badly displayed pictures in places and sometimes not being quite clear enough with explanations of certain sections of the book.

If you're a Blender beginner or an experienced Blender user that is new to 2.5 or a bit rusty, this book will be well worth the money. I really hope Mr Flavell does another Blender book, given the quality of this one.

You can purchase Beginning Blender - Open Source 3D Modeling, Animation, and Game Design from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

An anonymous reader writes "Last month, e-commerce marketplace Amazon.com launched a relatively unnoticed new feature that brings content from Wikipedia pages to its own servers in a shadowy new project that appears to be called 'Shopping Enabled Wikipedia Pages.' Hosted on the Amazon.com domain, they replicate Wikipedia's content but have added links to where a book can be purchased on Amazon. Amazon representative Anya Waring told CNET when asked via e-mail, 'As of November, we have rolled out in the books category, however [it] will be expanding to new categories in 2011.' If Average Joe scrapes Wikipedia and adds affiliate links to it, Google will remove and punish the domains with duplicate pages."

An anonymous reader writes "Netcraft posted two reports on the movement of the WikiLeaks website today. First the site was taken down by EveryDNS, who terminated the DNS provision for wikileaks.org. A few hours later, WikiLeaks moved to a Swiss domain (wikileaks.ch). Netcraft suggests this move could be because the wikileaks.org domain was registered with a US company, which could be influenced by the US government. The new wikileaks.ch site is hosted in Sweden, but redirects all of its traffic to France. Strangely, WikiLeaks has chosen to use EveryDNS again for their new domain." This follows Amazon's removal of WikiLeaks from their cloud hosting, which has the EFF and others worrying about free speech on the net as various hosting providers receive political pressure to censor certain content. Amazon claims their decision wasn't influenced by a government inquiry, while Tableau Software freely admits that a public request from Senator Joe Lieberman prompted them to take down WikiLeaks data visualizations.

melbenson writes "Moodle 1.9 Extension Development by Jonathon Moore and Michael Churchward, published by Packt Publishing, definitely delivers what it says on the book cover — 'Customize and extend Moodle by using its robust plugin systems.' This book, intended for users with a solid knowledge of the Moodle software and Moodle technologies, does a great job of opening the doors to creative and useful ideas to take your Moodle site to the next level. The book takes the reader through many examples of customizing and editing the Moodle code in an easy to understand, user-friendly way but also presents the reader with challenging and advanced concepts." Read on for the rest of melbenson's review. Moodle 1.9 Extension Development author Jonathan Moore, Michael Churchward pages 320 publisher Packt Publishing rating 9/10 reviewer melbenson ISBN 1847194249 summary Shows you how to build all sorts of Moodle plug-ins: admin plug-ins, Blocks, Activities, Grading components, Reports, Fliters that change the way your site works and looks. I've been working with the free open-source software, Moodle, for the past 3 years as an admin in a school district and consulting, which includes experience with Moodle themes, the Moodle database, admin tasks, user technology support and the end-user interface and functionality. I also have knowledge in CSS, web development and a basic understanding of PHP and server topics. I work with Moodle, read several Moodle-related books, attend Moodle user groups and participate in the online Moodle community but amuch of the information covered and talked about is the basic tech support and technology integration (which is great!) but I've been craving to learn more of the 'geeky"' code topics in Moodle. When I saw the title of the book I was expecting material on coding, development and more technical topics compared to the other Moodle books and that is exactly what I got.

In the beginning of the book the author goes over basic, but powerful tasks like creating and modifying blocks and activities. Later on, the book discusses more advanced topics like integrating Moodle with other systems, pagelib and formslib and web services.

The 'Customize and extend Moodle by using its robust plugin systems' phrase from the book cover describes this book very well. It discussed and showed just how much you can customize your Moodle site to fit your needs and create integrations between other systems. this book covers everything from simply creating a block to integrating the Moodle system with other systems and implementing Single Sign On (SSO). The full table of contents can be seen on the Packt Publishing website. The book involved heavy discussion about PHP, which was expected since Moodle is written in PHP and the book was basically all about editing the code. I'm a newbie with PHP so some of the examples were over my head but I know I will be able to go back and reference things I didn't fully understand the first time.

After reading this book I think this book is for any programmers, database and web development people and tech savvy Moodle admins, which is what I was expecting and the reason why I was so excited to read it. I don't think this book is intended for newbies to Moodle or Moodle technologies (PHP, MySQL, CSS/HTML) however, like myself, you don't have to be an expert in all of those subjects. I would say this book is for intermediate to advanced Moodle users and programmers.

I trust that the technical information given in this book is accurate as I have read several other books from the Packt Publishing company. The author also does a good job of informing the reader of the date of publication and alerts the reader of possible changes in future versions. Although the topics in the book were technical, the author does a good job of using language that was easy to read and follow along with. The only hardware that readers will need to follow along is a computer using any type of operating system. To follow along with the examples readers will also need an installation of Moodle, which is an open-source free software. Readers can install the free software locally on their computer or install it on a hosting service.

Throughout the entire book there were real-life examples and screenshot images. The only issue with the screenshots was that they were not in color which I think could have enhanced the experience of following along. To go along with the examples there was sample code presented in the book and the full source code is available for download. The example code for download will be great for future reference and it will be useful when I go through the examples again and try to do the tasks myself and experiment on my own.

The book covered and accomplished pretty much what I had expected. I can't think of anything that I thought the book was missing, besides going into more detail about the specific topics I was personally interested in. One reason I was so excited to begin reading this book is because I've read about a half dozen Moodle books and this one, I felt, was going to contain by far the most 'technical' and 'back-end' related material compared to all of the others. I have no knowledge of any other Moodle books that are similar in subject to this one, although I have a feeling that more books like this one will be coming.

Overall, I very much enjoyed reading this book and it is personally, my favorite Moodle-related book. Not because I thought it was better written, better quality or contained the most information but because it covered exactly what I was hoping it would. I personally think the best parts about this book were the coding and advanced technical topics covered, the real life examples covered and the provided full source code for download for future experimentation and reference.

You can purchase Moodle 1.9 Extension Development from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RickJWagner writes "Every once in a while a technical book comes out that so exhaustively covers a topic that it becomes the definitive word on the topic. These books are the end-all reference, the final authority, the singular go-to reference that every practitioner falls back to in their hour of need. This book review covers one such book, the newly released Spring Dynamic Modules in Action from Manning." Read below for the rest of Rick's review. Spring Dynamic Modules In Action author Arnaud Cogoluegnes, Thierry Templier, Andy Piper pages 548 publisher Manning Publications rating 9/10 reviewer Rick J Wagner ISBN 1935182307 summary Presents the fundamental concepts of OSGi-based apps and maps them to the familiar ideas of the Spring framework. First, a quick word about OSGi. OSGi is a specification meant to make Java more "modular." In practice, this means it is an attempt to solve the age-old problem of "jar hell", including all the class loading issues that go with it. (Users of JEE application servers know what I'm talking about here.) OSGi lets you specify every external library your component needs, to the version. So if you need FooLib v1.2.3, and the application beside yours needs FooLib v10.9.8, that's not a problem at all-- both applications can happily run in the same OSGi container, at the same time.

Should you care about OSGi? The answer is maybe. It's without question a big deal to the makers of Java application containers-- everybody from JBoss to Mule has an opinion on OSGi, and many vendors are busy baking it into their infrastructure. What will differ to you, the user of the container, is how the container developers decided to make OSGi available to their users. This book is about how Spring went about it, and what you need to do to use Spring and OSGi together.

Spring DM (short for "Dynamic Modules") is a framework that enables you to use the popular Spring framework with OSGi. Spring, of course, comes with a multitude of components for solving all kinds of enterprise application needs. So this book is all about using Spring with OSGi.

It's a big book, over 500 pages, written by 3 authors. In those 500 pages you get lots of valuable content:
- An introduction to OSGi and an explanation of its purpose
- Explanation of how Spring can be used within an OSGi container, review of the currently available containers
- Details about how Spring DM works, and the parts you need to understand
- Details about OSGi services, and how they relate to Spring DM
- In depth best practices for data access, enterprise Java projects, and web applications (includes specific advice for popular web application frameworks)
- Testing practices
- Extended uses of OSGi, including likely future direction

A big part of what makes this book valuable are the many pieces of advice from the authors as they explain best practices for using various tools. So you want to use Eclipse, Ant or Maven? No problem, these are all covered. About to use MyFaces, Wicket, or DWR? All covered. Are you a Tomcat user or Jetty? Check and check. I'm sure you get the picture-- if you use these tools, the path ahead of you is already blazed and you can avoid some headaches by leveraging the author's experience.

Make no mistake about it, there will be some headaches ahead of you. Seldom is an application written today that doesn't use an external framework or library of some sort. Using these pre-packaged bits of functionality (and we need to be thankful for them!) might mean 're-packaging', if the library isn't offered as an OSGi bundle. This re-packaging means pealing apart some .jar files and editing the manifest files inside-- yuck! Luckily, this book offers you two things to help you with this task: tooling and advice. Tooling comes in handy because it can automate a lot of the manual, error-prone drudgery that goes along with such a task. Advice is even more valuable-- these authors have already worked done the hard work and have written down what you need to do to make your efforts successful.

So who is this book appropriate for? I'd say anyone who is going to use Spring DM. If you're convinced this is the right framework for your needs, you need a copy of this book. If you're not sure, or if you're just a casual reader wanting to know more about OSGi-- then I'd say you should look through the book first before you buy it. You might like it, or you might not because a lot of the book is all about hands-on use of Spring DM and the little tricks you need to make it work right the first time. But if you're just interested in an overview of the technology, this book might be too detail-oriented and not enough high-level for your tastes.

If you use Spring DM, you need to buy a copy of this book. It's going to be the definitive resource on the topic for a long time.

You can purchase Spring Dynamic Modules In Action from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

witthaus writes "Jeff Stanford's Moodle 1.9 for Second Language Teaching is described in the preface as 'a recipe book' for creating communicative language teaching activities in Moodle. True to its description, the book contains over 500 pages of detailed, descriptive information on how to squeeze every last drop out of Moodle for language teaching purposes." Keep reading for the rest of Gabi's review. Moodle 1.9 for Second Language Teaching author Jeff Stanford pages 420 publisher Packt Publishing rating 9/10 reviewer Gabi Witthaus ISBN 1847196241 summary A descriptive how-to approach with enthusiastic insights into the rich potential of Moodle for creating engaging, useful language learning activities In the first two chapters, the book gives an introduction to Moodle and advice on how to get started with the platform. It then goes on to consider vocabulary, speaking, grammar, reading, writing and listening activities in chapters three to eight. Chapter nine looks at assessment, giving many practical tips on the best and most efficient ways to exploit Moodle's powerful capacity to generate statistics. Chapter 10 gives suggestions on some extended activities you could use Moodle for (requiring more set-up time as well as more of students' time, but with correspondingly greater pay-off in terms of learning). The final chapter deals with formatting and enhancing the visual aspects of Moodle, and enabling stress-free navigation through the platform for your students.

Activity descriptions are framed in terms of language teaching goals rather than technical functionality, making it an easy read for language teachers who are new to online platforms. Detailed, step-by-step instructions are given, along with helpful screenshots, and a star system to differentiate the easier from the more technically advanced activities. A clear distinction is made between what the language teacher could reasonably be expected to do with Moodle and the issues that should be referred to a more experienced Moodle administrator. The book goes beyond basic Moodle features and functions, introducing the reader to many useful add-ons (such as the wonderfully named Nanogong, for incorporating audio files), and other Web tools such as Audacity for creating and editing podcasts, and Hot Potatoes for making quizzes.

The recipes are indeed delicious, ranging from simple rustic dishes – requiring little or no patience for the technical side of things; just a deep love of the classical ingredients needed for communicative language teaching, such as personalization and a focus on meaningful communication – to sophisticated gourmet platters that probably are best avoided by IT novices. There is even a section (in chapter 10 – my favorite) on creating a whole dinner menu by stringing together a sequence of activities in various ways.

My only lament about the book is that I would like to have seen some discussion on the difference between using Moodle to supplement your face-to-face teaching, as opposed to using it for wholly online courses. The most obvious difference is that students probably already know one another in a face-to-face environment, whereas in a purely online environment they come in 'cold', and this can have a significant impact on their confidence and their engagement levels. Some tips and guidelines on how to draw remote learners in, and then keep them engaged, would be really helpful, as would tips on how to find the balance between face-to-face interaction and online work for classroom-based students. But perhaps here I am talking about how to host the dinner party, which goes beyond the scope of a recipe book.

All things considered, Moodle 1.9 for Language Teaching will undoubtedly increase the language teacher's ability to cook up interesting and enjoyable activities for language students. Bon appétit!

Disclosure: The reviewer is a colleague of Jeff Stanford's at the University of Leicester, where they both tutor on the online MA in Applied Linguistics and TESOL.

Gabi Witthaus has over 20 years' experience in EFL teaching and curriculum development. She is currently based at the University of Leicester, where she is involved in e-learning research and tutoring on the MA in TESOL and Applied Linguistics. (). This review was written in her personal capacity.

You can purchase Moodle 1.9 for Second Language Teaching from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RickJWagner writes "Are you a .Net developer? Do you have to persist your application objects to a database? If so, I know of a book you might be interested in, Packt Publishing's NHibernate 3.0 Cookbook. NHibernate is a port of the popular Hibernate object-relational mapper (ORM, for those who like TLAs.) An object-relational mapper is a framework that lets the developer get and retrieve application state from a database, and it does so in an efficient, non-intrusive, and flexible manner. Hibernate is the top of the line ORM implementation, yet it's easy enough to learn that even a newbie will find it easy to get started." Read on for the rest of Rick's review. NHibernate 3.0 Cookbook author Dentler Jason pages 328 publisher Packt Publishing rating 7/10 reviewer RickJWagner ISBN 184951304X summary The ultimate "how-to" reference for NHibernate 3.0 This book is written in Packt's 'Cookbook' style, which means it's really a series of how-to templates that guide the reader through some goal-centric activity. A 'recipe' is a formula for accomplishing something, like setting up a session for a web application, or using a profiler with NHibernate, or creating a validator class. You may not know what some of these things do-- but you will when you read the recipe! Each recipe follows a repeated pattern, with sub-sections "Getting Ready", "How to do it", "How it works", "There's More". At first glance, this can be a little deceptive for readers of technical books-- there's really no lengthy text sections that explain the basics of the tool in the early chapters of the book. You might be lulled into thinking this means there's no explanation for how things work, but that would be wrong! The truth is, there is plenty of good NHibernate theory and explanation, it's just that it's contained within the "How it Works" and "There's More" section of each instructional section, not in a chapter devoted to overview just by itself. For this reason, I'd urge bookshelf browsers to be sure to read one topic through front-to-back thoroughly, to get a feel for how the book presents theory as well as practical hands-on-the-keyboard instruction.

As far as content goes, there is a lot of useful content in this book. The author presents 70 different recipes for activites that range from the basic (i.e. your first class-to-database mappings) to the unusual (i.e. using NHibernate Spatial for solving distance-related problems.) The author offers plenty of good text in most of these, but again-- don't be upset by the placement of the high-level material. It's all there, it's just placed a little differently than what you'd find in most technical books.

The book is easy to read. The text is plain and straight to the point, and the author's writing style is quite readable. The code examples are likewise clean and well-formatted. (By the way, I'd urge you to go to Packt's site to get the source bundle if you buy the book. There's a lot of code referenced, you certainly wouldn't want to type it all by hand if you can get it handed to you.) The book runs a little over 300 pages, and most of the type is generously spaced. This is not a strong theoretical reference, but it is more than adequate as a primer for the vast majority of the tasks you'd want to accomplish with NHibernate.

So who is this book good for? I'd give it high marks for .Net developers who want to use NHibernate, regardless of experience level with the tool. I say that because there are enough use cases presented that there is almost certainly a subset of new material for almost anyone. How about Java Hibernate users? I think it's a decent book for them-- NHibernate is a very close port of the base product, so a Java user can get something out of this book, too. (For that crowd, this would obviously not be a good primary choice, but is worthwhile reading if you already have a Java go-to reference for Hibernate.) For anyone else wanting a good high-level overview of ORM use-- I'd say this book is only of marginal value. This is because the bulk of the explanatory material is presented in the context of 'how to' accomplish some particular task and isn't easily accessible without skipping from recipe to recipe.

By the way, lest you think NHibernate is only for .Net devs, I mostly ran the code samples under MonoDevelop on Ubuntu. This was my first adventure with MonoDevelop (the open source IDE for Mono, which itself is an open source, multi-platform port of .Net.) I was pleasantly surprised by the level of polish in the development environment, it really is a nice environment. Again, if you're a Java developer, I'd consider this book a decent learning supplement but would not recommend it as a primary for Hibernate proper.

You can purchase NHibernate 3.0 Cookbook from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

brothke writes "Security Engineering: A Guide to Building Dependable Distributed Systems by Ross Anderson is arguably the best information security book ever written. Anderson's premise is that security technology needs to take a structured engineering approach to systems design, with detailed requirements and specification from start-up to development and implementation; just as those designing buildings and bridges do. Without a deeply embedded structured approach to security systems design, Anderson argued that we find ourselves in the situation we are in today, with applications and operating systems full of bugs, vulnerabilities and other serious security flaws. As good as Security Engineering is, it was not written to be a detailed information security design guide. That vacuum has been filled by an incredibly important and valuable new bookSecurity Strategy: From Requirements to Reality." Read on for the rest of Ben's review. Security Strategy: From Requirements to Reality author Bill Stackpole and Eric Oksendahl pages 346 publisher Auerbach Publications rating 10/10 reviewer Ben Rothke ISBN 1439827338 summary One of the best information security books of the last few years Security Strategy is one of the first books that shows how to perform a comprehensive information security assessment and design, from section, development and deployment of a security strategy best suited to a specific organization.

The books main focus is on the planning, requirements and execution need to ensure formal and comprehensive information security elements are built into systems, applications and processes.

Authors Bill Stackpole and Eric Oksendahl each have over 25 years in the industry and the book reflects their vast expertise. Oksendahl spent time at Boeing, one of the most security aware organizations, with Stackpole spending a decade at Microsoft. While Microsoft is chided for creating more insecurity than security, it is worth noting that no organization in the world has spent more on training its staff and developers on security than Microsoft.

The books 300 densely written pages are composed of 14 chapters divided into 2 sections. Section one (chapters 1-6) is about strategy, with section two (chapters 7-14) around tactics.

Complete with checklists of the physical security requirements that organizations should consider when evaluating or designing facilities, the book provides the insight needed to enable an organization to achieve the operational efficiencies, cost reductions, and brand enhancements that are possible when an effective security strategy is put into action.

Chapters 1-3 take a high-level overview on how to approach strategy, with its many details. The authors note that strategy is a long-term plan of action designed to achieve a goal that includes what work will be done and by whom. This is not a trivial task, as many organizations simply roll-out a new technology, without defining what its goals are, and who exactly will manage and support this new technology.

Chapter 4 is where the hard work begins, as this chapter details the issues around strategic planning. Noting that strategic security planning is hard work and takes time; many organizations attempt to take an assumed easier path, that of bypassing security details and specifications. That is precisely why information security is in such a sorry state in many firms. These firms would rather buy a security appliance and place it in their data center and hope it works; rather than defining the details and specifications of what the appropriate appliance is in the first place.

Part 2 commences on the topic of tactics, and defines them as procedures or sets of actions used to achieve a specific objective. What this chapter does well, as does the entire book, is that it compels the reader to focus on specifics and objectives.

Chapter 9 gets into the importance of observation, in knowing what is going on within the network. The book notes that observation is both a deterrent and a detector. The chapter goes into detail about how observation works both in the physical world and its corollary use in the network side. The chapter breaks down the various functions needed to ensure that observation is done correctly; as opposed to the common method of simply rolling out an IDS and hoping that it somehow works.

Chapter 11 details the SDL (security development lifecycle). As the chapter notes, an effective SDL can improve application security via the use of a set of development practices designed to reduce or eliminate exploitable vulnerabilities. The issue though is that far too few organizations realize the need for a SDL, let alone take the time to design and deploy it.

Chapter 14 ends on the topic of security awareness training. While the notion of security awareness for many firms is an annual 10-slide PowerPoint; the authors take a pragmatic approach and detail the various parts of what makes for an effective awareness program.

Security Strategy: From Requirements to Reality is an incredibly valuable book that advances the state of information security. For organizations that are looking to get serious about information security, and those that want to go from good to great, the book is an invaluable guide that lays the groundwork on how to develop a first-rate information security infrastructure.

Taking a look at its table of contents shows the many fine points in which the book goes into each particular point, showing how it can be properly designed and deployed for effective security controls.

My only peeve with the book is that it lacked a CD-ROM or web site in which to download the many tables and matrices the book is built on. It is hoped that future editions will have them available.

Security Strategy: From Requirements to Reality is one of the best information security books of the last few years. Those who are serious about information security will ensure this is on their reading list, and that of everyone in their organization tasked with information security.

Ben Rothke is the author of Computer Security: 20 Things Every Employee Should Know.

You can purchase Security Strategy: From Requirements to Reality from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

CWmike writes "Columbia law professor Tim Wu, who coined the term 'net neutrality,' now says that Apple is the company that most endangers the freedom of the Internet. Wu recently published the book The Master Switch: The Rise and Fall of Information Empires, in which he details what he calls 'information empires' such as AT&T, NBC, Facebook, and Google. He told The New York Times, 'It's largely a story of the American affection for information monopolists and the consequences of that fondness.' When asked whether the Internet could similarly be controlled by large companies, he told the Times: 'I know the Internet was designed to resist integration, designed to resist centralized control, and that design defeated firms like AOL and Time Warner. But firms today, like Apple, make it unclear if the Internet is something lasting or just another cycle.' Asked which companies he feared most, Wu replied: 'Right now, I'd have to say Apple.'" Wu has been in the news a bit lately.

terrywallwork writes "A while back I received an email from the people at Packt publishing telling me of a new book they had just put out, and since any email the mentions the possibility of being able to read new Blender books instantly gets my attention, I clicked the link and was presented with a web page detailing a book called Blender 3D 2.49 - Architecture, Buildings and Scenery. This was confusing as I remember having reviewed a book with almost the same title and identical cover picture. So I went to my reviews and checked and sure enough I found a review with the same book cover and almost the same title. So I deleted the email and just put it down to an automated email snafu. Unfortunately I should not have been so quick with the delete button as it turned out to be an updated version of the previous book they put out." Read on to see what Terry thinks of this book. Blender 3D 2.49 - Architecture, Buildings and Scenery author Allan Birto pages 376 publisher Packt Publishing rating 8.5/10 reviewer Terry Wallwork ISBN 1849510482 summary Using Blender 3D 2.49 to create architectural visualizations For those that do not know architectural visualization is the technique of modeling the exterior and interior parts of a building so a potential client can see what it looks like (usually before it is constructed). In the old days before 3D, this would be done using an artists painting/drawing or someone would have constructed a model out of wood or card, now that all this kind of modeling is done on computers, this book covers the processes involved in visualization using Blender 3D 2.49.

This book is written by Allan Brito, who is a very skilled modeler and user of Blender 3D and has written multiple books on using Blender for various tasks. He has a very popular website that covers all aspects of architectural modeling (http://www.blender3darchitect.com). Mr Brito is very skilled at both the topics of Blender and Architectural Visualization.

Knowing all the above how does the updated book do in explaining the process of using Blender 3D to do Architectural Visualization? The short answer is very well given the page count.

The book starts by guiding the user through the basic but most important features of Blender, so as to allow a person that has never used Blender to get their feet. Covering the Blender interface and the basic ways of interacting with objects and meshes in Blender. To further help with this many pictures are used that for the most part are very clear and really help in getting across how to carryout particular tasks.

On a side note about the pictures: Some of you may remember that in the older version of this ebook the pictures were all in color, while in this newer updated version, most of the pictures in the ebook version are in grayscale? This was not intentional and having contacted the people at Packt, they say it's a mistake and are investigating. So they will probably fix that issue soon, then you will be able to re-download the book from Packt. So I am assuming in this review that the correction gets carried out. In any event even with the grayscaled pictures they are still useful and it is still possible to follow along using the pictures, it doesn't get in the way of using the book.

One thing that really stood out in this getting started section was the explanation of the Active Window concept, as I don't often see that described users are normally just left to figure that out, it was good Mr Brito took the time. Chapter 1 through 3 cover most of the basics of using Blender.

At Chapter 4 with the basic Blender tutorial chapters out of the way is when we start to use what we have learned to do Architectural Visualization tasks. Also scattered throughout the book are sections which cover the theories and fundamental concepts of Architectural Visualization. They help in explaining why certain things are done the way they are and how they are different from more traditional ways of doing 3D modeling.

A good amount of text is given over to using Blender to do precision modeling using the 3D grid and various snapping and 3D Cursor techniques. Which is useful for a lot of different Blender tasks not just Architectural Visualizations. Coverage of what layers are used for in Blender and how to use them was also present, a useful section on using layers for backups when doing complicated modeling changes was used in the book to show their usefulness.

Throughout the text different pieces of furniture and building elements are constructed, while introducing the user to different features of Blender at the same time. Various modifiers are explained that are deemed useful for Architectural Visualization, such as the mirror modifier and the array modifier. An informative section of the text goes over the process involved in making rounded corners for building walls using Blenders spin tool. As well as showing you have to construct items yourself, a discussion of when and how to use other peoples models is detailed, and various links to useful sources for models are provided. A nice clear explanation of edge loops and control loops was given helping new users when it comes to using the Subsurf Modifier and constructing object from scratch, even though the book is not really trying to teach you all the modeling fundamentals.

Importing models was covered and here although it gives you just enough information to import a DXF file and modify it for use within Blender, here I think more time should have been taken to describe more of the importing features and the various scripts and techniques used for cleaning and importing the varied import formats that Blender supports. Although hopefully this section of the book should give you enough information to find out the rest of it on your own, it's an important topic and needed more time as lots of things can and do go wrong when importing models from other formats that are not native to Blender.

Once the book has gone over how to create some simple objects it moves on to showing how use materials, textures and UV mapping over the next 3 chapters, giving enough information to do basic materials and texturing work for an Architectural Visualization project, even covering how to use Radiosity in later chapters. Though baking of textures is not covered in any detail. The sections on UV Unwrapping were clear and I think a new Blender user would have had no problems understanding them. UV Unwrapping is often a difficult subject to describe in a book especially describing seams, but the book does it well. There is the odd technical mistake about pinning preventing you from moving UV Unwrapped Nodes but its not a big issue, and it arguable depending on how you read it weather it's wrong at all. Thankfully there are very few problems like that in the book. Another advantage of this updated book is that a lot of the bad grammar and mistakes have been removed and for a book with over 300 pages there are not many typos.

In Chapter 10, Lighting is covered and this is a highlight (no pun) of the book. The descriptions of the different types of lights in Blender and their uses for Architectural Visualization is very detailed, going over both theory and practice on how to use them within Blender. Although its a small thing I thought the description of the Dist: parameter for lighting was one of the best I have read from a Blender book. I found out things even I didn't know about Dist. As a final test of all the things learned in the lighting section a demonstration of how to light a Solarium is used show the uses of various lighting types, which I think would be useful.

The more exotic lighting techniques are covered in chapter 11, those being Radiosity and Ambient Occlusion. Given the Blender 2.4x series doesn't have fully fledged global illumination (yet), the coverage of radiosity is welcome as there will be times where it comes in useful, even if it is being phased out slowly. More useful was the text on Ambient Occlusion and its various uses and options to bring a rendered scene to a new level of realism. The only real criticism I have of this section was that baking was not covered and being able to bake Occlusion is very useful, but other than that a good chapter.

Chapter 12 covers how to use external render Yafaray with Blender to produce globally illuminated scenes. Some of Yafaray's most important options as regards setting up Blender materials to be used in Yafaray are covered, and a good description of the different techniques that Yafaray uses to render a realistic 3D scene are described in some detail. Though obviously in a book this size an in-depth treatment of Yafaray could not be done, but enough information to get you started with Yafaray and Blender is given.

Chapter 13 introduces animation and Blenders Game Engine and shows the reader how to integrate models and scenes into Blender's animation system. The process of creating basic animatics and renderable animations is covered, as is how to take those animations and make them into a playable movie file. Blender IPO curves and NLA editor are covered briefly showing how they are used and how they can modify the timing of animations. Lastly on the animation side of things Blender Game Engine is used to make an interactive animation which allows the user to navigate around a 3D scene using the keyboard, so as to explore a building model. Although coverage of Blender Game Engine was very brief, it gave enough information to allow someone who has never used it to make a walk-through using it. Even though it was a small section it does give Blender a unique feature that other systems don't generally have.

Chapter 14, moves outside of Blender and covers how to use the Gimp application to carry out certain post production tasks such as color balancing and correcting hypothetical errors which could be introduced in to render. While Post Processing in Gimp is very useful and often needed, I do think that attention should have been put on Blender's Node editor as at least for color correcting Blender's Node editor is the more Blender centric way to do things. Still the coverage of GIMP was clear, someone who has little experience with Gimp will have no problem following along.

Chapter 15 is the final chapter and is a new chapter that didn't exist in the older version of this book. It covers some of the changes that will be coming when the Blender 2.5x series is stable and finally released. The chapter does not go into any great detail on using the newer version of Blender other than describing how to reorganize its interface. No attempt is made to actually build anything using it. This is probably just as well because since this part of the book was written the Blender 2.5 series has moved on quiet a bit and a lot of the information written about it would be out of date. Even so it does serve as a heads up on what to expect when the new version of Blender is released.

Overall this has been a good book. It won't make you an expert in any of the areas it covers, but it doesn't try to. It gives you enough information to get tasks done. The previous version of this book was littered with grammatical errors and some repeating sections, thankfully this updated version does not suffer from either of those problems and is a very useful book.

You can purchase Blender 3D 2.49 - Architecture, Buildings and Scenery from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Muad writes "Michael Kerrisk has been the maintainer of the Linux Man Pages collection (man 7) for more than five years now, and it is safe to say that he has contributed to the Linux documentation available in the online manual more than any other author before. For this reason he has been the recipient a few years back of a Linux Foundation fellowship meant to allow him to devote his full time to the furthering this endeavor. His book is entirely focused on the system interface and environment Linux (and, to some extent, any *NIX system) provides to a programmer. My most obvious choice for a comparison of the same caliber is Michael K. Johnson and Eric W. Troan's venerable Linux Application Development, the second edition of which was released in 2004 and is somewhat in need of a refresh, lamentably because it is an awesome book that belongs on any programmer's shelf. While Johnson and Troan have introduced a whole lot of programmers to the pleasure of coding to Linux's APIs, their approach is that of a nicely flowing tutorial, not necessarily complete, but unusually captivating and very suitable to academic use. Michael's book is a different kind of beast: while the older tome selects exquisite material, it is nowhere as complete as his — everything relating to the subject that I could reasonably think of is in the book, in a very thorough and maniacally complete yet enjoyably readable way — I did find one humorous exception, more on that later. Keep reading for the rest of Federico's review. The Linux Programming Interface author Michael Kerrisk pages 1552 publisher No Starch Press rating 8/10 reviewer Federico Lucifredi ISBN 9781593272203 summary The definitive guide to the Linux and UNIX programming interface This book is an unusual, if not altogether unique, entry into the Linux programming library: for one, it is a work of encyclopedic breadth and depth, spanning in great detail concepts usually spread in a multitude of medium-sized books, but by this yardstick the book is actually rather concise, as it is neatly segmented in 64 nearly self-contained chapters that work very nicely as short, deep-dive technical guides. I have collected an extremely complete technical library over the years, and pretty much any book of significance that came out of the Linux and Bell Labs communities is in it — it is about 4 shelves, and it is far from portable. It is very nice to be able to reach out and pick the definitive work on IPC, POSIX threads, or one of several socket programming guides — not least because having read them, I know what and where to pick from them. But for those out there who have not invested so much time, money, and sweat moving so many books around, Kerrisk's work is priceless: any subject be it timers, UNIX signals, memory allocation or the most classical of topics (file I/O) gets its deserved 15-30 page treatment, and you can pick just what you need, in any order.

Weighing in at 1552 pages, this book is second only to Charles Kozierok's mighty TCP/IP Guide in length in the No Starch Press catalog. Anyone who has heard me comment about books knows I usually look askance at anything beyond the 500-page mark, regarding it as something defective in structure that fails the "I have no time to read all that" test. In the case of Kerrisk's work, however, just as in the case of Kozierok's, actually, I am happy to waive my own rule, as these heavyweights in the publisher's catalog are really encyclopedias, and despite my bigger library I will like to keep this single tome within easy reach of my desk to avoid having to fetch the other tomes for quick lookups — yes, I still have lazy programmer blood in my veins.

There is another perspective to this: while writing, I took a break and while wandering around I found myself in Miguel's office (don't tell him ;-), and there spotted a Bell Labs book lying on his shelf that (incredibly) I have never heard of. After a quick visit to AbeBooks to take care of this embarrassing matter, I am back here writing to use this incident as a valuable example: the classic system programming books, albeit timeless in their own way, show their rust when it comes to newer and more esoteric Linux system calls (mmap and inotify are fair examples) and even entire subsystems in some cases — and that's another place where this book shines: it is not only very complete, it is really up to date, a combination I cannot think of a credible alternative to in today's available book offerings.

One more specialized but particularly unique property of this book is that it can be quite helpful in navigating what belongs to what standard, be it POSIX, X/Open, SUS, LSB, FHS, and what not. Perhaps it is not entirely complete in this, but it is more helpful than anything else I have seen released since Donald Lewine's ancient POSIX Programmers Guide (O'Reilly). Standards conformance is a painful topic, but one you inevitably stumble into when writing code meant to compile and run not only on Linux but to cross over to the BSDs or farther yet to other *NIX variants. If you have to deal with that kind of divine punishment, this book, together with the Glibc documentation, is a helpful palliative as it will let you know what is not available on other platforms, and sometimes even what alternatives you may have, for example, on the BSDs.

If you are considering the purchase, head over to Amazon and check out the table of contents, you will be impressed. The Linux Programming Encyclopedia would have been a perfectly adequate title for it in my opinion. In closing, I mentioned that after thinking for a good while I found one thing to be missing in this book: next to the appendixes on tracing, casting the null pointer, parsing command-line options, and building a kernel configuration, a tutorial on writing man pages was sorely and direly missing! Michael, what were you thinking?

Federico Lucifredi is the maintainer of man (1) and a Product Manager for the SUSE Linux Enterprise and openSUSE distributions.

You can purchase The Linux Programming Interface from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

vsedach writes "Remember the 1980s and BASIC, when programming was simple, brains flew through space, and everyone ate lasers? Computer magazines came with code listings, and classics like David Ahl's BASIC Computer Games offered a fun and easy way to get started in computer programming. Conrad Barski remembers, and with Land of Lisp, he's set out to demystify programming in the 21st century." Keep reading for the rest of Vladimir's review. Land of Lisp: Learn to Program in Lisp, One Game at a Time! author Conrad Barski, M.D. pages 504 publisher No Starch Press rating 10 reviewer Vladimir Sedach ISBN 978-1-59327-281-4 summary Learn to Program in Lisp, One Game at a Time! This is no small feat. Modern computers don't come with anything that looks like BASIC. Getting started with a "real" programming language like Java requires installing and learning hundreds of megabytes worth of compiler and integrated development environment. Barski's thesis is that Lisp is a refreshing alternative - it offers BASIC's ease of getting started (get a prompt, type in code, and it works), while providing a combination of modern features unmatched in other programming languages.

The first thing that immediately jumps out about Land of Lisp is that it has a lot of comics. The book is an outgrowth of Conrad's Casting SPELs in Lisp illustrated online tutorial, which originally appeared in 2004 (incidentally, around the same time as why's (poignant) guide to ruby, probably the most famous and epic programming language comic book). The comics are humorous and irreverent - if you're a C programmer, you might be surprised to know that you're a Cro-Magnon fighting the COBOL dinosaur.

Despite the silly humor and Barski's approach of introducing programming completely from scratch, Land of Lisp builds up to cover topics like graph theory, search algorithms, functional and network programming, and domain-specific languages. All throughout, the book emphasizes various techniques for doing I/O. The topics covered will leave the reader with a solid understanding of what modern programming entails and a good basis from which to explore either application or lower-level systems programming.

The most unintentionally impressive aspect of Land of Lisp is that it manages to completely explain web programming. No more hiding behind complicated software stacks and impenetrable web server packages - chapter 13, titled "Let's Create a Web Server!," does exactly what it promises, in only 15 pages. Later chapters introduce HTML and SVG to build a graphical game as a web application. If nothing else, this book will leave the reader with all the necessary basic skills and total confidence in their understanding to build real-world web applications.

Other introductory programming books use Lisp, but none fall into the same category as Land of Lisp. Abelson, Sussman and Sussman's Structure and Interpretation of Computer Programs, arguably the greatest introductory programming book ever written, requires a solid math background to understand the examples. Felleisen et alia's How to Design Programs offers a much deeper introduction to programming than Land of Lisp, but is an academic textbook, and hence lacks funny cartoons and may be boring. Friedman et alia's The Little Schemer is a favorite of many, but doesn't have LoL's real-world applications.

Land of Lisp is an excellent book for someone who wants to learn how to program, for web programmers who want to move up out of their niche and start learning about CS theory and systems programming, and for anyone who is puzzled about what really goes on behind the web and wants to learn what web programming is really about. Experienced programmers who want to jump into using Lisp are probably better off with Peter Seibel's Practical Common Lisp, though.

Watch Conrad's hilarious promotional music video for the book.

You can purchase Land of Lisp: Learn to Program in Lisp, One Game at a Time! from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "If you were to ask some database developers to cite their favorite strategies for expanding the functionality of the relational database management systems with which they work, you would probably hear a variety of answers. One individual might recommend the use of an alternate database engine optimized for the given application. Another might explain the many advantages of using stored procedures to replace SQL queries embedded in the source code of any programs that connect to databases. But one answer you likely would not receive involves changing the internals of the database engine itself. With the latest major release of MySQL, developers using that particular RDBMS are now able to extend the capabilities of the built-in database engines, by creating plug-ins. This is the topic of a book by Sergei Golubchik and Andrew Hutchings: MySQL 5.1 Plugin Development." Read on for the rest of Michael's review. MySQL 5.1 Plugin Development author Sergei Golubchik and Andrew Hutchings pages 288 pages publisher Packt Publishing rating 9/10 reviewer Michael J. Ross ISBN 978-1849510608 summary A practical and example-rich introduction to developing MySQL plug-ins. This title was released by Packt Publishing on 26 August 2010, under the ISBN 978-1849510608. On the publisher's page for the book, visitors will find a detailed description, the table of contents, a sample chapter (the fourth one in the book, "Information Schema Plugins," as a PDF file), and links to purchase the print and/or electronic versions of the book. There is also a link for downloading all of the sample code used in the book, except for the commands found in the first chapter. The sample code is sufficient to demonstrate the complexity of the subject area, and thus it is good that both authors possess a lot of experience in all of the primary technologies discussed in the book — particularly MySQL. In fact, Sergei Golubchik was one of the principal architects of the MySQL Plug-in application programming interface (API). Incidentally, in the "About the Authors" section, we read that he "has continued as a MySQL AB employee since 2000," which makes it sound as though he is still employed there (now Oracle); but then we are told that he resigned to join a startup firm, which is a bit confusing.

The book spans 288 pages, most of which are organized into ten chapters, followed by an appendix and an index. The first chapter explains the details of how to compile, link, and install MySQL User Defined Functions (UDFs), as well as proper MySQL plug-ins. For those people working on Windows platforms, numerous screenshots are provided, showing how to work with Microsoft Visual Studio (which is freely available). Readers learn how to use MySQL command-line utilities for building and packaging plug-ins, and the options needed to do so. The subsequent chapter focuses on UDFs — both normal and aggregate ones — which are technically not part of the MySQL Plugin API, although they may be in the future. However, they can be thought of as precursors to true plug-ins, because they are written in C/C++, loaded dynamically at runtime, and extend the capabilities of the MySQL server — in this case, by being callable from within SQL statements. The authors explicate how to install and utilize UDFs, and provide several examples.

The book's remaining chapters explore different types of plug-ins, starting with the most basic kind of all, Daemon plug-ins, which can run code utilizing a dedicated thread in the mysqld server process. Readers are shown how Daemon plug-ins are structured — including their declarations, types, status variables, and configuration system variables. To demonstrate these components, the authors dissect four separate sample plug-ins, line by line, with a great deal of helpful commentary. The next two chapters, 4 and 5, delve into schema-related plug-ins, starting with those that create tables, and ending with more advanced topics, such as how to access and output information about a server's internal data structures. These two chapters present almost half a dozen examples, as equally detailed as those of the earlier material.

During the past several years, all relational database systems are seeing increased use of full-text parsing, for various purposes. Chapters 6 and 7 show the reader how to create plug-ins that supplement the full-text search capabilities already baked into MySQL. The first sample plug-in presented by the authors could be used by PHP programmers for parsing their scripts, while another sample could be used by developers who need to match user input (which may include typos), using a Soundex algorithm. The final three chapters cover many aspects of storage engines, ranging from a basic read-only engine to a more complex one that supports indexes. The book concludes with an appendix that surveys the primary enhancements to the Plug-in API that database developers may see in versions of MySQL after 5.1.

On the publisher's site, there are no reported errata, but here are some that I found in just the first couple pages, to get the list started: "class [a] to" (page 1), "on [a] MySQL fork" (page 2), and "ask [the] questions" (page 2). Also, countless phrases and sentences in the book are oddly constructed, with multi-word adjectives missing hyphens, commas used where semicolons are called for, and sometimes both mistakes committed in the same sentence, such as the very first sentence of the preface. In fact, the lead author admits that he prefers reading fiction to a dictionary. Regardless, the information and instruction provided by the authors are generally clear to the reader, and ably illustrated with the sample code.

The book and thus the reader benefit greatly from the extensive MySQL experience and knowledge of the authors, reflected in the depth of coverage of the various topics. MySQL 5.1 Plugin Development brings together valuable information that is otherwise tedious to find — scattered throughout the API source code, official documentation, and online forum threads. For any programmer interested in unleashing the full potential of their MySQL servers through the creation and use of plug-ins, this book is an essential resource.

Michael J. Ross is a freelance website developer and writer.

You can purchase MySQL 5.1 Plugin Development from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

brothke writes "CyberForensics: Understanding Information Security Investigations is a new book written by a cast of industry all-stars. The book takes a broad look at cyberforensics with various case studies. Each of the book's 10 chapters takes a different approach to the topic. The book is meant to be a source guide to the core ideas on cyberforensics." Read on for the rest of Ben's review. CyberForensics: Understanding Information Security author Jennifer Bayuk (Editor) pages 167 publisher Humana Press rating 8/10 reviewer Ben Rothke ISBN 978-1607617716 summary New book written by a cast of industry all-stars The book notes that there is a cohesive set of concepts that binds cybersecurity investigators to a shared vision, of which is tries to be a source to. But at 150 pages, while all of the chapters are well-written and enlightening, the book does not have the breadth and depth needed to be a single source of all things cyberforensics.

Jennifer Bayuk is the books editor, who also wrote the introduction. I reviewed two of Bayuk's books on this site, Stepping Through the InfoSec Program and Enterprise Security For the Executive. Bayuk's introduction provides a historical background to the subject and puts things into context. The chapter uses a fantastic visual tool to explain the complete cyberforensic framework.

Chapter 2 is about the Complex World of Corporate CyberForencisc Investigations, and does a good job of detailing the various elements involved in getting various corporate departments integrated during an investigation. IT in an enterprise setting is fraught with challenges. Performing a forensic investigation in enterprise IT is even more challenging. Often these groups have different agendas and react quite different to a forensic event. The author uses the analogy of a puzzle, which can be complex to put together, but is challenging and necessary nonetheless.

Many of the chapters take a broader view of the topic, while others are quite detailed. Perhaps the best chapter in the book is chapter 6 – Analyzing Malicious Software from Lenny Zeltser. The chapter is an outgrowth of Zeltser's SANS Security 569 course on the topic. The chapter use of a case study to detail the behaviors analysis of malicious code provides an excellent synopsis of how to analyze and debug malicious code.

Chapter 7 on Network Packet Forensics from Eddie Schwartz is another exceptional chapter that provides the reader with a walk-through of using various digital forensic input to solve an incident.

Chapter 10 in Cybercrime and Law Enforcement Cooperation is about how to interface with law enforcement during a cyberforensic investigation. This may be the Achilles heel of forensics is that getting external cooperation is difficult at best, and often impossible. A recent example of this is when a friend of mine who had detailed information about the source of the Stuxnet worm. He attempted to share the information with law enforcement without much success. The various organizations were not receptive to it and didn't to take action on his well-researched claims.

The book is written for an experienced practitioner who wants an overview of current trends. This is not a for dummies type of book. Readers are expected to be comfortable with varied topics such as Wireshark packet capture, code analysis, investigations, and more. Those looking for an introduction to cyberforensics should definitely consider another title such as Computer Forensics for Dummies.

A problem with books of collaborations such as this is that they often lack a consistent stream of thought. This book is suffers from that, but to a limited degree. It is impossible for ten different authors wring about the same subject not to have different styles. An example of that is the use of the spelling of both CyberForensics and Cyberforensics in the book.

At 150 pages, the book is a relatively quick initial read, and covers numerous interesting areas.

The only downside to the book is that it has a prohibitive list price of $189.00 A month after its release, that price may be the reason why it has an Amazon Bestsellers Rank of #1,399,835.

While the book has excellent content, its exorbitant price will simply ensure that its sales will be eclipsed by the Pocket Oxford Latin Dictionary, coming in way ahead with an Amazon Bestsellers Rank of 182,392.

Ben Rothke is the author of Computer Security: 20 Things Every Employee Should Know.

You can purchase CyberForensics: Understanding Information Security from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

brothke writes "CyberForensics: Understanding Information Security Investigations is a new book written by a cast of industry all-stars. The book takes a broad look at cyberforensics with various case studies. Each of the book's 10 chapters takes a different approach to the topic. The book is meant to be a source guide to the core ideas on cyberforensics." Read on for the rest of Ben's review. CyberForensics: Understanding Information Security author Jennifer Bayuk (Editor) pages 167 publisher Humana Press rating 8/10 reviewer Ben Rothke ISBN 978-1607617716 summary New book written by a cast of industry all-stars The book notes that there is a cohesive set of concepts that binds cybersecurity investigators to a shared vision, of which is tries to be a source to. But at 150 pages, while all of the chapters are well-written and enlightening, the book does not have the breadth and depth needed to be a single source of all things cyberforensics.

Jennifer Bayuk is the books editor, who also wrote the introduction. I reviewed two of Bayuk's books on this site, Stepping Through the InfoSec Program and Enterprise Security For the Executive. Bayuk's introduction provides a historical background to the subject and puts things into context. The chapter uses a fantastic visual tool to explain the complete cyberforensic framework.

Chapter 2 is about the Complex World of Corporate CyberForencisc Investigations, and does a good job of detailing the various elements involved in getting various corporate departments integrated during an investigation. IT in an enterprise setting is fraught with challenges. Performing a forensic investigation in enterprise IT is even more challenging. Often these groups have different agendas and react quite different to a forensic event. The author uses the analogy of a puzzle, which can be complex to put together, but is challenging and necessary nonetheless.

Many of the chapters take a broader view of the topic, while others are quite detailed. Perhaps the best chapter in the book is chapter 6 – Analyzing Malicious Software from Lenny Zeltser. The chapter is an outgrowth of Zeltser's SANS Security 569 course on the topic. The chapter use of a case study to detail the behaviors analysis of malicious code provides an excellent synopsis of how to analyze and debug malicious code.

Chapter 7 on Network Packet Forensics from Eddie Schwartz is another exceptional chapter that provides the reader with a walk-through of using various digital forensic input to solve an incident.

Chapter 10 in Cybercrime and Law Enforcement Cooperation is about how to interface with law enforcement during a cyberforensic investigation. This may be the Achilles heel of forensics is that getting external cooperation is difficult at best, and often impossible. A recent example of this is when a friend of mine who had detailed information about the source of the Stuxnet worm. He attempted to share the information with law enforcement without much success. The various organizations were not receptive to it and didn't to take action on his well-researched claims.

The book is written for an experienced practitioner who wants an overview of current trends. This is not a for dummies type of book. Readers are expected to be comfortable with varied topics such as Wireshark packet capture, code analysis, investigations, and more. Those looking for an introduction to cyberforensics should definitely consider another title such as Computer Forensics for Dummies.

A problem with books of collaborations such as this is that they often lack a consistent stream of thought. This book is suffers from that, but to a limited degree. It is impossible for ten different authors wring about the same subject not to have different styles. An example of that is the use of the spelling of both CyberForensics and Cyberforensics in the book.

At 150 pages, the book is a relatively quick initial read, and covers numerous interesting areas.

The only downside to the book is that it has a prohibitive list price of $189.00 A month after its release, that price may be the reason why it has an Amazon Bestsellers Rank of #1,399,835.

While the book has excellent content, its exorbitant price will simply ensure that its sales will be eclipsed by the Pocket Oxford Latin Dictionary, coming in way ahead with an Amazon Bestsellers Rank of 182,392.

Ben Rothke is the author of Computer Security: 20 Things Every Employee Should Know.

You can purchase CyberForensics: Understanding Information Security from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

asgard4 writes "OpenGL SuperBible in its fifth edition is almost a complete rewrite. The authors threw out the discussion of old-style, fixed-function programming and replaced it with an introduction to OpenGL that is exclusively focused on using shaders from the very beginning. All the things that got deprecated with the advent of OpenGL 3 got removed, making it a more relevant and up-to-date book than the previous editions. The OpenGL SuperBible still strives to be the 'world's best introduction to OpenGL' according to the authors. Let's see if it can keep that promise." Read on for the rest of Martin's review. OpenGL SuperBible (Fifth Edition) author Richard S. Wright, Jr., Nicholas Haemel, Graham Sellers, Benjamin Lipchak pages 969 publisher Addison-Wesley Publishing http://www.awl.com rating 9/10 reviewer Martin Ecker ISBN 0-32-171261-7 summary : Quite possibly the best introduction to OpenGL 3.3 programming that focuses exclusively on graphics programming using shaders With the removal of the fixed-function pipeline, the OpenGL SuperBible is no longer quite the heavy-weight it used to be. It shrunk from more than 1200 to about 970 pages, which is not necessarily a bad thing. The book starts out with a basic introduction to 3D graphics, coordinate systems, and some basic math concepts, followed by short rundown of the history of OpenGL and a first little example program that renders a triangle. The authors even provide instructions on how to setup the C/C++ projects to build the example on Windows and MacOS. The writing is to the point but still verbose enough to easily follow the text. The authors analyze the example program in detail making it easy for a beginner to follow and understand the code. Overall, I really like the writing style and the flow of the book.

The next few chapters gradually introduce more and more OpenGL API functionality intermixed with new 3D graphics concepts, such as rendering points, lines, and polygons in various ways, alpha blending, how to use geometric transformations and projections, and how to move objects and the camera. Eventually, basic texture mapping is introduced with most of the basic things you need to know about the topic. In particular, specifying textures coordinates, sampling textures in the fragment shader, the various filtering modes (even anisotropic filtering), and texture compression are discussed. In a later chapter the authors do another deep dive into the topic of textures, in particular rectangle textures, cube maps, multitexturing, point sprites, and using texture arrays

Until this point the authors used haven't really talked much about shader programming yet. Most of the examples use simple pre-made shaders that don't really do much. This changes with chapter six titled "Nonstock Shaders" where we get a first glimpse of how to write our own shaders in GLSL, the OpenGL Shading Language. In particular, a fragment shader that uses a simple lighting model to light objects is developed.

After these introductory chapters presenting the basics of OpenGL programming, the next part of the book focuses on more advanced topics, beginning with buffer objects and how to use them to make your OpenGL programs run much more efficiently on modern hardware. Some of the examples presented in this part of the book include using render-to-texture to do reflections, tone mapping, and bloom. This part of the book closes with two fairly long chapters on advanced usage of the shader pipeline, in particular the transform feedback and the geometry shader stages. There is also some discussion on more advanced effects achievable with fragment shaders, in particular applying filters to images, such as a Gaussian blur or a Sobel filter. Finally, rendering geometry efficiently with vertex buffer objects and rendering many objects via geometry instancing is presented.

The final part of the book consists of 4 chapters explaining how to integrate OpenGL with the underlying operating system, in particular with Windows, Mac OS X, and Linux plus various other Unix flavors. The last chapter of this part of the book is about OpenGL ES, which is a version of OpenGL designed to be used especially on embedded system devices, in particular mobile phones and PDAs, to render real-time, interactive 3D graphics.

The book has a lot of images and diagrams throughout, though unfortunately not all of them are in color. There are however 24 color plates of the most interesting images in the middle of the book. The complete source code of the book, and even precompiled binaries for Windows and Mac OS X, can be downloaded from the book's webpage.

If you are new to both 3D graphics programming and OpenGL with a bit of C/C++ programming experience and you are eager to learn how to develop interactive programs with OpenGL, then this book is exactly right for you. The book is written in an easy to understand style without skimming the details (or even more advanced topics). It is the most comprehensive introduction to OpenGL that doesn't require a lot of previous knowledge I have seen to date. The decision to completely drop any discussion of the fixed-function pipeline turned out to be an excellent choice. Finally there is a book that no longer wastes the reader's time with the parts of OpenGL that nobody who does serious graphics development uses and instead presents up-to-date information on how to do 3D graphics on modern graphics hardware.

All in all, the OpenGL SuperBible in its fifth edition succeeds very well in keeping its promise to be the best introduction to OpenGL and 3D graphics programming. Even after you're done working your way through the main parts of the book you will always come back to the handy OpenGL API reference in the appendix of the book.

The review author has been involved in real-time graphics programming for more than 10 years and works as a professional game developer for High Moon Studios in sunny California.

You can purchase OpenGL SuperBible (Fifth Edition) from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Trevor James writes "Drupal 7 is currently at beta 1 stage with 11 critical issues remaining to be fixed before an official release version. The question arises whether we should all be writing about Drupal 7 now and so soon, when it's still in its beta phase. I argue we should be writing about it. It can only help introduce new users to the Drupal application and the Drupal community and get new people involved to help test Drupal 7. This will ultimately help improve the software for its official release and on. This helps to build the Drupal community of users and developers. It helps spread the word to everyone about this flexible and robust content management system. We want Drupal to be used. So this is one way of getting it out there and in the public sphere." Read on for the rest of Trevor's review. Drupal 7 author David Mercer pages 416 publisher Packt Publishing rating 9/10 reviewer Trevor James ISBN 1849512868 summary A pragmatic look at the steps necessary to get a website up and running using Drupal 7 Some nuances: most developers and Drupal users adhere to the rule that if you plan to run Drupal 7 as a production site and on a production server right now you need to be aware that there may still be bugs in core Drupal 7 that will cause issues on your site. But this doesn't mean you can't use Drupal 7. You can certainly download the beta 1 release and install it on your development or localhost server and use it. And you can improve it by using it now.

Which brings me to David Mercer's new book Drupal 7. This is the second edition of Mercer's popular Drupal 6 book, and here Mercer has had an early opportunity to update his text for Drupal 7. It's a good and important book to help promote Drupal 7 and spread the word about the Drupal project and the Drupal community to both experienced and new users. Mercer knows Drupal - remember that he's already proven himself with the Drupal (back to version 4.x and 5.x) and Drupal 6 titles previously published by Packt. The original edition of Drupal was published in 2006 so Mercer has been devoted to this subject for over 4 years.

The Drupal 7 title is good for Drupal beginners and novices who are just starting out with Drupal but it also has a wealth of information and resources for more intermediate and advanced Drupal users and developers. It gives you the full run down of Drupal core as well as details of many advanced Drupal topics including an entire chapter on the Views module. The book starts with a solid introduction to the Drupal 7 framework and community and shows detailed install instructions using the XAMPP installer. Mercer highlights the new installation profile functionality that ships with Drupal 7 (both a standard and minimal install profile) and even gives you tips on troubleshooting your install if something goes awry.

Chapter 2 outlines the details of Drupal architecture and structure including installing modules, enabling blocks and setting up menus. The highlight in this chapter are two new features in Drupal 7 that allow you to install contributed modules directly from their FTP URL/path on drupal.org; or by uploading the tar.gz archive directly via the Drupal administration interface. For anyone maintaining Drupal sites this will should be a well received enhancement.

Chapter 3 covers Drupal 7 site configuration and reporting mechanisms including setting up actions and triggers; creating shortcuts; managing the file system; configuring site performance; setting up site RSS feeds; and viewing site reports. One highlight in this chapter is the new shortcut functionality that allows you as a Drupal site admin to create sets of shortcut links for your fellow content editors and site admins. Another new feature in Drupal 7 is the ability to upload your attached files (images, PDF, doc, etc) to private folders on your site. In Drupal 6 you could restrict access to all uploaded files but not to specific files by content type (without having to install contributed modules to extend this functionality). In Drupal 7 you now have the ability to restrict access at the file field level per content type. So specific files attached via a content type can be uploaded to a private folder.

Chapter 4 explores Drupal 7 access control with a detailed walk-through of Drupal roles, permissions and user access. Mercer also includes a tutorial on using the OpenID Web service to provide single sign-on login functionality for your Drupal site.

Chapter 5 looks at setting up content workflows on your Drupal 7 site and describes all the Drupal core content types (Article, Basic page, Blog entry, Book page, Forum topic and Poll). Mercer covers content related modules including Aggregator and Book so anyone interested in setting up Web service based aggregated feeds; and multi-layer paginated content will get a lot out of this chapter. Chapter 6 deals with advanced content outlining the process of creating your own custom content types and adding custom fields; and integrating taxonomy with your content types.

Chapter 7 looks at integrating multimedia with your Drupal 7 site including images, and other types of embedded media. Drupal 7 now ships with the Image field in core so all you have to do is add an Image field to your content type. The image field now supports rotation and desaturate effects so besides scaling an image you can now rotate your images by a specific number of degrees.

Mercer includes an entire chapter on integrating the Views module with Drupal 7. The Views section even goes into detail on setting up advanced Views using arguments and relationships and shows you how to theme your Views. This is a real bonus for an introductory level book on Drupal. Anyone using the Views module even with Drupal 6 will benefit from reading this chapter.

Chapter 9 deals with Drupal theming both from the theme layer and the CSS perspectives. There is a lot of detailed information on theming using the Zen starter theme so anyone using Zen will learn some best practice theming solutions from this chapter. Chapter 10 introduces methods of integrating and using the Panels module with Drupal 7 as well as discussions of advanced theming techniques.

In general the title covers the Drupal 7 interface in much detail and points out the many new features of Drupal 7's administrative interface including the overlay admin screens; the simplified and re-named core content types including Article and Basic Page; the built-in CCK module (now part of core Drupal); the enhanced ability to install modules directly via the admin interface; and a look at the new core Drupal themes. Mercer covers best practices for deploying Drupal sites from staging locations to a production server; backup processes, and even a discussion of SEO best practice. The book even comes with quiz questions and exercises provided via the author's Web site. So you can use this title as a model for teaching Drupal 7 (and I would argue even Drupal 6) to new users. Short story - the book is loaded with good information and practical hands-on exercises.

Here's the main reason I'll recommend purchasing this book or at least knowing about it. Those 11 critical issues in Drupal 7 need to be tested, reproduced and fixed before we can use D7 on a production site and feel comfortable about with it's stability and security. We as users and developers need to help with this testing process. We can help to fix those issues by testing and reporting our findings back. This book will help us to do that by showing us how to install D7 and get rolling with it. For that I'm thankful it's been released now as opposed to 3 months from now. This is a good manual for us to use to test and bugfix this next great version of Drupal.

You know it's also just a great book and manual on using Drupal period — even the 6.x version of Drupal. You'll learn a ton about the Drupal framework from this title regardless of the version you're currently using to power your Web site.

Finally, the benefits of releasing this title now is that it will encourage both the Drupal community project and other Drupal authors to write more detailed documentation and instruction on how to use and develop with Drupal 7. We can raise Drupal 7 to a higher level by supporting its release with excellent documentation, tutorials and books.

Let's get Drupaling and help the community now by downloading Drupal 7.

Trevor James is a Drupal developer based in Maryland, USA.

You can purchase Drupal 7 from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

David Taiaroa writes "I was pleased to recieve a review copy of Joomla! Social Networking with JomSocial – Enhance your social networking with JomSocial by Beatrice A. Boateng and Kwasi Boateng. I've worked with many Joomla! extensions, but not with any of the social network options, so I was able to approach this book as someone learning about the topic for the first time." Keep reading for the rest of David's review Joomla! Social Networking with JomSocial author Beatrice A. Boateng, Kwasi Boateng pages 184 publisher Packt Publishing rating 9/10 reviewer David Taiaroa ISBN 1847199569 summary Provides step-by-step instructions for building your social networking system using the Joomla! content management system. The book is a well rounded and practical look at how to create a social network website using Joomla! and the JoomSocial extension, covering everything from installing Joomla! itself, to installing and configuring JoomSocial and other complementary extensions, some discussion of what makes a social networking site successful, and even an introduction to customizing Joomla! templates.

The book starts with thorough instructions on how to install XAMPP on a local computer, then Joomla! itself. I thought these detailed instructions on creating a development environment on a local computer were well done, and could easily be followed by someone new to Joomla!

Installing the JoomSocial component follows the same procedure as for any other Joomla! extension. The real work begins configuring the component and it's many plugins and modules. I think even experienced Joomla! professionals will find time saving suggestions in this section of the book. JoomSocial is a complex component, and without a good road map of where you are going and an overview of how everything fits together, you could have a lot of trial and error. This was one area of the book in particular which I think will be of interest to experienced and novice Joomla! users alike.

Clear instructions are given on how to migrate this draft site from our local development computer to an online server using Akeeba Backup. This is one of many examples in the book where novice users will learn not just about JoomSocial itself, but additional good Joomla! practices that they can take with them to other Joomla! projects. I think this will be an added bonus for many readers.

Once the site has been installed and is active on a remote web server, we can check that the process of adding user accounts and editing profiles within JoomSocial is working correctly.

A social network site needs users to be successful, and the book discusses some of the broader details a site administrator will have to think about – is the interface easy to use, how do users invite others to join, how do you encourage users to make connections within the network, and how will users add content to the site? Obviously important details if the site is to grow.

As part of the chapter on how to encourage users to submit content, the book covers in detail the task of installing SOBI2 and some of its associated modules. SOBI2 is a third party Joomla! component that allows for the creation of directory and review systems for Joomla! sites. I thought this section was another nice bonus in the book, since it gives good information on how to install and configure a component which has applications in many Joomla! websites.

Customizing a Joomla! template isn't a topic I was expecting to find covered, and I thought it was interesting that the authors decided to include this. Throughout the book, the authors use a GPL template from RocketTheme. In latter sections of the book they touch on how to customize this template, with the intention of modifying the template design, and improving the interface for site users. Some of this may be outside the comfort zone of novice readers, and the book doesn't pretend to offer a full guidelines on how to create or customize Joomla! Templates. But for anyone who has had some exposure to HTML and PHP, this introduction to templates, how they work, and how to change them will be enough to get them off to a good start.

No book about social networks would be complete without a mention of Facebook and Twitter. JoomSocial lets users integrate these other networks into their profiles. It's a relatively easy process and the necessary steps are clearly described.

The final chapter of the book discusses some of the other social networking extensions for Joomla!, especially Community Builder. All extensions have their strengths, and so I liked that the authors gave a brief overview of the other options available, how to install them, and how they compare to JoomSocial. Developing a social networking website is a large undertaking, and you want to be confident at the start that you've chosen the right software package, and that your site will come together at the end the way you picture it at the start.

Overall, what I enjoyed most about this book is that it looks at the big picture of what's involved in making a successful social networking website with JoomSocial and Joomla! Installing and configuring the component, its extensions and plugins is one thing. The book reminds us that to be successful, the website administrator also needs to think about the site design, its interface, and how users will will use, contribute and share the content on the site. Along the way, the book also discusses many 3rd party Joomla! extensions and good practice techniques which I think a lot readers will find valuable. The text gives thorough step by step instructions with screenshots throughout, and almost any reader will save time configuring the multitude of settings within JoomSocial by following the suggestions.

David Taiaroa is an experienced Joomla! and website designer with Panchroma Website Development.

You can purchase Joomla! Social Networking with JomSocial from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RickJWagner writes "Drools (sometimes called 'JBoss Rules') is a Business Rules Engine and supporting ecosystem. Drools, like other BREs, promises to lower the barriers to entry for application programming. Armed with this book, can a Business Analyst be used to write application logic? I don't believe so, and I'll tell you why." Keep reading for the rest of RickJWagner's review. Drools JBoss Rules 5.0 Developer's Guide author Michal Bali pages 320 publisher Packt Publishing rating 7/10 reviewer RickJWagner ISBN 1847195644 summary Guides you through all of the features of Drools, such as dynamic rules, the event model, and Rete implementation with high performance indexing. Business Rules Engines, especially those based on the Rete algorithm, strongly favor rules written in 'if/then' format. (Sometimes the marketers will call this 'when/then' logic.) The basic premise is that you write your rules as a series of rules that individually specify matching logic for some objects you make available to the engine, then you specify what to do if any of the objects match your conditions. Example "IF there is a customer with age > 60, THEN allow senior discount". That's the marketing promise, anyway.

This book does a great job of showing you how to build a banking application, complete with validation, data transformation, and reporting functions. Each of these are implemented using Drools, of course, and workable code is provided at every step. The author takes care to explain nearly every line of code provided and highlights important classes and features as they occur. I think the author did well here.

Writing business rules is quite a bit different than writing logic in a language like Java or C++. I'd compare it more directly to writing SQL-- you're declaratively specifying which objects (out of a group) you want something to happen to, so you're thinking in terms of matching logic rather than ordered steps in an algorithm. You also don't always have complete control over the order in which your rules are fired, so it's not like garden-variety coding where it can be treated like a 5-step recipe. It just takes a different mindset. Once you're used to it, things are easier to understand, and this book can help. (By the way, I've fooled around with BREs for about a decade now, and support a production application that uses Drools, so I'd consider myself moderately skilled in BRE usage.)

In the course of writing the banking application the book is anchored upon, the author occasionally makes design decisions that are specific to doing things "The Rule Engine Way". One example is the use of 'global' facilities for validation reporting. The author might have chosen to implement this another way, but chose what he considered the best path and briefly explained his reasoning in making the choice. That's exactly the kind of thing that I think a BRE-literate reader would find of value-- expert insights into how to use this tool, not mere explanations of syntax, etc. Unfortunately, these insights were relatively few in nature and not highlighted where they were presented, so they might not be apparent to readers that aren't already thinking in the BRE way.

One thing the book glossed over that I wish was given more coverage is Guvnor, the Drools Business Rule Management System. Basically, a BRMS is a web application used to change existing rules, write new rules (provided they have been pre-templated by a rule author, usually), and version the rules. I'm told this is one of the key differentiators between Drools and commercial offerings like IBM's JRules, so it's a little disappointing that it was given virtually no coverage in this book.

As the author fleshes out the banking application, we encounter a little scope bleed as the reader is introduced to iBatis, Spring and Tomcat. While I see how these are necessary for the provided application, I viewed them as distractions and potentially barriers to successful implementation for some readers. To counter that, I offer the author kudos for covering a multitude of Drools facets like Domain Specific Language inclusion, Complex Event Processing, and rule ordering through "Drools Flow". All these are valuable tools in the Drools user's toolbox and they are given adequate coverage.

As I hinted at in the opening paragraph, marketers of BREs love to show demonstrations where rules are written in shocking clear 'if/then' syntax. These rules are purported to control powerful application logic and can be maintained by low-cost business analysts. Is this reality with Drools? No, I'm afraid not. It's also not true with JRules, Blaze, or any other Rete-powered BRE. What marketers will show you is how easy rule maintenance can be-- but they're not showing you how difficult things can be when your logic doesn't neatly fit the 'if/then' paradigm. For example, commercial vendors love to show insurance logic where they offer rules like 'IF the driver's age is over 25, THEN give them a discount'. Next time you see one of those, ask the marketer to show you something along the lines of 'Calculate the average age of the drivers in the household'. Notice how that doesn't say 'IF'? Requests of this type will typically require a skilled rule author, not a business analyst copying from a rule template. This type of logic does not play to the strengths of the engine. Actually, implementing this type of logic can be fiendishly difficult-- that's the reason BRE developers are among the best paid of application developers (Check Dice or Monster.com). I say all this to let you know BRE usage sometimes is easy, sometimes is really hard. In a workspace like that, I like to have advice handy from a multitude of providers, and I'll be happy to add this book to my reference collection. I just wish there were more highlighted best practices in this book to help the user leverage the author's expert experience. (By the way, there are a few more books on rules engines available, but most all of what I've seen is truly awful. I do believe they were written by business analysts, and probably ones who have never actually written an application powered by a BRE. I do not find that fault with this book.)

So, what's the verdict? I'm glad I read this book (twice, to make sure I got everything) and would recommend it to anyone using Drools. If you're not yet a Drools user, I don't think this book offers enough remedial material to effectively help you get on board-- for that I recommend the excellent documentation offered online with the product. (By the way, I hope you like cheese. The Drools doc authors seem to have some sort of cheese fixation, so references to cheese are plentiful.) For a Drools user like me, this book offers a view at parts of the toolkit I hadn't yet used and a view of how an expert user might go about designing an application. I'll call it a keeper.

You can purchase Drools JBoss Rules 5.0 Developer's Guide from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RogueyWon writes "Now that the massively-multiplayer Final Fantasy XIV has been on the shelves for a couple of weeks, the reviews are starting to arrive; and it appears that the game is the subject of a critical battering unprecedented in the history of the main Final Fantasy series. First it was the Amazon user reviews, then Gamespot weighed in, describing the game as a 'step backwards for the genre,' and now IGN has described it as 'an arduous experience that, in its current state, isn't worth playing.' Given the general dissatisfaction that surrounded the release of the (offline) Final Fantasy XIII earlier in the year, many long-time fans of the series must now be wondering whether the magic hasn't departed."

rheotaxis writes "Many professional web developers have spent years building dynamic, database-driven web applications, but some of us, like myself, want to make the user experience more interactive and instantaneous. The book Building the Realtime User Experience, by Ted Roden, is an introduction to some new techniques making that happen now. New web servers like Cometd and Tornado power solutions that keep HTTP connections open until data is available for the clients requesting it, a technique called 'long-polling.' This means web developers can provide a real-time user experience using HTTP for all sorts of client devices now connecting to the Internet, not just web browsers, but mobile devices as well." Read below for the rest of rheotaxis's review. Building the Realtime User Experience author Ted Roden pages 320 publisher O'Reilly Media rating 8/10 reviewer rheotaxis ISBN 0596806159 summary Shows you how to build realtime user experiences by adding features on your site without making big changes to the existing infrastructure This book covers SUP and PubSubHubbub syndication, messaging with Bayeux protocol and Cometd, and asynchronous Python using Tornado, contrasting these with well-known client-side JavaScript methods. It then demonstrates how long-polling can implement and integrate chat, IM, SMS, and analytics. The last chapter wraps up with an example using all these technologies, a multi-user, real-time, interactive game using geo-location with mobile clients. Ted's writing style is concise and to the point, focused exclusively on the challenges presented and solved in each chapter, including just enough details for experienced programmers to download and setup the software tools being used, including the Google App Engine. The code samples are straight-forward, but be forewarned, it will be easier for readers with some experience building server-side scripts like PHP, Python, or Java, and a database server like MySQL. On the other hand, even if you never used Google App Engine before, that's OK, because Ted covers that in enough detail to get you started quickly. The sample code wasn't yet available on the O'Reilly web site, so you'll need to type in the code samples to try them. Check the O'Reilly errata page for the book to get a head start making the code work. (Full disclosure: I posted some of the errata.) The sample code for Cometd and Tornado ran easily on my laptop (HP 2.2 GHz with Windows Vista), and should be fine on Linux or Mac. Everything you need is open-source and easily downloaded.

The author explains that real-time web development puts the user at the center of all web interactions, and that developers have struggled with solving the push versus pull problem. The pull method requires multiple, periodic queries for updates from server information feeds, something that wastes server CPU and bandwidth when no changes have occurred, and is compounded by the number of different users making these queries. The push method allows the servers to contact the clients when information feeds have been updated, saving CPU and bandwidth.

RSS was designed for easy syndication of information feeds, but it suffers from the limitations of the pull methodology. While several push technologies have been proposed to solve this problem, only Simple Update Protocol (SUP) and PubSubHubbub are covered in detail here. Both of these are demonstrated with PHP code, so they should be easy to implement on hosted web account with PHP and MySQL. The author explains that while SUP isn't a real push methodology, it does address some the CPU and bandwidth issues. PubSubHubbub, a true push methodology when compared to SUP, is described with an equal amount of detail.

Next, the book covers techniques already familiar to JavaScript programmers who have experience building AJAX enabled web pages. Skim the text and glance at the code and diagrams in Chapter 3, if you already have this experience. The subtitle for this chapter is "Widgets in Pseudorealtime", and the key take away from this chapter is that client-side JavaScript can be used with pull or push technologies, depending upon the server-side implementation. If you don't yet have experience with AJAX, then be sure you can follow these code examples, because AJAX will be used in all the other chapters.

Have you ever wished your blog could send live updates to your readers the moment you post them? You'll learn how, using Bayeux protocol, Java, Cometd, and the Jetty web server. The sample code allows you to grasp how long-polling works with modern browsers. Once a client browser opens an HTTP connection to a web server using a POST method, the server leaves this connection open until it has data to deliver to the client. This chapter suggests using Firebug, a Firefox plugin for debugging web applications from the client side, to discover and track long-polling seasons.

Do you need to handle a large amount of incoming data, and then redisplay it on client browsers with almost no delay? Tornado, the Python web server, provides a solution. Tornado was created by FriendFeed, and made open source after being acquired by Facebook. Kudos to Facebook for making Tornado available. Please read Chapter 5 and 6 together, since they both explain how the Tornado server works. The sample code starts with Python threads that cache a Twitter feed, process and filter it, then send it out to web browsers already connected to Tornado using long-polling and asynchronous callbacks. Tornado is then used to implement a peer to peer chat system using long-polling. Again, each client stays connected to the Tornado server until messages are ready to deliver to each chat participant. Taken together, Chapter 5 and 6 lay the groundwork for more advanced Tornado web applications covered later in the book.

This is followed by two chapters using the Google App Engine to support real-time user experiences even though the Google App Engine does not support long-polling. If you have never used Google App Engine before this, don't worry. The author spends 10 pages explaining how to sign up. Then you build an application in the cloud and connect with your IM client, instead of the web browser. You can make your IM server accept commands and respond with information from other web services. The section, "Setting Up an API", gives you a tantalizing glimpse of possibilities explored later in the book. After adding Python code from the next chapter, you have SMS capabilities. Why would you want to do this? Because it allows users to keep informed while they're away from the web, making SMS another part of the real-time user experience.

Once you have implemented and deployed your real-time application, you can add analytics that give you immediate feedback about user interactions with your site. Instead of paying for a service, you can build your own custom web analytics using Tornado and client-side JavaScript. I especially like the authors approach to summarizing all the incoming web usage data into a single, super-simple, HTML template that is immediately updated as web usage changes. It should satisfy your curiosity to watch users interact with your web site in real-time, and you can make it track IM and SMS traffic connecting to your server too. Finally, the last chapter demonstrates how all the know-how you learn from the rest of the book can be combined in new and highly imaginative ways. The author provides all the details you need to setup a location-based, multi-user, real-time, interactive, game played by users with mobile web devices.

This book would be good for anyone that needs to quickly learn how to use Tornado and integrate it with other web services. It's also helpful for people who want to integrate the Google App Engine with other web services. Whether you're going to build a real-time web experience from the ground up, or just add a few more dynamic features to an existing site, the lessons you can learn from this book will help you.

You can purchase Building the Realtime User Experience from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

eldavojohn writes "Linux Kernel Development Third Edition by Robert Love is the perfect book for the beginning or intermediate Linux kernel hacker. It provided me an excellent bridge between the high level introduction I had in college (from Operating Systems Concepts) and the actual kernel code. The best part about this book is that the chapters are — like the kernel — modular, and allow the reader to dig down in a particular part if they have a specific interest. This, in conjunction with Love's indications of which files and code snippets contain the logic, gave me confidence to clone the kernel, make tiny adjustments, compile and run. At four hundred pages, the book is a long read, but for kernel newbies like me it's a better alternative to jumping into the millions of lines of code. While you might find this information in pieces floating around online, this book balances clarity with brevity in an exceptional manner. It should also be noted that this book defaults to the x86 architecture when explaining architecture-sensitive parts of the kernel (with 64-bit differences occasionally outlined)." Keep reading for the rest of eldavojohn's review. Linux Kernel Development Third Edition author Robert Love pages 480 publisher Addison-Wesley Professional rating 10 reviewer eldavojohn ISBN 978-0-672-32946-3 summary A thorough guide to the design and implementation of the 2.6 Linux kernel tailored for developers. If you're unfamiliar with Robert Love, let's just say he's been active in contributing to the Linux kernel for fifteen years and he's currently at Google and was part of the Android team. This is his third edition of Linux Kernel Development, and it's tailored to the 2.6 kernel. The first chapter of this book gives you a very brief history of Linux along with an explanation that a major upgrade has been postponed and 2.6 is a very stable and capable version to use. I'd imagine many companies today (like my own) live and die by the capabilities of 2.6 hosting a variety of services. The second chapter sets you up with git to clone the code and deploy it locally without hosing your kernel. If you'd like to sample Love's writing style, these two chapters are available for preview online (PDF).

From there on out, Love divides the kernel up and proceeds to ease the reader into each realm that he covers. You won't get full coverage of the kernel but he delivers the most important chunks that he can in 400 pages and makes good on keeping the material in focus. Every chapter seems to follow a pattern of a few pages of generic remedial kernel design talk then a few pages of Linux specific historical approaches to said design followed by the meat and potatoes in 10 to 40 pages depending on how much code is cited. A short paragraph or two tidies up each chapter to segue into the next one. I failed to find any weaknesses in Love's writing. While he struggles to keep the reader engaged and entertained at times, there's simply too much explaining to be done for him to waste pages on wit and banter. If any of that is to be found, it's sprinkled around the intros and outros surrounding some genuinely solid technical writing. To keep this review relatively concise, I'll only fully cover the content in the first half of the book.

Chapters three and four focus on processes and how the kernel manages them. Love glosses over some basic concepts (i.e. the state transition diagram of a process) about process creation but also includes small code snippets ranging from function signatures to iterative algorithms that do the heavy lifting when initializing and maintaining processes and their hierarchical structures. If you've ever wondered exactly what happens during a fork or how zombie processes are managed, it's all answered here in English. The book moves on to Linux's relatively new completely fair scheduler (CFS) and also describes how to switch out schedulers (the older schedulers appear to remain unused in the code if you want to swap them back in). Love concentrates on kernel/sched.c and kernel/sched_fair.c as he explains the code and flags that control waking, sleeping, preemption and context switching. For me this was one of the most interesting parts of the book where the reader gets to see timeslice and 'nice' factors at work in the actual code. The runnable processes are managed in a red-black tree and Love takes care to show how these are cached and used in the code. As I read these chapters, I couldn't help but wonder how companies like Google tailor the Linux kernel to their needs inside their massive server farms — the care to 'waste not' is already so evident in Love's explanations that tweaking through settings and flags or even rewriting seems like a hard route to save cycles.

Chapter five is a brief how-to about system calls in Linux. This chapter details how to create a system call and how to register it, but also gives background on how the kernel handles system calls and explains concisely how Linux handles system calls in regards to security and stability. Most importantly this chapter explains why you should rarely — if ever — resort to system calls (if it's not accepted as part of the kernel, you face future conflicts with the syscall number).

Chapter six was a bit of a surprise to me but outlines in depth four data structures (linked lists, queues, maps and red black trees). If you code only for Linux and you are rolling your own of any of these data structures then this chapter is for you. It's a bit of a flashback for me but important to note so that one does not duplicate these efforts inside the already expansive code in the kernel. Indeed, this topic is an addition to the book that was not present in the second edition.

Chapter seven is a good illustration of Love's ability to ease the reader into the kernel. He starts off giving a high level introduction to hardware interrupts and their superiority to hardware polling. Form there he explains interrupt handlers and finally the top half (handler) versus the bottom half (deferred workload). This four page intro to the chapter helps beginners like myself prepare for the coming sections on writing a hardware interrupt handler, registering it, unregistering it, disabling all or some handlers, explaining /proc/interrupts and checking contexts. This chapter lays the foundation for following chapters and shows the basics of interrupt handlers. Chapter eight, of course, covers exactly what was left unexplained in the prior chapter — the bottom half. And again the chapter eases into it with an explanation detailing bottom halves. Love gives just the right amount of background (a few paragraphs) to help the reader understand why we are about to discuss softirqs (statically defined bottom halves), tasklets (dynamically defined bottom halves built on top of softirqs) and work queues at great length.

Chapters nine and ten begin with topics the reader might already have some familiarity with: race conditions. Nine begins with the standard topic of the kinds of problems race conditions pose and how one can handle them. The reason for this is the advent of symmetrical multiprocessing (SMP) support that has faced increasing demand in modern operating systems. Love covers what questions the reader should be asking themselves when writing code that may be adversely affected by more than one processor. Love warns the reader that this is not something that can be tacked on at the tail end of development; it must be in the developer's mind from the start. This leads nicely into chapter ten which recalls these problems and explains the many different ways they can be addressed inside the Linux kernel. For each of these approaches, Love outlines the C functions that are available with a brief description. Love lists them in increasing complexity and decreasing frequency: atomic operations, spin locks, semaphores, mutex, completion variables, sequential locks and the Big Kernel Lock (BKL). For each of these, Love provides bullets of guidelines on when to use them versus the others. The most useful of the tables int his chapter are those that contain requirement/recommended tables that help prescribe the reader a solution. But Love advises that the simplest mechanism should be employed unless more complexity is demanded. He also advises the reader to try out several options before settling on the best way to enforce synchronization and handle concurrency. Aside from the specific technical details, this chapter was full of useful rules and guidelines to keep in mind.

The rest of the book covers — in equally excellent detail — the topics of: timers and their management, memory management, VFS, address space, I/O, page caching, debugging and portability. Love also gives some short pointers on code style, creating patches and how to join the community in the final chapter. Skimming the ToC from the second edition (also on 2.6) reveals no major changes to topics aside from some reordering and updating of sample code (like the completely fair scheduler). It's clear that Love has set out to provide a comprehensive guide to the Linux kernel and if you are looking to work intimately with the kernel for fun or for profit then this is the definitive book for delving below the surface of Linux.

You can purchase Linux Kernel Development Third Edition from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

r3lody writes "I have enjoyed other cookbooks in the O'Reilly library of computer texts, so when I saw JavaScript Cookbook by Shelley Powers in the catalog, I jumped at it. The description mentioned that the book would cover HTML5 and ECMAScript 5, so I really wanted to learn the new capabilities of both. I did get to learn a lot, but I wonder if these new features are too new." Keep reading for the rest of Ray's review. JavaScript Cookbook author Shelley Powers pages 560 publisher O'Reilly Media rating 7/10 reviewer Ray Lodato ISBN 978-0596806132 summary A well-constructed collection of JavaScript recipes, with forward-looking samples of ECMAScript 5 and HTML5 Like other cookbooks in the O'Reilly library, this one is organized as a series of specific problems, with their solutions neatly presented and grouped into the major chapters. Each solution has a discussion to flesh out the details. The website has downloadable copies of the examples in the book, which I used to test out the various recipes. ECMAScript 5 is fairly new, and HTML5 is still under development, so I made sure I had the latest stable versions of the major browsers (Firefox, Google Chrome, Internet Explorer, Opera, and Safari) to see how they would cope. The HTML5 features are very sparsely supported as of yet, so those portions of the book should be considered more of a sampling of things to come rather than a definitive set of solutions.

The first five chapters of the book are somewhat unremarkable. They start out easily enough with recipes for handling JavaScript strings. The discussion of String objects and literals obviously implies that the reader is already somewhat familiar with Object terminology and functionality. That makes this book unsuitable for beginners. The following chapter contains recipes for handling regular expressions. It starts off with an introduction to the basics, which are nothing that a somewhat savvy shell programmer should be familiar with. The remaining sections cover pretty basic problems. The only interesting ones I noted handled highlighted found phrases on a web page.

Chapter 3 covers dates, time, and timers. Handling dates is shown to be pretty straightforward, and one-shot and recurring timers are presented in a clear, easy-to-understand manner to wrap up the chapter. The next chapter, Working with Number and Math, consists mostly of basic mathematical solutions. The fifth chapter rounds up the basics with recipes for working with arrays and loops. As a Perl programmer, I found this to be familiar territory – especially the discussions of the splice and map method, and using associative arrays.

Chapters 6-10 provide the first real appetizing recipes in the JavaScript Cookbook. Shelley first discusses building reusability using function definitions, anonymous functions, recursion, scopes and memorization. It's starting with this chapter that you really begin to learn how to use JavaScript rather than just playing around with it.

Event Handling is the first major hurdle a procedural programmer needs to overcome to use JavaScript effectively. Various event triggers are discussed in the sections of chapter 7. While most of the code is easy to comprehend, I ran into problems when using the new HTML5 drag and drop was discussed. I had to ask myself could drag-and-drop be any more complicated? This example worked on all but Opera, but the solution is convoluted. Overall, if you really want to know how screwed up code must be to work in all different browsers, chapter 7 (Handling Events) will demonstrate it. Internet Explorer's differences is the reason for most of the odd workarounds in this chapter.

We would all like each browser to work just like another but, unfortunately, each one has its own quirks. Chapter 8 talks about the various ways browsers handle color support and page sizes. The chapter ends by dealing with dynamic pages and bookmarking their state.

The first time I worked with JavaScript was when I was coding some form handling. Chapter 9 covers the ways to handle forms and modify web pages. The most useful recipes (at least, for me) were the last two, which showed how to hide and display form elements on the fly, and how to modify selection lists based on other form element entries.

All programming involves error handling and usually some debugging. Chapter 10 describes the various ways to handle errors, followed by a well-written set of tips on how to use the debuggers and inspectors for the major browsers.

The following three chapters all deal with manipulating web pages. The first of these contained a lot of discussion of namespaces. Namespaces can be confusing, and I didn't really understand them much better after I was finished reading. In addition, you are presented with several boilerplate templates, with little information as to why you would use them. I also had problems with some of the downloaded samples not running correctly on my browsers. Chapter 12 contains lots of fun ways to manipulate page content, with specific instructions on how to handle IE and its different ways of doing things. Finally, chapter 13 provided some good basics of page manipulation, including creating collapsible sections, and creating tab pages.

Accessibility is the major topic of chapter 14, where you are introduced to ARIA (Accessible Rich Internet Applications). Many web pages are not built with accessibility in mind, so this chapter is very important for giving the web designer the tools for well-designed and usable pages. Some ARIA techniques are straightforward, but others (such as creating collapsible form sections) are much more complex to get right. This chapter does a marvelous job, even though it is somewhat hard to read.

The next chapter covers creating media-rich and interactive applications. This chapter was pretty deep, and the examples were not necessarily bad, but the techniques required need the coder to really think clearly about how to accomplish their goal.

Chapters 16 and 17 cover JavaScript Objects and Libraries. In the Objects chapter, there is quite a bit of discussion around ECMAScript 5, which is not yet well supported in the browsers normally available. As one example, Shelley does say regarding the preventExtensions feature "by the time this book hits the streets, I expect (hope) at least a couple of browsers will have implemented this feature". The Libraries chapter was more problematic in that I was not able to follow along and get the supplied samples working correctly. In addition, the coverage of jQuery was only a high-level overview, leaving the reader wanting more. In her defense, Shelley acknowledges the breadth of the jQuery topic and refers you to the jQuery Cookbook for more information. Overall, I found chapter 17 unsatisfying and abrupt in its coverage.

Communication via Ajax is the main topic for the recipes of chapter 18. Without a proper web server at my disposal, I could not properly evaluate the workability of the solutions. I was also somewhat amused that one of the solutions was described with the caveat that it's not a recommended procedure. I would ask why it was included in that case.

The Working with Structured Data chapter starts by covering JSON (JavaScript Object Notation), but then adds in recipes for handling hCalendar Microformat Annotations and RDFa. The transition was a little jarring, and not overly useful, in my opinion.

The penultimate chapter covered the issues around persistent information. While using URLs and cookies to maintain some state are discussed, much of this chapter revolves around new capabilities made available in the new HTML5 specifications. Unfortunately, most browsers either do not support, or only partially support these features, so the information is only useful as a "taste of things to come".

The final chapter covers the use of JavaScript in non-browser environments. Widgets and gadgets are simple JavaScript applications that are easily coded and disseminated. There are discussions of creating applications for the iPhone, Android phones, and Blackberry phones.

As I step back and reflect on this book, I think that many topics are solutions that cannot be implemented because the typically available browsers don't support the new features yet. If a web page designer wants their site to be available to users now, they need to focus on the features that are well entrenched across the internet. Having so many solutions based on features and capabilities that are still being defined is only useful as academic exercises. I would have preferred that the JavaScript Cookbook be more useful for the state of the web right now. That is why I'm rating it only 7 out of 10.

You can purchase JavaScript Cookbook from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Muad writes "John Calcote is a senior software engineer in Novell's Linux business, who after slogging up the steep learning curve the Autotools triad poses to those packaging software according to the portable GNU conventions for the first time, very kindly decided to make the experience easier to newcomers by sharing his years of experience and carefully crafted bag of tricks. His book is a welcome update to a field that has not seen entries now for a full ten years, so long has been the time since GNU Autoconf, Automake, and Libtool by Gary V. Vaughn, Ben Ellison, Tom Tromey, and Ian Lance Taylor hit the shelves. Unfortunately, the publishing industry is driven by the need to turn a profit to fund its endeavors, and specialist items like this book are not obvious candidates for volume selling - which is a credit to No Starch Press' willingness to venture down this path." Keep reading for the rest of Federico's review. Autotools: A practitioner's guide to GNU Autoconf, Automake, and Libtool author John Calcote pages 360 publisher No Starch Press rating 8/10 reviewer Federico Lucifredi ISBN 1593272065 summary Teaches how to master the Autotools build system to maximize your software The book opens with John's experiences in adopting the Autotools, and quickly offers what is in my view a very important word of caution that is often lacking in the few tutorials I have seen on the Net: the Autotools are not simply a set of tools but foremost the encoded embodiment of a set of practices and expectations in the way software should be packaged the GNU way. While it is acceptable for beginners not to know what these expectations are, the right frame of mind to approach the Autotools is to focus on learning what way the Autotools operate, what they are trying to accomplish, and why. Attempting to use the Autotools without understanding the bigger picture will lead to very high amounts of pain, as it is one of the toolsets most difficult to adapt for use separate from the policies they represent, so strongly are these conventions embedded in their fabric. With this understanding, it becomes possible to generate extensive configurations with a few lines of Autoconf or Automake - without this understanding, it very quickly becomes a battle to force a round peg into a square tool.

John's style is more extensive and takes a longer path to the "technical meat" of the problem than the 10-year old alternative, but in this reader's opinion it flows significantly better as there is an underlying story, a thread that connects the bits of what is otherwise a pretty arid subject. For those masters of shell-fu, this book is a page-turner, while for mere mortals it is a good, approachable, path into a difficult skill.

The book is structured around the packaging of two different projects, the first being a simplified "Hello, World" project to provide a digestible introduction to the processes and technology of the Autotools, while the second representing the full-blown packaging of a complex, real-world project (the FLAIM high-performance database). This is a very good approach, breaking the theory into many practical examples of practice, and providing many ready-made bits that the rest of us can start our own configuration build files from. The result is a first half providing a gentler, streamlined introduction to the subject matter, before the full jump into the gory details of the most complex possibilities the toolset offers. While it must be noted that John attempts to keep away from those most fine details which "may be subject to change" between minor releases of the tooling, which is doubtlessly good for both our scripts' and the book's shelf life, it must be observed that he does not shy away from very dense (and otherwise utterly undocumented) material, such as the use of M4 macros in Autoconf, something a colleague of mine once pointed to me as "the one more reason I'd rather chew broken glass than deal with Autotools".

Assuming you have the requisite knowledge of Make, Shell scripting (particularly Bash), and GCC that are essential to a developer, packager, maintainer or buildmaster of a Linux, BSD or *NIX project, or that you are on your way to achieving those skills, this is a book that belongs in your shelf, right next to the RPM documentation. This is material for experts or experts in the making, but in my opinion you will find no better introduction to this complex subject. I had it on my wish list well before it was ever printed, and its presence on my desk caused several other developers in my office to order their copies pretty much on the spot upon finding out of its existence. Either as a learning tool for a skill you are trying to attain, or as a reference to turn to when faced with the complexities of this unique set of tools, this book is well worth its price tag.

I certainly hope this is not the last publication we see on the Autotools in this decade, but either way, it is a good start indeed - and my hope is that the publisher will refresh the title when an update is warranted, without waiting ten years!

Federico Lucifredi is the maintainer of man (1) and a Product Manager for the SUSE Linux Enterprise and openSUSE distributions.

You can purchase Autotools: A practitioner's guide to GNU Autoconf, Automake, and Libtool from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

eldavojohn writes "As you're probably aware, HTML is in a transition period, lost somewhere in the mire between versions 4 and 5. That doesn't stop us from using the latest and greatest, but it does create a requirement for gracefully falling back when a user does not have native support for features like canvas, video, audio, local storage, web workers and geolocation. HTML5: Up and Running is a great resource for someone tasked with bringing HTML4 webpages up to HTML5 standards, but it's mediocre-to-poor in illustrating advanced usage. For example, author Mark Pilgrim invests around thirty pages on video, while putting at most half a page toward web workers. Some of this is not his fault, due to support (or lack thereof), but the book felt skimpy at a couple hundred pages. For me, this book had value if only for the many wrapper scripts and workarounds like Modernizr, complete with code snippets. This book is for the beginner to intermediate developer and also for developers tasked with implementing HTML5 immediately. I received my copy for review from O'Reilly, but you can also find a draft of it under CC-BY-3.0 license. And the sample code is available online, so you can follow along." Read on for the rest of eldavojohn's review. HTML5: Up and Running author Mark Pilgrim pages 224 publisher O'Reilly Media rating 8/10 reviewer eldavojohn ISBN 978-0596806026 summary A brief initial look at the cemented changes and features in HTML5 as well as those to come. The first chapter gives the impression that Pilgrim wants the reader to feel the pains so many in the HTML working groups have felt over the past two decades. But after all the anecdotes, after all the distribution list forensics, after 'too bad I'm doing it this way,' this chapter could be shortened down to one sage and universal rule for software: those who ship win. If you want to dictate HTML5 behavior and interfaces, sitting around e-mailing doesn't matter when other browsers are shipping code that works.

Chapter two is entirely focused on checking whether or not the user's browser supports any of the many features HTML5 is bringing to web developers' fingertips. An important thing to note throughout the book is that Pilgrim makes sure to keep mobile browsers in mind and a part of the discussion. While useful, this occupies fifteen verbose pages of the already short book.

Chapter three has really good material in it if you're looking to evolve from HTML4 to HTML5 without any of the added functionality (just markup). It makes for cleaner code and introduces all the new tags and their functionality. Here you'll see how navigation has been generalized (much to the joy of disabled/impaired users who rely on screen readers) and how to properly transform and maintain HTML towards to HTML5.

Chapter four does a good job of beginning to cover the canvas element and drawings in HTML5. Drawing shapes, lines, setting text and rendering images multiple times on the canvas are all covered. The chapter presents many examples and ends with a simple implementation of a game of halma. It's inefficient, and he alludes to better ways of rendering game graphics (like redrawing only 'dirty' parts of the screen). But I hope he takes the time to flesh out this chapter, as I've seen impressive things done with canvas already. I really hoped for more out of this chapter, but must concede that it might be better off in a book devoted to game design.

The next chapter exhaustively covers video and audio codecs. From there the book steps the user through how to make their page foolproof so that the video tag gracefully resorts back to Flash (or whatever you want), should it be unable to find a supported video codec. From batch encoding with ffmpeg to Firefogg to using handbrake, the author holds the user's hand and more (even explains MIME types). This chapter is very valuable to anyone who is sitting on some video data that wants anyone to be able to access it and isn't opposed to multiple encodings.

I'd like to mention also that Pilgrim is an entertaining author. As he covers the available codecs, he pokes fun at a few corporations:

MPEG-1 Audio Layer 3 is colloquially known as "MP3." If you haven't heard of MP3s, I don't know what to do with you. Walmart sells portable music players and calls them "MP3 players."Walmart. Anyway ...

And in regards to DRM:

Originally, all AAC files "bought" from the iTunes Store were encrypted with Apple's proprietary DRM scheme, called FairPlay. Selected songs in the iTunes Store are now available as unprotected AAC files, which Apple calls "iTunes Plus" because it sounds so much better than calling everything else "iTunes Minus."

It should be noted that Pilgrim can at times seem a little pro-Google. They are his employer, but I would appreciate it if he was an equal opportunity humorist and didn't pick on just the others.

Chapter six gives a short introduction to the geo-location features and the API provided by HTML5. It explains how to use gears or geo.js to work around IE's lack of support and also explains how to opt out of this sort of service — as it might seem a little too much for some people. I guess this is a feature for advertisers (not like they aren't doing it already, anyway).

Chapter seven briefly covers local storage in HTML5 and the precursors to it (cookies). It's got a few code snippets you can tinker with. There's a great meme embedded in this chapter: 'userData allows web pages to store up to 64 KB of data per domain, in a hierarchical XML-based structure. (Trusted domains, such as intranet sites, can store 10 times that amount. And hey, 640 KB ought to be enough for anybody.)' The chapter covers competing visions and notes that this is a separate effort from the core elements of HTML5. At the end, Pilgrim adds persistence to the halma game from earlier. This is already being abused, by the way.

Chapter eight shows how to markup your pages so that they operate offline. You include resources in the cache manifest file to let the browser know what to cache for offline usage (and more importantly, what not to cache). Again, at the end of this chapter, we take the halma game offline.

Chapter nine is one of the better chapters, as it extensively covers the various new types of form inputs we have in HTML5. Gone are the days of importing calendar scripts to create a date popup widget (although we already know how to check whether that's required). Search inputs, different kinds of integer selectors and color pickers are all covered in this chapter. While you might have experienced this in many other UI technologies, we're finally receiving native support in the browser!

The final chapter is relatively lengthy and very informative. It explains microdata and how to make HTML5 extensible so you can define your own markup (while keeping it normal so that older browsers don't plotz). It's like advanced metadata. You might wonder: Why would you do this? Well, the chapter continually shows how Google search results interpret this data ... but we aren't informed of any competitors using it or any plans of them using it. Pilgrim informs us that we should put this around our data and let others decide what to do with it (they might surprise you). So while the work is pretty extensive, you won't immediately see the fruits of your labors (unless everyone else is already doing it).

HTML5 has a long way to go. I hope this book is a living document, and I imagine the final O'Reilly book on HTML5 will be several times the length of Up and Running, but until those who ship their code cement it (after reading this book, my money's on Google), we'll have to wait. In the meantime, Pilgrim has some great resources on his site and done a decent job with this book.

You can purchase HTML5: Up and Running from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "In the past, a Web developer tasked with building an online store would most likely do so using a dedicated e-commerce system, instead of a content management system (CMS), because even though the leading CMSs offered more features and flexibility, they did not provide robust e-commerce capabilities, such as product listings, bulk import, pricing in multiple currencies, a built-in shopping cart, and integration with tax and shipping information sources. Since that time, e-commerce systems have become more like CMSs, by adding features such as blogging and forums. At the same time, CMSs are continually expanding their e-commerce potential, usually in the form of developers adding plug-ins. For developers using Drupal, there traditionally have been two major e-commerce plug-ins (known as "modules"): Ubercart and e-Commerce. The former has emerged as the leader, and is explored in Drupal E-commerce with Ubercart 2.x." Read on for the rest of Michael's review. Drupal e-commerce with Ubercart 2.x author George Papadongonas and Yiannis Doxaras pages 364 pages publisher Packt Publishing rating 7/10 reviewer Michael J. Ross ISBN 978-1847199201 summary A detailed guide to using Drupal and Ubercart to make a virtual store. This book was published by Packt Publishing on 22 March 2010, under the ISBN 978-1847199201. (My thanks to the publisher for a review copy of the book.) On the publisher's page, visitors will find detailed information about the book, a table of contents, a sample chapter in PDF format (Chapter 9, "User Interface Enhancement Techniques"), errata (only three reported as of this writing), and links to purchase either the print or electronic versions of the book, or both at a large discount. The authors of this title, George Papadongonas and Yiannis Doxaras, are experienced open-source developers. They both reside in Greece, which may explain why the reader will stumble upon — and sometimes over — many oddly-formed phrases throughout the book, as though they had been written in a foreign language initially, and then translated into English. More on that later. Nonetheless, almost all of the material presented within the 364 pages can be clearly understood by anyone who is comfortable with the basic terminology of e-commerce and Drupal. The authors have their own website for the book, yet oddly it isn't mentioned anywhere in the text.

The book is organized into ten chapters and three appendices. The first chapter is a brief introduction to Drupal, Ubercart, and the test case used in the early chapters — in this case, a store selling electronics online. Chapter 2 explains how to install the minimum required Web technologies, Drupal, Ubercart, and related contrib modules — either individually or using packages such as XAMPP for the Web server and the UberDrupal installation profile for Ubercart. The authors recommend the use of the Thickbox module for lightbox functionality, but that one has since been superseded by the Colorbox module. The reader is told that the extra modules listed on pages 34-35 do not need to be installed immediately, but will be installed in each chapter as required; but this is misleading, because in later chapters the readers will discover repeatedly that they were not told when to install the modules. Readers may be puzzled as to whether or not they are expected by the authors to use UberDrupal, but it is of no consequence, because the end result is the same, namely, the Ubercart site is ready for configuration.

The third chapter covers basic configuration of both Drupal and Ubercart, and begins with a thorough introduction to the admin area of Drupal. Experienced Drupal users could skip most of the first three chapters — aside from the list of needed contrib modules on pages 31 and 32. In the brief section on downloading and installing Ubercart, the authors advise the reader to enable the core modules, but unfortunately provide no guidance on any of the optional ones that should be enabled so the reader can easily follow the test case in the book. The reference on page 48 to "path/x" (where x is a node identifier) is perplexing, because the authors fail to explain what they mean by 'path', since its literal use is invalid, and no directory path is presented. Also, they state that the default Drupal temporary directory (/tmp) does not need to be changed, but that is not true for Windows users who want to use an existing directory, such as C:\DOCUME~1\[username]\LOCALS~1\Temp (where [username] is their current Windows username). The cart settings on page 55 show four panes, instead of the two that will be seen by readers who have followed the authors' instructions exactly up to this point. A similar problem is encountered on page 65, because the text assumes that the reader has enabled product kits, although Chapter 2 recommended otherwise. The "Product features" pane is skipped, without any apparent reason. In general, the authors' coverage of the configuration settings provide little information beyond what is already explained on the settings forms themselves; this chapter would have been much more beneficial had the authors explored the typical cases in which the reader would want to change the settings, and the benefits of doing so.

The material becomes more interesting with Chapter 4, which gets into the details of managing categories, subcategories, products, and attributes. The authors begin by showing how to enhance products using both admin-created and user-generated tags for products and product kits. Yet in describing the latter type, a critical step in the process is neglected, namely, enabling the "Tags" setting. The reader is then told to create a couple sample products, and combine them into a product kit, which is a straightforward process in Ubercart — although some readers may initially be puzzled by the instructions to go to a Web page on the site http://www.mysite.com/ (also on page 106). More odd is the example product kit having a name of just a single component and a description consisting only of the other component's name. Readers learn how to bulk import a large amount of product data. In the process, we are instructed to "enable this module" (page 89), when actually all three modules need to be enabled. Also, no reason is given as to why the authors opted for the directory name "import" over the module's better default of "imports." The second figure on page 97 shows the first imported record not as a formatted product entry, but as PHP code, which is probably not what was intended. The next topic — product attributes — is important, because any shopping cart system that lacks flexible and powerful attribute management capabilities may appear at first glance to be a workable choice for creating an online store, but eventually those deficiencies will make it difficult if not impossible to implement the e-commerce setup desired by the store owner. The chapter is wrapped up with a brief but valuable description of the three ways to manage the products in an Ubercart site.

When it comes to shipping and packaging — the focus of Chapter 5 — far too many shopping cart systems burden the store admin with limited options and non-intuitive interfaces. Ubercart is relatively more straightforward, and the book shows how to specify destination countries, conditional actions, and shipping quotes — using flat rates, product weight, UPS, and USPS. Unfortunately, conditional actions are given little attention, and even the sample scenario is not demonstrated. This is a shame, because the topic is critical to developing an Ubercart-based store so it will automatically perform actions — such as notifying the customer — based upon a wide range of common events and conditions. Anyone planning on using the UPS shipping method should note that the registration URL provided has changed since publication of the book, but does point to the UPS Developer Kit, which has a registration link and other resources. The last section, on weight quotes, could prove baffling, because it does not match the current behavior of Ubercart in defining such a shipping method.

Properly calculating the appropriate taxes for customer orders, and accepting payments online, are two areas of e-commerce fraught with potential problems, and even greater legal risks. These are explored in the sixth chapter, which gets off to a shaky start with the claim that the overview page for "Tax rates and settings" has policies already configured, when in fact there are none. Readers learn about tax rates within Ubercart, payment workflow options, advantages and disadvantages of accepting credit cards on one's site, the configuration of payment settings, and details on the Ubercart modules available for the major gateway services — with an emphasis upon PayPal and Google Checkout. Oddly, the authors recommend that merchants outside of the United States and UK obtain VAT numbers, even though the former country does not have a value-added tax (at least, not yet). The chapter concludes with a brief overview of how to create your own payment gateway module. The authors mention that they are providing the reader with code samples for two of the most common payment gateway request methods, and yet there is no such code in the chapter, and the book has no downloadable code on the Packt Publishing website.

Chapter 7 looks at the related topics of customer management; order tracking, workflow, search, creation, and modification; and invoicing, payments, packaging, and shipping. Merchants will find much of this information collected into the reports built into Ubercart. Yet more thought should have been put into the diagrams, such as the one on page 160, which includes an unexplained asterisk in one status box, and an order going from the status of "product gathering" to a second status with the identical name. Also, the process of creating a new order as described does not match the current interface in Ubercart 2.4 (the current version as of this writing). The chapter continues with summaries of customer relationship management (CRM) in general, and CiviCRM in particular, and how it can be integrated into an Ubercart site. The authors state that the Ubercart Wish List module is part of the Ubercart "extra" list of submodules, but it is instead a separate project. Other methods of increasing sales are discussed, including newsletters, company blogs, discussion forums, and Twitter.

In some respects, the remaining three chapters can be thought of as a second part of the book, because they presume that you have completed all of the elementary components of your online store, and are now ready to customize its appearance, and begin marketing the site. Chapter 8 elucidates how to find, install, and modify a Drupal theme for your needs — as well as how to create your own, based upon the popular Zen and Fusion starter themes. The material is generally clear, except for the authors' claims that site visitors cannot "perform proper searches" using the default Drupal 6 theme (Garland), and that you the site creator "cannot interfere with UI" (whatever that means). Confusingly, pages 200 and 201 list all sorts of advanced theme configuration settings for Garland which don't exist. The chapter finishes with a demonstration of how to create a new Drupal theme from either a static HTML site or a Photoshop template (despite an earlier claim that the chapter would end with a reference to the Fusion Theming System, which is absent).

Chapter 9, "User Interface Enhancement Techniques," shows you how to improve an Ubercart-based site using taxonomies and recommendation systems (for product cross-selling), the Panels and Views modules (for greater flexibility in information display), discounts, and other techniques. This discussion has more wheat than chaff versus the earlier chapters, probably because the authors are exploring higher-level methods, and not stepping the reader through forms. But again, configuration settings are mentioned that will not be seen by the reader, evidently because the authors do not provide timely instructions as to the modules to install and enable, such as XML Sitemap (page 231).

The final chapter first explores a host of Drupal contrib modules aimed at online promotion, and then shows how to improve a site's security with backups, security reviews, and spam blocking. The final material comprises three appendices, covering a hotel booking system, lists of the modules used in the book, and some of the free and paid themes suitable for an Ubercart site.

The book contains numerous errata: "contributed systems" (page 1; should read "contributed modules"), "innovated" (page 7; should read "innovative"), "constrains" (page 7; should read "constraints"), "hundreds and thousands" (page 8; should read "hundreds of thousands"), "It is [a] social media ready" (page 8), "brooking" (page 10), "flash animated" (page 10; should read "Flash-animated"), "depreciated" (page 20; should read "deprecated"), "[the] Drupal installer" (page 27 twice, and 28), "[the] time zone" (30), "their home page[s]" (32), "to [the] site" (48), "such [a] service" (58), "customer [to] enter" (65), "ipod" (80), ."com//node" (86), "types or files" (88; should read "types of files"), "know, exactly" (106), "it it" (111), ", [the] shipping rate" (112), "charge[s] you" (128), "customers['] geographic locations" (132), "statements[,] discussed" (134), "logics" (134). That last one — an amusing non-word — seemed a "logical" and thus appropriate place to stop recording errata, even though I had yet to reach the halfway point in the book.

Earlier I noted that many of the phrases — and entire sentences — are awkwardly constructed. A few of them are unintentionally humorous, such as the phrase "to mess with" getting turned into "to mess up with" (page 205), and the phrase "a check for the balance" getting shredded into "a balanced check" (page 147) — which immediately brings to mind the question, What would be an unbalanced check? This problem worsens as the book progresses; by page 244, "caching time" has been shortchanged into "cashing time," and "number-one ally" has melted into "number-one alloy" (page 292). Some of the problems are present in all the chapters. For example, in countless places, the words "the" and "a" are needed but missing. While programming books generally are known for being grammatically and stylistically weak, there is no excuse for releasing a book to press that has not been thoroughly proofread. The same is true with regards to the technical editing of such a volume prior to publication. Throughout the book, URLs are missing the root directory "/" (which generates an error from the server). In most if not all places where the reader is told to leave a page's settings unchanged, he is then told to click the "Save configuration" button (before going on to the next page) — which is completely unnecessary and a waste of time.

But these are not the flaws of greatest importance. There is too much emphasis throughout this book on how to fill out form fields that are fairly obvious, and yet the most important subject matter is oftentimes glossed over. For instance, the topic of conditional actions arguably deserves its own chapter, or at least an extended section — not one and a half pages up front, and then several paragraphs later. A few key e-commerce topics are absent. A glaring example of this is the lack of discussion of how to sell digital products in one's store, which nowadays is important enough to warrant its own chapter. Subscription services (typically with recurring payments) is another worthy topic completely skipped. These deficiencies may be due to the authors' focus on explaining the admin pages and settings found within the basic Ubercart modules, rather than a much more pragmatic approach of exploring the steps needed to reach a goal (e.g., selling downloadable files) regardless of what modules are utilized. Admittedly, Ubercart and all of its constituent modules comprise enough details and moving parts that could justify a book of greater length. Yet room could have been made for those details and advanced topics by spending less time describing (obvious) form fields. Lastly, if the authors had expected the reader to be able to follow their instructions throughout the book, they should have made it more clear as to which modules and options should be enabled at each step.

Nonetheless, the authors have clearly put a lot of effort into making what could be an extremely dry subject more approachable, as they take the reader through the major phases of building a typical online store for selling physical goods. Offering complete explanations and plenty of screenshots, this book could be a valuable resource — as both tutorial and reference — for Web designers, developers, business owners, and anyone else involved in creating a Drupal/Ubercart e-commerce website.

Michael J. Ross is a freelance website developer and writer.

You can purchase Drupal e-commerce with Ubercart 2.x from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

An anonymous reader writes "This is not an ordinary book and extraordinary would still be an understatement. Robert Louis Kemp has built a plateau of quod erat demonstrandum (Q.E.D.) in math, physics and logic; defined as his Super Principia Mathematica. Beyond brilliant, Kemp has worked on his book for over two decades, sacrificing personal comfort and financial security to laboriously bring to fruition his textbook style, hardback, expertly illustrated principles to the understanding level prevailed by most people. By 'most people' he means those who have a basic understanding of mathematics, geometry, algebra, calculus, physics and most importantly possessing the curiosity to learn." Read on for the rest of Gary's review. Super Principia Mathematica: The Rage to Master Conceptual and Mathematica Physics author Robert Louis Kemp pages 544 publisher Flying Car Publishing Company rating 10/10 reviewer Gary R. Sorkin ISBN 0984151826 summary Presents physics and mathematics in the form of simple math models, pictures, definitons, and aphorisms Kemp unpretentiously begins with a quick introduction of the laws of physics, math, relativity, quantum mechanics, and other issues regarding creation of matter, the beginning of the universe, plus dark energy, particle physics, atomic energy, geometry, time and space. In doing so he credits the groundbreaking work done by others over the centuries, such as; Nicolas Copernicus, Jonannes Kepler, Rene Descartes, Isaac Newton, and more recently Michael Faraday, Albert Einstein, Hendrik Lorentz, Alexander Friedman and the contemporary and controversial work of Steven Rado. However most notably Robert Louis Kemp celebrates the work and wisdom on one which he quotes throughout his prose and cites credit beyond all the others, and that is God. I would not classify this book within the genre of theology; however it is refreshing to see a man with such scientific acumen articulate his respect for a fundamentally diametrically opposing thought process.

It would be impossible to describe the scientific descriptions of Kemp without quoting an excerpt from his work to illustrate the nature of his writing. Halfway into this book he talks about the principles of The Vacuum Force. To quote, 'The Vacuum Force is popularly thought of as an attractive effect, which is incorrect since vacuums do not innately attract matter like Gravity does using mass. The Vacuum Force behaves similar to a home vacuum where the dust being "sucked" into a vacuum cleaner is actually being pushed in by the higher pressure air on the outside of the cleaner.' Kemp then goes into a discussion of the suction of fluids, which quite interestingly, 'if the pressure is inward (centripetal) motion, its motion does not follow a straight (radial) path to the center; it follows a spiraling path; this is called a vortex.' This is brought deeper into the discussion of the forces of the vacuum, the effect of 'zero-point energy,' called the Casimir Effect, proposed by Dutch physicist Hendrik B. G. Casimir. 'In quantum field theory, the Casimir effect and vacuum force are physical forces arising from a quantized field.' Kemp further goes on to show the relationships using algebraic equations.

An analytical critique of the examples of Robert Louis Kemp's work in a book review is like taking all of Mozart's music and summarizing it into a 30 second sound bite. Kemp writes concisely and cohesively on Einstein's Theory of Relativity, further explaining the relationships of gravitational force, energy, matter and time with countless drawings, equations, and formulas. This book is not to be read in one sitting, but to be savored, chapter by chapter preferably by a discussion group or class, and used as a foundation for further discovery. I have found nothing to contradict or state any opposing comments.

I will reiterate the tools described by Kemp, as stated in his Prologue, 'For me, the mathematics of physics, are the tools that God gave man that he may understand, describe, and predict the great works of God's created universe.' This textbook style book has hundreds of 'white board' equations, numerous expertly diagramed illustrations, and an index precisely affording the reader access to the points of reference within the text by subject. The reader will understand the relationships between such abstract forces and be able to compute the solution of an unknown variable based upon known formulas. His work is recommended for college level classroom studies, independent learning, and as a satisfying source of information for the curiosity within all of us. Robert Louis Kemp takes these tools and in this, one of his series of publications, Super Principia Mathematica: The Rage to Master Conceptual & Mathematical Physics -The General Theory of Relativity becomes a man and with a clear, cognitive vision describing God's universe to all fellow men.

You can purchase Super Principia Mathematica: The Rage to Master Conceptual & Mathematica Physics from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

jsuda writes "You've got to have a lot of confidence and nerve to write and try to sell a nearly 400 page book on cooking to the take-out pizza and cola set. No cookbook is likely to turn many geeks into chefs or take them away from their computer screens. However, even though Cooking for Geeks contains a large number of recipes, it is not a conventional cookbook but a scientific explanation of the how and why of cooking which will certainly appeal to that group, as well as to cooking professionals and intellectually curious others." Read on for the rest of jsuda's review. Cooking for Geeks: Real Science, Great Hacks, and Good Food author Jeff Potter pages 432 publisher O'Reilly Media rating 9/10 reviewer jsuda ISBN 0596805888 summary an excellent and intriguing resource for anyone who wants to experiment with cooking The author is a geek himself and brings "geek-like" approaches to the subject matter - deep intellectual curiosity, affinity for details, appreciation of problem solving and hacking, scientific method, and a love of technology. What is even better is his filtering of cooking concepts by a computer coder's framework, analogizing recipes to executable code, viewing of ingredients as inputs and as variables, running processes over and over in a logical manner to test and improve outcomes. This is not a mere literary shoe-horning of cooking concepts into a coder's framework but an ingenuous approach to the topics that should loudly resonate with geeks.

The subject matter includes selecting and using kitchen and cooking hardware; prepping inventory; calibrating equipment (especially your oven, using sugar); understanding tastes and smells; the fundamental difference between cooking and baking (and the personality types which gravitate to one form or the other); the importance of gluten and the three major types of leavening (biological, chemical, and mechanical); the types of cooking; using time and temperatures; how to use air as a tool; the chemistry of food combinations; and very thorough and detailed discussions of food handling and safety. The book is organized into seven chapters and includes an appendix dealing with cooking for people with allergies. The recipes are indexed in the front of the book.

The major conventional flavor types of salt, sugar, acids, and alcohol have been supplemented by modern industrial elements - E- Numbered (a Dewey decimal system-like index) additives, colloids, gels, foams, and other yummy things! All are itemized, charted, and explained in the chapter entitled "Playing with Chemistry." A whole chapter (and an interview with mathematician, Douglas Baldwin) is devoted to the latest and greatest food preparation technique - sous vide - cooking food in a temperature-controlled water bath.

Threaded through the sections are short sidebar interviews of mostly computer and techie types who are serious cooks or involved in the food industry. Some of these contributors are Adam Savage (of Myth Busters fame) on scientific technique, Tim O'Reilly (CEO of the book's publisher) on scones and jam, Nathan Myhrvold, on Moderist cuisine, and others. Other interviews deal with taste sensitivities, food mysteries, industrial hardware, pastry chef insights, and many more. There is an insightful section just on knives and how to use and care for them.

Anyone who is interested in cooking will learn from this book. I now pay attention to things I've never heard of before: browning methods like caramelization and the Maillard processes, savory as a major taste, transglutaminase (a.k.a. meat glue), for example. There is stuff I didn't really want to know - "if you've eaten fish you've eaten worms."

Although one of the strengths of the book is the systematic organization, there are useful tips spread throughout. For example, keeping a pizza stone permanently in your oven will help even out heat distribution; storing vegetables correctly requires knowing whether they admit ethylene gas or not (a chart is included); you can test your smell sensitivity profile by using a professional scratch and sniff test kit obtainable from the University of Pennsylvania. Whatever specialized information not contained in the book is referenced to external sources, especially on the Internet.

If all of this is not stimulus enough for the geek crowd, how about learning how you can spectacularly kill yourself cooking with dry ice, liquid nitrogen, blowtorches, and especially an electrocuted hotdog. Cool! This is mad scientist stuff. Engineering-minded types can learn how to make their own ice cream machine from Legos. You'll also learn how NOT to kill your guests with bacteria and other toxins.

The production is nicely done with easily readable text, plentiful drawings and charts, color captions, and many other quality production features. Weights are based in both grams and US volume-based measurements.

You can purchase Cooking for Geeks: Real Science, Great Hacks, and Good Food from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RichardSanders writes "This recent publication provides an accessible introduction to using Mahara within business and academic settings. It is great to see that the authors work for TDM, who provide Mahara & Moodle based solutions for a broad range of clients. This professional experience has contributed to a coherent and easy to follow text that provides essential information for new users. This comes as no surprise, as many individuals within the academic sector regularly benefit from Derrin's advice within mailing lists concerned with educational technologies." Keep reading for the rest of Richard's review. Mahara 1.2 ePortfolios: Beginners Guide author Derrin Kent, Richard Hand, Glenys Bradbury and Margaret Kent pages 264 publisher Packt Publishing rating 9/10 reviewer RichardSanders ISBN 978-1-847199-06-5 summary This book will provide you with step-by-step instructions to get started with Mahara and create an impressive electronic portfolio. Covering key functionality that the reader should be aware of, the book comprises of 7 main chapters dealing with reasons for using Mahara, setting up an account, adding artefacts, creating portfolio views, creating & managing groups, interacting with friends, overall site settings and administration. TDM have also provided an installation of Mahara for readers of the book to interact with, if they do not have access to an installation of their own.

Looking at this from the perspective of higher education, I can see this publication being used in two main ways. Academics can dip in and out of the publication to cement their understanding, and it can also be used in formulating support for students who are using Mahara for the first time. For both of these purposes, the authors' previous experience of writing instructional text for technology shines through, with flowing informal writing that is easy to digest and a logical, stepped approach to introducing each of the key features. Use of screenshots is intelligently done and you are provided with questions to test your understanding within every chapter. I particularly liked the 'Have a go hero' sections provided throughout the book, which are designed to encourage deeper investigation by the reader.

Other highlights include Derrin's example of a multi-page Mahara view, an easy to understand explanation of tagging. It's great to see the authors highlighting the importance of folder structures for files that you may store online. The publication also deals with quality checklists for information that you publish online, which is important to consider from an accessibility perspective.

For a new edition, there are only a few improvements that the authors could consider. The main area for improvement relates to the provided case studies, which are referred to at appropriate points within chapters. These are designed to illustrate how Mahara functionality can be used in particular situations and they manage to fulfill this purpose. This useful idea could be significantly enriched if case study examples were integrated into TDM's companion Mahara installation for readers to access. This would also help to encourage active community involvement around the installation, which could bring further collaborative benefits between readers in the future. It is also worth mentioning that the index could be improved for those that want to dip in and out of content.

I can whole-heartedly recommend this publication to anyone who is intending on using Mahara for the first time. If you need a more general academic justification for using ePortfolios or are looking for a way to compare the different solutions available for use, you would be better off looking somewhere else. This book is unashamedly for those who have already considered this and have come to the conclusion that Mahara is the best fit. With the close integration of Moodle with Mahara on the horizon, using this book to learn the basics becomes a no-brainer for those who already have this popular open source VLE.

You can purchase Mahara 1.2 ePortfolios: Beginners Guide from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

johhnyb writes "PrestaShop 1.3, Beginner's Guide by John Horton does exactly what is suggested by the title in that it provides a comprehensive and detailed guide to novices looking to set up their own online shops. While it is aimed at total beginners it never talks down to the reader and neither does it merely scratch the surface of the topic requiring you to go off and search for the real valuable information somewhere else. This book takes you from clueless beginner (which I undoubtedly was) to someone equipped with the knowledge, resources and additional support to be quite confident in setting up an effective online retail presence (which I believe I now am)." Keep reading for the rest of johhnyb's review. PrestaShop 1.3 Beginner's Guide author John Horton pages 308 publisher Packt Publishing rating 9/10 reviewer johhnyb ISBN 1849511144 summary covers all you need to know about starting your own e-commerce business. From the beginning, I was caught by the evident enthusiasm of the author and the fact he is clearly such an expert on the subject. I also liked the fact that he laid down his 'seven day challenge' and included some excerpts from his own 'story' throughout the book. Anyone who has even a faint idea about selling products online would undoubtedly benefit from this book as it gives you not just the technical information but the business input too. Likewise, if you already have an idea of what you want to sell and why it is a good product then you have a complete technical guide as to how to make that happen.

It actually helps if you have at least a certain comfort level with some simple computing basics, but even if you don't the processes described are in sufficiently layman's terms to make it easy for almost anyone. I can be quite confident in saying that this book contains pretty much everything you will need to set up a sophisticated and successful online shop. It doesn't go crazy though and go off on any disingenuous tangents by, for example, trying to explain Content Management Systems or some other equally esoteric topic. Overall, I think an excellent balance is achieved.

PrestaShop 1.3, Beginner's Guide is written in a very chatty and engaging style and the author's personality comes through loud and clear — you really do feel like he wants to make it as easy as possible for you to succeed. It is always down-to-earth and although the author clearly knows his topic well, he does go to great lengths to take everything step by step and make it as absolutely logical as possible. The level of detail is sufficient if you have never covered the particular task before.The addition of screen shots is also very convenient and makes the process easier. The 'What just happened' section is particularly good and there are plenty of reassuring summaries throughout so you can feel the book is not just running away with itself and the reader can keep recycling and reprocessing the information. Most importantly, he has done it himself and made a success of it. He has set up over 10 online shops, has been through all the different options, experienced the pitfalls, the highs and lows, and is passing on the very best information and advice possible to a new lucky group of shop owners.

I found the book full of very solid advice which could applied in many settings. It is also a great introduction to some of the most modern forms of online marketing including the use of Twitter, Facebook, and Google Adwords. One thing I liked was John's regular reference to the need for a strong, viable business case. Prestashop is a magnificent product but will totally fall flat if your basic offering does not create a customer which Peter Drucker famously said was the purpose of business. It is too easy to fly into the detail of a business before taking time to fully understand your Unique Selling Proposition (USP) and why people buy from you. Likewise, the author also covers key and hard-to-grasp issues like Search Engine Optimization which I think he correctly identifies as something readers will need to understand.

I can honestly say that PrestaShop 1.3, Beginner's Guide covers everything you will need. Not only that, John refers to several free resources he himself has written and provides an extensive list of resources at the end of the book.This book is almost encyclopedic in its treatment of how to set up and use Prestashop and it is certainly something that can used in that way. You don't only get Prestashop related material you also get a lot of valuable business advice, of course in a Prestashop context.Another benefit readers will receive is regular pointers to where they can find other free resources also written by the author.

I have to state clearly that John is a long-term friend of mine — to give you an idea we go back to those halcyon days of the Spectrum ZX-81 and the Commodore 64 — yes, we are getting on. Bearing this in mind, I have done my best to write something honest and useful to potential buyers of this book. Although he plays it down, John has always been marvelous with computers and able to effortlessly explain complex technical issues to me, a relative technophobe. Therefore, it does not surprise me he has written something so useful, practical and frankly inspiring.

You can purchase PrestaShop 1.3 Beginner's Guide from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

frisket writes "Definitive guides by the authors or maintainers of software systems tend to have the edge over other documentation because of the insight they provide. DocBook 5 — The Definitive Guide comes well up to scratch. DocBook has long been the de facto standard for computer system documentation in XML (and SGML before that), and Norm Walsh has revised and updated both the language and the documentation in a concise and valuable form, usable both by beginners and by tech doc experts." Read on for the rest of frisket's review. DocBook 5: The Definitive Guide author Norman Walsh pages 560 publisher O'Reilly in conjunction with XML Press rating 9/10 reviewer frisket ISBN 9780596805029 summary Examines and catalogs the entirety of the DocBook specification. DocBook is a rich XML vocabulary, primarily for the documentation of software systems. It provides markup both for the structure of your documents and for the descriptive detail of your writing, to an extent that few other XML systems match. Like XML itself, DocBook's popularity rests on its robustness, scope, and extensibility; and Walsh makes it clear that the Technical Committee has tried hard to balance stability and adaptability in releasing a new major version which does have a few backward-incompatible changes.

This is a reference book, so the initial chapters (1-5) are short (70 pages) but full of clear explanations of how DocBook works, what it does, and how to use it. Part II is 400 pages, covering every element type in the language, with a detailed description of what it is for, how and where to use it, and how it interacts with everything else. Both for the beginner and the expert, these descriptions are the key to effective use, and Walsh's explanations are clear and comprehensive.

For those of you who have been using DocBook in earlier incarnations, the changes are not deal-breakers, and many of them are welcome rationalizations of the way things have grown organically over the years. It still walks like a duck and quacks like a duck (and the book still has a duck on the cover), so it immediately feels like the same format that you're used to — the changes to element types are relatively few. Chapter 1 (Getting Started) has a brief history, a summary of the changes, and an explanation of the namespace and availability.

If you've never used DocBook before, its structure will still be familiar: in Chapter 2 (Creating DocBook Documents) Walsh explains the division of reference material like books, articles, and manuals into chapters, sections, and subsections, with all the conventional features like lists, figures, tables, and references, as well as the technically-oriented features like equations, programming constructs, interface descriptions, and code samples.

There is help in Chapter 3 (Validation) for those who construct or generate DocBook documents without the use of an XML editor (or even with them: more on editors below). The most common problems with misplaced markup (and the error messages they create) are clearly explained with examples.

Chapter 4 (Publishing) very briefly explains the role of stylesheets (CSS, XSL, and XQuery) in displaying and transforming your documents to other formats, but as these all have their own books and manuals, this book doesn't go into them in any detail.

Customizing DocBook is fairly commonplace, either to avoid the need to commit tag abuse, or to extend its structure into other fields (I added a new element type for typographical examples for my book on LaTeX, and it only took a few minutes). Chapter 5 provides some rules and explanation of customization layers and modularity for those who design schemas and DTDs.

The five Appendixes cover Installation, Variants, Resources, Interchange, and the GNU Free Documentation License — yes, you can read the whole thing online at docbook.org, for which Tim, Norm, and many others are to be thanked. It is a rare publisher who groks the need to be able to point someone at a reference, or quote it in email or a tweet, where a paper copy doesn't cut the mustard.

There isn't anything here about actually using an XML editor or about how to choose one. Editors do of course all come with their own documentation (much of it written using DocBook) and editor selection can be a complex business. However, there is a list of some common tools in Appendix C (Resources). Editors are a minefield, as my own research into the usability of editing software for structured documents is showing, so I can understand the omission, but some pointers to editor resources would have been useful.

The chapter on Publishing is useful for those who haven't been in the publication process before, but it could have emphasized more the need for accuracy and consistency. Experienced technical authors know this, but many other writers don't see the need for it, assuming that the publisher (or some elf) will automagically heal everything before publication. DocBook 5 and this book will help enormously, but author-edited documents sometimes unwittingly misuse or abuse the markup, no matter how exhaustive the manuals.

If you write computer documentation, or anything related to it, from a conference paper to a thesis to a book, DocBook 5 is probably what you should use if you want the document to survive and to be usable and reusable; and this is the book to help you do it.

You can purchase DocBook 5: The Definitive Guide from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Albert Schueller writes "Lulu is a place where authors can self-publish their books. It's a nice response to exorbitant college textbook prices. In an interesting twist, looks like you might be able to get away with selling other people's books on Lulu and reap a tidy profit. The Lulu offering Calculus Twirly Exponentials by Dave Stuart appears to be simply a high quality scan of the much more well-known, and expensive, Calculus: Early Transcendentals 6th ed. by James Stewart. Compare the preview images available for each at Lulu and Amazon respectively."

Trevor James writes "Finally, here's a Drupal book specifically for Drupal content editors and site managers, those folks responsible for posting new content and editing existing content on a Drupal site. While many of the Packt series of Drupal books focuses on code, development and are written for Drupal developers, this title is for anyone who is dealing with management of Drupal based content and any individuals or teams responsible for the management of Drupal sites on a daily and hourly basis. This book is also perfect for introductory Drupal classes and I will not hesitate to use it in my Drupal 101 classes in the near future." Read on for the rest of Trevor's review. Drupal 6 Content Administration author J. Ayen Green pages 179 publisher Packt Publishing rating 9/10 reviewer Trevor james ISBN 1847198562 summary A fun, informative, hands-on learning guide that uses an actual case study In Chapter 1, the author gives a concise and streamlined introduction to the Drupal CMS and the elements of a Drupal Web site from both the frontend and backend perspectives. I liked seeing the detailed explanations of a Drupal powered front end layout — explaining the differences between the site header, navigation areas, and content areas. I'd recommend this first chapter to anyone who is just starting to use Drupal and wants a basic introduction to the Drupal framework. It's hard to emphasize how important it is to understand the basic intro level concepts and functionality of the Drupal CMS and its all here in this intro section. To any of my intro Drupal users I would hand this chapter out and ask them to read it.

Chapter 2 moves into a detailed discussion of Drupal-based content and asks the simple question (but important one), what is content? In Drupal we know that content includes nodes and node types, node IDs (nid), comments, Blocks, and Views. The author defines the core node types including Story and Page. Note here to Drupal 7 users ... the story type is renamed "Article" and the Page type is "Basic Page" in the new D7 release. I also love the fact that Green defines what the Drupal front page or home page is and what that home page contains. I am asked this question all the time by new Drupal users — how do I post content to my home page and how do I customize the home page. Read the definition on p. 19 of this book.

At this point I'd encourage those readers who are using the book to go ahead and start creating content on their Drupal site following the author's instructions. It's a great book of examples of tutorials to follow along with hands-on. The author gets you creating story content and editing it quickly. He also spends a good deal of time discussing integrating a WYSIWYG text editor to your content node form so you can use the text editor buttons to format content.

Chapter 3 continues the content discussion by showing you a bunch of enhancements you can do to your posted content. The author aptly calls these "seasonings". This includes creating teasers, creating links to other node content using the text editor, uploading images using the text editors and manually via the Drupal node editor, linking your images, embedding audio content, and linking to downloadable files such as PDFs. My only concern here is that the author shows you how to link to PDF files via the text editor but there's actually simpler methods of doing this in Drupal using Drupal's default file attachments module (part of core). This is the preferred method since it easily opens up the attached file to be used in other areas of your site via the Views module for instance. I always encourage Drupal users to add attached files using the core Drupal file attachments since I think it's simpler and more streamlined and it's the "Drupal" way of attaching files. I would add this method first and then show the text editor option second.

The author shows us how to upload and embed video content using SWF Tools module. I would have spent a bit more time in this chapter showing the user more details about uploading Flash based content using a combination of the Flash node and the SWF tools modules and integrating various player options in SWF Tools such as the Flowplayer utility. But again these are technicalities. The information the author presents is great and detailed. It's a good starting point for more beginning Drupal users.

Chapter 4 moves into more advanced content editing topics. The author shows you how to use HTML and CSS to create table based layouts (without using table code) in your text editor and in a Drupal node. So for everyone who needs an introduction to CSS this is a great place to start. The author spends time showing us how to add the CSS files so they are recognized by our Drupal theme — this is going to be a bit more advanced for the new Drupal user but its good stuff to learn. He even shows us how to create a CSS file from scratch and how to build the table layout without using table code. Sticking to CSS is going to give you cleaner code and work better with Drupal so it's great that he emphasizes this here. For dealing with more table based code Green shows us some tricks to injecting this code using PHP. Again this is more advanced but good tips and tricks for those involved with code. He also shows us how revisions and workflow work in our Drupal site.

Chapter 5 deals with how to use tagging, tag clouds and how to re-name our URLs with human friendly path aliases using Drupal's core Path module. This will help our site become more searchable, browser and user friendly. Tagging is the focus here and he gives a nice walkthrough of Drupal's taxonomy system. Anyone interested in setting up tagging on their Drupal site should read this chapter. Chapter 6 moves into using Blocks, Views and setting up Blogs on your site. This chapter is the one to read if you're managing blocks and Views and want a good introduction to the Views module. Packt has published books specifically on using Drupal Views but I would start here first if you're just using Views for the first time.

The section on blogging is good too. Often I hear folks report that Drupal is only a fancy blogging tool or blogging application. This book actually shows that Drupal is a full scale and robust CMS and that blogging is only one minuscule part of the entire framework. If you're just going to be blogging on your site Drupal may actually be overkill. The author shows this by spending a smaller amount of time showing you how to set up your Drupal site for blogs, but of course it also shows you that Drupal does blogs too and you can easily use a Drupal site to just blog. I would argue that this is a great book to look at the overall impact of Drupal on building Web sites and how we can leverage it to build powerful, rich and robust content management driven sites. We can add a blog if we want to but it's not just a blogging-based piece of software.

Chapter 7 deals with setting up users, roles and permissions on your site. It's good to leave this chapter towards the end of the book since Drupal permissions can be a bit tricky and time consuming to set up. We moved through a bunch of fun material earlier in the book and now we have a chapter on permissions. I like the attention the author placed on how to organize this section into the overall book's theme and layout. Chapter 8 shows you some tricks for dealing with issues like pasting Word content into a Drupal node; and using the Blog API module to work on blog posts in remote software and then post those blog entries to your Drupal site via a Web service. A nice touch here to add a small section on using Web services to post content. Finally the Appendix shows you how to install Drupal.

This is definitely one of the best books I've read on Drupal from an introductory standpoint. It's up there with O'Reilly's Using Drupal book and I would recommend it to anyone who is installing Drupal for the first time. I'll use it in my introductory Drupal classes for sure. It will be nice to see this book revised for Drupal 7 soon. Excellent work again from J. Ayen Green.

You can purchase Drupal 6 Content Administration from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

eldavojohn writes "Beautiful Data: The Stories Behind Elegant Data Solutions is an addition to six or so other books in the 'Beautiful' series that O'Reilly has put out. It is not a comprehensive guide on data but instead a glimpse into success stories about twenty different projects that succeeded in displaying data — oftentimes in areas where others have failed. While this provides, for the most part, disjointed stories, it is a very readable book compared to most technical books. Beautiful Data proves to be quite the cover-to-cover page turner for anyone involved in building interfaces for data or the statistician at a loss for the best way to intuitively and effectively relay knowledge when given voluminous amounts of raw data. That said, it took me almost two months to make it through this book, as each chapter revealed a data repository or tool I had no idea existed. I felt like a child with an attention deficit disorder trying my hand at nearly everything. While the book isn't designed to relay complete theory on data (like Tufte), it is a great series of short success stories revolving around the entire real world practice of consuming, aggregating, realizing and making beautiful data." Keep reading for the rest of eldavojohn's review. Beautiful Data: The Stories Behind Elegant Data Solutions author Edited by Toby Segaran and Jeff Hammerbacher pages 384 publisher O'Reilly Media, Inc. rating 9/10 reviewer eldavojohn ISBN 978-0-596-15711-1 summary A collection of twenty essays and chronicles from the implementers of successful projects revolving around real world data processing and display. Since the individual articles in this book are essentially a series of what to do and what not to do, this review is more like a list of notes that were my personal rewards from each chapter. Given my background, these notes will be very specified to my interests and responsibilities for web development whereas a statistician, academic or researcher might pull a completely different set from the book. The book also has a nice colorized insert that allows the reader to get a better sense of the interfaces discussed throughout the book. One potential problem with these "case studies" is that they will most certainly become dated — and in our world that happens quite quickly. It's very easy for me to think that specific information about colocation facility usage by social networking sites (Chapter Four) will always be useful and relevant. The sad fact of the matter is that because of the unforeseen nature of hardware advancements and language evolution, many of these stories could become irrelevant blasts from the past in one or two decades. I think the audience that stands to benefit this most from this book are low level managers and people in charge of large amounts of data that they don't know what to do with. The reason for this is that while there are a few chapters that deal with low level implementation details it mostly consists of overviews of popular and successful mentalities surrounding data. One other type of audience that might be a target for this book would be young college students with interests in math, statistics or computer science. Had I picked this book up as a freshman in college, no doubt the number of projects I worked late into the night on would have multiplied as would my understanding of how the real world works.

Chapter One deals with two projects done by grad students: Personal Environmental Impact Report (PEIR) and your.flowingdata (YFD). This chapter starts out slow describing how the system harnesses personal GPS devices — a common trend in phone development these days. After clearing the basics, the chapter reveals a lot about the iterative developments the author took to select and include a map interface to effectively and quickly display several routes that a user has driven with intuitive visual queues to indicate which was the most environmentally expensive. Trying to stick with the green means good and red means bad proved difficult and they employed an inverted map of mostly shades of gray to avoid clashing colors with the natural colors on a regular map. The final part of PEIR discussed a Facebook application that simply paired you up against friends also using PEIR. This gave the user a relative value basis of otherwise incomprehensible numbers surrounding their environmental impact. YFD focuses more on an interface for accumulating Twitter data from a user to help them track sleeping and weight loss.

The second chapter deals entirely with constructing a very simple survey that has a variable length depending on what answer you give to an earlier question. While this seems to be a very simple task, the chapter does a great job of explaining how you can make it better and why doing this makes it better. A great quote from this chapter is "The key method for collecting data from people online is, of course, through the use of the dreaded form. There is no artifact potentially more valuable to a business, or more boring and tedious to a participant." The chapter points out that for every action you require the user to make, the user may decide the survey is not worth their time. Yes, clicking "Next" on a multi-page form only gives the user another chance to decide this isn't worth it. Furthermore, many pages might cause the user to be unsure of the real length of the survey. So they decided against this and instead made the survey branch from one page so that page would continually get a little larger depending on how you answered the questions. Knowing the targets for the surveys were older made a copy large font mandatory as 72% of Americans report vision impairment by the time they are age 45. This chapter dealt more with collecting the data, respecting the source of data and building trust with the participants than displaying the data they provided.

Chapter Three deals with the recently disabled Phoenix that landed on Mars and how precisely the image collection was done. While it might seem like the wrong place to do it, there was actually pre-processing and compression done on board the lander before transmission to Earth. This article tackles interesting issues that are long thought to be an extinct animal in computer science where resources are constrained and radiation bombarding keeps the CPU modestly lower than your average desktop. Do you process the image in place in memory or make a copy so that the original image can be retained during processing? These are familiar issues to embedded developers but stuff I haven't touched since college. While the author details the situation on all fronts down to the cameras being used, it's largely a blast from the past as far as resource aware computing is concerned. Then again, I doubt any of my code will ever be flight certified by NASA.

Chapter Four has a very interesting analysis and description of Yahoo!'s PNUTS system for serving up data in complex environments like tackling issues with latency across the world when dealing with social networking. The chapter does a decent job of explaining how issues are resolved when replicated servers across the United States become out of sync and the resolution strategy. The chapter ends on an even more interesting note explaining why Yahoo! deviated from Google's BigTable, Amazon's Dynamo, Microsoft's Azure and other existing implementations. This tale of well thought out design is a stark contrast to Chapter Five which centers on a Facebook 'data scientist' that — instead of explaining the solution as a well planned finalized implementation — tells the trial and error approach of a very small team of developers treading into waters unknown with data sets of Sisyphean proportions. It was tempting for me to read this chapter and chastise the author for not foreseeing what numbers could come with making it big in social networking. But the chapter has a lot of value in a "lessons learned" realm. It may even prepare some of you who are writing web applications with a potentially explosive or viral user base. While it's popular to hate Facebook and in turn transfer that hate to the developers, no one can argue against them being one of the most successful social networking sites and any information of their (sometimes flawed) operations certainly proves to be interesting.

Chapter Six was completely unengaging for me. The chapter covers geographing. More specifically the efforts to take pictures of Britain and Ireland and map/display them geographically. The images would aim to cover a large area than users could tag them with what they see (tree, road, hill, etc). Unfortunately it never really registered with me why someone would want to do this and what the end goal was that they were aiming for. Instead they managed to produce some pretty heinous and very difficult to digest heat maps or "spatial tree maps." By embedding coloration and lines into the treemaps the authors hoped to convey intuitive information to the reader. Instead my eyes often glazed over and sometimes I flat out disagreed with their affirmation that this is how to display data beautifully. You're welcome to try to convince me that geographing has some sort of merit other than producing pretty mosaics of large image sets but it took a lot of effort for me to continue reading at points in this chapter.

Chapter Seven sets the book back on track in "Data Finds Data" where the writers cover very important concepts and problems surrounding federated search and instead offer up directories with some semantic metadata or relationship data that makes keyword searching possible over billions of documents. For anyone dealing with large volumes of data, this chapter is a great start to understanding the options you have to processing your data when you first get it (and only once) versus searching for that data just in time and paying for it in delay. While the former incurs much more disk space cost, Google has proven that paradigm shift definitely has merit.

Chapter Eight is about social data APIs and pushes gnip heavily as the de facto social endpoint aggregator for programmers. The chapter mentions WebHooks as an up and coming HTTP Post event transmission project but doesn't offer much more than a wake up call for programmers. The traditional polling has dominated web APIs and has lead to fragile points of failure. This chapter is a much needed call for sanity in the insane world of HTTP transactional polling. Unfortunately, the community seems to be so in love with the simplicity of polling that they use it for everything, even when a slightly more complicated eventing model would save them a large percentage of transactions.

Chapter Nine is a tutorial on harvesting data from the deep web. What they mean by this is that — given proper permission — one can exploit forms on websites to access database data and then index that instead of merely being relegated to static HTML pages. In my opinion, this is a fragile and often frowned upon approach to data collection but as this chapter (and many others) illustrates, sometimes data is locked up due to lack of resources to expose it. This means that if a repository of information is meant to be available to you through a simple submission form, you can tease that information out of "the deep web" and into your system with the tricks mentioned in this chapter.

Chapter Ten is the story of Radiohead's open sourced "data" music video of "House of Cards" and the collection process from the kinds of devices used to the methodology of collecting that data to the attitude they used when treating the data. This chapter is a sort of key for understanding what data you have with Radiohead's offerings and I heavily recommend it for anyone interested in taking a stab at this video. The most interesting things I found in this was their method for collection and, more importantly, their decision to actually degrade the data and opted not to texture when displaying Thom Yorke's face — citing artistic choice. This chapter gave me one very amazing display tool that I am embarrassed to admit I had no knowledge of prior to this book: processing.

Chapter Eleven is the story of a few people that chose to do something about serious crime problems in Oakland. The city was compiling reports of crimes weekly but they weren't opening up the data. You could do a search and get a very minimal display on a map of crimes that had happened. This caused Oakland Crimespotting to arise. At first they were forced to graphically scrape and estimate crime locations so their own system could offer it back to the user in more intuitive and useful ways to the citizens so the citizens could take action. At first they were forced to work around problems but in the end the city government came to its senses and began offering them the data in a far more open format. From browsing the site now, you can get an idea of the tale this chapter tells. The evolution of that end product is chronicled in this chapter.

Chapter Twelve center's on sense.us, a potentially powerful product that aims to empower users to analyze and create notations on graphs that might relay correlations between factors inside US Census data. The only disappointment with this chapter is that sense.us isn't live for us to use. The tool shows powerful abilities in collaboration in analysis of census data but also is a double edged sword. There's nothing that stops this tool from being used for political and monetary ideals instead of purely academic revelations. They used tools like Colorbrewer and prefuse to dynamically generate graphs and charts that were pleasing to the eye. Then they used 'geometric annotation' (a vector graphic approach to recording user's doodling and annotations) in order to facilitate collaboration. The notes the researchers took on the collaboration between their pilot users is probably more intriguing than their actual approach to display good graphics. Each user seemed to take a natural progression from annotation producer to annotation crawler and then bounce between them as other user annotations gave them ideas for more annotations to create. While not exactly ideal collaboration, it's interesting to hear what users do in the wild when left to their own.

Chapter Thirteen "What Data Doesn't Do" is a very short chapter with a set of ten or so rules that are intended to remind you that data doesn't predict, more data isn't always better or easier, probabilities do not explain, data doesn't stand alone, etc. This chapter felt sort of like a pause and remember way point through the book. Just when you've gone through these great stories of success, the book, reels you back into reality with this chapter. In other chapters you'll be reminded to avoid pitfalls like the narrative fallacy but this book just reminds you quite literally what data doesn't do automatically for you. It's an indicator that you need to shore up these things that data doesn't magically do when you present data.

Chapter Fourteen is Peter Norvig's "Natural Language Corpus Data" and does not disappoint. Once the reader is empowered with the code and the data in this chapter, it almost seems like one could solve several problems using ngrams, Bayes' theorem and natural language analysis. As you read this chapter, Norvig lays out how to tackle several problems with ease: decoding encryption levels up to WWII, spelling correction, machine translation and even spam detection. In just 23 pages, Norvig conveys a tiny bit of the power of a corpus of documents coupled with the willingness to be a little dirty (total probabilities summing to more than one, dropping ngrams below a threshold, etc). It's clear why he's employed at Google.

Chapter Fifteen takes a drastic turn into one of Earth's oldest data stores: DNA. As the chapter so coyly notes, programmers can view DNA as a simple string: char(3*10^6) human_genome; The chapter gives you a brief glimpse of DNA analysis but focuses more on the data storage involved in facilities that are currently working to harvest data from many subjects. As of the writing of this chapter, one facility was generating 75 terabits per week in raw data. Most interesting to me from this chapter was ensemble.org, a site to find DNA data, genome data and also collaborate with other researchers on annotating and commenting on certain parts and regions of DNA.

Similar to the previous chapter, Chapter Sixteen focuses briefly on chemistry and describes how data was collected "to predict teh solubility of a wide range of chemicals in non-aqueous solvents such as ethanol, methanol, etc." Having a very minimal chemistry background, it's never really revealed what purpose this data collection has but nonetheless the chapter explains a lot of challenges in this environment that are similar to other chapters. The interesting aspect of this chapter is that the team used open notebook science to collect this data and therefore faced the challenge of cleaning crowd-sourced data. A constantly recurring problem in these chapters is how one represents data and chemistry apparently has many standards — some more open than others. This book makes a very good argument for open standards and selecting open standards when one witnesses the screen scraping, licensing issues and costs researchers face when unifying data even for something as old as the representations of chemicals.

Chapter Seventeen is the case study of FaceStat, a statistically more ambitious Hot-or-Not effort from researchers. The site would allow anyone to upload a photo of a person and then allow users to rate them and tag them. After collecting this data, the researchers used the ubiquitous R statistical language to do some feature extraction on the data. Of course, the chapter first deals with cleaning the data and catching bad user input. While this chapter sounds like vanilla run-of-the-mill feature extraction, it also includes some interesting display examples as well as the very interesting yet controversial stereotype analysis. From taboo topics like attractiveness vs age line fitting to the sexism of tags to using k-means in order to establish stereotype clusters in the data. While other chapters sought offense through possible privacy concerns, this chapter reveals more about the callow stereotypes that internet inflict upon each other.

Chapter Eighteen looks at the San Fransisco Bay Area housing market from a very interesting selection of recent years. What differentiates this chapter from so many of the others (we collect, clean and process the data) is that it needed to break the data down by neighborhood to find the really interesting features of the data. The neighborhoods could then be grouped into six different groups with their increase in house prices to their decline in house prices. Only one group had one neighborhood that showed no decline (Mountain View). Unfortunately for this chapter and the next one, by the time the reader arrives they appear to be straight forward replications of ideas from other chapters. Chapter Nineteen is brief chapter on statistics inside politics. Aside from revealing five or six interesting correlations in voting revealed through data, this chapter merely relays what we already know: politicians implement statistics to a sometimes harmful degree (gerrymandering).

The last chapter is, appropriately, about the many sources of data exposed on the internet and the problems everyone faces in matching entities from one data source to another. The idea of using a URI to describe a movie hasn't really seemed to catch on. And if that wasn't enough, even words like "location" used to describe a column could mean drastically different things between houses and genomes. The chapter lists out a number of sources where data is available to download and tinker with (most already listed in the book) and proceeds to analyze an algorithmic (collective reconciliation) way for a system to differentiate between two movies with the same name. Naturally the author of this chapter worked on freebase which was recently (and predictably) acquired by Google. Although a short chapter, it speaks to problems that all online data communities face and what prohibits mashups from automagically happening between two disparate data sources holding data that is actually related.

With the exception of chapter six, every chapter offered me something that I won't forget. More importantly, most chapters offered a data source or data processing tool that expanded my toolbox of things to use when programming. The only reason this book misses a perfect 10/10 from me is chapter six and a couple of the later chapters feeling like weaker ideas from earlier chapters rehashed into a different domain. A worthwhile book if you work with data — whether you be a consumer or producer.

You can purchase Beautiful Data: The Stories Behind Elegant Data Solutions from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Trevor James writes "Plone 3 Multimedia is an excellent book focusing on adding multimedia including images, audio and video files to a Web site built using the Plone 3 CMS. Overall this book has a nice balance and mix of text, screenshots and code. I recommend the book for Plone power users including Plone developers and users who want to enhance and expand their core Plone multimedia arsenal. You'll get more out of this book if you already have a Plone site running but want to add more multimedia based capabilities to it." Read on for the rest of Trevor's review. Plone 3 Multimedia author Tom Gross pages 372 publisher Packt Publishing rating 8/10 reviewer Trevor James ISBN 1847197663 summary Focuses on adding multimedia including images, audio and video files to a Web site built using the Plone 3 CMS Chapter 1 gives us an intro to the Plone, CMS and multimedia universe with concise definitions of terms such as CMS, Zope architecture, Buildout, and multimedia and tells us why we should be using the Plone CMS to host and store multimedia content. Chapter 1 concludes with a look at the Plone4Artists project which extends the core Plone CMS to add multimedia rich features for musicians and artists who need powerful Web sites for their audio and image based content. Plone4Artists adds modules for handling images, audio, video, events and calendars, and tags.

Chapter 2 gets things started by using the Plone 3 CMS to post image content. The author reviews how we can leverage the Plone core Image type to post image files. While reading Chapter 2 I followed along with my own Plone 3 local install so I could work on the tutorials and recipes hands-on as the author presented them. I started out by adding some images to my Plone site and followed the author's instructions on transforming and resizing the image. Gross gives code-based recipes for restricting image dimensions and file size to a specific user. He also shows us how to access images using code in our page templates, via a Python code method, and how to add images to custom content types using code. There's a lot of code and detailed analysis provided just in the first 25 pages of the book and you really get your money's worth just from this chapter on image manipulation. This chapter will interest developers and users of Plone who want to dive into the code and find out how images are being manipulated behind the scenes.

Gross moves on to show us how to organize our images into views which are essentially folders that contain images. The folders provide thumbnails of our images and are clickable to larger scales. We learn how to post a page and then use the Plone Kupu text editor to browse for an image from our folders and upload that image to our page. Gross points out that you can search for images by keyword (and by using wildcards) within the Kupu editor — a powerful feature if you have a ton of images. Then he tells us how to customize various elements of Kupu functionality using code, including tweaking CSS. Gross shows us how to take the tweaks we've made and make them easily persistent across our site's functionality by creating a boilerplate. There's a lot of code in this section of chapter 2 and developers will get a lot of expert tips and examples here.

Having an interest in Web services and how to get image content from Picasa and Flickr into Plone and other CMS-driven sites I was pleased to see Gross show us how to enhance our images using the p4a.ploneimage product; and how to build galleries of our images using the collective.plonetruegallery product. Gross installs the product, configures it and then accesses Flickr and Picasa data. He concludes the chapter looking at another gallery product called slideshowfolder. Gross shows that there are lots of methods for enhancing your Plone site using images and displaying the images as rich interactive galleries.

Chapter 3 covers adding audio content to your site in the same exhaustive detail as the image chapter. I like the discussion of how to choose the best audio format for your Web site. Gross shows us how to enhance our audio player widgets on the Plone site using the p4a.ploneaudio product. There's a lot of detail provided on setting up metadata for our audio libraries and collections. Building custom audio players and using the Flowplayer, a commonly used Flash-based player on open source driven CMS sites. Gross even shows us differences between embedding audio content using HTML 5 vs. HTML 4 and he concludes the chapter building a player using HTML 5. Another exhaustively detailed chapter.

Chapter 4 gives us tutorials on adding video content, including streaming and embedding videos on your Plone site. Gross gives us a tour of the p4a.plonevideo product and the embed version of the product which allows us to embed externally hosted videos (from YouTube, Yahoo! video, and blib.tv). Flowplayer for videos is also presented. The chapter follows the same outline and format as the audio chapter.

Chapter 5 covers adding Flash content to your Plone site and a lot of background discussion on Flash and how best to embed Flash using the Kupu text editor in Plone. Various Plone based Flash products are discussed. Gross also discusses using Silverlight and adding Silverlight content to a Plone site. This is a great topic to be included in this title. Being a Drupal developer I'm hoping that there is more discussion soon in print titles on how to integrate Silverlight content with Drupal sites. So it's nice to see this topic in a Plone book.

Chapter 6 and 7 deal with general content organization concepts and best practices, and syndication opportunities for your Plone site. Gross gives examples of using Dublin core metadata; and managing content using Plone based categories and keywords. Setting up glossaries of content, tagging content and integrating GoogleMaps is also discussed. RSS and Atom are given detailed attention as well here. These chapters should interest any Plone user or developer since it deals with more general Plone concepts and not just focusing on multimedia.

Chapter 8 looks at more advanced upload strategies. Gross spends time showing us how to create bulk uploads on our site using products such as collective.uploadify. Muliuploads is a huge plus and benefit for using Plone as your CMS and this chapter will interest anyone who wants to get large amounts of images into their Web site. Following on this topic Gross tells us how best to store our files and content in chapter 9. Again this topic will be of great interest to site managers and administrators who are in charge of keeping tabs on where content is being hosted and stored. System and server administrators may find some enlightenment in this chapter for dealing with hosting large amounts of CMS-driven multimedia content. Finally chapter 10 covers performance issues including server optimization and site caching mechanisms.

The Appendixes contain a wealth of information for developers including explanations of multimedia formats and licenses. I appreciated Gross' definitions of various codecs and the differences between various lossless codecs and comparisons with lossy codecs. Just the detail on the MPEG-1 Audio Layer 3 and Ogg Vorbis is encyclopedic and I'd most likely look here first before going to another resouces like Wikipedia. There's a ton of good information on licensing and the differences between Creative Commons Attribution licenses, Attribution Share Alike, No Derivatives, Non-commercial and more.

Appendix B contains details and explanation of syndication formats including RSS, RSS 2.0 and Atom. Example XML files for both Atom and RSS 2.0 feeds are given. MediaRSS is also explained in great detail. Finally Appendix C gives links to a large amount of resources and tutorials on how to use Plone for multimedia and links to various segments of the Plone support community including IRC chat.

Overall I'm pleased with this title. It's another great open source and CMS based resource from Packt Publishing and Tom Gross has added required reading to the expanding library of titles on Plone. If you're a Plone user or developer geared towards working with a lot of multimedia content this book belongs in your collection.

You can purchase Plone 3 Multimedia from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

joel.neely writes "R is a statistical computing environment that is fully-compliant with state-of-the-art buzzwords: free, open-source, cross-platform, interactive, graphics, objects, closures, higher-order functions, and more. It is supported by an impressive collection of user-supplied modules through CRAN, the 'Comprehensive R Archive Network.' And now it has its own O'Reilly Nutshell book, R in a Nutshell, written by Joseph Adler. I am pleased to report that Adler has risen to the challenge of the highly-regarded 'Nutshell' franchise. As is traditional for the series, this title mixes introduction, tutorial, and reference material in a style that is well suited to a reader who already has a background in programming, but is a new or occasional user of R." Read on for the rest of Joel's review. R in a Nutshell author Joseph Adler pages 672 publisher O'Reilly rating 9/10 reviewer Joel Neely ISBN 978-0-596-80170-0 summary A practical and engaging introduction to the R statistical system and its usage As a curious newcomer to R who wanted to get going quickly, I was well-served by Part 1, which provided an R kickstart. Chapter 1 covers the process of getting and installing R. It is short, to the point, and just works, addressing Windows, Mac OS X, and Linux/Unix with equal attention. Chapter 2, on the R user interface, introduces the range of options for interacting with R: the GUI (both the standard version and some enhanced alternatives), the interactive console, batch mode, and the RExcel package (which supports R inside a certain well-known spreadsheet). Chapter 3 uses a set of interactive examples to provide a quick tour of the R language and environment, establishing a task-oriented theme that carries through the rest of the book. The last chapter of part 1 covers R packages. It summarizes the standard pre-loaded packages, introduces the tools to explore repositories and install additional package, and concludes by explaining how to create new packages.

As a polyglot programmer who is always interested in seeing how a new language approaches programs and their construction, I enjoyed Part 2, which described the R language. This section begins with an overview in chapter 5, and then devotes a chapter each to R syntax, R objects, symbols and environments (central to understanding the dynamic nature of R), functions (including higher-order functions), and R's own approach to object-oriented programming. This section closes in chapter 11, with a discussion of techniques and tips for improving performance.

As a busy professional with data sitting on my hard drive that I'd like to understand better, I appreciated Part 3, with its practical emphasis on using R to load, transform, and visualize data. Chapter 12 presented alternatives for loading, editing, and saving data, from the built-in data editor, through file I/O in a variety of formats, to a mature set of database access options. Chapter 13 illustrated a range of techniques for manipulating, organizing, cleaning, and sorting data, in preparation for presentation or more detailed analysis. Chapter 14 introduces the reader to the wealth of graphical presentation options built into the R environment. There are so many charting types and details that this chapter could have been overwhelming, but Adler keeps the interest high and the mood light by drawing on an engaging variety of data: toxic chemical levels, baseball statistics, the topography of Yosemite Valley, demographic data, and even turkey prices. Chapter 15 is devoted to lattice graphics, the R implementation of the "trellis graphics" technique for data visualization developed at Bell Labs. This chapter illustrates the power of lattice graphics by exploring the question of why more babies are born on weekdays than weekends.

As a non-statistician who still occasionally needs to do some number-crunching, I'm sure I'll be returning to Part 4, with its detailed explanations and illustrations of analysis tools and techniques–almost two-hundred pages worth. In chapters 16 through 20, Adler surveys topics in data analysis, probability, statistics, power tests, and regression modeling. As someone who has been offered too many medications and lost fortunes, I found much to enjoy in chapter 21, which used a variety of spam-detection techniques to illustrate the concepts of classification. Chapter 22, on machine learning, discusses several of the data mining techniques that R supports. Chapter 23 covers time series analysis, which may be used to identify trends or periodic patterns in data. Finally, chapter 24 offers an overview of Bioconductor, an open-source project focused on genomic data.

The book closes with a detailed reference to the standard R packages.

This is an impressive piece of work. In a volume of this size (about 650 pages), navigation is crucial, and I found both the organization of the chapters and index up to the task. I was able to follow the instructions and examples through the first several chapters of the book essentially without a hitch, and in the latter chapters the variety of illustrations and data sources added interest to what could have been very dull going.

I won't claim perfection for this book. There were a couple of explanations that could have been clearer, and one or two odd turns of phrase or rough edits. Out of all the code examples that I tried, I found exactly one that didn't seem to work without a minor correction. For a work of this size, that's actually pretty amazing!

As a long-time O'Reilly reader, I see Joseph Adler's R in a Nutshell as a welcome addition to the menagerie.

You can purchase R in a Nutshell: A Desktop Quick Reference from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

RickJWagner writes "This is a book targeted primarily towards the Java programmer who doesn't yet know Groovy. Groovy is a dynamic scripting language that runs on the JVM and offers easy integration with the Java language. Groovy also offers dynamic language features that lend themselves to the creation of DSLs (Domain-Specific Languages). This book attempts to simultaneously teach the reader how to use Groovy and how to build a DSL." Keep reading for the rest of RickJWagner's review. Groovy for Domain-Specific Languages author Fergal Dearle pages 312 publisher Packt Publishing rating 7/10 reviewer RickJWagner ISBN 184719690X summary a practical tutorial, walking the reader through examples of building DSLs with Groovy covering meta-programming with Groovy DSLs are something of a hot topic these days. A DSL is a 'Little Language' or a language written just for one business domain. As programmers, we're familiar with DSLs whether we realize it or not-- each time you use 'Make' to build a C project, or use 'Ant' to make a Java project, you're using a DSL. A DSL is a purpose-built language, with it's own verbs, rules, syntax, etc. It's made for one purpose only, and is meant to make things as easy as possible for the intended user. If the user has a need outside what the DSL can provide-- they're just tough out of luck! General purpose languages are for doing whatever the user needs-- DSLs are for doing only one task, but making that one task exceedingly easy for the user.

The book does a good job of making Groovy understandable for a Java coder. Programmers of other stripes would be able to use the book, but the author aimed squarely for the Java sweet spot and I think did a good job of hitting it. Where language integration was to be shown, the JDK was the reciprocal part in the examples, and the classes singled out for interfacing were ones that would be well-known to a Java coder.

Writing DSLs has been done for many years, but was largely an undocumented process until just recently. I think the rise of dynamic languages has something to do with that. Dynamic languages offer some key features that make DSL creation a little easier. A few of these features the book covers are closures and meta-programming. Closures are anonymous methods, packaged in such a way that they can be passed as parameters to other methods. Meta-programming is using code to write other code, and can be used to perform some neat tricks like allowing the user to call methods that don't have a previously written definition. (If that sounds really strange to you, I agree. But it turns out this is something very handy if you're writing a DSL!)

The book is written in a way that thoroughly the breadth of features offered by the Groovy language, but not a lot of depth in all of them. For this reason, I found myself sometimes referring to external sources when I was encountering some language construct that seemed a little less familiar than most. It wasn't a problem-- the book did a fine job of letting me know of the existence of some language feature and how it might be used in writing a DSL. If I didn't immediately grasp the use of the feature after the typical single example of seeing it used in sample code, I'd just pop out to the internet and get a few more examples. The book is nearly 300 pages as it is, and very little of that is wasted. I give the book good grades for technical content.

Style-wise, I found the book reasonable to read but not great. As well as the author does spelling out the nuances of the Groovy language, the DSL parts are interspersed among the chapters and sometimes could be hard to find unless you read a lot of surrounding technical content. Maybe this is the only way to cover two meaty topics at once, I don't know. But I found myself doing quite a bit of paging when I wanted to refer back to DSL-specific advice, sometimes falling back to the chapter-by-chapter summary in the front of the book to get myself in the right neighborhood.

The book has plenty of sample code, which I found well constructed and easy to read. The author adapted the practice of writing small snippets of code, then used assertions to demonstrate the behavior the reader would expect if the code were to be executed. I really liked that. The code itself was always cleanly formatted and minimal in length, which made it very easy to read.

So, did the book hit it's target? I believe it did. The strengths of using Groovy for Domain Specific Languages are drawn out, and the Groovy language is given a thorough overview. Java coders will find this book a reference that will let them start using dynamic features while still staying on the JVM. (By the way, Groovy compiles to Java, so all your existing Java code is usable from Groovy. So you might write an application that's 95% Java and 5% Groovy, and that's just fine with Groovy.) I think this book covered a lot of ground and did it well.

You can purchase Groovy for Domain-Specific Languages from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.